More detailed explanations where Fresh instances come from

Author: odersky

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

@@ -462,7 +462,9 @@ extension (tp: Type)
             if args.forall(_.isAlwaysPure) then
               // Also map existentials in results to reach capabilities if all
               // preceding arguments are known to be always pure
-              t.derivedFunctionOrMethod(args, apply(root.resultToFresh(res)))
+              t.derivedFunctionOrMethod(
+                args,
+                apply(root.resultToFresh(res, i"when instantiating $t")))
             else
               t
           case _ =>
@@ -795,7 +797,8 @@ abstract class DeepTypeAccumulator[T](using Context) extends TypeAccumulator[T]:
       case AnnotatedType(parent, _) =>
         this(acc, parent)
       case t @ FunctionOrMethod(args, res) =>
-        if args.forall(_.isAlwaysPure) then this(acc, root.resultToFresh(res))
+        if args.forall(_.isAlwaysPure) then
+          this(acc, root.resultToFresh(res, i" when instantiating $t"))
         else acc
       case _ =>
         foldOver(acc, t)

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

@@ -423,8 +423,8 @@ object CaptureSet:
   def universalImpliedByCapability(using Context) =
     defn.universalCSImpliedByCapability
 
-  def fresh()(using Context): CaptureSet =
-    root.Fresh().singletonCaptureSet
+  def fresh(purpose: => String)(using Context): CaptureSet =
+    root.Fresh(purpose).singletonCaptureSet
 
   /** The shared capture set `{cap.rd}` */
   def shared(using Context): CaptureSet =
@@ -685,7 +685,7 @@ object CaptureSet:
     def solve()(using Context): Unit =
       CCState.withCapAsRoot: // // OK here since we infer parameter types that get checked later
         val approx = upperApprox(empty)
-          .map(root.CapToFresh().inverse)    // Fresh --> cap
+          .map(root.CapToFresh("").inverse)    // Fresh --> cap
           .showing(i"solve $this = $result", capt)
         //println(i"solving var $this $approx ${approx.isConst} deps = ${deps.toList}")
         val newElems = approx.elems -- elems
@@ -1388,7 +1388,7 @@ object CaptureSet:
       def capturingCase(acc: CaptureSet, parent: Type, refs: CaptureSet) =
         this(acc, parent) ++ refs
       def abstractTypeCase(acc: CaptureSet, t: TypeRef, upperBound: Type) =
-        if includeTypevars && upperBound.isExactlyAny then CaptureSet.fresh()
+        if includeTypevars && upperBound.isExactlyAny then CaptureSet.fresh(i" when computing deep capture set of $t")
         else this(acc, upperBound)
     collect(CaptureSet.empty, tp)
 

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

@@ -714,7 +714,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val meth = tree.fun.symbol
       if meth == defn.Caps_unsafeAssumePure then
         val arg :: Nil = tree.args: @unchecked
-        val argType0 = recheck(arg, pt.stripCapturing.capturing(root.Fresh()))
+        val argType0 = recheck(arg, pt.stripCapturing.capturing(root.Fresh(i" when instantiating argument of unsafeAssumePure")))
         val argType =
           if argType0.captureSet.isAlwaysEmpty then argType0
           else argType0.widen.stripCapturing
@@ -729,12 +729,16 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  occurrences are replaced by `Fresh` instances. Also, if formal parameter carries a `@use`,
      *  charge the deep capture set of the actual argument to the environment.
      */
-    protected override def recheckArg(arg: Tree, formal: Type)(using Context): Type =
-      val freshenedFormal = root.capToFresh(formal)
+    protected override def recheckArg(arg: Tree, formal: Type, pref: ParamRef, app: Apply)(using Context): Type =
+      val fn = app.symbol
+      def purpose =
+        if fn.exists then i" when checking argument to parameter ${pref.paramName} of $fn"
+        else ""
+      val freshenedFormal = root.capToFresh(formal, purpose)
       val argType = recheck(arg, freshenedFormal)
         .showing(i"recheck arg $arg vs $freshenedFormal = $result", capt)
       if formal.hasAnnotation(defn.UseAnnot) || formal.hasAnnotation(defn.ConsumeAnnot) then
-        // The @use and/or @consume annotation is added to `formal` by `prepareFunction`
+        // The @use and/or @consume annotation is added to `formal` by `prep areFunction`
         capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
         markFree(argType.deepCaptureSet, arg)
       if formal.containsCap then
@@ -764,7 +768,11 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     protected override
     def recheckApplication(tree: Apply, qualType: Type, funType: MethodType, argTypes: List[Type])(using Context): Type =
-      val appType = root.resultToFresh(super.recheckApplication(tree, qualType, funType, argTypes))
+      val fn = tree.symbol
+      def methDescr = if fn.exists then i"$fn's type " else ""
+      val appType = root.resultToFresh(
+        super.recheckApplication(tree, qualType, funType, argTypes),
+        i" when instantiating $methDescr$funType")
       val qualCaptures = qualType.captureSet
       val argCaptures =
         for (argType, formal) <- argTypes.lazyZip(funType.paramInfos) yield
@@ -823,8 +831,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       def addParamArgRefinements(core: Type, initCs: CaptureSet): (Type, CaptureSet) =
         var refined: Type = core
         var allCaptures: CaptureSet =
-          if core.derivesFromMutable then initCs ++ CaptureSet.fresh()
-          else if core.derivesFromCapability then initCs ++ root.Fresh().readOnly.singletonCaptureSet
+          if core.derivesFromMutable then
+            initCs ++ CaptureSet.fresh(i" when constructing mutable $core")
+          else if core.derivesFromCapability then
+            initCs ++ root.Fresh(i" when constructing Capability instance $core").readOnly.singletonCaptureSet
           else initCs
         for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
           val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
@@ -864,8 +874,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       val meth = tree.fun match
         case fun @ Select(qual, nme.apply) => qual.symbol.orElse(fun.symbol)
         case fun => fun.symbol
+      def methDescr = if meth.exists then i"$meth's type " else ""
       disallowCapInTypeArgs(tree.fun, meth, tree.args)
-      val res = root.resultToFresh(super.recheckTypeApply(tree, pt))
+      val funType = super.recheckTypeApply(tree, pt)
+      val res = root.resultToFresh(funType, i" when instantiating $methDescr$funType")
       includeCallCaptures(tree.symbol, res, tree)
       checkContains(tree)
       res
@@ -925,14 +937,16 @@ class CheckCaptures extends Recheck, SymTransformer:
               // neg-custom-args/captures/vars.scala. That's why this code is conditioned.
               // to apply only to closures that are not eta expansions.
               assert(paramss1.isEmpty)
-              val respt = root.resultToFresh:
-                pt match
-                  case defn.RefinedFunctionOf(rinfo) =>
-                    val paramTypes = params.map(_.asInstanceOf[ValDef].tpt.nuType)
-                    rinfo.instantiate(paramTypes)
-                  case _ =>
-                    resType
-              val res = root.resultToFresh(mdef.tpt.nuType)
+              val respt0 = pt match
+                case defn.RefinedFunctionOf(rinfo) =>
+                  val paramTypes = params.map(_.asInstanceOf[ValDef].tpt.nuType)
+                  rinfo.instantiate(paramTypes)
+                case _ =>
+                  resType
+              val respt = root.resultToFresh(respt0,
+                i" when instantiating expected result type $respt0 of lambda")
+              val res = root.resultToFresh(mdef.tpt.nuType,
+                i" when instantiating result type ${mdef.tpt.nuType} of lambda")
               // We need to open existentials here in order not to get vars mixed up in them
               // We do the proper check with existentials when we are finished with the closure block.
               capt.println(i"pre-check closure $expr of type $res against $respt")
@@ -1632,7 +1646,9 @@ class CheckCaptures extends Recheck, SymTransformer:
                           memberTp,
                           otherTp.derivedTypeBounds(
                             otherTp.lo,
-                            hi.derivedCapturingType(parent, root.Fresh().singletonCaptureSet))))
+                            hi.derivedCapturingType(parent,
+                              root.Fresh(i" when instantiating upper bound of member overridden by $member")
+                                .singletonCaptureSet))))
                       case _ => None
                   case _ => None
               case _ => None

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

@@ -472,7 +472,12 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     val tp3 =
       if sym.isType then stripImpliedCaptureSet(tp2)
       else tp2
-    if freshen then root.capToFresh(tp3).tap(addOwnerAsHidden(_, sym))
+    if freshen then
+      root.capToFresh(tp3,
+        if sym.is(Method) then i" in the result type of $sym"
+        else if sym.exists then i" in the type of $sym"
+        else "")
+      .tap(addOwnerAsHidden(_, sym))
     else tp3
   end transformExplicitType
 
@@ -568,7 +573,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           traverse(fn)
           for case arg: TypeTree <- args do
             if defn.isTypeTestOrCast(fn.symbol) then
-              arg.setNuType(root.capToFresh(arg.tpe))
+              arg.setNuType(
+                root.capToFresh(arg.tpe, i" of type argument ${arg.tpe}"))
             else
               transformTT(arg, NoSymbol, boxed = true) // type arguments in type applications are boxed
 

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

@@ -116,7 +116,8 @@ object Synthetics:
     def transformUnapplyCaptures(info: Type)(using Context): Type = info match
       case info: MethodType =>
         val paramInfo :: Nil = info.paramInfos: @unchecked
-        val newParamInfo = CapturingType(paramInfo, CaptureSet.fresh())
+        val newParamInfo = CapturingType(paramInfo,
+          CaptureSet.fresh(i" when instantiating argument of unapply with type $info"))
         val trackedParam = info.paramRefs.head
         def newResult(tp: Type): Type = tp match
           case tp: MethodOrPoly =>

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

@@ -61,7 +61,7 @@ object root:
 
   enum Kind:
     case Result(binder: MethodType)
-    case Fresh(hidden: CaptureSet.HiddenSet)
+    case Fresh(hidden: CaptureSet.HiddenSet)(val purpose: () => String)
     case Global
 
     override def equals(other: Any): Boolean =
@@ -129,10 +129,10 @@ object root:
 
   /** Constructor and extractor methods for "fresh" capabilities */
   object Fresh:
-    def apply(using Context)(owner: Symbol = ctx.owner): CaptureRef =
+    def apply(using Context)(purpose: => String, owner: Symbol = ctx.owner): CaptureRef =
       if ccConfig.useSepChecks then
         val hiddenSet = CaptureSet.HiddenSet(owner)
-        val res = AnnotatedType(cap, Annot(Kind.Fresh(hiddenSet)))
+        val res = AnnotatedType(cap, Annot(Kind.Fresh(hiddenSet)(() => purpose)))
         hiddenSet.owningCap = res
         //assert(hiddenSet.id != 3)
         res
@@ -167,14 +167,14 @@ object root:
   /** Map each occurrence of cap to a different Fresh instance
    *  Exception: CapSet^ stays as it is.
    */
-  class CapToFresh()(using Context) extends BiTypeMap, FollowAliasesMap:
+  class CapToFresh(purpose: => String)(using Context) extends BiTypeMap, FollowAliasesMap:
     thisMap =>
 
     override def apply(t: Type) =
       if variance <= 0 then t
       else t match
         case t: CaptureRef if t.isCap =>
-          Fresh()
+          Fresh(purpose)
         case t @ CapturingType(parent: TypeRef, _) if parent.symbol == defn.Caps_CapSet =>
           t
         case t @ CapturingType(_, _) =>
@@ -212,23 +212,23 @@ object root:
   end CapToFresh
 
   /** Maps cap to fresh */
-  def capToFresh(tp: Type)(using Context): Type =
-    if ccConfig.useSepChecks then CapToFresh()(tp) else tp
+  def capToFresh(tp: Type, purpose: => String)(using Context): Type =
+    if ccConfig.useSepChecks then CapToFresh(purpose)(tp) else tp
 
   /** Maps fresh to cap */
   def freshToCap(tp: Type)(using Context): Type =
-    if ccConfig.useSepChecks then CapToFresh().inverse(tp) else tp
+    if ccConfig.useSepChecks then CapToFresh("").inverse(tp) else tp
 
   /** Map top-level free existential variables one-to-one to Fresh instances */
-  def resultToFresh(tp: Type)(using Context): Type =
+  def resultToFresh(tp: Type, purpose: => String)(using Context): Type =
     val subst = new TypeMap:
       val seen = EqHashMap[Annotation, CaptureRef]()
       var localBinders: SimpleIdentitySet[MethodType] = SimpleIdentitySet.empty
 
       def apply(t: Type): Type = t match
         case t @ Result(binder) =>
           if localBinders.contains(binder) then t // keep bound references
-          else seen.getOrElseUpdate(t.annot, Fresh()) // map free references to Fresh()
+          else seen.getOrElseUpdate(t.annot, Fresh(purpose)) // map free references to Fresh()
         case t: MethodType =>
           // skip parameters
           val saved = localBinders
@@ -294,7 +294,7 @@ object root:
               val (k, v) = it.next
               if v.annot eq t.annot then ref = k
             if ref == null then
-              ref = Fresh()
+              ref = Fresh("")
               seen(ref) = t
             ref
           case _ => mapOver(t)

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -8,7 +8,7 @@ import printing.{RefinedPrinter, MessageLimiter, ErrorMessageLimiter}
 import printing.Texts.Text
 import printing.Formatting.hl
 import config.SourceVersion
-import cc.{CaptureRef, CaptureSet, root}
+import cc.{CaptureRef, CaptureSet, root, rootAnnot}
 
 import scala.language.unsafeNulls
 import scala.annotation.threadUnsafe
@@ -175,15 +175,21 @@ object Message:
             if owner.isConstructor then
               i"constructor of ${ownerStr(owner.owner)}"
             else if owner.isAnonymousFunction then
-              i"anonymous fucntion of type ${owner.info}"
+              i"anonymous function of type ${owner.info}"
             else if owner.name.toString.contains('$') then
               ownerStr(owner.owner)
             else
               owner.show
           val descr =
             if ref.isCap then "the universal root capability"
             else ref match
-              case root.Fresh(hidden) => i"a fresh root capability created in ${ownerStr(hidden.owner)}"
+              case ref @ root.Fresh(hidden) =>
+                val (kind: root.Kind.Fresh) = ref.rootAnnot.kind: @unchecked
+                val purpose = kind.purpose()
+                val descr =
+                  if purpose.startsWith(" in the ") then purpose
+                  else i" created in ${ownerStr(hidden.owner)}$purpose"
+                i"a fresh root capability$descr"
               case root.Result(binder) => i"a root capability associated with the result type of $binder"
           s"$relation $descr"
     end explanation

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -304,7 +304,7 @@ abstract class Recheck extends Phase, SymTransformer:
     /** A hook to massage the type of an applied method */
     protected def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType = funtpe
 
-    protected def recheckArg(arg: Tree, formal: Type)(using Context): Type =
+    protected def recheckArg(arg: Tree, formal: Type, pref: ParamRef, app: Apply)(using Context): Type =
       recheck(arg, formal)
 
     /** A hook to check all the parts of an application:
@@ -336,7 +336,7 @@ abstract class Recheck extends Phase, SymTransformer:
             else fntpe.paramInfos
           def recheckArgs(args: List[Tree], formals: List[Type], prefs: List[ParamRef]): List[Type] = args match
             case arg :: args1 =>
-              val argType = recheckArg(arg, normalizeByName(formals.head))
+              val argType = recheckArg(arg, normalizeByName(formals.head), prefs.head, tree)
               val formals1 =
                 if fntpe.isParamDependent
                 then formals.tail.map(_.substParam(prefs.head, argType))

tests/neg-custom-args/captures/byname.check

@@ -7,10 +7,10 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:10:6 ----------------------------------------
 10 |  h(f2())  // error
    |    ^^^^
-   |    Found:    () ?->{cap1} Int ->{cap1} Int
-   |    Required: () ?=> Int ->{cap2} Int
+   |Found:    () ?->{cap1} Int ->{cap1} Int
+   |Required: () ?=> Int ->{cap2} Int
    |
-   |    where:    ?=> refers to a fresh root capability created in method test
+   |where:    ?=> refers to a fresh root capability created in method test when checking argument to parameter ff of method h
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:19:5 ----------------------------------------

tests/neg-custom-args/captures/capt-depfun.check

@@ -4,7 +4,7 @@
    |                                         Found:    Str^{} ->{ac, y, z} Str^{y, z}
    |                                         Required: Str^{y, z} => Str^{y, z}
    |
-   |                                         where:    => refers to a fresh root capability created in value dc
+   |                                         where:    => refers to a fresh root capability in the type of value dc
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/capt-depfun.scala:11:24 -------------------------------------------------------