private async Task <ImmutableArray <SymbolReference> > GetReferencesForMatchingTypesAsync(SearchScope searchScope) { searchScope.CancellationToken.ThrowIfCancellationRequested(); if (!_owner.CanAddImportForType(_diagnosticId, _node, out var nameNode)) { return(ImmutableArray <SymbolReference> .Empty); } CalculateContext( nameNode, _syntaxFacts, out var name, out var arity, out var inAttributeContext, out var hasIncompleteParentMember, out var looksGeneric); if (ExpressionBinds(nameNode, checkForExtensionMethods: false, cancellationToken: searchScope.CancellationToken)) { // If the expression bound, there's nothing to do. return(ImmutableArray <SymbolReference> .Empty); } var symbols = await searchScope.FindDeclarationsAsync(name, nameNode, SymbolFilter.Type).ConfigureAwait(false); // also lookup type symbols with the "Attribute" suffix if necessary. if (inAttributeContext) { var attributeSymbols = await searchScope.FindDeclarationsAsync(name + AttributeSuffix, nameNode, SymbolFilter.Type).ConfigureAwait(false); symbols = symbols.AddRange( attributeSymbols.Select(r => r.WithDesiredName(r.DesiredName.GetWithoutAttributeSuffix(isCaseSensitive: false)))); } var typeSymbols = OfType <ITypeSymbol>(symbols); var options = await _document.GetOptionsAsync(searchScope.CancellationToken).ConfigureAwait(false); var hideAdvancedMembers = options.GetOption(CompletionOptions.HideAdvancedMembers); var editorBrowserInfo = new EditorBrowsableInfo(_semanticModel.Compilation); // Only keep symbols which are accessible from the current location and that are allowed by the current // editor browsable rules. var accessibleTypeSymbols = typeSymbols.WhereAsArray( s => ArityAccessibilityAndAttributeContextAreCorrect(s.Symbol, arity, inAttributeContext, hasIncompleteParentMember, looksGeneric) && s.Symbol.IsEditorBrowsable(hideAdvancedMembers, _semanticModel.Compilation, editorBrowserInfo)); // These types may be contained within namespaces, or they may be nested // inside generic types. Record these namespaces/types if it would be // legal to add imports for them. var typesContainedDirectlyInNamespaces = accessibleTypeSymbols.WhereAsArray(s => s.Symbol.ContainingSymbol is INamespaceSymbol); var typesContainedDirectlyInTypes = accessibleTypeSymbols.WhereAsArray(s => s.Symbol.ContainingType != null); var namespaceReferences = GetNamespaceSymbolReferences(searchScope, typesContainedDirectlyInNamespaces.SelectAsArray(r => r.WithSymbol(r.Symbol.ContainingNamespace))); var typeReferences = typesContainedDirectlyInTypes.SelectAsArray( r => searchScope.CreateReference(r.WithSymbol(r.Symbol.ContainingType))); return(namespaceReferences.Concat(typeReferences)); }
public Builder(Checksum checksum, string language, string genericTypeSuffix, EditorBrowsableInfo editorBrowsableInfo) { _checksum = checksum; _language = language; _genericTypeSuffix = genericTypeSuffix; _editorBrowsableInfo = editorBrowsableInfo; _itemsBuilder = ArrayBuilder <TypeImportCompletionItemInfo> .GetInstance(); }
public static bool IsEditorBrowsable( this ISymbol symbol, bool hideAdvancedMembers, Compilation compilation, EditorBrowsableInfo editorBrowsableInfo = default) { return(IsEditorBrowsableWithState( symbol, hideAdvancedMembers, compilation, editorBrowsableInfo).isBrowsable); }
/// <summary> /// Get appropriate completion items for all the visible top level types from given PE reference. /// </summary> private bool TryGetUpToDateCacheForPEReference( Compilation originCompilation, Solution solution, EditorBrowsableInfo editorBrowsableInfo, PortableExecutableReference peReference, CancellationToken cancellationToken, out TypeImportCompletionCacheEntry cacheEntry) { if (originCompilation.GetAssemblyOrModuleSymbol(peReference) is not IAssemblySymbol assemblySymbol) { cacheEntry = default; return(false); }
// In addition to given symbol's browsability, also returns its EditorBrowsableState if it contains EditorBrowsableAttribute. public static (bool isBrowsable, bool isEditorBrowsableStateAdvanced) IsEditorBrowsableWithState( this ISymbol symbol, bool hideAdvancedMembers, Compilation compilation, EditorBrowsableInfo editorBrowsableInfo = default ) { // Namespaces can't have attributes, so just return true here. This also saves us a // costly check if this namespace has any locations in source (since a merged namespace // needs to go collect all the locations). if (symbol.Kind == SymbolKind.Namespace) { return(isBrowsable : true, isEditorBrowsableStateAdvanced : false); } // check for IsImplicitlyDeclared so we don't spend time examining VB's embedded types. // This saves a few percent in typing scenarios. An implicitly declared symbol can't // have attributes, so it can't be hidden by them. if (symbol.IsImplicitlyDeclared) { return(isBrowsable : true, isEditorBrowsableStateAdvanced : false); } if (editorBrowsableInfo.IsDefault) { editorBrowsableInfo = new EditorBrowsableInfo(compilation); } // Ignore browsability limiting attributes if the symbol is declared in source. // Check all locations since some of VB's embedded My symbols are declared in // both source and the MyTemplateLocation. if (symbol.Locations.All(loc => loc.IsInSource)) { // The HideModuleNameAttribute still applies to Modules defined in source return( !IsBrowsingProhibitedByHideModuleNameAttribute( symbol, editorBrowsableInfo.HideModuleNameAttribute ), isEditorBrowsableStateAdvanced : false ); } var(isProhibited, isEditorBrowsableStateAdvanced) = IsBrowsingProhibited( symbol, hideAdvancedMembers, editorBrowsableInfo ); return(!isProhibited, isEditorBrowsableStateAdvanced); }
private async Task <ImmutableArray <SymbolResult> > GetMatchingTypesAsync( Document document, SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var project = document.Project; var syntaxFacts = project.LanguageServices.GetRequiredService <ISyntaxFactsService>(); syntaxFacts.GetNameAndArityOfSimpleName(node, out var name, out var arity); var looksGeneric = syntaxFacts.LooksGeneric(node); var symbols = await DeclarationFinder.FindAllDeclarationsWithNormalQueryAsync( project, SearchQuery.Create(name, IgnoreCase), SymbolFilter.Type, cancellationToken).ConfigureAwait(false); // also lookup type symbols with the "Attribute" suffix. var inAttributeContext = syntaxFacts.IsAttributeName(node); if (inAttributeContext) { var attributeSymbols = await DeclarationFinder.FindAllDeclarationsWithNormalQueryAsync( project, SearchQuery.Create(name + "Attribute", IgnoreCase), SymbolFilter.Type, cancellationToken).ConfigureAwait(false); symbols = symbols.Concat(attributeSymbols); } var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false); var hideAdvancedMembers = options.GetOption(CompletionOptions.HideAdvancedMembers); var editorBrowserInfo = new EditorBrowsableInfo(semanticModel.Compilation); var validSymbols = symbols .OfType <INamedTypeSymbol>() .Where(s => IsValidNamedTypeSearchResult(semanticModel, arity, inAttributeContext, looksGeneric, s) && s.IsEditorBrowsable(hideAdvancedMembers, semanticModel.Compilation, editorBrowserInfo)) .ToImmutableArray(); // Check what the current node binds to. If it binds to any symbols, but with // the wrong arity, then we don't want to suggest fully qualifying to the same // type that we're already binding to. That won't address the WrongArity problem. var currentSymbolInfo = semanticModel.GetSymbolInfo(node, cancellationToken); if (currentSymbolInfo.CandidateReason == CandidateReason.WrongArity) { validSymbols = validSymbols.WhereAsArray( s => !currentSymbolInfo.CandidateSymbols.Contains(s)); } return(validSymbols.SelectAsArray(s => new SymbolResult(s, weight: TypeWeight))); }
private static (bool isProhibited, bool isEditorBrowsableStateAdvanced) IsBrowsingProhibited( ISymbol symbol, bool hideAdvancedMembers, EditorBrowsableInfo editorBrowsableInfo ) { var attributes = symbol.GetAttributes(); if (attributes.Length == 0) { return(isProhibited : false, isEditorBrowsableStateAdvanced : false); } var(isProhibited, isEditorBrowsableStateAdvanced) = IsBrowsingProhibitedByEditorBrowsableAttribute( attributes, hideAdvancedMembers, editorBrowsableInfo.EditorBrowsableAttributeConstructor ); return( ( isProhibited || IsBrowsingProhibitedByTypeLibTypeAttribute( attributes, editorBrowsableInfo.TypeLibTypeAttributeConstructors ) || IsBrowsingProhibitedByTypeLibFuncAttribute( attributes, editorBrowsableInfo.TypeLibFuncAttributeConstructors ) || IsBrowsingProhibitedByTypeLibVarAttribute( attributes, editorBrowsableInfo.TypeLibVarAttributeConstructors ) || IsBrowsingProhibitedByHideModuleNameAttribute( symbol, editorBrowsableInfo.HideModuleNameAttribute, attributes ) ), isEditorBrowsableStateAdvanced ); }