Simplify TypeComparer

Author: odersky

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

@@ -68,11 +68,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   private var myInstance: TypeComparer = this
   def currentInstance: TypeComparer = myInstance
 
-  /** All capturing types in the original `tp1` enclosing the currently
-   *  compared type.
-   */
-  private var enclosingCapturing1: List[AnnotatedType] = Nil
-
   /** Is a subtype check in progress? In that case we may not
    *  permanently instantiate type variables, because the corresponding
    *  constraint might still be retracted and the instantiation should
@@ -553,11 +548,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
               if tp1.isBoxedCapturing && !parent1.isBoxedCapturing
               then tp2.unboxed
               else tp2
-            try
-              enclosingCapturing1 = tp1 :: enclosingCapturing1
-              recur(parent1, tp2a)
-            finally
-              enclosingCapturing1 = enclosingCapturing1.tail
+            recur(parent1, tp2a)
           else thirdTry
         compareCapturing
       case tp1: AnnotatedType if !tp1.isRefining =>
@@ -685,7 +676,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
             if defn.isFunctionType(tp2) then
               if tp2.derivesFrom(defn.PolyFunctionClass) then
-                return isSubInfo(tp1.ccMember(nme.apply).info, tp2.refinedInfo)
+                return isSubInfo(tp1.member(nme.apply).info, tp2.refinedInfo)
               else
                 tp1w.widenDealias match
                   case tp1: RefinedType =>
@@ -2038,7 +2029,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    *  rebase both itself and the member info of `tp` on a freshly created skolem type.
    */
   def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
-    trace(i"hasMatchingMember($tp1 . $name :? ${tp2.refinedInfo}), mbr: ${tp1.ccMember(name).info}", subtyping) {
+    trace(i"hasMatchingMember($tp1 . $name :? ${tp2.refinedInfo}), mbr: ${tp1.member(name).info}", subtyping) {
 
       // If the member is an abstract type and the prefix is a path, compare the member itself
       // instead of its bounds. This case is needed situations like:
@@ -2119,30 +2110,9 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         || (tp1.isStable && m.symbol.isStableMember && isSubType(TermRef(tp1, m.symbol), tp2.refinedInfo))
       end qualifies
 
-      tp1.ccMember(name).hasAltWithInline(qualifies)
+      tp1.member(name).hasAltWithInline(qualifies)
     }
 
-  extension (qual: Type)
-	/** Add all directly enclosing capture sets to `qual` and select `name` on the
-	 *  resulting type. A capture set is directly enclosing if there is an enclosing
-	 *  capturing type with the set and all types between `qual` and that type
-	 *  are RefinedTypes or CapturingTypes.
-	 */
-    def ccMember(name: Name): Denotation =
-      def isEnclosing(tp: Type): Boolean = tp match
-        case RefinedType(parent, _, _) => isEnclosing(parent)
-        case CapturingType(parent, _) => isEnclosing(parent)
-        case _ => tp eq qual
-
-      def addCaptures(tp: Type, encls: List[AnnotatedType]): Type = encls match
-        case (ct @ CapturingType(parent, refs)) :: encls1 if isEnclosing(parent) =>
-          addCaptures(CapturingType(tp, refs, ct.isBoxedCapturing), encls1)
-        case _ =>
-          tp
-
-      addCaptures(qual, enclosingCapturing1).member(name)
-    end ccMember
-
   final def ensureStableSingleton(tp: Type): SingletonType = tp.stripTypeVar match {
     case tp: SingletonType if tp.isStable => tp
     case tp: ValueType => SkolemType(tp)
@@ -3418,7 +3388,7 @@ class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     }
 
   override def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
-    traceIndented(s"hasMatchingMember(${show(tp1)} . $name, ${show(tp2.refinedInfo)}), member = ${show(tp1.ccMember(name).info)}") {
+    traceIndented(s"hasMatchingMember(${show(tp1)} . $name, ${show(tp2.refinedInfo)}), member = ${show(tp1.member(name).info)}") {
       super.hasMatchingMember(name, tp1, tp2)
     }
 

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

@@ -19,7 +19,7 @@ import typer.ForceDegree
 import typer.Inferencing._
 import typer.IfBottom
 import reporting.TestingReporter
-import cc.{CapturingType, derivedCapturingType, CaptureSet, isBoxed, isBoxedCapturing, isLevelOwner, localRoot}
+import cc.{CapturingType, derivedCapturingType, CaptureSet, isBoxed, isBoxedCapturing}
 import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
 
 import scala.annotation.internal.sharable
@@ -99,8 +99,8 @@ object TypeOps:
         tp match {
           case tp: NamedType =>
             val sym = tp.symbol
-            if sym.isStatic && !sym.maybeOwner.seesOpaques then tp
-            else if tp.prefix `eq` NoPrefix then tp
+            if sym.isStatic && !sym.maybeOwner.seesOpaques || (tp.prefix `eq` NoPrefix)
+            then tp
             else derivedSelect(tp, atVariance(variance max 0)(this(tp.prefix)))
           case tp: LambdaType =>
             mapOverLambda(tp) // special cased common case

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

@@ -2931,6 +2931,7 @@ object Types {
       name == nme.CAPTURE_ROOT && symbol == defn.captureRoot
 
     def localRootOwner(using Context): Symbol =
+      // TODO Try to make local class roots be NonMembers owned directly by the class
       val owner = symbol.maybeOwner
       def normOwner = if owner.isLocalDummy then owner.owner else owner
       if name == nme.LOCAL_CAPTURE_ROOT then normOwner

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -20,7 +20,6 @@ import config.SourceVersion.{`3.0`, `future`}
 import config.Printers.refcheck
 import reporting._
 import Constants.Constant
-import cc.{localRoot, isCaptureChecking, isLevelOwner}
 
 object RefChecks {
   import tpd._