Parameters

Binder\Binder.ValueChecks.cs (24)

Binder\Binder_Attributes.cs (4)

238attributeConstructor.Parameters, 250if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter)) 300ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 710ImmutableArray<ParameterSymbol> parameters = attributeConstructor.Parameters;

Binder\Binder_Await.cs (1)

483var parameter = method.Parameters[method.ParameterCount - 1];

Binder\Binder_Conversions.cs (11)

580method.Parameters[0].Type is ArrayTypeSymbol { IsSZArray: true, ElementType: TypeParameterSymbol }); 590static (readonlySpanType, method) => method.Parameters[0].Type.IsSpan() && 636Parameters: [{ } parameter], 669Parameters: [{ Type.SpecialType: SpecialType.System_String }] 1061var parameterType = (NamedTypeSymbol)collectionBuilderMethod.Parameters[0].Type; 1538var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1888if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 1906var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2837var delegateOrFuncPtrParameters = delegateOrFuncPtrMethod.Parameters; 2838var methodParameters = method.Parameters; 2987return method.Parameters[0];

Binder\Binder_Crefs.cs (1)

567foreach (var param in signature.Parameters)

Binder\Binder_Deconstruct.cs (1)

685var parameters = deconstructMethod.Parameters;

Binder\Binder_Expressions.cs (6)

5039var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5060BindDefaultArguments(nonNullSyntax, resultMember.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParamsOpt, out var defaultArguments, expanded, enableCallerInfo, diagnostics); 6819BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 10515original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10516original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 11180var parameters = methodSymbol.Parameters;

Binder\Binder_Invocation.cs (4)

941argumentSyntax, singleCandidate.Parameters.Last().Name, singleCandidate.Name); 1240BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 1253ParameterSymbol receiverParameter = method.Parameters.First(); 2028parameterListList.Add(m.Parameters);

Binder\Binder_Patterns.cs (1)

1074parameter = deconstructMethod.Parameters[parameterIndex];

Binder\BinderFactory.BinderFactoryVisitor.cs (3)

1243return new WithParametersBinder(method.Parameters, nextBinder); 1276parameters = parameters.Add(property.SetMethod.Parameters.Last()); 1291ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

Binder\DecisionDagBuilder.cs (1)

541var element = new BoundDagTemp(syntax, method.Parameters[i + extensionExtra].Type, evaluation, i);

Binder\ExecutableCodeBinder.cs (1)

112: iterator.Parameters;

Binder\ForEachLoopBinder.cs (8)

1031Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.IsExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty)); 1040builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type; 1115if (getEnumeratorMethod?.Parameters[0].IsOptional == false) 1236patternDisposeMethod.Parameters, 1492result.Parameters, 1565var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1578result.Parameters[0].Type); 1972method.Parameters,

Binder\InMethodBinder.cs (3)

206var parameters = _methodSymbol.Parameters; 232foreach (var parameter in _methodSymbol.Parameters) 332var parameters = _methodSymbol.Parameters;

Binder\LocalBinderFactory.cs (4)

312MethodSymbol methodSymbol => methodSymbol.Parameters, 330return method.Parameters; 344return method.Parameters; 358return invokeMethod.Parameters;

Binder\PatternExplainer.cs (2)

543int count = method.Parameters.Length - extensionExtra; 547var elementTemp = new BoundDagTemp(e.Syntax, method.Parameters[j + extensionExtra].Type, e, j);

Binder\RefSafetyAnalysis.cs (5)

609return method.Parameters is [{ } firstParameter, ..] ? firstParameter : null; 689method.Parameters, 790constructor.Parameters, 819constructor.Parameters, 973var parameters = deconstructMethod.Parameters;

Binder\Semantics\Conversions\Conversions.cs (3)

257GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 339thisParameter = method.Parameters[0]; 403GetDelegateOrFunctionPointerArguments(syntax, analyzedArguments, delegateInvokeMethod.Parameters, Compilation);

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

1494var delegateParameters = invokeMethod.Parameters;

Binder\Semantics\OverloadResolution\OverloadResolution.cs (2)

3687if (!IdenticalParameters(invoke1.Parameters, invoke2.Parameters))

Binder\UsingStatementBinder.cs (1)

214disposeMethod.Parameters,

Binder\WithPrimaryConstructorParametersBinder.cs (2)

38foreach (var parameter in _lazyPrimaryCtorWithParameters.Parameters) 83var parameters = _lazyPrimaryCtorWithParameters.Parameters;

BoundTree\BoundDagTest.cs (1)

63foreach (var param in d.DeconstructMethod.Parameters)

BoundTree\UnboundLambda.cs (1)

1130foreach (var p in invoke.Parameters)

CodeGen\EmitConversion.cs (1)

383var parameters = m.Parameters;

CodeGen\EmitExpression.cs (5)

1663EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 1994EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 2449EmitArguments(expression.Arguments, constructor.Parameters, expression.ArgumentRefKindsOpt); 2633if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2707EmitArguments(objCreation.Arguments, constructor.Parameters, objCreation.ArgumentRefKindsOpt);

CodeGen\Optimizer.cs (2)

1188var rewrittenArguments = VisitArguments(node.Arguments, node.Method.Parameters, node.ArgumentRefKindsOpt); 1319var rewrittenArguments = VisitArguments(node.Arguments, constructor.Parameters, node.ArgumentRefKindsOpt);

Compilation\CSharpCompilation.cs (3)

2231if (method.Parameters.Length == 0) 2236if (method.Parameters.Length > 1) 2246var firstType = method.Parameters[0].TypeWithAnnotations;

Compilation\MemberSemanticModel.cs (1)

855return GetParameterSymbol(localFunction.Parameters, parameter, cancellationToken);

Compilation\SyntaxTreeSemanticModel.cs (2)

2095return GetParameterSymbol(method.Parameters, parameter, cancellationToken); 2155return GetParameterSymbol(delegateInvoke.Parameters, parameter, cancellationToken);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

283retExpression = F.StaticCall(manager.System_String, formatMethod, F.Null(formatMethod.Parameters[0].Type), format, F.ArrayOrEmpty(manager.System_Object, arguments));

Compiler\ClsComplianceChecker.cs (5)

256CheckParameterCompliance(symbol.DelegateInvokeMethod.Parameters, symbol); 315CheckForMeaninglessOnParameter(symbol.Parameters); 330CheckParameterCompliance(symbol.Parameters, symbol.ContainingType); 477CheckForMeaninglessOnParameter(method.Parameters); 484CheckForMeaninglessOnParameter(method.Parameters);

Compiler\DocumentationCommentCompiler.cs (1)

617return delegateInvoke.Parameters;

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (2)

563parameters = ((MethodSymbol)memberSymbol).Parameters; 573parameters = typeSymbol.DelegateInvokeMethod.Parameters;

Compiler\MethodBodySynthesizer.cs (4)

92var submissionArrayReference = new BoundParameter(syntax, submissionConstructor.Parameters[0]) { WasCompilerGenerated = true }; 198var parameter = accessor.Parameters[0]; 296accessor.Parameters[0]); 387parameterSymbol: accessor.Parameters[0])

Compiler\MethodBodySynthesizer.Lowered.cs (1)

460foreach (var param in F.CurrentFunction.Parameters)

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (2)

111if (symbol.Parameters.Any() || symbol.IsVararg) 113s_parameterOrReturnTypeInstance.VisitParameters(symbol.Parameters, symbol.IsVararg, builder);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

516invokeMethod.Parameters.SequenceEqual(otherInvokeMethod.Parameters, 603method.Parameters.SequenceEqual(other.Parameters, AreParametersEqual) &&

Emitter\Model\MethodReference.cs (1)

82return moduleBeingBuilt.Translate(UnderlyingMethod.Parameters);

Emitter\Model\MethodSymbolAdapter.cs (3)

201return moduleBeingBuilt.Translate(AdaptedMethodSymbol.Parameters); 207Debug.Assert(AdaptedMethodSymbol.Parameters.All(p => p.IsDefinition)); 210return AdaptedMethodSymbol.Parameters.SelectAsArray<ParameterSymbol, Cci.IParameterDefinition>(p => p.GetCciAdapter());

Emitter\NoPia\EmbeddedTypesManager.cs (1)

148ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))),

FlowAnalysis\AbstractFlowPass.cs (3)

471return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 1557if (method is null || Binder.GetCorrespondingParameter(i, method.Parameters, argsToParamsOpt, expanded)?.RefKind.IsWritableReference() != false) 3025var param = method.Parameters[0];

FlowAnalysis\AbstractFlowPass_LocalFunctions.cs (3)

91if (!localFunc.WasCompilerGenerated) EnterParameters(localFuncSymbol.Parameters); 116LeaveParameters(localFuncSymbol.Parameters, localFunc.Syntax, location); 127LeaveParameters(localFuncSymbol.Parameters,

FlowAnalysis\AbstractRegionDataFlowPass.cs (2)

46MakeSlots(node.Symbol.Parameters); 52MakeSlots(node.Symbol.Parameters);

FlowAnalysis\DefiniteAssignment.cs (4)

1827foreach (var parameter in method.Parameters) 2464if (!node.WasCompilerGenerated) EnterParameters(node.Symbol.Parameters); 2470LeaveParameters(node.Symbol.Parameters, node.Syntax, null); 2479LeaveParameters(node.Symbol.Parameters, pending.Branch.Syntax, null);

FlowAnalysis\NullableWalker.cs (29)

2944var methodParameters = methodSymbol.Parameters; 2945var signatureParameters = (_useDelegateInvokeParameterTypes ? _delegateInvokeMethod! : methodSymbol).Parameters; 3085EnforceNotNullIfNotNull(node.Syntax, this.State, method.Parameters, method.ReturnNotNullIfParameterNotNull, ResultType.State, outputParam: null); 3755return invokeMethod!.Parameters.SequenceEqual(l.Parameters, 4004node, arguments, node.ArgumentRefKindsOpt, constructor?.Parameters ?? default, 4072argumentsCompletion(argumentResults, constructor?.Parameters ?? default, constructor); 4460addMethod.Parameters, 4516node, containingType, visitArgumentsCompletion.Invoke(argumentResults, addMethod.Parameters, addMethod).method, 4995if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 4996(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 5250var parameters = method.Parameters; 6370var annotations = GetCorrespondingParameter(0, node.Method.Parameters, node.ArgsToParamsOpt, node.Expanded, ref paramsIterationType).Annotations; 6436(method, results, returnNotNull) = VisitArguments(node, node.Arguments, refKindsOpt, method!.Parameters, node.ArgsToParamsOpt, node.DefaultArguments, 6514var parameterType = method.Parameters[0].TypeWithAnnotations; 6879return VisitArguments(node, arguments, refKindsOpt, method is null ? default : method.Parameters, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod, method); 6986parametersOpt = method.Parameters; 9028NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 9545var parameter = method.Parameters[0]; 9844method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod); 10001CheckExtensionMethodThisNullability(receiverOpt, Conversion.Identity, method.Parameters[0], receiverType); 10377var parameters = deconstructMethod.Parameters; 10385CheckExtensionMethodThisNullability(right, argConversion, deconstructMethod.Parameters[0], rightResult); 10617targetTypeOfOperandConversion = incrementOperator.Parameters[0].TypeWithAnnotations; 10619parameter = incrementOperator.Parameters[0]; 11078if (enumeratorInfoOpt?.GetEnumeratorInfo is { Method: { IsExtensionMethod: true, Parameters: var parameters } } enumeratorMethodInfo) // Tracked by https://github.com/dotnet/roslyn/issues/76130: Test this code path with new extensions 11444var parameter = method.Parameters[0]; 11571ReportArgumentWarnings(left!, leftType, trueFalseOperator.Parameters[0]); 11576ReportArgumentWarnings(left!, leftType, logicalOperator.Parameters[0]); 11586ReportArgumentWarnings(right, rightType, logicalOperator.Parameters[1]);

FlowAnalysis\NullableWalker_Patterns.cs (1)

451var parameterType = method.Parameters[i + extensionExtra].TypeWithAnnotations;

FlowAnalysis\ReadWriteWalker.cs (1)

85foreach (var p in m.Parameters)

FlowAnalysis\VariablesDeclaredWalker.cs (2)

104foreach (var parameter in node.Symbol.Parameters) 117foreach (var parameter in node.Symbol.Parameters)

Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (15)

Lowering\AsyncRewriter\AsyncRewriter.cs (1)

185new BoundExpression[] { F.Parameter(F.CurrentFunction.Parameters[0]) })),

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

390DeclareLocals(_currentScope, _topLevelMethod.Parameters); 594DeclareLocals(_currentScope, functionSymbol.Parameters, _inExpressionTree);

Lowering\ClosureConversion\ClosureConversion.cs (1)

1549foreach (var parameter in node.Symbol.Parameters)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (7)

702var conversionInputType = method.Parameters[0].Type; 709? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 767unquoted = _bound.Call(_bound.MethodInfo(method, createDelegate.ContainingType), createDelegate, _bound.Typeof(delegateType, createDelegate.Parameters[0].Type), receiver); 774_bound.Typeof(delegateType, createDelegate.Parameters[0].Type), 776_bound.MethodInfo(method, createDelegate.Parameters[2].Type)); 839foreach (var p in node.Symbol.Parameters) 860foreach (var p in node.Symbol.Parameters)

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

210protected override ImmutableArray<ParameterSymbol> BaseMethodParameters => this.BaseMethod.Parameters;

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

617foreach (var p in lambda.Parameters)

Lowering\DiagnosticsPass_Warnings.cs (1)

244if (method.Parameters[i].RefKind != RefKind.None && (argumentRefKindsOpt.IsDefault || argumentRefKindsOpt[i] == RefKind.None)) return true;

Lowering\ExtensionMethodBodyRewriter.cs (2)

55Debug.Assert(symbol.Parameters.Length == rewrittenParameters.Length); 60foreach (var parameter in symbol.Parameters)

Lowering\ExtensionMethodReferenceRewriter.cs (2)

102var receiverRefKind = method.Parameters[0].RefKind; 120Debug.Assert(receiverOpt.Type!.Equals(method.Parameters[0].Type, TypeCompareKind.ConsiderEverything));

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (5)

305foreach (var parameter in _factory.CurrentFunction.Parameters) 316MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)parameter.Ordinal))))); 405MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, assignment, refAssignmentSourceIndex, targetIndex)) 535MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex))); 598MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex)));

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (4)

186member is MethodSymbol { Parameters: [.., { RefKind: RefKind.None, Type: { } lastParamType }] parametersWithCancellationToken } overload && 189methodDefinition.Parameters.Length == parametersWithCancellationToken.Length - 1 && 196methodDefinition.Parameters.AsSpan(), 198parametersWithCancellationToken.AsSpan(0, methodDefinition.Parameters.Length),

Lowering\IteratorRewriter\IteratorRewriter.cs (1)

282bodyBuilder.Add(F.Assignment(F.Field(F.This(), stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state;

Lowering\LocalRewriter\LocalRewriter.cs (3)

334delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 337if (node.Symbol.Parameters.LastOrDefault(static (p) => p.IsParamsCollection) is { } parameter) 1128symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

187ParameterSymbol parameter = method.Parameters[i]; 243Debug.Assert(e.Property.GetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Int32);

Lowering\LocalRewriter\LocalRewriter_Call.cs (3)

251this._diagnostics.Add(ErrorCode.ERR_InterceptorMustHaveMatchingThisParameter, attributeLocation, method.Parameters[0], method); 306argumentRefKindsOpt = method.Parameters.SelectAsArray(static param => param.RefKind); 1246return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

226ConversionsBase.HasIdentityConversion(builder.Parameters[0].Type, spreadType) && 227(!builder.ReturnType.IsRefLikeType || builder.Parameters[0].EffectiveScope == ScopedKind.ScopedValue)) 328Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions)); 480var spanType = (NamedTypeSymbol)constructMethod.Parameters[0].Type;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

744delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 1760Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1866Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked);

Lowering\LocalRewriter\LocalRewriter_Event.cs (3)

310BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType, ctor.Parameters[0].Type), _factory.Literal(node.Event.MetadataName)); 312_factory.Convert(addRemove.Parameters[0].Type, rewrittenReceiver), 313_factory.Convert(addRemove.Parameters[1].Type, rewrittenArgument));

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (2)

243MethodSymbol createSpan = getCreateSpanHelper(node, spanType: getItemOrSliceHelper.ContainingType, intType: (NamedTypeSymbol)getItemOrSliceHelper.Parameters[0].Type); 273possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (3)

184Debug.Assert(addMethod.Parameters 203if (initializer.InvokedAsExtensionMethod && addMethod.Parameters[0].RefKind == RefKind.Ref) 208var builder = ArrayBuilder<RefKind>.GetInstance(addMethod.Parameters.Length, RefKind.None);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

443readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out) 481Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out); 488argumentRefKindsOpt: [readOnlySpanCtorRefParamChar.Parameters[0].RefKind == RefKind.Ref ? RefKind.Ref : RefKindExtensions.StrictIn],

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (2)

500Debug.Assert(method.Parameters.AsSpan()[1..].All(static (p) => (p.IsOptional || p.IsParams) && p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 504Debug.Assert(method.Parameters.All(p => p.IsOptional || p.IsParams));

Lowering\StateMachineRewriter\StateMachineRewriter.cs (2)

327foreach (var parameter in method.Parameters) 485foreach (var parameter in method.Parameters)

Lowering\SynthesizedMethodBaseSymbol.cs (1)

110get { return this.BaseMethod.Parameters; }

Lowering\SyntheticBoundNodeFactory.cs (2)

1514if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1516arg = Convert(conversion.Method.Parameters[0].Type, arg);

Symbols\Attributes\SourceAttributeData.cs (3)

152Debug.Assert(this.AttributeConstructor.Parameters[parameterIndex].IsOptional || 153this.AttributeConstructor.Parameters[parameterIndex].IsParamsArray); 242ImmutableArray<ParameterSymbol> parameters = ctor.Parameters;

Symbols\Compilation_WellKnownMembers.cs (1)

1133return method.Parameters;

Symbols\Extensions\RewrittenLambdaOrLocalFunctionSymbol.cs (1)

35return ImmutableArray<ParameterSymbol>.CastUp(_originalMethod.Parameters.SelectAsArray(static (p, @this) => new RewrittenMethodParameterSymbol(@this, p), this));

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (1)

88var sourceParameters = _originalMethod.Parameters;

Symbols\MemberSymbolExtensions.cs (3)

39return ((MethodSymbol)member).Parameters; 380foreach (ParameterSymbol param in method.Parameters) 788return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

Symbols\Metadata\PE\MemberRefMetadataDecoder.cs (1)

238if (!ParametersMatch(candidateMethod.Parameters[i], candidateMethodTypeMap, ref targetParamInfo[i + 1 /*for return type*/]))

Symbols\Metadata\PE\PENamedTypeSymbol.cs (4)

419return new ReceiverParameterSymbol(@this, methodSymbol.Parameters[0]); 503candidate.Parameters[0], 515candidate.Parameters.AsSpan(additionalParameterCount, candidate.ParameterCount - additionalParameterCount), 517method.Parameters.AsSpan(),

Symbols\MethodSymbol.cs (6)

314return this.Parameters.Length; 902ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 915ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 961DeriveUseSiteInfoFromParameters(ref result, this.Parameters)) 975GetUnificationUseSiteDiagnosticRecursive(ref diagnosticInfo, this.Parameters, this, ref unificationCheckedTypes) || 1232ImmutableArray<IParameterSymbolInternal> IMethodSymbolInternal.Parameters => Parameters.Cast<ParameterSymbol, IParameterSymbolInternal>();

Symbols\MethodSymbolExtensions.cs (1)

18return method.ParameterCount != 0 && method.Parameters[method.ParameterCount - 1].IsParams;

Symbols\NamedTypeSymbol.cs (1)

356var thisParam = method.Parameters.First();

Symbols\NativeIntegerTypeSymbol.cs (1)

363var parameters = UnderlyingMethod.Parameters.SelectAsArray((p, m) => (ParameterSymbol)new NativeIntegerParameterSymbol(m._container, m, p), this);

Symbols\ReducedExtensionMethodSymbol.cs (5)

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 250return _reducedFrom.Parameters[0].Type; 255_reducedFrom.Parameters[0].TypeWithAnnotations.ToPublicAnnotation(); 539internal override bool IsEffectivelyReadOnly => _reducedFrom.Parameters[0].RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 558var reducedFromParameters = _reducedFrom.Parameters;

Symbols\Retargeting\RetargetingMethodSymbol.cs (1)

166var list = _underlyingMethod.Parameters;

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

1002var targetParams = method.Parameters.SelectAsArray(

Symbols\Source\CustomModifierUtils.cs (2)

45parameters = CopyParameterCustomModifiers(constructedSourceMethod.Parameters, destinationMethod.Parameters, alsoCopyParamsModifier);

Symbols\Source\SourceMemberContainerSymbol.cs (2)

2199var refKind1 = method1.Parameters[i].RefKind; 2200var refKind2 = method2.Parameters[i].RefKind;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (7)

1259var baseParameters = baseMethod.Parameters; 1260var overrideParameters = overrideMethod.Parameters; 1384var parameters = method.Parameters; 1462var baseParameters = baseMethod.Parameters; 1463var overrideParameters = overrideMethod.Parameters; 1513var baseParameters = baseMethod.Parameters; 1514var overrideParameters = overrideMethod.Parameters;

Symbols\Source\SourceMemberMethodSymbol.cs (2)

925foreach (var parameter in this.Parameters) 1023foreach (var parameter in Parameters)

Symbols\Source\SourceMethodSymbol.cs (1)

66var parameters = !this.IsStatic ? this.GetParametersIncludingExtensionParameter() : Parameters;

Symbols\Source\SourceMethodSymbolWithAttributes.cs (3)

767foreach (var param in this.Parameters) 1400foreach (var param in Parameters) 1588var enumeratorCancellationCount = Parameters.Count(p => p.HasEnumeratorCancellationAttribute);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

64if (_lazyExtensionInfo.LazyExtensionParameter == null && markerMethod is { Parameters: [var parameter, ..] })

Symbols\SubstitutedMethodSymbol.cs (2)

169return reduced.Parameters[0].Type; 334var unsubstitutedParameters = OriginalDefinition.Parameters;

Symbols\SymbolExtensions.cs (1)

440if (property.GetOwnOrInheritedSetMethod()?.Parameters.Last().FlowAnalysisAnnotations is { } setterAnnotations)

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

560var parameterReference = f.Parameter(method.Parameters[0]); 596var parameterReference0 = f.Parameter(method.Parameters[0]); 597var parameterReference1 = f.Parameter(method.Parameters[1]); 653var parameterReference = f.Parameter(method.Parameters[0]); 687var parameterReference = f.Parameter(method.Parameters[0]);

Symbols\Synthesized\Records\SynthesizedRecordClone.cs (2)

124if (ctor.ParameterCount == 1 && ctor.Parameters[0].RefKind == RefKind.None && 125ctor.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

Symbols\Synthesized\Records\SynthesizedRecordCopyCtor.cs (2)

147method.Parameters[0].Type.Equals(containingType, TypeCompareKind.AllIgnoreOptions) && 148method.Parameters[0].RefKind == RefKind.None;

Symbols\Synthesized\Records\SynthesizedRecordEqualityOperator.cs (2)

45if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None && 47candidate.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

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

126F.Convert(baseEquals.Parameters[0].Type, other));

Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)

300return sourceMethod.Parameters.SelectAsArray(

Symbols\TypeSymbol.cs (1)

1615interfaceMethod.Parameters,

Symbols\TypeSymbolExtensions.cs (3)

580return invokeMethod.Parameters; 980(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(currentPointer.Parameters[i].TypeWithAnnotations, canDigThroughNullable); 997next = currentPointer.Parameters[i].TypeWithAnnotations;

Symbols\VarianceSafety.cs (1)

169CheckParametersVarianceSafety(method.Parameters, method, diagnostics);