Fix SYSLIB1045 code fixer generating duplicate MyRegex names across partial class declarations

danmoseley · Copilot · danmoseley · commit ca22fda0ef3a · 2026-02-20T22:24:55.000-07:00
When the BatchFixer applies multiple fixes concurrently, each fix sees the original compilation and independently picks the same first-available name. This causes CS0756 when two partial declarations of the same class both contain Regex calls that need fixing. The fix scans all partial declarations of the containing type for Regex call sites that would generate new property names, orders them deterministically (by file path, then position), and offsets the generated name by the current node's index in that list. Fixes #77409 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
diff --git a/src/libraries/System.Text.RegularExpressions/gen/UpgradeToGeneratedRegexCodeFixer.cs b/src/libraries/System.Text.RegularExpressions/gen/UpgradeToGeneratedRegexCodeFixer.cs
@@ -121,6 +121,21 @@ operation is not (IInvocationOperation or IObjectCreationOperation))
                 {
                     memberName = $"{DefaultRegexPropertyName}{memberCount++}";
                 }
+
+                // When the BatchFixer applies multiple fixes concurrently, each fix sees the
+                // original compilation and picks the same first-available name. To avoid
+                // duplicates, determine this node's position among all Regex call sites in
+                // the type that would generate new names, and offset accordingly.
+                int precedingCount = CountPrecedingRegexCallSites(
+                    typeSymbol, compilation, regexSymbol, nodeToFix, cancellationToken);
+                for (int i = 0; i < precedingCount; i++)
+                {
+                    memberName = $"{DefaultRegexPropertyName}{memberCount++}";
+                    while (GetAllMembers(typeSymbol).Any(m => m.Name == memberName))
+                    {
+                        memberName = $"{DefaultRegexPropertyName}{memberCount++}";
+                    }
+                }
             }
 
             // Add partial to all ancestors.
@@ -457,5 +472,73 @@ private static IEnumerable<ISymbol> GetAllMembers(INamedTypeSymbol typeSymbol)
                 }
             }
         }
+
+        /// <summary>
+        /// Counts how many Regex call sites in the same type (across all partial declarations)
+        /// appear before the given node in a deterministic order. This ensures that when the
+        /// BatchFixer applies fixes concurrently against the original compilation, each fix
+        /// picks a unique generated method name.
+        /// </summary>
+        private static int CountPrecedingRegexCallSites(
+            INamedTypeSymbol typeSymbol, Compilation compilation,
+            INamedTypeSymbol regexSymbol, SyntaxNode nodeToFix,
+            CancellationToken cancellationToken)
+        {
+            var callSites = new List<(string FilePath, int Position)>();
+
+            foreach (SyntaxReference syntaxRef in typeSymbol.DeclaringSyntaxReferences)
+            {
+                SyntaxNode declSyntax = syntaxRef.GetSyntax(cancellationToken);
+                SemanticModel declModel = compilation.GetSemanticModel(syntaxRef.SyntaxTree);
+
+                foreach (SyntaxNode descendant in declSyntax.DescendantNodes())
+                {
+                    if (descendant is not (InvocationExpressionSyntax or ObjectCreationExpressionSyntax or ImplicitObjectCreationExpressionSyntax))
+                    {
+                        continue;
+                    }
+
+                    // Skip call sites inside nested type declarations — they belong to
+                    // a different type and won't affect this type's generated names.
+                    if (descendant.Ancestors().Any(a => a is TypeDeclarationSyntax && a != declSyntax))
+                    {
+                        continue;
+                    }
+
+                    IOperation? op = declModel.GetOperation(descendant, cancellationToken);
+                    bool isRegexCall = op switch
+                    {
+                        IInvocationOperation inv => inv.TargetMethod.IsStatic &&
+                            SymbolEqualityComparer.Default.Equals(inv.TargetMethod.ContainingType, regexSymbol),
+                        IObjectCreationOperation create => SymbolEqualityComparer.Default.Equals(create.Type, regexSymbol),
+                        _ => false
+                    };
+
+                    if (isRegexCall)
+                    {
+                        callSites.Add((syntaxRef.SyntaxTree.FilePath ?? string.Empty, descendant.SpanStart));
+                    }
+                }
+            }
+
+            if (callSites.Count <= 1)
+            {
+                return 0;
+            }
+
+            callSites.Sort((a, b) =>
+            {
+                int cmp = StringComparer.Ordinal.Compare(a.FilePath, b.FilePath);
+                return cmp != 0 ? cmp : a.Position.CompareTo(b.Position);
+            });
+
+            string currentFilePath = nodeToFix.SyntaxTree.FilePath ?? string.Empty;
+            int currentPosition = nodeToFix.SpanStart;
+
+            int index = callSites.FindIndex(c =>
+                StringComparer.Ordinal.Equals(c.FilePath, currentFilePath) && c.Position == currentPosition);
+
+            return index > 0 ? index : 0;
+        }
     }
 }
diff --git a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/UpgradeToGeneratedRegexAnalyzerTests.cs b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/UpgradeToGeneratedRegexAnalyzerTests.cs
@@ -1085,6 +1085,183 @@ public static void Main()
             }.RunAsync();
         }
 
+        [Fact]
+        public async Task CodeFixerGeneratesUniqueNamesAcrossPartialClassDeclarations()
+        {
+            string test = @"using System.Text.RegularExpressions;
+
+internal partial class C
+{
+    public static Regex A()
+    {
+        var r = [|new Regex|](""abc"");
+        return r;
+    }
+}
+
+internal partial class C
+{
+    public static Regex B()
+    {
+        var r = [|new Regex|](""def"");
+        return r;
+    }
+}
+";
+
+            string fixedSource = @"using System.Text.RegularExpressions;
+
+internal partial class C
+{
+    public static Regex A()
+    {
+        var r = MyRegex;
+        return r;
+    }
+
+    [GeneratedRegex(""abc"")]
+    private static partial Regex MyRegex { get; }
+}
+
+internal partial class C
+{
+    public static Regex B()
+    {
+        var r = MyRegex1;
+        return r;
+    }
+
+    [GeneratedRegex(""def"")]
+    private static partial Regex MyRegex1 { get; }
+}
+";
+
+            await VerifyCS.VerifyCodeFixAsync(test, fixedSource);
+        }
+
+        [Fact]
+        public async Task CodeFixerGeneratesUniqueNamesAcrossThreePartialClassDeclarations()
+        {
+            string test = @"using System.Text.RegularExpressions;
+
+internal partial class C
+{
+    public static Regex A()
+    {
+        return [|new Regex|](""aaa"");
+    }
+}
+
+internal partial class C
+{
+    public static Regex B()
+    {
+        return [|new Regex|](""bbb"");
+    }
+}
+
+internal partial class C
+{
+    public static Regex D()
+    {
+        return [|new Regex|](""ccc"");
+    }
+}
+";
+
+            string fixedSource = @"using System.Text.RegularExpressions;
+
+internal partial class C
+{
+    public static Regex A()
+    {
+        return MyRegex;
+    }
+
+    [GeneratedRegex(""aaa"")]
+    private static partial Regex MyRegex { get; }
+}
+
+internal partial class C
+{
+    public static Regex B()
+    {
+        return MyRegex1;
+    }
+
+    [GeneratedRegex(""bbb"")]
+    private static partial Regex MyRegex1 { get; }
+}
+
+internal partial class C
+{
+    public static Regex D()
+    {
+        return MyRegex2;
+    }
+
+    [GeneratedRegex(""ccc"")]
+    private static partial Regex MyRegex2 { get; }
+}
+";
+
+            await VerifyCS.VerifyCodeFixAsync(test, fixedSource);
+        }
+
+        [Fact]
+        public async Task CodeFixerGeneratesUniqueNamesWhenExistingMemberNamedMyRegex()
+        {
+            string test = @"using System.Text.RegularExpressions;
+
+internal partial class C
+{
+    private static void MyRegex() { }
+
+    public static Regex A()
+    {
+        return [|new Regex|](""abc"");
+    }
+}
+
+internal partial class C
+{
+    public static Regex B()
+    {
+        return [|new Regex|](""def"");
+    }
+}
+";
+
+            string fixedSource = @"using System.Text.RegularExpressions;
+
+internal partial class C
+{
+    private static void MyRegex() { }
+
+    public static Regex A()
+    {
+        return MyRegex1;
+    }
+
+    [GeneratedRegex(""abc"")]
+    private static partial Regex MyRegex1 { get; }
+}
+
+internal partial class C
+{
+    public static Regex B()
+    {
+        return MyRegex2;
+    }
+
+    [GeneratedRegex(""def"")]
+    private static partial Regex MyRegex2 { get; }
+}
+";
+
+            await VerifyCS.VerifyCodeFixAsync(test, fixedSource);
+        }
+
         [Fact]
         public async Task CodeFixerSupportsNamedParameters()
         {
