Ensure RazorVSInternalCompletionParams is used for serialization of completion requests

src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Completion/CohostDocumentCompletionEndpoint.cs

@@ -153,7 +153,13 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
             // results we don't want to show. So we want to call HTML LSP only if we know we are in HTML content.
             if (documentPositionInfo.LanguageKind == RazorLanguageKind.Html)
             {
-                htmlCompletionList = await GetHtmlCompletionListAsync(request, razorDocument, razorCompletionOptions, correlationId, cancellationToken).ConfigureAwait(false);
+                var completionParams = new RazorVSInternalCompletionParams()
+                {
+                    Context = completionContext,
+                    Position = request.Position,
+                    TextDocument = request.TextDocument,
+                };
+                htmlCompletionList = await GetHtmlCompletionListAsync(completionParams, razorDocument, razorCompletionOptions, correlationId, cancellationToken).ConfigureAwait(false);
 
                 if (htmlCompletionList is not null)
                 {
@@ -218,23 +224,23 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
     }
 
     private async Task<RazorVSInternalCompletionList?> GetHtmlCompletionListAsync(
-        CompletionParams request,
+        RazorVSInternalCompletionParams completionParams,
         TextDocument razorDocument,
         RazorCompletionOptions razorCompletionOptions,
         Guid correlationId,
         CancellationToken cancellationToken)
     {
-        var result = await _requestInvoker.MakeHtmlLspRequestAsync<CompletionParams, RazorVSInternalCompletionList>(
+        var result = await _requestInvoker.MakeHtmlLspRequestAsync<RazorVSInternalCompletionParams, RazorVSInternalCompletionList>(
             razorDocument,
             Methods.TextDocumentCompletionName,
-            request,
+            completionParams,
             TelemetryThresholds.CompletionSubLSPTelemetryThreshold,
             correlationId,
             cancellationToken).ConfigureAwait(false);
 
         var rewrittenResponse = DelegatedCompletionHelper.RewriteHtmlResponse(result, razorCompletionOptions);
 
-        var razorDocumentIdentifier = new TextDocumentIdentifierAndVersion(request.TextDocument, Version: 0);
+        var razorDocumentIdentifier = new TextDocumentIdentifierAndVersion(completionParams.TextDocument, Version: 0);
         var resolutionContext = new DelegatedCompletionResolutionContext(razorDocumentIdentifier, RazorLanguageKind.Html, rewrittenResponse.Data ?? rewrittenResponse.ItemDefaults?.Data);
         var resultId = _completionListCache.Add(rewrittenResponse, resolutionContext);
         rewrittenResponse.SetResultId(resultId, _clientCapabilitiesService.ClientCapabilities);

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/HtmlRequestInvoker.cs

@@ -68,7 +68,7 @@ internal sealed class HtmlRequestInvoker(
             _logger.LogDebug($"Making LSP request for {method} from {htmlDocument.Uri}{(request is ITextDocumentPositionParams positionParams ? $" at {positionParams.Position}" : "")}, checksum {syncResult.Checksum}.");
 
             // Passing Guid.Empty to this method will mean no tracking
-            using var _ = _telemetryReporter.TrackLspRequest(Methods.TextDocumentCodeActionName, RazorLSPConstants.HtmlLanguageServerName, threshold, correlationId);
+            using var _ = _telemetryReporter.TrackLspRequest(method, RazorLSPConstants.HtmlLanguageServerName, threshold, correlationId);
 
             var result = await _requestInvoker.ReinvokeRequestOnServerAsync<TRequest, TResponse?>(
                 htmlDocument.Snapshot.TextBuffer,

src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Cohosting/TestHtmlRequestInvoker.cs

@@ -13,19 +13,29 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
 internal class TestHtmlRequestInvoker : IHtmlRequestInvoker
 {
-    private readonly Dictionary<string, object?> _htmlResponses;
+    private readonly Dictionary<string, Func<object, object?>> _getResponses;
+
+    public TestHtmlRequestInvoker()
+        : this(Array.Empty<(string, Func<object, object?>)>())
+    {
+    }
 
     public TestHtmlRequestInvoker(params (string method, object? response)[] htmlResponses)
+        : this(htmlResponses.Select<(string method, object? response), (string, Func<object, object?>)>(kvp => (kvp.method, _ => kvp.response)).ToArray())
+    {
+    }
+
+    public TestHtmlRequestInvoker(params (string method, Func<object, object?> getResponse)[] htmlResponses)
     {
-        _htmlResponses = htmlResponses.ToDictionary(kvp => kvp.method, kvp => kvp.response);
+        _getResponses = htmlResponses.ToDictionary(kvp => kvp.method, kvp => kvp.getResponse);
     }
 
     public Task<TResponse?> MakeHtmlLspRequestAsync<TRequest, TResponse>(TextDocument razorDocument, string method, TRequest request, TimeSpan threshold, Guid correlationId, CancellationToken cancellationToken) where TRequest : notnull
     {
-        if (_htmlResponses is not null &&
-            _htmlResponses.TryGetValue(method, out var response))
+        if (_getResponses is not null &&
+            _getResponses.TryGetValue(method, out var getResponse))
         {
-            return Task.FromResult((TResponse?)response);
+            return Task.FromResult((TResponse?)getResponse(request));
         }
 
         return Task.FromResult<TResponse?>(default);

src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Shared/CohostDocumentCompletionEndpointTest.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -12,6 +13,7 @@
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.AspNetCore.Razor.Test.Common;
 using Microsoft.AspNetCore.Razor.Test.Common.Workspaces;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor;
 using Microsoft.CodeAnalysis.Razor.Completion;
 using Microsoft.CodeAnalysis.Razor.Protocol;
@@ -346,6 +348,23 @@ This is a Razor document.
             unexpectedItemLabels: ["snippet1", "snippet2"]);
     }
 
+    [Fact]
+    public async Task HtmlElementNamesCompletion_UsesRazorVSInternalCompletionParams()
+    {
+        await VerifyCompletionListParamsTypeAsync(
+            input: """
+                This is a Razor document.
+
+                <$$1
+                """,
+            completionContext: new VSInternalCompletionContext()
+            {
+                InvokeKind = VSInternalCompletionInvokeKind.Typing,
+                TriggerCharacter = "<",
+                TriggerKind = CompletionTriggerKind.TriggerCharacter
+            });
+    }
+
     [Fact]
     public async Task HtmlElementDoNotCommitWithSpace()
     {
@@ -826,7 +845,7 @@ private async Task<RazorVSInternalCompletionList> VerifyCompletionListAsync(
 
         if (!commitElementsWithSpace)
         {
-            Assert.False(result.Items.Any(item => item.CommitCharacters?.First().Contains(" ") ?? false));
+            Assert.False(result.Items.Any(item => item.CommitCharacters?.First().Contains(' ') ?? false));
         }
 
         if (!autoInsertAttributeQuotes)
@@ -855,6 +874,51 @@ private async Task<RazorVSInternalCompletionList> VerifyCompletionListAsync(
         return result;
     }
 
+    private async Task VerifyCompletionListParamsTypeAsync(
+        TestCode input,
+        VSInternalCompletionContext completionContext,
+        RazorFileKind? fileKind = null)
+    {
+        var document = CreateProjectAndRazorDocument(input.Text, fileKind);
+        var sourceText = await document.GetTextAsync(DisposalToken);
+
+        // Assert the request invoker is passed a RazorVSInternalCompletionParams
+        var requestInvoker = new TestHtmlRequestInvoker((Methods.TextDocumentCompletionName, ValidateArgType));
+
+        var languageServerFeatureOptions = new TestLanguageServerFeatureOptions();
+
+        var completionListCache = new CompletionListCache();
+        var endpoint = new CohostDocumentCompletionEndpoint(
+            IncompatibleProjectService,
+            RemoteServiceInvoker,
+            ClientSettingsManager,
+            ClientCapabilitiesService,
+            snippetCompletionItemProvider: null,
+            languageServerFeatureOptions,
+            requestInvoker,
+            completionListCache,
+            NoOpTelemetryReporter.Instance,
+            LoggerFactory);
+
+        var request = new CompletionParams()
+        {
+            TextDocument = new TextDocumentIdentifier()
+            {
+                DocumentUri = document.CreateDocumentUri()
+            },
+            Position = sourceText.GetPosition(input.Position),
+            Context = completionContext
+        };
+
+        await endpoint.GetTestAccessor().HandleRequestAsync(request, document, DisposalToken);
+
+        static RazorVSInternalCompletionList? ValidateArgType(object arg)
+        {
+            Assert.Equal(typeof(RazorVSInternalCompletionParams), arg.GetType());
+            return default;
+        }
+    }
+
     private async Task VerifyCompletionResolveAsync(CodeAnalysis.TextDocument document, CompletionListCache completionListCache, VSInternalCompletionItem item, string? expected, string expectedResolvedItemDescription)
     {
         // We expect data to be a JsonElement, so for tests we have to _not_ strongly type
@@ -917,7 +981,7 @@ private async Task VerifyCompletionResolveAsync(CodeAnalysis.TextDocument docume
         }
     }
 
-    private string? FlattenDescription(ClassifiedTextElement? description)
+    private static string? FlattenDescription(ClassifiedTextElement? description)
     {
         if (description is null)
         {