Remove Coby related interfaces.

src/EditorFeatures/CSharp/FindReferences/CSharpFindReferencesService.cs

@@ -14,9 +14,8 @@ internal class CSharpFindReferencesService : AbstractFindReferencesService
         [ImportingConstructor]
         public CSharpFindReferencesService(
             [ImportMany] IEnumerable<IDefinitionsAndReferencesPresenter> referencedSymbolsPresenters,
-            [ImportMany] IEnumerable<INavigableItemsPresenter> navigableItemsPresenters,
-            [ImportMany] IEnumerable<IFindReferencesResultProvider> externalReferencesProviders)
-            : base(referencedSymbolsPresenters, navigableItemsPresenters, externalReferencesProviders)
+            [ImportMany] IEnumerable<INavigableItemsPresenter> navigableItemsPresenters)
+            : base(referencedSymbolsPresenters, navigableItemsPresenters)
         {
         }
     }
@@ -27,9 +26,8 @@ internal class CSharpStreamingFindReferencesService : AbstractFindReferencesServ
         [ImportingConstructor]
         public CSharpStreamingFindReferencesService(
             [ImportMany] IEnumerable<IDefinitionsAndReferencesPresenter> referencedSymbolsPresenters,
-            [ImportMany] IEnumerable<INavigableItemsPresenter> navigableItemsPresenters,
-            [ImportMany] IEnumerable<IFindReferencesResultProvider> externalReferencesProviders)
-            : base(referencedSymbolsPresenters, navigableItemsPresenters, externalReferencesProviders)
+            [ImportMany] IEnumerable<INavigableItemsPresenter> navigableItemsPresenters)
+            : base(referencedSymbolsPresenters, navigableItemsPresenters)
         {
         }
     }

src/EditorFeatures/CSharp/GoToDefinition/CSharpGoToDefinitionService.cs

@@ -14,8 +14,8 @@ internal class CSharpGoToDefinitionService : AbstractGoToDefinitionService
     {
         [ImportingConstructor]
         public CSharpGoToDefinitionService(
-            [ImportMany]IEnumerable<Lazy<INavigableItemsPresenter>> presenters,
-            [ImportMany]IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders) : base(presenters, externalDefinitionProviders)
+            [ImportMany]IEnumerable<Lazy<INavigableItemsPresenter>> presenters) 
+            : base(presenters)
         {
         }
 
@@ -24,4 +24,4 @@ protected override ISymbol FindRelatedExplicitlyDeclaredSymbol(ISymbol symbol, C
             return symbol;
         }
     }
-}
+}
\ No newline at end of file

src/EditorFeatures/CSharp/GoToImplementation/CSharpGoToImplementationService.cs

@@ -14,8 +14,8 @@ internal sealed class CSharpGoToImplementationService : AbstractGoToImplementati
     {
         [ImportingConstructor]
         public CSharpGoToImplementationService(
-            [ImportMany]IEnumerable<Lazy<INavigableItemsPresenter>> presenters,
-            [ImportMany]IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders) : base(presenters, externalDefinitionProviders)
+            [ImportMany]IEnumerable<Lazy<INavigableItemsPresenter>> presenters) 
+            : base(presenters)
         {
         }
     }

src/EditorFeatures/Core/EditorFeatures.csproj

@@ -256,8 +256,6 @@
     <Compile Include="Implementation\Diagnostics\SuggestionTag.cs" />
     <Compile Include="Implementation\FindReferences\AbstractFindReferencesService.ProgressAdapter.cs" />
     <Compile Include="Implementation\FindReferences\FindReferencesContext.cs" />
-    <Compile Include="Implementation\FindReferences\IFindReferencesNavigableItemResultProvider.cs" />
-    <Compile Include="Implementation\GoToDefinition\INavigableDefinitionProvider.cs" />
     <Compile Include="Implementation\GoToImplementation\AbstractGoToImplementationService.cs" />
     <Compile Include="Implementation\GoToImplementation\IGoToImplementationService.cs" />
     <Compile Include="Implementation\Intellisense\Completion\BraceCompletionMetadata.cs" />
@@ -782,4 +780,4 @@
     <Folder Include="Extensibility\Navigation\" />
   </ItemGroup>
   <Import Project="..\..\..\build\Targets\Imports.targets" />
-</Project>
+</Project>
\ No newline at end of file

src/EditorFeatures/Core/Implementation/FindReferences/AbstractFindReferencesService.cs

@@ -21,16 +21,13 @@ internal abstract partial class AbstractFindReferencesService :
     {
         private readonly IEnumerable<IDefinitionsAndReferencesPresenter> _referenceSymbolPresenters;
         private readonly IEnumerable<INavigableItemsPresenter> _navigableItemPresenters;
-        private readonly IEnumerable<IFindReferencesResultProvider> _externalReferencesProviders;
 
         protected AbstractFindReferencesService(
             IEnumerable<IDefinitionsAndReferencesPresenter> referenceSymbolPresenters,
-            IEnumerable<INavigableItemsPresenter> navigableItemPresenters,
-            IEnumerable<IFindReferencesResultProvider> externalReferencesProviders)
+            IEnumerable<INavigableItemsPresenter> navigableItemPresenters)
         {
             _referenceSymbolPresenters = referenceSymbolPresenters;
             _navigableItemPresenters = navigableItemPresenters;
-            _externalReferencesProviders = externalReferencesProviders;
         }
 
         /// <summary>
@@ -68,22 +65,6 @@ internal abstract partial class AbstractFindReferencesService :
             return Tuple.Create(mapping.Symbol, mapping.Project);
         }
 
-        /// <summary>
-        /// Finds references using the externally defined <see cref="IFindReferencesResultProvider"/>s.
-        /// </summary>
-        private async Task AddExternalReferencesAsync(Document document, int position, ArrayBuilder<INavigableItem> builder, CancellationToken cancellationToken)
-        {
-            // CONSIDER: Do the computation in parallel.
-            foreach (var provider in _externalReferencesProviders)
-            {
-                var references = await provider.FindReferencesAsync(document, position, cancellationToken).ConfigureAwait(false);
-                if (references != null)
-                {
-                    builder.AddRange(references.WhereNotNull());
-                }
-            }
-        }
-
         private async Task<Tuple<IEnumerable<ReferencedSymbol>, Solution>> FindReferencedSymbolsAsync(
             Document document, int position, IWaitContext waitContext)
         {
@@ -116,47 +97,12 @@ private static string GetDisplayName(ISymbol symbol)
         public bool TryFindReferences(Document document, int position, IWaitContext waitContext)
         {
             var cancellationToken = waitContext.CancellationToken;
-            var workspace = document.Project.Solution.Workspace;
-
-            // First see if we have any external navigable item references.
-            // If so, we display the results as navigable items.
-            var succeeded = TryFindAndDisplayNavigableItemsReferencesAsync(document, position, waitContext).WaitAndGetResult(cancellationToken);
-            if (succeeded)
-            {
-                return true;
-            }
 
             // Otherwise, fall back to displaying SymbolFinder based references.
             var result = this.FindReferencedSymbolsAsync(document, position, waitContext).WaitAndGetResult(cancellationToken);
             return TryDisplayReferences(result);
         }
 
-        /// <summary>
-        /// Attempts to find and display navigable item references, including the references provided by external providers.
-        /// </summary>
-        /// <returns>False if there are no external references or display was not successful.</returns>
-        private async Task<bool> TryFindAndDisplayNavigableItemsReferencesAsync(Document document, int position, IWaitContext waitContext)
-        {
-            var foundReferences = false;
-            if (_externalReferencesProviders.Any())
-            {
-                var cancellationToken = waitContext.CancellationToken;
-                var builder = ArrayBuilder<INavigableItem>.GetInstance();
-                await AddExternalReferencesAsync(document, position, builder, cancellationToken).ConfigureAwait(false);
-
-                // TODO: Merging references from SymbolFinder and external providers might lead to duplicate or counter-intuitive results.
-                // TODO: For now, we avoid merging and just display the results either from SymbolFinder or the external result providers but not both.
-                if (builder.Count > 0 && TryDisplayReferences(builder))
-                {
-                    foundReferences = true;
-                }
-
-                builder.Free();
-            }
-
-            return foundReferences;
-        }
-
         private bool TryDisplayReferences(IEnumerable<INavigableItem> result)
         {
             if (result != null && result.Any())

src/EditorFeatures/Core/Implementation/FindReferences/IFindReferencesNavigableItemResultProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Navigation;
-
-namespace Microsoft.CodeAnalysis.Editor
-{
-    internal interface IFindReferencesResultProvider
-    {
-        /// <summary>
-        /// Compute navigable reference items for the symbol referenced or defined at the given position in the given document.
-        /// </summary>
-        Task<IEnumerable<INavigableItem>> FindReferencesAsync(Document document, int position, CancellationToken cancellationToken);
-    }
-}

src/EditorFeatures/Core/Implementation/GoToDefinition/AbstractGoToDefinitionService.cs

@@ -17,14 +17,13 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.GoToDefinition
     internal abstract class AbstractGoToDefinitionService : IGoToDefinitionService
     {
         private readonly IEnumerable<Lazy<INavigableItemsPresenter>> _presenters;
-        private readonly IEnumerable<Lazy<INavigableDefinitionProvider>> _externalDefinitionProviders;
 
         protected abstract ISymbol FindRelatedExplicitlyDeclaredSymbol(ISymbol symbol, Compilation compilation);
 
-        protected AbstractGoToDefinitionService(IEnumerable<Lazy<INavigableItemsPresenter>> presenters, IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders)
+        protected AbstractGoToDefinitionService(
+            IEnumerable<Lazy<INavigableItemsPresenter>> presenters)
         {
             _presenters = presenters;
-            _externalDefinitionProviders = externalDefinitionProviders;
         }
 
         private async Task<ISymbol> FindSymbolAsync(Document document, int position, CancellationToken cancellationToken)
@@ -59,11 +58,6 @@ public async Task<IEnumerable<INavigableItem>> FindDefinitionsAsync(Document doc
             var items = symbol != null
                 ? NavigableItemFactory.GetItemsFromPreferredSourceLocations(document.Project.Solution, symbol, displayTaggedParts: null)
                 : null;
-            if (items == null || items.IsEmpty())
-            {
-                // Fallback to asking the navigation definition providers for navigable definition locations.
-                items = await GoToDefinitionHelpers.FindExternalDefinitionsAsync(document, position, _externalDefinitionProviders, cancellationToken).ConfigureAwait(false);
-            }
 
             // realize the list here so that the consumer await'ing the result doesn't lazily cause
             // them to be created on an inappropriate thread.
@@ -74,21 +68,19 @@ public bool TryGoToDefinition(Document document, int position, CancellationToken
         {
             // First try to compute the referenced symbol and attempt to go to definition for the symbol.
             var symbol = FindSymbolAsync(document, position, cancellationToken).WaitAndGetResult(cancellationToken);
-            if (symbol != null)
+            if (symbol == null)
             {
-                var isThirdPartyNavigationAllowed = IsThirdPartyNavigationAllowed(symbol, position, document, cancellationToken);
-
-                return GoToDefinitionHelpers.TryGoToDefinition(symbol,
-                    document.Project,
-                    _externalDefinitionProviders,
-                    _presenters,
-                    thirdPartyNavigationAllowed: isThirdPartyNavigationAllowed,
-                    throwOnHiddenDefinition: true,
-                    cancellationToken: cancellationToken);
+                return false;
             }
 
-            // Otherwise, fallback to the external navigation definition providers.
-            return GoToDefinitionHelpers.TryExternalGoToDefinition(document, position, _externalDefinitionProviders, _presenters, cancellationToken);
+            var isThirdPartyNavigationAllowed = IsThirdPartyNavigationAllowed(symbol, position, document, cancellationToken);
+
+            return GoToDefinitionHelpers.TryGoToDefinition(symbol,
+                document.Project,
+                _presenters,
+                thirdPartyNavigationAllowed: isThirdPartyNavigationAllowed,
+                throwOnHiddenDefinition: true,
+                cancellationToken: cancellationToken);
         }
 
         private static bool IsThirdPartyNavigationAllowed(ISymbol symbolToNavigateTo, int caretPosition, Document document, CancellationToken cancellationToken)

src/EditorFeatures/Core/Implementation/GoToDefinition/GoToDefinitionHelpers.cs

@@ -20,7 +20,6 @@ internal static class GoToDefinitionHelpers
         public static bool TryGoToDefinition(
             ISymbol symbol,
             Project project,
-            IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders,
             IEnumerable<Lazy<INavigableItemsPresenter>> presenters,
             CancellationToken cancellationToken,
             bool thirdPartyNavigationAllowed = true,
@@ -71,16 +70,6 @@ internal static class GoToDefinitionHelpers
 
             if (!preferredSourceLocations.Any())
             {
-                // Attempt to find source locations from external definition providers.
-                if (thirdPartyNavigationAllowed && externalDefinitionProviders.Any())
-                {
-                    var externalSourceDefinitions = FindExternalDefinitionsAsync(symbol, project, externalDefinitionProviders, cancellationToken).WaitAndGetResult(cancellationToken).ToImmutableArray();
-                    if (externalSourceDefinitions.Length > 0)
-                    {
-                        return TryGoToDefinition(externalSourceDefinitions, title, options, presenters, throwOnHiddenDefinition);
-                    }
-                }
-
                 // If there are no visible source locations, then tell the host about the symbol and 
                 // allow it to navigate to it.  This will either navigate to any non-visible source
                 // locations, or it can appropriately deal with metadata symbols for hosts that can go 
@@ -153,55 +142,6 @@ internal static class GoToDefinitionHelpers
             }
         }
 
-        public static async Task<IEnumerable<INavigableItem>> FindExternalDefinitionsAsync(Document document, int position, IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders, CancellationToken cancellationToken)
-        {
-            foreach (var definitionProvider in externalDefinitionProviders)
-            {
-                var definitions = await definitionProvider.Value.FindDefinitionsAsync(document, position, cancellationToken).ConfigureAwait(false);
-                if (definitions != null && definitions.Any())
-                {
-                    var preferredDefinitions = NavigableItemFactory.GetPreferredNavigableItems(document.Project.Solution, definitions);
-                    if (preferredDefinitions.Any())
-                    {
-                        return preferredDefinitions;
-                    }
-                }
-            }
-
-            return SpecializedCollections.EmptyEnumerable<INavigableItem>();
-        }
-
-        public static async Task<IEnumerable<INavigableItem>> FindExternalDefinitionsAsync(ISymbol symbol, Project project, IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders, CancellationToken cancellationToken)
-        {
-            foreach (var definitionProvider in externalDefinitionProviders)
-            {
-                var definitions = await definitionProvider.Value.FindDefinitionsAsync(project, symbol, cancellationToken).ConfigureAwait(false);
-                if (definitions != null && definitions.Any())
-                {
-                    var preferredDefinitions = NavigableItemFactory.GetPreferredNavigableItems(project.Solution, definitions);
-                    if (preferredDefinitions.Any())
-                    {
-                        return preferredDefinitions;
-                    }
-                }
-            }
-
-            return SpecializedCollections.EmptyEnumerable<INavigableItem>();
-        }
-
-        public static bool TryExternalGoToDefinition(Document document, int position, IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders, IEnumerable<Lazy<INavigableItemsPresenter>> presenters, CancellationToken cancellationToken)
-        {
-            var externalDefinitions = FindExternalDefinitionsAsync(document, position, externalDefinitionProviders, cancellationToken).WaitAndGetResult(cancellationToken);
-            if (externalDefinitions != null && externalDefinitions.Any())
-            {
-                var itemsArray = externalDefinitions.ToImmutableArrayOrEmpty();
-                var title = itemsArray[0].DisplayTaggedParts.JoinText();
-                return TryGoToDefinition(externalDefinitions.ToImmutableArrayOrEmpty(), title, document.Project.Solution.Workspace.Options, presenters, throwOnHiddenDefinition: true);
-            }
-
-            return false;
-        }
-
         private static bool TryThirdPartyNavigation(ISymbol symbol, Solution solution)
         {
             var symbolNavigationService = solution.Workspace.Services.GetService<ISymbolNavigationService>();
@@ -210,4 +150,4 @@ private static bool TryThirdPartyNavigation(ISymbol symbol, Solution solution)
             return symbolNavigationService.TrySymbolNavigationNotify(symbol, solution);
         }
     }
-}
+}
\ No newline at end of file

src/EditorFeatures/Core/Implementation/GoToDefinition/INavigableDefinitionProvider.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Navigation;
-
-namespace Microsoft.CodeAnalysis.Editor
-{
-    internal interface INavigableDefinitionProvider
-    {
-        /// <summary>
-        /// Find definitions for the symbol referenced or defined at the given position in the given document.
-        /// </summary>
-        Task<IEnumerable<INavigableItem>> FindDefinitionsAsync(Document document, int position, CancellationToken cancellationToken);
-
-        /// <summary>
-        /// Find definitions for the given symbol in the context of the given project.
-        /// </summary>
-        Task<IEnumerable<INavigableItem>> FindDefinitionsAsync(Project project, ISymbol symbol, CancellationToken cancellationToken);
-    }
-}
\ No newline at end of file

src/EditorFeatures/Core/Implementation/GoToImplementation/AbstractGoToImplementationService.cs

@@ -17,14 +17,11 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.GoToImplementation
     internal abstract class AbstractGoToImplementationService : IGoToImplementationService
     {
         private readonly IEnumerable<Lazy<INavigableItemsPresenter>> _navigableItemPresenters;
-        private readonly IEnumerable<Lazy<INavigableDefinitionProvider>> _externalDefinitionProviders;
 
         public AbstractGoToImplementationService(
-            IEnumerable<Lazy<INavigableItemsPresenter>> navigableItemPresenters,
-            IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders)
+            IEnumerable<Lazy<INavigableItemsPresenter>> navigableItemPresenters)
         {
             _navigableItemPresenters = navigableItemPresenters;
-            _externalDefinitionProviders = externalDefinitionProviders;
         }
 
         public bool TryGoToImplementation(Document document, int position, CancellationToken cancellationToken, out string message)
@@ -42,10 +39,6 @@ public bool TryGoToImplementation(Document document, int position, CancellationT
                     return TryGoToImplementationOnMappedSymbol(mapping, cancellationToken, out message);
                 }
             }
-            else
-            {
-                return TryExternalGotoDefinition(document, position, cancellationToken, out message);
-            }
 
             message = EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret;
             return false;
@@ -100,7 +93,7 @@ private bool TryGoToImplementationOnMappedSymbol(SymbolMappingResult mapping, Ca
             else
             {
                 // This is something boring like a regular method or type, so we'll just go there directly
-                if (GoToDefinition.GoToDefinitionHelpers.TryGoToDefinition(mapping.Symbol, mapping.Project, _externalDefinitionProviders, _navigableItemPresenters, cancellationToken))
+                if (GoToDefinition.GoToDefinitionHelpers.TryGoToDefinition(mapping.Symbol, mapping.Project, _navigableItemPresenters, cancellationToken))
                 {
                     message = null;
                     return true;
@@ -126,7 +119,7 @@ private bool TryGoToImplementations(IEnumerable<ISymbol> candidateImplementation
             }
             else if (implementations.Count == 1)
             {
-                GoToDefinition.GoToDefinitionHelpers.TryGoToDefinition(implementations.Single(), mapping.Project, _externalDefinitionProviders, _navigableItemPresenters, cancellationToken);
+                GoToDefinition.GoToDefinitionHelpers.TryGoToDefinition(implementations.Single(), mapping.Project, _navigableItemPresenters, cancellationToken);
                 message = null;
                 return true;
             }
@@ -155,19 +148,5 @@ private static IEnumerable<INavigableItem> CreateItemsForImplementation(ISymbol
                 implementation,
                 displayTaggedParts: symbolDisplayService.ToDisplayParts(implementation).ToTaggedText());
         }
-
-        private bool TryExternalGotoDefinition(Document document, int position, CancellationToken cancellationToken, out string message)
-        {
-            if (GoToDefinition.GoToDefinitionHelpers.TryExternalGoToDefinition(document, position, _externalDefinitionProviders, _navigableItemPresenters, cancellationToken))
-            {
-                message = null;
-                return true;
-            }
-            else
-            {
-                message = EditorFeaturesResources.Cannot_navigate_to_the_symbol_under_the_caret;
-                return false;
-            }
-        }
     }
-}
+}
\ No newline at end of file

src/EditorFeatures/Test2/GoToDefinition/GoToDefinitionCommandHandlerTests.vb

@@ -100,7 +100,7 @@ class C
                 Dim cursorBuffer = cursorDocument.TextBuffer
                 Dim document = workspace.CurrentSolution.GetDocument(cursorDocument.Id)
 
-                Dim goToDefService = New CSharpGoToDefinitionService(presenters, {})
+                Dim goToDefService = New CSharpGoToDefinitionService(presenters)
 
                 Dim waitContext = New TestWaitContext(updatesBeforeCancel)
                 Dim waitIndicator = New TestWaitIndicator(waitContext)

src/EditorFeatures/Test2/GoToDefinition/GoToDefinitionTests.vb

@@ -11,10 +11,10 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.GoToDefinition
     Public Class GoToDefinitionTests
         Private Function TestAsync(workspaceDefinition As XElement, Optional expectedResult As Boolean = True) As Tasks.Task
             Return GoToTestHelpers.TestAsync(workspaceDefinition, expectedResult,
-                Function(document As Document, cursorPosition As Integer, presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)), externalDefinitionProviders As IEnumerable(Of Lazy(Of INavigableDefinitionProvider)))
+                Function(document As Document, cursorPosition As Integer, presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)))
                     Dim goToDefService = If(document.Project.Language = LanguageNames.CSharp,
-                        DirectCast(New CSharpGoToDefinitionService(presenters, externalDefinitionProviders), IGoToDefinitionService),
-                        New VisualBasicGoToDefinitionService(presenters, externalDefinitionProviders))
+                        DirectCast(New CSharpGoToDefinitionService(presenters), IGoToDefinitionService),
+                        New VisualBasicGoToDefinitionService(presenters))
 
                     Return goToDefService.TryGoToDefinition(document, cursorPosition, CancellationToken.None)
                 End Function)

src/EditorFeatures/Test2/GoToImplementation/GoToImplementationTests.vb

@@ -11,10 +11,10 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.GoToImplementation
     Public Class GoToImplementationTests
         Private Function TestAsync(workspaceDefinition As XElement, Optional shouldSucceed As Boolean = True) As Tasks.Task
             Return GoToTestHelpers.TestAsync(workspaceDefinition, shouldSucceed,
-                Function(document As Document, cursorPosition As Integer, presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)), externalDefinitionProviders As IEnumerable(Of Lazy(Of INavigableDefinitionProvider)))
+                Function(document As Document, cursorPosition As Integer, presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)))
                     Dim service = If(document.Project.Language = LanguageNames.CSharp,
-                        DirectCast(New CSharpGoToImplementationService(presenters, externalDefinitionProviders), IGoToImplementationService),
-                        New VisualBasicGoToImplementationService(presenters, externalDefinitionProviders))
+                        DirectCast(New CSharpGoToImplementationService(presenters), IGoToImplementationService),
+                        New VisualBasicGoToImplementationService(presenters))
 
                     Dim message As String = Nothing
                     Return service.TryGoToImplementation(document, cursorPosition, CancellationToken.None, message)

src/EditorFeatures/TestUtilities2/Utilities/GoToHelpers/GoToTestHelpers.vb

@@ -17,7 +17,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities.GoToHelpers
 
         Public ReadOnly ExportProvider As ExportProvider = MinimalTestExportProvider.CreateExportProvider(Catalog)
 
-        Public Async Function TestAsync(workspaceDefinition As XElement, expectedResult As Boolean, executeOnDocument As Func(Of Document, Integer, IEnumerable(Of Lazy(Of INavigableItemsPresenter)), IEnumerable(Of Lazy(Of INavigableDefinitionProvider)), Boolean)) As System.Threading.Tasks.Task
+        Public Async Function TestAsync(workspaceDefinition As XElement, expectedResult As Boolean, executeOnDocument As Func(Of Document, Integer, IEnumerable(Of Lazy(Of INavigableItemsPresenter)), Boolean)) As System.Threading.Tasks.Task
             Using workspace = Await TestWorkspace.CreateAsync(workspaceDefinition, exportProvider:=ExportProvider)
                 Dim solution = workspace.CurrentSolution
                 Dim cursorDocument = workspace.Documents.First(Function(d) d.CursorPosition.HasValue)
@@ -41,7 +41,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Utilities.GoToHelpers
 
                 Dim presenter = New MockNavigableItemsPresenter(Sub(i) items = i)
                 Dim presenters = {New Lazy(Of INavigableItemsPresenter)(Function() presenter)}
-                Dim actualResult = executeOnDocument(document, cursorPosition, presenters, {})
+                Dim actualResult = executeOnDocument(document, cursorPosition, presenters)
 
                 Assert.Equal(expectedResult, actualResult)
 

src/EditorFeatures/VisualBasic/FindReferences/VisualBasicFindReferencesService.vb

@@ -12,9 +12,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.FindReferences
 
         <ImportingConstructor>
         Protected Sub New(<ImportMany> referencedSymbolsPresenters As IEnumerable(Of IDefinitionsAndReferencesPresenter),
-                          <ImportMany> navigableItemsPresenters As IEnumerable(Of INavigableItemsPresenter),
-                          <ImportMany> externalReferencesProviders As IEnumerable(Of IFindReferencesResultProvider))
-            MyBase.New(referencedSymbolsPresenters, navigableItemsPresenters, externalReferencesProviders)
+                          <ImportMany> navigableItemsPresenters As IEnumerable(Of INavigableItemsPresenter))
+            MyBase.New(referencedSymbolsPresenters, navigableItemsPresenters)
         End Sub
     End Class
 
@@ -24,9 +23,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.FindReferences
 
         <ImportingConstructor>
         Protected Sub New(<ImportMany> referencedSymbolsPresenters As IEnumerable(Of IDefinitionsAndReferencesPresenter),
-                          <ImportMany> navigableItemsPresenters As IEnumerable(Of INavigableItemsPresenter),
-                          <ImportMany> externalReferencesProviders As IEnumerable(Of IFindReferencesResultProvider))
-            MyBase.New(referencedSymbolsPresenters, navigableItemsPresenters, externalReferencesProviders)
+                          <ImportMany> navigableItemsPresenters As IEnumerable(Of INavigableItemsPresenter))
+            MyBase.New(referencedSymbolsPresenters, navigableItemsPresenters)
         End Sub
     End Class
 End Namespace
\ No newline at end of file

src/EditorFeatures/VisualBasic/GoToDefinition/VisualBasicGoToDefinitionService.vb

@@ -12,12 +12,12 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.GoToDefinition
         Inherits AbstractGoToDefinitionService
 
         <ImportingConstructor>
-        Public Sub New(<ImportMany> presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)), <ImportMany> externalDefinitionProviders As IEnumerable(Of Lazy(Of INavigableDefinitionProvider)))
-            MyBase.New(presenters, externalDefinitionProviders)
+        Public Sub New(<ImportMany> presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)))
+            MyBase.New(presenters)
         End Sub
 
         Protected Overrides Function FindRelatedExplicitlyDeclaredSymbol(symbol As ISymbol, compilation As Compilation) As ISymbol
             Return symbol.FindRelatedExplicitlyDeclaredSymbol(compilation)
         End Function
     End Class
-End Namespace
+End Namespace
\ No newline at end of file

src/EditorFeatures/VisualBasic/GoToImplementation/VisualBasicGoToImplementationService.vb

@@ -11,8 +11,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.GoToImplementation
         Inherits AbstractGoToImplementationService
 
         <ImportingConstructor>
-        Public Sub New(<ImportMany> presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)), <ImportMany> externalDefinitionProviders As IEnumerable(Of Lazy(Of INavigableDefinitionProvider)))
-            MyBase.New(presenters, externalDefinitionProviders)
+        Public Sub New(<ImportMany> presenters As IEnumerable(Of Lazy(Of INavigableItemsPresenter)))
+            MyBase.New(presenters)
         End Sub
     End Class
 End Namespace

src/VisualStudio/Core/Impl/RoslynVisualStudioWorkspace.cs

@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Implementation.GoToDefinition;
 using Microsoft.CodeAnalysis.Editor.Undo;
@@ -30,7 +29,6 @@ internal class RoslynVisualStudioWorkspace : VisualStudioWorkspaceImpl
     {
         private readonly IEnumerable<Lazy<INavigableItemsPresenter>> _navigableItemsPresenters;
         private readonly IEnumerable<Lazy<IDefinitionsAndReferencesPresenter>> _referencedSymbolsPresenters;
-        private readonly IEnumerable<Lazy<INavigableDefinitionProvider>> _externalDefinitionProviders;
 
         [ImportingConstructor]
         private RoslynVisualStudioWorkspace(
@@ -38,7 +36,6 @@ internal class RoslynVisualStudioWorkspace : VisualStudioWorkspaceImpl
             SaveEventsService saveEventsService,
             [ImportMany] IEnumerable<Lazy<INavigableItemsPresenter>> navigableItemsPresenters,
             [ImportMany] IEnumerable<Lazy<IDefinitionsAndReferencesPresenter>> referencedSymbolsPresenters,
-            [ImportMany] IEnumerable<Lazy<INavigableDefinitionProvider>> externalDefinitionProviders,
             [ImportMany] IEnumerable<IDocumentOptionsProviderFactory> documentOptionsProviderFactories)
             : base(
                 serviceProvider,
@@ -50,7 +47,6 @@ internal class RoslynVisualStudioWorkspace : VisualStudioWorkspaceImpl
 
             _navigableItemsPresenters = navigableItemsPresenters;
             _referencedSymbolsPresenters = referencedSymbolsPresenters;
-            _externalDefinitionProviders = externalDefinitionProviders;
 
             foreach (var providerFactory in documentOptionsProviderFactories)
             {
@@ -190,15 +186,14 @@ public override bool TryGoToDefinition(ISymbol symbol, Project project, Cancella
                 return false;
             }
 
-            ISymbol searchSymbol;
-            Project searchProject;
-            if (!TryResolveSymbol(symbol, project, cancellationToken, out searchSymbol, out searchProject))
+            if (!TryResolveSymbol(symbol, project, cancellationToken, 
+                    out var searchSymbol, out var searchProject))
             {
                 return false;
             }
 
             return GoToDefinitionHelpers.TryGoToDefinition(
-                searchSymbol, searchProject, _externalDefinitionProviders, _navigableItemsPresenters, cancellationToken: cancellationToken);
+                searchSymbol, searchProject, _navigableItemsPresenters, cancellationToken: cancellationToken);
         }
 
         public override bool TryFindAllReferences(ISymbol symbol, Project project, CancellationToken cancellationToken)
@@ -208,9 +203,7 @@ public override bool TryFindAllReferences(ISymbol symbol, Project project, Cance
                 return false;
             }
 
-            ISymbol searchSymbol;
-            Project searchProject;
-            if (!TryResolveSymbol(symbol, project, cancellationToken, out searchSymbol, out searchProject))
+            if (!TryResolveSymbol(symbol, project, cancellationToken, out var searchSymbol, out var searchProject))
             {
                 return false;
             }
@@ -309,4 +302,4 @@ internal override object GetBrowseObject(SymbolListItem symbolListItem)
             return null;
         }
     }
-}
+}
\ No newline at end of file

src/VisualStudio/Core/Test/GoToDefinition/GoToDefinitionApiTests.vb

@@ -39,7 +39,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.GoToDefinition
 
                 WpfTestCase.RequireWpfFact($"{NameOf(GoToDefinitionHelpers)}.{NameOf(GoToDefinitionHelpers.TryGoToDefinition)} assumes it's on the UI thread with a WaitAndGetResult call")
                 Dim success = GoToDefinitionHelpers.TryGoToDefinition(
-                    symbolInfo.Symbol, document.Project, {}, {New Lazy(Of INavigableItemsPresenter)(Function() presenter)}, thirdPartyNavigationAllowed:=True, throwOnHiddenDefinition:=False, cancellationToken:=CancellationToken.None)
+                    symbolInfo.Symbol, document.Project, {New Lazy(Of INavigableItemsPresenter)(Function() presenter)}, thirdPartyNavigationAllowed:=True, throwOnHiddenDefinition:=False, cancellationToken:=CancellationToken.None)
 
                 Assert.Equal(expectSuccess, success)
             End Using