Generate delegating constructor should make the implicit no-arg const…

…ructor explicit to preserve binary and source compat (#76330)

src/Analyzers/CSharp/Tests/GenerateDefaultConstructors/GenerateDefaultConstructorsTests.cs

@@ -1620,5 +1620,92 @@ public Program()
             """);
     }
 
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/51049")]
+    public async Task TestGenerateDefaultConstructorPreserveBinaryCompat1()
+    {
+        await TestRefactoringAsync(
+            """
+            class Base
+            {
+                protected Base()
+                {
+                }
+
+                protected Base(int i)
+                {
+                }
+            }
+
+            sealed class Program : [||]Base
+            {
+            }
+            """,
+            """
+            class Base
+            {
+                protected Base()
+                {
+                }
+            
+                protected Base(int i)
+                {
+                }
+            }
+
+            sealed class Program : Base
+            {
+                public Program()
+                {
+                }
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/51049")]
+    public async Task TestGenerateDefaultConstructorPreserveBinaryCompat2()
+    {
+        await TestRefactoringAsync(
+            """
+            class Base
+            {
+                protected Base()
+                {
+                }
+
+                protected Base(int i)
+                {
+                }
+            }
+
+            sealed class Program : [||]Base
+            {
+            }
+            """,
+            """
+            class Base
+            {
+                protected Base()
+                {
+                }
+            
+                protected Base(int i)
+                {
+                }
+            }
+
+            sealed class Program : Base
+            {
+                public Program()
+                {
+                }
+
+                public Program(int i) : base(i)
+                {
+                }
+            }
+            """,
+            index: 1);
+    }
+
 #endif
 }

src/Analyzers/Core/CodeFixes/CodeFixes.projitems

@@ -45,9 +45,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)GenerateConstructor\GenerateConstructorHelpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GenerateConstructor\IGenerateConstructorService.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\AbstractGenerateDefaultConstructorCodeFixProvider.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.CodeAction.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.CodeActionAll.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.State.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GenerateDefaultConstructors\IGenerateDefaultConstructorsService.cs" />

src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.State.cs

@@ -79,10 +79,9 @@ private bool TryInitialize(
             var destinationProvider = semanticDocument.Project.Solution.Services.GetLanguageServices(ClassType.Language);
             var isCaseSensitive = syntaxFacts.IsCaseSensitive;
 
-            UnimplementedConstructors =
-                baseType.InstanceConstructors
-                        .WhereAsArray(c => c.IsAccessibleWithin(ClassType) &&
-                                           IsMissing(c, classConstructors, isCaseSensitive));
+            UnimplementedConstructors = baseType
+                .InstanceConstructors
+                .WhereAsArray(c => c.IsAccessibleWithin(ClassType) && IsMissing(c, classConstructors, isCaseSensitive));
 
             return UnimplementedConstructors.Length > 0;
         }

src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.cs

@@ -4,13 +4,14 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors;
 
@@ -37,11 +38,28 @@ public async Task<ImmutableArray<CodeAction>> GenerateDefaultConstructorsAsync(
                 var state = State.Generate((TService)this, semanticDocument, textSpan, forRefactoring, cancellationToken);
                 if (state != null)
                 {
+                    // If the user only has an implicit no-arg constructor, and we're adding a constructor with args,
+                    // then the compiler will not emit the implicit no-arg constructor anymore.  So we need to include
+                    // that member to ensure binary compat when generating members.
+                    var unimplementedDefaultConstructor = state.UnimplementedConstructors.FirstOrDefault(
+                        m => m.Parameters.Length == 0);
+
                     foreach (var constructor in state.UnimplementedConstructors)
-                        result.Add(new GenerateDefaultConstructorCodeAction(document, state, constructor));
+                    {
+                        Contract.ThrowIfNull(state.ClassType);
+
+                        result.Add(new GenerateDefaultConstructorsCodeAction(
+                            document, state,
+                            string.Format(CodeFixesResources.Generate_constructor_0_1,
+                                state.ClassType.Name,
+                                string.Join(", ", constructor.Parameters.Select(p => p.Name))),
+                            unimplementedDefaultConstructor == null || unimplementedDefaultConstructor == constructor
+                                ? [constructor]
+                                : [unimplementedDefaultConstructor, constructor]));
+                    }
 
                     if (state.UnimplementedConstructors.Length > 1)
-                        result.Add(new CodeActionAll(document, state, state.UnimplementedConstructors));
+                        result.Add(new GenerateDefaultConstructorsCodeAction(document, state, CodeFixesResources.Generate_all, state.UnimplementedConstructors));
                 }
             }
 

src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs → src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/GenerateDefaultConstructorsCodeAction.cs

@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -22,26 +22,17 @@ namespace Microsoft.CodeAnalysis.GenerateDefaultConstructors;
 
 internal abstract partial class AbstractGenerateDefaultConstructorsService<TService>
 {
-    private abstract class AbstractCodeAction : CodeAction
+    private sealed class GenerateDefaultConstructorsCodeAction(
+        Document document,
+        State state,
+        string title,
+        ImmutableArray<IMethodSymbol> constructors) : CodeAction
     {
-        private readonly IList<IMethodSymbol> _constructors;
-        private readonly Document _document;
-        private readonly State _state;
-        private readonly string _title;
+        private readonly ImmutableArray<IMethodSymbol> _constructors = constructors;
+        private readonly Document _document = document;
+        private readonly State _state = state;
 
-        protected AbstractCodeAction(
-            Document document,
-            State state,
-            IList<IMethodSymbol> constructors,
-            string title)
-        {
-            _document = document;
-            _state = state;
-            _constructors = constructors;
-            _title = title;
-        }
-
-        public override string Title => _title;
+        public override string Title => title;
 
         protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
         {