Make completion capabilities checks more robust (#11964)

davidwengier · web-flow · commit b9e53afd5042 · 2025-06-23T09:01:34.000+10:00
Fixes https://devdiv.visualstudio.com/DevDiv/_workitems/edit/2508507 I accidentally broke Html completion when I fixed override completion in VS Code. Previously we would always wrap the Data object, I made it only wrap if the delegated server specified it, but Html (in VS code at least?) doesn't specify any data, which meant we couldn't work out what document the request was for. This fixes it by correctly being guided by the client capabilities as to which data object should be set.
diff --git a/src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Completion/Delegation/DelegatedCompletionListProvider.cs b/src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Completion/Delegation/DelegatedCompletionListProvider.cs
@@ -116,10 +116,9 @@ internal class DelegatedCompletionListProvider(
             ? DelegatedCompletionHelper.RewriteCSharpResponse(delegatedResponse, absoluteIndex, codeDocument, positionInfo.Position, razorCompletionOptions)
             : DelegatedCompletionHelper.RewriteHtmlResponse(delegatedResponse, razorCompletionOptions);
 
-        var completionCapability = clientCapabilities?.TextDocument?.Completion as VSInternalCompletionSetting;
         var resolutionContext = new DelegatedCompletionResolutionContext(identifier, positionInfo.LanguageKind, rewrittenResponse.Data ?? rewrittenResponse.ItemDefaults?.Data);
         var resultId = _completionListCache.Add(rewrittenResponse, resolutionContext);
-        rewrittenResponse.SetResultId(resultId, completionCapability);
+        rewrittenResponse.SetResultId(resultId, clientCapabilities);
 
         return rewrittenResponse;
     }
diff --git a/src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Completion/RazorCompletionEndpoint.cs b/src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Completion/RazorCompletionEndpoint.cs
@@ -93,10 +93,7 @@ public TextDocumentIdentifier GetTextDocumentIdentifier(CompletionParams request
                 return null;
             }
 
-            var completionCapability = _clientCapabilities?.TextDocument?.Completion as VSInternalCompletionSetting;
-            var supportsCompletionListData = completionCapability.SupportsCompletionListData();
-
-            RazorCompletionResolveData.Wrap(result, request.TextDocument, supportsCompletionListData: supportsCompletionListData);
+            RazorCompletionResolveData.Wrap(result, request.TextDocument, _clientCapabilities);
             return result;
         }
     }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Completion/CohostDocumentCompletionEndpoint.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Completion/CohostDocumentCompletionEndpoint.cs
@@ -211,10 +211,7 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
             return null;
         }
 
-        var completionCapability = _clientCapabilitiesService.ClientCapabilities.TextDocument?.Completion as VSInternalCompletionSetting;
-        var supportsCompletionListData = completionCapability.SupportsCompletionListData();
-
-        RazorCompletionResolveData.Wrap(combinedCompletionList, originalTextDocumentIdentifier, supportsCompletionListData: supportsCompletionListData);
+        RazorCompletionResolveData.Wrap(combinedCompletionList, originalTextDocumentIdentifier, _clientCapabilitiesService.ClientCapabilities);
 
         return combinedCompletionList;
     }
@@ -236,12 +233,10 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
 
         var rewrittenResponse = DelegatedCompletionHelper.RewriteHtmlResponse(result, razorCompletionOptions);
 
-        var completionCapability = _clientCapabilitiesService.ClientCapabilities.TextDocument?.Completion as VSInternalCompletionSetting;
-
         var razorDocumentIdentifier = new TextDocumentIdentifierAndVersion(request.TextDocument, Version: 0);
         var resolutionContext = new DelegatedCompletionResolutionContext(razorDocumentIdentifier, RazorLanguageKind.Html, rewrittenResponse.Data ?? rewrittenResponse.ItemDefaults?.Data);
         var resultId = _completionListCache.Add(rewrittenResponse, resolutionContext);
-        rewrittenResponse.SetResultId(resultId, completionCapability);
+        rewrittenResponse.SetResultId(resultId, _clientCapabilitiesService.ClientCapabilities);
 
         return rewrittenResponse;
     }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionListProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionListProvider.cs
@@ -78,13 +78,11 @@ internal class RazorCompletionListProvider(
 
         var completionList = CreateLSPCompletionList(razorCompletionItems, clientCapabilities);
 
-        var completionCapability = clientCapabilities?.TextDocument?.Completion as VSInternalCompletionSetting;
-
         // The completion list is cached and can be retrieved via this result id to enable the resolve completion functionality.
         var filePath = codeDocument.Source.FilePath.AssumeNotNull();
         var razorResolveContext = new RazorCompletionResolveContext(filePath, razorCompletionItems);
         var resultId = _completionListCache.Add(completionList, razorResolveContext);
-        completionList.SetResultId(resultId, completionCapability);
+        completionList.SetResultId(resultId, clientCapabilities);
 
         return completionList;
     }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionResolveData.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/RazorCompletionResolveData.cs
@@ -30,21 +30,22 @@ public static RazorCompletionResolveData Unwrap(CompletionItem completionItem)
         return context;
     }
 
-    public static void Wrap(VSInternalCompletionList completionList, TextDocumentIdentifier textDocument, bool supportsCompletionListData)
+    public static void Wrap(VSInternalCompletionList completionList, TextDocumentIdentifier textDocument, VSInternalClientCapabilities clientCapabilities)
     {
         var data = new RazorCompletionResolveData(textDocument, OriginalData: null);
 
-        if (supportsCompletionListData)
+        if (clientCapabilities.SupportsAnyCompletionListData())
         {
-            if (completionList.Data is not null)
+            if (clientCapabilities.SupportsCompletionListData() || completionList.Data is not null)
             {
                 // Can set data at the completion list level
                 completionList.Data = data with { OriginalData = completionList.Data };
             }
 
-            if (completionList.ItemDefaults?.Data is not null)
+            if (clientCapabilities.SupportsCompletionListItemDefaultsData() || completionList.ItemDefaults?.Data is not null)
             {
                 // Set data for the item defaults
+                completionList.ItemDefaults ??= new();
                 completionList.ItemDefaults.Data = data with { OriginalData = completionList.ItemDefaults.Data };
             }
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/VSInternalCompletionListExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/VSInternalCompletionListExtensions.cs
@@ -13,14 +13,14 @@ internal static class VSInternalCompletionListExtensions
     public static void SetResultId(
         this RazorVSInternalCompletionList completionList,
         int resultId,
-        VSInternalCompletionSetting? completionSetting)
+        VSInternalClientCapabilities clientCapabilities)
     {
         var data = JsonSerializer.SerializeToElement(new JsonObject()
         {
             [VSInternalCompletionItemExtensions.ResultIdKey] = resultId,
         });
 
-        if (completionSetting.SupportsCompletionListData())
+        if (clientCapabilities.SupportsAnyCompletionListData())
         {
             // Ensure there is data at the completion list level, but only if ItemDefaults isn't set by the delegated server,
             // or if they've set both.
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/VSInternalCompletionSettingExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/VSInternalCompletionSettingExtensions.cs
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/ClientCapabilitiesExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/ClientCapabilitiesExtensions.cs
@@ -20,12 +20,20 @@ public static MarkupKind GetMarkupKind(this ClientCapabilities clientCapabilitie
     }
 
     public static bool SupportsMarkdown(this ClientCapabilities clientCapabilities)
-    {
-        return clientCapabilities.GetMarkupKind() == MarkupKind.Markdown;
-    }
+        => clientCapabilities.GetMarkupKind() == MarkupKind.Markdown;
 
     public static bool SupportsVisualStudioExtensions(this ClientCapabilities clientCapabilities)
-    {
-        return (clientCapabilities as VSInternalClientCapabilities)?.SupportsVisualStudioExtensions ?? false;
-    }
+        => clientCapabilities is VSInternalClientCapabilities { SupportsVisualStudioExtensions: true };
+
+    public static bool SupportsAnyCompletionListData(this ClientCapabilities clientCapabilities)
+        => clientCapabilities.SupportsCompletionListData() ||
+           clientCapabilities.SupportsCompletionListItemDefaultsData();
+
+    public static bool SupportsCompletionListData(this ClientCapabilities clientCapabilities)
+        => clientCapabilities.SupportsVisualStudioExtensions() &&
+           clientCapabilities.TextDocument?.Completion is VSInternalCompletionSetting { CompletionList.Data: true };
+
+    public static bool SupportsCompletionListItemDefaultsData(this ClientCapabilities clientCapabilities)
+        => clientCapabilities.TextDocument?.Completion?.CompletionListSetting?.ItemDefaults is { } defaults &&
+           Array.IndexOf(defaults, "data") >= 0;
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/Completion/RemoteCompletionService.cs b/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/Completion/RemoteCompletionService.cs
@@ -234,11 +234,9 @@ private async ValueTask<Response> GetCompletionAsync(
             mappedPosition,
             razorCompletionOptions);
 
-        var completionCapability = clientCapabilities?.TextDocument?.Completion as VSInternalCompletionSetting;
-
         var resolutionContext = new DelegatedCompletionResolutionContext(identifier, RazorLanguageKind.CSharp, rewrittenResponse.Data ?? rewrittenResponse.ItemDefaults?.Data);
         var resultId = _completionListCache.Add(rewrittenResponse, resolutionContext);
-        rewrittenResponse.SetResultId(resultId, completionCapability);
+        rewrittenResponse.SetResultId(resultId, clientCapabilities);
 
         return rewrittenResponse;
     }
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/RazorCompletionResolveEndpointTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/RazorCompletionResolveEndpointTest.cs
@@ -73,7 +73,7 @@ public async Task Handle_EvictedCachedCompletionItem_NoChange()
         // Arrange
         var completionItem = new VSInternalCompletionItem() { Label = "Test" };
         var completionList = new RazorVSInternalCompletionList() { Items = [completionItem] };
-        completionList.SetResultId(1337, completionSetting: null);
+        completionList.SetResultId(1337, clientCapabilities: new());
         var parameters = ConvertToBridgedItem(completionItem);
         var requestContext = CreateRazorRequestContext(documentContext: null);
 
@@ -91,7 +91,7 @@ public async Task Handle_CachedCompletionItem_Resolves()
         var completionItem = new VSInternalCompletionItem() { Label = "Test" };
         var completionList = new RazorVSInternalCompletionList() { Items = [completionItem] };
         var resultId = _completionListCache.Add(completionList, StrictMock.Of<ICompletionResolveContext>());
-        completionList.SetResultId(resultId, completionSetting: null);
+        completionList.SetResultId(resultId, clientCapabilities: new());
         var parameters = ConvertToBridgedItem(completionItem);
         var requestContext = CreateRazorRequestContext(documentContext: null);
 
@@ -111,9 +111,9 @@ public async Task Handle_MultipleResultIdsIgnoresEvictedResultIds_Resolves()
         await InitializeAsync();
         var completionItem = new VSInternalCompletionItem() { Label = "Test" };
         var completionList = new RazorVSInternalCompletionList() { Items = [completionItem] };
-        completionList.SetResultId(/* Invalid */ 1337, completionSetting: null);
+        completionList.SetResultId(/* Invalid */ 1337, clientCapabilities: new());
         var resultId = _completionListCache.Add(completionList, StrictMock.Of<ICompletionResolveContext>());
-        completionList.SetResultId(resultId, completionSetting: null);
+        completionList.SetResultId(resultId, clientCapabilities: new());
         var parameters = ConvertToBridgedItem(completionItem);
         var requestContext = CreateRazorRequestContext(documentContext: null);
 
@@ -131,17 +131,27 @@ public async Task Handle_MergedCompletionListFindsProperCompletionList_Resolves(
     {
         // Arrange
         await InitializeAsync();
-        var completionSetting = new VSInternalCompletionSetting() { CompletionList = new VSInternalCompletionListSetting() { Data = true } };
+        var clientCapabilities = new VSInternalClientCapabilities
+        {
+            SupportsVisualStudioExtensions = true,
+            TextDocument = new()
+            {
+                Completion = new VSInternalCompletionSetting()
+                {
+                    CompletionList = new VSInternalCompletionListSetting() { Data = true }
+                }
+            }
+        };
         var completionList1 = new RazorVSInternalCompletionList() { Items = [] };
         var completion1Context = StrictMock.Of<ICompletionResolveContext>();
         var resultId1 = _completionListCache.Add(completionList1, completion1Context);
-        completionList1.SetResultId(resultId1, completionSetting);
+        completionList1.SetResultId(resultId1, clientCapabilities);
 
         var completionItem = new VSInternalCompletionItem() { Label = "Test" };
         var completionList2 = new RazorVSInternalCompletionList() { Items = [completionItem] };
         var completion2Context = StrictMock.Of<ICompletionResolveContext>();
         var resultId2 = _completionListCache.Add(completionList2, completion2Context);
-        completionList2.SetResultId(resultId2, completionSetting);
+        completionList2.SetResultId(resultId2, clientCapabilities);
         var mergedCompletionList = CompletionListMerger.Merge(completionList1, completionList2);
         var mergedCompletionItem = mergedCompletionList.Items.Single();
         mergedCompletionItem.Data = mergedCompletionList.Data;
@@ -161,7 +171,7 @@ public async Task Handle_MergedCompletionListFindsProperCompletionList_Resolves(
     private VSInternalCompletionItem ConvertToBridgedItem(CompletionItem completionItem)
     {
         var list = new VSInternalCompletionList { Items = [completionItem] };
-        RazorCompletionResolveData.Wrap(list, textDocument: new(), supportsCompletionListData: false);
+        RazorCompletionResolveData.Wrap(list, textDocument: new(), clientCapabilities: new());
 
         var serialized = JsonSerializer.Serialize(completionItem, SerializerOptions);
         var bridgedItem = JsonSerializer.Deserialize<VSInternalCompletionItem>(serialized, SerializerOptions);
diff --git a/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/CompletionListCacheTest.cs b/src/Razor/test/Microsoft.CodeAnalysis.Razor.Workspaces.Test/Completion/CompletionListCacheTest.cs
@@ -21,7 +21,7 @@ public void TryGet_SetCompletionList_ReturnsTrue()
             Items = [new VSInternalCompletionItem()]
         };
         var resultId = _completionListCache.Add(completionList, _context);
-        completionList.SetResultId(resultId, completionSetting: null);
+        completionList.SetResultId(resultId, clientCapabilities: new());
 
         // Act
         var result = _completionListCache.TryGetOriginalRequestData((VSInternalCompletionItem)completionList.Items[0], out var cachedCompletionList, out var context);
@@ -48,7 +48,7 @@ public void TryGet_SetCompletionListOnFullCache_ReturnsTrue()
             Items = [new VSInternalCompletionItem()]
         };
         var resultId = _completionListCache.Add(completionList, _context);
-        completionList.SetResultId(resultId, completionSetting: null);
+        completionList.SetResultId(resultId, clientCapabilities: new());
 
         // Act
         var result = _completionListCache.TryGetOriginalRequestData((VSInternalCompletionItem)completionList.Items[0], out var cachedCompletionList, out var context);
@@ -80,7 +80,7 @@ public void TryGet_LastCompletionList_ReturnsTrue()
             Items = [new VSInternalCompletionItem()]
         };
         var initialCompletionListResultId = _completionListCache.Add(initialCompletionList, _context);
-        initialCompletionList.SetResultId(initialCompletionListResultId, completionSetting: null);
+        initialCompletionList.SetResultId(initialCompletionListResultId, clientCapabilities: new());
 
         for (var i = 0; i < CompletionListCache.MaxCacheSize - 1; i++)
         {
@@ -106,7 +106,7 @@ public void TryGet_EvictedCompletionList_ReturnsFalse()
             Items = [new VSInternalCompletionItem()]
         };
         var initialCompletionListResultId = _completionListCache.Add(initialCompletionList, _context);
-        initialCompletionList.SetResultId(initialCompletionListResultId, completionSetting: null);
+        initialCompletionList.SetResultId(initialCompletionListResultId, clientCapabilities: new());
 
         // We now fill the completion list cache up until its cache max so that the initial completion list we set gets evicted.
         for (var i = 0; i < CompletionListCache.MaxCacheSize; i++)
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostDocumentCompletionEndpointTest.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostDocumentCompletionEndpointTest.cs
@@ -1,6 +1,7 @@
 ﻿// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostDocumentCompletionResolveEndpointTest.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostDocumentCompletionResolveEndpointTest.cs
@@ -25,10 +25,25 @@ This is a Razor document.
                 <div st$$></div>
 
                 The end.
-                """);
+                """,
+            supportsVisualStudioExtensions: true);
     }
 
-    private async Task VerifyCompletionItemResolveAsync(TestCode input)
+    [Fact]
+    public async Task HtmlResolve_VSCode()
+    {
+        await VerifyCompletionItemResolveAsync(
+            input: """
+                This is a Razor document.
+
+                <div st$$></div>
+
+                The end.
+                """,
+            supportsVisualStudioExtensions: false);
+    }
+
+    private async Task VerifyCompletionItemResolveAsync(TestCode input, bool supportsVisualStudioExtensions)
     {
         var document = CreateProjectAndRazorDocument(input.Text);
 
@@ -54,22 +69,50 @@ private async Task VerifyCompletionItemResolveAsync(TestCode input)
             OriginalCompletionListData: null,
             ProjectedKind: RazorLanguageKind.Html);
 
-        var request = new VSInternalCompletionItem()
+        var list = new RazorVSInternalCompletionList
         {
-            Data = JsonSerializer.SerializeToElement(context),
-            Label = "TestItem"
+            Data = supportsVisualStudioExtensions ? JsonSerializer.SerializeToElement(context) : null,
+            ItemDefaults = new()
+            {
+                Data = supportsVisualStudioExtensions ? null : JsonSerializer.SerializeToElement(context),
+            },
+            Items = [new VSInternalCompletionItem()
+            {
+                Label = "TestItem"
+            }]
         };
-        var list = new RazorVSInternalCompletionList
+
+        var clientCapabilities = new VSInternalClientCapabilities
         {
-            Items = [request]
+            SupportsVisualStudioExtensions = supportsVisualStudioExtensions,
+            TextDocument = new TextDocumentClientCapabilities()
+            {
+                Completion = new VSInternalCompletionSetting()
+                {
+                    CompletionList = new()
+                    {
+                        Data = supportsVisualStudioExtensions
+                    },
+                    CompletionListSetting = new()
+                    {
+                        ItemDefaults = supportsVisualStudioExtensions ? null : ["data"]
+                    }
+                }
+            }
         };
 
         var resultId = completionListCache.Add(list, context);
-        list.SetResultId(resultId, null);
-        RazorCompletionResolveData.Wrap(list, textDocumentIdentifier.TextDocumentIdentifier, supportsCompletionListData: false);
+        list.SetResultId(resultId, clientCapabilities);
+        RazorCompletionResolveData.Wrap(list, textDocumentIdentifier.TextDocumentIdentifier, clientCapabilities);
+
+        var request = list.Items[0];
+        // Simulate the LSP client, which would receive all of the items and the list data, and send the item back to us with
+        // data filled in.
+        request.Data = JsonSerializer.SerializeToElement(list.Data ?? list.ItemDefaults.Data, JsonHelpers.JsonSerializerOptions);
 
-        // We expect data to be a JsonElement, so for tests we have to _not_ strongly type
-        request.Data = JsonSerializer.SerializeToElement(request.Data, JsonHelpers.JsonSerializerOptions);
+        var tdi = endpoint.GetTestAccessor().GetRazorTextDocumentIdentifier(request);
+        Assert.NotNull(tdi);
+        Assert.Equal(document.CreateUri(), tdi.Value.Uri);
 
         var result = await endpoint.GetTestAccessor().HandleRequestAsync(request, document, DisposalToken);
 

Original file line number	Diff line number	Diff line change
`@@ -93,10 +93,7 @@ public TextDocumentIdentifier GetTextDocumentIdentifier(CompletionParams request`
`93`	`93`	`return null;`
`94`	`94`	`}`
`95`	`95`
`96`		`- var completionCapability = _clientCapabilities?.TextDocument?.Completion as VSInternalCompletionSetting;`
`97`		`- var supportsCompletionListData = completionCapability.SupportsCompletionListData();`
`98`		`-`
`99`		`- RazorCompletionResolveData.Wrap(result, request.TextDocument, supportsCompletionListData: supportsCompletionListData);`
	`96`	`+ RazorCompletionResolveData.Wrap(result, request.TextDocument, _clientCapabilities);`
`100`	`97`	`return result;`
`101`	`98`	`}`
`102`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,21 +30,22 @@ public static RazorCompletionResolveData Unwrap(CompletionItem completionItem)`
`30`	`30`	`return context;`
`31`	`31`	`}`
`32`	`32`
`33`		`- public static void Wrap(VSInternalCompletionList completionList, TextDocumentIdentifier textDocument, bool supportsCompletionListData)`
	`33`	`+ public static void Wrap(VSInternalCompletionList completionList, TextDocumentIdentifier textDocument, VSInternalClientCapabilities clientCapabilities)`
`34`	`34`	`{`
`35`	`35`	`var data = new RazorCompletionResolveData(textDocument, OriginalData: null);`
`36`	`36`
`37`		`- if (supportsCompletionListData)`
	`37`	`+ if (clientCapabilities.SupportsAnyCompletionListData())`
`38`	`38`	`{`
`39`		`- if (completionList.Data is not null)`
	`39`	`+ if (clientCapabilities.SupportsCompletionListData() \|\| completionList.Data is not null)`
`40`	`40`	`{`
`41`	`41`	`// Can set data at the completion list level`
`42`	`42`	`completionList.Data = data with { OriginalData = completionList.Data };`
`43`	`43`	`}`
`44`	`44`
`45`		`- if (completionList.ItemDefaults?.Data is not null)`
	`45`	`+ if (clientCapabilities.SupportsCompletionListItemDefaultsData() \|\| completionList.ItemDefaults?.Data is not null)`
`46`	`46`	`{`
`47`	`47`	`// Set data for the item defaults`
	`48`	`+ completionList.ItemDefaults ??= new();`
`48`	`49`	`completionList.ItemDefaults.Data = data with { OriginalData = completionList.ItemDefaults.Data };`
`49`	`50`	`}`
`50`	`51`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,14 @@ internal static class VSInternalCompletionListExtensions`
`13`	`13`	`public static void SetResultId(`
`14`	`14`	`this RazorVSInternalCompletionList completionList,`
`15`	`15`	`int resultId,`
`16`		`- VSInternalCompletionSetting? completionSetting)`
	`16`	`+ VSInternalClientCapabilities clientCapabilities)`
`17`	`17`	`{`
`18`	`18`	`var data = JsonSerializer.SerializeToElement(new JsonObject()`
`19`	`19`	`{`
`20`	`20`	`[VSInternalCompletionItemExtensions.ResultIdKey] = resultId,`
`21`	`21`	`});`
`22`	`22`
`23`		`- if (completionSetting.SupportsCompletionListData())`
	`23`	`+ if (clientCapabilities.SupportsAnyCompletionListData())`
`24`	`24`	`{`
`25`	`25`	`// Ensure there is data at the completion list level, but only if ItemDefaults isn't set by the delegated server,`
`26`	`26`	`// or if they've set both.`