Return the SignatureHelp items nearest to the cursor

src/EditorFeatures/Core.Wpf/SignatureHelp/Controller.Session_ComputeModel.cs

@@ -13,10 +13,8 @@
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.LanguageService;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.SignatureHelp;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
 using Roslyn.Utilities;
 
@@ -87,9 +85,14 @@ internal partial class Session
                         var options = Controller.GlobalOptions.GetSignatureHelpOptions(document.Project.Language);
 
                         // first try to query the providers that can trigger on the specified character
-                        var (provider, items) = await ComputeItemsAsync(
-                            providers, caretPosition, triggerInfo,
-                            options, document, cancellationToken).ConfigureAwait(false);
+                        var service = document.GetRequiredLanguageService<SignatureHelpService>();
+                        var (provider, items) = await service.GetSignatureHelpAsync(
+                            providers,
+                            document,
+                            caretPosition,
+                            triggerInfo,
+                            options,
+                            cancellationToken).ConfigureAwait(false);
 
                         if (provider == null)
                         {
@@ -174,66 +177,6 @@ private static bool DisplayPartsMatch(SignatureHelpItem i1, SignatureHelpItem i2
 
             private static bool CompareParts(TaggedText p1, TaggedText p2)
                 => p1.ToString() == p2.ToString();
-
-            private static async Task<(ISignatureHelpProvider provider, SignatureHelpItems items)> ComputeItemsAsync(
-                ImmutableArray<ISignatureHelpProvider> providers,
-                SnapshotPoint caretPosition,
-                SignatureHelpTriggerInfo triggerInfo,
-                SignatureHelpOptions options,
-                Document document,
-                CancellationToken cancellationToken)
-            {
-                try
-                {
-                    ISignatureHelpProvider bestProvider = null;
-                    SignatureHelpItems bestItems = null;
-
-                    // TODO(cyrusn): We're calling into extensions, we need to make ourselves resilient
-                    // to the extension crashing.
-                    foreach (var provider in providers)
-                    {
-                        cancellationToken.ThrowIfCancellationRequested();
-
-                        var currentItems = await provider.GetItemsAsync(document, caretPosition, triggerInfo, options, cancellationToken).ConfigureAwait(false);
-                        if (currentItems != null && currentItems.ApplicableSpan.IntersectsWith(caretPosition.Position))
-                        {
-                            // If another provider provides sig help items, then only take them if they
-                            // start after the last batch of items.  i.e. we want the set of items that
-                            // conceptually are closer to where the caret position is.  This way if you have:
-                            //
-                            //  Goo(new Bar($$
-                            //
-                            // Then invoking sig help will only show the items for "new Bar(" and not also
-                            // the items for "Goo(..."
-                            if (IsBetter(bestItems, currentItems.ApplicableSpan))
-                            {
-                                bestItems = currentItems;
-                                bestProvider = provider;
-                            }
-                        }
-                    }
-
-                    return (bestProvider, bestItems);
-                }
-                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
-                {
-                    return (null, null);
-                }
-            }
-
-            private static bool IsBetter(SignatureHelpItems bestItems, TextSpan? currentTextSpan)
-            {
-                // If we have no best text span, then this span is definitely better.
-                if (bestItems == null)
-                {
-                    return true;
-                }
-
-                // Otherwise we want the one that is conceptually the innermost signature.  So it's
-                // only better if the distance from it to the caret position is less than the best
-                // one so far.
-                return currentTextSpan.Value.Start > bestItems.ApplicableSpan.Start;
-            }
         }
     }
 }

src/Features/CSharp/Portable/SignatureHelp/CSharpSignatureHelpService.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.SignatureHelp;
+
+namespace Microsoft.CodeAnalysis.CSharp.SignatureHelp;
+
+[ExportLanguageServiceFactory(typeof(SignatureHelpService), LanguageNames.CSharp), Shared]
+internal class CSharpSignatureHelpServiceFactory : ILanguageServiceFactory
+{
+    [ImportingConstructor]
+    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+    public CSharpSignatureHelpServiceFactory()
+    {
+    }
+
+    public ILanguageService CreateLanguageService(HostLanguageServices languageServices)
+        => new CSharpSignatureHelpService(languageServices.LanguageServices);
+}
+
+internal class CSharpSignatureHelpService : SignatureHelpServiceWithProviders
+{
+    internal CSharpSignatureHelpService(LanguageServices services)
+        : base(services)
+    {
+    }
+}

src/Features/Core/Portable/SignatureHelp/SignatureHelpService.cs

@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.SignatureHelp;
+
+/// <summary>
+/// A service that is used to determine the appropriate signature help for a position in a document.
+/// </summary>
+internal abstract class SignatureHelpService : ILanguageService
+{
+    /// <summary>
+    /// Gets the appropriate <see cref="SignatureHelpService"/> for the specified document.
+    /// </summary>
+    public static SignatureHelpService? GetService(Document? document)
+        => document?.GetLanguageService<SignatureHelpService>();
+
+    /// <summary>
+    /// Gets the <see cref="ISignatureHelpProvider"/> and <see cref="SignatureHelpItems"/> associated with
+    /// the position in the document.
+    /// </summary>
+    public abstract Task<(ISignatureHelpProvider? provider, SignatureHelpItems? bestItems)> GetSignatureHelpAsync(
+        Document document,
+        int position,
+        SignatureHelpTriggerInfo triggerInfo,
+        SignatureHelpOptions options,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets the <see cref="ISignatureHelpProvider"/> and <see cref="SignatureHelpItems"/> associated with
+    /// the position in the document.
+    /// </summary>
+    public async Task<(ISignatureHelpProvider? provider, SignatureHelpItems? bestItems)> GetSignatureHelpAsync(
+        ImmutableArray<ISignatureHelpProvider> providers,
+        Document document,
+        int position,
+        SignatureHelpTriggerInfo triggerInfo,
+        SignatureHelpOptions options,
+        CancellationToken cancellationToken)
+    {
+        ISignatureHelpProvider? bestProvider = null;
+        SignatureHelpItems? bestItems = null;
+
+        // returns the first non-empty quick info found (based on provider order)
+        foreach (var provider in providers)
+        {
+            var items = await TryGetItemsAsync(document, position, triggerInfo, options, provider, cancellationToken).ConfigureAwait(false);
+            if (items is null)
+            {
+                continue;
+            }
+
+            // If another provider provides sig help items, then only take them if they
+            // start after the last batch of items.  i.e. we want the set of items that
+            // conceptually are closer to where the caret position is.  This way if you have:
+            //
+            //  Goo(new Bar($$
+            //
+            // Then invoking sig help will only show the items for "new Bar(" and not also
+            // the items for "Goo(..."
+            if (bestItems is not null && items.ApplicableSpan.Start < bestItems.ApplicableSpan.Start)
+            {
+                continue;
+            }
+
+            bestProvider = provider;
+            bestItems = items;
+        }
+
+        return (bestProvider, bestItems);
+    }
+
+    private static async Task<SignatureHelpItems?> TryGetItemsAsync(Document document, int position, SignatureHelpTriggerInfo triggerInfo, SignatureHelpOptions options, ISignatureHelpProvider provider, CancellationToken cancellationToken)
+    {
+        // We're calling into extensions, we need to make ourselves resilient
+        // to the extension crashing.
+        try
+        {
+            var items = await provider.GetItemsAsync(document, position, triggerInfo, options, cancellationToken).ConfigureAwait(false);
+            if (items is null)
+            {
+                return null;
+            }
+
+            if (!items.ApplicableSpan.IntersectsWith(position))
+            {
+                return null;
+            }
+
+            return items;
+        }
+        catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken, ErrorSeverity.Critical))
+        {
+            return null;
+        }
+    }
+}

src/Features/Core/Portable/SignatureHelp/SignatureHelpServiceWithProviders.cs

@@ -0,0 +1,65 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Utilities;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.SignatureHelp;
+
+/// <summary>
+/// Base class for <see cref="SignatureHelpService"/>'s that delegate to <see cref="ISignatureHelpProvider"/>'s.
+/// </summary>
+internal abstract class SignatureHelpServiceWithProviders : SignatureHelpService
+{
+    private readonly LanguageServices _services;
+    private ImmutableArray<ISignatureHelpProvider> _providers;
+
+    protected SignatureHelpServiceWithProviders(LanguageServices services)
+    {
+        _services = services;
+    }
+
+    private ImmutableArray<ISignatureHelpProvider> GetProviders()
+    {
+        if (_providers.IsDefault)
+        {
+            var mefExporter = _services.SolutionServices.ExportProvider;
+
+            var providers = ExtensionOrderer
+                .Order(mefExporter.GetExports<ISignatureHelpProvider, OrderableLanguageMetadata>()
+                    .Where(lz => lz.Metadata.Language == _services.Language))
+                .Select(lz => lz.Value)
+                .ToImmutableArray();
+
+            ImmutableInterlocked.InterlockedCompareExchange(ref _providers, providers, default);
+        }
+
+        return _providers;
+    }
+
+    public override Task<(ISignatureHelpProvider? provider, SignatureHelpItems? bestItems)> GetSignatureHelpAsync(
+        Document document,
+        int position,
+        SignatureHelpTriggerInfo triggerInfo,
+        SignatureHelpOptions options,
+        CancellationToken cancellationToken)
+    {
+        return GetSignatureHelpAsync(
+            GetProviders(),
+            document,
+            position,
+            triggerInfo,
+            options,
+            cancellationToken);
+    }
+}
+