Work capture root determination into AsSeenFrom

Author: odersky

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

@@ -511,7 +511,7 @@ object CaptureSet:
         if elem.isRootCapability then res
         else res.orElse(addNewElems(elem.captureSetOfInfo.elems, origin))
       else
-        //assert(id != 2, newElems)
+        //assert(id != 19 || !elem.isLocalRootCapability, elem.asInstanceOf[TermRef].localRootOwner)
         elems += elem
         if elem.isGenericRootCapability then rootAddedHandler()
         newElemAddedHandler(elem)

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

@@ -382,11 +382,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           tp1 = mapRoots(sym.localRoot.termRef, rootVar)(tp1)
           if tp1 ne tpw then
             ccSetup.println(i"INST local $sym: $tp, ${sym.localRoot} = $tp1")
-        if sym.owner.isClass then
-          val tp2 = CaptureRoot.instantiateOuterClassRoots(sym, pre, rootVar)(tp1)
-          if tp2 ne tp1 then
-            ccSetup.println(i"INST class $sym: $tp, ${sym.localRoot} in $pre = $tp2")
-          tp1 = tp2
         if tpw eq tp1 then tp else tp1
       else
         tp

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

@@ -11,7 +11,7 @@ import StdNames._
 import collection.mutable
 import ast.tpd._
 import reporting.trace
-import config.Printers.typr
+import config.Printers.{typr, ccSetup}
 import config.Feature
 import transform.SymUtils.*
 import typer.ProtoTypes._
@@ -93,13 +93,25 @@ object TypeOps:
         }
       }
 
+      def mapLocalRoot(tp: TermRef): Type =
+        if tp.symbol.owner.isLocalDummy then
+          val pre1 = toPrefix(pre, cls, tp.localRootOwner.asClass)
+          if pre1 ne tp then pre1.captureSet.impliedRoot(tp)
+            .showing(i"map local root $tp from $pre to $result", ccSetup)
+          else tp
+        else tp
+
       trace.conditionally(track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) { // !!! DEBUG
         // All cases except for ThisType are the same as in Map. Inlined for performance
         // TODO: generalize the inlining trick?
         tp match {
           case tp: NamedType =>
             val sym = tp.symbol
-            if (sym.isStatic && !sym.maybeOwner.seesOpaques || (tp.prefix `eq` NoPrefix)) tp
+            if sym.isStatic && !sym.maybeOwner.seesOpaques then tp
+            else if tp.prefix `eq` NoPrefix then
+              if tp.name == nme.LOCAL_CAPTURE_ROOT
+              then mapLocalRoot(tp.asInstanceOf[TermRef])
+              else tp
             else derivedSelect(tp, atVariance(variance max 0)(this(tp.prefix)))
           case tp: LambdaType =>
             mapOverLambda(tp) // special cased common case

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

@@ -1,9 +1,16 @@
 class C
 type Cap = C^
 
-class Foo(x: Cap):
-  this: Foo^{x} =>
+type Proc = () => Unit
+
+class Ref(p: () => Unit):
+  private var x: () => Unit = p
+  def set(x: () ->{cap[Ref]} Unit): Unit = this.x = x
+  def get: () => Unit = x
+
+def test(c: () => Unit) =
+  val p: () => Unit = ???
+  val r = Ref(p)
+  val x = r.get
+  r.set(x)
 
-def test(c: Cap) =
-  val x = Foo(c)
-  ()