Streamlined treatment of ThisType in subtype checks.

Author: odersky

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

@@ -195,7 +195,7 @@ class TypeComparer(initctx: Context) extends DotClass {
       val saved = constraint
       val savedSuccessCount = successCount
       val savedTotalCount = totalCount
-      if (Stats.monitored) Stats.record(s"isSubType ${tp1.getClass} <:< ${tp2.getClass}")
+      if (Stats.monitored) Stats.record(s"isSubType ${tp1.show} <:< ${tp2.show}")
       try {
         recCount += 1
 /* !!! DEBUG
@@ -281,23 +281,14 @@ class TypeComparer(initctx: Context) extends DotClass {
               ) else
                 tp1.name == tp2.name && isSubType(tp1.prefix, tp2.prefix)
             ) || secondTryNamed(tp1, tp2)
+          case ThisType(cls) if cls eq tp2.symbol.moduleClass =>
+            isSubType(cls.owner.thisType, tp2.prefix)
           case _ =>
             secondTry(tp1, tp2)
         }
         compareNamed
       case tp2: ProtoType =>
         isMatchedByProto(tp2, tp1)
-      case tp2 @ ThisType(cls) =>
-        def compareThis: Boolean = {
-          if (cls is ModuleClass)
-            tp1 match {
-              case tp1: TermRef =>
-                if (tp1.symbol.moduleClass == cls) return tp1.prefix <:< cls.owner.thisType
-              case _ =>
-            }
-          secondTry(tp1, tp2)
-        }
-        compareThis
       case tp2: PolyParam =>
         def comparePolyParam = {
           tp2 == tp1 ||
@@ -330,20 +321,14 @@ class TypeComparer(initctx: Context) extends DotClass {
 
   def secondTry(tp1: Type, tp2: Type): Boolean = tp1 match {
     case tp1: NamedType =>
-      secondTryNamed(tp1, tp2)
+      tp2 match {
+        case ThisType(cls) if cls eq tp1.symbol.moduleClass =>
+          isSubType(tp1.prefix, cls.owner.thisType)
+        case _ =>
+          secondTryNamed(tp1, tp2)
+      }
     case OrType(tp11, tp12) =>
       isSubType(tp11, tp2) && isSubType(tp12, tp2)
-    case tp1 @ ThisType(cls) =>
-      def compareThis: Boolean = {
-        if (cls is ModuleClass)
-          tp2 match {
-            case tp2: TermRef =>
-              if (tp2.symbol.moduleClass == cls) return cls.owner.thisType <:< tp2.prefix
-            case _ =>
-          }
-        thirdTry(tp1, tp2)
-      }
-      compareThis
     case tp1: PolyParam =>
       def comparePolyParam = {
         tp1 == tp2 ||
@@ -622,7 +607,7 @@ class TypeComparer(initctx: Context) extends DotClass {
     (hkArgs.length == tparams.length) && {
       val base = tp1.narrow
       (tparams, hkArgs).zipped.forall { (tparam, hkArg) =>
-        base.memberInfo(tparam) <:< hkArg.bounds // TODO: base.memberInfo needed?
+        isSubType(base.memberInfo(tparam), hkArg.bounds) // TODO: base.memberInfo needed?
       } &&
         (tparams, tp2.typeSymbol.typeParams).zipped.forall { (tparam, tparam2) =>
           tparam.variance == tparam2.variance
@@ -631,7 +616,7 @@ class TypeComparer(initctx: Context) extends DotClass {
   }
 
   def trySetType(tr: NamedType, bounds: TypeBounds): Boolean =
-    (bounds.lo <:< bounds.hi) &&
+    isSubType(bounds.lo, bounds.hi) &&
     { tr.symbol.changeGADTInfo(bounds); true }
 
   /** A function implementing `tp1` matches `tp2`. */
@@ -1050,7 +1035,7 @@ class TypeComparer(initctx: Context) extends DotClass {
     case tp1: ClassInfo =>
       tp2 match {
         case tp2: ClassInfo =>
-          (tp1.prefix <:< tp2.prefix) || (tp1.cls.owner derivesFrom tp2.cls.owner)
+          isSubType(tp1.prefix, tp2.prefix) || (tp1.cls.owner derivesFrom tp2.cls.owner)
         case _ =>
           false
       }
@@ -1066,7 +1051,7 @@ class TypeComparer(initctx: Context) extends DotClass {
       tp2 match {
         case tp2: MethodType =>
           def asGoodParams(formals1: List[Type], formals2: List[Type]) =
-            (formals2 corresponds formals1)(_ <:< _)
+            (formals2 corresponds formals1)(isSubType)
           asGoodParams(tp1.paramTypes, tp2.paramTypes) &&
           (!asGoodParams(tp2.paramTypes, tp1.paramTypes) ||
            isAsGood(tp1.resultType, tp2.resultType))