Redo handling of closures without relying on pre-existing maps

Author: odersky

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

@@ -33,7 +33,13 @@ object ccConfig:
   inline val allowUnsoundMaps = false
 
   /** If enabled, use a special path in recheckClosure for closures
-   *  that are eta expansions. This can improve some error messages.
+   *  to compare the result tpt of the anonymous functon with the expected
+   *  result type. This can narrow the scope of error messages.
+   */
+  inline val preTypeClosureResults = false
+
+  /** If this and `preTypeClosureResults` are both enabled, disable `preTypeClosureResults`
+   *  for eta expansions. This can improve some error messages.
    */
   inline val handleEtaExpansionsSpecially = true
 

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

@@ -318,7 +318,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  upper approximation.
      */
     private def interpolate(tp: Type, sym: Symbol, startingVariance: Int = 1)(using Context): Unit =
-    
+
       object variances extends TypeTraverser:
         variance = startingVariance
         val varianceOfVar = EqHashMap[CaptureSet.Var, Int]()
@@ -335,7 +335,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             traverse(rinfo)
           case _ =>
             traverseChildren(t)
-            
+
       val interpolator = new TypeTraverser:
         override def traverse(t: Type) = t match
           case t @ CapturingType(parent, refs) =>
@@ -349,7 +349,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             traverse(rinfo)
           case _ =>
             traverseChildren(t)
-      
+
       variances.traverse(tp)
       interpolator.traverse(tp)
     end interpolate
@@ -947,28 +947,51 @@ class CheckCaptures extends Recheck, SymTransformer:
      *      { def $anonfun(...) = ...; closure($anonfun, ...)}
      */
     override def recheckClosureBlock(mdef: DefDef, expr: Closure, pt: Type)(using Context): Type =
+
+      def matchParams(paramss: List[ParamClause], pt: Type): Unit =
+        //println(i"match $mdef against $pt")
+        paramss match
+        case params :: paramss1 => pt match
+          case defn.PolyFunctionOf(poly: PolyType) =>
+            assert(params.hasSameLengthAs(poly.paramInfos))
+            matchParams(paramss1, poly.instantiate(params.map(_.symbol.typeRef)))
+          case FunctionOrMethod(argTypes, resType) =>
+            assert(params.hasSameLengthAs(argTypes), i"$mdef vs $pt, ${params}")
+            for (argType, param) <- argTypes.lazyZip(params) do
+              //println(i"compare $argType against $param")
+              checkConformsExpr(argType, root.freshToCap(param.asInstanceOf[ValDef].tpt.nuType), param)
+            if ccConfig.preTypeClosureResults && !(isEtaExpansion(mdef) && ccConfig.handleEtaExpansionsSpecially) then
+              // Check whether the closure's result conforms to the expected type
+              // This constrains parameter types of the closure which can give better
+              // error messages.
+              // But if the closure is an eta expanded method reference it's better to not constrain
+              // its internals early since that would give error messages in generated code
+              // which are less intelligible. An example is the line `a = x` in
+              // neg-custom-args/captures/vars.scala. That's why this code is conditioned.
+              // to apply only to closures that are not eta expansions.
+              assert(paramss1.isEmpty)
+              val respt = root.resultToFresh:
+                pt match
+                  case defn.RefinedFunctionOf(rinfo) =>
+                    val paramTypes = params.map(_.asInstanceOf[ValDef].tpt.nuType)
+                    rinfo.instantiate(paramTypes)
+                  case _ =>
+                    resType
+              val res = root.resultToFresh(mdef.tpt.nuType)
+              // We need to open existentials here in order not to get vars mixed up in them
+              // We do the proper check with existentials when we are finished with the closure block.
+              capt.println(i"pre-check closure $expr of type $res against $respt")
+              checkConformsExpr(res, respt, expr)
+          case _ =>
+        case Nil =>
+
       openClosures = (mdef.symbol, pt) :: openClosures
+        // openClosures is needed for errors but currently makes no difference
+        // TODO follow up on this
       try
-        // Constrain closure's parameters and result from the expected type before
-        // rechecking the body.
-        val res = recheckClosure(expr, pt, forceDependent = true)
-        if !(isEtaExpansion(mdef) && ccConfig.handleEtaExpansionsSpecially) then
-          // Check whether the closure's results conforms to the expected type
-          // This constrains parameter types of the closure which can give better
-          // error messages.
-          // But if the closure is an eta expanded method reference it's better to not constrain
-          // its internals early since that would give error messages in generated code
-          // which are less intelligible. An example is the line `a = x` in
-          // neg-custom-args/captures/vars.scala. That's why this code is conditioned.
-          // to apply only to closures that are not eta expansions.
-          val res1 = root.resultToFresh(res) // TODO: why deep = true?
-          val pt1 = root.resultToFresh(pt)
-            // We need to open existentials here in order not to get vars mixed up in them
-            // We do the proper check with existentials when we are finished with the closure block.
-          capt.println(i"pre-check closure $expr of type $res1 against $pt1")
-          checkConformsExpr(res1, pt1, expr)
+        matchParams(mdef.paramss, pt)
         recheckDef(mdef, mdef.symbol)
-        res
+        recheckClosure(expr, pt, forceDependent = true)
       finally
         openClosures = openClosures.tail
     end recheckClosureBlock

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

@@ -21,6 +21,7 @@ import collection.mutable
 import CCState.*
 import dotty.tools.dotc.util.NoSourcePosition
 import CheckCaptures.CheckerAPI
+import NamerOps.methodType
 
 /** Operations accessed from CheckCaptures */
 trait SetupAPI:
@@ -704,6 +705,23 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         // If there's a change in the signature, update the info of `sym`
         if sym.exists && signatureChanges then
           val updatedInfo =
+            if ccConfig.newScheme then
+              def newInfo = root.toResultInResults(report.error(_, tree.srcPos)):
+                if sym.is(Method) then methodType(sym.paramSymss, localReturnType)
+                else tree.tpt.nuType
+              if tree.tpt.isInstanceOf[InferredTypeTree]
+                  && !sym.is(Param) && !sym.is(ParamAccessor)
+              then
+                val prevInfo = sym.info
+                new LazyType:
+                  def complete(denot: SymDenotation)(using Context) =
+                    assert(ctx.phase == thisPhase.next, i"$sym")
+                    capt.println(i"forcing $sym, printing = ${ctx.mode.is(Mode.Printing)}")
+                    sym.info = prevInfo // set info provisionally so we can analyze the symbol in recheck
+                    completeDef(tree, sym, this)
+                    sym.info = newInfo
+              else newInfo
+            else
               val newInfo =
                 root.toResultInResults(report.error(_, tree.srcPos)):
                   integrateRT(sym.info, sym.paramSymss, localReturnType, Nil, Nil)

tests/neg-custom-args/captures/box-adapt-boxing.scala

@@ -1,11 +1,11 @@
 trait Cap
 
 def main(io: Cap^, fs: Cap^): Unit = {
-  val test1: Unit -> Unit = _ => {
+  val test1: Unit -> Unit = _ => { // error
     type Op = [T] -> (T ->{io} Unit) -> Unit
     val f: (Cap^{io}) -> Unit = ???
     val op: Op = ???
-    op[Cap^{io}](f)   // error
+    op[Cap^{io}](f)
     // expected type of f: {io} (box {io} Cap) -> Unit
     // actual type: ({io} Cap) -> Unit
     // adapting f to the expected type will also

tests/neg-custom-args/captures/box-adapt-cases.check

@@ -8,7 +8,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/box-adapt-cases.scala:15:10 ------------------------------
 15 |  x.value(cap => cap.use())  // error
    |          ^^^^^^^^^^^^^^^^
-   |          Found:    (cap: box Cap^?) ->{io} Int
+   |          Found:    (cap: box Cap^{io}) ->{io} Int
    |          Required: (cap: box Cap^{io}) -> Int
    |
    | longer explanation available when compiling with `-explain`

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

@@ -6,17 +6,21 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:10:6 ----------------------------------------
 10 |  h(f2())  // error
    |    ^^^^
-   |    Found:    Int ->{cap1} Int
-   |    Required: Int ->? Int
+   |    Found:    () ?->{cap1} Int ->{cap1} Int
+   |    Required: () ?=> Int ->{cap2} Int
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/byname.scala:19:5 -------------------------------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:19:5 ----------------------------------------
 19 |  h(g()) // error
    |    ^^^
-   |    reference (cap2 : Cap) is not included in the allowed capture set {cap1}
-   |    of an enclosing function literal with expected type () ?->{cap1} I
--- Error: tests/neg-custom-args/captures/byname.scala:22:12 ------------------------------------------------------------
+   |    Found:    () ?->{cap2} I^?
+   |    Required: () ?->{cap1} I
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:22:5 ----------------------------------------
 22 |  h2(() => g())() // error
-   |           ^^^
-   |           reference (cap2 : Cap) is not included in the allowed capture set {cap1}
-   |           of an enclosing function literal with expected type () ->{cap1} I
+   |     ^^^^^^^^^
+   |     Found:    () ->{cap2} I^?
+   |     Required: () ->{cap1} I
+   |
+   | longer explanation available when compiling with `-explain`

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

@@ -1,13 +1,17 @@
--- Error: tests/neg-custom-args/captures/capt1.scala:5:11 --------------------------------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:5:2 ------------------------------------------
 5 |  () => if x == null then y else y  // error
-  |           ^
-  |           reference (x : C^) is not included in the allowed capture set {}
-  |           of an enclosing function literal with expected type () -> C
--- Error: tests/neg-custom-args/captures/capt1.scala:8:11 --------------------------------------------------------------
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  Found:    () ->{x} C^?
+  |  Required: () -> C
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:8:2 ------------------------------------------
 8 |  () => if x == null then y else y  // error
-  |           ^
-  |           reference (x : C^) is not included in the allowed capture set {}
-  |           of an enclosing function literal with expected type Matchable
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  Found:    () ->{x} C^?
+  |  Required: Matchable
+  |
+  | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:15:2 -----------------------------------------
 15 |  def f(y: Int) = if x == null then y else y  // error
    |  ^
@@ -38,11 +42,13 @@
    |             ^^^^^^^^^
    |             Type variable X of method h cannot be instantiated to () -> box C^ since
    |             the part box C^ of that type captures the root capability `cap`.
--- Error: tests/neg-custom-args/captures/capt1.scala:36:30 -------------------------------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:36:24 ----------------------------------------
 36 |  val z2 = h[() -> Cap](() => x) // error // error
-   |                              ^
-   |                              reference (x : C^) is not included in the allowed capture set {}
-   |                              of an enclosing function literal with expected type () -> box C^
+   |                        ^^^^^^^
+   |                        Found:    () ->{x} box C^{x}
+   |                        Required: () -> box C^
+   |
+   | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/capt1.scala:38:13 -------------------------------------------------------------
 38 |  val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // error
    |             ^^^^^^^^^^^^^^^^^^^^^^^

tests/neg-custom-args/captures/dcs-tvar.check

@@ -1,10 +1,10 @@
 -- Error: tests/neg-custom-args/captures/dcs-tvar.scala:6:15 -----------------------------------------------------------
 6 |  () => runOps(xs) // error
   |               ^^
-  |               reference xs* is not included in the allowed capture set {}
-  |               of an enclosing function literal with expected type () -> Unit
+  |               Local reach capability xs* leaks into capture scope of method f.
+  |               To allow this, the parameter xs should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/dcs-tvar.scala:9:15 -----------------------------------------------------------
 9 |  () => runOps(xs) // error
   |               ^^
-  |               reference xs* is not included in the allowed capture set {}
-  |               of an enclosing function literal with expected type () -> Unit
+  |               Local reach capability xs* leaks into capture scope of method g.
+  |               To allow this, the parameter xs should be declared with a @use annotation

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

@@ -1,13 +1,13 @@
 -- Error: tests/neg-custom-args/captures/delayedRunops.scala:17:13 -----------------------------------------------------
 17 |      runOps(ops1)  // error
    |             ^^^^
-   |             reference ops* is not included in the allowed capture set {}
-   |             of an enclosing function literal with expected type () -> Unit
+   |             Local reach capability ops* leaks into capture scope of method delayedRunOps1.
+   |             To allow this, the parameter ops should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/delayedRunops.scala:29:13 -----------------------------------------------------
 29 |      runOps(ops1)  // error
    |             ^^^^
-   |             reference ops* is not included in the allowed capture set {}
-   |             of an enclosing function literal with expected type () -> Unit
+   |             Local reach capability ops* leaks into capture scope of method delayedRunOps3.
+   |             To allow this, the parameter ops should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/delayedRunops.scala:22:16 -----------------------------------------------------
 22 |      val ops1: List[() => Unit] = ops // error
    |                ^^^^^^^^^^^^^^^^

tests/neg-custom-args/captures/depfun-reach.check

@@ -1,3 +1,10 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/depfun-reach.scala:12:27 ---------------------------------
+12 |    List(() => op.foreach((f,g) => { f(); g() })) // error (???)
+   |                           ^^^^^^^^^^^^^^^^^^^^
+   |                           Found:    (x$1: (box () ->? Unit, box () ->? Unit)^?) ->? Unit
+   |                           Required: (x$1: (box () ->{op*} Unit, box () ->{op*} Unit)) => Unit
+   |
+   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/depfun-reach.scala:19:4 ----------------------------------
 19 |    op // error
    |    ^^