Better error messages in healTypeParam

Also: better parameter names for synthesized methods

Author: odersky

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

@@ -4,6 +4,7 @@ package cc
 
 import core.*
 import Types.*, Symbols.*, Contexts.*, Annotations.*, Flags.*
+import Names.TermName
 import ast.{tpd, untpd}
 import Decorators.*, NameOps.*
 import config.SourceVersion
@@ -45,9 +46,12 @@ def isCaptureCheckingOrSetup(using Context): Boolean =
 /** A dependent function type with given arguments and result type
  * TODO Move somewhere else where we treat all function type related ops together.
  */
-def depFun(args: List[Type], resultType: Type, isContextual: Boolean)(using Context): Type =
- MethodType.companion(isContextual = isContextual)(args, resultType)
- .toFunctionType(alwaysDependent = true)
+def depFun(args: List[Type], resultType: Type, isContextual: Boolean, paramNames: List[TermName] = Nil)(using Context): Type =
+ val make = MethodType.companion(isContextual = isContextual)
+ val mt = 
+ if paramNames.length == args.length then make(paramNames, args, resultType)
+ else make(args, resultType)
+ mt.toFunctionType(alwaysDependent = true)
 
 /** An exception thrown if a @retains argument is not syntactically a CaptureRef */
 class IllegalCaptureRef(tpe: Type) extends Exception(tpe.toString)

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

@@ -867,11 +867,13 @@ class CheckCaptures extends Recheck, SymTransformer:
  if eparent1 eq eparent then expected
  else CapturingType(eparent1, refs, boxed = expected0.isBoxed)
  case expected @ defn.FunctionOf(args, resultType, isContextual)
- if defn.isNonRefinedFunction(expected) && defn.isFunctionNType(actual) && !defn.isNonRefinedFunction(actual) =>
- val expected1 = depFun(args, resultType, isContextual)
- expected1
- case _ =>
- expected
+ if defn.isNonRefinedFunction(expected) =>
+ actual match
+ case RefinedType(parent, nme.apply, rinfo: MethodType)
+ if defn.isFunctionNType(actual) =>
+ depFun(args, resultType, isContextual, rinfo.paramNames)
+ case _ => expected
+ case _ => expected
  recur(expected)
 
  /** For the expected type, implement the rule outlined in #14390:
@@ -1239,7 +1241,7 @@ class CheckCaptures extends Recheck, SymTransformer:
  * compensate this by pushing the widened capture set of `f` into ?1.
  * This solves the soundness issue caused by the ill-formness of ?1.
  */
- private def healTypeParam(tree: Tree)(using Context): Unit =
+ private def healTypeParam(tree: Tree, paramName: TypeName, meth: Symbol)(using Context): Unit =
  val checker = new TypeTraverser:
  private var allowed: SimpleIdentitySet[TermParamRef] = SimpleIdentitySet.empty
 
@@ -1261,8 +1263,14 @@ class CheckCaptures extends Recheck, SymTransformer:
  val widened = ref.captureSetOfInfo
  val added = widened.filter(isAllowed(_))
  capt.println(i"heal $ref in $cs by widening to $added")
- checkSubset(added, cs, tree.srcPos)
- widened.elems.foreach(recur)
+ if !added.subCaptures(cs, frozen = false).isOK then
+ val location = if meth.exists then i" of $meth" else ""
+ val debugSetInfo = if ctx.settings.YccDebug.value then i" $cs" else ""
+ report.error(
+ i"local reference ${ref.paramName} leaks into outer capture set$debugSetInfo of type parameter $paramName$location",
+ tree.srcPos)
+ else
+ widened.elems.foreach(recur)
  case _ =>
  recur(elem)
 
@@ -1303,14 +1311,12 @@ class CheckCaptures extends Recheck, SymTransformer:
  case t @ TypeApply(fun, args) =>
  fun.knownType.widen match
  case tl: PolyType =>
- val normArgs = args.lazyZip(tl.paramInfos).map { (arg, bounds) =>
+ val normArgs = args.lazyZip(tl.paramInfos).map: (arg, bounds) =>
  arg.withType(arg.knownType.forceBoxStatus(
  bounds.hi.isBoxedCapturing | bounds.lo.isBoxedCapturing))
- }
  checkBounds(normArgs, tl)
+ args.lazyZip(tl.paramNames).foreach(healTypeParam(_, _, fun.symbol))
  case _ =>
-
- args.foreach(healTypeParam(_))
  case _ =>
  end check
  end checker

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

@@ -19,7 +19,7 @@
 27 | val boxed2 : Observe[C^] = box2(c) // error
  | ^^^^^^^
  | Found: (C{val arg: C^}^{c} => Unit) ->{c} Unit
- | Required: Observe[C^]
+ | Required: (C^ => Unit) -> Unit
  |
  | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:33 ---------------------------------------

tests/neg-custom-args/captures/simple-using.check

@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/captures/simple-using.scala:8:2 --------------------------------------------------------
+8 | usingLogFile { f => () => f.write(2) } // error
+ | ^^^^^^^^^^^^
+ | local reference f leaks into outer capture set of type parameter T of method usingLogFile

tests/neg-custom-args/captures/simple-using.scala

@@ -0,0 +1,8 @@
+import java.io.*
+def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+ val logFile = FileOutputStream("log")
+ val result = op(logFile)
+ logFile.close()
+ result
+def test() =
+ usingLogFile { f => () => f.write(2) } // error

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

@@ -18,22 +18,16 @@
 51 | 22
 52 |} { // error
  | ^
- | Found: () ->{x$0, x$0²} Int
+ | Found: () ->{x, x²} Int
  | Required: () -> Int
  |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | where: x is a reference to a value parameter
+ | x² is a reference to a value parameter
 53 | (ex: Exception) => () => 22
 54 |}
  |
  | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/try.scala:35:11 ---------------------------------------------------------------
 35 | val xx = handle { // error
  | ^^^^^^
- | reference (caps.cap : caps.Cap) is not included in the allowed capture set {x$0, x$0²}
- |
- | Note that the universal capability `cap`
- | cannot be included in capture set {x$0, x$0}
- |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | local reference x leaks into outer capture set of type parameter R of method handle

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

@@ -13,40 +13,16 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:23:14 ------------------------------------------------------
 23 | val later = usingLogFile { f => () => f.write(0) } // error
  | ^^^^^^^^^^^^
- | reference (caps.cap : caps.Cap) is not included in the allowed capture set {x$0, x$0²}
- |
- | Note that the universal capability `cap`
- | cannot be included in capture set {x$0, x$0}
- |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | local reference f leaks into outer capture set of type parameter T of method usingLogFile
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:28:23 ------------------------------------------------------
 28 | private val later2 = usingLogFile { f => Cell(() => f.write(0)) } // error
  | ^^^^^^^^^^^^
- | reference (caps.cap : caps.Cap) is not included in the allowed capture set {x$0, x$0²}
- |
- | Note that the universal capability `cap`
- | cannot be included in capture set {x$0, x$0}
- |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | local reference f leaks into outer capture set of type parameter T of method usingLogFile
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:52:16 ------------------------------------------------------
 52 | val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
  | ^^^^^^^^^
- | reference (caps.cap : caps.Cap) is not included in the allowed capture set {x$0, x$0²}
- |
- | Note that the universal capability `cap`
- | cannot be included in capture set {x$0, x$0}
- |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | local reference f leaks into outer capture set of type parameter T of method usingFile
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:60:16 ------------------------------------------------------
 60 | val later = usingFile("logfile", // error !!! but should be ok, since we can widen `l` to `file` instead of to `cap`
  | ^^^^^^^^^
- | reference (_$1 : java.io.OutputStream^) is not included in the allowed capture set {x$0, x$0²}
- |
- | Note that reference (_$1 : java.io.OutputStream^), defined in method $anonfun
- | cannot be included in outer capture set {x$0, x$0} which is associated with method test
- |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | local reference l leaks into outer capture set of type parameter T of method usingFile

tests/neg-custom-args/captures/vars-simple.check

@@ -9,7 +9,7 @@
 16 | a = g // error
  | ^
  | Found: (x: String) ->{cap3} String
- | Required: (x$0: String) ->{cap[test]} String
+ | Required: (x: String) ->{cap[test]} String
  |
  | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars-simple.scala:17:12 ----------------------------------

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

@@ -25,10 +25,4 @@
 -- Error: tests/neg-custom-args/captures/vars.scala:34:2 ---------------------------------------------------------------
 34 | local { cap3 => // error
  | ^^^^^
- | reference (caps.cap : caps.Cap) is not included in the allowed capture set {x$0, x$0²}
- |
- | Note that the universal capability `cap`
- | cannot be included in capture set {x$0, x$0}
- |
- | where: x$0 is a reference to a value parameter
- | x$0² is a reference to a value parameter
+ | local reference cap3 leaks into outer capture set of type parameter T of method local