Merge pull request scala#3981 from retronym/ticket/8575-2

SI-8575 Fix subtyping transitivity with aliases, compound types

Author: lrytz

src/reflect/scala/reflect/internal/Types.scala

@@ -1600,7 +1600,14 @@ trait Types
     private var normalized: Type = _
     private def normalizeImpl = {
       // TODO see comments around def intersectionType and def merge
-      def flatten(tps: List[Type]): List[Type] = tps flatMap { case RefinedType(parents, ds) if ds.isEmpty => flatten(parents) case tp => List(tp) }
+      // SI-8575 The dealias is needed here to keep subtyping transitive, example in run/t8575b.scala
+      def flatten(tps: List[Type]): List[Type] = {
+        def dealiasRefinement(tp: Type) = if (tp.dealias.isInstanceOf[RefinedType]) tp.dealias else tp
+        tps map dealiasRefinement flatMap {
+          case RefinedType(parents, ds) if ds.isEmpty => flatten(parents)
+          case tp => List(tp)
+        }
+      }
       val flattened = flatten(parents).distinct
       if (decls.isEmpty && hasLength(flattened, 1)) {
         flattened.head

test/files/run/t8575.scala

@@ -0,0 +1,33 @@
+class E[F]
+class A
+class B
+class C
+
+trait TypeMember {
+  type X
+
+  // This call throws an AbstractMethodError, because it invokes the erasure of
+  // consume(X): Unit that is consume(Object): Unit. But the corresponding
+  // bridge method is not generated.
+  consume(value)
+
+  def value: X
+  def consume(x: X): Unit
+}
+
+object Test extends TypeMember {
+  type F = A with B
+
+  // works if replaced by type X = E[A with B with C]
+  type X = E[F with C]
+
+  val value = new E[F with C]
+
+  // This call passes, since it invokes consume(E): Unit
+  consume(value)
+  def consume(x: X) {}
+
+  def main(args: Array[String]) {
+    
+  }
+}

test/files/run/t8575b.scala

@@ -0,0 +1,17 @@
+class A
+class B
+class C
+
+object Test {
+  type F = A with B
+
+  def main(args: Array[String]) {
+    import reflect.runtime.universe._
+    val t1 = typeOf[F with C]
+    val t2 = typeOf[(A with B) with C]
+    val t3 = typeOf[A with B with C]
+    assert(t1 =:= t2)
+    assert(t2 =:= t3)
+    assert(t3 =:= t1)
+  }
+}

test/files/run/t8575c.scala

@@ -0,0 +1,23 @@
+class C
+
+trait TypeMember {
+  type X
+  type Y
+  type Z
+}
+
+object Test extends TypeMember {
+  type A = X with Y
+  type B = Z with A
+  type F = A with B
+
+  def main(args: Array[String]) {
+    import reflect.runtime.universe._
+    val t1 = typeOf[F with C]
+    val t2 = typeOf[(A with B) with C]
+    val t3 = typeOf[A with B with C]
+    assert(t1 =:= t2)
+    assert(t2 =:= t3)
+    assert(t3 =:= t1)
+  }
+}