Merge PrimaryConstructors into Main

src/Analyzers/CSharp/Tests/AddParameter/AddParameterTests.cs

@@ -2809,6 +2809,22 @@ public static class IsExternalInit { }
 ", parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp9));
         }
 
+        [Fact]
+        public async Task Test_PrimaryConstructor_Class()
+        {
+            await TestInRegularAndScriptAsync(@"
+var b = ""B"";
+var r = [|new R(1, b)|];
+
+class R(int A);
+", @"
+var b = ""B"";
+var r = new R(1, b);
+
+class R(int A, string b);
+", parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview));
+        }
+
         [Fact, WorkItem(54408, "https://github.com/dotnet/roslyn/issues/54408")]
         public async Task TestPositionalRecordStruct()
         {
@@ -2835,6 +2851,22 @@ public static class IsExternalInit { }
 ", parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp9));
         }
 
+        [Fact]
+        public async Task Test_PrimaryConstructor_Struct()
+        {
+            await TestInRegularAndScriptAsync(@"
+var b = ""B"";
+var r = [|new R(1, b)|];
+
+struct R(int A);
+", @"
+var b = ""B"";
+var r = new R(1, b);
+
+struct R(int A, string b);
+", parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.Preview));
+        }
+
         [Fact, WorkItem(56952, "https://github.com/dotnet/roslyn/issues/56952")]
         public async Task TestRecordsNamingConventions()
         {
@@ -2847,6 +2879,18 @@ record Test(string V);
 ");
         }
 
+        [Fact]
+        public async Task TestNamingConventions_PrimaryConstructor_Class()
+        {
+            await TestInRegularAndScript1Async(@"[|new Test(""repro"")|];
+
+class Test();
+", @"new Test(""repro"");
+
+class Test(string v);
+");
+        }
+
         [Fact, WorkItem(56952, "https://github.com/dotnet/roslyn/issues/56952")]
         public async Task TestRecordsNamingConventions_RecordStruct()
         {
@@ -2859,6 +2903,18 @@ record struct Test(string V);
 ");
         }
 
+        [Fact]
+        public async Task TestNamingConventions_PrimaryConstructor_Struct()
+        {
+            await TestInRegularAndScript1Async(@"[|new Test(""repro"")|];
+
+struct Test();
+", @"new Test(""repro"");
+
+struct Test(string v);
+");
+        }
+
         [Fact, WorkItem(61715, "https://github.com/dotnet/roslyn/issues/61715")]
         public async Task TestMethodGroup1()
         {

src/Analyzers/CSharp/Tests/DocumentationComments/AddDocCommentNodesCodeFixProviderTests.cs

@@ -802,6 +802,52 @@ record R(int [|First|], int Second, int Third);
 /// <param name=""Second""></param>
 /// <param name=""Third""></param>
 record R(int First, int Second, int Third);
+";
+            await TestAsync(initial, expected);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddDocCommentNodes)]
+        public async Task AddsParamTag_Class()
+        {
+            var initial = @"
+/// <summary>
+/// 
+/// </summary>
+/// <param name=""Second""></param>
+class R(int [|First|], int Second, int Third);
+";
+
+            var expected = @"
+/// <summary>
+/// 
+/// </summary>
+/// <param name=""First""></param>
+/// <param name=""Second""></param>
+/// <param name=""Third""></param>
+class R(int First, int Second, int Third);
+";
+            await TestAsync(initial, expected);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddDocCommentNodes)]
+        public async Task AddsParamTag_Struct()
+        {
+            var initial = @"
+/// <summary>
+/// 
+/// </summary>
+/// <param name=""Second""></param>
+struct R(int [|First|], int Second, int Third);
+";
+
+            var expected = @"
+/// <summary>
+/// 
+/// </summary>
+/// <param name=""First""></param>
+/// <param name=""Second""></param>
+/// <param name=""Third""></param>
+struct R(int First, int Second, int Third);
 ";
             await TestAsync(initial, expected);
         }

src/Analyzers/CSharp/Tests/MakeStructReadOnly/MakeStructReadOnlyTests.cs

@@ -130,6 +130,16 @@ await TestMissingAsync(
 }");
     }
 
+    [Fact]
+    public async Task TestMissingWithMutableAndReadOnlyFieldStruct2()
+    {
+        await TestMissingAsync(
+@"struct S(int j)
+{
+    int i;
+}");
+    }
+
     [Fact]
     public async Task TestMissingWithMutableProperty()
     {
@@ -160,6 +170,16 @@ await TestMissingAsync(
 }");
     }
 
+    [Fact]
+    public async Task TestMissingWithMutablePropertyStruct2()
+    {
+        await TestMissingAsync(
+@"struct S(int q)
+{
+    int P { get; set; }
+}");
+    }
+
     [Fact]
     public async Task TestMissingWithEmptyStruct()
     {
@@ -179,14 +199,23 @@ await TestMissingAsync(
     }
 
     [Fact]
-    public async Task TestMissingWithEmptyStructPrimaryConstructor()
+    public async Task TestMissingWithEmptyRecordStructPrimaryConstructor()
     {
         await TestMissingAsync(
 @"record struct S()
 {
 }");
     }
 
+    [Fact]
+    public async Task TestMissingWithEmptyStructPrimaryConstructor()
+    {
+        await TestMissingAsync(
+@"struct S()
+{
+}");
+    }
+
     [Fact]
     public async Task TestMissingWithOtherReadonlyPartialPart()
     {
@@ -309,6 +338,15 @@ await TestMissingAsync(
 }");
     }
 
+    [Fact]
+    public async Task TestMissingStructWithPrimaryConstructor()
+    {
+        await TestMissingAsync(
+@"struct S(int i)
+{
+}");
+    }
+
     [Fact]
     public async Task TestMissingOnRecordStructWithPrimaryConstructorFieldAndNormalField()
     {
@@ -319,6 +357,21 @@ await TestMissingAsync(
 }");
     }
 
+    [Fact]
+    public async Task TestOnStructWithPrimaryConstructorAndReadonlyField()
+    {
+        await TestAsync(
+@"struct [|S|](int i)
+{
+    readonly int i;
+}",
+@"readonly struct S(int i)
+{
+    readonly int i;
+}",
+LanguageVersion.Preview);
+    }
+
     [Fact]
     public async Task TestNestedStructs1()
     {

src/Analyzers/CSharp/Tests/UpgradeProject/UpgradeProjectTests.cs

@@ -1030,6 +1030,66 @@ public record Base
                 new CSharpParseOptions(LanguageVersion.CSharp9));
         }
 
+        [Fact]
+        public async Task UpgradeProjectForPrimaryConstructors_Class()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+class Program[|()|];",
+                LanguageVersion.Preview,
+                new CSharpParseOptions(LanguageVersion.CSharp11));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForPrimaryConstructors_Struct()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+struct Program[|()|];",
+                LanguageVersion.Preview,
+                new CSharpParseOptions(LanguageVersion.CSharp11));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForSemicolonBody_Class()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+class Program[|;|]",
+                LanguageVersion.Preview,
+                new CSharpParseOptions(LanguageVersion.CSharp11));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForSemicolonBody_Struct()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+struct Program[|;|]",
+                LanguageVersion.Preview,
+                new CSharpParseOptions(LanguageVersion.CSharp11));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForSemicolonBody_Interface()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+interface Program[|;|]",
+                LanguageVersion.Preview,
+                new CSharpParseOptions(LanguageVersion.CSharp11));
+        }
+
+        [Fact]
+        public async Task UpgradeProjectForSemicolonBody_Enum()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"
+enum Program[|;|]",
+                LanguageVersion.Preview,
+                new CSharpParseOptions(LanguageVersion.CSharp11));
+        }
+
         [Fact]
         public async Task UpgradeProjectForTargetTypedNew()
         {

src/Compilers/CSharp/CSharpAnalyzerDriver/CSharpDeclarationComputer.cs

@@ -98,17 +98,19 @@ private static void ComputeDeclarations(
 
                         return;
                     }
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.StructDeclaration:
                 case SyntaxKind.RecordDeclaration:
                 case SyntaxKind.RecordStructDeclaration:
                     {
                         if (associatedSymbol is IMethodSymbol ctor)
                         {
-                            var recordDeclaration = (RecordDeclarationSyntax)node;
-                            Debug.Assert(ctor.MethodKind == MethodKind.Constructor && recordDeclaration.ParameterList is object);
+                            var typeDeclaration = (TypeDeclarationSyntax)node;
+                            Debug.Assert(ctor.MethodKind == MethodKind.Constructor && typeDeclaration.ParameterList is object);
 
-                            var codeBlocks = GetParameterListInitializersAndAttributes(recordDeclaration.ParameterList);
+                            var codeBlocks = GetParameterListInitializersAndAttributes(typeDeclaration.ParameterList);
 
-                            if (recordDeclaration.BaseList?.Types.FirstOrDefault() is PrimaryConstructorBaseTypeSyntax initializer)
+                            if (typeDeclaration.BaseList?.Types.FirstOrDefault() is PrimaryConstructorBaseTypeSyntax initializer)
                             {
                                 codeBlocks = codeBlocks.Concat(initializer);
                             }
@@ -117,10 +119,8 @@ private static void ComputeDeclarations(
                             return;
                         }
 
-                        goto case SyntaxKind.ClassDeclaration;
+                        goto case SyntaxKind.InterfaceDeclaration;
                     }
-                case SyntaxKind.ClassDeclaration:
-                case SyntaxKind.StructDeclaration:
                 case SyntaxKind.InterfaceDeclaration:
                     {
                         var t = (TypeDeclarationSyntax)node;