internal override void Lookup(LookupResult result, string name, BinderContext original, LookupFilter filter)
        {
            Debug.Assert(result.IsClear());

            var results = Compilation.GlobalNamespace.GetMembers(name);
            original.FilterAccessibility(result, results, filter);
        }
Beispiel #2
0
        private SymbolInfo LookupType(BinderContext underlying, TypeSyntax type, int arity = 0)
        {
            using (var context = new DiagnosticBufferBinderContext(underlying))
            {
                var result = context.BindType(type, arity);
                var err = result as ErrorTypeSymbol;
                if (err == null)
                {
                    return new SymbolInfo(result, ConsList.Singleton(result), context.Commit(false));
                }

                var info = err.ErrorInfo;
                var errors = context.Commit(false).ToList();
                if (info != null)
                {
                    errors.Add(new Diagnostic(info, context.Location(type)));
                }

                var syms = (info is CSDiagnosticInfo) ? (info as CSDiagnosticInfo).Symbols : Enumerable.Empty<Symbol>();
                return new SymbolInfo(result, syms, errors);
            }
        }
 internal TopLevelBuilder1(DiagnosticBag bag, Symbol owner, SingleDeclaration declaration, BinderContext enclosingContext)
     : base(owner, declaration, enclosingContext)
 {
     this.diagnosticBag = bag;
 }
        internal override void LookupNamespaceOrType(LookupResult result, string name, BinderContext original, ConsList<Symbol> basesBeingResolved, LookupFilter filter)
        {
            Debug.Assert(result.IsClear());

            original.FilterAccessibility(result, Compilation.GlobalNamespace.GetMembers(name).OfType<Symbol, NamespaceOrTypeSymbol>(), filter);
        }
        internal override void LookupType(LookupResult result, string name, int arity, BinderContext original, ConsList<Symbol> basesBeingResolved)
        {
            Debug.Assert(result.IsClear());

            original.FilterAccessibility(result, Compilation.GlobalNamespace.GetTypeMembers(name, arity));
        }
 internal abstract SyntaxBinding BindStatement(BinderContext context, StatementSyntax statement);
 internal abstract SyntaxBinding BindExpression(BinderContext context, ExpressionSyntax expression);
 internal SpeculatableMemberBinderContext(Location location, Symbol accessor, BinderContext next)
     : base(location, accessor, next)
 {
 }
 internal DiagnosticBufferBinderContext(BinderContext underlying)
     : base(underlying.Location(), underlying.Accessor, underlying)
 {
 }
 internal NamespaceBuilder1(Symbol owner, SingleDeclaration declaration, BinderContext enclosingContext)
     : base(declaration.Location, owner, enclosingContext)
 {
     this.declaration = declaration;
 }
        internal override void LookupType(LookupResult result, string name, int arity, BinderContext original, ConsList <Symbol> basesBeingResolved)
        {
            Debug.Assert(result.IsClear());

            original.FilterAccessibility(result, Compilation.GlobalNamespace.GetTypeMembers(name, arity));
        }