Don't interpolate parameters of anonymous functions

Here, we should wait until we get the info from the outside, which can
be arbitrarily much later.

Author: odersky

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

@@ -234,6 +234,9 @@ abstract class Recheck extends Phase, IdentityDenotTransformer:
     def recheckBlock(stats: List[Tree], expr: Tree, pt: Type)(using Context): Type =
       recheckStats(stats)
       val exprType = recheck(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.
       TypeOps.avoid(exprType, localSyms(stats).filterConserve(_.isTerm))
 
     def recheckBlock(tree: Block, pt: Type)(using Context): Type =

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

@@ -203,11 +203,11 @@ class CheckCaptures extends Recheck:
         tp
     end transformType
 
-    private def interpolateVars(using Context) = new TypeTraverser:
+    private def interpolator(using Context) = new TypeTraverser:
       override def traverse(t: Type) =
         t match
           case CapturingType(parent, refs: CaptureSet.Var, _) =>
-            //if variance < 0 then println(i"solving $t")
+            if variance < 0 then capt.println(i"solving $t")
             refs.solve(variance)
             traverse(parent)
           case t @ RefinedType(_, nme.apply, rinfo) if defn.isFunctionOrPolyType(t) =>
@@ -220,8 +220,8 @@ class CheckCaptures extends Recheck:
 
     private def interpolateVarsIn(tpt: Tree)(using Context): Unit =
       if tpt.isInstanceOf[InferredTypeTree] then
-        //println(i"solving vars in ${knownType(tpt)}, ${knownType(tpt).toString}")
-        interpolateVars.traverse(knownType(tpt))
+        interpolator.traverse(knownType(tpt))
+          .showing(i"solved vars in ${knownType(tpt)}", capt)
 
     private var curEnv: Env = Env(NoSymbol, CaptureSet.empty, false, null)
 
@@ -289,7 +289,13 @@ class CheckCaptures extends Recheck:
 
     override def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Unit =
       try super.recheckValDef(tree, sym)
-      finally interpolateVarsIn(tree.tpt)
+      finally
+        if !sym.is(Param) then
+          // parameters with inferred types belong to anonymous methods. We need to wait
+          // for more info from the context, so we cannot interpolate. Note that we cannot
+          // expect to have all necessary info available at the point where the anonymous
+          // function is compiled since we do not propagate expected types into blocks.
+          interpolateVarsIn(tree.tpt)
 
     override def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Unit =
       val saved = curEnv