private IEnumerable <INamedTypeSymbol> GetOuterTypesAndBases()
            {
                if (_lazyOuterTypesAndBases == null)
                {
                    _lazyOuterTypesAndBases = _context.GetOuterTypes(_cancellationToken).SelectMany(o => o.GetBaseTypesAndThis()).Select(t => t.OriginalDefinition);
                }

                return(_lazyOuterTypesAndBases);
            }
Beispiel #2
0
        private bool ShouldIncludeSymbol(ISymbol symbol, AbstractSyntaxContext context, CancellationToken cancellationToken)
        {
            var isMember = false;

            switch (symbol.Kind)
            {
            case SymbolKind.NamedType:
                var namedType = (INamedTypeSymbol)symbol;
                if (namedType.SpecialType == SpecialType.System_Void)
                {
                    return(false);
                }

                break;

            case SymbolKind.Method:
                var methodSymbol = (IMethodSymbol)symbol;
                if (methodSymbol.MethodKind == MethodKind.EventAdd ||
                    methodSymbol.MethodKind == MethodKind.EventRemove ||
                    methodSymbol.MethodKind == MethodKind.EventRaise ||
                    methodSymbol.MethodKind == MethodKind.PropertyGet ||
                    methodSymbol.MethodKind == MethodKind.PropertySet)
                {
                    return(false);
                }

                isMember = true;
                break;

            case SymbolKind.Event:
            case SymbolKind.Field:
            case SymbolKind.Property:
                isMember = true;
                break;
            }

            if (context.IsAttributeNameContext)
            {
                return(symbol.IsOrContainsAccessibleAttribute(context.SemanticModel.Compilation));
            }

            if (context.IsEnumTypeMemberAccessContext)
            {
                return(symbol.Kind == SymbolKind.Field);
            }

            // In an expression or statement context, we don't want to display instance members declared in outer containing types.
            if ((context.IsStatementContext || context.IsAnyExpressionContext) &&
                !symbol.IsStatic &&
                isMember &&
                context.GetOuterTypes(cancellationToken).Contains(symbol.ContainingType))
            {
                return(false);
            }

            var namespaceSymbol = symbol as INamespaceSymbol;

            if (namespaceSymbol != null)
            {
                return(namespaceSymbol.ContainsAccessibleTypesOrNamespaces(context.SemanticModel.Compilation.Assembly));
            }

            return(true);
        }
        private bool ShouldIncludeSymbol(ISymbol symbol, AbstractSyntaxContext context, CancellationToken cancellationToken)
        {
            var isMember = false;
            switch (symbol.Kind)
            {
                case SymbolKind.NamedType:
                    var namedType = (INamedTypeSymbol)symbol;
                    if (namedType.SpecialType == SpecialType.System_Void)
                    {
                        return false;
                    }

                    break;

                case SymbolKind.Method:
                    var methodSymbol = (IMethodSymbol)symbol;
                    if (methodSymbol.MethodKind == MethodKind.EventAdd ||
                        methodSymbol.MethodKind == MethodKind.EventRemove ||
                        methodSymbol.MethodKind == MethodKind.EventRaise ||
                        methodSymbol.MethodKind == MethodKind.PropertyGet ||
                        methodSymbol.MethodKind == MethodKind.PropertySet)
                    {
                        return false;
                    }

                    isMember = true;
                    break;

                case SymbolKind.Event:
                case SymbolKind.Field:
                case SymbolKind.Property:
                    isMember = true;
                    break;

                case SymbolKind.TypeParameter:
                    return ((ITypeParameterSymbol)symbol).TypeParameterKind != TypeParameterKind.Cref;
            }

            if (context.IsAttributeNameContext)
            {
                var enclosingSymbol = context.SemanticModel.GetEnclosingNamedType(context.LeftToken.SpanStart, cancellationToken);
                return symbol.IsOrContainsAccessibleAttribute(enclosingSymbol, context.SemanticModel.Compilation.Assembly);
            }

            if (context.IsEnumTypeMemberAccessContext)
            {
                return symbol.Kind == SymbolKind.Field;
            }

            // In an expression or statement context, we don't want to display instance members declared in outer containing types.
            if ((context.IsStatementContext || context.IsAnyExpressionContext) &&
                !symbol.IsStatic &&
                isMember &&
                context.GetOuterTypes(cancellationToken).Contains(symbol.ContainingType))
            {
                return false;
            }

            var namespaceSymbol = symbol as INamespaceSymbol;
            if (namespaceSymbol != null)
            {
                return namespaceSymbol.ContainsAccessibleTypesOrNamespaces(context.SemanticModel.Compilation.Assembly);
            }

            return true;
        }