Include call captures for parameterless methods

Author: odersky

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

@@ -1513,8 +1513,8 @@ object Types {
     }
 
     def captureSet(using Context): CaptureSet = CaptureSet.ofType(this)
-    def noCaptures(using Context): Boolean =
-      ctx.mode.is(Mode.RelaxedCapturing) || allCaptures.isEmpty
+    def noCaptures(using Context): Boolean = // ^^^ drop
+      ctx.mode.is(Mode.RelaxedCapturing) || !ctx.settings.Ycc.value || allCaptures.isEmpty
 
     def allCaptures(using Context): CaptureSet = this match // ^^^^ optimize, relate with boxedCaptures?
       case tp: CapturingType => tp.refs
@@ -2709,7 +2709,7 @@ object Types {
      *  References to term parameters of classes cannot be tracked individually.
      *  They are subsumed in the capture sets of the enclosing class.
      */
-    def canBeTracked(using Context) =
+    def canBeTracked(using Context) = // ^^^ exclude methods
       (prefix eq NoPrefix) || symbol.hasAnnotation(defn.AbilityAnnot) || isRootCapability
 
     override def isRootCapability(using Context): Boolean =

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -59,6 +59,8 @@ abstract class Recheck extends Phase, IdentityDenotTransformer:
     def reinferResult(info: Type)(using Context): Type = info match
       case info: MethodOrPoly =>
         info.derivedLambdaType(resType = reinferResult(info.resType))
+      case info: ExprType =>
+        info.derivedExprType(resType = reinferResult(info.resType))
       case _ =>
         reinfer(info)
 
@@ -317,7 +319,7 @@ abstract class Recheck extends Phase, IdentityDenotTransformer:
           || expected.isRepeatedParam
              && actual <:< expected.translateFromRepeated(toArray = tree.tpe.isRef(defn.ArrayClass))
         if !isCompatible then
-          err.typeMismatch(tree.withType(tpe), pt)
+          err.typeMismatch(tree.withType(tpe), expected)
 
     def checkUnit(unit: CompilationUnit)(using Context): Unit =
       recheck(unit.tpdTree)

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

@@ -95,11 +95,22 @@ class CheckCaptures extends Recheck:
         val ref = sym.termRef
         def recur(env: Env): Unit =
           if env.isOpen && env.owner != sym.enclosure then
-            capt.println(i"Mark $sym free in ${env.owner}")
+            capt.println(i"Mark $sym with cs ${ref.captureSet} free in ${env.owner}")
             checkElem(ref, env.captured, pos)
             recur(env.outer)
         if ref.isTracked then recur(curEnv)
 
+    def includeCallCaptures(sym: Symbol, pos: SrcPos)(using Context): Unit =
+      if curEnv.isOpen then
+        val ownEnclosure = ctx.owner.enclosingMethodOrClass
+        var targetSet = capturedVars(sym)
+        if !targetSet.isEmpty && sym.enclosure == ownEnclosure then
+          targetSet = targetSet.filter {
+            case ref: TermRef => ref.symbol.enclosure != ownEnclosure
+            case _ => true
+          }
+        checkSubset(targetSet, curEnv.captured, pos)
+
     def assertSub(cs1: CaptureSet, cs2: CaptureSet)(using Context) =
       assert((cs1 <:< cs2) == CompareResult.OK, i"$cs1 is not a subset of $cs2")
 
@@ -121,6 +132,7 @@ class CheckCaptures extends Recheck:
 
     override def recheckIdent(tree: Ident)(using Context): Type =
       markFree(tree.symbol, tree.srcPos)
+      if tree.symbol.is(Method) then includeCallCaptures(tree.symbol, tree.srcPos)
       super.recheckIdent(tree)
 
     override def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Type =
@@ -138,17 +150,8 @@ class CheckCaptures extends Recheck:
       finally curEnv = saved
 
     override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      if curEnv.isOpen then
-        val ownEnclosure = ctx.owner.enclosingMethodOrClass
-        var targetSet = capturedVars(tree.symbol)
-        if !targetSet.isEmpty && tree.symbol.enclosure == ownEnclosure then
-          targetSet = targetSet.filter {
-            case ref: TermRef => ref.symbol.enclosure != ownEnclosure
-            case _ => true
-          }
-
-        checkSubset(targetSet, curEnv.captured, tree.srcPos)
       val sym = tree.symbol
+      includeCallCaptures(sym, tree.srcPos)
       val cs = if sym.isConstructor then capturedVars(sym.owner) else CaptureSet.empty
       super.recheckApply(tree, pt).capturing(cs)
 

tests/neg-custom-args/captures/capt-wf.scala renamed to tests/disabled/neg-custom-args/captures/capt-wf.scala

@@ -1,3 +1,4 @@
+// No longer valid
 class C
 type Cap = C retains *
 type Top = Any retains *

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

@@ -1,9 +1,7 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/boxmap.scala:15:2 ----------------------------------------
-15 |  () => b[Box[B]]((x: A) => box(f(x)))  // error
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/boxmap.scala:14:5 ----------------------------------------
+14 |  () => b[Box[B]]((x: A) => box(f(x)))  // error
    |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |  Found:    {f} {b} () => Box[B]
-   |  Required: {B} () => Box[B]
-   |
-   |  where:    B is a type in method lazymap with bounds <: Top
+   |  Found:    {f} () => Box[B]
+   |  Required: () => Box[B]
 
 longer explanation available when compiling with `-explain`

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

@@ -1,9 +1,8 @@
 type Top = Any retains *
-class Cap extends Retains[*]
 
 infix type ==> [A, B] = (A => B) retains *
 
-type Box[+T <: Top] = ([K <: Top] => (T ==> K) => K) retains T
+type Box[+T <: Top] = ([K <: Top] => (T ==> K) => K)
 
 def box[T <: Top](x: T): Box[T] =
   [K <: Top] => (k: T ==> K) => k(x)

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

@@ -3,7 +3,7 @@ sealed trait IO:
 
 def test1 =
   val IO : IO retains * = new IO {}
-  def foo = IO.puts("hello")
+  def foo = {IO; IO.puts("hello") }
   val x : () => Unit = () => foo  // error: Found: (() => Unit) retains IO; Required: () => Unit
 
 def test2 =
@@ -19,3 +19,4 @@ def test3 =
   def puts(msg: Any, io: Capability[IO]) = println(msg)
   def foo() = puts("hello", IO)
   val x : () => Unit = () => foo()  // error: Found: (() => Unit) retains IO; Required: () => Unit
+

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

@@ -1,7 +1,8 @@
 import java.io.IOException
 
-class CanThrow[E] extends Retains[*]
-type Top  = Any retains *
+class CT[E]
+type CanThrow[E] = {*} CT[E]
+type Top  = {*} Any
 
 def handle[E <: Exception, T <: Top](op: CanThrow[E] ?=> T)(handler: E => T): T =
   val x: CanThrow[E] = ???
@@ -13,9 +14,9 @@ def raise[E <: Exception](ex: E)(using CanThrow[E]): Nothing =
 
 @main def Test: Int =
   def f(a: Boolean) =
-    handle { // error
+    handle {
       if !a then raise(IOException())
-      (b: Boolean) =>
+      (b: Boolean) => // error
         if !b then raise(IOException())
         0
     } {