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 (10)

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; 1530var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1876if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 1894var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2825var delegateOrFuncPtrParameters = delegateOrFuncPtrMethod.Parameters; 2826var methodParameters = method.Parameters;

Binder\Binder_Crefs.cs (1)

567foreach (var param in signature.Parameters)

Binder\Binder_Deconstruct.cs (1)

684var parameters = deconstructMethod.Parameters;

Binder\Binder_Expressions.cs (6)

4985var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5006BindDefaultArguments(nonNullSyntax, resultMember.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParamsOpt, out var defaultArguments, expanded, enableCallerInfo, diagnostics); 6765BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 10134original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10135original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 10798var parameters = methodSymbol.Parameters;

Binder\Binder_Invocation.cs (4)

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

Binder\Binder_Patterns.cs (1)

1074parameter = deconstructMethod.Parameters[parameterIndex];

Binder\BinderFactory.BinderFactoryVisitor.cs (3)

1244return new WithParametersBinder(method.Parameters, nextBinder); 1277parameters = parameters.Add(property.SetMethod.Parameters.Last()); 1292ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

Binder\DecisionDagBuilder.cs (1)

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

Binder\ExecutableCodeBinder.cs (1)

110foreach (var parameter in iterator.Parameters)

Binder\ForEachLoopBinder.cs (8)

1020Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty)); 1024? builder.GetEnumeratorInfo.Method.Parameters[0].Type 1090if (getEnumeratorMethod?.Parameters[0].IsOptional == false) 1211patternDisposeMethod.Parameters, 1467result.Parameters, 1529var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1542result.Parameters[0].Type); 1925method.Parameters,

Binder\InMethodBinder.cs (3)

206var parameters = _methodSymbol.Parameters; 232foreach (var parameter in _methodSymbol.Parameters) 324var 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 (4)

664method.Parameters, 765constructor.Parameters, 794constructor.Parameters, 948var parameters = deconstructMethod.Parameters;

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

254GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 330var thisParameter = method.Parameters[0]; 384GetDelegateOrFunctionPointerArguments(syntax, analyzedArguments, delegateInvokeMethod.Parameters, Compilation); 452if (methodGroup.IsExtensionMethodGroup && !method.Parameters[0].Type.IsReferenceType)

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

1494var delegateParameters = invokeMethod.Parameters;

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

3611if (!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)

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

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

Compilation\MemberSemanticModel.cs (1)

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

Compilation\SyntaxTreeSemanticModel.cs (2)

2040return GetParameterSymbol(method.Parameters, parameter, cancellationToken); 2100return 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)

623return 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 (2)

471return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 3014var param = method.Parameters[0];

FlowAnalysis\DefiniteAssignment.cs (1)

1812foreach (var parameter in method.Parameters)

FlowAnalysis\NullableWalker.cs (29)

2802var methodParameters = methodSymbol.Parameters; 2803var signatureParameters = (_useDelegateInvokeParameterTypes ? _delegateInvokeMethod! : methodSymbol).Parameters; 2943EnforceNotNullIfNotNull(node.Syntax, this.State, method.Parameters, method.ReturnNotNullIfParameterNotNull, ResultType.State, outputParam: null); 3613return invokeMethod!.Parameters.SequenceEqual(l.Parameters, 3862node, arguments, node.ArgumentRefKindsOpt, constructor?.Parameters ?? default, 3929argumentsCompletion(argumentResults, constructor?.Parameters ?? default, constructor); 4315addMethod.Parameters, 4371node, containingType, visitArgumentsCompletion.Invoke(argumentResults, addMethod.Parameters, addMethod).method, 4848if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 4849(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 5103var parameters = method.Parameters; 6222var annotations = GetCorrespondingParameter(0, node.Method.Parameters, node.ArgsToParamsOpt, node.Expanded, ref paramsIterationType).Annotations; 6287(method, results, returnNotNull) = VisitArguments(node, node.Arguments, refKindsOpt, method!.Parameters, node.ArgsToParamsOpt, node.DefaultArguments, 6365var parameterType = method.Parameters[0].TypeWithAnnotations; 6724return VisitArguments(node, arguments, refKindsOpt, method is null ? default : method.Parameters, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod, method); 6831parametersOpt = method.Parameters; 8866NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 9383var parameter = method.Parameters[0]; 9682method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod); 9838CheckExtensionMethodThisNullability(receiverOpt, Conversion.Identity, method.Parameters[0], receiverType); 10199var parameters = deconstructMethod.Parameters; 10207CheckExtensionMethodThisNullability(right, argConversion, deconstructMethod.Parameters[0], rightResult); 10439targetTypeOfOperandConversion = incrementOperator.Parameters[0].TypeWithAnnotations; 10441parameter = incrementOperator.Parameters[0]; 10900if (enumeratorInfoOpt?.GetEnumeratorInfo is { Method: { IsExtensionMethod: true, Parameters: var parameters } } enumeratorMethodInfo) 11266var parameter = method.Parameters[0]; 11393ReportArgumentWarnings(left!, leftType, trueFalseOperator.Parameters[0]); 11398ReportArgumentWarnings(left!, leftType, logicalOperator.Parameters[0]); 11408ReportArgumentWarnings(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)

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)

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

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (5)

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));

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

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

Lowering\DiagnosticsPass_Warnings.cs (1)

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

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 (2)

334delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 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 (7)

233var interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 252this._diagnostics.Add(ErrorCode.ERR_InterceptorMustHaveMatchingThisParameter, attributeLocation, method.Parameters[0], method); 281Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 282|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 283receiverOpt = MakeConversionNode(receiverOpt, interceptor.Parameters[0].Type, @checked: false, markAsChecked: true); 307argumentRefKindsOpt = method.Parameters.SelectAsArray(static param => param.RefKind); 1234((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol :

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

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

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (3)

746delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 1762Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1868Conversion 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)

145Debug.Assert(addMethod.Parameters 164if (addMethod.Parameters[0].RefKind == RefKind.Ref) 169var builder = ArrayBuilder<RefKind>.GetInstance(addMethod.Parameters.Length, RefKind.None);

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

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

323foreach (var parameter in method.Parameters) 481foreach (var parameter in method.Parameters)

Lowering\SynthesizedMethodBaseSymbol.cs (1)

126get { return this.BaseMethod.Parameters; }

Lowering\SyntheticBoundNodeFactory.cs (2)

1496if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1498arg = 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\MemberSymbolExtensions.cs (3)

38return ((MethodSymbol)member).Parameters; 208foreach (ParameterSymbol param in method.Parameters) 581return 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\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)

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

Symbols\NativeIntegerTypeSymbol.cs (1)

359var 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\SourceComplexParameterSymbol.cs (2)

475SourceMemberMethodSymbol { PartialImplementationPart.Parameters: { } parameters } => parameters, 496SourceMemberMethodSymbol { PartialDefinitionPart.Parameters: { } parameters } => parameters,

Symbols\Source\SourceMemberContainerSymbol.cs (4)

2154var refKind1 = method1.Parameters[i].RefKind; 2155var refKind2 = method2.Parameters[i].RefKind; 3866ParametersMatchPropertyAccessor(propertySymbol, getNotSet, methodSymbol.Parameters)) 3902ParametersMatchEventAccessor(eventSymbol, methodSymbol.Parameters))

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (7)

1258var baseParameters = baseMethod.Parameters; 1259var overrideParameters = overrideMethod.Parameters; 1383var parameters = method.Parameters; 1449var baseParameters = baseMethod.Parameters; 1450var overrideParameters = overrideMethod.Parameters; 1500var baseParameters = baseMethod.Parameters; 1501var overrideParameters = overrideMethod.Parameters;

Symbols\Source\SourceMemberMethodSymbol.cs (2)

897foreach (var parameter in this.Parameters) 995foreach (var parameter in Parameters)

Symbols\Source\SourceMethodSymbol.cs (1)

63foreach (var parameter in Parameters)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (3)

762foreach (var param in this.Parameters) 1394foreach (var param in Parameters) 1582var enumeratorCancellationCount = Parameters.Count(p => p.IsSourceParameterWithEnumeratorCancellationAttribute());

Symbols\SubstitutedMethodSymbol.cs (2)

168return reduced.Parameters[0].Type; 333var unsubstitutedParameters = OriginalDefinition.Parameters;

Symbols\SymbolExtensions.cs (1)

453if (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)

1605interfaceMethod.Parameters,

Symbols\TypeSymbolExtensions.cs (3)

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

Symbols\VarianceSafety.cs (1)

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