Propagate expected type into blocks

The level checking should do the proper avoidance so that local symbols
would not leak into type variables of the expected type.

Author: odersky

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

@@ -376,25 +376,21 @@ abstract class Recheck extends Phase, SymTransformer:
       recheck(tree.rhs, lhsType.widen)
       defn.UnitType
 
-    private def recheckBlock(stats: List[Tree], expr: Tree)(using Context): Type =
+    private def recheckBlock(stats: List[Tree], expr: Tree, pt: Type)(using Context): Type =
       recheckStats(stats)
-      val exprType = recheck(expr)
+      val exprType = recheck(expr, pt)
       TypeOps.avoid(exprType, localSyms(stats).filterConserve(_.isTerm))
 
     def recheckBlock(tree: Block, pt: Type)(using Context): Type = tree match
-      case Block(Nil, expr: Block) => recheckBlock(expr, pt)
       case Block((mdef : DefDef) :: Nil, closure: Closure) =>
         recheckClosureBlock(mdef, closure.withSpan(tree.span), pt)
-      case Block(stats, expr) => recheckBlock(stats, expr)
-        // The expected type `pt` is not propagated. Doing so would allow variables in the
-        // expected type to contain references to local symbols of the block, so the
-        // local symbols could escape that way.
+      case Block(stats, expr) => recheckBlock(stats, expr, pt)
 
     def recheckClosureBlock(mdef: DefDef, expr: Closure, pt: Type)(using Context): Type =
-      recheckBlock(mdef :: Nil, expr)
+      recheckBlock(mdef :: Nil, expr, pt)
 
     def recheckInlined(tree: Inlined, pt: Type)(using Context): Type =
-      recheckBlock(tree.bindings, tree.expansion)(using inlineContext(tree))
+      recheckBlock(tree.bindings, tree.expansion, pt)(using inlineContext(tree))
 
     def recheckIf(tree: If, pt: Type)(using Context): Type =
       recheck(tree.cond, defn.BooleanType)

tests/neg-custom-args/captures/capt-test.scala

@@ -20,8 +20,8 @@ def handle[E <: Exception,  R <: Top](op: (CT[E] @retains[caps.cap.type]) => R)(
   catch case ex: E => handler(ex)
 
 def test: Unit =
-  val b = handle[Exception, () => Nothing] { // error // error
-    (x: CanThrow[Exception]) => () => raise(new Exception)(using x)
+  val b = handle[Exception, () => Nothing] { // error
+    (x: CanThrow[Exception]) => () => raise(new Exception)(using x)  // error
   } {
     (ex: Exception) => ???
   }

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

@@ -16,35 +16,31 @@
   |  Note that capability x is not included in capture set {}.
   |
   | 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
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:16:2 -----------------------------------------
+16 |  f  // error
    |  ^
    |  Found:    (y: Int) ->{x} Int
    |  Required: Matchable
    |
    |  Note that capability x is not included in capture set {}.
-16 |  f
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:22:2 -----------------------------------------
-22 |  class F(y: Int) extends A:   // error
-   |  ^
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:24:2 -----------------------------------------
+24 |  F(22)  // error
+   |  ^^^^^
    |  Found:    A^{x}
    |  Required: A
    |
    |  Note that capability x is not included in capture set {}.
-23 |    def m() = if x == null then y else y
-24 |  F(22)
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:27:2 -----------------------------------------
-27 |  new A: // error
-   |  ^
-   |  Found:    A^{x}
-   |  Required: A
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:28:40 ----------------------------------------
+28 |    def m() = if x == null then y else y  // error
+   |                                        ^
+   |                                        Found:    A^{x}
+   |                                        Required: A
    |
-   |  Note that capability x is not included in capture set {}.
-28 |    def m() = if x == null then y else y
+   |                                        Note that capability x is not included in capture set {}.
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/capt1.scala:36:16 -------------------------------------------------------------

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

@@ -12,20 +12,20 @@ def h1(x: C @retains[caps.cap.type], y: C): Any =
   () => f()  // ok
 
 def h2(x: C @retains[caps.cap.type]): Matchable =
-  def f(y: Int) = if x == null then y else y  // error
-  f
+  def f(y: Int) = if x == null then y else y
+  f  // error
 
 class A
 type Cap = C @retains[caps.cap.type]
 
 def h3(x: Cap): A =
-  class F(y: Int) extends A:   // error
+  class F(y: Int) extends A:
     def m() = if x == null then y else y
-  F(22)
+  F(22)  // error
 
 def h4(x: Cap, y: Int): A =
-  new A: // error
-    def m() = if x == null then y else y
+  new A:
+    def m() = if x == null then y else y  // error
 
 def f1(c: Cap): () ->{c} c.type = () => c // ok
 

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

@@ -7,3 +7,12 @@
   |         Note that capability f is not included in capture set {}.
   |
   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/eta.scala:7:7 --------------------------------------------
+7 |       () => { stowaway.apply().apply() }  // error (was ok)
+  |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |       Found:    () ->{stowaway} Unit
+  |       Required: () -> Unit
+  |
+  |       Note that capability stowaway is not included in capture set {}.
+  |
+  | longer explanation available when compiling with `-explain`

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

@@ -4,4 +4,4 @@
          g  // error
        val stowaway: () -> Proc^{f} =
          bar( () => f )  // was error now OK
-       () => { stowaway.apply().apply() }
+       () => { stowaway.apply().apply() }  // error (was ok)

tests/neg-custom-args/captures/heal-tparam-cs.check

@@ -1,6 +1,6 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/heal-tparam-cs.scala:10:23 -------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/heal-tparam-cs.scala:10:25 -------------------------------
 10 |  val test1 = localCap { c => // error
-   |                       ^
+   |                         ^
    |Found:    (c: Capp^'s1) ->'s2 () ->{c} Unit
    |Required: (c: Capp^) => () ->'s3 Unit
    |
@@ -9,7 +9,6 @@
    |where:    => refers to a fresh root capability created in value test1 when checking argument to parameter op of method localCap
    |          ^  refers to the universal root capability
 11 |    () => { c.use() }
-12 |  }
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/heal-tparam-cs.scala:15:13 -------------------------------

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

@@ -16,16 +16,21 @@
    |             Note that capability b is not included in capture set {}.
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i23207.scala:23:2 ----------------------------------------
-23 |  class B extends A:   // error, now we see the error for the whole block since there are no nested errors
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i23207.scala:19:2 ----------------------------------------
+19 |  c // error
    |  ^
-   |  Found:    A^{io}
+   |  Found:    A^{c}
    |  Required: A
    |
-   |  Note that capability io is not included in capture set {}.
-24 |    val hide: AnyRef^{io} = io
-25 |  val b = new B
-26 |  val c = b.getBox.x
-27 |  c
+   |  Note that capability c is not included in capture set {}.
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i23207.scala:27:2 ----------------------------------------
+27 |  c  // error
+   |  ^
+   |  Found:    A^{c}
+   |  Required: A
+   |
+   |  Note that capability c is not included in capture set {}.
    |
    | longer explanation available when compiling with `-explain`

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

@@ -16,13 +16,12 @@ def leak(io: AnyRef^): A =
   val c = b.getBox.x
   val _: B^{b} = c // ok
   val _: A = c // error
-  c // no error here since we don't propagate expected type into the last expression of a block
-    // and the whole block's span overlaps with previous errors
+  c // error
 
 def leak2(io: AnyRef^): A =
-  class B extends A:   // error, now we see the error for the whole block since there are no nested errors
+  class B extends A:
     val hide: AnyRef^{io} = io
 
   val b = new B
   val c = b.getBox.x
-  c
+  c  // error

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

@@ -1,29 +1,19 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:18:4 ------------------------------------
-18 |    final class Mapped extends LazyList[B]:  // error
-   |    ^
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:24:4 ------------------------------------
+24 |    new Mapped  // error
+   |    ^^^^^^^^^^
    |    Found:    LazyList[B^'s1]^{f, xs}
    |    Required: LazyList[B]^{f}
    |
    |    Note that capability xs is not included in capture set {f}.
-19 |      this: (Mapped^{xs, f}) =>
-20 |      def isEmpty = false
-21 |      def head: B = f(xs.head)
-22 |      def tail: LazyList[B]^{this} = xs.tail.map(f)
-23 |    new Mapped
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:27:4 ------------------------------------
-27 |    final class Mapped extends LazyList[B]:  // error
-   |    ^
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:33:4 ------------------------------------
+33 |    new Mapped  // error
+   |    ^^^^^^^^^^
    |    Found:    LazyList[B^'s2]^{f, xs}
    |    Required: LazyList[B]^{xs}
    |
    |    Note that capability f is not included in capture set {xs}.
-28 |      this: Mapped^{xs, f} =>
-29 |      def isEmpty = false
-30 |      def head: B = f(xs.head)
-31 |      def tail: LazyList[B]^{this} = xs.tail.map(f)
-32 |    new Mapped
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/lazylists2.scala:40:20 --------------------------------------------------------
@@ -34,22 +24,26 @@
 41 |      def tail: LazyList[B]^{this}= xs.tail.map(f) // error
    |                                                ^
    |         reference (f : A => B) is not included in the allowed capture set {xs} of the self type of class Mapped
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:45:4 ------------------------------------
-45 |    final class Mapped extends LazyList[B]:  // error
-   |    ^
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:51:4 ------------------------------------
+51 |    new Mapped  // error
+   |    ^^^^^^^^^^
    |    Found:    LazyList[B^'s3]^{f, xs}
    |    Required: LazyList[B]^{xs}
    |
    |    Note that capability f is not included in capture set {xs}.
-46 |      this: (Mapped^{xs, f}) =>
-47 |      def isEmpty = false
-48 |      def head: B = f(xs.head)
-49 |      def tail: LazyList[B]^{xs, f} = xs.tail.map(f)
-50 |    new Mapped
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/lazylists2.scala:60:10 --------------------------------------------------------
 60 |    class Mapped2 extends Mapped:  // error
    |    ^
    |    references {f, xs} are not all included in the allowed capture set {} of the self type of class Mapped2
 61 |      this: Mapped =>
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:62:4 ------------------------------------
+62 |    new Mapped2 // error
+   |    ^^^^^^^^^^^
+   |    Found:    LazyList[B^'s4]^{f, xs}
+   |    Required: LazyList[B]
+   |
+   |    Note that capability f is not included in capture set {}.
+   |
+   | longer explanation available when compiling with `-explain`