Handle outer class roots when instantiating class members

The problem arises if we have a class like the one in pos-custom-args/captures/refs.scala:

```scala
class MonoRef(init: Proc):
  type MonoProc = Proc
  var x: MonoProc = init
  def getX: MonoProc = x
  def setX(x: MonoProc): Unit = this.x = x
```

The type of `getX` and `setX` refer to the local root capability of class `MonoRef`.
When we call `m.getX` or `m.setX` in `m: MonoRef`, these occurrences have to be adapted to
capture roots in the scope of the selection. We determine these roots by inspecting the
capture set of `m` and picking a root that corresponds to it.

Author: odersky

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

@@ -89,8 +89,6 @@ trait FollowAliases extends TypeMap:
       mapOver(t)
 
 class mapRoots(from0: CaptureRoot, to: CaptureRoot)(using Context) extends BiTypeMap, FollowAliases:
-  thisMap =>
-
   val from = from0.followAlias
 
   //override val toString = i"mapRoots($from, $to)"
@@ -467,12 +465,10 @@ extension (sym: Symbol)
       else newRoot
     ccState.localRoots.getOrElseUpdate(owner, lclRoot)
 
-  def maxNested(other: Symbol, pickFirstOnConflict: Boolean = false)(using Context): Symbol =
+  def maxNested(other: Symbol, onConflict: (Symbol, Symbol) => Context ?=> Symbol)(using Context): Symbol =
     if !sym.exists || other.isContainedIn(sym) then other
     else if !other.exists || sym.isContainedIn(other) then sym
-    else
-      assert(pickFirstOnConflict, i"incomparable nesting: $sym and $other")
-      sym
+    else onConflict(sym, other)
 
   def minNested(other: Symbol)(using Context): Symbol =
     if !other.exists || other.isContainedIn(sym) then sym

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

@@ -4,10 +4,12 @@ package cc
 
 import core.*
 import Types.*, Symbols.*, Contexts.*, Annotations.*, Flags.*
+import config.Printers.capt
 import Hashable.Binders
 import printing.Showable
 import util.SimpleIdentitySet
-import Decorators.i
+import Decorators.*
+import StdNames.nme
 import scala.annotation.constructorOnly
 import scala.annotation.internal.sharable
 
@@ -43,11 +45,31 @@ object CaptureRoot:
         case _ =>
       myAlias = r
 
+    /** A fresh var with the same limits and outerRoots as this one */
+    def fresh(using Context): Var =
+      val r = Var(owner, NoSymbol)
+      r.innerLimit = innerLimit
+      r.outerLimit = outerLimit
+      r.outerRoots = outerRoots
+      r
+
+    /** A fresh var that is enclosed by all roots in `rs`.
+     *  @throws A NoCommonRoot exception if this is not possible
+     *          since root scopes dont' overlap.
+     */
+    def freshEnclosedBy(rs: CaptureRoot*)(using Context): CaptureRoot =
+      val r = fresh
+      if rs.forall(_.encloses(r)) then r else throw NoCommonRoot(rs*)
+
     def computeHash(bs: Binders): Int = hash
     def hash: Int = System.identityHashCode(this)
     def underlying(using Context): Type = defn.Caps_Cap.typeRef
   end Var
 
+  class NoCommonRoot(rs: CaptureRoot*)(using Context) extends Exception(
+    i"No common capture root nested in ${rs.mkString(" and ")}"
+  )
+
   extension (r: CaptureRoot)
 
     def followAlias(using Context): CaptureRoot = r match
@@ -83,7 +105,9 @@ object CaptureRoot:
           else if !r2.innerLimit.isContainedIn(r1.outerLimit) then false // no overlap
           else if r1.outerRoots.contains(r2) then // unify
             r1.alias = r2
-            r2.outerLimit = r1.outerLimit.maxNested(r2.outerLimit)
+            r2.outerLimit =
+              r1.outerLimit.maxNested(r2.outerLimit,
+                onConflict = (_, _) => throw NoCommonRoot(r1, r2))
             r2.innerLimit = r1.innerLimit.minNested(r2.innerLimit)
             true
           else
@@ -93,6 +117,75 @@ object CaptureRoot:
               r2.outerRoots -= r2
               false
     end encloses
+  end extension
+
+  /** The capture root enclosed by `root1` and `root2`.
+   *  If one of these is a Var, create a fresh Var with the appropriate constraints.
+   *  If the scopes of `root1` and `root2` don't overlap, thow a `NoCommonRoot` exception.
+   */
+  def lub(root1: CaptureRoot, root2: CaptureRoot)(using Context): CaptureRoot =
+    val (r1, r2) = (root1.followAlias, root2.followAlias)
+    if r1 eq r2 then r1
+    else (r1, r2) match
+      case (r1: TermRef, r2: TermRef) =>
+        r1.localRootOwner.maxNested(r2.localRootOwner,
+          onConflict = (_, _) => throw NoCommonRoot(r1, r2)
+        ).termRef
+      case (r1: TermRef, r2: Var) =>
+        r2.freshEnclosedBy(r1, r2)
+      case (r1: Var, r2) =>
+        r1.freshEnclosedBy(r1, r2)
+
+  /** A map that instantiates all outer class roots in the info of `sym`
+   *  according to prefix `pre`. This is called for adapting the info of
+   *  a selection `pre.sym`. The logic of the function is modeled after
+   *  AsSeenFrom. But where AsSeenFrom maps a `this` of class `C` to a corresponding
+   *  prefix, the present method maps a local root corresponding to a class to
+   *  the root implied by the capture set of the corresponding prefix.
+   *  @param  sym     the class member symbol whose info is mapped
+   *  @param  pre     the prefix from which `sym` is selected
+   *  @param  deafilt the capture root to use if the capture set of the corresponding
+   *                  prfefix is empty.
+   */
+  class instantiateOuterClassRoots(sym: Symbol, pre: Type, default: CaptureRoot)(using Context) extends ApproximatingTypeMap:
+    val cls = sym.owner.asClass
+
+    def apply(tp: Type): Type =
+
+      /** Analogous to `toPrefix` in `AssSeenFromMap`, but result prefix gets
+       *  further mapped to a capture root via `impliedRoot`.
+       */
+      def mapCaptureRoot(pre: Type, cls: Symbol, thiscls: ClassSymbol, fallBack: CaptureRoot): CaptureRoot =
+        if (pre eq NoType) || (pre eq NoPrefix) || (cls is PackageClass) then
+          fallBack
+        else pre match
+          case pre: SuperType =>
+            mapCaptureRoot(pre.thistpe, cls, thiscls, fallBack)
+          case _ =>
+            if thiscls.derivesFrom(cls) && pre.baseType(thiscls).exists then
+              pre.captureSet.impliedRoot(default)
+            else if pre.termSymbol.is(Package) && !thiscls.is(Package) then
+              mapCaptureRoot(pre.select(nme.PACKAGE), cls, thiscls, fallBack)
+            else
+              mapCaptureRoot(pre.baseType(cls).normalizedPrefix, cls.owner, thiscls, fallBack)
+
+      def instRoot(elem: CaptureRef): CaptureRef = elem match
+        case elem: TermRef
+        if elem.name == nme.LOCAL_CAPTURE_ROOT && elem.symbol.owner.isLocalDummy =>
+          mapCaptureRoot(pre, cls, elem.localRootOwner.asClass, elem)
+            .showing(i"mapped capture root $elem in $cls to $result", capt)
+        case _ =>
+          elem
+
+      tp match
+        case t @ CapturingType(parent, refs) =>
+          val elems = refs.elems.toList
+          val elems1 = elems.mapConserve(instRoot)
+          val refs1 = if elems1 eq elems then refs else CaptureSet(elems1*)
+          t.derivedCapturingType(apply(parent), refs1)
+        case _ =>
+          mapOver(tp)
+  end instantiateOuterClassRoots
 
 end CaptureRoot
 

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

@@ -233,7 +233,7 @@ sealed abstract class CaptureSet extends Showable:
     else if that.subCaptures(this, frozen = true).isOK then this
     else if this.isConst && that.isConst then Const(this.elems ++ that.elems)
     else Var(
-        this.levelLimit.maxNested(that.levelLimit, pickFirstOnConflict = true),
+        this.levelLimit.maxNested(that.levelLimit, onConflict = (sym1, sym2) => sym1),
         this.elems ++ that.elems)
       .addAsDependentTo(this).addAsDependentTo(that)
 
@@ -315,6 +315,22 @@ sealed abstract class CaptureSet extends Showable:
   def substParams(tl: BindingType, to: List[Type])(using Context) =
     map(Substituters.SubstParamsMap(tl, to))
 
+  /** The capture root that corresponds to this capture set. This is:
+   *    - if the capture set is a Var with a defined level limit, the
+   *      associated capture root,
+   *    - otherwise, if the set is nonempty, the innermost root such
+   *      that some element of the set subcaptures this root,
+   *    - otherwise, if the set is empty, `default`.
+   */
+  def impliedRoot(default: CaptureRoot)(using Context): CaptureRoot =
+    if levelLimit.exists then levelLimit.localRoot.termRef
+    else if elems.isEmpty then default
+    else elems.toList
+      .map:
+        case elem: CaptureRoot if elem.isLocalRootCapability => elem
+        case elem => elem.captureSetOfInfo.impliedRoot(default)
+      .reduce((x: CaptureRoot, y: CaptureRoot) => CaptureRoot.lub(x, y))
+
   /** Invoke handler if this set has (or later aquires) the root capability `cap` */
   def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
     if isUniversal then handler()

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

@@ -319,7 +319,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           includeCallCaptures(tree.symbol, tree.srcPos)
       else
         markFree(tree.symbol, tree.srcPos)
-      instantiateLocalRoots(tree.symbol, pt):
+      instantiateLocalRoots(tree.symbol, NoPrefix, pt):
         super.recheckIdent(tree, pt)
 
     /** A specialized implementation of the selection rule.
@@ -349,7 +349,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       val selType = recheckSelection(tree, qualType, name, disambiguate)
       val selCs = selType.widen.captureSet
-      instantiateLocalRoots(tree.symbol, pt):
+      instantiateLocalRoots(tree.symbol, qualType, pt):
         if selCs.isAlwaysEmpty || selType.widen.isBoxedCapturing || qualType.isBoxedCapturing then
           selType
         else
@@ -370,14 +370,23 @@ class CheckCaptures extends Recheck, SymTransformer:
      *   - `tp` is the type of a function that gets applied, either as a method
      *     or as a function value that gets applied.
      */
-    def instantiateLocalRoots(sym: Symbol, pt: Type)(tp: Type)(using Context): Type =
+    def instantiateLocalRoots(sym: Symbol, pre: Type, pt: Type)(tp: Type)(using Context): Type =
       def canInstantiate =
         sym.is(Method, butNot = Accessor)
         || sym.isTerm && defn.isFunctionType(sym.info) && pt == AnySelectionProto
-      if sym.skipConstructor.isLevelOwner && canInstantiate then
+      if canInstantiate then
         val tpw = tp.widen
-        val tp1 = mapRoots(sym.localRoot.termRef, CaptureRoot.Var(ctx.owner, sym))(tpw)
-          .showing(i"INST $sym: $tp, ${sym.localRoot} = $result", ccSetup)
+        var tp1 = tpw
+        val rootVar = CaptureRoot.Var(ctx.owner, sym)
+        if sym.skipConstructor.isLevelOwner then
+          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
@@ -695,6 +704,9 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ =>
       val res =
         try super.recheck(tree, pt)
+        catch case ex: CaptureRoot.NoCommonRoot =>
+          report.error(ex.getMessage.nn)
+          tree.tpe
         finally curEnv = saved
       if tree.isTerm && !pt.isBoxedCapturing then
         markFree(res.boxedCaptureSet, tree.srcPos)

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

@@ -0,0 +1,28 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/pairs.scala:15:31 ----------------------------------------
+15 |    val x1c: Cap^ ->{c} Unit = x1  // error
+   |                               ^^
+   |                               Found:    (x$0: Cap^{cap[test]}) ->{x1} Unit
+   |                               Required: Cap^{cap[x1c]} ->{c} Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/pairs.scala:17:30 ----------------------------------------
+17 |    val y1c: Cap ->{d} Unit = y1  // error
+   |                              ^^
+   |                              Found:    (x$0: Cap^{cap[test]}) ->{y1} Unit
+   |                              Required: Cap^{cap[y1c]} ->{d} Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/pairs.scala:34:30 ----------------------------------------
+34 |    val x1c: Cap ->{c} Unit = x1  // error
+   |                              ^^
+   |                              Found:    (x$0: Cap^{cap[test]}) ->{x1} Unit
+   |                              Required: Cap^{cap[x1c]} ->{c} Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/pairs.scala:36:30 ----------------------------------------
+36 |    val y1c: Cap ->{d} Unit = y1  // error
+   |                              ^^
+   |                              Found:    (x$0: Cap^{cap[test]}) ->{y1} Unit
+   |                              Required: Cap^{cap[y1c]} ->{d} Unit
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/pairs.scala

@@ -0,0 +1,37 @@
+@annotation.capability class Cap
+
+object Monomorphic:
+
+  class Pair(x: Cap => Unit, y: Cap => Unit):
+    type PCap = Cap
+    def fst: PCap ->{x} Unit = x
+    def snd: PCap ->{y} Unit = y
+
+  def test(c: Cap, d: Cap) =
+    def f(x: Cap): Unit = if c == x then ()
+    def g(x: Cap): Unit = if d == x then ()
+    val p = Pair(f, g)
+    val x1 = p.fst
+    val x1c: Cap^ ->{c} Unit = x1  // error
+    val y1 = p.snd
+    val y1c: Cap ->{d} Unit = y1  // error
+
+object Monomorphic2:
+
+  class Pair(x: Cap => Unit, y: Cap => Unit):
+    def fst: Cap^{cap[Pair]} ->{x} Unit = x
+    def snd: Cap^{cap[Pair]} ->{y} Unit = y
+
+  class Pair2(x: Cap => Unit, y: Cap => Unit):
+    def fst: Cap^{cap[Pair2]} => Unit = x
+    def snd: Cap^{cap[Pair2]} => Unit = y
+
+  def test(c: Cap, d: Cap) =
+    def f(x: Cap): Unit = if c == x then ()
+    def g(x: Cap): Unit = if d == x then ()
+    val p = Pair(f, g)
+    val x1 = p.fst
+    val x1c: Cap ->{c} Unit = x1  // error
+    val y1 = p.snd
+    val y1c: Cap ->{d} Unit = y1  // error
+

tests/pos-custom-args/captures/outer-roots.scala

@@ -0,0 +1,26 @@
+class C
+type Cap = C^
+
+class A
+class B
+
+class Foo(x: Cap):
+
+  def foo: A ->{cap[Foo]} Unit = ???
+
+  class Bar(y: Cap):
+
+    def bar: B ->{cap[Bar]} Unit = ???
+
+    def f(a: A ->{cap[Foo]} Unit, b: B ->{cap[Bar]} Unit)
+      : (A ->{a} Unit, B ->{b} Unit)
+      = (a, b)
+
+def test(c1: Cap, c2: Cap) =
+  val x = Foo(c1)
+  val y = x.Bar(c2)
+  val xfoo = x.foo
+  val ybar = y.bar
+  val z1 = y.f(xfoo, ybar)
+  val z2 = y.f(x.foo, y.bar)
+  ()

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

@@ -29,9 +29,9 @@ object Monomorphic:
     def g(x: Cap): Unit = if d == x then ()
     val p = Pair(f, g)
     val x1 = p.fst
-    val x1c: Cap ->{c} Unit = x1
+    val x1c: Cap^{cap[test]} ->{c} Unit = x1
     val y1 = p.snd
-    val y1c: Cap ->{d} Unit = y1
+    val y1c: Cap^{cap[test]} ->{d} Unit = y1
 
 object Monomorphic2:
 
@@ -48,7 +48,6 @@ object Monomorphic2:
     def g(x: Cap): Unit = if d == x then ()
     val p = Pair(f, g)
     val x1 = p.fst
-    val x1c: Cap ->{c} Unit = x1
+    val x1c: Cap^{cap[test]} ->{c} Unit = x1
     val y1 = p.snd
-    val y1c: Cap ->{d} Unit = y1
-
+    val y1c: Cap^{cap[test]} ->{d} Unit = y1

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

@@ -0,0 +1,29 @@
+type Proc = () => Unit
+
+class MonoRef(init: Proc):
+  type MonoProc = Proc
+  var x: MonoProc = init
+  def getX: MonoProc = x
+  def setX(x: MonoProc): Unit = this.x = x
+
+def test(p: Proc) =
+  val x = MonoRef(p)
+  x.setX(p)
+  val y = x.getX
+  val yc1: Proc = y
+  val yc2: () ->{x} Unit = y
+  val yc3: () ->{cap[test]} Unit = y
+
+class MonoRef2(init: () => Unit):
+  var x: () ->{cap[MonoRef2]} Unit = init
+  def getX: () ->{cap[MonoRef2]} Unit = x
+  def setX(x: () ->{cap[MonoRef2]} Unit): Unit = this.x = x
+
+def test2(p: Proc) =
+  val x = MonoRef2(p)
+  x.setX(p)
+  val y = x.getX
+  val yc1: Proc = y
+  val yc2: () ->{x} Unit = y
+  val yc3: () ->{cap[test2]} Unit = y
+