Fix parsing of parenthesized type in switch arm (#81863)

Author: CyrusNajmabadi

docs/compilers/CSharp/Compiler Breaking Changes - DotNet 11.md

@@ -154,3 +154,22 @@ void M()
 ```
 
 See also https://github.com/dotnet/roslyn/issues/80954.
+
+## Parsing of 'with' within a switch-expression-arm
+
+***Introduced in Visual Studio 2026 version 18.4***
+
+See https://github.com/dotnet/roslyn/issues/81837 and https://github.com/dotnet/roslyn/pull/81863
+
+Previously, when seeing the following, the compiler would treat `(X.Y)when` as a cast-expression.  Specifically,
+casting the contextual identifier `when` to `(X.Y)`:  
+
+```c#
+x switch
+{
+    (X.Y) when
+}
+```
+
+This was undesirable, and meant a simple `when` check of the pattern (like `(X.Y) when a > b =>`) would not
+parse properly.  Now, this is treated as a constant pattern `(X.Y)` followed by a `when clause`.

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -12770,7 +12770,7 @@ private ExpressionSyntax ParseCastOrParenExpressionOrTuple()
             // expression?  Because look-ahead is cheap with our token stream, we check
             // to see if this "looks like" a cast (without constructing any parse trees)
             // to help us make the decision.
-            if (this.ScanCast())
+            if (this.ScanCast(forPattern: false, inSwitchArmPattern: false))
             {
                 if (!IsCurrentTokenQueryKeywordInQuery())
                 {
@@ -12848,8 +12848,10 @@ private TupleExpressionSyntax ParseTupleExpressionTail(SyntaxToken openParen, Ar
                 this.EatToken(SyntaxKind.CloseParenToken));
         }
 
-        private bool ScanCast(bool forPattern = false)
+        private bool ScanCast(bool forPattern, bool inSwitchArmPattern)
         {
+            Debug.Assert(!inSwitchArmPattern || forPattern, "Can't be in a switch arm without also being in a pattern");
+
             if (this.CurrentToken.Kind != SyntaxKind.OpenParenToken)
             {
                 return false;
@@ -12872,8 +12874,20 @@ private bool ScanCast(bool forPattern = false)
 
             if (forPattern && this.CurrentToken.Kind == SyntaxKind.IdentifierToken)
             {
-                // In a pattern, an identifier can follow a cast unless it's a binary pattern token.
-                return !isBinaryPattern();
+                // In a pattern we might have a cast of a constant, or the start of a legal pattern form.
+                //
+                // For example: `(A.B) and ...` should be treated not as a 'cast' of some variable 'and', but instead as
+                // a conjunctive pattern.
+                if (isBinaryPattern())
+                    return false;
+
+                // Similarly `(A.B) when` directly in a switch arm should be treated as the start of a `when` clause not
+                // a cast of a `when` variable when in a switch expression arm.  This matches the exact checking logic
+                // in IsValidPatternDesignation.
+                if (inSwitchArmPattern && this.CurrentToken.ContextualKind == SyntaxKind.WhenKeyword)
+                    return false;
+
+                return true;
             }
 
             switch (type)

src/Compilers/CSharp/Portable/Parser/LanguageParser_Patterns.cs

@@ -393,7 +393,7 @@ bool parsePropertyPatternClause([NotNullWhen(true)] out PropertyPatternClauseSyn
             bool looksLikeCast()
             {
                 using var _ = this.GetDisposableResetPoint(resetOnDispose: true);
-                return this.ScanCast(forPattern: true);
+                return this.ScanCast(forPattern: true, inSwitchArmPattern);
             }
         }
 
@@ -404,14 +404,16 @@ bool looksLikeCast()
                 : null;
         }
 
-        private bool IsValidPatternDesignation(bool whenIsKeyword)
+        private bool IsValidPatternDesignation(bool inSwitchArmPattern)
         {
             if (CurrentToken.Kind == SyntaxKind.IdentifierToken)
             {
                 switch (CurrentToken.ContextualKind)
                 {
                     case SyntaxKind.WhenKeyword:
-                        return !whenIsKeyword;
+                        // When directly in a switch arm, we *always* treat 'when' as a keyword starting the 'when
+                        // clause'.  In other patterns, we allow 'when' to be a normal designator.
+                        return !inSwitchArmPattern;
                     case SyntaxKind.AndKeyword:
                     case SyntaxKind.OrKeyword:
                         var tk = PeekToken(1).Kind;