Handle differences in package vs package object in TypeComparer

With the changes in Typer, it is now possible that a type `T` that is a
member of some package object `pobj` in a package `p` is seen once as
`p.pobj.T` and then also as `p.T`. Type comparer has to make sure that
these two types are seen as equivalent.

Author: odersky

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

@@ -225,13 +225,14 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
         def compareNamed(tp1: Type, tp2: NamedType): Boolean = {
           implicit val ctx: Context = this.ctx
           tp2.info match {
-            case info2: TypeAlias => recur(tp1, info2.alias)
+            case info2: TypeAlias =>
+              recur(tp1, info2.alias) || tryPackagePrefix2(tp1, tp2)
             case _ => tp1 match {
               case tp1: NamedType =>
                 tp1.info match {
                   case info1: TypeAlias =>
                     if (recur(info1.alias, tp2)) return true
-                    if (tp1.prefix.isStable) return false
+                    if (tp1.prefix.isStable) return tryPackagePrefix1(tp1, tp2)
                       // If tp1.prefix is stable, the alias does contain all information about the original ref, so
                       // there's no need to try something else. (This is important for performance).
                       // To see why we cannot in general stop here, consider:
@@ -253,7 +254,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
                 if ((sym1 ne NoSymbol) && (sym1 eq sym2))
                   ctx.erasedTypes ||
                   sym1.isStaticOwner ||
-                  isSubType(tp1.prefix, tp2.prefix) ||
+                  isSubType(stripPackageObject(tp1.prefix), stripPackageObject(tp2.prefix)) ||
                   thirdTryNamed(tp2)
                 else
                   (  (tp1.name eq tp2.name)
@@ -352,7 +353,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
         tp1.info match {
           case info1: TypeAlias =>
             if (recur(info1.alias, tp2)) return true
-            if (tp1.prefix.isStable) return false
+            if (tp1.prefix.isStable) return tryPackagePrefix1(tp1, tp2)
           case _ =>
             if (tp1 eq NothingType) return true
         }
@@ -1057,6 +1058,33 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
     }
   }
 
+  /** If `tp` is a reference to a package object, a reference to the package itself,
+   *  otherwise `tp`.
+   */
+  private def stripPackageObject(tp: Type) = tp match {
+    case tp: TermRef if tp.symbol.isPackageObject => tp.symbol.owner.thisType
+    case tp: ThisType if tp.cls.isPackageObject => tp.cls.owner.thisType
+    case _ => tp
+  }
+
+  /** If prefix of `tp1` is a reference to a package object, retry with
+   *  the prefix pointing to the package itself, otherwise `false`
+   */
+  private def tryPackagePrefix1(tp1: NamedType, tp2: Type) = {
+    val pre1 = tp1.prefix
+    val pre1a = stripPackageObject(pre1)
+    (pre1a ne pre1) && isSubType(tp1.withPrefix(pre1a), tp2)
+  }
+
+  /** If prefix of `tp2` is a reference to a package object, retry with
+   *  the prefix pointing to the package itself, otherwise `false`
+   */
+  private def tryPackagePrefix2(tp1: Type, tp2: NamedType) = {
+    val pre2 = tp2.prefix
+    val pre2a = stripPackageObject(pre2)
+    (pre2a ne pre2) && isSubType(tp1, tp2.withPrefix(pre2a))
+  }
+
   /** Optionally, the `n` such that `tp <:< ConstantType(Constant(n: Int))` */
   def natValue(tp: Type): Option[Int] = constValue(tp) match {
     case Some(Constant(n: Int)) if n >= 0 => Some(n)