New test files from SI 7278.

Author: odersky

tests/neg/t7278.scala

@@ -0,0 +1,42 @@
+class A { class E }
+class B extends A { class E }
+trait C { type E = Int }
+trait D { type E = String }
+trait EC { type E }
+
+object Test {
+  // should not compile (?)
+  // martin says "I'd argue about that"
+  // martin retracts his statement: this should not compile
+  type EE[+X <: EC] = X#E
+  type EE2[+X <: EC] = X#E // repeat to get error count to 2
+
+  def fail1(): Unit = {
+    val b = new B
+    var x1: EE[A] = null
+    var x2: EE[B] = new b.E // error: found: B#E, required: A#E
+//    x1 = x2  // gives a prior type error: B#E, required: A#E, masked to get at the real thing.
+  }
+
+/* Not representable in dotty as there are no existential types
+  def fail2(): Unit = {
+    val b = new B
+    var x1: p.E forSome { val p: A } = new b.E // should not compile
+    var x2: p.E forSome { val p: B } = new b.E
+    x1 = x2 // should not compile
+  }
+*/
+  def fail3(): Unit = {
+    var x1: EE[C] = 5
+    var x2: EE[C & D] = ""
+    x1 = x2
+  }
+
+  def wrap(label: String)(op: => Unit): Unit =
+    try { op } catch { case x: ClassCastException => println("%30s %s".format(label, x)) }
+
+  def main(args: Array[String]): Unit = {
+    wrap("Variance and inner classes")(fail1())
+    wrap("Linearization and type aliases")(fail3())
+  }
+}

tests/run/t7278.scala

@@ -0,0 +1,32 @@
+class Foo {
+    class Bar {
+      def foo = 1
+    }
+  }
+
+  class SubFoo extends Foo {
+    class SubBar {
+      def foo = 42
+    }
+  }
+
+object Test {
+  def main(args: Array[String]): Unit = {
+
+// Let's create some instances:
+  val foo = new Foo
+  val fooBar = new foo.Bar
+  assert(fooBar.foo == 1)                         //> res0: Int = 1
+  // ok
+
+  val subFoo = new SubFoo
+  val subFooBar = new subFoo.SubBar
+  assert(subFooBar.foo == 42)                      //> res1: Int = 42
+  // ok
+
+  val superFoo: Foo = subFoo
+  val superFooBar = new superFoo.Bar
+  assert(superFooBar.foo == 1)                     //> res2: Int = 1
+  // NOT OK!
+  }
+}