Treat result of by-name closures as inferred

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -117,14 +117,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  where the closure's type is the target type of the expression (FunctionN, unless
    *  otherwise specified).
    */
-  def Closure(meth: TermSymbol, rhsFn: List[List[Tree]] => Tree, targs: List[Tree] = Nil, targetType: Type = NoType)(using Context): Block = {
-    val targetTpt = if (targetType.exists) TypeTree(targetType) else EmptyTree
+  def Closure(meth: TermSymbol, rhsFn: List[List[Tree]] => Tree, targs: List[Tree] = Nil, targetType: Type = NoType, inferred: Boolean = false)(using Context): Block = {
+    val targetTpt = if (targetType.exists) TypeTree(targetType, inferred) else EmptyTree
     val call =
       if (targs.isEmpty) Ident(TermRef(NoPrefix, meth))
       else TypeApply(Ident(TermRef(NoPrefix, meth)), targs)
-    Block(
-      DefDef(meth, rhsFn) :: Nil,
-      Closure(Nil, call, targetTpt))
+    var mdef = DefDef(meth, rhsFn)
+    if inferred then mdef = cpy.DefDef(mdef)(tpt = TypeTree(mdef.tpt.tpe, inferred))
+    Block(mdef :: Nil, Closure(Nil, call, targetTpt))
   }
 
   /** A closure whose anonymous function has the given method type */

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

@@ -68,7 +68,6 @@ object CheckCaptures:
    */
   final class SubstParamsMap(from: BindingType, to: List[Type])(using Context)
   extends ApproximatingTypeMap, IdempotentCaptRefMap:
-
     def apply(tp: Type): Type =
       tp match
         case tp: ParamRef =>

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

@@ -102,7 +102,8 @@ class ElimByName extends MiniPhase, InfoTransformer:
     val meth = newAnonFun(ctx.owner, MethodType(Nil, argType), coord = arg.span)
     Closure(meth,
         _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase),
-        targetType = defn.ByNameFunction(argType)
+        targetType = defn.ByNameFunction(argType),
+        inferred = true
       ).withSpan(arg.span)
 
   private def isByNameRef(tree: Tree)(using Context): Boolean =

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

@@ -1,12 +1,24 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:10:6 ----------------------------------------
-10 |  h(f2()) // error
-   |    ^^^^
-   |    Found:    (x$0: Int) ->{cap1} Int
-   |    Required: (x$0: Int) ->{cap2} Int
-   |
-   | longer explanation available when compiling with `-explain`
 -- 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
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:4:2 -----------------------------------------
+ 4 |  def f() = if cap1 == cap1 then g else g // error
+   |  ^
+   |  Found:    (x$0: Int) ->{cap2} Int
+   |  Required: (x$0: Int) -> Int
+   |
+   |  Note that the expected type Int => Int
+   |  is the previously inferred result type of method test
+   |  which is also the type seen in separately compiled sources.
+   |  The new inferred type (x$0: Int) ->{cap2} Int
+   |  must conform to this type.
+ 5 |  def g(x: Int) = if cap2 == cap2 then 1 else x
+ 6 |  def g2(x: Int) = if cap1 == cap1 then 1 else x
+ 7 |  def f2() = if cap1 == cap1 then g2 else g2
+ 8 |  def h(ff: => Int ->{cap2} Int) = ff
+ 9 |  h(f())
+10 |  h(f2())
+   |
+   | longer explanation available when compiling with `-explain`

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

@@ -1,13 +1,13 @@
 @annotation.capability class Cap
 
 def test(cap1: Cap, cap2: Cap) =
-  def f() = if cap1 == cap1 then g else g
+  def f() = if cap1 == cap1 then g else g // error
   def g(x: Int) = if cap2 == cap2 then 1 else x
   def g2(x: Int) = if cap1 == cap1 then 1 else x
   def f2() = if cap1 == cap1 then g2 else g2
   def h(ff: => Int ->{cap2} Int) = ff
-  h(f())  // ok
-  h(f2()) // error
+  h(f())
+  h(f2())
 
 class I
 

tests/pos/invariant-cc.scala

@@ -5,7 +5,14 @@ trait IterableFactory[+CC[_]] extends Pure:
 
   def fill[A](n: Int)(elem: => A): CC[A]^{elem} = ???
   def fill[A](n1: Int, n2: Int)(elem: => A): CC[(CC[A]^{elem}) @uncheckedVariance]^{elem} =
-  	fill[CC[A]^{elem}](n1)(fill(n2)(elem)) // !!! explicit type argument required under cc
-  	// fill(n1)(fill(n2)(elem)) // !!! does not currently work
+  	fill[CC[A]^{elem}](n1)(fill(n2)(elem))
+  	fill(n1)(fill(n2)(elem))
+
+  def fill2[A](n: Int)(elem: () => A): CC[A]^{elem} = ???
+  def fill2[A](n1: Int, n2: Int)(elem: () => A): CC[(CC[A]^{elem}) @uncheckedVariance]^{elem} =
+  	fill2[CC[A]^{elem}](n1)(() => fill2(n2)(elem))
+  	fill2(n1)(() => fill2(n2)(elem))
+
+