Refactoring: Separate addOwnerAsHidden from Fresh creation

Also, work towards linking Fresh.fromCap more tightly to transformExplicitType

Author: odersky

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

@@ -764,7 +764,7 @@ object CapsOfApply:
 
 abstract class AnnotatedCapability(annotCls: Context ?=> ClassSymbol):
   def apply(tp: Type)(using Context): AnnotatedType =
-    assert(tp.isTrackableRef)
+    assert(tp.isTrackableRef, i"not a trackable ref: $tp")
     tp match
       case AnnotatedType(_, annot) =>
         assert(!unwrappable.contains(annot.symbol), i"illegal combination of derived capabilities: $annotCls over ${annot.symbol}")

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

@@ -419,7 +419,7 @@ object CaptureSet:
     defn.captureRoot.termRef.singletonCaptureSet
 
   def fresh(owner: Symbol = NoSymbol)(using Context): CaptureSet =
-    Fresh(owner).singletonCaptureSet
+    Fresh.withOwner(owner).singletonCaptureSet
 
   /** The shared capture set `{cap.rd}` */
   def shared(using Context): CaptureSet =
@@ -952,8 +952,8 @@ object CaptureSet:
    *  which are already subject through snapshotting and rollbacks in VarState.
    *  It's advantageous if we don't need to deal with other pieces of state there.
    */
-  class HiddenSet(initialOwner: Symbol, initialHidden: Refs = emptyRefs)(using @constructorOnly ictx: Context)
-  extends Var(initialOwner, initialHidden):
+  class HiddenSet(initialOwner: Symbol)(using @constructorOnly ictx: Context)
+  extends Var(initialOwner):
     var owningCap: AnnotatedType = uninitialized
     var givenOwner: Symbol = initialOwner
 

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

@@ -846,7 +846,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         var refined: Type = core
         var allCaptures: CaptureSet =
           if core.derivesFromMutable then initCs ++ CaptureSet.fresh()
-          else if core.derivesFromCapability then initCs ++ Fresh(core.classSymbol).readOnly.singletonCaptureSet
+          else if core.derivesFromCapability then initCs ++ Fresh.withOwner(core.classSymbol).readOnly.singletonCaptureSet
           else initCs
         for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
           val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol

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

@@ -234,7 +234,7 @@ object Existential:
       def apply(t: Type): Type = t match
         case t @ Vble(binder) =>
           if localBinders.contains(binder) then t // keep bound references
-          else seen.getOrElseUpdate(t.annot, Fresh(NoSymbol)) // map free references to Fresh()
+          else seen.getOrElseUpdate(t.annot, Fresh()) // map free references to Fresh()
         case t: MethodType =>
           // skip parameters
           val saved = localBinders
@@ -306,7 +306,7 @@ object Existential:
               val (k, v) = it.next
               if v.annot eq t.annot then ref = k
             if ref == null then
-              ref = Fresh(NoSymbol)
+              ref = Fresh()
               seen(ref) = t
             ref
           case _ => mapOver(t)

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

@@ -47,29 +47,27 @@ object Fresh:
   end Annot
 
   /** Constructor and extractor methods for "fresh" capabilities */
-  def apply(owner: Symbol, initialHidden: Refs = emptyRefs)(using Context): CaptureRef =
+  private def make(owner: Symbol)(using Context): CaptureRef =
     if ccConfig.useSepChecks then
-      val hiddenSet = CaptureSet.HiddenSet(owner, initialHidden)
+      val hiddenSet = CaptureSet.HiddenSet(owner)
       val res = AnnotatedType(defn.captureRoot.termRef, Annot(hiddenSet, NoType))
       hiddenSet.owningCap = res
       //assert(hiddenSet.id != 3)
       res
     else
       defn.captureRoot.termRef
 
-  def apply(owner: Symbol, reach: Boolean)(using Context): CaptureRef =
-    apply(owner, ownerToHidden(owner, reach))
+  def withOwner(owner: Symbol)(using Context): CaptureRef = make(owner)
 
-  def apply(owner: Symbol)(using Context): CaptureRef =
-    apply(owner, ownerToHidden(owner, reach = false))
+  def apply()(using Context): CaptureRef = make(NoSymbol)
 
   def unapply(tp: AnnotatedType): Option[CaptureSet.HiddenSet] = tp.annot match
     case Annot(hidden, binder) if !binder.exists => Some(hidden)
     case _ => None
 
   /** Create an existential */
   def existential(binder: MethodType)(using Context): AnnotatedType =
-    val hiddenSet = CaptureSet.HiddenSet(NoSymbol, emptyRefs)
+    val hiddenSet = CaptureSet.HiddenSet(NoSymbol)
     val res = AnnotatedType(defn.captureRoot.termRef, Annot(hiddenSet, binder))
     hiddenSet.owningCap = res
     res
@@ -88,17 +86,13 @@ object Fresh:
   class FromCap(owner: Symbol)(using Context) extends BiTypeMap, FollowAliasesMap:
     thisMap =>
 
-    private var reach = false
-
     override def apply(t: Type) =
       if variance <= 0 then t
       else t match
         case t: CaptureRef if t.isCap =>
-          Fresh(owner, ownerToHidden(owner, reach))
-        case t @ CapturingType(_, refs) =>
-          val savedReach = reach
-          if t.isBoxed then reach = true
-          try mapOver(t) finally reach = savedReach
+          Fresh.withOwner(owner)
+        case t @ CapturingType(_, _) =>
+          mapOver(t)
         case t @ AnnotatedType(parent, ann) =>
           val parent1 = this(parent)
           if ann.symbol.isRetains && ann.tree.toCaptureSet.containsCap then

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

@@ -14,6 +14,7 @@ import transform.{PreRecheck, Recheck}, Recheck.*
 import CaptureSet.{IdentityCaptRefMap, IdempotentCaptRefMap}
 import Synthetics.isExcluded
 import util.SimpleIdentitySet
+import util.chaining.*
 import reporting.Message
 import printing.{Printer, Texts}, Texts.{Text, Str}
 import collection.mutable
@@ -132,7 +133,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       def mappedInfo =
         if toBeUpdated.contains(sym)
         then symd.info // don't transform symbols that will anyway be updated
-        else Fresh.fromCap(transformExplicitType(symd.info, sym), sym)
+        else Fresh.fromCap(transformExplicitType(symd.info, sym), sym).tap(addOwnerAsHidden(_, sym))
       if Synthetics.needsTransform(symd) then
         Synthetics.transform(symd, mappedInfo)
       else if isPreCC(sym) then
@@ -489,6 +490,22 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
   extension (sym: Symbol) def nextInfo(using Context): Type =
     atPhase(thisPhase.next)(sym.info)
 
+  private def addOwnerAsHidden(tp: Type, owner: Symbol)(using Context): Unit =
+    val ref = owner.termRef
+    def add = new TypeTraverser:
+      var reach = false
+      def traverse(t: Type): Unit = t match
+        case Fresh(hidden) =>
+          if reach then hidden.elems += ref.reach
+          else if ref.isTracked then hidden.elems += ref
+        case t @ CapturingType(_, _) if t.isBoxed && !reach =>
+          reach = true
+          try traverseChildren(t) finally reach = false
+        case _ =>
+          traverseChildren(t)
+    if ref.isTrackableRef then add.traverse(tp)
+  end addOwnerAsHidden
+
   /** A traverser that adds knownTypes and updates symbol infos */
   def setupTraverser(checker: CheckerAPI) = new TreeTraverserWithPreciseImportContexts:
     import checker.*
@@ -503,15 +520,17 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         var transformed =
           if tree.isInferred
           then transformInferredType(tree.tpe)
-          else transformExplicitType(tree.tpe, sym, tptToCheck = tree)
+          else
+            val transformed = transformExplicitType(tree.tpe, sym, tptToCheck = tree)
+            if boxed then transformed
+            else Fresh.fromCap(transformed, sym).tap(addOwnerAsHidden(_, sym))
         if boxed then transformed = box(transformed)
         if sym.is(Param) && (transformed ne tree.tpe) then
           paramSigChange += tree
         tree.setNuType(
           if boxed then transformed
           else if sym.hasAnnotation(defn.UncheckedCapturesAnnot) then makeUnchecked(transformed)
-          else if tree.isInferred then transformed
-          else Fresh.fromCap(transformed, sym))
+          else transformed)
 
     /** Transform the type of a val or var or the result type of a def */
     def transformResultType(tpt: TypeTree, sym: Symbol)(using Context): Unit =
@@ -899,7 +918,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     def apply(t: Type) = t match
       case t @ CapturingType(parent, refs) =>
         val parent1 = this(parent)
-        if refs.isUniversal then t.derivedCapturingType(parent1, CaptureSet.Fluid)
+        if refs.isUniversalOrFresh then t.derivedCapturingType(parent1, CaptureSet.Fluid)
         else t
       case _ => mapFollowingAliases(t)
 

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

@@ -10,11 +10,11 @@
    |       Separation failure: argument of type  List[box () ->{c} Unit]
    |       to method foo: (xs: List[box () => Unit], y: Object^): Nothing
    |       corresponds to capture-polymorphic formal parameter xs of type  List[box () => Unit]
-   |       and hides capabilities  {<none>*, c}.
+   |       and hides capabilities  {c}.
    |       Some of these overlap with the captures of the second argument with type  (c : Object^).
    |
-   |         Hidden set of current argument        : {<none>*, c}
-   |         Hidden footprint of current argument  : {<none>*, c}
+   |         Hidden set of current argument        : {c}
+   |         Hidden footprint of current argument  : {c}
    |         Capture set of second argument        : {c}
    |         Footprint set of second argument      : {c}
    |         The two sets overlap at               : {c}