Method

Binder\Binder.ValueChecks.cs (16)

877return CheckMethodReturnValueKind(call.Method, call.Syntax, node, valueKind, checkingReceiver, diagnostics); 895return CheckMethodReturnValueKind(sliceAccess.Method, sliceAccess.Syntax, node, valueKind, checkingReceiver, diagnostics); 3530var methodSymbol = call.Method; 3537MethodInfo.Create(call.Method), 3613var methodSymbol = call.Method; 3620MethodInfo.Create(call.Method), 3854var methodSymbol = call.Method; 3937var methodSymbol = call.Method; 4259MethodInfo.Create(call.Method), 4262call.Method.Parameters, 4329MethodInfo.Create(call.Method), 4332call.Method.Parameters, 5007var methodSymbol = call.Method; 5095var methodSymbol = call.Method; 5838if (part is not BoundCall { Method.Name: BoundInterpolatedString.AppendFormattedMethod } call) 5852call.Method.Parameters[0].EffectiveScope == ScopedKind.ScopedValue)

Binder\Binder_Await.cs (4)

95if ((object)call.Method != null && call.Method.IsAsync) 348var getAwaiterMethod = call.Method; 456getResultMethod = call.Method;

Binder\Binder_Conversions.cs (1)

1670Debug.Assert(call.Method.Name == "Add");

Binder\Binder_Deconstruct.cs (1)

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

Binder\Binder_Expressions.cs (1)

6535boundCall.Method,

Binder\Binder_InterpolatedString.cs (1)

983if (call is BoundCall { Method: { ReturnType: var returnType } method })

Binder\Binder_Invocation.cs (5)

1062if (!call.HasAnyErrors && call.ReceiverOpt != null && (object)call.ReceiverOpt.Type != null && !call.Method.GetIsNewExtensionMember()) 1067if (call.ReceiverOpt.Type.IsRestrictedType() && !call.Method.ContainingType.IsInterface && !TypeSymbol.Equals(call.Method.ContainingType, call.ReceiverOpt.Type, TypeCompareKind.ConsiderEverything2)) 1069SymbolDistinguisher distinguisher = new SymbolDistinguisher(compilation, call.ReceiverOpt.Type, call.Method.ContainingType); 1075SymbolDistinguisher distinguisher = new SymbolDistinguisher(compilation, this.ContainingType, call.Method.ContainingType);

Binder\Binder_Query.cs (4)

328result.ReceiverOpt, result.InitialBindingReceiverIsSubjectToCloning, result.Method, arguments.ToImmutableAndFree(), argumentNamesOpt: default, 472invocation = invocation.Update(invocation.ReceiverOpt, invocation.InitialBindingReceiverIsSubjectToCloning, invocation.Method, arguments); 541invocation = invocation.Update(invocation.ReceiverOpt, invocation.InitialBindingReceiverIsSubjectToCloning, invocation.Method, arguments); 632invocation.Method,

Binder\Binder_Statements.cs (2)

1722BoundImplicitIndexerAccess { IndexerOrSliceAccess: BoundCall call } => call.Method, 4175var patternMethodSymbol = call.Method;

Binder\RefSafetyAnalysis.cs (2)

722var method = node.Method; 1004var deconstructMethod = invocation.Method;

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

502return call.Method;

BoundTree\BoundExpression.cs (1)

263return this.Method;

BoundTree\BoundExpressionExtensions.cs (1)

34return ((BoundCall)node).Method.RefKind;

BoundTree\BoundNode_Source.cs (1)

221append(call.Method.Name);

BoundTree\BoundNodeExtensions.cs (1)

60MethodSymbol method = call!.Method;

BoundTree\BoundTreeWalker.cs (3)

39if (call != null && (object)call.Method != null) 42if (call.Method.Name == "Select") 46else if (call.Method.Name == "GroupBy")

BoundTree\Constructors.cs (1)

160return this.Update(ReceiverOpt, InitialBindingReceiverIsSubjectToCloning, Method, arguments, ArgumentNamesOpt, ArgumentRefKindsOpt, IsDelegateCall, Expanded, InvokedAsExtensionMethod, ArgsToParamsOpt, DefaultArguments, ResultKind, OriginalMethodsOpt, Type);

CodeGen\CodeGenerator_HasHome.cs (1)

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

CodeGen\CodeGenerator_RefSafety.cs (3)

18returnRefKind: node.Method.RefKind, 19thisParameterSymbol: node.Method.TryGetThisParameter(out var thisParameter) ? thisParameter : null, 20parameters: node.Method.Parameters);

CodeGen\EmitAddress.cs (1)

179var methodRefKind = call.Method.RefKind;

CodeGen\EmitExpression.cs (11)

1620if (call.Method.IsDefaultValueTypeConstructor()) 1624else if (!call.Method.RequiresInstanceReceiver) 1637var method = call.Method; 1657var method = call.Method; 1747var methodRefKind = call.Method.RefKind; 1841var method = call.Method; 1958var method = call.Method; 2089if (call.ReceiverOpt is BoundCall { Method: { RequiresInstanceReceiver: true } method } receiver && !method.IsDefaultValueTypeConstructor()) 2236return ((BoundCall)receiver).Method.RefKind != RefKind.None; 2959Debug.Assert(left.Method.RefKind != RefKind.None); 3161Debug.Assert(((BoundCall)expression).Method.RefKind != RefKind.None);

CodeGen\Optimizer.cs (6)

1066Debug.Assert(((BoundCall)lhs).Method.RefKind == RefKind.Ref, "only ref returning methods are assignable"); 1166MethodSymbol method = node.Method; 1197var rewrittenArguments = VisitArguments(node.Arguments, node.Method.Parameters, node.ArgumentRefKindsOpt); 1198return node.Update(receiver, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, node.Method, rewrittenArguments); 2264if (node.Method.RequiresInstanceReceiver) 2290return node.Update(receiverOpt, node.InitialBindingReceiverIsSubjectToCloning, node.Method, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.IsDelegateCall, node.Expanded, node.InvokedAsExtensionMethod, node.ArgsToParamsOpt, node.DefaultArguments, node.ResultKind, node.OriginalMethodsOpt, type);

Compilation\CSharpSemanticModel.cs (3)

3453if ((object)call.Method != null) 4278if (invocation != null && invocation.Expression.SkipParens() == ((ExpressionSyntax)boundNode.Syntax).SkipParens() && (object)call.Method != null) 4790var method = call.Method;

Compiler\MethodCompiler.cs (4)

1977expressionStatement.Expression is BoundCall { Method: var initMethod } && initMethod.IsDefaultValueTypeConstructor(); 2470if (ctorCall != null && !ctorCall.HasAnyErrors && ctorCall.Method != method && TypeSymbol.Equals(ctorCall.Method.ContainingType, method.ContainingType, TypeCompareKind.ConsiderEverything2)) 2473compilationState.ReportCtorInitializerCycles(method, ctorCall.Method, ctorCall.Syntax, diagnostics);

FlowAnalysis\AbstractFlowPass.cs (6)

1335bool callsAreOmitted = node.Method.CallsAreOmitted(node.SyntaxTree); 1357VisitReceiverBeforeCall(node.ReceiverOpt, node.Method); 1369VisitReceiverBeforeCall(node.ReceiverOpt, node.Method); 1384if (node.Method?.OriginalDefinition is LocalFunctionSymbol localFunc) 1389VisitArgumentsAfterCall(node.Arguments, node.ArgumentRefKindsOpt, node.Method, node.ArgsToParamsOpt, node.Expanded); 1390VisitReceiverAfterCall(node.ReceiverOpt, node.Method);

FlowAnalysis\NullableWalker.cs (12)

1555return constructorBody is BoundConstructorMethodBody { Initializer: BoundExpressionStatement { Expression: BoundCall { Method: { MethodKind: MethodKind.Constructor } initializerMethod } } } 6491bool isNewExtensionMethod = node.Method.GetIsNewExtensionMember(); 6498CheckCallReceiver(receiver, receiverType, node.Method); 6506var refKind = isNewExtensionMethod ? GetExtensionReceiverRefKind(node.Method) : GetRefKind(node.ArgumentRefKindsOpt, 0); 6511Debug.Assert(node.Method.ContainingType.ExtensionParameter is not null); 6512annotations = node.Method.ContainingType.ExtensionParameter.FlowAnalysisAnnotations; 6517annotations = GetCorrespondingParameter(0, node.Method.Parameters, node.ArgsToParamsOpt, node.Expanded, ref paramsIterationType).Annotations; 6561return VisitAndCheckReceiver(node.ReceiverOpt, node.Method); 6570node.Method, 6589SetUpdatedSymbol(node, node.Method, method); 7364if (node is BoundCall { Method: { OriginalDefinition: LocalFunctionSymbol localFunction } }) 10690var deconstructMethod = invocation?.Method;

FlowAnalysis\NullableWalker_Patterns.cs (1)

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

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

6178if (receiverOpt != this.ReceiverOpt || initialBindingReceiverIsSubjectToCloning != this.InitialBindingReceiverIsSubjectToCloning || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(method, this.Method) || arguments != this.Arguments || argumentNamesOpt != this.ArgumentNamesOpt || argumentRefKindsOpt != this.ArgumentRefKindsOpt || isDelegateCall != this.IsDelegateCall || expanded != this.Expanded || invokedAsExtensionMethod != this.InvokedAsExtensionMethod || argsToParamsOpt != this.ArgsToParamsOpt || defaultArguments != this.DefaultArguments || resultKind != this.ResultKind || originalMethodsOpt != this.OriginalMethodsOpt || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything)) 11877MethodSymbol method = this.VisitMethodSymbol(node.Method); 14091MethodSymbol method = GetUpdatedSymbol(node, node.Method); 16549new TreeDumperNode("method", node.Method, null),

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

460if (node.Method.MethodKind == MethodKind.LocalFunction) 463AddIfCaptured(node.Method.OriginalDefinition, node.Syntax);

Lowering\ClosureConversion\ClosureConversion.cs (2)

1076if (node.Method.MethodKind == MethodKind.LocalFunction) 1086node.Method,

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (1)

646var method = node.Method;

Lowering\DiagnosticsPass_ExpressionTrees.cs (3)

503CheckReferenceToMethodIfLocalFunction(node, node.Method); 514CheckReferenceToMethodIfLocalFunction(node, node.Method); 523VisitCall(node.Method, null, node.Arguments, node.ArgumentRefKindsOpt, node.ArgumentNamesOpt, node.ArgsToParamsOpt, node.DefaultArguments, node);

Lowering\ExtensionMethodReferenceRewriter.cs (5)

77Debug.Assert(node.Method.MethodKind == MethodKind.LocalFunction || node.Method.IsStatic || node.ReceiverOpt is not null); 81VisitMethodSymbolWithExtensionRewrite(rewriter, node.Method), 102Debug.Assert(boundCall.Method.OriginalDefinition.TryGetCorrespondingExtensionImplementationMethod() == (object)method.OriginalDefinition); 103Debug.Assert(!boundCall.Method.IsStatic);

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

551MethodSymbol method = original.Method;

Lowering\LocalRewriter\LocalRewriter.cs (1)

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

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

155node.Method.MethodKind == MethodKind.LocalFunction || 159MethodMayMutateReceiver(node.ReceiverOpt, node.Method);

Lowering\LocalRewriter\LocalRewriter_Call.cs (1)

379MethodSymbol method = node.Method;

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (2)

794Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 1011var method = call.Method;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (2)

1383if (call.Method.ReturnType.IsValidNullableTypeArgument()) 1385Debug.Assert(resultType.IsNullableType() && TypeSymbol.Equals(resultType.GetNullableUnderlyingType(), call.Method.ReturnType, TypeCompareKind.ConsiderEverything2));

Lowering\LocalRewriter\LocalRewriter_ExpressionStatement.cs (1)

64if (call.Method.CallsAreOmitted(call.SyntaxTree))

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)

199var method = boundCall.Method;

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

384if ((object)call.Method == _concatStringArray && call.Arguments[0] is BoundArrayCreation array) 397if (call is { Arguments: [], ReceiverOpt.Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, Method: { Name: "ToString" } method } 420if ((object)call.Method == concatMethod)

Lowering\MethodToClassRewriter.cs (3)

98var rewrittenMethodSymbol = VisitMethodSymbol(node.Method); 106== node.Method.IsMetadataVirtual(MethodSymbol.IsMetadataVirtualOption.ForceCompleteIfNeeded)); 111if (BaseReferenceInReceiverWasRewritten(node.ReceiverOpt, rewrittenReceiver) && node.Method.IsMetadataVirtual())

Lowering\SpillSequenceSpiller.cs (12)

439if (call.Method.OriginalDefinition is SynthesizedInlineArrayFirstElementRefMethod or SynthesizedInlineArrayFirstElementRefReadOnlyMethod) 444else if (call.Method.OriginalDefinition is SynthesizedInlineArrayElementRefMethod or SynthesizedInlineArrayElementRefReadOnlyMethod) 448else if (call.Method.OriginalDefinition == _F.Compilation.GetWellKnownTypeMember(WellKnownMember.System_Span_T__get_Item) || 449call.Method.OriginalDefinition == _F.Compilation.GetWellKnownTypeMember(WellKnownMember.System_ReadOnlySpan_T__get_Item)) 454call.Method, 458else if (call.Method.OriginalDefinition is SynthesizedInlineArrayAsSpanMethod or SynthesizedInlineArrayAsReadOnlySpanMethod) 462else if (call.Method.OriginalDefinition == _F.Compilation.GetWellKnownTypeMember(WellKnownMember.System_Span_T__Slice_Int_Int) || 463call.Method.OriginalDefinition == _F.Compilation.GetWellKnownTypeMember(WellKnownMember.System_ReadOnlySpan_T__Slice_Int_Int)) 468call.Method, 471else if (call.Method == _F.Compilation.GetSpecialTypeMember(SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)) 1026else if (node.Method.RequiresInstanceReceiver) 1068return UpdateExpression(builder, node.Update(receiver, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, node.Method, arguments));

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

649Debug.Assert(call.Method.RefKind != RefKind.None); 650F.Diagnostics.Add(ErrorCode.ERR_RefReturningCallAndAwait, F.Syntax.Location, call.Method);

Operations\CSharpOperationFactory.cs (2)

442MethodSymbol targetMethod = boundCall.Method; 2450BoundCall { Method.Name: var name } => name,

Operations\CSharpOperationFactory_Methods.cs (1)

235return DeriveArguments(boundCall.Method,