Esempio n. 1
0
        /// <summary>
        /// Finds references using <see cref="SymbolFinder.FindReferencesAsync(ISymbol, Solution, CancellationToken)"/>
        /// </summary>
        private async Task AddSymbolReferencesAsync(Document document, int position, ArrayBuilder <INavigableItem> builder, IWaitContext waitContext)
        {
            var result = await this.FindReferencedSymbolsAsync(document, position, waitContext).ConfigureAwait(false);

            if (result != null)
            {
                var referencedSymbols = result.Item1;
                var searchSolution    = result.Item2;

                var q = from r in referencedSymbols
                        from loc in r.Locations
                        select NavigableItemFactory.GetItemFromSymbolLocation(searchSolution, r.Definition, loc.Location);

                builder.AddRange(q);
            }
        }
        private static bool TryPresentInNavigableItemsPresenter(
            Solution solution, ISymbol symbol,
            IEnumerable <Lazy <INavigableItemsPresenter> > presenters,
            string title, Location[] locations)
        {
            var presenter = presenters.FirstOrDefault();

            if (presenter != null)
            {
                var navigableItems = locations.Select(location =>
                                                      NavigableItemFactory.GetItemFromSymbolLocation(
                                                          solution, symbol, location,
                                                          displayTaggedParts: null)).ToImmutableArray();

                presenter.Value.DisplayResult(title, navigableItems);
                return(true);
            }

            return(false);
        }
        public async Task <IEnumerable <INavigableItem> > FindReferencesAsync(Document document, int position, IWaitContext waitContext)
        {
            var cancellationToken = waitContext.CancellationToken;
            var result            = await this.FindReferencedSymbolsAsync(document, position, waitContext).ConfigureAwait(false);

            if (result == null)
            {
                return(SpecializedCollections.EmptyEnumerable <INavigableItem>());
            }

            var referencedSymbols = result.Item1;
            var searchSolution    = result.Item2;

            var q = from r in referencedSymbols
                    from loc in r.Locations
                    select NavigableItemFactory.GetItemFromSymbolLocation(searchSolution, r.Definition, loc.Location);

            // realize the list here so that the consumer await'ing the result doesn't lazily cause
            // them to be created on an inapropriate thread.
            return(q.ToList());
        }
        public static bool TryGoToDefinition(
            ISymbol symbol,
            Project project,
            IEnumerable <Lazy <INavigableItemsPresenter> > presenters,
            IEnumerable <Lazy <IStreamingFindUsagesPresenter> > streamingPresenters,
            CancellationToken cancellationToken,
            bool thirdPartyNavigationAllowed = true,
            bool throwOnHiddenDefinition     = false)
        {
            var alias = symbol as IAliasSymbol;

            if (alias != null)
            {
                var ns = alias.Target as INamespaceSymbol;
                if (ns != null && ns.IsGlobalNamespace)
                {
                    return(false);
                }
            }

            // VB global import aliases have a synthesized SyntaxTree.
            // We can't go to the definition of the alias, so use the target type.

            var solution = project.Solution;

            if (symbol is IAliasSymbol &&
                NavigableItemFactory.GetPreferredSourceLocations(solution, symbol).All(l => project.Solution.GetDocument(l.SourceTree) == null))
            {
                symbol = ((IAliasSymbol)symbol).Target;
            }

            var definition = SymbolFinder.FindSourceDefinitionAsync(symbol, solution, cancellationToken).WaitAndGetResult(cancellationToken);

            cancellationToken.ThrowIfCancellationRequested();

            symbol = definition ?? symbol;

            if (thirdPartyNavigationAllowed && TryThirdPartyNavigation(symbol, solution))
            {
                return(true);
            }

            // If it is a partial method declaration with no body, choose to go to the implementation
            // that has a method body.
            if (symbol is IMethodSymbol)
            {
                symbol = ((IMethodSymbol)symbol).PartialImplementationPart ?? symbol;
            }

            var options = project.Solution.Options;

            var preferredSourceLocations = NavigableItemFactory.GetPreferredSourceLocations(solution, symbol).ToArray();
            var displayParts             = NavigableItemFactory.GetSymbolDisplayTaggedParts(project, symbol);
            var title = displayParts.JoinText();

            if (preferredSourceLocations.Length == 0)
            {
                // 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
                // to a metadata-as-source view.

                var symbolNavigationService = solution.Workspace.Services.GetService <ISymbolNavigationService>();
                return(symbolNavigationService.TryNavigateToSymbol(
                           symbol, project,
                           options: options.WithChangedOption(NavigationOptions.PreferProvisionalTab, true),
                           cancellationToken: cancellationToken));
            }
            else if (preferredSourceLocations.Length == 1)
            {
                var item = NavigableItemFactory.GetItemFromSymbolLocation(
                    solution, symbol, preferredSourceLocations[0],
                    displayTaggedParts: null);
                return(TryGoToSingleLocation(item, options, throwOnHiddenDefinition));
            }
            else
            {
                // We have multiple viable source locations, so ask the host what to do. Most hosts
                // will simply display the results to the user and allow them to choose where to
                // go.

                return(TryPresentInFindUsagesPresenter(solution, symbol, streamingPresenters, cancellationToken) ||
                       TryPresentInNavigableItemsPresenter(solution, symbol, presenters, title, preferredSourceLocations));
            }
        }
Esempio n. 5
0
        public static bool TryGoToDefinition(
            ISymbol symbol,
            Project project,
            IEnumerable <Lazy <INavigableItemsPresenter> > presenters,
            CancellationToken cancellationToken,
            bool thirdPartyNavigationAllowed = true,
            bool throwOnHiddenDefinition     = false)
        {
            var alias = symbol as IAliasSymbol;

            if (alias != null)
            {
                var ns = alias.Target as INamespaceSymbol;
                if (ns != null && ns.IsGlobalNamespace)
                {
                    return(false);
                }
            }

            // VB global import aliases have a synthesized SyntaxTree.
            // We can't go to the definition of the alias, so use the target type.

            var solution = project.Solution;

            if (symbol is IAliasSymbol &&
                NavigableItemFactory.GetPreferredSourceLocations(solution, symbol).All(l => project.Solution.GetDocument(l.SourceTree) == null))
            {
                symbol = ((IAliasSymbol)symbol).Target;
            }

            var definition = SymbolFinder.FindSourceDefinitionAsync(symbol, solution, cancellationToken).WaitAndGetResult(cancellationToken);

            cancellationToken.ThrowIfCancellationRequested();

            symbol = definition ?? symbol;

            if (thirdPartyNavigationAllowed && TryThirdPartyNavigation(symbol, solution))
            {
                return(true);
            }

            // If it is a partial method declaration with no body, choose to go to the implementation
            // that has a method body.
            if (symbol is IMethodSymbol)
            {
                symbol = ((IMethodSymbol)symbol).PartialImplementationPart ?? symbol;
            }

            var preferredSourceLocations = NavigableItemFactory.GetPreferredSourceLocations(solution, symbol).ToArray();

            if (!preferredSourceLocations.Any())
            {
                // 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
                // to a metadata-as-source view.

                var symbolNavigationService = solution.Workspace.Services.GetService <ISymbolNavigationService>();
                return(symbolNavigationService.TryNavigateToSymbol(symbol, project, cancellationToken: cancellationToken, usePreviewTab: true));
            }

            // If we have a single location, then just navigate to it.
            if (preferredSourceLocations.Length == 1)
            {
                var firstItem         = preferredSourceLocations[0];
                var workspace         = project.Solution.Workspace;
                var navigationService = workspace.Services.GetService <IDocumentNavigationService>();

                if (navigationService.CanNavigateToSpan(workspace, solution.GetDocument(firstItem.SourceTree).Id, firstItem.SourceSpan))
                {
                    return(navigationService.TryNavigateToSpan(workspace, solution.GetDocument(firstItem.SourceTree).Id, firstItem.SourceSpan, usePreviewTab: true));
                }
                else
                {
                    if (throwOnHiddenDefinition)
                    {
                        const int E_FAIL = -2147467259;
                        throw new COMException(EditorFeaturesResources.TheDefinitionOfTheObjectIsHidden, E_FAIL);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            else
            {
                // We have multiple viable source locations, so ask the host what to do. Most hosts
                // will simply display the results to the user and allow them to choose where to
                // go.

                if (presenters.Any())
                {
                    presenters.First().Value.DisplayResult(NavigableItemFactory.GetSymbolDisplayString(project, symbol),
                                                           preferredSourceLocations.Select(location => NavigableItemFactory.GetItemFromSymbolLocation(solution, symbol, location)).ToList());

                    return(true);
                }

                return(false);
            }
        }
Esempio n. 6
0
        public static bool TryGoToDefinition(
            ISymbol symbol,
            Project project,
            IEnumerable <Lazy <INavigableDefinitionProvider> > externalDefinitionProviders,
            IEnumerable <Lazy <INavigableItemsPresenter> > presenters,
            CancellationToken cancellationToken,
            bool thirdPartyNavigationAllowed = true,
            bool throwOnHiddenDefinition     = false)
        {
            var alias = symbol as IAliasSymbol;

            if (alias != null)
            {
                var ns = alias.Target as INamespaceSymbol;
                if (ns != null && ns.IsGlobalNamespace)
                {
                    return(false);
                }
            }

            // VB global import aliases have a synthesized SyntaxTree.
            // We can't go to the definition of the alias, so use the target type.

            var solution = project.Solution;

            if (symbol is IAliasSymbol &&
                NavigableItemFactory.GetPreferredSourceLocations(solution, symbol).All(l => project.Solution.GetDocument(l.SourceTree) == null))
            {
                symbol = ((IAliasSymbol)symbol).Target;
            }

            var definition = SymbolFinder.FindSourceDefinitionAsync(symbol, solution, cancellationToken).WaitAndGetResult(cancellationToken);

            cancellationToken.ThrowIfCancellationRequested();

            symbol = definition ?? symbol;

            if (thirdPartyNavigationAllowed && TryThirdPartyNavigation(symbol, solution))
            {
                return(true);
            }

            // If it is a partial method declaration with no body, choose to go to the implementation
            // that has a method body.
            if (symbol is IMethodSymbol)
            {
                symbol = ((IMethodSymbol)symbol).PartialImplementationPart ?? symbol;
            }

            var options = project.Solution.Options;

            var preferredSourceLocations = NavigableItemFactory.GetPreferredSourceLocations(solution, symbol).ToArray();
            var title = NavigableItemFactory.GetSymbolDisplayString(project, symbol);

            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
                // to a metadata-as-source view.

                var symbolNavigationService = solution.Workspace.Services.GetService <ISymbolNavigationService>();
                return(symbolNavigationService.TryNavigateToSymbol(
                           symbol, project,
                           options: options.WithChangedOption(NavigationOptions.PreferProvisionalTab, true),
                           cancellationToken: cancellationToken));
            }

            var navigableItems = preferredSourceLocations.Select(location => NavigableItemFactory.GetItemFromSymbolLocation(solution, symbol, location)).ToImmutableArray();

            return(TryGoToDefinition(navigableItems, title, options, presenters, throwOnHiddenDefinition));
        }