Implement level checking for Fresh roots

Author: odersky

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

@@ -122,6 +122,30 @@ trait CaptureRef extends TypeProxy, ValueType:
   final def isExclusive(using Context): Boolean =
     !isReadOnly && (isRootCapability || captureSetOfInfo.isExclusive)
 
+  final def ccOwner(using Context): Symbol = this match
+    case root.Fresh(hidden) =>
+      hidden.owner
+    case ref: TermRef =>
+      if ref.isCap then NoSymbol
+      else ref.prefix match
+        case prefix: CaptureRef => prefix.ccOwner
+        case _ => ref.symbol
+    case ref: ThisType =>
+      ref.cls
+    case QualifiedCapability(ref1) =>
+      ref1.ccOwner
+    case _ =>
+      NoSymbol
+
+  final def adjustedOwner(using Context): Symbol =
+    def adjust(owner: Symbol): Symbol =
+      if !owner.exists
+        || owner.isClass && (!owner.is(Flags.Module) || owner.isStatic)
+        || owner.is(Flags.Method, butNot = Flags.Accessor) && !owner.isConstructor
+      then owner
+      else adjust(owner.owner)
+    adjust(ccOwner)
+
   // With the support of paths, we don't need to normalize the `TermRef`s anymore.
   // /** Normalize reference so that it can be compared with `eq` for equality */
   // final def normalizedRef(using Context): CaptureRef = this match

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -467,7 +467,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         vbleText ~ hashStr(binder) ~ Str(idStr).provided(showUniqueIds)
       case tp @ root.Fresh(hidden) =>
         val idStr = if showUniqueIds then s"#${tp.rootAnnot.id}" else ""
-        if ccVerbose then s"<fresh$idStr hiding " ~ toTextCaptureSet(hidden) ~ ">"
+        if ccVerbose then s"<fresh$idStr in ${tp.ccOwner} hiding " ~ toTextCaptureSet(hidden) ~ ">"
         else if ccVerbose then "fresh"
         else "cap"
       case tp => toText(tp)

tests/pos-custom-args/captures/skolems2.scala

@@ -13,6 +13,17 @@ def Test(@consume c: Object^, @consume f: Object^ => Object^) =
   val x4: Object^ =
     { unsafeAssumeSeparate(f)(cc) }
 
+def Test2(@consume c: Object^, @consume f: Object^ => Object^) =
+  def cc(): Object^ = unsafeAssumeSeparate(c)
+  val x1 =
+    { f(cc()) }
+  val x2 =
+    f(cc())
+  val x3: Object^ =
+    f(cc())
+  val x4: Object^ =
+    { unsafeAssumeSeparate(f)(cc()) }
+