BoundCall

Binder\Binder_Await.cs (11)

62out BoundCall? runtimeAsyncAwaitCall, 95var call = (BoundCall)expression; 269out BoundCall? runtimeAsyncAwaitCall, 284out BoundCall? runtimeAsyncAwaitCall, 331bool tryGetRuntimeAwaitHelper(BoundExpression expression, out BoundAwaitableValuePlaceholder? placeholder, out BoundCall? runtimeAwaitCall, BindingDiagnosticBag diagnostics) 495bool getRuntimeAwaitAwaiter(TypeSymbol awaiterType, out BoundCall? runtimeAwaitAwaiterCall, out BoundAwaitableValuePlaceholder? placeholder, SyntaxNode syntax, BindingDiagnosticBag diagnostics) 615var call = (BoundCall)getAwaiterCall; 732var call = (BoundCall)getAwaiterGetResultCall;

Binder\Binder_Conversions.cs (3)

1407if (projectionInvocationExpression is not BoundCall 1453var builderCall = new BoundCall( 2246case BoundCall call:

Binder\Binder_Deconstruct.cs (1)

686var deconstructMethod = ((BoundCall)result).Method;

Binder\Binder_Expressions.cs (4)

5198var result = CreateBadCall( 6675var boundCall = (BoundCall)addMethodInvocation; 11301Debug.Assert(indexerOrSliceAccess is BoundIndexerAccess or BoundCall);

Binder\Binder_InterpolatedString.cs (3)

670Debug.Assert(appendCallsArray.All(appendCalls => appendCalls.All(a => a is { HasErrors: true } or BoundCall { Arguments: { Length: > 0 } } or BoundDynamicInvocation))); 979Debug.Assert(call is BoundCall or BoundDynamicInvocation or { HasErrors: true }); 983if (call is BoundCall { Method: { ReturnType: var returnType } method })

Binder\Binder_Invocation.cs (7)

1109var call = (BoundCall)expression; 1163private BoundCall BindInvocationExpressionContinued( 2076private BoundCall CreateBadCall( 2132return BoundCall.ErrorCall(node, receiver, method, args, argNames, argRefKinds, isDelegate, invokedAsExtensionMethod: invokedAsExtensionMethod, originalMethods: methods, resultKind: resultKind, binder: this); 2358private BoundCall CreateBadCall( 2373return BoundCall.ErrorCall(node, expr, method, args, argNames, argRefKinds, isDelegateCall: false, invokedAsExtensionMethod: false, originalMethods: originalMethods, resultKind: resultKind, binder: this);

Binder\Binder_Query.cs (19)

233var result = MakeQueryInvocation(state.selectOrGroup, e, "Select", lambda, diagnostics 257BoundCall result; 308private static BoundCall ReverseLastTwoParameterOrder(BoundCall result) 367var invocation = MakeQueryInvocation(where, state.fromExpression, "Where", lambda, diagnostics 415BoundCall invocation; 481BoundCall invocation; 568var invocation = MakeQueryInvocation(ordering, state.fromExpression, methodName, lambda, diagnostics 611var invocation = MakeQueryInvocation( 658var invocation = MakeQueryInvocation( 677private static BoundExpression? ExtractCastInvocation(BoundCall invocation) 688var i1 = r1 != null ? r1.ExpressionOpt as BoundCall : null; 762var invocation = MakeQueryInvocation(let, state.fromExpression, "Select", lambda, diagnostics 879protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, BoundExpression arg, BindingDiagnosticBag diagnostics 892protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, ImmutableArray<BoundExpression> args, BindingDiagnosticBag diagnostics 905protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, TypeSyntax typeArgSyntax, TypeWithAnnotations typeArg, BindingDiagnosticBag diagnostics 918protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, SeparatedSyntaxList<TypeSyntax> typeArgsSyntax, ImmutableArray<TypeWithAnnotations> typeArgs, ImmutableArray<BoundExpression> args, BindingDiagnosticBag diagnostics 997return (BoundCall)MakeInvocationExpression(

Binder\Binder_Statements.cs (6)

1704case BoundCall or BoundArrayAccess: 1752BoundImplicitIndexerAccess { IndexerOrSliceAccess: BoundCall call } => call.Method, 4024internal static BoundCall? GenerateBaseParameterlessConstructorInitializer(MethodSymbol constructor, BindingDiagnosticBag diagnostics) 4086private static BoundCall? GenerateBaseCopyConstructorInitializer(SynthesizedRecordCopyCtor constructor, BindingDiagnosticBag diagnostics) 4265var call = (BoundCall)patternMethodCall;

Binder\Binder.ValueChecks.cs (18)

113public static MethodInvocationInfo FromCall(BoundCall call, BoundExpression? substitutedReceiver = null) 1114var call = (BoundCall)expr; 1132case BoundCall sliceAccess: 3798var call = (BoundCall)expr; 3859case BoundCall call: 4088var call = (BoundCall)expr; 4156case BoundCall call: 4460var call = (BoundCall)expr; 4508case BoundCall call: 5180var call = (BoundCall)expr; 5245case BoundCall call: 5914if (part is not BoundCall { IsErroneousNode: false } call) 5955if (part is not BoundCall { IsErroneousNode: false } call)

Binder\ForEachLoopBinder.cs (1)

742return BoundCall.Synthesized(

Binder\RefSafetyAnalysis.cs (12)

780public sealed override BoundNode? VisitCall(BoundCall node) 783if (methodInvocationInfo.Receiver is BoundCall receiver1) 785var calls = ArrayBuilder<(BoundCall call, MethodInvocationInfo methodInvocationInfo)>.GetInstance(); 791while (methodInvocationInfo.Receiver is BoundCall receiver2) 820static MethodInvocationInfo getInvocationInfo(BoundCall node) 832void visitReceiver(BoundCall node, ref readonly MethodInvocationInfo methodInvocationInfo) 844void visitArguments(BoundCall node, ref readonly MethodInvocationInfo methodInvocationInfo) 857protected override void VisitReceiver(BoundCall node) 870protected override void VisitArguments(BoundCall node) 875private void VisitArguments(BoundCall node, ref readonly MethodInvocationInfo methodInvocationInfo) 1175var invocation = conversion.DeconstructionInfo.Invocation as BoundCall;

Binder\Semantics\Conversions\Conversion.cs (2)

536if (deconstructionUncommonData.DeconstructMethodInfo.Invocation is BoundCall call) 1319Debug.Assert(invocation is not BoundCall { Expanded: true });

BoundTree\BoundCollectionExpression.cs (3)

17if (collectionCreation is BoundCall boundCall) 43/// <item>a <see cref="BoundCall"/> (when targeting a CollectionBuilder method),</item> 58or BoundCall

BoundTree\BoundExpressionExtensions.cs (2)

34return ((BoundCall)node).Method.RefKind; 219var originalMethods = ((BoundCall)node).OriginalMethodsOpt;

BoundTree\BoundImplicitIndexerAccess.cs (1)

21Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess);

BoundTree\BoundNodeExtensions.cs (2)

51return expression.Kind == BoundKind.Call && ((BoundCall)expression).IsConstructorInitializer(); 57public static bool IsConstructorInitializer(this BoundCall call)

BoundTree\BoundTreeVisitors.cs (1)

116return VisitCall(node as BoundCall, arg);

BoundTree\BoundTreeWalker.cs (10)

38var call = unoptimizedForm as BoundCall; 179public override BoundNode? VisitCall(BoundCall node) 181if (node.ReceiverOpt is BoundCall receiver1) 183var calls = ArrayBuilder<BoundCall>.GetInstance(); 188while (node.ReceiverOpt is BoundCall receiver2) 216protected virtual void BeforeVisitingSkippedBoundCallChildren(BoundCall node) 221/// Called only for the first (in evaluation order) <see cref="BoundCall"/> in the chain. 223protected virtual void VisitReceiver(BoundCall node) 228protected virtual void VisitArguments(BoundCall node)

BoundTree\Constructors.cs (8)

106public BoundCall Update(BoundExpression? receiverOpt, 121public static BoundCall ErrorCall( 165public BoundCall Update(ImmutableArray<BoundExpression> arguments) 170public BoundCall Update(BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments) 175public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method) 180public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, BoundExpression arg0) 185public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, BoundExpression arg0, BoundExpression arg1) 190public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt = default)

CodeGen\CodeGenerator_HasHome.cs (1)

134var methodRefKind = ((BoundCall)expression).Method.RefKind;

CodeGen\CodeGenerator_RefSafety.cs (1)

13private static bool MightEscapeTemporaryRefs(BoundCall node, bool used)

CodeGen\EmitAddress.cs (3)

118var call = (BoundCall)expression; 197private static bool UseCallResultAsAddress(BoundCall call, AddressKind addressKind)

CodeGen\EmitExpression.cs (20)

103EmitCallExpression((BoundCall)expression, used ? UseKind.UsedAsValue : UseKind.Unused); 627protected override void VisitReceiver(BoundCall node) 1637private void EmitCallExpression(BoundCall call, UseKind useKind) 1654private void EmitDefaultValueTypeConstructorCallExpression(BoundCall call) 1674private void EmitStaticCallExpression(BoundCall call, UseKind useKind) 1711private void EmitInstanceCallExpression(BoundCall call, UseKind useKind) 1720if (receiverIsInstanceCall(call, out BoundCall nested)) 1722var calls = ArrayBuilder<BoundCall>.GetInstance(); 1738var parentCall = calls.Pop(); 1858CallKind determineEmitReceiverStrategy(BoundCall call, out AddressKind? addressKind, out bool box) 1953void emitReceiver(BoundCall call, CallKind callKind, AddressKind? addressKind, bool box, out LocalDefinition tempOpt) 1979void emitArgumentsAndCallEpilogue(BoundCall call, CallKind callKind, UseKind useKind) 2065void emitGenericReceiverCloneIfNecessary(BoundCall call, CallKind callKind, ref LocalDefinition tempOpt) 2116static bool receiverIsInstanceCall(BoundCall call, out BoundCall nested) 2118if (call.ReceiverOpt is BoundCall { Method: { RequiresInstanceReceiver: true } method } receiver && !method.IsDefaultValueTypeConstructor()) 2266return ((BoundCall)receiver).Method.RefKind != RefKind.None; 2987var left = (BoundCall)assignmentTarget; 3201Debug.Assert(((BoundCall)expression).Method.RefKind != RefKind.None);

CodeGen\Optimizer.cs (17)

1066Debug.Assert(((BoundCall)lhs).Method.RefKind == RefKind.Ref, "only ref returning methods are assignable"); 1119public override BoundNode VisitCall(BoundCall node) 1121if (node.ReceiverOpt is BoundCall receiver) 1124var calls = ArrayBuilder<BoundCall>.GetInstance(); 1129while (node.ReceiverOpt is BoundCall receiver2) 1165BoundExpression visitReceiver(BoundCall node) 1197BoundCall visitArgumentsAndUpdateCall(BoundCall node, BoundExpression receiver) 1204private BoundExpression VisitCallOrConditionalAccessReceiver(BoundExpression receiver, BoundCall callOpt) 1219private void CheckCallReceiver(BoundExpression receiver, BoundCall call) 2075public override BoundNode VisitCall(BoundCall node) 2278public override BoundNode VisitCall(BoundCall node) 2280if (node.ReceiverOpt is BoundCall receiver1) 2282var calls = ArrayBuilder<BoundCall>.GetInstance(); 2287while (node.ReceiverOpt is BoundCall receiver2) 2318BoundExpression? visitReceiver(BoundCall node) 2344BoundExpression visitArgumentsAndUpdateCall(BoundCall node, BoundExpression? receiverOpt)

Compilation\CSharpCompilation.cs (1)

2290var success = binder.GetAwaitableExpressionInfo(dumbInstance, out BoundExpression? result, out BoundCall? runtimeAwaitCall, syntax, diagnostics);

Compilation\CSharpSemanticModel.cs (6)

3451var call = (BoundCall)boundNode; 4289var call = (BoundCall)boundNodeForSyntacticParent; 4765private static OneOrMany<Symbol> CreateReducedAndFilteredSymbolsFromOriginals(BoundCall call, CSharpCompilation compilation) 4801private OneOrMany<Symbol> CreateReducedExtensionMethodIfPossible(BoundCall call)

Compilation\MemberSemanticModel.cs (4)

1095var call = bound?.Operation as BoundCall; 1824var call = (BoundCall)node;

Compiler\MethodBodySynthesizer.cs (8)

288BoundCall getOrCreateCall = BoundCall.Synthesized( 301BoundCall processHandlerCall = BoundCall.Synthesized( 400operand: BoundCall.Synthesized(syntax, 465operand: BoundCall.Synthesized(syntax, 483BoundExpression compareExchange = BoundCall.Synthesized(syntax, 546BoundCall.Synthesized(

Compiler\MethodBodySynthesizer.Lowered.cs (1)

377public static BoundCall GenerateGetHashCode(

Compiler\MethodCompiler.cs (3)

2022expressionStatement.Expression is BoundCall { Method: var initMethod } && initMethod.IsDefaultValueTypeConstructor(); 2521var ctorCall = initializerInvocation as BoundCall;

FlowAnalysis\AbstractFlowPass.cs (5)

1331public override BoundNode VisitCall(BoundCall node) 1345if (node.ReceiverOpt is BoundCall receiver1) 1347var calls = ArrayBuilder<BoundCall>.GetInstance(); 1352while (node.ReceiverOpt is BoundCall receiver2) 1381void visitArgumentsAndCompleteAnalysis(BoundCall node)

FlowAnalysis\NullableWalker_Patterns.cs (1)

992case BoundCall call:

FlowAnalysis\NullableWalker.cs (18)

1628return constructorBody is BoundConstructorMethodBody { Initializer: BoundExpressionStatement { Expression: BoundCall { Method: { MethodKind: MethodKind.Constructor } initializerMethod } } } 4062else if (collectionCreation is BoundCall call) 6833public override BoundNode? VisitCall(BoundCall node) 6836if (tryGetReceiver(node, out BoundCall? receiver)) 6839var calls = ArrayBuilder<BoundCall>.GetInstance(); 6847while (tryGetReceiver(node, out BoundCall? receiver2)) 6936bool tryGetReceiver(BoundCall node, [MaybeNullWhen(returnValue: false)] out BoundCall receiver) 6938if (node.ReceiverOpt is BoundCall instanceReceiver) 6944if (node.InvokedAsExtensionMethod && node.Arguments is [BoundCall extensionReceiver, ..] && 6957TypeWithState visitAndCheckReceiver(BoundCall node) 6967void reinferMethodAndVisitArguments(BoundCall node, TypeWithState receiverType, VisitResult? firstArgumentResult = null) 7175private void LearnFromEqualsMethod(MethodSymbol method, BoundCall node, TypeWithState receiverType, ImmutableArray<VisitResult> results) 7564if (node is BoundCall && node.Syntax is SlicePatternSyntax) 7774if (node is BoundCall { HasErrors: true, ArgumentNamesOpt.IsDefaultOrEmpty: false, ArgsToParamsOpt.IsDefault: true } && 7818if (node is BoundCall { Method: { OriginalDefinition: LocalFunctionSymbol localFunction } }) 11538var invocation = conversion.DeconstructionInfo.Invocation as BoundCall;

Generated\BoundNodes.xml.Generated.cs (17)

2177public BoundAwaitableInfo(SyntaxNode syntax, BoundAwaitableValuePlaceholder? awaitableInstancePlaceholder, bool isDynamic, BoundExpression? getAwaiter, PropertySymbol? isCompleted, MethodSymbol? getResult, BoundCall? runtimeAsyncAwaitCall, BoundAwaitableValuePlaceholder? runtimeAsyncAwaitCallPlaceholder, bool hasErrors = false) 2198public BoundCall? RuntimeAsyncAwaitCall { get; } 2204public BoundAwaitableInfo Update(BoundAwaitableValuePlaceholder? awaitableInstancePlaceholder, bool isDynamic, BoundExpression? getAwaiter, PropertySymbol? isCompleted, MethodSymbol? getResult, BoundCall? runtimeAsyncAwaitCall, BoundAwaitableValuePlaceholder? runtimeAsyncAwaitCallPlaceholder) 6261public BoundCall Update(BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalMethodsOpt, TypeSymbol type) 6265var result = new BoundCall(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, defaultArguments, resultKind, originalMethodsOpt, type, this.HasErrors); 9407return VisitCall((BoundCall)node, arg); 9724public virtual R VisitCall(BoundCall node, A arg) => this.DefaultVisit(node, arg); 9965public virtual BoundNode? VisitCall(BoundCall node) => this.DefaultVisit(node); 10743public override BoundNode? VisitCall(BoundCall node) 11458BoundCall? runtimeAsyncAwaitCall = (BoundCall?)this.Visit(node.RuntimeAsyncAwaitCall); 12166public override BoundNode? VisitCall(BoundCall node) 13445BoundCall? runtimeAsyncAwaitCall = (BoundCall?)this.Visit(node.RuntimeAsyncAwaitCall); 14424public override BoundNode? VisitCall(BoundCall node) 14430BoundCall updatedNode; 16921public override TreeDumperNode VisitCall(BoundCall node, object? arg) => new TreeDumperNode("call", null, new TreeDumperNode[]

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (7)

143var runtimeAsyncAwaitCall = awaitableInfo.RuntimeAsyncAwaitCall; 203var isCompletedCall = _factory.Call(tmp, isCompletedMethod); 209var awaitCall = (BoundCall)Visit(awaitableInfo.RuntimeAsyncAwaitCall); 219var getResultCall = _factory.Call(tmp, getResultMethod); 267var unsafeAwaitCall = _factory.Call( 276var safeAwaitCall = _factory.Call(

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (2)

137BoundCall? runtimeAsyncAwaitCall = null; 144runtimeAsyncAwaitCall = (BoundCall?)this.Visit(node.RuntimeAsyncAwaitCall);

Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (1)

458protected override void VisitArguments(BoundCall node)

Lowering\ClosureConversion\ClosureConversion.cs (3)

1084public override BoundNode VisitCall(BoundCall node) 1124var rewritten = (BoundCall)visited;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

205return VisitCall((BoundCall)node); 643private BoundExpression VisitCall(BoundCall node)

Lowering\DiagnosticsPass_ExpressionTrees.cs (5)

484public override BoundNode VisitCall(BoundCall node) 486if (node.ReceiverOpt is BoundCall receiver1) 488var calls = ArrayBuilder<BoundCall>.GetInstance(); 493while (node.ReceiverOpt is BoundCall receiver2) 523void visitCall(BoundCall node)

Lowering\ExtensionMethodBodyRewriter.cs (1)

169public override BoundNode? VisitCall(BoundCall node)

Lowering\ExtensionMethodReferenceRewriter.cs (7)

29public override BoundNode VisitCall(BoundCall node) 34public static BoundNode VisitCall(BoundTreeRewriter rewriter, BoundCall node) 40if (LocalRewriter.TryGetReceiver(node, out BoundCall? receiver1)) 43var calls = ArrayBuilder<BoundCall>.GetInstance(); 48while (LocalRewriter.TryGetReceiver(node, out BoundCall? receiver2)) 75static BoundExpression visitArgumentsAndFinishRewrite(BoundTreeRewriter rewriter, BoundCall node, BoundExpression? rewrittenReceiver) 91BoundCall boundCall,

Lowering\Instrumentation\CompoundInstrumenter.cs (1)

159public override BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)

Lowering\Instrumentation\Instrumenter.cs (1)

227public virtual BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

552public override BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (3)

422BoundExpression setterCall = BoundCall.Synthesized( 438BoundCall setterCall = BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (11)

Lowering\LocalRewriter\LocalRewriter_Call.cs (10)

338public override BoundNode VisitCall(BoundCall node) 344if (TryGetReceiver(node, out BoundCall? receiver1)) 347var calls = ArrayBuilder<BoundCall>.GetInstance(); 352while (TryGetReceiver(node, out BoundCall? receiver2)) 379BoundExpression visitArgumentsAndFinishRewrite(BoundCall node, BoundExpression? rewrittenReceiver) 438internal static bool TryGetReceiver(BoundCall node, [MaybeNullWhen(returnValue: false)] out BoundCall receiver) 440if (node.ReceiverOpt is BoundCall instanceReceiver) 446if (node.InvokedAsExtensionMethod && node.Arguments is [BoundCall extensionReceiver, ..]) 458BoundCall? node,

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (6)

417var listSpanValue = _factory.Call(null, asSpanMethod.Construct([elementType]), list); 433var array = _factory.Call(list, listToArray); 754var call = _factory.Call(null, elementRef, inlineArrayLocal, _factory.Literal(i), useStrictArgumentRefKinds: true); 767var span = _factory.Call( 1206var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!)); 1207var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (5)

46return BoundCall.Synthesized(syntax, 67BoundCall.Synthesized(syntax, 871Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 1088var call = (BoundCall)expression;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (11)

Lowering\LocalRewriter\LocalRewriter_Event.cs (1)

256getOrCreateCall = BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_ExpressionStatement.cs (2)

63var call = (BoundCall)expression;

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)

359var getPinnableCall = getPinnableMethod.IsStatic ?

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (6)

202BoundCall.Synthesized( 455BoundExpression disposeCall = BoundCall.Synthesized(syntax: forEachSyntax, receiverOpt: boundDisposableVar, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method: disposeMethod); 716return BoundCall.Synthesized( 725return BoundCall.Synthesized( 1101BoundExpression currentDimensionUpperBound = BoundCall.Synthesized(forEachSyntax, boundArrayVar, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getUpperBoundMethod, dimensionArgument); 1155BoundExpression currentDimensionLowerBound = BoundCall.Synthesized(forEachSyntax, boundArrayVar, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getLowerBoundMethod, dimensionArgument);

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (4)

305var spanExpr = _factory.Call(null, createSpan, rewrittenReceiver, _factory.Literal(length), useStrictArgumentRefKinds: true); 880Debug.Assert(node.IndexerOrSliceAccess is BoundCall); 994var sliceCall = (BoundCall)node.IndexerOrSliceAccess;

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (5)

55var enterScopeCall = BoundCall.Synthesized( 108exitCallExpr = BoundCall.Synthesized( 154BoundCall.Synthesized( 203enterCallExpr = BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (3)

126var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault), 152var lhsReadHasValue = BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, hasValue);

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (5)

142return BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault); 149return BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefaultDefaultValue, rewrittenRight); 197var boundCall = (BoundCall)expression; 258rewrittenLeft = BoundCall.Synthesized(rewrittenLeft.Syntax, rewrittenLeft, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault);

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (3)

186BoundCall clone = _factory.Call( 350var createInstanceCall = new BoundCall( 420BoundCall instance = _factory.Call(null, createInstance, callGetTypeFromCLSID);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

450else if (rewrittenArrayAccess is BoundCall getSubArrayCall)

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (1)

97return BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (11)

196return BoundCall.Synthesized(originalSyntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method, finalArguments); 293else if (argument is BoundCall call) 413public bool IsWellKnownConcatMethod(BoundCall call, out ImmutableArray<BoundExpression> arguments) 441public bool IsCharToString(BoundCall call, [NotNullWhen(true)] out BoundExpression? charExpression) 463private readonly bool IsConcatNonArray(BoundCall call, ref MethodSymbol? concatMethod, SpecialMember concatSpecialMember, out ImmutableArray<BoundExpression> arguments) 554args[i] = BoundCall.Synthesized(arg.Syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, stringImplicitConversionToReadOnlySpan, arg); 558var concatCall = BoundCall.Synthesized(syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, spanConcat, args.ToImmutableAndFree()); 693return BoundCall.Synthesized(syntax, expr, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, structToStringMethod); 718return BoundCall.Synthesized(syntax, expr, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, objectToStringMethod); 746whenNotNull: BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (3)

33Debug.Assert(parts.All(static p => p is BoundCall or BoundDynamicInvocation)); 73if (part is BoundCall call) 227? BoundCall.Synthesized(syntax, result.HandlerTemp, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, toStringAndClear)

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (3)

176var call = factory.Call( 191var call = factory.Call( 205var call = factory.Call(

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (15)

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)

365disposedExpression = BoundCall.Synthesized(resourceSyntax, local, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault);

Lowering\LocalRewriter\LocalRewriter.cs (1)

1099return ((BoundCall)expr).Method.RefKind != RefKind.None;

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (1)

151protected override void VisitArguments(BoundCall node)

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (1)

658var siteInvocation = _factory.Call(

Lowering\MethodToClassRewriter.cs (1)

96public override BoundNode VisitCall(BoundCall node)

Lowering\SpillSequenceSpiller.cs (4)

432var call = (BoundCall)expression; 520BoundExpression spillInlineArrayHelperWithTwoArguments(BoundSpillSequenceBuilder builder, BoundCall call) 1086public override BoundNode VisitCall(BoundCall node)

Lowering\StateMachineRewriter\RefInitializationHoister.cs (2)

231var call = (BoundCall)expr;

Lowering\SyntheticBoundNodeFactory.cs (8)

879public BoundCall Call(BoundExpression? receiver, MethodSymbol method) 884public BoundCall Call(BoundExpression? receiver, MethodSymbol method, BoundExpression arg0, bool useStrictArgumentRefKinds = false) 889public BoundCall Call(BoundExpression? receiver, MethodSymbol method, BoundExpression arg0, BoundExpression arg1, bool useStrictArgumentRefKinds = false) 894public BoundCall Call(BoundExpression? receiver, MethodSymbol method, params BoundExpression[] args) 899public BoundCall Call(BoundExpression? receiver, WellKnownMember method, BoundExpression arg0) 902public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<BoundExpression> args, bool useStrictArgumentRefKinds = false) 944public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<RefKind> refKinds, ImmutableArray<BoundExpression> args) 1836return BoundCall.Synthesized(

Operations\CSharpOperationFactory_Methods.cs (2)

234var boundCall = (BoundCall)containingExpression;

Operations\CSharpOperationFactory.cs (5)

41return CreateBoundCallOperation((BoundCall)boundNode); 447private IOperation CreateBoundCallOperation(BoundCall boundCall) 1329if (collectionCreation is BoundCall boundCall) 2398case BoundCall call: 2535BoundCall { Method.Name: var name } => name,

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (1)

784static BoundCall makeEqualityComparerDefaultEquals(

Symbols\Synthesized\Records\SynthesizedRecordBaseEquals.cs (1)

71var retExpr = F.Call(

Symbols\Synthesized\Records\SynthesizedRecordEquals.cs (1)

97var contractsEqual = F.Call(receiver: null, F.WellKnownMethod(WellKnownMember.System_Type__op_Equality),

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)

171var basePrintCall = F.Call(receiver: F.Base(ContainingType.BaseTypeNoUseSiteDiagnostics), basePrintMethod, builder);

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (4)

295private static BoundCall CreateParameterlessCall(CSharpSyntaxNode syntax, BoundExpression receiver, ThreeState receiverIsSubjectToCloning, MethodSymbol method) 365BoundCall userMainInvocation = new BoundCall( 530var initializeCall = CreateParameterlessCall(syntax, scriptLocal, receiverIsSubjectToCloning: ThreeState.False, initializer); 646var initializeResult = CreateParameterlessCall(

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)

297var baseConstructorCall = Binder.GenerateBaseParameterlessConstructorInitializer(this, diagnostics);