Fix concept of a parameter in which a path is rooted

pathRoot overshoots, selects `this` as the root of `this.param`.

Author: odersky

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

@@ -375,15 +375,18 @@ object Capabilities:
       case tp1: FreshCap => tp1.ccOwner
       case _ => NoSymbol
 
-    final def isParamPath(using Context): Boolean = this match
+    final def paramPathRoot(using Context): Type = core match
       case tp1: NamedType =>
         tp1.prefix match
           case _: ThisType | NoPrefix =>
-            tp1.symbol.is(Param) || tp1.symbol.is(ParamAccessor)
-          case prefix: CoreCapability => prefix.isParamPath
-          case _ => false
-      case _: ParamRef => true
-      case _ => false
+            if tp1.symbol.is(Param) || tp1.symbol.is(ParamAccessor) then tp1
+            else NoType
+          case prefix: CoreCapability => prefix.paramPathRoot
+          case _ => NoType
+      case tp1: ParamRef => tp1
+      case _ => NoType
+
+    final def isParamPath(using Context): Boolean = paramPathRoot.exists
 
     final def ccOwner(using Context): Symbol = this match
       case self: ThisType => self.cls

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

@@ -463,7 +463,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       def checkUseDeclared(c: Capability, env: Env, lastEnv: Env | Null) =
         if lastEnv != null && env.nestedClosure.exists && env.nestedClosure == lastEnv.owner then
           assert(ccConfig.deferredReaches) // access is from a nested closure under deferredReaches, so it's OK
-        else c.pathRoot match
+        else c.paramPathRoot match
           case ref: NamedType if !ref.symbol.isUseParam =>
             val what = if ref.isType then "Capture set parameter" else "Local reach capability"
             report.error(

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

@@ -0,0 +1,10 @@
+-- Error: tests/neg-custom-args/captures/i23303.scala:6:36 -------------------------------------------------------------
+6 |    def execute: Unit = ops.foreach(f => f()) // error
+  |                                    ^^^^^^^^
+  |                                 Local reach capability Runner.this.ops* leaks into capture scope of class Runner.
+  |                                 To allow this, the value ops should be declared with a @use annotation
+-- Error: tests/neg-custom-args/captures/i23303.scala:9:22 -------------------------------------------------------------
+9 |    () => ops.foreach(f => f()) // error
+  |                      ^^^^^^^^
+  |                      Local reach capability ops* leaks into capture scope of method Runner2.
+  |                      To allow this, the parameter ops should be declared with a @use annotation

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

@@ -1,13 +1,13 @@
 import language.experimental.captureChecking
 import caps.use
 
-/*class Test:
+class Test:
   class Runner(ops: List[() => Unit]):
     def execute: Unit = ops.foreach(f => f()) // error
 
   def Runner2(ops: List[() => Unit]) =
     () => ops.foreach(f => f()) // error
-*/
+
 
 class Test2:
   class Runner(@use ops: List[() => Unit]):