Don't write false into _mightAssignSomething while scanning.

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BasePatternSwitchLocalRewriter.cs

@@ -151,12 +151,18 @@ public override BoundNode Visit(BoundNode node)
 
                 public override BoundNode VisitCall(BoundCall node)
                 {
-                    _mightAssignSomething =
+                    bool mightMutate =
                         // might be a call to a local function that assigns something
                         node.Method.MethodKind == MethodKind.LocalFunction ||
                         // or perhaps we are passing a variable by ref and mutating it that way
                         !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitCall(node);
+
+                    if (mightMutate)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitCall(node);
+
+                    return null;
                 }
 
                 public override BoundNode VisitAssignmentOperator(BoundAssignmentOperator node)
@@ -186,41 +192,65 @@ public override BoundNode VisitIncrementOperator(BoundIncrementOperator node)
                 public override BoundNode VisitDynamicInvocation(BoundDynamicInvocation node)
                 {
                     // perhaps we are passing a variable by ref and mutating it that way
-                    _mightAssignSomething = !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitDynamicInvocation(node);
+                    if (!node.ArgumentRefKindsOpt.IsDefault)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitDynamicInvocation(node);
+
+                    return null;
                 }
 
                 public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
                 {
                     // perhaps we are passing a variable by ref and mutating it that way
-                    _mightAssignSomething = !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitObjectCreationExpression(node);
+                    if (!node.ArgumentRefKindsOpt.IsDefault)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitObjectCreationExpression(node);
+
+                    return null;
                 }
 
                 public override BoundNode VisitDynamicObjectCreationExpression(BoundDynamicObjectCreationExpression node)
                 {
-                    _mightAssignSomething = !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitDynamicObjectCreationExpression(node);
+                    if (!node.ArgumentRefKindsOpt.IsDefault)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitDynamicObjectCreationExpression(node);
+
+                    return null;
                 }
 
                 public override BoundNode VisitObjectInitializerMember(BoundObjectInitializerMember node)
                 {
                     // Although ref indexers are not declarable in C#, they may be usable
-                    _mightAssignSomething = !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitObjectInitializerMember(node);
+                    if (!node.ArgumentRefKindsOpt.IsDefault)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitObjectInitializerMember(node);
+
+                    return null;
                 }
 
                 public override BoundNode VisitIndexerAccess(BoundIndexerAccess node)
                 {
                     // Although property arguments with ref indexers are not declarable in C#, they may be usable
-                    _mightAssignSomething = !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitIndexerAccess(node);
+                    if (!node.ArgumentRefKindsOpt.IsDefault)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitIndexerAccess(node);
+
+                    return null;
                 }
 
                 public override BoundNode VisitDynamicIndexerAccess(BoundDynamicIndexerAccess node)
                 {
-                    _mightAssignSomething = !node.ArgumentRefKindsOpt.IsDefault;
-                    return base.VisitDynamicIndexerAccess(node);
+                    if (!node.ArgumentRefKindsOpt.IsDefault)
+                        _mightAssignSomething = true;
+                    else
+                        base.VisitDynamicIndexerAccess(node);
+
+                    return null;
                 }
             }
 

src/Compilers/CSharp/Test/Emit/CodeGen/PatternTests.cs

@@ -1985,6 +1985,9 @@ static void Main()
         Console.Write(M4(1));
         Console.Write(M5(1));
         Console.Write(M6(1));
+        Console.Write(M7(1));
+        Console.Write(M8(1));
+        Console.Write(M9(1));
     }
     public static int M1(int x)
     {
@@ -2013,6 +2016,19 @@ public static int M6(int x)
         dynamic d = x;
         return x switch { _ when new Program(d, ref x).P => 1, 1 => 2, _ => 3 };
     }
+    public static int M7(int x)
+    {
+        return x switch { _ when new Program(ref x).P && new Program().P => 1, 1 => 2, _ => 3 };
+    }
+    public static int M8(int x)
+    {
+        dynamic d = x;
+        return x switch { _ when new Program(d, ref x).P && new Program().P => 1, 1 => 2, _ => 3 };
+    }
+    public static int M9(int x)
+    {
+        return x switch { _ when (x=100) == 1 => 1, 1 => 2, _ => 3 };
+    }
     Program() { }
     Program(ref int x) { x = 100; }
     Program(int a, ref int x) { x = 100; }
@@ -2021,7 +2037,7 @@ public static int M6(int x)
 ";
             var compilation = CreateCompilation(source, options: TestOptions.ReleaseExe, references: new[] { CSharpRef });
             compilation.VerifyDiagnostics();
-            var expectedOutput = @"222222";
+            var expectedOutput = @"222222222";
             var compVerifier = CompileAndVerify(compilation, expectedOutput: expectedOutput);
         }