Fix OverridingPairs

OverridingPairs had several bugs which caused pairs to be lost, which caused
missing overrides checks. Fixing OverridingPairs revealed several test failures
(and a problem in Synthetics generation which was fixed in the last commit).
Tests that became negative are all moved into neg/overrides.scala, and the
original versions in pos were fixed.

6 files changed, 81 insertions, 4 deletions

diff --git a/tests/neg/over.scala b/tests/neg/over.scala
new file mode 100644
index 000000000..488d71614
--- /dev/null
+++ b/tests/neg/over.scala
@@ -0,0 +1,10 @@
+trait T {
+  def x = 1
+}
+
+class C extends T {
+
+  val x = 2
+  override val y = 2
+
+}
diff --git a/tests/neg/overrides.scala b/tests/neg/overrides.scala
new file mode 100644
index 000000000..4befe1623
--- /dev/null
+++ b/tests/neg/overrides.scala
@@ -0,0 +1,59 @@
+  abstract class FooA {
+    type A <: Ax;
+    abstract class Ax;
+    abstract class InnerA {
+      type B <: A;
+      def doB : B;
+    }
+  }
+  trait FooB extends FooA {
+    type A <: Ax;
+    trait Ax extends super.Ax { def xxx : Int; }
+    abstract class InnerB extends InnerA {
+      // type B <: A;
+      val a : A = doB;
+      a.xxx;
+      doB.xxx;
+    }
+  }
+
+package p1 {
+  abstract class T1 {
+    protected def bug(p: Int = 1): Int // without 'protected' compiles fine
+  }
+}
+package p2 { // all being in the same package compiles fine
+  import p1._
+  abstract class T2 extends T1 {
+    class A {
+      bug()
+    }
+  }
+
+  abstract class T3 extends T2 {
+    class A {
+      bug()
+    }
+  }
+}
+
+class A[T] {
+
+  def f(x: T)(y: T = x) = y
+
+}
+
+class B extends A[Int] {
+
+  def f(x: Int)(y: Int) = y
+
+  f(2)()
+
+}
+
+class X {
+  def f: A[Int] = ???
+}
+class Y extends X {
+  def f: A[Int] = ???
+}
diff --git a/tests/pos/overrides.scala b/tests/pos/overrides.scala
index 3d254ea70..97402f773 100644
--- a/tests/pos/overrides.scala
+++ b/tests/pos/overrides.scala
@@ -6,7 +6,7 @@ class A[T] {
 
 class B extends A[Int] {
 
-  def f(x: Int)(y: Int) = y
+  override def f(x: Int)(y: Int) = y
 
   f(2)()
 
diff --git a/tests/pos/synthetics.scala b/tests/pos/synthetics.scala
index c7d49df70..c870cb1a4 100644
--- a/tests/pos/synthetics.scala
+++ b/tests/pos/synthetics.scala
@@ -2,3 +2,11 @@ case class C(x: Int, var y: String) {
 
 }
 
+
+class Top {
+
+  final override def hashCode: Int = 2
+
+}
+
+case class Sub() extends Top
diff --git a/tests/pos/t0599.scala b/tests/pos/t0599.scala
index 885159af6..6445fa9fb 100644
--- a/tests/pos/t0599.scala
+++ b/tests/pos/t0599.scala
@@ -7,8 +7,8 @@ abstract class FooA {
     }
   }
   trait FooB extends FooA {
-    type A <: Ax;
-    trait Ax extends super.Ax { def xxx : Int; }
+    type A <: Axx;
+    trait Axx extends super.Ax { def xxx : Int; }
     abstract class InnerB extends InnerA {
       // type B <: A;
       val a : A = doB;
diff --git a/tests/pos/t2809.scala b/tests/pos/t2809.scala
index 1f68b0b07..1e9ec60d2 100644
--- a/tests/pos/t2809.scala
+++ b/tests/pos/t2809.scala
@@ -12,7 +12,7 @@ package p2 { // all being in the same package compiles fine
   }
 
   abstract class T3 extends T2 {
-    class A {
+    class A2 {
       bug()
     }
   }