Keep track of provenance of capturing types

Author: odersky

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

@@ -25,6 +25,30 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
   import CaptureAnnotation.*
   import tpd.*
 
+  private var myOrigins: Set[AnnotatedType] | Null = null
+
+  def origins: Set[AnnotatedType] =
+    if myOrigins == null then myOrigins = Set()
+    myOrigins.nn
+
+  def withOrigins(origins: Set[AnnotatedType]): CaptureAnnotation =
+    if myOrigins == null then
+      myOrigins = origins
+      this
+    else if origins.subsetOf(myOrigins.nn) then
+      this
+    else
+      CaptureAnnotation(refs, boxed)(cls).withOrigins(myOrigins.nn ++ origins)
+
+  private var myProvenance: Set[AnnotatedType] | Null = null
+
+  def provenance: Set[AnnotatedType] =
+    if myProvenance == null then
+      myProvenance = origins ++ origins.flatMap:
+        case AnnotatedType(_, ann: CaptureAnnotation) => ann.provenance
+        case _ => Set()
+    myProvenance.nn
+
   /** A cache for the version of this annotation which differs in its boxed status. */
   var boxDual: CaptureAnnotation | Null = null
 

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

@@ -179,14 +179,23 @@ extension (tp: Type)
         && !cs.keepAlways
     then tp
     else tp match
-      case CapturingType(parent, cs1) => parent.capturing(cs1 ++ cs)
+      case tp @ CapturingType(parent, cs1) => parent.capturing(cs1 ++ cs).withOrigin(tp)
       case _ => CapturingType(tp, cs)
 
+  def withOrigins(origins: Set[AnnotatedType])(using Context) = tp match
+    case tp @ AnnotatedType(p, ann: CaptureAnnotation) =>
+      tp.derivedAnnotatedType(p, ann.withOrigins(origins))
+    case _ =>
+      tp
+
+  def withOrigin(origin: AnnotatedType)(using Context) =
+    withOrigins(Set(origin))
+
   /** @pre `tp` is a CapturingType */
   def derivedCapturingType(parent: Type, refs: CaptureSet)(using Context): Type = tp match
     case tp @ CapturingType(p, r) =>
       if (parent eq p) && (refs eq r) then tp
-      else CapturingType(parent, refs, tp.isBoxed)
+      else CapturingType(parent, refs, tp.isBoxed).withOrigin(tp)
 
   /** If this is a unboxed capturing type with nonempty capture set, its boxed version.
    *  Or, if type is a TypeBounds of capturing types, the version where the bounds are boxed.
@@ -196,7 +205,7 @@ extension (tp: Type)
     case tp @ CapturingType(parent, refs) if !tp.isBoxed && !refs.isAlwaysEmpty =>
       tp.annot match
         case ann: CaptureAnnotation if !parent.derivesFrom(defn.Caps_CapSet) =>
-          AnnotatedType(parent, ann.boxedAnnot)
+          AnnotatedType(parent, ann.boxedAnnot).withOrigin(tp)
         case ann => tp
     case tp: RealTypeBounds =>
       tp.derivedTypeBounds(tp.lo.boxed, tp.hi.boxed)
@@ -209,7 +218,7 @@ extension (tp: Type)
    */
   def unboxed(using Context): Type = tp.dealias match
     case tp @ CapturingType(parent, refs) if tp.isBoxed && !refs.isAlwaysEmpty =>
-      CapturingType(parent, refs)
+      CapturingType(parent, refs).withOrigin(tp)
     case tp: RealTypeBounds =>
       tp.derivedTypeBounds(tp.lo.unboxed, tp.hi.unboxed)
     case _ =>
@@ -303,7 +312,7 @@ extension (tp: Type)
         case ref: Capability if ref.isTracked || ref.isInstanceOf[DerivedCapability] =>
           ref.singletonCaptureSet
         case _ => refs
-      CapturingType(parent, refs1, boxed)
+      CapturingType(parent, refs1, boxed).withOrigin(tp)
     case _ =>
       tp
 

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

@@ -37,7 +37,7 @@ object CapturingType:
     if refs.isAlwaysEmpty && !refs.keepAlways then parent
     else parent match
       case parent @ CapturingType(parent1, refs1) if boxed || !parent.isBoxed =>
-        apply(parent1, refs ++ refs1, boxed)
+        apply(parent1, refs ++ refs1, boxed).withOrigin(parent)
       case _ =>
         if parent.derivesFromMutable then refs.setMutable()
         refs.adoptClassifier(parent.classifier)

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

@@ -204,25 +204,27 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     /** Pull out an embedded capture set from a part of `tp` */
     def normalizeCaptures(tp: Type)(using Context): Type = tp match
       case tp @ RefinedType(parent @ CapturingType(parent1, refs), rname, rinfo) =>
-        CapturingType(tp.derivedRefinedType(parent1, rname, rinfo), refs, parent.isBoxed)
+        CapturingType(tp.derivedRefinedType(parent1, rname, rinfo), refs, parent.isBoxed).withOrigin(parent)
       case tp: RecType =>
         tp.parent match
           case parent @ CapturingType(parent1, refs) =>
-            CapturingType(tp.derivedRecType(parent1), refs, parent.isBoxed)
+            CapturingType(tp.derivedRecType(parent1), refs, parent.isBoxed).withOrigin(parent)
           case _ =>
             tp // can return `tp` here since unlike RefinedTypes, RecTypes are never created
                 // by `mapInferred`. Hence if the underlying type admits capture variables
                 // a variable was already added, and the first case above would apply.
       case AndType(tp1 @ CapturingType(parent1, refs1), tp2 @ CapturingType(parent2, refs2)) =>
         assert(tp1.isBoxed == tp2.isBoxed)
         CapturingType(AndType(parent1, parent2), refs1 ** refs2, tp1.isBoxed)
+          .withOrigins(Set(tp1, tp2))
       case tp @ OrType(tp1 @ CapturingType(parent1, refs1), tp2 @ CapturingType(parent2, refs2)) =>
         assert(tp1.isBoxed == tp2.isBoxed)
         CapturingType(OrType(parent1, parent2, tp.isSoft), refs1 ++ refs2, tp1.isBoxed)
+          .withOrigins(Set(tp1, tp2))
       case tp @ OrType(tp1 @ CapturingType(parent1, refs1), tp2) =>
-        CapturingType(OrType(parent1, tp2, tp.isSoft), refs1, tp1.isBoxed)
+        CapturingType(OrType(parent1, tp2, tp.isSoft), refs1, tp1.isBoxed).withOrigin(tp1)
       case tp @ OrType(tp1, tp2 @ CapturingType(parent2, refs2)) =>
-        CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed)
+        CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed).withOrigin(tp2)
       case tp @ AppliedType(tycon, args)
       if !defn.isFunctionClass(tp.dealias.typeSymbol) && (tp.dealias eq tp) =>
         tp.derivedAppliedType(tycon, args.mapConserve(_.boxDeeply))
@@ -266,7 +268,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           tp.typeSymbol match
             case cls: ClassSymbol
             if !defn.isFunctionClass(cls) && cls.is(CaptureChecked) =>
-              RecType: _ =>
                 cls.paramGetters.foldLeft(tp): (core, getter) =>
                   if atPhase(thisPhase.next)(getter.hasTrackedParts)
                       && getter.isRefiningParamAccessor

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

@@ -54,7 +54,7 @@ object ccConfig:
 
   /** Not used currently. Handy for trying out new features */
   def newScheme(using ctx: Context): Boolean =
-    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
+    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.9`)
 
   def allowUse(using Context): Boolean =
     Feature.sourceVersion.stable.isAtMost(SourceVersion.`3.7`)

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

@@ -367,14 +367,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case tp2: LazyRef =>
         isBottom(tp1)
         || !tp2.evaluating && recur(tp1, tp2.ref)
-      case tp2: RecType =>
-        def compareRec = tp1.safeDealias match
-          case tp1: RecType =>
-            val rthis1 = tp1.recThis
-            recur(tp1.parent, tp2.parent.substRecThis(tp2, rthis1))
-          case _ =>
-            secondTry
-        compareRec
       case CapturingType(_, _) =>
         secondTry
       case tp2: AnnotatedType if !tp2.isRefining =>