public static void LookupSymbolsSimpleName( this Microsoft.CodeAnalysis.CSharp.Binder binder, LookupResult result, NamespaceOrTypeSymbol qualifierOpt, string plainName, int arity, ConsList <TypeSymbol> basesBeingResolved, LookupOptions options, bool diagnose, ref HashSet <DiagnosticInfo> useSiteDiagnostics ) { CompoundUseSiteInfo <AssemblySymbol> useSiteInfo = default; binder.LookupSymbolsSimpleName( result, qualifierOpt, plainName, arity, basesBeingResolved, options, diagnose, ref useSiteInfo ); AddDiagnosticInfos(ref useSiteDiagnostics, useSiteInfo); }
internal void CollectLocalsFromDeconstruction( ExpressionSyntax declaration, LocalDeclarationKind kind, ArrayBuilder<LocalSymbol> locals, SyntaxNode deconstructionStatement, Binder enclosingBinderOpt = null) { switch (declaration.Kind()) { case SyntaxKind.TupleExpression: { var tuple = (TupleExpressionSyntax)declaration; foreach (var arg in tuple.Arguments) { CollectLocalsFromDeconstruction(arg.Expression, kind, locals, deconstructionStatement, enclosingBinderOpt); } break; } case SyntaxKind.DeclarationExpression: { var declarationExpression = (DeclarationExpressionSyntax)declaration; CollectLocalsFromDeconstruction( declarationExpression.Designation, declarationExpression.Type, kind, locals, deconstructionStatement, enclosingBinderOpt); break; } case SyntaxKind.IdentifierName: break; default: // In broken code, we can have an arbitrary expression here. Collect its expression variables. ExpressionVariableFinder.FindExpressionVariables(this, locals, declaration); break; } }
internal void CollectLocalsFromDeconstruction( ExpressionSyntax declaration, LocalDeclarationKind kind, ArrayBuilder<LocalSymbol> locals, SyntaxNode deconstructionStatement, Binder enclosingBinderOpt = null) { switch (declaration.Kind()) { case SyntaxKind.TupleExpression: { var tuple = (TupleExpressionSyntax)declaration; foreach (var arg in tuple.Arguments) { CollectLocalsFromDeconstruction(arg.Expression, kind, locals, deconstructionStatement, enclosingBinderOpt); } break; } case SyntaxKind.DeclarationExpression: { var declarationExpression = (DeclarationExpressionSyntax)declaration; CollectLocalsFromDeconstruction( declarationExpression.Designation, declarationExpression.Type, kind, locals, deconstructionStatement, enclosingBinderOpt); break; } case SyntaxKind.IdentifierName: break; default: throw ExceptionUtilities.UnexpectedValue(declaration.Kind()); } }
public QueryUnboundLambdaState(Binder binder, RangeVariableMap rangeVariableMap, ImmutableArray<RangeVariableSymbol> parameters, LambdaBodyFactory bodyFactory) : base(binder, unboundLambdaOpt: null) { _parameters = parameters; _rangeVariableMap = rangeVariableMap; _bodyFactory = bodyFactory; }
internal override BoundStatement BindLockStatementParts(DiagnosticBag diagnostics, Binder originalBinder) { // Allow method groups during binding and then rule them out when we check that the expression has // a reference type. ExpressionSyntax exprSyntax = TargetExpressionSyntax; BoundExpression expr = BindTargetExpression(diagnostics); TypeSymbol exprType = expr.Type; bool hasErrors = false; if ((object)exprType == null) { if (expr.ConstantValue != ConstantValue.Null || Compilation.FeatureStrictEnabled) // Dev10 allows the null literal. { Error(diagnostics, ErrorCode.ERR_LockNeedsReference, exprSyntax, expr.Display); hasErrors = true; } } else if (!exprType.IsReferenceType && (exprType.IsValueType || Compilation.FeatureStrictEnabled)) { Error(diagnostics, ErrorCode.ERR_LockNeedsReference, exprSyntax, exprType); hasErrors = true; } BoundStatement stmt = originalBinder.BindPossibleEmbeddedStatement(_syntax.Statement, diagnostics); Debug.Assert(this.Locals.IsDefaultOrEmpty); return new BoundLockStatement(_syntax, expr, stmt, hasErrors); }
internal ExecutableCodeBinder(CSharpSyntaxNode root, Symbol memberSymbol, Binder next, BinderFlags additionalFlags) : base(next, (next.Flags | additionalFlags) & ~BinderFlags.AllClearedAtExecutableCodeBoundary) { this.memberSymbol = memberSymbol; this.root = root; this.owner = memberSymbol as MethodSymbol; }
internal BinderWithConditionalReceiver(Binder next, BoundExpression receiverExpression) : base(next) { Debug.Assert(receiverExpression != null); _receiverExpression = receiverExpression; }
public WithConstructorInitializerLocalsBinder(Binder enclosing, ConstructorDeclarationSyntax declaration) : base(enclosing, enclosing.Flags) { Debug.Assert(declaration.Initializer != null); this.scope = declaration; this.initializerArgumentList = declaration.Initializer.ArgumentList; }
public BoundLambda(CSharpSyntaxNode syntax, BoundBlock body, ImmutableArray<Diagnostic> diagnostics, Binder binder, TypeSymbol delegateType, bool inferReturnType) : this(syntax, (LambdaSymbol)binder.ContainingMemberOrLambda, body, diagnostics, binder, delegateType) { if (inferReturnType) { this._inferredReturnType = InferReturnType( this.Body, this.Binder, delegateType, this.Symbol.IsAsync, ref this._inferredReturnTypeUseSiteDiagnostics, out this._refKind, out this._inferredFromSingleType); #if DEBUG _hasInferredReturnType = true; #endif } Debug.Assert( syntax.IsAnonymousFunction() || // lambda expressions syntax is ExpressionSyntax && LambdaUtilities.IsLambdaBody(syntax, allowReducedLambdas: true) || // query lambdas LambdaUtilities.IsQueryPairLambda(syntax) // "pair" lambdas in queries ); }
private BoundForStatement BindForParts(ForStatementSyntax node, Binder originalBinder, DiagnosticBag diagnostics) { BoundStatement initializer; if (node.Declaration != null) { Debug.Assert(node.Initializers.Count == 0); if (node.Declaration.IsDeconstructionDeclaration) { initializer = originalBinder.BindDeconstructionDeclaration(node.Declaration, node.Declaration, diagnostics); } else { ImmutableArray<BoundLocalDeclaration> unused; initializer = originalBinder.BindForOrUsingOrFixedDeclarations(node.Declaration, LocalDeclarationKind.ForInitializerVariable, diagnostics, out unused); } } else { initializer = originalBinder.BindStatementExpressionList(node.Initializers, diagnostics); } var condition = (node.Condition != null) ? originalBinder.BindBooleanExpression(node.Condition, diagnostics) : null; var increment = originalBinder.BindStatementExpressionList(node.Incrementors, diagnostics); var body = originalBinder.BindPossibleEmbeddedStatement(node.Statement, diagnostics); Debug.Assert(this.Locals == this.GetDeclaredLocalsForScope(node)); return new BoundForStatement(node, this.Locals, initializer, condition, increment, body, this.BreakLabel, this.ContinueLabel); }
public WithConstructorInitializerLocalsBinder(Binder enclosing, ArgumentListSyntax initializerArgumentList) : base(enclosing, enclosing.Flags) { Debug.Assert(initializerArgumentList != null); this.scope = initializerArgumentList; this.initializerArgumentList = initializerArgumentList; }
internal Binder(Binder next) { Debug.Assert(next != null); _next = next; this.Flags = next.Flags; this.Compilation = next.Compilation; }
public static SmallDictionary<CSharpSyntaxNode, Binder> BuildMap(MethodSymbol method, CSharpSyntaxNode syntax, Binder enclosing, out bool sawYield) { var builder = new LocalBinderFactory(method, enclosing); builder.Visit(syntax); sawYield = builder._sawYield; return builder._map; }
private LocalBinderFactory(MethodSymbol method, Binder enclosing) { Debug.Assert((object)method != null); _map = new SmallDictionary<CSharpSyntaxNode, Binder>(ReferenceEqualityComparer.Instance); _method = method; _enclosing = enclosing; }
public QueryUnboundLambdaState(UnboundLambda unbound, Binder binder, RangeVariableMap rangeVariableMap, ImmutableArray<RangeVariableSymbol> parameters, ExpressionSyntax body) : this(unbound, binder, rangeVariableMap, parameters, (LambdaSymbol lambdaSymbol, ExecutableCodeBinder lambdaBodyBinder, DiagnosticBag diagnostics) => { BoundExpression expression = lambdaBodyBinder.BindValue(body, diagnostics, BindValueKind.RValue); return lambdaBodyBinder.WrapExpressionLambdaBody(expression, body, diagnostics); }) { }
protected override void LookupSymbolsInSingleBinder( LookupResult result, string name, int arity, ConsList<Symbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref HashSet<DiagnosticInfo> useSiteDiagnostics) { if ((options & (LookupOptions.NamespaceAliasesOnly | LookupOptions.MustBeInvocableIfMember)) != 0) { return; } Debug.Assert(result.IsClear); var count = parameterMap.GetCountForKey(name); if (count == 1) { ParameterSymbol p; parameterMap.TryGetSingleValue(name, out p); result.MergeEqual(originalBinder.CheckViability(p, arity, options, null, diagnose, ref useSiteDiagnostics)); } else if (count > 1) { var parameters = parameterMap[name]; foreach (var sym in parameters) { result.MergeEqual(originalBinder.CheckViability(sym, arity, options, null, diagnose, ref useSiteDiagnostics)); } } }
public QueryUnboundLambdaState(UnboundLambda unbound, Binder binder, RangeVariableMap rangeVariableMap, ImmutableArray<RangeVariableSymbol> parameters, LambdaBodyResolver bodyResolver) : base(unbound, binder) { this.parameters = parameters; this.bodyResolver = bodyResolver; this.rangeVariableMap = rangeVariableMap; }
internal WithPrimaryConstructorParametersBinder(MethodSymbol primaryCtor, Binder next) : base(next) { Debug.Assert((object)primaryCtor != null); this.primaryCtor = primaryCtor; var parameters = primaryCtor.Parameters; var definitionMap = new SmallDictionary<string, ParameterSymbol>(); for (int i = parameters.Length - 1; i >= 0; i--) { var parameter = parameters[i]; definitionMap[parameter.Name] = parameter; } this.definitionMap = definitionMap; var parameterMap = new MultiDictionary<string, ParameterSymbol>(parameters.Length, EqualityComparer<string>.Default); foreach (var parameter in parameters) { parameterMap.Add(parameter.Name, parameter); } this.parameterMap = parameterMap; }
internal BinderWithContainingMemberOrLambda(Binder next, BinderFlags flags, Symbol containingMemberOrLambda) : base(next, flags) { Debug.Assert(containingMemberOrLambda != null); _containingMemberOrLambda = containingMemberOrLambda; }
public QueryUnboundLambdaState(UnboundLambda unbound, Binder binder, RangeVariableMap rangeVariableMap, ImmutableArray<RangeVariableSymbol> parameters, ExpressionSyntax body) : this(unbound, binder, rangeVariableMap, parameters, (LambdaSymbol lambdaSymbol, ref Binder lambdaBodyBinder, DiagnosticBag diagnostics) => { lambdaBodyBinder = new ScopedExpressionBinder(lambdaBodyBinder, body); return lambdaBodyBinder.BindLambdaExpressionAsBlock(body, diagnostics); }) { }
private MethodBodySemanticModel(CSharpCompilation compilation, Symbol owner, Binder rootBinder, CSharpSyntaxNode syntax, SyntaxTreeSemanticModel parentSemanticModelOpt = null, int speculatedPosition = 0) : base(compilation, syntax, owner, rootBinder, parentSemanticModelOpt, speculatedPosition) { Debug.Assert((object)owner != null); Debug.Assert(owner.Kind == SymbolKind.Method); Debug.Assert(syntax != null); Debug.Assert(owner.ContainingType.IsScriptClass || syntax.Kind != SyntaxKind.CompilationUnit); }
public BoundDiscardExpression FailInference(Binder binder, DiagnosticBag diagnosticsOpt) { if (diagnosticsOpt != null) { Binder.Error(diagnosticsOpt, ErrorCode.ERR_DiscardTypeInferenceFailed, this.Syntax); } return this.Update(binder.CreateErrorType("var")); }
internal LockOrUsingStatementExpressionHandler(ExpressionSyntax expressionSyntax, Binder binder) { Debug.Assert(expressionSyntax != null); Debug.Assert(binder != null); this.expressionSyntax = expressionSyntax; this.binder = binder; }
/// <summary> /// Creates a binder with given imports. /// </summary> internal InContainerBinder(NamespaceOrTypeSymbol container, Binder next, Imports imports = null) : base(next) { Debug.Assert((object)container != null); _container = container; _imports = imports ?? Imports.Empty; }
/// <summary> /// Creates a speculative AttributeSemanticModel that allows asking semantic questions about an attribute node that did not appear in the original source code. /// </summary> public static AttributeSemanticModel CreateSpeculative(SyntaxTreeSemanticModel parentSemanticModel, AttributeSyntax syntax, NamedTypeSymbol attributeType, AliasSymbol aliasOpt, Binder rootBinder, int position) { Debug.Assert(parentSemanticModel != null); Debug.Assert(rootBinder != null); Debug.Assert(rootBinder.IsSemanticModelBinder); return new AttributeSemanticModel(parentSemanticModel.Compilation, syntax, attributeType, aliasOpt, rootBinder, parentSemanticModel, position); }
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder) { var hostObjectType = GetHostObjectType(); if (hostObjectType.Kind != SymbolKind.ErrorType) { AddMemberLookupSymbolsInfo(result, hostObjectType, options, originalBinder); } }
internal override BoundNode Bind(Binder binder, CSharpSyntaxNode node, DiagnosticBag diagnostics) { if (node.Kind() == SyntaxKind.ArrowExpressionClause) { return binder.BindExpressionBodyAsBlock((ArrowExpressionClauseSyntax)node, diagnostics); } return base.Bind(binder, node, diagnostics); }
/// <summary> /// Creates a binder with given import computation function. /// </summary> internal InContainerBinder(Binder next, Func<ConsList<Symbol>, Imports> computeImports) : base(next) { Debug.Assert(computeImports != null); _container = null; _computeImports = computeImports; }
internal override BoundDoStatement BindDoParts(DiagnosticBag diagnostics, Binder originalBinder) { var node = (DoStatementSyntax)syntax; var condition = BindBooleanExpression(node.Condition, diagnostics); var body = originalBinder.BindPossibleEmbeddedStatement(node.Statement, diagnostics); return new BoundDoStatement(node, this.Locals, condition, body, this.BreakLabel, this.ContinueLabel); }
internal TypeofBinder(ExpressionSyntax typeExpression, Binder next) // Unsafe types are not unsafe in typeof, so it is effectively an unsafe region. // Since we only depend on existence of nameable members and nameof(x) produces a constant // string expression usable in an early attribute, we use early attribute binding. : base(next, next.Flags | BinderFlags.UnsafeRegion | BinderFlags.EarlyAttributeBinding) { OpenTypeVisitor.Visit(typeExpression, out _allowedMap, out _isTypeExpressionOpen); }
protected override void AddLookupSymbolsInfoInSingleBinder( LookupSymbolsInfo result, LookupOptions options, Binder originalBinder) { // Add types within namespaces imported through usings, but don't add nested namespaces. LookupOptions usingOptions = (options & ~(LookupOptions.NamespaceAliasesOnly | LookupOptions.NamespacesOrTypesOnly)) | LookupOptions.MustNotBeNamespace; Imports.AddLookupSymbolsInfoInUsings(ConsolidatedUsings, this, result, usingOptions); }
public static BoundExpression BindExpression( this Microsoft.CodeAnalysis.CSharp.Binder binder, ExpressionSyntax node, DiagnosticBag diagnostics ) { return(binder.BindExpression( node, new Microsoft.CodeAnalysis.CSharp.BindingDiagnosticBag(diagnostics) )); }
public static BoundBlock BindEmbeddedBlock( this Microsoft.CodeAnalysis.CSharp.Binder binder, BlockSyntax node, DiagnosticBag diagnostics ) { return(binder.BindEmbeddedBlock( node, new Microsoft.CodeAnalysis.CSharp.BindingDiagnosticBag(diagnostics) )); }
public static ImmutableArray <Symbol> BindCref( this Microsoft.CodeAnalysis.CSharp.Binder binder, CrefSyntax syntax, out Symbol ambiguityWinner, DiagnosticBag diagnostics ) { return(binder.BindCref( syntax, out ambiguityWinner, new Microsoft.CodeAnalysis.CSharp.BindingDiagnosticBag(diagnostics) )); }
private static void AddLookupSymbolsInfoInUsings( ImmutableArray <NamespaceOrTypeAndUsingDirective> usings, LookupSymbolsInfo result, LookupOptions options, Binder originalBinder) { if (originalBinder.Flags.Includes(BinderFlags.InScriptUsing)) { return; } Debug.Assert(!options.CanConsiderNamespaces()); // look in all using namespaces foreach (var namespaceSymbol in usings) { foreach (var member in namespaceSymbol.NamespaceOrType.GetMembersUnordered()) { if (IsValidLookupCandidateInUsings(member) && originalBinder.CanAddLookupSymbolInfo(member, options, result, null)) { result.AddSymbol(member, member.Name, member.GetArity()); } } } }
internal void LookupExtensionMethodsInUsings( ArrayBuilder <MethodSymbol> methods, string name, int arity, LookupOptions options, Binder originalBinder ) { var binderFlags = originalBinder.Flags; if (binderFlags.Includes(BinderFlags.InScriptUsing)) { return; } Debug.Assert(methods.Count == 0); bool callerIsSemanticModel = binderFlags.Includes(BinderFlags.SemanticModel); // We need to avoid collecting multiple candidates for an extension method imported both through a namespace and a static class // We will look for duplicates only if both of the following flags are set to true bool seenNamespaceWithExtensionMethods = false; bool seenStaticClassWithExtensionMethods = false; foreach (var nsOrType in this.Usings) { switch (nsOrType.NamespaceOrType.Kind) { case SymbolKind.Namespace: { var count = methods.Count; ((NamespaceSymbol)nsOrType.NamespaceOrType).GetExtensionMethods( methods, name, arity, options ); // If we found any extension methods, then consider this using as used. if (methods.Count != count) { MarkImportDirective(nsOrType.UsingDirective, callerIsSemanticModel); seenNamespaceWithExtensionMethods = true; } break; } case SymbolKind.NamedType: { var count = methods.Count; ((NamedTypeSymbol)nsOrType.NamespaceOrType).GetExtensionMethods( methods, name, arity, options ); // If we found any extension methods, then consider this using as used. if (methods.Count != count) { MarkImportDirective(nsOrType.UsingDirective, callerIsSemanticModel); seenStaticClassWithExtensionMethods = true; } break; } } } if (seenNamespaceWithExtensionMethods && seenStaticClassWithExtensionMethods) { methods.RemoveDuplicates(); } }
protected override void AddLookupSymbolsInfoInSingleBinder(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder) { if (options.CanConsiderLocals()) { foreach (var parameter in _parameters) { if (originalBinder.CanAddLookupSymbolInfo(parameter, options, result, null)) { result.AddSymbol(parameter, parameter.Name, 0); } } } }
internal override BoundStatement BindForEachDeconstruction(DiagnosticBag diagnostics, Binder originalBinder) { // There's supposed to be a ForEachLoopBinder (or other overrider of this method) in the chain. throw ExceptionUtilities.Unreachable; }
protected abstract BoundBlock BindLambdaBody(LambdaSymbol lambdaSymbol, ref Binder lambdaBodyBinder, DiagnosticBag diagnostics);
public BoundLambda(CSharpSyntaxNode syntax, BoundBlock body, ImmutableArray <Diagnostic> diagnostics, Binder binder, TypeSymbol type, bool inferReturnType) : this(syntax, (LambdaSymbol)binder.ContainingMemberOrLambda, body, diagnostics, binder, type) { if (inferReturnType) { _inferredReturnType = InferReturnType(this.Body, this.Binder, this.Symbol.IsAsync, ref _inferredReturnTypeUseSiteDiagnostics, out _inferredFromSingleType); #if DEBUG _hasInferredReturnType = true; #endif } Debug.Assert( syntax.IsAnonymousFunction() || // lambda expressions syntax is ExpressionSyntax && LambdaUtilities.IsLambdaBody(syntax) || // query lambdas LambdaUtilities.IsQueryPairLambda(syntax) // "pair" lambdas in queries ); }
internal void AddLookupSymbolsInfoInAliases(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder) { foreach (var(_, usingAlias) in this.UsingAliases) { AddAliasSymbolToResult(result, usingAlias.Alias, options, originalBinder); } foreach (var externAlias in this.ExternAliases) { AddAliasSymbolToResult(result, externAlias.Alias, options, originalBinder); } }
/// <summary> /// Creates a speculative AttributeSemanticModel that allows asking semantic questions about an attribute node that did not appear in the original source code. /// </summary> public static AttributeSemanticModel CreateSpeculative(SyntaxTreeSemanticModel parentSemanticModel, AttributeSyntax syntax, NamedTypeSymbol attributeType, AliasSymbol aliasOpt, Binder rootBinder, int position) { Debug.Assert(parentSemanticModel != null); Debug.Assert(rootBinder != null); Debug.Assert(rootBinder.IsSemanticModelBinder); return(new AttributeSemanticModel(syntax, attributeType, aliasOpt, rootBinder, parentSemanticModelOpt: parentSemanticModel, speculatedPosition: position)); }
/// <summary> /// Creates a speculative SemanticModel for a TypeSyntax node at a position within an existing MemberSemanticModel. /// </summary> public SpeculativeMemberSemanticModel(SyntaxTreeSemanticModel parentSemanticModel, Symbol owner, TypeSyntax root, Binder rootBinder, int position) : base(root, owner, rootBinder, containingSemanticModelOpt: null, parentSemanticModelOpt: parentSemanticModel, speculatedPosition: position) { }
private Binder XSLookupSymbolsInternal( LookupResult result, string name, int arity, ConsList <Symbol> basesBeingResolved, LookupOptions options, bool diagnose, ref HashSet <DiagnosticInfo> useSiteDiagnostics) { Debug.Assert(result.IsClear); Debug.Assert(options.AreValid()); // X# looks for functions first //if (Compilation.Options.HasRuntime) { // check for function calls method calls outside the current class bool check = (options.HasFlag(LookupOptions.MustNotBeInstance) && !options.HasFlag(LookupOptions.MustNotBeMethod)); if (check) { var funcOptions = options; funcOptions |= LookupOptions.MustBeInvocableIfMember; Binder scope = this; while (scope != null) { if (scope is InContainerBinder && scope.ContainingType == null) // at the namespace level, so outside of all types { scope.LookupSymbolsInSingleBinder(result, name, arity, basesBeingResolved, funcOptions, this, diagnose, ref useSiteDiagnostics); FilterResults(result, options); if (!result.IsClear) { break; } } scope = scope.Next; } } } LookupResult functionResults = LookupResult.GetInstance(); if (!result.IsClear) { foreach (var symbol in result.Symbols) { if (symbol is MethodSymbol) { var ms = symbol as MethodSymbol; if (ms.IsStatic && ms.ContainingType.Name.EndsWith("Functions", XSharpString.Comparison)) { SingleLookupResult single = new SingleLookupResult(LookupResultKind.Viable, ms, null); functionResults.MergeEqual(single); } } } result.Clear(); } Binder binder = null; for (var scope = this; scope != null && !result.IsMultiViable; scope = scope.Next) { if (binder != null) { var tmp = LookupResult.GetInstance(); scope.LookupSymbolsInSingleBinder(tmp, name, arity, basesBeingResolved, options, this, diagnose, ref useSiteDiagnostics); FilterResults(tmp, options); result.MergeEqual(tmp); tmp.Free(); } else { scope.LookupSymbolsInSingleBinder(result, name, arity, basesBeingResolved, options, this, diagnose, ref useSiteDiagnostics); FilterResults(result, options); if (!result.IsClear) { binder = scope; } } } if (!functionResults.IsClear) { // compare the function results with the overall results found // create a list of functions and methods // function first and then the methods LookupResult mergedResults = LookupResult.GetInstance(); mergedResults.MergeEqual(functionResults); // now add the symbols from result that do not exist for (int j = 0; j < result.Symbols.Count; j++) { var sym = result.Symbols[j]; var found = false; for (int i = 0; i < mergedResults.Symbols.Count; i++) { if (sym == mergedResults.Symbols[i]) { found = true; break; } } if (!found) { SingleLookupResult single = new SingleLookupResult(LookupResultKind.Viable, sym, null); mergedResults.MergeEqual(single); } } result.Clear(); result.MergeEqual(mergedResults); } // C563 Make sure the error is generated for Inaccessible types. if (!result.IsClear && result.Kind == LookupResultKind.Inaccessible && result.Error != null) { // we only want to add this for internal fields (globals) if (result.Symbols[0].Kind == SymbolKind.Field) { if (useSiteDiagnostics == null) { useSiteDiagnostics = new HashSet <DiagnosticInfo>(); } useSiteDiagnostics.Add(result.Error); } } return(binder); }
internal override BoundExpression BindSwitchExpressionCore(SwitchExpressionSyntax node, Binder originalBinder, DiagnosticBag diagnostics) { // There's supposed to be a SwitchExpressionBinder (or other overrider of this method) in the chain. throw ExceptionUtilities.Unreachable; }
/// <summary> /// Creates a SemanticModel that creates and owns the ExecutableCodeBinder for the method of which it is a model. /// </summary> internal static MethodBodySemanticModel Create(CSharpCompilation compilation, MethodSymbol owner, Binder rootBinder, CSharpSyntaxNode syntax) { var executableCodeBinder = new ExecutableCodeBinder(syntax, owner, rootBinder); return(new MethodBodySemanticModel(compilation, owner, executableCodeBinder, syntax)); }
internal WithParametersBinder(ImmutableArray <ParameterSymbol> parameters, Binder next) : base(next) { Debug.Assert(!parameters.IsDefaultOrEmpty); _parameters = parameters; }
internal void LookupSymbolInAliases( Binder originalBinder, LookupResult result, string name, int arity, ConsList <TypeSymbol> basesBeingResolved, LookupOptions options, bool diagnose, ref CompoundUseSiteInfo <AssemblySymbol> useSiteInfo ) { bool callerIsSemanticModel = originalBinder.IsSemanticModelBinder; AliasAndUsingDirective alias; if (this.UsingAliases.TryGetValue(name, out alias)) { // Found a match in our list of normal aliases. Mark the alias as being seen so that // it won't be reported to the user as something that can be removed. var res = originalBinder.CheckViability( alias.Alias, arity, options, null, diagnose, ref useSiteInfo, basesBeingResolved ); if (res.Kind == LookupResultKind.Viable) { MarkImportDirective(alias.UsingDirective, callerIsSemanticModel); } result.MergeEqual(res); } foreach (var a in this.ExternAliases) { if (a.Alias.Name == name) { // Found a match in our list of extern aliases. Mark the extern alias as being // seen so that it won't be reported to the user as something that can be // removed. var res = originalBinder.CheckViability( a.Alias, arity, options, null, diagnose, ref useSiteInfo, basesBeingResolved ); if (res.Kind == LookupResultKind.Viable) { MarkImportDirective(a.ExternAliasDirective, callerIsSemanticModel); } result.MergeEqual(res); } } }
private static void AddAliasSymbolToResult(LookupSymbolsInfo result, AliasSymbol aliasSymbol, LookupOptions options, Binder originalBinder) { var targetSymbol = aliasSymbol.GetAliasTarget(basesBeingResolved: null); if (originalBinder.CanAddLookupSymbolInfo(targetSymbol, options, result, accessThroughType: null, aliasSymbol: aliasSymbol)) { result.AddSymbol(aliasSymbol, aliasSymbol.Name, 0); } }
private Conversions(Binder binder, int currentRecursionDepth, bool includeNullability, Conversions otherNullabilityOpt) : base(binder.Compilation.Assembly.CorLibrary, currentRecursionDepth, includeNullability, otherNullabilityOpt) { _binder = binder; }
public virtual Binder ParameterBinder(LambdaSymbol lambdaSymbol, Binder binder) { return(new WithLambdaParametersBinder(lambdaSymbol, binder)); }
public Conversions(Binder binder) : this(binder, currentRecursionDepth : 0, includeNullability : false, otherNullabilityOpt : null) { }
// Note: we do not mark nodes when looking up arities or names. This is because these two // types of lookup are only around to make the public // SemanticModel.LookupNames/LookupSymbols work and do not count as usages of the directives // when the actual code is bound. internal void AddLookupSymbolsInfo(LookupSymbolsInfo result, LookupOptions options, Binder originalBinder) { AddLookupSymbolsInfoInAliases(result, options, originalBinder); // Add types within namespaces imported through usings, but don't add nested namespaces. LookupOptions usingOptions = (options & ~(LookupOptions.NamespaceAliasesOnly | LookupOptions.NamespacesOrTypesOnly)) | LookupOptions.MustNotBeNamespace; AddLookupSymbolsInfoInUsings(this.Usings, result, usingOptions, originalBinder); }
internal override void LookupSymbolsInSingleBinder( LookupResult result, string name, int arity, ConsList <TypeSymbol> basesBeingResolved, LookupOptions options, Binder originalBinder, bool diagnose, ref HashSet <DiagnosticInfo> useSiteDiagnostics) { if ((options & (LookupOptions.NamespaceAliasesOnly | LookupOptions.MustBeInvocableIfMember)) != 0) { return; } Debug.Assert(result.IsClear); foreach (ParameterSymbol parameter in _parameters) { if (parameter.Name == name) { result.MergeEqual(originalBinder.CheckViability(parameter, arity, options, null, diagnose, ref useSiteDiagnostics)); } } }
internal LockOrUsingBinder(Binder enclosing) : base(enclosing) { }
internal override BoundStatement BindLockStatementParts(DiagnosticBag diagnostics, Binder originalBinder) { // There's supposed to be a LockBinder (or other overrider of this method) in the chain. throw ExceptionUtilities.Unreachable; }
/// <summary> /// Creates a speculative SemanticModel for an expression body that did not appear in the original source code. /// </summary> internal static MethodBodySemanticModel CreateSpeculative(SyntaxTreeSemanticModel parentSemanticModel, MethodSymbol owner, ArrowExpressionClauseSyntax syntax, Binder rootBinder, int position) { Debug.Assert(parentSemanticModel != null); Debug.Assert(syntax != null); Debug.Assert(rootBinder != null); Debug.Assert(rootBinder.IsSemanticModelBinder); return(new MethodBodySemanticModel(parentSemanticModel.Compilation, owner, rootBinder, syntax, parentSemanticModel, position)); }
internal LocalInProgressBinder(LocalSymbol inProgress, Binder next) : base(next) { this.inProgress = inProgress; }
private static MethodGroupResolution ResolveDelegateOrFunctionPointerMethodGroup(Binder binder, BoundMethodGroup source, MethodSymbol delegateInvokeMethodOpt, bool isFunctionPointer, in CallingConventionInfo callingConventionInfo, ref CompoundUseSiteInfo <AssemblySymbol> useSiteInfo)
/// <summary> /// Creates an AttributeSemanticModel that allows asking semantic questions about an attribute node. /// </summary> public static AttributeSemanticModel Create(SyntaxTreeSemanticModel containingSemanticModel, AttributeSyntax syntax, NamedTypeSymbol attributeType, AliasSymbol aliasOpt, Binder rootBinder) { return(new AttributeSemanticModel(syntax, attributeType, aliasOpt, rootBinder, containingSemanticModel)); }