Compute union switch-arm pattern type from the case symbol in the parser

The emitter previously derived the C# `value switch` pattern type by
stripping a trailing `?` character from the case's fully-qualified name —
a stringly-typed shortcut that relied on the `SymbolDisplayFormat` spelling
of `Nullable<T>` always ending in `?` and would silently produce a
malformed identifier for any FQN that did not. Reviewer feedback flagged
this as unsafe.

Move the decision to the parser, where the actual `ITypeSymbol` is in
scope. `UnionCaseSpec` gains a `PatternType : TypeRef` property which is

* `Nullable<T>.TypeArguments[0]` (the underlying `T`) for value-type
  `Nullable<T>` cases, and
* `CaseType` for everything else.

The emitter just reads `caseSpec.PatternType.FullyQualifiedName`; the
`GetPatternTypeFullyQualifiedName` helper is deleted. Snapshot output is
byte-identical (`StringOrIntUnion` baseline still matches), all four test
suites stay at the same counts.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: eiriktsarpalis

src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs

@@ -677,7 +677,7 @@ private static SourceText GenerateForUnion(ContextGenerationSpec contextSpec, Ty
                             continue;
                         }
 
-                        string patternTypeFQN = GetPatternTypeFullyQualifiedName(caseSpec);
+                        string patternTypeFQN = caseSpec.PatternType.FullyQualifiedName;
                         writer.WriteLine($"{patternTypeFQN} caseValue{ctorArmIndex} => new {genericArg}(caseValue{ctorArmIndex}),");
                         ctorArmIndex++;
                     }
@@ -751,7 +751,7 @@ private static SourceText GenerateForUnion(ContextGenerationSpec contextSpec, Ty
                             continue;
                         }
 
-                        string patternTypeFQN = GetPatternTypeFullyQualifiedName(caseSpec);
+                        string patternTypeFQN = caseSpec.PatternType.FullyQualifiedName;
                         writer.WriteLine($"{patternTypeFQN} caseValue{deconArmIndex} => (typeof({caseSpec.CaseType.FullyQualifiedName}), (object?)caseValue{deconArmIndex}),");
                         deconArmIndex++;
                     }
@@ -784,26 +784,6 @@ private static SourceText GenerateForUnion(ContextGenerationSpec contextSpec, Ty
                 return CompleteSourceFileAndReturnText(writer);
             }
 
-            /// <summary>
-            /// Returns the type name to use in a <c>value switch</c> pattern. C# rejects
-            /// <c>Nullable&lt;T&gt;</c> (in any spelling — <c>T?</c>, <c>Nullable&lt;T&gt;</c>,
-            /// <c>System.Nullable&lt;T&gt;</c>) in a pattern with CS8116 and directs the user
-            /// to the underlying <c>T</c>. At runtime a boxed <c>Nullable&lt;T&gt;</c> with
-            /// HasValue=true is bit-identical to a boxed <c>T</c>, so the resulting arm
-            /// naturally covers the non-null payloads of both <c>Foo(T)</c> and
-            /// <c>Foo(Nullable&lt;T&gt;)</c> ctors.
-            /// </summary>
-            private static string GetPatternTypeFullyQualifiedName(UnionCaseSpec caseSpec)
-            {
-                string fqn = caseSpec.CaseType.FullyQualifiedName;
-                if (caseSpec.CaseType.SpecialType is SpecialType.System_Nullable_T && fqn.Length > 0 && fqn[fqn.Length - 1] == '?')
-                {
-                    return fqn.Substring(0, fqn.Length - 1);
-                }
-
-                return fqn;
-            }
-
             /// <summary>
             /// Formats the cast prefix used by the <c>null =&gt;</c> arm of the constructor
             /// switch (e.g. <c>(int?)</c>). For a Nullable&lt;T&gt; case the FQN already ends

src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs

@@ -749,9 +749,21 @@ private TypeGenerationSpec ParseTypeGenerationSpec(in TypeToGenerate typeToGener
                                     break;
                                 }
 
+                                TypeRef caseTypeRef = EnqueueType(caseType, typeToGenerate.Mode);
+
+                                // C# rejects Nullable<T> in `value switch` patterns (CS8116). The CLR layer
+                                // boxes a Nullable<T> with HasValue=true bit-identically to a boxed T, so the
+                                // generated pattern arm uses the underlying T symbol — never the source
+                                // Nullable<T> string spelling. Compute this from the symbol here so the
+                                // emitter never has to manipulate FQN strings.
+                                TypeRef patternTypeRef = caseType is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } nullableCaseType
+                                    ? new TypeRef(nullableCaseType.TypeArguments[0])
+                                    : caseTypeRef;
+
                                 resolvedUnionCaseSpecs.Add(new UnionCaseSpec
                                 {
-                                    CaseType = EnqueueType(caseType, typeToGenerate.Mode),
+                                    CaseType = caseTypeRef,
+                                    PatternType = patternTypeRef,
                                     IsNullable = acceptsNull,
                                     IsSwitchArm = switchArmRoles[i],
                                 });

src/libraries/System.Text.Json/gen/Model/UnionCaseSpec.cs

@@ -18,6 +18,17 @@ public sealed record UnionCaseSpec
     {
         public required TypeRef CaseType { get; init; }
 
+        /// <summary>
+        /// Type symbol used in the generated <c>value switch</c> arm pattern.
+        /// For a value-type <c>Nullable&lt;T&gt;</c> case this is the underlying
+        /// <c>T</c> (C# rejects <c>Nullable&lt;T&gt;</c> in a pattern with CS8116
+        /// — at the CLR layer a boxed <c>Nullable&lt;T&gt;</c> with HasValue=true
+        /// is bit-identical to a boxed <c>T</c>, so the underlying-type arm covers
+        /// both <c>Foo(T)</c> and <c>Foo(Nullable&lt;T&gt;)</c> non-null payloads).
+        /// For every other shape this equals <see cref="CaseType"/>.
+        /// </summary>
+        public required TypeRef PatternType { get; init; }
+
         public required bool IsNullable { get; init; }
 
         /// <summary>