Parameters

Binder\Binder.ValueChecks.cs (12)

137Parameters = call.Method.Parameters, 150Parameters = method.Parameters, 196Parameters = objectCreation.Constructor.Parameters, 212Parameters = unaryOperator.MethodOpt.Parameters, 229Parameters = binaryOperatorMethod.Parameters, 243Parameters = logicalOperator.LogicalOperator.Parameters, 256Parameters = operatorMethod.Parameters, 284Parameters = incrementOperator.MethodOpt.Parameters, 301Parameters = method.Parameters, 335Parameters = colElement.AddMethod.Parameters, 661var parameters = accessorForDefaultArguments.Parameters; 4981Parameters = methodInfo.Method.Parameters,

Binder\Binder_Attributes.cs (4)

239attributeConstructor.Parameters, 252if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter)) 302ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 718ImmutableArray<ParameterSymbol> parameters = attributeConstructor.Parameters;

Binder\Binder_Await.cs (3)

374BoundExpression argument = CreateConversion(placeholder, argumentConversion, destination: method.Parameters[0].Type, diagnostics); 474method.Parameters[0].Type, 754var parameter = method.Parameters[method.ParameterCount - 1];

Binder\Binder_Conversions.cs (17)

657method.Parameters[0].Type is ArrayTypeSymbol { IsSZArray: true, ElementType: TypeParameterSymbol }); 667static (readonlySpanType, method) => method.Parameters[0].Type.IsSpan() && 713Parameters: [{ } parameter], 746Parameters: [{ Type.SpecialType: SpecialType.System_String }] 1435var readonlySpanParameter = collectionBuilderMethod.Parameters.Last(); 1568if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 1579if (method.Parameters is [.., { IsParams: true }, _]) 1596parameterType = (NamedTypeSymbol)methodWithTargetTypeParameters.Parameters.Last().Type; 1636var parameterType = (NamedTypeSymbol)collectionBuilderMethod.Parameters.Last().Type; 2092bool thisTypeIsOpen = typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0]); 2105if (!typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[1])) 2127TypeSymbol secondArgumentType = (constructed ?? member).Parameters[1].Type; 2154var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 2161else if (typeParameters.Any((typeParameter, parameter) => !parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0])) 3540var delegateOrFuncPtrParameters = delegateOrFuncPtrMethod.Parameters; 3541var methodParameters = method.Parameters; 3690return method.Parameters[0];

Binder\Binder_Crefs.cs (1)

766foreach (var param in signature.Parameters)

Binder\Binder_Deconstruct.cs (1)

687var parameters = deconstructMethod.Parameters;

Binder\Binder_Expressions.cs (6)

5132var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5154BindDefaultArguments(nonNullSyntax, resultMember.Parameters, extensionReceiver: null, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParamsOpt, out var defaultArguments, expanded, enableCallerInfo, diagnostics); 6978BindDefaultArguments(node, method.Parameters, extensionReceiver: null, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics: diagnostics); 10807original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10808original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 11511var parameters = methodSymbol.Parameters;

Binder\Binder_Invocation.cs (3)

965argumentSyntax, singleCandidate.Parameters.Last().Name, singleCandidate.Name); 1256BindDefaultArguments(node, method.Parameters, extensionReceiver, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 1269ParameterSymbol receiverParameter = method.Parameters.First();

Binder\Binder_Operators.cs (4)

476BoundExpression rightConverted = CreateConversion(right, overloadResolutionResult.ValidResult.Result.ConversionForArg(isExtension ? 1 : 0), method.Parameters[0].Type, diagnostics); 515rightType: method.Parameters[0].Type, 1649TypeSymbol parameterType = userDefinedOperator.Parameters[0].Type; 3861(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In);

Binder\Binder_Patterns.cs (5)

290Conversion conversion = conversions.ClassifyBuiltInConversion(type, candidate.Parameters[0].Type, isChecked: false, ref discardedUseSiteInfo); 325typeSet.Contains(declaredMethod.Parameters[0].Type); 370Parameters: [{ RefKind: RefKind.Out }], 433method.Parameters[0].Type); 1695parameter = deconstructMethod.Parameters[parameterIndex];

Binder\BinderFactory.BinderFactoryVisitor.cs (3)

1258return new WithParametersBinder(method.Parameters, nextBinder); 1307parameters = parameters.Add(property.SetMethod.Parameters.Last()); 1324ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

Binder\DecisionDagBuilder.cs (1)

674targetType = deconstructMethod.Parameters[0].Type;

Binder\ForEachLoopBinder.cs (8)

1034Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.IsExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty)); 1043builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type; 1113if (getEnumeratorMethod?.Parameters[0].IsOptional == false) 1225patternDisposeMethod.Parameters, 1488result.Parameters, 1562var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1577result.Parameters[0].Type); 1976method.Parameters,

Binder\InMethodBinder.cs (3)

207var parameters = _methodSymbol.Parameters; 233foreach (var parameter in _methodSymbol.Parameters) 333var parameters = _methodSymbol.Parameters;

Binder\LocalBinderFactory.cs (4)

311MethodSymbol methodSymbol => methodSymbol.Parameters, 329return method.Parameters; 343return method.Parameters; 357return invokeMethod.Parameters;

Binder\PatternExplainer.cs (1)

659int count = method.Parameters.Length - extensionExtra;

Binder\RefSafetyAnalysis.cs (1)

688return method.Parameters is [{ } firstParameter, ..] ? firstParameter : null;

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

270GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 352thisParameter = method.Parameters[0]; 416GetDelegateOrFunctionPointerArguments(syntax, analyzedArguments, delegateInvokeMethod.Parameters, Compilation);

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

1509var delegateParameters = invokeMethod.Parameters;

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (1)

1609return SourceUserDefinedOperatorSymbolBase.ExtensionOperatorParameterTypeMatchesExtendedType(method.Parameters[paramIndex].Type, extensionParameter.Type);

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (1)

295foreach (var parameter in op.OriginalDefinition.AsMember(Normalize(extension)).Parameters)

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

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

Binder\UsingStatementBinder.cs (1)

217disposeMethod.Parameters,

Binder\WithPrimaryConstructorParametersBinder.cs (2)

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

BoundTree\BoundDagEvaluation.cs (2)

326ParameterSymbol parameter = method.Parameters[i + extensionExtra]; 338ParameterSymbol parameter = method.Parameters[extensionExtra];

BoundTree\BoundDagTest.cs (1)

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

BoundTree\UnboundLambda.cs (1)

1174foreach (var p in invoke.Parameters)

CodeGen\CodeGenerator_RefSafety.cs (2)

20parameters: node.Method.Parameters); 31parameters: node.Constructor.Parameters);

CodeGen\EmitConversion.cs (1)

414var parameters = m.Parameters;

CodeGen\EmitExpression.cs (5)

1676EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 2025EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 2490EmitArguments(expression.Arguments, constructor.Parameters, expression.ArgumentRefKindsOpt); 2676if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2753EmitArguments(objCreation.Arguments, constructor.Parameters, objCreation.ArgumentRefKindsOpt);

CodeGen\Optimizer.cs (2)

1197var rewrittenArguments = VisitArguments(node.Arguments, node.Method.Parameters, node.ArgumentRefKindsOpt); 1328var rewrittenArguments = VisitArguments(node.Arguments, constructor.Parameters, node.ArgumentRefKindsOpt);

Compilation\CSharpCompilation.cs (3)

2334if (method.Parameters.Length == 0) 2339if (method.Parameters.Length > 1) 2349var firstType = method.Parameters[0].TypeWithAnnotations;

Compilation\MemberSemanticModel.cs (1)

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

Compilation\SyntaxTreeSemanticModel.cs (2)

2093return GetParameterSymbol(method.Parameters, parameter, cancellationToken); 2153return GetParameterSymbol(delegateInvoke.Parameters, parameter, cancellationToken);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

287retExpression = 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)

761return 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 }; 200var parameter = accessor.Parameters[0]; 298accessor.Parameters[0]); 389parameterSymbol: accessor.Parameters[0])

Compiler\MethodBodySynthesizer.Lowered.cs (1)

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

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (2)

110if (symbol.Parameters.Any() || symbol.IsVararg) 112s_parameterOrReturnTypeInstance.VisitParameters(symbol.Parameters, symbol.IsVararg, builder);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

530invokeMethod.Parameters.SequenceEqual(otherInvokeMethod.Parameters, 617method.Parameters.SequenceEqual(other.Parameters, AreParametersEqual) &&

Emitter\Model\MethodReference.cs (1)

82return moduleBeingBuilt.Translate(UnderlyingMethod.Parameters);

Emitter\Model\MethodSymbolAdapter.cs (3)

211return moduleBeingBuilt.Translate(AdaptedMethodSymbol.Parameters); 217Debug.Assert(AdaptedMethodSymbol.Parameters.All(p => p.IsDefinition)); 220return AdaptedMethodSymbol.Parameters.SelectAsArray<ParameterSymbol, Cci.IParameterDefinition>(p => p.GetCciAdapter());

Emitter\NoPia\EmbeddedMethod.cs (1)

43return EmbeddedTypesManager.EmbedParameters(this, UnderlyingMethod.AdaptedMethodSymbol.Parameters);

Emitter\NoPia\EmbeddedTypesManager.cs (1)

189ImmutableArray.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; 1558if (method is null || Binder.GetCorrespondingParameter(i, method.Parameters, argsToParamsOpt, expanded)?.RefKind.IsWritableReference() != false) 3047var 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)

1765foreach (var parameter in method.Parameters) 2394if (!node.WasCompilerGenerated) EnterParameters(node.Symbol.Parameters); 2400LeaveParameters(node.Symbol.Parameters, node.Syntax, null); 2409LeaveParameters(node.Symbol.Parameters, pending.Branch.Syntax, null);

FlowAnalysis\NullableWalker.cs (33)

2078var parameter = factory.Parameters[0]; 3028var methodParameters = methodSymbol.Parameters; 3029var signatureParameters = (_useDelegateInvokeParameterTypes ? _delegateInvokeMethod! : methodSymbol).Parameters; 3864return invokeMethod!.Parameters.SequenceEqual(l.Parameters, 3998objectCreation.Constructor.Parameters, 4012reinferenceResult.Completion(reinferenceResult.Results, constructor.Parameters, constructor); 4036call.Method.Parameters, 4067reinferenceResult.Completion(reinferenceResult.Results, constructed.Parameters, constructed); 4127var reinferredParameter = reinferredAddMethod.Parameters[argIndex]; 4299node, receiverType: null, arguments, node.ArgumentRefKindsOpt, constructor?.Parameters ?? default, 4370argumentsCompletion(argumentResults, constructor?.Parameters ?? default, constructor); 4861addMethod.Parameters, 4921node, containingType, visitArgumentsCompletion.Invoke(argumentResults, addMethod.Parameters, addMethod).member, 5400if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5401(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 5654var parameters = method.Parameters; 6865annotations = GetCorrespondingParameter(0, node.Method.Parameters, node.ArgsToParamsOpt, node.Expanded, ref paramsIterationType).Annotations; 7008ImmutableArray<ParameterSymbol> parameters = AdjustParametersIfNeeded(method.Parameters, adjustForExtensionBlockMember, method); 7165var parameterType = method.Parameters[0].TypeWithAnnotations; 7530var reinferenceResult = VisitArgumentsCore(node, receiverType, arguments, refKindsOpt, method is null ? default : method.Parameters, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod, method, delayCompletionForTargetMember: false); 9896NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 10478var parameter = method.Parameters[0]; 10563var returnNotNull = operandState.IsNotNull() && method.ReturnNotNullIfParameterNotNull.Contains(method.Parameters[0].Name); 10644var parameter = factory.Parameters[0]; 10947method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod); 11110ParameterSymbol? receiverParameter = isExtensionBlockMethod ? method.ContainingType.ExtensionParameter : method.Parameters[0]; 11489var parameters = deconstructMethod.Parameters; 11497var receiverParameter = isExtensionBlockMethod ? deconstructMethod.ContainingType.ExtensionParameter : deconstructMethod.Parameters[0]; 11819targetTypeOfOperandConversion = incrementOperator.Parameters[0].TypeWithAnnotations; 11827parameter = incrementOperator.Parameters[0]; 12780var parameter = method.Parameters[0]; 13002var parameters = logicalOperator.Parameters; 13013var trueFalseParameter = trueFalseOperator.Parameters[0];

FlowAnalysis\NullableWalker_Patterns.cs (1)

700var parameterType = method.Parameters[output.Index + extensionExtra].TypeWithAnnotations;

FlowAnalysis\ReadWriteWalker.cs (1)

85foreach (var p in m.Parameters)

FlowAnalysis\VariablesDeclaredWalker.cs (2)

187foreach (var parameter in node.Symbol.Parameters) 200foreach (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)

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

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (7)

712var conversionInputType = method.Parameters[0].Type; 719? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 787unquoted = _bound.Call(_bound.MethodInfo(method, createDelegate.ContainingType), createDelegate, _bound.Typeof(delegateType, createDelegate.Parameters[0].Type), receiver); 794_bound.Typeof(delegateType, createDelegate.Parameters[0].Type), 796_bound.MethodInfo(method, createDelegate.Parameters[2].Type)); 859foreach (var p in node.Symbol.Parameters) 880foreach (var p in node.Symbol.Parameters)

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

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

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

619foreach (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)

56Debug.Assert(symbol.Parameters.Length == rewrittenParameters.Length); 61foreach (var parameter in symbol.Parameters)

Lowering\ExtensionMethodReferenceRewriter.cs (2)

105var receiverRefKind = method.Parameters[0].RefKind; 123Debug.Assert(receiverOpt.Type!.Equals(method.Parameters[0].Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (4)

322MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)ordinal))))); 411MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, assignment, refAssignmentSourceIndex, targetIndex)) 544MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex))); 621MakeStoreLoggerArguments(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)

339delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 342if (node.Symbol.Parameters.LastOrDefault(static (p) => p.IsParamsCollection) is { } parameter) 1143symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

178addArg(method.ParameterRefKinds[0], _localRewriter.ConvertReceiverForExtensionIfNeeded(input, markAsChecked: true, method.Parameters[0])); 262Debug.Assert(e.Property.GetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Int32);

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (1)

770var parameterType = leftTruthOperator.Parameters[0].Type;

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

247ParameterSymbol? interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 267this._diagnostics.Add(ErrorCode.ERR_InterceptorMustHaveMatchingThisParameter, attributeLocation, method.Parameters[0], method); 296Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 297|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 298receiverOpt = MakeConversionNode(receiverOpt, interceptor.Parameters[0].Type, @checked: false, markAsChecked: true); 322argumentRefKindsOpt = method.Parameters.SelectAsArray(static param => param.RefKind); 1331return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (6)

187if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 232CollectionBuilderMethod: { Parameters: [var parameter] } builder, 376assertTypesAreCompatible(_compilation, arrayType, spanConstructor.Parameters[0].Type, isReadOnlySpan); 591var readonlySpanParameter = constructMethod.Parameters.Last(); 787&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 1350if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (5)

719Debug.Assert(method.Parameters[0].Type.IsStringType()); 761delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 1563Debug.Assert(conversion.Method.Parameters[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 1879Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1992Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked);

Lowering\LocalRewriter\LocalRewriter_Event.cs (3)

310TypeSymbol parameters0Type = addRemove.Parameters[0].Type; 316TypeSymbol parameters1Type = addRemove.Parameters[1].Type; 322BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType, ctor.Parameters[0].Type), _factory.Literal(node.Event.MetadataName));

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)

360factory.Call(null, getPinnableMethod, this.ConvertReceiverForExtensionIfNeeded(callReceiver, markAsChecked: true, getPinnableMethod.Parameters[0])) :

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (2)

283MethodSymbol createSpan = getCreateSpanHelper(node, spanType: getItemOrSliceHelper.ContainingType, intType: (NamedTypeSymbol)getItemOrSliceHelper.Parameters[0].Type); 330possiblyRefCapturedReceiver = _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)

490readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out) 528Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out); 535argumentRefKindsOpt: [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)

331foreach (var parameter in method.Parameters) 489foreach (var parameter in method.Parameters)

Lowering\SynthesizedMethodBaseSymbol.cs (1)

111get { return this.BaseMethod.Parameters; }

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)

1175return method.Parameters;

Symbols\Extensions\RewrittenLambdaOrLocalFunctionSymbol.cs (1)

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

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (1)

121var sourceParameters = _originalMethod.Parameters;

Symbols\MemberSymbolExtensions.cs (3)

40return ((MethodSymbol)member).Parameters; 454foreach (ParameterSymbol param in method.Parameters) 862return 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 (3)

539candidate.Parameters[0], 551candidate.Parameters.AsSpan(additionalParameterCount, candidate.ParameterCount - additionalParameterCount), 553method.Parameters.AsSpan(),

Symbols\MethodSymbol.cs (6)

327return this.Parameters.Length; 919ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 932ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 978DeriveUseSiteInfoFromParameters(ref result, this.Parameters)) 992GetUnificationUseSiteDiagnosticRecursive(ref diagnosticInfo, this.Parameters, this, ref unificationCheckedTypes) || 1249ImmutableArray<IParameterSymbolInternal> IMethodSymbolInternal.Parameters => Parameters.Cast<ParameterSymbol, IParameterSymbolInternal>();

Symbols\MethodSymbolExtensions.cs (1)

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

Symbols\NamedTypeSymbol.cs (4)

366var thisParam = method.Parameters.First(); 1900var candidate = factory.Parameters[0].Type; 1968Parameters: [{ RefKind: RefKind.In or RefKind.None }] 2002return ctor is { DeclaredAccessibility: Accessibility.Public, ParameterCount: 1, Parameters: [{ RefKind: RefKind.In or RefKind.None }] };

Symbols\NativeIntegerTypeSymbol.cs (1)

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

Symbols\PublicModel\MethodSymbol.cs (1)

129static underlying => underlying.Parameters.GetPublicSymbols(),

Symbols\ReducedExtensionMethodSymbol.cs (5)

53var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 251return _reducedFrom.Parameters[0].Type; 256_reducedFrom.Parameters[0].TypeWithAnnotations.ToPublicAnnotation(); 544internal override bool IsEffectivelyReadOnly => _reducedFrom.Parameters[0].RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 563var reducedFromParameters = _reducedFrom.Parameters;

Symbols\Retargeting\RetargetingMethodSymbol.cs (1)

170var 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 (4)

2379var refKind1 = method1.Parameters[i].RefKind; 2380var refKind2 = method2.Parameters[i].RefKind; 4560ParametersMatchPropertyAccessor(propertySymbol, getNotSet, methodSymbol.Parameters)) 4599ParametersMatchEventAccessor(eventSymbol, methodSymbol.Parameters))

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (7)

1294var baseParameters = baseMethod.Parameters; 1295var overrideParameters = overrideMethod.Parameters; 1419var parameters = method.Parameters; 1498var baseParameters = baseMethod.Parameters; 1499var overrideParameters = overrideMethod.Parameters; 1549var baseParameters = baseMethod.Parameters; 1550var overrideParameters = overrideMethod.Parameters;

Symbols\Source\SourceMemberMethodSymbol.cs (2)

925foreach (var parameter in this.Parameters) 1053foreach (var parameter in method.Parameters)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (4)

783foreach (var param in this.Parameters) 1019Debug.Assert(arguments.Attribute.AttributeConstructor.Parameters is [{ Type.SpecialType: SpecialType.System_Int32 }, { Type.SpecialType: SpecialType.System_String }]); 1412foreach (var param in Parameters) 1600var enumeratorCancellationCount = Parameters.Count(p => p.HasEnumeratorCancellationAttribute);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (2)

995foreach (var parameter in constructor.Parameters) 1022if (_lazyExtensionInfo.LazyExtensionParameter == null && markerMethod is { Parameters: [var parameter, ..] })

Symbols\SubstitutedMethodSymbol.cs (2)

170return reduced.Parameters[0].Type; 348var unsubstitutedParameters = OriginalDefinition.Parameters;

Symbols\SymbolExtensions.cs (1)

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

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

576var parameterReference = f.Parameter(method.Parameters[0]); 619var parameterReference0 = f.Parameter(method.Parameters[0]); 620var parameterReference1 = f.Parameter(method.Parameters[1]); 688var parameterReference = f.Parameter(method.Parameters[0]); 722var 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)

130TypeSymbol baseType = baseEquals.Parameters[0].Type;

Symbols\Synthesized\SynthesizedCollectionBuilderProjectedMethodSymbol.cs (1)

97var parameters = this.UnderlyingMethod.Parameters;

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)

388&& handleAsyncEntryPointMethod.Parameters[0].Type.Equals(userMain.ReturnType, TypeCompareKind.AllIgnoreOptions))

Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)

302return sourceMethod.Parameters.SelectAsArray(

Symbols\TypeSymbol.cs (1)

1615interfaceMethod.Parameters,

Symbols\TypeSymbolExtensions.cs (3)

621return invokeMethod.Parameters; 1026(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(currentPointer.Parameters[i].TypeWithAnnotations, canDigThroughNullable); 1043next = currentPointer.Parameters[i].TypeWithAnnotations;

Symbols\VarianceSafety.cs (1)

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