Add snippet support for component completion with EditorRequired attributes

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionItem.cs

@@ -82,8 +82,9 @@ public static RazorCompletionItem CreateMarkupTransition(
     public static RazorCompletionItem CreateTagHelperElement(
         string displayText, string insertText,
         AggregateBoundElementDescription descriptionInfo,
-        ImmutableArray<RazorCommitCharacter> commitCharacters)
-        => new(RazorCompletionItemKind.TagHelperElement, displayText, insertText, sortText: null, descriptionInfo, commitCharacters, isSnippet: false);
+        ImmutableArray<RazorCommitCharacter> commitCharacters,
+        bool isSnippet = false)
+        => new(RazorCompletionItemKind.TagHelperElement, displayText, insertText, sortText: null, descriptionInfo, commitCharacters, isSnippet);
 
     public static RazorCompletionItem CreateTagHelperAttribute(
         string displayText, string insertText, string? sortText,

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/TagHelperCompletionProvider.cs

@@ -7,6 +7,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Text;
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.AspNetCore.Razor.Language.Syntax;
 using Microsoft.AspNetCore.Razor.PooledObjects;
@@ -235,11 +236,26 @@ private ImmutableArray<RazorCompletionItem> GetElementCompletions(
         {
             var tagHelperDescriptions = tagHelpers.SelectAsArray(BoundElementDescriptionInfo.From);
 
+            var insertText = displayText;
+            var isSnippet = false;
+
+            // Check if snippets are supported and if any of the tag helpers have EditorRequired attributes
+            if (context.Options.SnippetsSupported && tagHelpers.Any())
+            {
+                var tagHelpersArray = tagHelpers.ToImmutableArray();
+                if (TryGetEditorRequiredAttributesSnippet(tagHelpersArray, displayText, context.Options.AutoInsertAttributeQuotes, out var snippetText))
+                {
+                    insertText = snippetText;
+                    isSnippet = true;
+                }
+            }
+
             var razorCompletionItem = RazorCompletionItem.CreateTagHelperElement(
                 displayText: displayText,
-                insertText: displayText,
+                insertText: insertText,
                 descriptionInfo: new(tagHelperDescriptions),
-                commitCharacters: commitChars);
+                commitCharacters: commitChars,
+                isSnippet: isSnippet);
 
             completionItems.Add(razorCompletionItem);
         }
@@ -283,6 +299,60 @@ private static ImmutableArray<RazorCommitCharacter> ResolveAttributeCommitCharac
         };
     }
 
+    private static bool TryGetEditorRequiredAttributesSnippet(
+        ImmutableArray<TagHelperDescriptor> tagHelpers,
+        string tagName,
+        bool autoInsertAttributeQuotes,
+        [NotNullWhen(true)] out string? snippetText)
+    {
+        // Collect all unique EditorRequired attributes from all matching tag helpers
+        using var editorRequiredAttributes = new PooledHashSet<string>(StringHashSetPool.Ordinal);
+
+        foreach (var tagHelper in tagHelpers)
+        {
+            var requiredAttributes = tagHelper.EditorRequiredAttributes;
+            foreach (var attribute in requiredAttributes)
+            {
+                editorRequiredAttributes.Add(attribute.Name);
+            }
+        }
+
+        // If there are no EditorRequired attributes, don't create a snippet
+        if (editorRequiredAttributes.Count == 0)
+        {
+            snippetText = null;
+            return false;
+        }
+
+        // Build snippet with placeholders for each required attribute
+        var builder = new StringBuilder();
+        builder.Append(tagName);
+
+        var tabStopIndex = 1;
+        var attributeNames = editorRequiredAttributes.ToArray();
+        foreach (var attributeName in attributeNames)
+        {
+            builder.Append(' ');
+            builder.Append(attributeName);
+            builder.Append(autoInsertAttributeQuotes ? "=\"$" : "=$");
+            builder.Append(tabStopIndex);
+            if (autoInsertAttributeQuotes)
+            {
+                builder.Append('"');
+            }
+
+            tabStopIndex++;
+        }
+
+        // Add final tab stop for the element content
+        builder.Append(">$0</");
+        builder.Append(tagName);
+        builder.Append('>');
+
+        snippetText = builder.ToString();
+        return true;
+    }
+
     private enum AttributeContext
     {
         Indexer,

src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/TagHelperCompletionProviderTest.cs

@@ -931,6 +931,139 @@ private static void AssertTest1Test2Completions(IReadOnlyList<RazorCompletionIte
         );
     }
 
+    [Fact]
+    public void GetCompletionAt_ComponentWithEditorRequiredAttributes_SnippetsSupported_ReturnsSnippet()
+    {
+        // Arrange
+        var componentBuilder = TagHelperDescriptorBuilder.CreateComponent("ComponentWithRequiredParams", "TestAssembly");
+        componentBuilder.SetTypeName(
+            fullName: "TestNamespace.ComponentWithRequiredParams",
+            typeNamespace: "TestNamespace",
+            typeNameIdentifier: "ComponentWithRequiredParams");
+        componentBuilder.TagMatchingRule(rule => rule.TagName = "ComponentWithRequiredParams");
+        componentBuilder.IsFullyQualifiedNameMatch = true;
+        componentBuilder.BindAttribute(attribute =>
+        {
+            attribute.Name = "RequiredParam1";
+            attribute.PropertyName = "RequiredParam1";
+            attribute.TypeName = typeof(string).FullName;
+            attribute.IsEditorRequired = true;
+        });
+        componentBuilder.BindAttribute(attribute =>
+        {
+            attribute.Name = "RequiredParam2";
+            attribute.PropertyName = "RequiredParam2";
+            attribute.TypeName = typeof(int).FullName;
+            attribute.IsEditorRequired = true;
+        });
+        componentBuilder.BindAttribute(attribute =>
+        {
+            attribute.Name = "OptionalParam";
+            attribute.PropertyName = "OptionalParam";
+            attribute.TypeName = typeof(string).FullName;
+        });
+
+        var service = CreateTagHelperCompletionProvider();
+        var options = new RazorCompletionOptions(SnippetsSupported: true, AutoInsertAttributeQuotes: true, CommitElementsWithSpace: true, UseVsCodeCompletionCommitCharacters: false);
+        var context = CreateRazorCompletionContext(
+            """
+                <$$
+                """,
+            isRazorFile: true,
+            options,
+            tagHelpers: ImmutableArray.Create(componentBuilder.Build()));
+
+        // Act
+        var completions = service.GetCompletionItems(context);
+
+        // Assert
+        var completion = Assert.Single(completions);
+        Assert.Equal("ComponentWithRequiredParams", completion.DisplayText);
+        Assert.True(completion.IsSnippet);
+        Assert.Contains("RequiredParam1", completion.InsertText);
+        Assert.Contains("RequiredParam2", completion.InsertText);
+        Assert.Contains("$1", completion.InsertText);
+        Assert.Contains("$2", completion.InsertText);
+        Assert.Contains("$0", completion.InsertText);
+    }
+
+    [Fact]
+    public void GetCompletionAt_ComponentWithEditorRequiredAttributes_SnippetsNotSupported_ReturnsNonSnippet()
+    {
+        // Arrange
+        var componentBuilder = TagHelperDescriptorBuilder.CreateComponent("ComponentWithRequiredParams", "TestAssembly");
+        componentBuilder.SetTypeName(
+            fullName: "TestNamespace.ComponentWithRequiredParams",
+            typeNamespace: "TestNamespace",
+            typeNameIdentifier: "ComponentWithRequiredParams");
+        componentBuilder.TagMatchingRule(rule => rule.TagName = "ComponentWithRequiredParams");
+        componentBuilder.IsFullyQualifiedNameMatch = true;
+        componentBuilder.BindAttribute(attribute =>
+        {
+            attribute.Name = "RequiredParam1";
+            attribute.PropertyName = "RequiredParam1";
+            attribute.TypeName = typeof(string).FullName;
+            attribute.IsEditorRequired = true;
+        });
+
+        var service = CreateTagHelperCompletionProvider();
+        var options = new RazorCompletionOptions(SnippetsSupported: false, AutoInsertAttributeQuotes: true, CommitElementsWithSpace: true, UseVsCodeCompletionCommitCharacters: false);
+        var context = CreateRazorCompletionContext(
+            """
+                <$$
+                """,
+            isRazorFile: true,
+            options,
+            tagHelpers: ImmutableArray.Create(componentBuilder.Build()));
+
+        // Act
+        var completions = service.GetCompletionItems(context);
+
+        // Assert
+        var completion = Assert.Single(completions);
+        Assert.Equal("ComponentWithRequiredParams", completion.DisplayText);
+        Assert.False(completion.IsSnippet);
+        Assert.Equal("ComponentWithRequiredParams", completion.InsertText);
+    }
+
+    [Fact]
+    public void GetCompletionAt_ComponentWithNoEditorRequiredAttributes_SnippetsSupported_ReturnsNonSnippet()
+    {
+        // Arrange
+        var componentBuilder = TagHelperDescriptorBuilder.CreateComponent("ComponentWithoutRequired", "TestAssembly");
+        componentBuilder.SetTypeName(
+            fullName: "TestNamespace.ComponentWithoutRequired",
+            typeNamespace: "TestNamespace",
+            typeNameIdentifier: "ComponentWithoutRequired");
+        componentBuilder.TagMatchingRule(rule => rule.TagName = "ComponentWithoutRequired");
+        componentBuilder.IsFullyQualifiedNameMatch = true;
+        componentBuilder.BindAttribute(attribute =>
+        {
+            attribute.Name = "OptionalParam";
+            attribute.PropertyName = "OptionalParam";
+            attribute.TypeName = typeof(string).FullName;
+        });
+
+        var service = CreateTagHelperCompletionProvider();
+        var options = new RazorCompletionOptions(SnippetsSupported: true, AutoInsertAttributeQuotes: true, CommitElementsWithSpace: true, UseVsCodeCompletionCommitCharacters: false);
+        var context = CreateRazorCompletionContext(
+            """
+                <$$
+                """,
+            isRazorFile: true,
+            options,
+            tagHelpers: ImmutableArray.Create(componentBuilder.Build()));
+
+        // Act
+        var completions = service.GetCompletionItems(context);
+
+        // Assert
+        var completion = Assert.Single(completions);
+        Assert.Equal("ComponentWithoutRequired", completion.DisplayText);
+        Assert.False(completion.IsSnippet);
+        Assert.Equal("ComponentWithoutRequired", completion.InsertText);
+    }
+
     private static RazorCompletionContext CreateRazorCompletionContext(string markup, bool isRazorFile, RazorCompletionOptions options = default, ImmutableArray<TagHelperDescriptor> tagHelpers = default)
     {
         tagHelpers = tagHelpers.NullToEmpty();