Cleanup SubstParamsMap

Author: odersky

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -77,7 +77,7 @@ object CheckCaptures:
   final class SubstParamsMap(from: BindingType, to: List[Type])(using Context)
   extends ApproximatingTypeMap, IdempotentCaptRefMap:
     /** This SubstParamsMap is exact if `to` only contains `CaptureRef`s. */
-    private val isExactSubstitution: Boolean = to.forall(_.isInstanceOf[CaptureRef])
+    private val isExactSubstitution: Boolean = to.forall(_.isTrackableRef)
 
     /** As long as this substitution is exact, there is no need to create `Range`s when mapping invariant positions. */
     override protected def needsRangeIfInvariant(refs: CaptureSet): Boolean = !isExactSubstitution
@@ -136,7 +136,7 @@ object CheckCaptures:
     for elem <- retainedElems(ann) do
       elem.tpe match
         case ref: CaptureRef =>
-          if !ref.canBeTracked then
+          if !ref.isTrackableRef then
             report.error(em"$elem cannot be tracked since it is not a parameter or local value", elem.srcPos)
         case tpe =>
           report.error(em"$elem: $tpe is not a legal element of a capture set", elem.srcPos)
@@ -470,10 +470,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       case x :: xs1 => xs1.isEmpty || !xs1.contains(x) && isDistinct(xs1)
       case Nil => true
 
-    private def isTrackable(tp: Type)(using Context) = tp match
-      case tp: CaptureRef => tp.canBeTracked
-      case _ => false
-
     /** Handle an application of method `sym` with type `mt` to arguments of types `argTypes`.
      *  This means:
      *   - Instantiate result type with actual arguments
@@ -490,7 +486,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val ownType =
         if !mt.isResultDependent then
           mt.resType
-        else if argTypes.forall(isTrackable) && isDistinct(argTypes) then
+        else if argTypes.forall(_.isTrackableRef) && isDistinct(argTypes) then
           SubstParamsBiMap(mt, argTypes)(mt.resType)
         else
           SubstParamsMap(mt, argTypes)(mt.resType)

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

@@ -478,6 +478,11 @@ object Types {
      */
     def isDeclaredVarianceLambda: Boolean = false
 
+    /** Is this type a CaptureRef that can be tracked?
+     *  This is true for all ThisTypes or ParamRefs but only for some NamedTypes.
+     */
+    def isTrackableRef(using Context): Boolean = false
+
     /** Does this type contain wildcard types? */
     final def containsWildcardTypes(using Context) =
       existsPart(_.isInstanceOf[WildcardType], StopAt.Static, forceLazy = false)
@@ -2149,15 +2154,10 @@ object Types {
     private var myCaptureSetRunId: Int = NoRunId
     private var mySingletonCaptureSet: CaptureSet.Const | Null = null
 
-    /** Can the reference be tracked? This is true for all ThisTypes or ParamRefs
-     *  but only for some NamedTypes.
-     */
-    def canBeTracked(using Context): Boolean
-
     /** Is the reference tracked? This is true if it can be tracked and the capture
      *  set of the underlying type is not always empty.
      */
-    final def isTracked(using Context): Boolean = canBeTracked && !captureSetOfInfo.isAlwaysEmpty
+    final def isTracked(using Context): Boolean = isTrackableRef && !captureSetOfInfo.isAlwaysEmpty
 
     /** Is this reference the root capability `cap` ? */
     def isRootCapability(using Context): Boolean = false
@@ -2190,7 +2190,7 @@ object Types {
 
     override def captureSet(using Context): CaptureSet =
       val cs = captureSetOfInfo
-      if canBeTracked && !cs.isAlwaysEmpty then singletonCaptureSet else cs
+      if isTrackableRef && !cs.isAlwaysEmpty then singletonCaptureSet else cs
   end CaptureRef
 
   /** A trait for types that bind other types that refer to them.
@@ -2887,7 +2887,7 @@ object Types {
      *  They are subsumed in the capture sets of the enclosing class.
      *  TODO: ^^^ What about call-by-name?
      */
-    def canBeTracked(using Context) =
+    override def isTrackableRef(using Context) =
       ((prefix eq NoPrefix)
       || symbol.is(ParamAccessor) && (prefix eq symbol.owner.thisType)
       || isRootCapability
@@ -2897,7 +2897,7 @@ object Types {
       name == nme.CAPTURE_ROOT && symbol == defn.captureRoot
 
     override def normalizedRef(using Context): CaptureRef =
-      if canBeTracked then symbol.termRef else this
+      if isTrackableRef then symbol.termRef else this
   }
 
   abstract case class TypeRef(override val prefix: Type,
@@ -3050,7 +3050,7 @@ object Types {
           // can happen in IDE if `cls` is stale
       }
 
-    def canBeTracked(using Context) = true
+    override def isTrackableRef(using Context) = true
 
     override def computeHash(bs: Binders): Int = doHash(bs, tref)
 
@@ -4661,9 +4661,9 @@ object Types {
    */
   abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef, CaptureRef {
     type BT = TermLambda
-    def canBeTracked(using Context) = true
     def kindString: String = "Term"
     def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
+    override def isTrackableRef(using Context) = true
   }
 
   private final class TermParamRefImpl(binder: TermLambda, paramNum: Int) extends TermParamRef(binder, paramNum)
@@ -5728,11 +5728,11 @@ object Types {
 
     /** A restriction of this map to a function on tracked CaptureRefs */
     def forward(ref: CaptureRef): CaptureRef = this(ref) match
-      case result: CaptureRef if result.canBeTracked => result
+      case result: CaptureRef if result.isTrackableRef => result
 
     /** A restriction of the inverse to a function on tracked CaptureRefs */
     def backward(ref: CaptureRef): CaptureRef = inverse(ref) match
-      case result: CaptureRef if result.canBeTracked => result
+      case result: CaptureRef if result.isTrackableRef => result
   end BiTypeMap
 
   abstract class TypeMap(implicit protected var mapCtx: Context)