Add some flexibility in comparing named and unnamed parameterized types.

Author: odersky

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -371,7 +371,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             case _ =>
               compareRefinedSlow ||
               fourthTry(tp1, tp2) ||
-              compareHkLambda(tp2, tp1, inOrder = false)
+              compareHkLambda(tp2, tp1, inOrder = false) ||
+              compareAliasedRefined(tp2, tp1, inOrder = false)
           }
         else // fast path, in particular for refinements resulting from parameterization.
           isSubType(tp1, skipped2) &&
@@ -491,7 +492,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       }
       isNewSubType(tp1.underlying.widenExpr, tp2) || comparePaths
     case tp1: RefinedType =>
-      isNewSubType(tp1.parent, tp2) || compareHkLambda(tp1, tp2, inOrder = true)
+      isNewSubType(tp1.parent, tp2) ||
+      compareHkLambda(tp1, tp2, inOrder = true) ||
+      compareAliasedRefined(tp1, tp2, inOrder = true)
     case AndType(tp11, tp12) =>
       // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 | T12) <: T2
       // and analogously for T11 & (T121 | T122) & T12 <: T2
@@ -614,6 +617,35 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       false
   }
 
+  /** Say we are comparing a refined type `P{type M = U}` or `P{type M >: L <: U}`.
+   *  If P#M refers to a BaseTypeArg aliased to some other typeref P#N,
+   *  do the same comparison with `P{type N = U}` or `P{type N >: L <: U}`, respectively.
+   *  This allows to handle situations involving named type params like this one:
+   *
+   *      trait Lambda[type Elem]
+   *      trait Lst[T] extends Lambda[T]
+   *
+   *  compareAliasedRefined is necessary so we establish that
+   *
+   *      Lst[Int] = Lst[Elem = Int]
+   */
+  private def compareAliasedRefined(rt: RefinedType, other: Type, inOrder: Boolean) = {
+    val mbr = refinedSymbol(rt)
+    mbr.is(BaseTypeArg) && {
+      mbr.info match {
+        case TypeAlias(TypeRef(_, aliasName)) =>
+          val rt1 = rt.derivedRefinedType(rt.parent, aliasName, rt.refinedInfo)
+          subtyping.println(i"rewiring $rt to $rt1 in comparison with $other")
+          if (inOrder) isSubType(rt1, other) else isSubType(other, rt1)
+        case _ =>
+          false
+      }
+    }
+  }
+
+  /** The symbol referred to in the refinement of `rt` */
+  private def refinedSymbol(rt: RefinedType) = rt.parent.member(rt.refinedName).symbol
+
   /** Returns true iff either `tp11 <:< tp21` or `tp12 <:< tp22`, trying at the same time
    *  to keep the constraint as wide as possible. Specifically, if
    *
@@ -742,11 +774,14 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   /** A type has been covered previously in subtype checking if it
    *  is some combination of TypeRefs that point to classes, where the
    *  combiners are RefinedTypes, AndTypes or AnnotatedTypes.
+   *  One exception: Refinements referring to basetype args are never considered
+   *  to be already covered. This is necessary because such refined types might
+   *  still need to be compared with a compareAliasRefined.
    */
   private def isCovered(tp: Type): Boolean = tp.dealias.stripTypeVar match {
     case tp: TypeRef => tp.symbol.isClass && tp.symbol != NothingClass && tp.symbol != NullClass
     case tp: ProtoType => false
-    case tp: RefinedType => isCovered(tp.parent)
+    case tp: RefinedType => isCovered(tp.parent) && !refinedSymbol(tp).is(BaseTypeArg)
     case tp: AnnotatedType => isCovered(tp.underlying)
     case AndType(tp1, tp2) => isCovered(tp1) && isCovered(tp2)
     case _ => false

tests/pos/hk-named.scala

@@ -0,0 +1,58 @@
+import language.higherKinds
+
+object hk0 {
+
+  trait Lambda[type Elem]
+
+  abstract class Functor[F <: Lambda] {
+    def map[A, B](f: A => B): F[Elem = A] => F[Elem = B]
+  }
+
+  object test1 {
+    class ListT[T] extends Lambda[T]
+
+    val ml: Functor[ListT] = ???
+    val mx = ml
+    var xs: ListT[Int] = ???
+    var ys: ListT { type Elem = Int } = xs
+    xs = ys
+    val mm: (Int => Boolean) => ListT[Int] => ListT[Boolean] = mx.map[Int, Boolean]
+    val mm2: (Int => Boolean) => ListT[Int] => ListT[Boolean] = mx.map
+  }
+}
+
+
+object higherKinded {
+
+  type Untyped = Null
+
+  class Tree[type -Attr >: Untyped] {
+    type ThisType <: Tree
+    def withString(s: String): ThisType[Attr = String] = withString(s)
+  }
+/*
+  class Ident[-Attr >: Untyped] extends Tree[Attr] {
+    type ThisType = Ident
+  }
+
+  val id = new Ident[Integer]
+
+  val y = id.withString("abc")
+
+  val z: Ident[String] = y
+
+  val zz: tpd.Tree = y
+
+  abstract class Instance[T >: Untyped] {g
+    type Tree = higherKinded.Tree[T]
+  }
+
+  object tpd extends Instance[String]
+
+  def transform(tree: Tree[String]) = {
+    val tree1 = tree.withString("")
+    tree1: Tree[String]
+  }
+*/
+}
+