Add records support to XmlDocCommentCompletion and ChangeSignature

src/EditorFeatures/CSharpTest/ChangeSignature/AddParameterTests.cs

@@ -1261,5 +1261,39 @@ public void M()
 }";
             await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: permutation, expectedUpdatedInvocationDocumentCode: updatedCode);
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.ChangeSignature)]
+        [WorkItem(44558, "https://github.com/dotnet/roslyn/issues/44558")]
+        public async Task AddParameters_Record()
+        {
+            var markup = @"
+/// <param name=""First""></param>
+/// <param name=""Second""></param>
+/// <param name=""Third""></param>
+record $$R(int First, int Second, int Third)
+{
+    static R M(this R r) => new R(1, 2, 3);
+}
+";
+            var updatedSignature = new AddedParameterOrExistingIndex[]
+            {
+                new(0),
+                new(2),
+                new(1),
+                new(new AddedParameter(null, "int", "Forth", CallSiteKind.Value, "12345"), "System.Int32")
+            };
+            var updatedCode = @"
+/// <param name=""First""></param>
+/// <param name=""Third""></param>
+/// <param name=""Second""></param>
+/// <param name=""Forth""></param>
+record R(int First, int Third, int Second, int Forth)
+{
+    static R M(this R r) => new R(1, 3, 2, 12345);
+}
+";
+
+            await TestChangeSignatureViaCommandAsync(LanguageNames.CSharp, markup, updatedSignature: updatedSignature, expectedUpdatedInvocationDocumentCode: updatedCode);
+        }
     }
 }

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs

@@ -1012,5 +1012,27 @@ static void Goo()
             await VerifyItemExistsAsync(text, "term");
             await VerifyItemExistsAsync(text, "description");
         }
+
+        [WorkItem(52738, "https://github.com/dotnet/roslyn/issues/52738")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RecordParam()
+        {
+            await VerifyItemsExistAsync(@"
+/// $$
+public record Goo<T>(string MyParameter);
+", "param name=\"MyParameter\"", "typeparam name=\"T\"");
+        }
+
+        [WorkItem(52738, "https://github.com/dotnet/roslyn/issues/52738")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RecordParamRef()
+        {
+            await VerifyItemsExistAsync(@"
+/// <summary>
+/// $$
+/// <summary>
+public record Goo<T>(string MyParameter);
+", "paramref name=\"MyParameter\"", "typeparamref name=\"T\"");
+        }
     }
 }

src/EditorFeatures/CSharpTest/DocumentationComments/CodeFixes/AddDocCommentNodesCodeFixProviderTests.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -785,5 +786,29 @@ public void Fizz(int i, int j, int k) {}
 
             await TestAsync(initial, expected);
         }
+
+        [WorkItem(52738, "https://github.com/dotnet/roslyn/issues/52738")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddDocCommentNodes)]
+        public async Task AddsParamTag_Record()
+        {
+            var initial = @"
+/// <summary>
+/// 
+/// </summary>
+/// <param name=""Second""></param>
+record R(int [|First|], int Second, int Third);
+";
+
+            var expected = @"
+/// <summary>
+/// 
+/// </summary>
+/// <param name=""First""></param>
+/// <param name=""Second""></param>
+/// <param name=""Third""></param>
+record R(int First, int Second, int Third);
+";
+            await TestAsync(initial, expected);
+        }
     }
 }

src/Features/CSharp/Portable/ChangeSignature/CSharpChangeSignatureService.cs

@@ -42,7 +42,9 @@ internal sealed class CSharpChangeSignatureService : AbstractChangeSignatureServ
             SyntaxKind.DelegateDeclaration,
             SyntaxKind.SimpleLambdaExpression,
             SyntaxKind.ParenthesizedLambdaExpression,
-            SyntaxKind.LocalFunctionStatement);
+            SyntaxKind.LocalFunctionStatement,
+            // TODO: Record structs
+            SyntaxKind.RecordDeclaration);
 
         private static readonly ImmutableArray<SyntaxKind> _declarationAndInvocableKinds =
             _declarationKinds.Concat(ImmutableArray.Create(
@@ -85,7 +87,9 @@ internal sealed class CSharpChangeSignatureService : AbstractChangeSignatureServ
             SyntaxKind.NameMemberCref,
             SyntaxKind.AnonymousMethodExpression,
             SyntaxKind.ParenthesizedLambdaExpression,
-            SyntaxKind.SimpleLambdaExpression);
+            SyntaxKind.SimpleLambdaExpression,
+            // TODO: record structs
+            SyntaxKind.RecordDeclaration);
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
@@ -265,12 +269,13 @@ public override async Task<SyntaxNode> ChangeSignatureAsync(
             CancellationToken cancellationToken)
         {
             var updatedNode = potentiallyUpdatedNode as CSharpSyntaxNode;
-
             // Update <param> tags.
+            // TODO: Record structs
             if (updatedNode.IsKind(SyntaxKind.MethodDeclaration) ||
                 updatedNode.IsKind(SyntaxKind.ConstructorDeclaration) ||
                 updatedNode.IsKind(SyntaxKind.IndexerDeclaration) ||
-                updatedNode.IsKind(SyntaxKind.DelegateDeclaration))
+                updatedNode.IsKind(SyntaxKind.DelegateDeclaration) ||
+                updatedNode.IsKind(SyntaxKind.RecordDeclaration))
             {
                 var updatedLeadingTrivia = UpdateParamTagsInLeadingTrivia(document, updatedNode, declarationSymbol, signaturePermutation);
                 if (updatedLeadingTrivia != default && !updatedLeadingTrivia.IsEmpty)
@@ -286,6 +291,13 @@ public override async Task<SyntaxNode> ChangeSignatureAsync(
                 return method.WithParameterList(method.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
             }
 
+            // TODO: Record structs
+            if (updatedNode.IsKind(SyntaxKind.RecordDeclaration, out RecordDeclarationSyntax? record) && record.ParameterList is not null)
+            {
+                var updatedParameters = UpdateDeclaration(record.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
+                return record.WithParameterList(record.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
+            }
+
             if (updatedNode.IsKind(SyntaxKind.LocalFunctionStatement, out LocalFunctionStatementSyntax? localFunction))
             {
                 var updatedParameters = UpdateDeclaration(localFunction.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);

src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs

@@ -124,6 +124,19 @@ internal async Task<ChangeSignatureAnalyzedContext> GetChangeSignatureContextAsy
                 {
                     symbol = typeSymbol.DelegateInvokeMethod;
                 }
+                else if (typeSymbol.IsRecord)
+                {
+                    // A bit hacky to determine the parameters of primary constructor associated with a given record.
+                    // TODO: record structs.
+                    const int RecordDeclarationRawKind = 9063;
+                    var potentialPrimaryCtor = typeSymbol.InstanceConstructors.FirstOrDefault(
+                        c => c.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax()?.RawKind == RecordDeclarationRawKind);
+
+                    if (potentialPrimaryCtor is not null)
+                    {
+                        symbol = potentialPrimaryCtor;
+                    }
+                }
             }
 
             if (!symbol.MatchesKind(SymbolKind.Method, SymbolKind.Property))
@@ -1001,7 +1014,6 @@ protected ImmutableArray<SyntaxTrivia> GetPermutedDocCommentTrivia(Document docu
                     node.GetTrailingTrivia(),
                     lastWhiteSpaceTrivia,
                     document.Project.Solution.Options.GetOption(FormattingOptions.NewLine, document.Project.Language));
-
                 var newTrivia = Generator.Trivia(extraDocComments);
 
                 updatedLeadingTrivia.Add(newTrivia);

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs

@@ -364,13 +364,33 @@ public static bool IsParams([NotNullWhen(returnValue: true)] this ISymbol? symbo
         }
 
         public static ImmutableArray<IParameterSymbol> GetParameters(this ISymbol? symbol)
-            => symbol switch
+        {
+            return symbol switch
             {
                 IMethodSymbol m => m.Parameters,
-                IPropertySymbol nt => nt.Parameters,
+                IPropertySymbol p => p.Parameters,
+                INamedTypeSymbol nt when nt.IsRecord => GetRecordParameters(nt),
                 _ => ImmutableArray<IParameterSymbol>.Empty,
             };
 
+            ImmutableArray<IParameterSymbol> GetRecordParameters(INamedTypeSymbol recordSymbol)
+            {
+                const int RecordDeclarationRawKind = 9063;
+
+                // A bit hacky to determine the parameters of primary constructor associated with a given record.
+                // TODO: record structs.
+                var primaryConstructor = recordSymbol.InstanceConstructors.FirstOrDefault(
+                    c => c.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax()?.RawKind == RecordDeclarationRawKind);
+
+                if (primaryConstructor is null)
+                {
+                    return ImmutableArray<IParameterSymbol>.Empty;
+                }
+
+                return primaryConstructor.Parameters;
+            }
+        }
+
         public static ImmutableArray<ITypeParameterSymbol> GetTypeParameters(this ISymbol? symbol)
             => symbol switch
             {