Send back icons for FAR via LSP

eng/Versions.props

@@ -34,7 +34,7 @@
     <CodeStyleAnalyzerVersion>3.8.0-2.20414.4</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.8.39</VisualStudioEditorPackagesVersion>
     <ILToolsPackageVersion>5.0.0-alpha1.19409.1</ILToolsPackageVersion>
-    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>16.8.103</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
+    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>16.8.120</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
     <MicrosoftVisualStudioShellPackagesVersion>16.8.30406.65-pre</MicrosoftVisualStudioShellPackagesVersion>
   </PropertyGroup>
   <!--

src/EditorFeatures/Core/Shared/Extensions/GlyphExtensions.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.VisualStudio.Core.Imaging;
 using Microsoft.VisualStudio.Imaging;
+using Microsoft.VisualStudio.Text.Adornments;
 
 namespace Microsoft.CodeAnalysis.Editor.Shared.Extensions
 {
@@ -221,5 +222,8 @@ public static ImageId GetImageId(this Glyph glyph)
                     throw new ArgumentException(nameof(glyph));
             }
         }
+
+        public static ImageElement GetImageElement(this Glyph glyph)
+            => new ImageElement(glyph.GetImageId());
     }
 }

src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs

@@ -28,6 +28,7 @@
 using Microsoft.VisualStudio.Composition;
 using Microsoft.VisualStudio.Text.Adornments;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using Roslyn.Utilities;
 using Xunit;
 using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -244,18 +245,20 @@ protected static LSP.VSCompletionItem CreateCompletionItem(
                 SortText = sortText ?? insertText,
                 InsertTextFormat = LSP.InsertTextFormat.Plaintext,
                 Kind = kind,
-                Data = new CompletionResolveData()
+                Data = JObject.FromObject(new CompletionResolveData()
                 {
                     DisplayText = insertText,
                     TextDocument = requestParameters.TextDocument,
                     Position = requestParameters.Position,
-                    CompletionTrigger = new CompletionTrigger(ProtocolConversions.LSPToRoslynCompletionTriggerKind(requestParameters.Context.TriggerKind), char.Parse(requestParameters.Context.TriggerCharacter))
-                },
-                Preselect = preselect,
+                    CompletionTrigger = requestParameters.Context == null
+                        ? new CompletionTrigger()
+                        : new CompletionTrigger(ProtocolConversions.LSPToRoslynCompletionTriggerKind(requestParameters.Context.TriggerKind), char.Parse(requestParameters.Context.TriggerCharacter))
+                }),
+                Preselect = preselect
             };
 
             if (tags != null)
-                item.Icon = new ImageElement(tags.ToImmutableArray().GetFirstGlyph().GetImageId());
+                item.Icon = tags.ToImmutableArray().GetFirstGlyph().GetImageElement();
 
             if (commitCharacters != null)
                 item.CommitCharacters = commitCharacters.Value.Select(c => c.ToString()).ToArray();

src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs

@@ -9,6 +9,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.FindSymbols.Finders;
@@ -93,7 +94,7 @@ public override async ValueTask OnDefinitionFoundAsync(DefinitionItem definition
                 var definitionItem = await GenerateVSReferenceItemAsync(
                     _id, definitionId: _id, _document, _position, definition.SourceSpans.FirstOrDefault(),
                     definition.DisplayableProperties, _metadataAsSourceFileService, definition.GetClassifiedText(),
-                    symbolUsageInfo: null, CancellationToken).ConfigureAwait(false);
+                    definition.Tags.GetFirstGlyph(), symbolUsageInfo: null, CancellationToken).ConfigureAwait(false);
 
                 if (definitionItem != null)
                 {
@@ -135,7 +136,7 @@ public override async ValueTask OnReferenceFoundAsync(SourceReferenceItem refere
                 var referenceItem = await GenerateVSReferenceItemAsync(
                     _id, definitionId, _document, _position, reference.SourceSpan,
                     reference.AdditionalProperties, _metadataAsSourceFileService, definitionText: null,
-                    reference.SymbolUsageInfo, CancellationToken).ConfigureAwait(false);
+                    definitionGlyph: Glyph.None, reference.SymbolUsageInfo, CancellationToken).ConfigureAwait(false);
 
                 if (referenceItem != null)
                 {
@@ -153,6 +154,7 @@ public override async ValueTask OnReferenceFoundAsync(SourceReferenceItem refere
             ImmutableDictionary<string, string> properties,
             IMetadataAsSourceFileService metadataAsSourceFileService,
             ClassifiedTextElement? definitionText,
+            Glyph definitionGlyph,
             SymbolUsageInfo? symbolUsageInfo,
             CancellationToken cancellationToken)
         {
@@ -176,6 +178,7 @@ public override async ValueTask OnReferenceFoundAsync(SourceReferenceItem refere
             {
                 DefinitionId = definitionId,
                 DefinitionText = definitionText,    // Only definitions should have a non-null DefinitionText
+                DefinitionIcon = definitionGlyph.GetImageElement(),
                 DisplayPath = location.Uri.LocalPath,
                 Id = id,
                 Kind = symbolUsageInfo.HasValue ? ProtocolConversions.SymbolUsageInfoToReferenceKinds(symbolUsageInfo.Value) : Array.Empty<ReferenceKind>(),

src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs

@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.DocumentHighlighting;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Elfie.Diagnostics;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Internal.Log;

src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs

@@ -51,6 +51,11 @@ public CompletionHandler(
                 return null;
             }
 
+            if (request.Context?.TriggerCharacter == null)
+            {
+                return null;
+            }
+
             // C# and VB share the same LSP language server, and thus share the same default trigger characters.
             // We need to ensure the trigger character is valid in the document's language. For example, the '{'
             // character, while a trigger character in VB, is not a trigger character in C#.
@@ -97,7 +102,7 @@ public CompletionHandler(
             return new LSP.VSCompletionList
             {
                 Items = list.Items.Select(item => CreateLSPCompletionItem(request, item, lspVSClientCapability, completionTrigger, commitCharactersRuleCache)).ToArray(),
-                SuggesstionMode = list.SuggestionModeItem != null,
+                SuggestionMode = list.SuggestionModeItem != null,
             };
 
             // Local functions

src/Features/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs

@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.LanguageServer.CustomProtocol;
 using Microsoft.VisualStudio.Text.Adornments;
 using Newtonsoft.Json.Linq;
+using Roslyn.Utilities;
 using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler
@@ -29,12 +30,16 @@ public CompletionResolveHandler()
         {
         }
 
+        private static CompletionResolveData GetCompletionResolveData(LSP.CompletionItem request)
+        {
+            Contract.ThrowIfNull(request.Data);
+
+            return ((JToken)request.Data).ToObject<CompletionResolveData>();
+        }
+
         public LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(LSP.CompletionItem request)
             => GetCompletionResolveData(request).TextDocument;
 
-        private static CompletionResolveData GetCompletionResolveData(LSP.CompletionItem completionItem)
-            => completionItem.Data as CompletionResolveData ?? ((JToken)completionItem.Data).ToObject<CompletionResolveData>();
-
         public async Task<LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)
         {
             var document = context.Document;

src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs

@@ -41,6 +41,12 @@ public FindAllReferencesHandler(IMetadataAsSourceFileService metadataAsSourceFil
                 return Array.Empty<LSP.VSReferenceItem>();
             }
 
+            // We only support streaming results back, so no point doing any work if the client doesn't
+            if (referenceParams.PartialResultToken == null)
+            {
+                return Array.Empty<LSP.VSReferenceItem>();
+            }
+
             var findUsagesService = document.GetRequiredLanguageService<IFindUsagesLSPService>();
             var position = await document.GetPositionFromLinePositionAsync(
                 ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false);

src/Features/LanguageServer/ProtocolUnitTests/Completion/CompletionTests.cs

@@ -127,7 +127,7 @@ void M()
 
             var results = (LSP.VSCompletionList)await RunGetCompletionsAsync(workspace.CurrentSolution, completionParams).ConfigureAwait(false);
             Assert.True(results.Items.Any());
-            Assert.True(results.SuggesstionMode);
+            Assert.True(results.SuggestionMode);
         }
 
         [Fact]

src/Features/LanguageServer/ProtocolUnitTests/References/FindAllReferencesHandlerTests.cs

@@ -4,9 +4,13 @@
 
 #nullable disable
 
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.VisualStudio.Text.Adornments;
 using Roslyn.Test.Utilities;
 using Xunit;
 using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -45,7 +49,44 @@ void M2()
             Assert.Equal("M", results[1].ContainingMember);
             Assert.Equal("M2", results[3].ContainingMember);
 
-            AssertValidDefinitionProperties(results, 0);
+            AssertValidDefinitionProperties(results, 0, Glyph.FieldPublic);
+        }
+
+        [WpfFact(Skip = "https://github.com/dotnet/roslyn/issues/43063")]
+        public async Task TestFindAllReferencesAsync_Class()
+        {
+            var markup =
+@"class {|reference:A|}
+{
+    public int someInt = 1;
+    void M()
+    {
+        var i = someInt + 1;
+    }
+}
+class B
+{
+    int someInt = {|reference:A|}.someInt + 1;
+    void M2()
+    {
+        var j = someInt + {|caret:|}{|reference:A|}.someInt;
+    }
+}";
+            using var workspace = CreateTestWorkspace(markup, out var locations);
+
+            var results = await RunFindAllReferencesAsync(workspace.CurrentSolution, locations["caret"].First());
+            AssertLocationsEqual(locations["reference"], results.Select(result => result.Location));
+
+            var textElement = results[0].Text as ClassifiedTextElement;
+            Assert.NotNull(textElement);
+            var actualText = string.Concat(textElement.Runs.Select(r => r.Text));
+
+            Assert.Equal("class A", actualText);
+            Assert.Equal("B", results[1].ContainingType);
+            Assert.Equal("B", results[2].ContainingType);
+            Assert.Equal("M2", results[2].ContainingMember);
+
+            AssertValidDefinitionProperties(results, 0, Glyph.ClassInternal);
         }
 
         [WpfFact(Skip = "https://github.com/dotnet/roslyn/issues/43063")]
@@ -80,7 +121,7 @@ void M2()
             Assert.Equal("M", results[1].ContainingMember);
             Assert.Equal("M2", results[3].ContainingMember);
 
-            AssertValidDefinitionProperties(results, 0);
+            AssertValidDefinitionProperties(results, 0, Glyph.FieldPublic);
         }
 
         [WpfFact]
@@ -116,12 +157,13 @@ void M()
             Assert.NotNull(results[0].Location.Uri);
         }
 
-        private static LSP.ReferenceParams CreateReferenceParams(LSP.Location caret) =>
+        private static LSP.ReferenceParams CreateReferenceParams(LSP.Location caret, IProgress<object> progress) =>
             new LSP.ReferenceParams()
             {
                 TextDocument = CreateTextDocumentIdentifier(caret.Uri),
                 Position = caret.Range.Start,
                 Context = new LSP.ReferenceContext(),
+                PartialResultToken = progress
             };
 
         private static async Task<LSP.VSReferenceItem[]> RunFindAllReferencesAsync(Solution solution, LSP.Location caret)
@@ -131,17 +173,23 @@ private static LSP.ReferenceParams CreateReferenceParams(LSP.Location caret) =>
                 SupportsVisualStudioExtensions = true
             };
 
+            var progress = new ProgressCollector<LSP.VSReferenceItem>();
+
             var queue = CreateRequestQueue(solution);
-            return await GetLanguageServer(solution).ExecuteRequestAsync<LSP.ReferenceParams, LSP.VSReferenceItem[]>(queue, LSP.Methods.TextDocumentReferencesName,
-                CreateReferenceParams(caret), vsClientCapabilities, null, CancellationToken.None);
+            await GetLanguageServer(solution).ExecuteRequestAsync<LSP.ReferenceParams, LSP.VSReferenceItem[]>(queue, LSP.Methods.TextDocumentReferencesName,
+                CreateReferenceParams(caret, progress), vsClientCapabilities, null, CancellationToken.None);
+
+            return progress.GetItems();
         }
 
-        private static void AssertValidDefinitionProperties(LSP.ReferenceItem[] referenceItems, int definitionIndex)
+        private static void AssertValidDefinitionProperties(LSP.VSReferenceItem[] referenceItems, int definitionIndex, Glyph definitionGlyph)
         {
             var definition = referenceItems[definitionIndex];
             var definitionId = definition.DefinitionId;
             Assert.NotNull(definition.DefinitionText);
 
+            Assert.Equal(definitionGlyph.GetImageId(), definition.DefinitionIcon.ImageId);
+
             for (var i = 0; i < referenceItems.Length; i++)
             {
                 if (i == definitionIndex)
@@ -150,9 +198,22 @@ private static void AssertValidDefinitionProperties(LSP.ReferenceItem[] referenc
                 }
 
                 Assert.Null(referenceItems[i].DefinitionText);
+                Assert.Equal(0, referenceItems[i].DefinitionIcon.ImageId.Id);
                 Assert.Equal(definitionId, referenceItems[i].DefinitionId);
                 Assert.NotEqual(definitionId, referenceItems[i].Id);
             }
         }
+
+        private sealed class ProgressCollector<T> : IProgress<object>
+        {
+            private readonly List<T> _items = new List<T>();
+
+            public T[] GetItems() => _items.ToArray();
+
+            public void Report(object value)
+            {
+                _items.AddRange((T[])value);
+            }
+        }
     }
 }

src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Completion/CompletionHandler.cs

@@ -45,7 +45,7 @@ public async Task<CompletionItem[]> HandleRequestAsync(CompletionParams request,
             var completionService = document.Project.LanguageServices.GetRequiredService<IXamlCompletionService>();
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
             var offset = text.Lines.GetPosition(ProtocolConversions.PositionToLinePosition(request.Position));
-            var completionResult = await completionService.GetCompletionsAsync(new XamlCompletionContext(document, offset, request.Context.TriggerCharacter?.FirstOrDefault() ?? '\0'), cancellationToken: cancellationToken).ConfigureAwait(false);
+            var completionResult = await completionService.GetCompletionsAsync(new XamlCompletionContext(document, offset, request.Context?.TriggerCharacter?.FirstOrDefault() ?? '\0'), cancellationToken: cancellationToken).ConfigureAwait(false);
             if (completionResult?.Completions == null)
             {
                 return Array.Empty<CompletionItem>();
@@ -62,7 +62,7 @@ private static CompletionItem CreateCompletionItem(XamlCompletionItem xamlComple
                 CommitCharacters = xamlCompletion.CommitCharacters,
                 Detail = xamlCompletion.Detail,
                 InsertText = xamlCompletion.InsertText,
-                Preselect = xamlCompletion.Preselect,
+                Preselect = xamlCompletion.Preselect.GetValueOrDefault(),
                 SortText = xamlCompletion.SortText,
                 FilterText = xamlCompletion.FilterText,
                 Kind = GetItemKind(xamlCompletion.Kind),

src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Completion/CompletionResolveHandler.cs

@@ -38,9 +38,14 @@ public CompletionResolveHandler()
 
         public async Task<LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)
         {
-            if (!(completionItem.Data is CompletionResolveData data))
+            CompletionResolveData data;
+            if (completionItem.Data is JToken token)
             {
-                data = ((JToken)completionItem.Data).ToObject<CompletionResolveData>();
+                data = token.ToObject<CompletionResolveData>();
+            }
+            else
+            {
+                return completionItem;
             }
 
             var documentId = DocumentId.CreateFromSerialized(ProjectId.CreateFromSerialized(data.ProjectGuid), data.DocumentGuid);

src/Workspaces/Remote/ServiceHub/Services/LanguageServer/LanguageServer.cs

@@ -126,6 +126,8 @@ private static async Task<ImmutableArray<SymbolInformation>> SearchDocumentAsync
         /// </summary>
         private static async Task SearchDocumentAndReportSymbolsAsync(Document document, WorkspaceSymbolParams args, CancellationToken cancellationToken)
         {
+            Contract.ThrowIfNull(args.PartialResultToken);
+
             var convertedResults = await SearchDocumentAsync(document, args.Query, cancellationToken).ConfigureAwait(false);
             args.PartialResultToken.Report(convertedResults.ToArray());
         }