BoundCall

Binder\Binder.ValueChecks.cs (17)

874var call = (BoundCall)expr; 892case BoundCall sliceAccess: 3443var call = (BoundCall)expr; 3527case BoundCall call: 3760var call = (BoundCall)expr; 3844case BoundCall call: 4158var call = (BoundCall)expr; 4229case BoundCall call: 4868var call = (BoundCall)expr; 4956case BoundCall call: 5665if (part is not BoundCall { Method.Name: BoundInterpolatedString.AppendFormattedMethod } call) 5772var methodRefKind = ((BoundCall)expression).Method.RefKind;

Binder\Binder_Await.cs (6)

92var call = (BoundCall)expression; 347var call = (BoundCall)getAwaiterCall; 455var call = (BoundCall)getAwaiterGetResultCall;

Binder\Binder_Deconstruct.cs (1)

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

Binder\Binder_Expressions.cs (4)

5038var result = CreateBadCall( 6457var boundCall = (BoundCall)addMethodInvocation; 9924Debug.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)

1044var call = (BoundCall)expression; 1098private BoundCall BindInvocationExpressionContinued( 1912private BoundCall CreateBadCall( 1953return BoundCall.ErrorCall(node, receiver, method, args, argNames, argRefKinds, isDelegate, invokedAsExtensionMethod: invokedAsExtensionMethod, originalMethods: methods, resultKind: resultKind, binder: this); 2166private BoundCall CreateBadCall( 2181return 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) 683var i1 = r1 != null ? r1.ExpressionOpt as BoundCall : null; 757var invocation = MakeQueryInvocation(let, state.fromExpression, "Select", lambda, diagnostics 874protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, BoundExpression arg, BindingDiagnosticBag diagnostics 887protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, ImmutableArray<BoundExpression> args, BindingDiagnosticBag diagnostics 900protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, TypeSyntax typeArgSyntax, TypeWithAnnotations typeArg, BindingDiagnosticBag diagnostics 913protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression receiver, string methodName, SeparatedSyntaxList<TypeSyntax> typeArgsSyntax, ImmutableArray<TypeWithAnnotations> typeArgs, ImmutableArray<BoundExpression> args, BindingDiagnosticBag diagnostics 1008return (BoundCall)MakeInvocationExpression(

Binder\Binder_Statements.cs (6)

1659case BoundCall or BoundArrayAccess: 1707BoundImplicitIndexerAccess { IndexerOrSliceAccess: BoundCall call } => call.Method, 3909internal static BoundCall? GenerateBaseParameterlessConstructorInitializer(MethodSymbol constructor, BindingDiagnosticBag diagnostics) 3971private static BoundCall? GenerateBaseCopyConstructorInitializer(SynthesizedRecordCopyCtor constructor, BindingDiagnosticBag diagnostics) 4147var call = (BoundCall)patternMethodCall;

Binder\ForEachLoopBinder.cs (1)

714return BoundCall.Synthesized(

Binder\RefSafetyAnalysis.cs (4)

270protected override void BeforeVisitingSkippedBoundCallChildren(BoundCall node) 651protected override void VisitArguments(BoundCall node) 933var invocation = conversion.DeconstructionInfo.Invocation as BoundCall;

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

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

BoundTree\BoundExpressionExtensions.cs (2)

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

BoundTree\BoundImplicitIndexerAccess.cs (1)

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

BoundTree\BoundNode_Source.cs (1)

212case BoundCall call:

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 sealed 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( 158public BoundCall Update(ImmutableArray<BoundExpression> arguments) 163public BoundCall Update(BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments) 168public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method) 173public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, BoundExpression arg0) 178public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, BoundExpression arg0, BoundExpression arg1) 183public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt = default)

CodeGen\EmitAddress.cs (3)

113var call = (BoundCall)expression; 179private static bool UseCallResultAsAddress(BoundCall call, AddressKind addressKind)

CodeGen\EmitExpression.cs (19)

103EmitCallExpression((BoundCall)expression, used ? UseKind.UsedAsValue : UseKind.Unused); 630protected override void VisitReceiver(BoundCall node) 1618private void EmitCallExpression(BoundCall call, UseKind useKind) 1635private void EmitDefaultValueTypeConstructorCallExpression(BoundCall call) 1655private void EmitStaticCallExpression(BoundCall call, UseKind useKind) 1686private void EmitInstanceCallExpression(BoundCall call, UseKind useKind) 1693if (receiverIsInstanceCall(call, out BoundCall nested)) 1695var calls = ArrayBuilder<BoundCall>.GetInstance(); 1823CallKind determineEmitReceiverStrategy(BoundCall call, out AddressKind? addressKind, out bool box) 1914void emitReceiver(BoundCall call, CallKind callKind, AddressKind? addressKind, bool box, out LocalDefinition tempOpt) 1940void emitArgumentsAndCallEpilogue(BoundCall call, CallKind callKind, UseKind useKind) 2020void emitGenericReceiverCloneIfNecessary(BoundCall call, CallKind callKind, ref LocalDefinition tempOpt) 2071static bool receiverIsInstanceCall(BoundCall call, out BoundCall nested) 2073if (call.ReceiverOpt is BoundCall { Method: { RequiresInstanceReceiver: true } method } receiver && !method.IsDefaultValueTypeConstructor()) 2220return ((BoundCall)receiver).Method.RefKind != RefKind.None; 2929var left = (BoundCall)assignmentTarget; 3133Debug.Assert(((BoundCall)expression).Method.RefKind != RefKind.None);

CodeGen\Optimizer.cs (16)

1057Debug.Assert(((BoundCall)lhs).Method.RefKind == RefKind.Ref, "only ref returning methods are assignable"); 1108public override BoundNode VisitCall(BoundCall node) 1110if (node.ReceiverOpt is BoundCall receiver) 1113var calls = ArrayBuilder<BoundCall>.GetInstance(); 1118while (node.ReceiverOpt is BoundCall receiver2) 1154BoundExpression visitReceiver(BoundCall node) 1186BoundCall visitArgumentsAndUpdateCall(BoundCall node, BoundExpression receiver) 1193private BoundExpression VisitCallOrConditionalAccessReceiver(BoundExpression receiver, BoundCall callOpt) 1208private void CheckCallReceiver(BoundExpression receiver, BoundCall call) 2211public override BoundNode VisitCall(BoundCall node) 2213if (node.ReceiverOpt is BoundCall receiver1) 2215var calls = ArrayBuilder<BoundCall>.GetInstance(); 2220while (node.ReceiverOpt is BoundCall receiver2) 2251BoundExpression? visitReceiver(BoundCall node) 2277BoundExpression visitArgumentsAndUpdateCall(BoundCall node, BoundExpression? receiverOpt)

Compilation\CSharpSemanticModel.cs (6)

3438var call = (BoundCall)boundNode; 4264var call = (BoundCall)boundNodeForSyntacticParent; 4740private static OneOrMany<MethodSymbol> CreateReducedExtensionMethodsFromOriginalsIfNecessary(BoundCall call, CSharpCompilation compilation) 4777private OneOrMany<Symbol> CreateReducedExtensionMethodIfPossible(BoundCall call)

Compilation\MemberSemanticModel.cs (4)

1049var call = bound?.Operation as BoundCall; 1778var call = (BoundCall)node;

Compiler\MethodBodySynthesizer.cs (8)

286BoundCall getOrCreateCall = BoundCall.Synthesized( 299BoundCall processHandlerCall = BoundCall.Synthesized( 398operand: BoundCall.Synthesized(syntax, 463operand: BoundCall.Synthesized(syntax, 481BoundExpression compareExchange = BoundCall.Synthesized(syntax, 544BoundCall.Synthesized(

Compiler\MethodBodySynthesizer.Lowered.cs (1)

377public static BoundCall GenerateGetHashCode(

Compiler\MethodCompiler.cs (3)

1867expressionStatement.Expression is BoundCall { Method: var initMethod } && initMethod.IsDefaultValueTypeConstructor(); 2359var 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.cs (16)

1461return constructorBody is BoundConstructorMethodBody { Initializer: BoundExpressionStatement { Expression: BoundCall { Method: { MethodKind: MethodKind.Constructor } initializerMethod } } } 6172public override BoundNode? VisitCall(BoundCall node) 6175if (tryGetReceiver(node, out BoundCall? receiver)) 6178var calls = ArrayBuilder<BoundCall>.GetInstance(); 6186while (tryGetReceiver(node, out BoundCall? receiver2)) 6241bool tryGetReceiver(BoundCall node, [MaybeNullWhen(returnValue: false)] out BoundCall receiver) 6243if (node.ReceiverOpt is BoundCall instanceReceiver) 6249if (node.InvokedAsExtensionMethod && node.Arguments is [BoundCall extensionReceiver, ..] && 6262TypeWithState visitAndCheckReceiver(BoundCall node) 6275void reinferMethodAndVisitArguments(BoundCall node, TypeWithState receiverType, VisitResult? firstArgumentResult = null) 6305private void LearnFromEqualsMethod(MethodSymbol method, BoundCall node, TypeWithState receiverType, ImmutableArray<VisitResult> results) 6877if (node is BoundCall { HasErrors: true, ArgumentNamesOpt.IsDefaultOrEmpty: false, ArgsToParamsOpt.IsDefault: true } && 6917if (node is BoundCall { Method: { OriginalDefinition: LocalFunctionSymbol localFunction } }) 10159var invocation = conversion.DeconstructionInfo.Invocation as BoundCall;

FlowAnalysis\NullableWalker_Patterns.cs (1)

851BoundCall call => AsMemberOfType(inputType, call.Method).GetTypeOrReturnType(),

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

6184public 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) 6188var result = new BoundCall(this.Syntax, receiverOpt, initialBindingReceiverIsSubjectToCloning, method, arguments, argumentNamesOpt, argumentRefKindsOpt, isDelegateCall, expanded, invokedAsExtensionMethod, argsToParamsOpt, defaultArguments, resultKind, originalMethodsOpt, type, this.HasErrors); 9157return VisitCall((BoundCall)node, arg); 9466public virtual R VisitCall(BoundCall node, A arg) => this.DefaultVisit(node, arg); 9702public virtual BoundNode? VisitCall(BoundCall node) => this.DefaultVisit(node); 10458public override BoundNode? VisitCall(BoundCall node) 11737public override BoundNode? VisitCall(BoundCall node) 13928public override BoundNode? VisitCall(BoundCall node) 13934BoundCall updatedNode; 16383public override TreeDumperNode VisitCall(BoundCall node, object? arg) => new TreeDumperNode("call", null, new TreeDumperNode[]

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

458protected override void VisitArguments(BoundCall node)

Lowering\ClosureConversion\ClosureConversion.cs (3)

1069public override BoundNode VisitCall(BoundCall node) 1109var rewritten = (BoundCall)visited;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

200return VisitCall((BoundCall)node); 636private BoundExpression VisitCall(BoundCall node)

Lowering\DiagnosticsPass_ExpressionTrees.cs (4)

450public override BoundNode VisitCall(BoundCall node) 452if (node.ReceiverOpt is BoundCall receiver1) 454var calls = ArrayBuilder<BoundCall>.GetInstance(); 459while (node.ReceiverOpt is BoundCall receiver2)

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)

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

Lowering\LocalRewriter\LocalRewriter.cs (1)

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

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

151protected override void VisitArguments(BoundCall node)

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (3)

335BoundExpression setterCall = BoundCall.Synthesized( 351BoundCall setterCall = BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (11)

Lowering\LocalRewriter\LocalRewriter_Call.cs (10)

321public override BoundNode VisitCall(BoundCall node) 327if (tryGetReceiver(node, out BoundCall? receiver1)) 330var calls = ArrayBuilder<BoundCall>.GetInstance(); 335while (tryGetReceiver(node, out BoundCall? receiver2)) 363static bool tryGetReceiver(BoundCall node, [MaybeNullWhen(returnValue: false)] out BoundCall receiver) 365if (node.ReceiverOpt is BoundCall instanceReceiver) 371if (node.InvokedAsExtensionMethod && node.Arguments is [BoundCall extensionReceiver, ..]) 382BoundExpression visitArgumentsAndFinishRewrite(BoundCall node, BoundExpression? rewrittenReceiver) 439BoundCall? node,

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (5)

478var invocation = new BoundCall( 578var call = _factory.Call(null, elementRef, inlineArrayLocal, _factory.Literal(i), useStrictArgumentRefKinds: true); 591var span = _factory.Call( 964var spreadLength = _factory.Call(spreadOperandAsSpan, getLengthMethod.AsMember((NamedTypeSymbol)spreadOperandAsSpan.Type!)); 965var targetSlice = _factory.Call(spanTemp, spanSliceMethod.AsMember((NamedTypeSymbol)spanTemp.Type!), indexTemp, spreadLength);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (3)

699Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 915var call = (BoundCall)expression;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (10)

1081value = BoundCall.Synthesized(syntax, rewrittenOperand, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, get_Value); 1181BoundCall.Synthesized(syntax, boundTemp, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault), 1224return MakeLiftedUserDefinedConversionConsequence(BoundCall.Synthesized( 1369BoundExpression result = BoundCall.Synthesized( 1379private BoundExpression MakeLiftedUserDefinedConversionConsequence(BoundCall call, TypeSymbol resultType) 1441BoundCall callGetValueOrDefault = BoundCall.Synthesized(syntax, boundTemp, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault); 1446BoundCall userDefinedCall = BoundCall.Synthesized( 1745return BoundCall.Synthesized(syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method, operand);

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)

358var getPinnableCall = getPinnableMethod.IsStatic ?

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (7)

198BoundCall.Synthesized( 445BoundExpression disposeCall = BoundCall.Synthesized(syntax: forEachSyntax, receiverOpt: boundDisposableVar, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method: disposeMethod); 548return BoundCall.Synthesized(syntax, receiver, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, methodArgumentInfo.Method, arguments: ImmutableArray<BoundExpression>.Empty); 717return BoundCall.Synthesized( 726return BoundCall.Synthesized( 1102BoundExpression currentDimensionUpperBound = BoundCall.Synthesized(forEachSyntax, boundArrayVar, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getUpperBoundMethod, dimensionArgument); 1156BoundExpression currentDimensionLowerBound = BoundCall.Synthesized(forEachSyntax, boundArrayVar, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getLowerBoundMethod, dimensionArgument);

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (3)

772Debug.Assert(node.IndexerOrSliceAccess is BoundCall); 986var 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)

103var tmp = _factory.StoreToTemp(BoundCall.Synthesized(leftOperand.Syntax, lhsRead, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, getValueOrDefault), 126var 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 (1)

345var createInstanceCall = new BoundCall(

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

417else if (rewrittenArrayAccess is BoundCall getSubArrayCall)

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (1)

97return BoundCall.Synthesized(

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (15)

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)

164var call = factory.Call( 179var call = factory.Call( 193var call = factory.Call(

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (9)

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)

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

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (1)

657var siteInvocation = _factory.Call(

Lowering\MethodToClassRewriter.cs (1)

229public override BoundNode VisitCall(BoundCall node)

Lowering\SpillSequenceSpiller.cs (4)

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

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

615var call = (BoundCall)expr;

Lowering\SyntheticBoundNodeFactory.cs (8)

824public BoundCall Call(BoundExpression? receiver, MethodSymbol method) 829public BoundCall Call(BoundExpression? receiver, MethodSymbol method, BoundExpression arg0, bool useStrictArgumentRefKinds = false) 834public BoundCall Call(BoundExpression? receiver, MethodSymbol method, BoundExpression arg0, BoundExpression arg1, bool useStrictArgumentRefKinds = false) 839public BoundCall Call(BoundExpression? receiver, MethodSymbol method, params BoundExpression[] args) 844public BoundCall Call(BoundExpression? receiver, WellKnownMember method, BoundExpression arg0) 847public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<BoundExpression> args, bool useStrictArgumentRefKinds = false) 884public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<RefKind> refKinds, ImmutableArray<BoundExpression> args) 1796return BoundCall.Synthesized(

Operations\CSharpOperationFactory.cs (4)

42return CreateBoundCallOperation((BoundCall)boundNode); 440private IOperation CreateBoundCallOperation(BoundCall boundCall) 2313case BoundCall call: 2450BoundCall { Method.Name: var name } => name,

Operations\CSharpOperationFactory_Methods.cs (2)

234var boundCall = (BoundCall)containingExpression;

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

735static BoundCall makeEqualityComparerDefaultEquals(

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

65var 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)

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

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (4)

291private static BoundCall CreateParameterlessCall(CSharpSyntaxNode syntax, BoundExpression receiver, ThreeState receiverIsSubjectToCloning, MethodSymbol method) 356BoundCall userMainInvocation = new BoundCall( 490var initializeCall = CreateParameterlessCall(syntax, scriptLocal, receiverIsSubjectToCloning: ThreeState.False, initializer); 605var initializeResult = CreateParameterlessCall(

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)

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