public Task OnReferenceFoundAsync( SymbolAndProjectId definition, ReferenceLocation reference) { return _service.Rpc.InvokeAsync(nameof(OnReferenceFoundAsync), SerializableSymbolAndProjectId.Dehydrate(definition), SerializableReferenceLocation.Dehydrate(reference)); }
private static ISymbol GetEnclosingMethodOrPropertyOrField( SemanticModel semanticModel, ReferenceLocation reference) { var enclosingSymbol = semanticModel.GetEnclosingSymbol(reference.Location.SourceSpan.Start); for (var current = enclosingSymbol; current != null; current = current.ContainingSymbol) { if (current.Kind == SymbolKind.Field) { return current; } if (current.Kind == SymbolKind.Property) { return current; } if (current.Kind == SymbolKind.Method) { var method = (IMethodSymbol)current; if (method.IsAccessor()) { return method.AssociatedSymbol; } if (method.MethodKind != MethodKind.AnonymousFunction) { return method; } } } return null; }
public Task OnReferenceFoundAsync(SymbolAndProjectId definition, ReferenceLocation location) { lock (_gate) { _symbolToLocations[definition].Add(location); } return _underlyingProgress.OnReferenceFoundAsync(definition, location); }
public void OnReferenceFound(ISymbol definition, ReferenceLocation location) { var referenceItem = location.TryCreateSourceReferenceItem( GetDefinitionItem(definition)); if (referenceItem != null) { _context.OnReferenceFound(referenceItem); } }
public async Task OnReferenceFoundAsync(SymbolAndProjectId definition, ReferenceLocation location) { // Ignore duplicate locations. We don't want to clutter the UI with them. if (location.IsDuplicateReferenceLocation) { return; } var referenceItem = location.TryCreateSourceReferenceItem( GetDefinitionItem(definition), includeHiddenLocations: false); if (referenceItem != null) { await _context.OnReferenceFoundAsync(referenceItem).ConfigureAwait(false); } }
private void HandleLocation(ISymbol symbol, ReferenceLocation location) { _foundReferences.GetOrAdd(symbol, s_createSymbolLocations).Add(location); _progress.OnReferenceFound(symbol, location); }
private Task HandleLocationAsync(SymbolAndProjectId symbolAndProjectId, ReferenceLocation location) { return _progress.OnReferenceFoundAsync(symbolAndProjectId, location); }
internal static async Task<IEnumerable<RenameLocation>> GetRenamableReferenceLocationsAsync(ISymbol referencedSymbol, ISymbol originalSymbol, ReferenceLocation location, Solution solution, CancellationToken cancellationToken) { var shouldIncludeSymbol = await ShouldIncludeSymbolAsync(referencedSymbol, originalSymbol, solution, true, cancellationToken).ConfigureAwait(false); if (!shouldIncludeSymbol) { return SpecializedCollections.EmptyEnumerable<RenameLocation>(); } // Implicit references are things like a foreach referencing GetEnumerator. We don't // want to consider those as part of the set if (location.IsImplicit) { return SpecializedCollections.EmptyEnumerable<RenameLocation>(); } var results = new List<RenameLocation>(); // If we were originally naming an alias, then we'll only use the location if was // also bound through the alias if (originalSymbol.Kind == SymbolKind.Alias) { if (originalSymbol.Equals(location.Alias)) { results.Add(new RenameLocation(location, location.Document.Id)); // We also need to add the location of the alias // itself var aliasLocation = location.Alias.Locations.Single(); results.Add(new RenameLocation(aliasLocation, solution.GetDocument(aliasLocation.SourceTree).Id)); } } else { // If we bound through an alias, we'll only rename if the alias's name matches // the name of symbol it points to. We do this because it's common to see things // like "using Foo = System.Foo" where people want to import a single type // rather than a whole namespace of stuff. if (location.Alias != null) { if (location.Alias.Name == referencedSymbol.Name) { results.Add(new RenameLocation(location.Location, location.Document.Id, isCandidateLocation: location.IsCandidateLocation, isRenamableAliasUsage: true, isWrittenTo: location.IsWrittenTo)); // We also need to add the location of the alias itself var aliasLocation = location.Alias.Locations.Single(); results.Add(new RenameLocation(aliasLocation, solution.GetDocument(aliasLocation.SourceTree).Id)); } } else { // The simple case, so just the single location and we're done results.Add(new RenameLocation( location.Location, location.Document.Id, isWrittenTo: location.IsWrittenTo, isCandidateLocation: location.IsCandidateLocation, isMethodGroupReference: location.IsCandidateLocation && location.CandidateReason == CandidateReason.MemberGroup, isRenamableAccessor: await IsPropertyAccessorOrAnOverride(referencedSymbol, solution, cancellationToken).ConfigureAwait(false))); } } return results; }
public static SerializableReferenceLocation Dehydrate( ReferenceLocation referenceLocation) { return new SerializableReferenceLocation { Document = SerializableDocumentId.Dehydrate(referenceLocation.Document), Alias = SerializableSymbolAndProjectId.Dehydrate(referenceLocation.Alias, referenceLocation.Document), Location = SerializableTextSpan.Dehydrate(referenceLocation.Location.SourceSpan), IsImplicit = referenceLocation.IsImplicit, IsWrittenTo = referenceLocation.IsWrittenTo, CandidateReason = referenceLocation.CandidateReason }; }
private void RemoveAwaitFromCallerIfPresent( SyntaxEditor editor, ISyntaxFactsService syntaxFacts, SyntaxNode root, ReferenceLocation referenceLocation, CancellationToken cancellationToken) { if (referenceLocation.IsImplicit) { return; } var location = referenceLocation.Location; var token = location.FindToken(cancellationToken); var nameNode = token.Parent; if (nameNode == null) { return; } // Look for the following forms: // await M(...) // await <expr>.M(...) // await M(...).ConfigureAwait(...) // await <expr>.M(...).ConfigureAwait(...) var expressionNode = nameNode; if (syntaxFacts.IsNameOfMemberAccessExpression(nameNode)) { expressionNode = nameNode.Parent; } if (!syntaxFacts.IsExpressionOfInvocationExpression(expressionNode)) { return; } // We now either have M(...) or <expr>.M(...) var invocationExpression = expressionNode.Parent; Debug.Assert(syntaxFacts.IsInvocationExpression(invocationExpression)); if (syntaxFacts.IsExpressionOfAwaitExpression(invocationExpression)) { // Handle the case where we're directly awaited. var awaitExpression = invocationExpression.Parent; editor.ReplaceNode(awaitExpression, (currentAwaitExpression, generator) => syntaxFacts.GetExpressionOfAwaitExpression(currentAwaitExpression) .WithTriviaFrom(currentAwaitExpression)); } else if (syntaxFacts.IsExpressionOfMemberAccessExpression(invocationExpression)) { // Check for the .ConfigureAwait case. var parentMemberAccessExpression = invocationExpression.Parent; var parentMemberAccessExpressionNameNode = syntaxFacts.GetNameOfMemberAccessExpression( parentMemberAccessExpression); var parentMemberAccessExpressionName = syntaxFacts.GetIdentifierOfSimpleName(parentMemberAccessExpressionNameNode).ValueText; if (parentMemberAccessExpressionName == nameof(Task.ConfigureAwait)) { var parentExpression = parentMemberAccessExpression.Parent; if (syntaxFacts.IsExpressionOfAwaitExpression(parentExpression)) { var awaitExpression = parentExpression.Parent; editor.ReplaceNode(awaitExpression, (currentAwaitExpression, generator) => { var currentConfigureAwaitInvocation = syntaxFacts.GetExpressionOfAwaitExpression(currentAwaitExpression); var currentMemberAccess = syntaxFacts.GetExpressionOfInvocationExpression(currentConfigureAwaitInvocation); var currentInvocationExpression = syntaxFacts.GetExpressionOfMemberAccessExpression(currentMemberAccess); return currentInvocationExpression.WithTriviaFrom(currentAwaitExpression); }); } } } }
private static async Task<IAliasSymbol> GetAliasSymbolAsync( Document document, ReferenceLocation location, CancellationToken cancellationToken) { if (location.Location.IsInSource) { var tree = location.Location.SourceTree; var root = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false); var token = root.FindToken(location.Location.SourceSpan.Start); var node = token.Parent; var syntaxFacts = document.Project.LanguageServices.GetService<ISyntaxFactsService>(); if (syntaxFacts.IsRightSideOfQualifiedName(node)) { node = node.Parent; } if (syntaxFacts.IsUsingDirectiveName(node)) { var directive = node.Parent; var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var aliasSymbol = semanticModel.GetDeclaredSymbol(directive, cancellationToken) as IAliasSymbol; if (aliasSymbol != null) { return aliasSymbol; } } } return null; }
public void OnReferenceFound(ISymbol symbol, ReferenceLocation location) { }
/// <summary> /// Exclude the following kind of symbols: /// 1. Implicitly declared symbols (such as implicit fields backing properties) /// 2. Symbols that can't be referenced by name (such as property getters and setters). /// 3. Metadata only symbols, i.e. symbols with no location in source. /// </summary> private static bool FilterReference(ISymbol queriedSymbol, ISymbol definition, ReferenceLocation reference) { var isImplicitlyDeclared = definition.IsImplicitlyDeclared || definition.IsAccessor(); // FindRefs treats a constructor invocation as a reference to the constructor symbol and to the named type symbol that defines it. // While we need to count the cascaded symbol definition from the named type to its constructor, we should not double count the // reference location for the invocation while computing references count for the named type symbol. var isImplicitReference = queriedSymbol.Kind == SymbolKind.NamedType && (definition as IMethodSymbol)?.MethodKind == MethodKind.Constructor; return isImplicitlyDeclared || isImplicitReference || (!definition.Locations.Any(loc => loc.IsInSource) && !reference.Location.IsInSource); }
public void OnReferenceFound(ISymbol symbol, ReferenceLocation location) { if (FilterReference(_queriedSymbol, symbol, location)) { return; } _locations.Add(location.Location); if (SearchCapReached) { _aggregateCancellationTokenSource.Cancel(); } }
public Task OnReferenceFoundAsync(SymbolAndProjectId symbolAndProjectId, ReferenceLocation location) { _progress.OnReferenceFound(symbolAndProjectId.Symbol, location); return SpecializedTasks.EmptyTask; }
public Task OnReferenceFoundAsync(SymbolAndProjectId symbol, ReferenceLocation location) => SpecializedTasks.EmptyTask;