Fix access to hoisted variables from reductions

src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Statements.cs

@@ -100,7 +100,7 @@ private void EnterScope(object node)
                     // User-created blocks will never hit this case; only our
                     // internally reduced nodes will.
                     //
-                    scope = new CompilerScope(node, false) { NeedsClosure = _scope.NeedsClosure };
+                    scope = new CompilerScope(node, false) { NeedsClosure = true };
                 }
 
                 _scope = scope.Enter(this, _scope);

src/libraries/System.Linq.Expressions/tests/Switch/SwitchTests.cs

@@ -951,6 +951,44 @@ public void SwitchOnStringEqualsMethod(bool useInterpreter)
             }
         }
 
+        [Theory, ClassData(typeof(CompilationTypes))]
+        public void SwitchOnStringWithAccessToLambdaHoistedVariables(bool useInterpreter)
+        {
+            ParameterExpression arg0 = Expression.Parameter(typeof(string), "value");
+
+            // f1 = (Func<int> f) => f();
+            ParameterExpression arg1 = Expression.Parameter(typeof(Func<int>), "f");
+            Expression<Func<Func<int>, int>> expr1 =
+                Expression.Lambda<Func<Func<int>, int>>(
+                    body: Expression.Invoke(arg1),
+                    parameters: new[] { arg1 });
+
+            // f2 = () => value.Length;
+            Expression<Func<int>> expr2 =
+                Expression.Lambda<Func<int>>(
+                    Expression.Property(arg0, typeof(string).GetProperty("Length")));
+
+            // f0 = (string value) => value switch { "1" => 1, ..., "7" => 7, _ => f1(f2) };
+            Expression<Func<string, int>> expr0 =
+                Expression.Lambda<Func<string, int>>(
+                    body: Expression.Switch(
+                        switchValue: arg0,
+                        defaultBody: Expression.Invoke(expr1, expr2),
+                        cases: Enumerable.Range(1, 7).Select(index =>
+                            Expression.SwitchCase(Expression.Constant(index), Expression.Constant(index.ToString()))).ToArray()),
+                    parameters: new[] { arg0 });
+
+            Func<string, int> f0 = expr0.Compile(useInterpreter);
+            Assert.Equal(1, f0("1"));
+            Assert.Equal(2, f0("2"));
+            Assert.Equal(3, f0("3"));
+            Assert.Equal(4, f0("4"));
+            Assert.Equal(5, f0("5"));
+            Assert.Equal(6, f0("6"));
+            Assert.Equal(7, f0("7"));
+            Assert.Equal(2, f0("10"));
+        }
+
         [Fact]
         public void ToStringTest()
         {

src/libraries/System.Linq.Expressions/tests/TypeBinary/TypeEqual.cs

@@ -196,6 +196,24 @@ public void TypeEqualConstant(Type type, bool useInterpreter)
             Assert.False(isNullOfType());
         }
 
+        [Theory, ClassData(typeof(CompilationTypes))]
+        public void TypeEqualConstantWithAccessToLambdaHoistedVariables(bool useInterpreter)
+        {
+            ParameterExpression arg0 = Expression.Parameter(typeof(object), "value");
+
+            // f1 = () => value;
+            Expression<Func<object>> expr1 = Expression.Lambda<Func<object>>(arg0);
+
+            // f0 = (object value) => (() => value) is int;
+            Expression<Func<object, bool>> expr0 = Expression.Lambda<Func<object, bool>>(
+                Expression.TypeEqual(
+                    expr1,
+                    typeof(int)),
+                parameters: new[] { arg0 });
+            Func<object, bool> f0 = expr0.Compile(useInterpreter);
+            Assert.False(f0(null));
+        }
+
         [Fact]
         public void ToStringTest()
         {