private void ProcessReferencedSymbol( Solution solution, ReferencedSymbol referencedSymbol, ArrayBuilder <DefinitionItem> definitions, ArrayBuilder <SourceReferenceItem> references, HashSet <DocumentSpan> uniqueSpans) { // See if this is a symbol we even want to present to the user. If not, // ignore it entirely (including all its reference locations). if (!referencedSymbol.ShouldShow()) { return; } var definitionItem = referencedSymbol.Definition.ToDefinitionItem(solution, uniqueSpans); definitions.Add(definitionItem); // Now, create the SourceReferenceItems for all the reference locations // for this definition. CreateReferences(referencedSymbol, references, definitionItem, uniqueSpans); // Finally, see if there are any third parties that want to add their // own result to our collection. var thirdPartyItem = GetThirdPartyDefinitionItem(solution, referencedSymbol.Definition); if (thirdPartyItem != null) { definitions.Add(thirdPartyItem); } }
private static void CreateReferences( ReferencedSymbol referencedSymbol, ImmutableArray <SourceReferenceItem> .Builder references, DefinitionItem definitionItem, HashSet <DocumentLocation> uniqueLocations) { foreach (var referenceLocation in referencedSymbol.Locations) { var location = referenceLocation.Location; Debug.Assert(location.IsInSource); var document = referenceLocation.Document; var sourceSpan = location.SourceSpan; var documentLocation = new DocumentLocation(document, sourceSpan); if (!documentLocation.CanNavigateTo()) { continue; } if (uniqueLocations.Add(documentLocation)) { references.Add(new SourceReferenceItem(definitionItem, documentLocation)); } } }
public FieldParameterSyntax(TextSpan span, Name name, IExpressionSyntax?defaultValue) : base(span, name) { Name = name; DefaultValue = defaultValue; DataType = ReferencedSymbol.Select(s => s?.DataType ?? Types.DataType.Unknown); }
/// <summary> /// Reference locations are de-duplicated across the entire find references result set /// Order the definitions so that references to multiple definitions appear under the /// desired definition (e.g. constructor references should prefer the constructor method /// over the type definition). Note that this does not change the order in which /// definitions are displayed in Find Symbol Results, it only changes which definition /// a given reference should appear under when its location is a reference to multiple /// definitions. /// </summary> private static int GetPrecedence(ReferencedSymbol referencedSymbol) { switch (referencedSymbol.Definition.Kind) { case SymbolKind.Event: case SymbolKind.Field: case SymbolKind.Label: case SymbolKind.Local: case SymbolKind.Method: case SymbolKind.Parameter: case SymbolKind.Property: case SymbolKind.RangeVariable: return(0); case SymbolKind.ArrayType: case SymbolKind.DynamicType: case SymbolKind.ErrorType: case SymbolKind.NamedType: case SymbolKind.PointerType: return(1); default: return(2); } }
private AbstractTreeItem ConvertToDefinitionItem( Solution solution, ReferencedSymbol referencedSymbol, Location location, Glyph glyph) { if (!location.IsInSource) { return(referencedSymbol.Locations.Any() ? new MetadataDefinitionTreeItem( solution.Workspace, referencedSymbol.Definition, referencedSymbol.Locations.First().Document.Project.Id, glyph.GetGlyphIndex()) : null); } var document = solution.GetDocument(location.SourceTree); var sourceSpan = location.SourceSpan; if (!IsValidSourceLocation(document, sourceSpan)) { return(null); } return(new SourceDefinitionTreeItem(document, sourceSpan, referencedSymbol.Definition, glyph.GetGlyphIndex())); }
public static bool ShouldShow(this ReferencedSymbol referencedSymbol) { // If the reference has any locations then we will present it. if (referencedSymbol.Locations.Any()) { return(true); } return(referencedSymbol.Definition.ShouldShowWithNoReferenceLocations()); }
private async Task <IEnumerable <ArgumentResults> > ExtractArguments(ReferencedSymbol reference) { var result = new List <ArgumentResults>(); foreach (var location in reference.Locations) { result.Add(await CalculateArgumentResults(location)); } return(result); }
public static bool ShouldShow( this ReferencedSymbol referencedSymbol, FindReferencesSearchOptions options) { // If the reference has any locations then we will present it. if (referencedSymbol.Locations.Any()) { return(true); } return(referencedSymbol.Definition.ShouldShowWithNoReferenceLocations( options, showMetadataSymbolsWithoutReferences: true)); }
private static void Verify(ReferencedSymbol reference, HashSet <int> expectedMatchedLines) { System.Action <Location> verifier = (location) => Assert.True(expectedMatchedLines.Remove(location.GetLineSpan().StartLinePosition.Line)); foreach (var location in reference.Locations) { verifier(location.Location); } foreach (var location in reference.Definition.Locations) { verifier(location); } }
private bool IncludeDefinition(ReferencedSymbol reference) { var definition = reference.Definition; // Don't include parameters to property accessors if (definition is IParameterSymbol && definition.ContainingSymbol is IMethodSymbol && ((IMethodSymbol)definition.ContainingSymbol).AssociatedSymbol is IPropertySymbol) { return(false); } return(true); }
private static ReferencedSymbol CreateReferencedSymbol(string symbolName, int referenceCount) { var symbol = new StubSymbol(symbolName); var locations = new List <ReferenceLocation>(capacity: referenceCount); for (int i = 0; i < referenceCount; i++) { locations.Add(new ReferenceLocation()); } var referencedSymbol = new ReferencedSymbol(symbol, locations); return(referencedSymbol); }
private static DefinitionItem CreateDefinitionItem( Solution solution, ReferencedSymbol referencedSymbol, HashSet <DocumentLocation> uniqueLocations) { var definition = referencedSymbol.Definition; var displayParts = definition.ToDisplayParts(s_definitionDisplayFormat).ToTaggedText(); return(CreateDefinitionItem( GlyphTags.GetTags(definition.GetGlyph()), displayParts, definition.ShouldShowWithNoReferenceLocations(), solution, definition, uniqueLocations)); }
private static void Verify(ReferencedSymbol reference, HashSet <int> expectedMatchedLines) { void verifier(Location location) { var line = location.GetLineSpan().StartLinePosition.Line; Assert.True(expectedMatchedLines.Remove(line), $"An unexpected reference was found on line number {line}."); } foreach (var location in reference.Locations) { verifier(location.Location); } foreach (var location in reference.Definition.Locations) { verifier(location); } }
private static bool ShouldKeep(ReferencedSymbol r) { if (r.Locations.Any()) { return(true); } if (r.Definition.IsImplicitlyDeclared) { return(false); } if (r.Definition.IsPropertyAccessor()) { return(false); } return(true); }
private static void CreateReferences( ReferencedSymbol referencedSymbol, ArrayBuilder <SourceReferenceItem> references, DefinitionItem definitionItem, HashSet <DocumentSpan> uniqueSpans) { foreach (var referenceLocation in referencedSymbol.Locations) { var sourceReferenceItem = referenceLocation.TryCreateSourceReferenceItem(definitionItem); if (sourceReferenceItem == null) { continue; } if (uniqueSpans.Add(sourceReferenceItem.SourceSpan)) { references.Add(sourceReferenceItem); } } }
public void DebuggerDisplay_NoReferences() { ReferencedSymbol referencedSymbol = CreateReferencedSymbol("Foo", 0); Assert.Equal("Foo, 0 refs", referencedSymbol.DebuggerDisplay); }
public void DebuggerDisplay_TwoReferences() { ReferencedSymbol referencedSymbol = CreateReferencedSymbol("Foo", 2); Assert.Equal("Foo, 2 refs", referencedSymbol.GetDebuggerDisplay()); }
public void DebuggerDisplay_OneReference() { ReferencedSymbol referencedSymbol = CreateReferencedSymbol("Foo", 1); Assert.Equal("Foo, 1 ref", referencedSymbol.GetDebuggerDisplay()); }
public void DebuggerDisplay_NoReferences() { ReferencedSymbol referencedSymbol = CreateReferencedSymbol("Goo", 0); Assert.Equal("Goo, 0 refs", referencedSymbol.GetTestAccessor().GetDebuggerDisplay()); }
async Task <PropertyDeclarationSyntax> FindFullPropertyForConvertingAutoPropertyAsync(PropertyDeclarationSyntax propertyDeclaration) { if (propertyDeclaration.AccessorList == null) { return(null); } if (propertyDeclaration.AccessorList.Accessors.Count != 2) { return(null); } var getNode = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(x => x.Keyword.IsKind(SyntaxKind.GetKeyword)); var setNode = propertyDeclaration.AccessorList.Accessors.FirstOrDefault(x => x.Keyword.IsKind(SyntaxKind.SetKeyword)); if (setNode == null || getNode == null) { return(null); } var getIdentifier = HasJustReturnValue(getNode); if (getIdentifier == null) { return(null); } var setIdentifier = HasJustSetValue(setNode); if (setIdentifier == null) { return(null); } var setIdentifierSymbol = projectItemDetails.SemanticModel.GetSymbolInfo(setIdentifier).Symbol; var getIdentifierSymbol = projectItemDetails.SemanticModel.GetSymbolInfo(getIdentifier).Symbol; if (SymbolEqualityComparer.Default.Equals(setIdentifierSymbol, getIdentifierSymbol) == false) { return(null); } //if (setIdentifierSymbol != getIdentifierSymbol) return null; var baseFieldSymbol = projectItemDetails.SemanticModel.GetSymbolInfo(setIdentifier).Symbol; if (baseFieldSymbol is IFieldSymbol == false) { return(null); } var propertyDelarationSymbol = projectItemDetails.SemanticModel.GetDeclaredSymbol(propertyDeclaration); if (SymbolEqualityComparer.Default.Equals(baseFieldSymbol.ContainingType, propertyDelarationSymbol.ContainingType) == false) { return(null); } //if (baseFieldSymbol.ContainingType != propertyDelarationSymbol.ContainingType) return null; var baseFieldVariableDeclaration = await baseFieldSymbol.DeclaringSyntaxReferences[0].GetSyntaxAsync() as VariableDeclaratorSyntax; var baseFieldFieldDeclaration = baseFieldVariableDeclaration.Parent.Parent as FieldDeclarationSyntax; if (CheckVisibility(baseFieldFieldDeclaration, getNode, setNode, propertyDeclaration) == false) { return(null); } var refrences = await Microsoft.CodeAnalysis.FindSymbols.SymbolFinder.FindReferencesAsync(baseFieldSymbol, TidyCSharpPackage.Instance.CleanupWorkingSolution); ReferencedSymbol references = null; references = refrences.FirstOrDefault(); if (references == null) { return(null); } if (baseFieldFieldDeclaration.HasNoneWhiteSpaceTrivia(new SyntaxKind[] { SyntaxKind.SingleLineCommentTrivia, SyntaxKind.MultiLineCommentTrivia })) { return(null); } VariablesToRemove.Add( new Tuple <VariableDeclaratorSyntax, PropertyDeclarationSyntax, bool> ( baseFieldVariableDeclaration, propertyDeclaration, references.Locations.Count() > 2 ) ); return(propertyDeclaration); }