Copy escape scope of pattern locals from source expressions

docs/compilers/CSharp/Compiler Breaking Changes - post VS2017.md

@@ -131,4 +131,5 @@ Example:
 - Visual Studio 2017 version 15.8: https://github.com/dotnet/roslyn/issues/22455 C# compiler will now produce errors if there was an "in" or an "out" argument to an "__arglist" call. "out" was always allowed, and "in" was introduced in 15.5.
 - Visual Studio 2017 version 15.8: https://github.com/dotnet/roslyn/issues/26418 C# compiler will now produce errors on out variable declarations that have "ref" or "ref readonly" ref kinds. Example: M(out ref int x);
 - Visual Studio 2017 version 15.8: https://github.com/dotnet/roslyn/issues/27047 The C# compiler will now produce diagnostics for operators marked as obsolete when they are used as part of a tuple comparison.
-- Visual Studio 2017 version 15.8: https://github.com/dotnet/roslyn/pull/27461 The method `LanguaguageVersionFacts.TryParse` is no longer an extension method.
+- Visual Studio 2017 version 15.8: https://github.com/dotnet/roslyn/pull/27461 The method `LanguaguageVersionFacts.TryParse` is no longer an extension method.
+- Visual Studio 2017 version 15.8: https://github.com/dotnet/roslyn/pull/27803 pattern matching now will produce errors when trying to return a stack bound value to an invalid escape scope.

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

@@ -27,7 +27,7 @@ private BoundExpression BindIsPatternExpression(IsPatternExpressionSyntax node,
                 }
             }
 
-            var pattern = BindPattern(node.Pattern, expressionType, hasErrors, diagnostics);
+            var pattern = BindPattern(expression, node.Pattern, expressionType, hasErrors, diagnostics);
             if (!hasErrors && pattern is BoundDeclarationPattern p && !p.IsVar && expression.ConstantValue == ConstantValue.Null)
             {
                 diagnostics.Add(ErrorCode.WRN_IsAlwaysFalse, node.Location, p.DeclaredType.Type);
@@ -38,6 +38,7 @@ private BoundExpression BindIsPatternExpression(IsPatternExpressionSyntax node,
         }
 
         internal BoundPattern BindPattern(
+            BoundExpression sourceExpression,
             PatternSyntax node,
             TypeSymbol operandType,
             bool hasErrors,
@@ -47,7 +48,7 @@ private BoundExpression BindIsPatternExpression(IsPatternExpressionSyntax node,
             {
                 case SyntaxKind.DeclarationPattern:
                     return BindDeclarationPattern(
-                        (DeclarationPatternSyntax)node, operandType, hasErrors, diagnostics);
+                        sourceExpression, (DeclarationPatternSyntax)node, operandType, hasErrors, diagnostics);
 
                 case SyntaxKind.ConstantPattern:
                     var constantPattern = (ConstantPatternSyntax)node;
@@ -234,6 +235,7 @@ internal BoundExpression ConvertPatternExpression(TypeSymbol inputType, CSharpSy
         }
 
         private BoundPattern BindDeclarationPattern(
+            BoundExpression sourceExpression,
             DeclarationPatternSyntax node,
             TypeSymbol operandType,
             bool hasErrors,
@@ -290,6 +292,7 @@ internal BoundExpression ConvertPatternExpression(TypeSymbol inputType, CSharpSy
                 }
 
                 localSymbol.SetType(declType);
+                localSymbol.SetValEscape(GetValEscape(sourceExpression, LocalScopeDepth));
 
                 // Check for variable declaration errors.
                 hasErrors |= localSymbol.ScopeBinder.ValidateDeclarationNameConflictsInScope(localSymbol, diagnostics);

src/Compilers/CSharp/Portable/Binder/PatternSwitchBinder.cs

@@ -260,7 +260,7 @@ internal override void BindPatternSwitchLabelForInference(CasePatternSwitchLabel
                     {
                         var matchLabelSyntax = (CasePatternSwitchLabelSyntax)node;
                         var pattern = sectionBinder.BindPattern(
-                            matchLabelSyntax.Pattern, SwitchGoverningType, node.HasErrors, diagnostics);
+                            SwitchGoverningExpression, matchLabelSyntax.Pattern, SwitchGoverningType, node.HasErrors, diagnostics);
                         return new BoundPatternSwitchLabel(node, label, pattern,
                             matchLabelSyntax.WhenClause != null ? sectionBinder.BindBooleanExpression(matchLabelSyntax.WhenClause.Condition, diagnostics) : null,
                             true, node.HasErrors);

src/Compilers/CSharp/Portable/Binder/SwitchBinder.cs

@@ -242,7 +242,7 @@ private void BuildSwitchLabels(SyntaxList<SwitchLabelSyntax> labelsSyntax, Binde
                         // bind the pattern, to cause its pattern variables to be inferred if necessary
                         var matchLabel = (CasePatternSwitchLabelSyntax)labelSyntax;
                         var pattern = sectionBinder.BindPattern(
-                            matchLabel.Pattern, SwitchGoverningType, labelSyntax.HasErrors, tempDiagnosticBag);
+                            SwitchGoverningExpression, matchLabel.Pattern, SwitchGoverningType, labelSyntax.HasErrors, tempDiagnosticBag);
                         break;
 
                     default:

src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests.cs

@@ -6503,5 +6503,56 @@ static bool Dummy(int x)
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_2, "int x1").WithArguments("declaration of expression variables in member initializers and queries", "7.3").WithLocation(9, 61)
                 );
         }
+
+        [Fact]
+        [WorkItem(27218, "https://github.com/dotnet/roslyn/issues/27218")]
+        public void IsPatternMatchingDoesNotCopyEscapeScopes()
+        {
+            CreateCompilationWithMscorlibAndSpan(@"
+using System;
+public class C
+{
+    public ref int M()
+    {
+        Span<int> outer = stackalloc int[100];
+        if (outer is Span<int> inner)
+        {
+            return ref inner[5];
+        }
+
+        throw null;
+    }
+}").VerifyDiagnostics(
+                // (10,24): error CS8352: Cannot use local 'inner' in this context because it may expose referenced variables outside of their declaration scope
+                //             return ref inner[5];
+                Diagnostic(ErrorCode.ERR_EscapeLocal, "inner").WithArguments("inner").WithLocation(10, 24));
+        }
+
+        [Fact]
+        [WorkItem(27218, "https://github.com/dotnet/roslyn/issues/27218")]
+        public void CasePatternMatchingDoesNotCopyEscapeScopes()
+        {
+            CreateCompilationWithMscorlibAndSpan(@"
+using System;
+public class C
+{
+    public ref int M()
+    {
+        Span<int> outer = stackalloc int[100];
+        switch (outer)
+        {
+            case Span<int> inner:
+            {
+                return ref inner[5];
+            }
+        }
+
+        throw null;
+    }
+}").VerifyDiagnostics(
+                // (12,28): error CS8352: Cannot use local 'inner' in this context because it may expose referenced variables outside of their declaration scope
+                //                 return ref inner[5];
+                Diagnostic(ErrorCode.ERR_EscapeLocal, "inner").WithArguments("inner").WithLocation(12, 28));
+        }
     }
 }