Refine Regex generator Results to ImmutableEquatableArray without diagnostics/locations

eiriktsarpalis · Copilot · eiriktsarpalis · commit 850a8ea53d83 · 2026-03-10T21:34:04.000+02:00
- Remove unrelated base.runtextpos change from RegexGenerator.Emitter.cs
- Move DiagnosticLocation, Tree, Analysis out of RegexMethod positional
  params so they don't participate in record equality
- Convert helpers Dictionary to ImmutableEquatableArray for value equality
- Build ImmutableEquatableArray&lt;ValueTuple&lt;...&gt;&gt; in Collect().Select() that
  contains only data needed for source emission (no Diagnostic or Location)
- Add ImmutableEquatableArray.cs and HashHelpers.cs to generator csproj

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs
@@ -1106,7 +1106,6 @@ bool EmitAnchors()
                                 noMatchFoundLabelNeeded = true;
                                 Goto(NoMatchFound);
                             }
-                            writer.WriteLine("base.runtextpos = pos;");
                         }
                         writer.WriteLine();
                         break;
diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs
@@ -214,15 +214,15 @@ regexPropertySymbol.SetMethod is not null ||
             var result = new RegexPatternAndSyntax(
                 regexType,
                 IsProperty: regexMemberSymbol is IPropertySymbol,
-                memberSyntax.GetLocation(),
                 regexMemberSymbol.Name,
                 memberSyntax.Modifiers.ToString(),
                 nullableRegex,
                 pattern,
                 regexOptions,
                 matchTimeout,
                 culture,
-                compilationData);
+                compilationData)
+            { DiagnosticLocation = memberSyntax.GetLocation() };
 
             RegexType current = regexType;
             var parent = typeDec.Parent as TypeDeclarationSyntax;
@@ -249,11 +249,21 @@ SyntaxKind.RecordStructDeclaration or
         }
 
         /// <summary>Data about a regex directly from the GeneratedRegex attribute.</summary>
-        internal sealed record RegexPatternAndSyntax(RegexType DeclaringType, bool IsProperty, Location DiagnosticLocation, string MemberName, string Modifiers, bool NullableRegex, string Pattern, RegexOptions Options, int? MatchTimeout, CultureInfo Culture, CompilationData CompilationData);
+        internal sealed record RegexPatternAndSyntax(RegexType DeclaringType, bool IsProperty, string MemberName, string Modifiers, bool NullableRegex, string Pattern, RegexOptions Options, int? MatchTimeout, CultureInfo Culture, CompilationData CompilationData)
+        {
+            /// <summary>Location for diagnostic reporting. Not part of record equality.</summary>
+            public Location DiagnosticLocation { get; init; } = Location.None;
+        }
 
         /// <summary>Data about a regex, including a fully parsed RegexTree and subsequent analysis.</summary>
-        internal sealed record RegexMethod(RegexType DeclaringType, bool IsProperty, Location DiagnosticLocation, string MemberName, string Modifiers, bool NullableRegex, string Pattern, RegexOptions Options, int? MatchTimeout, RegexTree Tree, AnalysisResults Analysis, CompilationData CompilationData)
+        internal sealed record RegexMethod(RegexType DeclaringType, bool IsProperty, string MemberName, string Modifiers, bool NullableRegex, string Pattern, RegexOptions Options, int? MatchTimeout, CompilationData CompilationData)
         {
+            /// <summary>Location for diagnostic reporting. Not part of record equality.</summary>
+            public Location DiagnosticLocation { get; init; } = Location.None;
+            /// <summary>Parsed regex tree. Not part of record equality.</summary>
+            public RegexTree Tree { get; init; } = null!;
+            /// <summary>Analysis results from the regex tree. Not part of record equality.</summary>
+            public AnalysisResults Analysis { get; init; } = null!;
             public string? GeneratedName { get; set; }
             public bool IsDuplicate { get; set; }
         }
diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using SourceGenerators;
 
 [assembly: System.Resources.NeutralResourcesLanguage("en-us")]
 
@@ -77,7 +78,12 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                         {
                             RegexTree regexTree = RegexParser.Parse(method.Pattern, method.Options | RegexOptions.Compiled, method.Culture); // make sure Compiled is included to get all optimizations applied to it
                             AnalysisResults analysis = RegexTreeAnalyzer.Analyze(regexTree);
-                            return new RegexMethod(method.DeclaringType, method.IsProperty, method.DiagnosticLocation, method.MemberName, method.Modifiers, method.NullableRegex, method.Pattern, method.Options, method.MatchTimeout, regexTree, analysis, method.CompilationData);
+                            return new RegexMethod(method.DeclaringType, method.IsProperty, method.MemberName, method.Modifiers, method.NullableRegex, method.Pattern, method.Options, method.MatchTimeout, method.CompilationData)
+                            {
+                                DiagnosticLocation = method.DiagnosticLocation,
+                                Tree = regexTree,
+                                Analysis = analysis,
+                            };
                         }
                         catch (Exception e)
                         {
@@ -101,7 +107,12 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     // We'll still output a limited implementation that just caches a new Regex(...).
                     if (!SupportsCodeGeneration(regexMethod, regexMethod.CompilationData.LanguageVersion, out string? reason))
                     {
-                        return (regexMethod, reason, Diagnostic.Create(DiagnosticDescriptors.LimitedSourceGeneration, regexMethod.DiagnosticLocation), regexMethod.CompilationData);
+                        return (object)(
+                            regexMethod,
+                            (string?)null,
+                            (string?)reason,
+                            ImmutableEquatableArray<(string, ImmutableEquatableArray<string>)>.Empty,
+                            (Diagnostic?)Diagnostic.Create(DiagnosticDescriptors.LimitedSourceGeneration, regexMethod.DiagnosticLocation));
                     }
 
                     // Generate the core logic for the regex.
@@ -112,35 +123,51 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     writer.WriteLine();
                     EmitRegexDerivedTypeRunnerFactory(writer, regexMethod, requiredHelpers, regexMethod.CompilationData.CheckOverflow);
                     writer.Indent -= 2;
-                    return (regexMethod, sw.ToString(), requiredHelpers, regexMethod.CompilationData);
+
+                    // Convert helpers to an equatable form for the incremental pipeline.
+                    var equatableHelpers = requiredHelpers
+                        .OrderBy(h => h.Key, StringComparer.Ordinal)
+                        .Select(h => (h.Key, h.Value.ToImmutableEquatableArray()))
+                        .ToImmutableEquatableArray();
+
+                    return (object)(regexMethod, (string?)sw.ToString(), (string?)null, equatableHelpers, (Diagnostic?)null);
                 })
 
                 // Combine all of the generated text outputs into a single batch, then split
                 // the source model from diagnostics so they can be emitted independently.
+                // The Results use ImmutableEquatableArray for deep value equality, ensuring the
+                // source output callback only fires when emitted code would actually change.
                 .Collect()
                 .Select(static (results, _) =>
                 {
                     ImmutableArray<Diagnostic>.Builder? diagnostics = null;
+                    var methods = new List<(RegexMethod Method, string? RunnerFactory, string? LimitedReason, ImmutableEquatableArray<(string Key, ImmutableEquatableArray<string> Lines)> Helpers)>();
 
                     foreach (object result in results)
                     {
                         if (result is Diagnostic d)
                         {
                             (diagnostics ??= ImmutableArray.CreateBuilder<Diagnostic>()).Add(d);
                         }
-                        else if (result is ValueTuple<RegexMethod, string, Diagnostic, CompilationData> limitedSupportResult)
+                        else if (result is ValueTuple<RegexMethod, string, string, ImmutableEquatableArray<(string, ImmutableEquatableArray<string>)>, Diagnostic> entry)
                         {
-                            (diagnostics ??= ImmutableArray.CreateBuilder<Diagnostic>()).Add(limitedSupportResult.Item3);
+                            methods.Add((entry.Item1, entry.Item2, entry.Item3, entry.Item4));
+                            if (entry.Item5 is Diagnostic diag)
+                            {
+                                (diagnostics ??= ImmutableArray.CreateBuilder<Diagnostic>()).Add(diag);
+                            }
                         }
                     }
 
-                    return (Results: results, Diagnostics: diagnostics?.ToImmutable() ?? ImmutableArray<Diagnostic>.Empty);
+                    return (
+                        Results: methods.ToImmutableEquatableArray(),
+                        Diagnostics: diagnostics?.ToImmutable() ?? ImmutableArray<Diagnostic>.Empty);
                 });
 
-            // Project to just the source model for code generation.
+            // Project to just the equatable source model for code generation.
             context.RegisterSourceOutput(collected.Select(static (t, _) => t.Results), static (context, results) =>
             {
-                if (results.All(static r => r is Diagnostic))
+                if (results.Count == 0)
                 {
                     return;
                 }
@@ -170,48 +197,34 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 // pair is the implementation used for the key.
                 var emittedExpressions = new Dictionary<(string Pattern, RegexOptions Options, int? Timeout), RegexMethod>();
 
-                // If we have any (RegexMethod regexMethod, string generatedName, string reason, Diagnostic diagnostic), these are regexes for which we have
-                // limited support and need to simply output boilerplate.
-                // If we have any (RegexMethod regexMethod, string generatedName, string runnerFactoryImplementation, Dictionary<string, string[]> requiredHelpers),
-                // those are generated implementations to be emitted.  We need to gather up their required helpers.
-                Dictionary<string, string[]> requiredHelpers = new();
-                foreach (object? result in results)
+                // Gather required helpers from all regex methods with full implementations.
+                var requiredHelpers = new Dictionary<string, ImmutableEquatableArray<string>>();
+                foreach ((RegexMethod method, string? runnerFactory, string? limitedReason, ImmutableEquatableArray<(string Key, ImmutableEquatableArray<string> Lines)> helpers) in results)
                 {
-                    RegexMethod? regexMethod = null;
-                    if (result is ValueTuple<RegexMethod, string, Diagnostic, CompilationData> limitedSupportResult)
+                    var key = (method.Pattern, method.Options, method.MatchTimeout);
+                    if (emittedExpressions.TryGetValue(key, out RegexMethod? implementation))
                     {
-                        regexMethod = limitedSupportResult.Item1;
+                        method.IsDuplicate = true;
+                        method.GeneratedName = implementation.GeneratedName;
                     }
-                    else if (result is ValueTuple<RegexMethod, string, Dictionary<string, string[]>, CompilationData> regexImpl)
+                    else
                     {
-                        foreach (KeyValuePair<string, string[]> helper in regexImpl.Item3)
-                        {
-                            if (!requiredHelpers.ContainsKey(helper.Key))
-                            {
-                                requiredHelpers.Add(helper.Key, helper.Value);
-                            }
-                        }
-
-                        regexMethod = regexImpl.Item1;
+                        method.IsDuplicate = false;
+                        method.GeneratedName = $"{method.MemberName}_{id++}";
+                        emittedExpressions.Add(key, method);
                     }
 
-                    if (regexMethod is not null)
+                    EmitRegexPartialMethod(method, writer);
+                    writer.WriteLine();
+
+                    foreach ((string helperKey, ImmutableEquatableArray<string> helperLines) in helpers)
                     {
-                        var key = (regexMethod.Pattern, regexMethod.Options, regexMethod.MatchTimeout);
-                        if (emittedExpressions.TryGetValue(key, out RegexMethod? implementation))
-                        {
-                            regexMethod.IsDuplicate = true;
-                            regexMethod.GeneratedName = implementation.GeneratedName;
-                        }
-                        else
+#pragma warning disable CA1864 // Prefer Dictionary.TryAdd -- not available on netstandard2.0
+                        if (!requiredHelpers.ContainsKey(helperKey))
                         {
-                            regexMethod.IsDuplicate = false;
-                            regexMethod.GeneratedName = $"{regexMethod.MemberName}_{id++}";
-                            emittedExpressions.Add(key, regexMethod);
+                            requiredHelpers.Add(helperKey, helperLines);
                         }
-
-                        EmitRegexPartialMethod(regexMethod, writer);
-                        writer.WriteLine();
+#pragma warning restore CA1864
                     }
                 }
 
@@ -237,21 +250,18 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
                 // Emit each Regex-derived type.
                 writer.Indent++;
-                foreach (object? result in results)
+                foreach ((RegexMethod method, string? runnerFactory, string? limitedReason, _) in results)
                 {
-                    if (result is ValueTuple<RegexMethod, string, Diagnostic, CompilationData> limitedSupportResult)
+                    if (!method.IsDuplicate)
                     {
-                        if (!limitedSupportResult.Item1.IsDuplicate)
+                        if (limitedReason is not null)
                         {
-                            EmitRegexLimitedBoilerplate(writer, limitedSupportResult.Item1, limitedSupportResult.Item2, limitedSupportResult.Item4.LanguageVersion);
+                            EmitRegexLimitedBoilerplate(writer, method, limitedReason, method.CompilationData.LanguageVersion);
                             writer.WriteLine();
                         }
-                    }
-                    else if (result is ValueTuple<RegexMethod, string, Dictionary<string, string[]>, CompilationData> regexImpl)
-                    {
-                        if (!regexImpl.Item1.IsDuplicate)
+                        else if (runnerFactory is not null)
                         {
-                            EmitRegexDerivedImplementation(writer, regexImpl.Item1, regexImpl.Item2, regexImpl.Item4.AllowUnsafe);
+                            EmitRegexDerivedImplementation(writer, method, runnerFactory, method.CompilationData.AllowUnsafe);
                             writer.WriteLine();
                         }
                     }
@@ -268,7 +278,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     writer.WriteLine($"{{");
                     writer.Indent++;
                     bool sawFirst = false;
-                    foreach (KeyValuePair<string, string[]> helper in requiredHelpers.OrderBy(h => h.Key, StringComparer.Ordinal))
+                    foreach (KeyValuePair<string, ImmutableEquatableArray<string>> helper in requiredHelpers.OrderBy(h => h.Key, StringComparer.Ordinal))
                     {
                         if (sawFirst)
                         {
diff --git a/src/libraries/System.Text.RegularExpressions/gen/System.Text.RegularExpressions.Generator.csproj b/src/libraries/System.Text.RegularExpressions/gen/System.Text.RegularExpressions.Generator.csproj
@@ -26,6 +26,8 @@
     <Compile Include="$(CommonPath)Roslyn\DiagnosticDescriptorHelper.cs" Link="Common\Roslyn\DiagnosticDescriptorHelper.cs" />
     <Compile Include="$(CommonPath)Roslyn\GetBestTypeByMetadataName.cs" Link="Common\Roslyn\GetBestTypeByMetadataName.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Runtime\CompilerServices\IsExternalInit.cs" Link="Common\System\Runtime\CompilerServices\IsExternalInit.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Numerics\Hashing\HashHelpers.cs" Link="Common\System\Numerics\Hashing\HashHelpers.cs" />
+    <Compile Include="$(CommonPath)SourceGenerators\ImmutableEquatableArray.cs" Link="Common\SourceGenerators\ImmutableEquatableArray.cs" />
 
     <!-- Code included from System.Text.RegularExpressions -->
     <Compile Include="$(CommonPath)System\HexConverter.cs" Link="Production\HexConverter.cs" />

Original file line number	Diff line number	Diff line change
`@@ -1106,7 +1106,6 @@ bool EmitAnchors()`
`1106`	`1106`	`noMatchFoundLabelNeeded = true;`
`1107`	`1107`	`Goto(NoMatchFound);`
`1108`	`1108`	`}`
`1109`		`- writer.WriteLine("base.runtextpos = pos;");`
`1110`	`1109`	`}`
`1111`	`1110`	`writer.WriteLine();`
`1112`	`1111`	`break;`