ParameterSymbol

Binder\Binder.CapturedParametersFinder.cs (9)

21private readonly ArrayBuilder<ParameterSymbol> _captured; 23private CapturedParametersFinder(SynthesizedPrimaryConstructor primaryConstructor, HashSet<string> namesToCheck, ArrayBuilder<ParameterSymbol> captured) 30public static IReadOnlyDictionary<ParameterSymbol, FieldSymbol> GetCapturedParameters(SynthesizedPrimaryConstructor primaryConstructor) 38return SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 41var captured = ArrayBuilder<ParameterSymbol>.GetInstance(primaryConstructor.Parameters.Length); 73return SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 76var result = new Dictionary<ParameterSymbol, FieldSymbol>(ReferenceEqualityComparer.Instance); 91foreach (var parameter in primaryConstructor.Parameters) 155if (candidate is ParameterSymbol parameter && parameter.ContainingSymbol == (object)_primaryConstructor)

Binder\Binder.ValueChecks.cs (41)

105internal ParameterSymbol? Parameter { get; } 114internal MixableDestination(ParameterSymbol parameter, BoundExpression argument) 150internal ParameterSymbol? Parameter { get; } 156internal EscapeArgument(ParameterSymbol? parameter, BoundExpression argument, RefKind refKind, bool isArgList = false) 164public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out RefKind refKind) 186internal ParameterSymbol? Parameter { get; } 199internal EscapeValue(ParameterSymbol? parameter, BoundExpression argument, EscapeLevel escapeLevel, bool isRefEscape) 207public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out EscapeLevel escapeLevel, out bool isRefEscape) 1115ParameterSymbol parameterSymbol = parameter.ParameterSymbol; 1172static void reportReadOnlyParameterError(ParameterSymbol parameterSymbol, SyntaxNode node, BindValueKind valueKind, bool checkingReceiver, BindingDiagnosticBag diagnostics) 1228private static SafeContext GetParameterValEscape(ParameterSymbol parameter) 1238private static EscapeLevel? GetParameterValEscapeLevel(ParameterSymbol parameter) => 1241private static SafeContext GetParameterRefEscape(ParameterSymbol parameter) 1253private static EscapeLevel? GetParameterRefEscapeLevel(ParameterSymbol parameter) => 1256private bool CheckParameterValEscape(SyntaxNode node, ParameterSymbol parameter, SafeContext escapeTo, BindingDiagnosticBag diagnostics) 1274private bool CheckParameterRefEscape(SyntaxNode node, BoundExpression parameter, ParameterSymbol parameterSymbol, SafeContext escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics) 1961ImmutableArray<ParameterSymbol> parameters, 2050ImmutableArray<ParameterSymbol> parameters, 2115ImmutableArray<ParameterSymbol> parameters, 2208ImmutableArray<ParameterSymbol> parameters, 2281ImmutableArray<ParameterSymbol> parameters, 2331var parameter = argIndex < parameters.Length ? 2359static bool isMixableParameter([NotNullWhen(true)] ParameterSymbol? parameter) => 2411ParameterSymbol? thisParameter = null; 2458ImmutableArray<ParameterSymbol> parameters, 2528ImmutableArray<ParameterSymbol> parameters, 2583ImmutableArray<ParameterSymbol> parameters, 2659ImmutableArray<ParameterSymbol> parameters, 2713private static string GetInvocationParameterName(ParameterSymbol? parameter) 2730ParameterSymbol? parameter, 2773ImmutableArray<ParameterSymbol> parameters, 2873ImmutableArray<ParameterSymbol> parameters, 2957ImmutableArray<ParameterSymbol> parameters, 2987private readonly ParameterSymbol _underlyingParameter; 2989internal TypeParameterThisParameterSymbol(ParameterSymbol underlyingParameter, TypeParameterSymbol type) 3379var thisParam = ((MethodSymbol)_symbol).ThisParameter; 3705var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4049var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4746var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5481ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5521ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

Binder\Binder_Attributes.cs (4)

396private void ValidateTypeForAttributeParameters(ImmutableArray<ParameterSymbol> parameters, CSharpSyntaxNode syntax, BindingDiagnosticBag diagnostics, ref bool hasErrors) 398foreach (var parameter in parameters) 710ImmutableArray<ParameterSymbol> parameters = attributeConstructor.Parameters; 717ParameterSymbol parameter = parameters[paramIndex];

Binder\Binder_Await.cs (1)

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

Binder\Binder_Conversions.cs (5)

2319var lambdaParameter = lambdaSymbol.Parameters[p]; 2320var delegateParameter = delegateParameters[p]; 2385ParameterSymbol lambdaParameter, 2848var delegateParameter = delegateOrFuncPtrParameters[i]; 2849var methodParameter = methodParameters[isExtensionMethod ? i + 1 : i];

Binder\Binder_Crefs.cs (6)

495ImmutableArray<ParameterSymbol> parameterSymbols = BindCrefParameters(parameterListSyntax, diagnostics); 567foreach (var param in signature.Parameters) 758private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder<Symbol> candidates, ImmutableArray<ParameterSymbol> parameterSymbols, int arity, MemberCrefSyntax memberSyntax, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics) 929private ImmutableArray<ParameterSymbol> BindCrefParameters(BaseCrefParameterListSyntax parameterListSyntax, BindingDiagnosticBag diagnostics) 931ArrayBuilder<ParameterSymbol> parameterBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameterListSyntax.Parameters.Count);

Binder\Binder_Expressions.cs (21)

455TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, result) is (ParameterSymbol parameter, SyntaxNode syntax) && 484ParameterSymbol parameter, 495ParameterSymbol parameter, 1773if (GetSymbolOrMethodOrPropertyGroup(lookupResult, node, name, node.Arity, members, diagnostics, out bool isError, qualifierOpt: null) is ParameterSymbol shadowedParameter && 2077var parameter = (ParameterSymbol)symbol; 2494ParameterSymbol? thisSymbol = this.ContainingMemberOrLambda.EnclosingThisSymbol(); 3505ImmutableArray<ParameterSymbol> parameters, 3561ImmutableArray<ParameterSymbol> parameters, 3594ImmutableArray<ParameterSymbol> parameters, 3677static ParameterSymbol getCorrespondingParameter(in MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, int arg) 3687ImmutableArray<ParameterSymbol> parameters, 3698var correspondingParameter = getCorrespondingParameter(in memberAnalysisResult, parameters, interpolatedStringArgNum); 3815var parameter = parameters[originalParameterIndex]; 3835var parameter = parameters[originalParameterIndex]; 4975var parametersPassedToBase = new OrderedSet<ParameterSymbol>(); 4984if (TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, analyzedArguments.Argument(i)) is (ParameterSymbol parameter, SyntaxNode syntax)) 4988var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5079private static (ParameterSymbol, SyntaxNode) TryGetPrimaryConstructorParameterUsedAsValue(SynthesizedPrimaryConstructor primaryConstructor, BoundExpression boundExpression) 9636var parameter = property.Parameters[0];

Binder\Binder_Invocation.cs (17)

1215ParameterSymbol receiverParameter = method.Parameters.First(); 1363private BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, BindingDiagnosticBag diagnostics) 1421internal static ParameterSymbol? GetCorrespondingParameter( 1423ImmutableArray<ParameterSymbol> parameters, 1428ParameterSymbol? parameter; 1465ImmutableArray<ParameterSymbol> parameters, 1480var parameter = GetCorrespondingParameter(i, parameters, argsToParamsOpt, expanded); 1541foreach (var parameter in parameters.AsSpan()[..lastIndex]) 1597BoundExpression bindDefaultArgument(SyntaxNode syntax, ParameterSymbol parameter, Symbol? containingMember, bool enableCallerInfo, BindingDiagnosticBag diagnostics, ArrayBuilder<BoundExpression> argumentsBuilder, int argumentsCount, ImmutableArray<int> argsToParamsOpt) 1717private BoundExpression CreateParamsCollection(SyntaxNode node, ParameterSymbol paramsParameter, ImmutableArray<BoundExpression> collectionArgs, BindingDiagnosticBag diagnostics) 1848!(d.Arguments is [ParameterSymbol shadowedParameter] && shadowedParameter.Type.Equals(typeOrValue.Data.ValueExpression.Type, TypeCompareKind.AllIgnoreOptions))) // If the type and the name match, we would resolve to the same type rather than a value at the end. 1968var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 1988var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2006private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedArguments analyzedArguments, IEnumerable<ImmutableArray<ParameterSymbol>> parameterListList) 2140private static TypeSymbol GetCorrespondingParameterType(AnalyzedArguments analyzedArguments, int i, ImmutableArray<ParameterSymbol> parameterList) 2146foreach (var parameter in parameterList) 2163return BuildArgumentsForErrorRecovery(analyzedArguments, Enumerable.Empty<ImmutableArray<ParameterSymbol>>());

Binder\Binder_Lookup.cs (1)

1398if ((options & LookupOptions.MustNotBeParameter) != 0 && unwrappedSymbol is ParameterSymbol)

Binder\Binder_NameConflicts.cs (2)

29ImmutableArray<ParameterSymbol> parameters, 60foreach (var p in parameters)

Binder\Binder_Operators.cs (1)

2646ParameterSymbol parameterSymbol = parameterAccess.ParameterSymbol;

Binder\Binder_Patterns.cs (1)

1068ParameterSymbol? parameter = null;

Binder\Binder_Symbols.cs (2)

1441if (IsPossiblyCapturingPrimaryConstructorParameterReference(colorColorValueReceiver, out ParameterSymbol parameter)) 1506private bool IsPossiblyCapturingPrimaryConstructorParameterReference(BoundExpression colorColorValueReceiver, out ParameterSymbol parameterSymbol)

Binder\BinderFactory.BinderFactoryVisitor.cs (2)

1270ImmutableArray<ParameterSymbol> parameters = property.Parameters; 1292ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

Binder\ExecutableCodeBinder.cs (1)

110foreach (var parameter in iterator.Parameters)

Binder\InMethodBinder.cs (4)

24private MultiDictionary<string, ParameterSymbol> _lazyParameterMap; 207parameterMap = new MultiDictionary<string, ParameterSymbol>(parameters.Length, EqualityComparer<string>.Default); 208foreach (var parameter in parameters) 232foreach (var parameter in _methodSymbol.Parameters)

Binder\LocalBinderFactory.cs (6)

313ParameterSymbol parameter => getAllParameters(parameter), 325static ImmutableArray<ParameterSymbol> getAllParameters(ParameterSymbol parameter) 339static ImmutableArray<ParameterSymbol> getMethodParametersFromTypeParameter(TypeParameterSymbol typeParameter) 353static ImmutableArray<ParameterSymbol> getDelegateParameters(NamedTypeSymbol delegateType) 365static ImmutableArray<ParameterSymbol> getSetterParameters(SourcePropertyAccessorSymbol setter)

Binder\RefSafetyAnalysis.cs (2)

605static ParameterSymbol? tryGetThisParameter(MethodSymbol method) 612return method.TryGetThisParameter(out var thisParameter) ? thisParameter : null;

Binder\Semantics\AccessCheck.cs (1)

173foreach (var param in funcPtr.Signature.Parameters)

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

73foreach (var p in invoke.Parameters) 330var thisParameter = method.Parameters[0]; 402public static void GetDelegateOrFunctionPointerArguments(SyntaxNode syntax, AnalyzedArguments analyzedArguments, ImmutableArray<ParameterSymbol> delegateParameters, CSharpCompilation compilation) 404foreach (var p in delegateParameters) 406ParameterSymbol parameter = p;

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

3398var sourceParam = sourceSig.Parameters[i]; 3399var destinationParam = destinationSig.Parameters[i];

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (6)

1007foreach (var parameter in parameters) 1478ImmutableArray<ParameterSymbol> delegateParameters, 2418var sourceParam = sourceSignature.Parameters[i]; 2419var targetParam = targetSignature.Parameters[i]; 2768var sourceParam = sourceSignature.Parameters[i]; 2769var targetParam = targetSignature.Parameters[i];

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

1301ParameterSymbol final = member.GetParameters().Last(); 2071private static ParameterSymbol GetParameter(int argIndex, MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters) 2529var parameter1 = GetParameter(i, m1.Result, m1LeastOverriddenParameters); 2530var parameter2 = GetParameter(i, m2.Result, m2LeastOverriddenParameters); 2558static TypeSymbol getParameterTypeAndRefKind(int i, MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, TypeWithAnnotations paramsElementTypeOpt, out RefKind parameter1RefKind) 2560var parameter = GetParameter(i, result, parameters); 2604ImmutableArray<ParameterSymbol> parameters1, 2606ImmutableArray<ParameterSymbol> parameters2) 2615var p1 = GetParameter(i, m1.Result, parameters1); 2616var p2 = GetParameter(i, m2.Result, parameters2); 3700private static bool IdenticalParameters(ImmutableArray<ParameterSymbol> p1, ImmutableArray<ParameterSymbol> p2) 3715var param1 = p1[i]; 3716var param2 = p2[i]; 3825ImmutableArray<ParameterSymbol> parameters = member.GetParameters(); 3851var parameter = parameters[parm]; 3876ParameterSymbol parameter, 3988var parameter = parameters[parm];

Binder\Semantics\OverloadResolution\OverloadResolution_ArgsToParameters.cs (5)

67ImmutableArray<ParameterSymbol> parameters = symbol.GetParameters(); 233ImmutableArray<ParameterSymbol> memberParameters, 341ImmutableArray<ParameterSymbol> parameters, 381private static bool CanBeOptional(ParameterSymbol parameter, bool isMethodGroupConversion) 434ImmutableArray<ParameterSymbol> parameters,

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (4)

898ImmutableArray<ParameterSymbol> parameters = badMember.GetParameters(); 1187ParameterSymbol parameter = method.GetParameters()[parm]; 1368static bool isStringLiteralToInterpolatedStringHandlerArgumentConversion(BoundExpression argument, ParameterSymbol parameter) 1377static Symbol unwrapIfParamsCollection(MemberResolutionResult<TMember> badArg, ParameterSymbol parameter, bool isLastParameter)

Binder\WithLambdaParametersBinder.cs (8)

19protected readonly MultiDictionary<string, ParameterSymbol> parameterMap; 20private readonly SmallDictionary<string, ParameterSymbol> _definitionMap; 26this.parameterMap = new MultiDictionary<string, ParameterSymbol>(); 31_definitionMap = new SmallDictionary<string, ParameterSymbol>(); 32foreach (var parameter in parameters) 106foreach (var parameter in lambdaSymbol.Parameters) 116private static bool ReportConflictWithParameter(ParameterSymbol parameter, Symbol newSymbol, string name, Location newLocation, BindingDiagnosticBag diagnostics) 160ParameterSymbol existingDeclaration;

Binder\WithParametersBinder.cs (4)

22private readonly ImmutableArray<ParameterSymbol> _parameters; 24internal WithParametersBinder(ImmutableArray<ParameterSymbol> parameters, Binder next) 35foreach (var parameter in _parameters) 55foreach (ParameterSymbol parameter in _parameters)

Binder\WithPrimaryConstructorParametersBinder.cs (4)

19private MultiDictionary<string, ParameterSymbol>? _lazyParameterMap; 38foreach (var parameter in _lazyPrimaryCtorWithParameters.Parameters) 84parameterMap = new MultiDictionary<string, ParameterSymbol>(parameters.Length, EqualityComparer<string>.Default); 85foreach (var parameter in parameters)

BoundTree\BoundDagTest.cs (1)

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

BoundTree\Constructors.cs (2)

530public BoundParameter(SyntaxNode syntax, ParameterSymbol parameterSymbol, bool hasErrors = false) 535public BoundParameter(SyntaxNode syntax, ParameterSymbol parameterSymbol)

BoundTree\NullabilityRewriter.cs (1)

144case ParameterSymbol param:

BoundTree\UnboundLambda.cs (2)

1109foreach (var p in invoke.Parameters) 1265foreach (var parameter in lambda.Parameters)

CodeGen\EmitAddress.cs (1)

471ParameterSymbol parameterSymbol = parameter.ParameterSymbol;

CodeGen\EmitExpression.cs (3)

946private void EmitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt) 967internal static RefKind GetArgumentRefKind(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt, int i) 1381var sym = parameter.ParameterSymbol;

CodeGen\Optimizer.cs (1)

1255private ImmutableArray<BoundExpression> VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt)

Compilation\CSharpSemanticModel.cs (12)

1783case ParameterSymbol _: 3223protected ParameterSymbol GetParameterSymbol( 3224ImmutableArray<ParameterSymbol> parameters, 3228foreach (var symbol in parameters) 3685var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind); 3730private static ParameterSymbol GetThisParameter(TypeSymbol typeOfThis, NamedTypeSymbol containingType, Symbol containingMember, out LookupResultKind resultKind) 3739ParameterSymbol thisParam; 4511ParameterSymbol param = FindNamedParameter(containingInvocationInfo.Symbol.GetSymbol().GetParameters(), argumentName); 4528ParameterSymbol param = FindNamedParameter(invocationSym.GetSymbol().GetParameters(), argumentName); 4550private static ParameterSymbol FindNamedParameter(ImmutableArray<ParameterSymbol> parameters, string argumentName) 4552foreach (ParameterSymbol param in parameters)

Compilation\InitializerSemanticModel.cs (3)

59internal static InitializerSemanticModel Create(PublicSemanticModel containingSemanticModel, ParameterSyntax syntax, ParameterSymbol parameterSymbol, Binder rootBinder, ImmutableDictionary<Symbol, Symbol> parentRemappedSymbolsOpt) 173var parameter = (ParameterSymbol)this.MemberSymbol;

Compilation\MemberSemanticModel.cs (3)

828private ParameterSymbol GetLambdaOrLocalFunctionParameterSymbol( 862private ParameterSymbol GetLambdaParameterSymbol( 2342Debug.Assert(symbol is LocalSymbol or ParameterSymbol or MethodSymbol { MethodKind: MethodKind.LambdaMethod });

Compilation\SpeculativeSemanticModelWithMemberModel.cs (2)

191var parameterSymbol = containing.GetDeclaredSymbol(paramDecl).GetSymbol<ParameterSymbol>();

Compilation\SyntaxTreeSemanticModel.cs (8)

1016var parameterSymbol = containing.GetDeclaredSymbol(paramDecl).GetSymbol<ParameterSymbol>(); 1151ParameterSymbol parameterSymbol = GetDeclaredNonLambdaParameterSymbol(parameterDecl); 2006private ParameterSymbol GetMethodParameterSymbol( 2043private ParameterSymbol GetIndexerParameterSymbol( 2070private ParameterSymbol GetDelegateParameterSymbol( 2123private ParameterSymbol GetDeclaredNonLambdaParameterSymbol(ParameterSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) 2386Debug.Assert(symbol is LocalSymbol or ParameterSymbol or MethodSymbol { MethodKind: MethodKind.LambdaMethod });

Compiler\ClsComplianceChecker.cs (3)

572private void CheckParameterCompliance(ImmutableArray<ParameterSymbol> parameters, NamedTypeSymbol context) 576foreach (ParameterSymbol parameter in parameters) 674private void CheckForMeaninglessOnParameter(ImmutableArray<ParameterSymbol> parameters)

Compiler\DocumentationCommentCompiler.cs (9)

329HashSet<ParameterSymbol> documentedParameters; 381foreach (ParameterSymbol parameter in GetParameters(symbol)) 498out HashSet<ParameterSymbol> documentedParameters, 615private static ImmutableArray<ParameterSymbol> GetParameters(Symbol symbol) 632return ImmutableArray<ParameterSymbol>.Empty; 1129ref HashSet<ParameterSymbol> documentedParameters, 1142documentedParameters = new HashSet<ParameterSymbol>(); 1196ParameterSymbol parameter = (ParameterSymbol)referencedSymbol;

Compiler\DocumentationCommentCompiler.DocumentationCommentWalker.cs (3)

37private HashSet<ParameterSymbol> _documentedParameters; 46HashSet<ParameterSymbol> documentedParameters, 123ref HashSet<ParameterSymbol> documentedParameters,

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (5)

38private HashSet<ParameterSymbol> _documentedParameters; 46HashSet<ParameterSymbol> documentedParameters, 70ref HashSet<ParameterSymbol> documentedParameters, 558ImmutableArray<ParameterSymbol> parameters = ImmutableArray<ParameterSymbol>.Empty;

Compiler\MethodBodySynthesizer.cs (3)

183var thisSymbol = accessor.ThisParameter; 198var parameter = accessor.Parameters[0]; 350ParameterSymbol thisParameter = accessor.ThisParameter;

Compiler\MethodBodySynthesizer.Lowered.cs (3)

61ParameterSymbol text = this.Parameters[0]; 146ParameterSymbol text = this.Parameters[0]; 460foreach (var param in F.CurrentFunction.Parameters)

Compiler\MethodCompiler.cs (1)

1226IReadOnlyDictionary<ParameterSymbol, FieldSymbol> capturedParameters = primaryCtor.GetCapturedParameters();

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (3)

75private void VisitParameters(ImmutableArray<ParameterSymbol> parameters, bool isVararg, StringBuilder builder) 80foreach (var parameter in parameters) 241public override object VisitParameter(ParameterSymbol symbol, StringBuilder builder)

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (7)

367public override Symbol VisitParameter(ParameterSymbol parameter) 407foreach (var param in sig.Parameters) 652private bool AreParametersEqual(ParameterSymbol parameter, ParameterSymbol other) 685private bool AreFunctionPointerParametersEqual(ParameterSymbol param, ParameterSymbol otherParam) 924foreach (var param in sig.Parameters)

Emitter\Model\MethodSymbolAdapter.cs (1)

210return AdaptedMethodSymbol.Parameters.SelectAsArray<ParameterSymbol, Cci.IParameterDefinition>(p => p.GetCciAdapter());

Emitter\Model\ParameterSymbolAdapter.cs (2)

271internal ParameterSymbolAdapter(ParameterSymbol underlyingParameterSymbol) 283internal ParameterSymbol AdaptedParameterSymbol { get; }

Emitter\Model\ParameterTypeInformation.cs (2)

18private readonly ParameterSymbol _underlyingParameter; 20public ParameterTypeInformation(ParameterSymbol underlyingParameter)

Emitter\Model\PEModuleBuilder.cs (9)

1364internal ImmutableArray<Cci.IParameterTypeInformation> Translate(ImmutableArray<ParameterSymbol> @params) 1374return @params.SelectAsArray<ParameterSymbol, Cci.IParameterTypeInformation>(p => p.GetCciAdapter()); 1383private static bool MustBeWrapped(ParameterSymbol param) 1403private ImmutableArray<Cci.IParameterTypeInformation> TranslateAll(ImmutableArray<ParameterSymbol> @params) 1406foreach (var param in @params) 1413private Cci.IParameterTypeInformation CreateParameterTypeInformationWrapper(ParameterSymbol param) 1503internal SynthesizedAttributeData SynthesizeRequiresLocationAttribute(ParameterSymbol symbol) 1514internal SynthesizedAttributeData SynthesizeParamCollectionAttribute(ParameterSymbol symbol) 1683internal SynthesizedAttributeData SynthesizeScopedRefAttribute(ParameterSymbol symbol, ScopedKind scope)

Emitter\Model\PropertySymbolAdapter.cs (2)

115return AdaptedPropertySymbol.Parameters.SelectAsArray<ParameterSymbol, IParameterDefinition>(p => p.GetCciAdapter()); 173return AdaptedPropertySymbol.Parameters.SelectAsArray<ParameterSymbol, IParameterTypeInformation>(p => p.GetCciAdapter());

Emitter\Model\SynthesizedPrivateImplementationDetailsStaticConstructor.cs (1)

21this.SetParameters(ImmutableArray<ParameterSymbol>.Empty);

Emitter\NoPia\EmbeddedTypesManager.cs (1)

630ImmutableArray<ParameterSymbol> underlyingParameters)

FlowAnalysis\AbstractFlowPass.cs (12)

316protected virtual void EnterParameters(ImmutableArray<ParameterSymbol> parameters) 318foreach (var parameter in parameters) 324protected virtual void EnterParameter(ParameterSymbol parameter) 328ImmutableArray<ParameterSymbol> parameters, 332foreach (ParameterSymbol parameter in parameters) 338protected virtual void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location) 466protected ImmutableArray<ParameterSymbol> MethodParameters 471return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 479protected ParameterSymbol MethodThisParameter 483ParameterSymbol thisParameter = null; 1438else if (method.TryGetThisParameter(out var thisParameter) 3018var param = method.Parameters[0];

FlowAnalysis\AbstractRegionDataFlowPass.cs (2)

57private void MakeSlots(ImmutableArray<ParameterSymbol> parameters) 60foreach (var parameter in parameters)

FlowAnalysis\DataFlowsInWalker.cs (1)

117ParameterSymbol parameter,

FlowAnalysis\DataFlowsOutWalker.cs (6)

96var param = variable as ParameterSymbol; 219ParameterSymbol param = Param(node); 230private bool FlowsOut(ParameterSymbol param) 237private ParameterSymbol Param(BoundNode node) 264protected override void ReportUnassignedOutParameter(ParameterSymbol parameter, SyntaxNode node, Location location)

FlowAnalysis\DefiniteAssignment.cs (20)

70private PooledHashSet<ParameterSymbol>? _readParameters; 332ImmutableArray<ParameterSymbol> methodParameters = MethodParameters; 333ParameterSymbol methodThisParameter = MethodThisParameter; 347foreach (var parameter in primaryConstructor.Parameters) 449protected virtual void ReportUnassignedOutParameter(ParameterSymbol parameter, SyntaxNode node, Location location) 689!(captured is ParameterSymbol { ContainingSymbol: SynthesizedPrimaryConstructor primaryConstructor } parameter && 707private void CheckCaptured(Symbol variable, ParameterSymbol? rangeVariableUnderlyingParameter = null) 746if (symbol is ParameterSymbol { ContainingSymbol: SynthesizedPrimaryConstructor } parameter) 748_readParameters ??= PooledHashSet<ParameterSymbol>.GetInstance(); 754ParameterSymbol rangeVariableUnderlyingParameter = null) 1234((ParameterSymbol)symbol).RefKind == RefKind.Out) 1236if (((ParameterSymbol)symbol).IsThis) 1386var self = MethodThisParameter; 1619var param = paramExpr.ParameterSymbol; 1812foreach (var parameter in method.Parameters) 1824if (method.TryGetThisParameter(out ParameterSymbol thisParameter) && thisParameter is not null) 1844foreach (var parameter in primaryConstructor.Parameters) 1876protected override void EnterParameter(ParameterSymbol parameter) 1932protected override void LeaveParameters(ImmutableArray<ParameterSymbol> parameters, SyntaxNode syntax, Location location) 1943protected override void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location)

FlowAnalysis\NullableWalker.cs (67)

FlowAnalysis\NullableWalker.Variables.cs (1)

358case ParameterSymbol:

FlowAnalysis\ReadWriteWalker.cs (5)

85foreach (var p in m.Parameters) 94var thisParameter = m.ThisParameter; 125protected override void NoteRead(Symbol variable, ParameterSymbol rangeVariableUnderlyingParameter = null) 286ParameterSymbol rangeVariableUnderlyingParameter = GetRangeVariableUnderlyingParameter(node.Value); 295private static ParameterSymbol GetRangeVariableUnderlyingParameter(BoundNode underlying)

FlowAnalysis\UnassignedVariablesWalker.cs (1)

70protected override void ReportUnassignedOutParameter(ParameterSymbol parameter, SyntaxNode node, Location location)

FlowAnalysis\VariablesDeclaredWalker.cs (2)

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

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

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

210protected override BoundStatement InitializeParameterField(MethodSymbol getEnumeratorMethod, ParameterSymbol parameter, BoundExpression resultParameter, BoundExpression parameterProxy)

Lowering\ClosureConversion\ClosureConversion.Analysis.cs (3)

211if (!_topLevelMethod.TryGetThisParameter(out var thisParam) || 345_topLevelMethod.TryGetThisParameter(out var thisParam); 568if (variable is ParameterSymbol p && p.IsThis)

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

392if (_topLevelMethod.TryGetThisParameter(out var thisParam) && (object)thisParam != null) 501var thisParam = _topLevelMethod.ThisParameter; 689type = ((ParameterSymbol)capturedVariable).Type;

Lowering\ClosureConversion\ClosureConversion.cs (15)

85private readonly Dictionary<ParameterSymbol, ParameterSymbol> _parameterMap = new Dictionary<ParameterSymbol, ParameterSymbol>(); 103private ParameterSymbol _currentFrameThis; 159ParameterSymbol? thisParameter, 202Debug.Assert(localOrParameter is LocalSymbol || localOrParameter is ParameterSymbol || 229ParameterSymbol? thisParameter, 609var potentialParameter = lambda.Parameters[i]; 753var parameter = (ParameterSymbol)symbol; 754ParameterSymbol parameterToUse; 821ParameterSymbol replacementParameter; 1551foreach (var parameter in node.Symbol.Parameters) 1558var oldFrameThis = _currentFrameThis;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (5)

21private readonly Dictionary<ParameterSymbol, BoundExpression> _parameterMap = new Dictionary<ParameterSymbol, BoundExpression>(); 839foreach (var p in node.Symbol.Parameters) 860foreach (var p in node.Symbol.Parameters) 892ParameterSymbol lambdaParameter = _bound.SynthesizedParameter(fromType, parameterName);

Lowering\ClosureConversion\LambdaCapturedVariable.cs (8)

48Debug.Assert(captured is LocalSymbol || captured is ParameterSymbol); 52bool isThis = IsThis(captured, out ParameterSymbol? parameter); 65/// Is assigned to <paramref name="captured"/> when it is a <see cref="ParameterSymbol"/>, 68private static bool IsThis(Symbol captured, out ParameterSymbol? parameter) 70parameter = captured as ParameterSymbol; 136return frame.TypeMap.SubstituteType(((object)local != null ? local.TypeWithAnnotations : ((ParameterSymbol)variable).TypeWithAnnotations).Type).Type; 176private readonly ParameterSymbol _parameter; 178public LambdaCapturedVariableForRegularParameter(SynthesizedClosureEnvironment frame, TypeWithAnnotations type, string fieldName, ParameterSymbol parameter)

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

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

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

573foreach (var p in lambda.Parameters)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (3)

305foreach (var parameter in _factory.CurrentFunction.Parameters) 436ParameterSymbol parameter, 489ParameterSymbol param => _factory.Parameter(param),

Lowering\IteratorRewriter\IteratorConstructor.cs (3)

21private readonly ImmutableArray<ParameterSymbol> _parameters; 27_parameters = ImmutableArray.Create<ParameterSymbol>( 39public override ImmutableArray<ParameterSymbol> Parameters

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (2)

164public override ImmutableArray<ParameterSymbol> Parameters 166get { return ImmutableArray<ParameterSymbol>.Empty; }

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

187ParameterSymbol parameter = method.Parameters[i];

Lowering\LocalRewriter\LocalRewriter_Call.cs (9)

231method.TryGetThisParameter(out var methodThisParameter); 232var interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 233interceptor.TryGetThisParameter(out var interceptorThisParameter) ? interceptorThisParameter : null; 826ImmutableArray<ParameterSymbol> parameters, 1016ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 1155private static ImmutableArray<RefKind> GetEffectiveArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters) 1190static void fillRefKindsBuilder(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters, [NotNull] ref ArrayBuilder<RefKind>? refKindsBuilder) 1304ImmutableArray<ParameterSymbol> parameters, 1600ImmutableArray<ParameterSymbol> parameters,

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

329ImmutableArray<ParameterSymbol> parameters = indexer.Parameters;

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (8)

99var parameter = (ParameterSymbol)variable; 111Debug.Assert(!allVariables.Any((s, method) => s.Symbol is ParameterSymbol { ContainingSymbol: var container } && container != method && container is not SynthesizedPrimaryConstructor, method)); 121!(symbol is ParameterSymbol { ContainingSymbol: var container } && container != method)) // Not interested in force hoisting parameters that do not belong to our method 140ParameterSymbol parameter => 211var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type; 248protected override void EnterParameter(ParameterSymbol parameter) 297var thisSymbol = topLevelMethod.ThisParameter;

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

142var thisParameter = originalMethod.ThisParameter; 963var thisParameter = this.OriginalMethod.ThisParameter;

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (2)

91private readonly ParameterSymbol _parameter; 93public StateMachineFieldSymbolForRegularParameter(NamedTypeSymbol stateMachineType, TypeWithAnnotations type, string name, ParameterSymbol parameter, bool isPublic)

Lowering\StateMachineRewriter\StateMachineRewriter.cs (5)

236var parameter = (ParameterSymbol)variable; 327foreach (var parameter in method.Parameters) 485foreach (var parameter in method.Parameters) 519protected virtual BoundStatement InitializeParameterField(MethodSymbol getEnumeratorMethod, ParameterSymbol parameter, BoundExpression resultParameter, BoundExpression parameterProxy)

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)

56public override ImmutableArray<ParameterSymbol> Parameters

Lowering\SynthesizedMethodBaseSymbol.cs (6)

30private ImmutableArray<ParameterSymbol> _parameters; 107public sealed override ImmutableArray<ParameterSymbol> Parameters 124protected virtual ImmutableArray<ParameterSymbol> BaseMethodParameters 129private ImmutableArray<ParameterSymbol> MakeParameters() 132var builder = ArrayBuilder<ParameterSymbol>.GetInstance(); 135foreach (var p in parameters)

Lowering\SyntheticBoundNodeFactory.cs (4)

186public StateMachineFieldSymbol StateMachineFieldForRegularParameter(TypeSymbol type, string name, ParameterSymbol parameter, bool isPublic) 244public BoundParameter Parameter(ParameterSymbol p) 632public ParameterSymbol SynthesizedParameter(TypeSymbol type, string name, MethodSymbol? container = null, int ordinal = 0) 1340public BoundExpression ParameterId(ParameterSymbol symbol)

Operations\CSharpOperationFactory_Methods.cs (3)

307ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 366ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 376var parameter = parameters[p];

Symbols\AbstractTypeMap.cs (1)

255foreach (var param in f.Signature.Parameters)

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (4)

20private readonly ImmutableArray<ParameterSymbol> _parameters; 29var paramsArr = ArrayBuilder<ParameterSymbol>.GetInstance(fieldsCount); 39_parameters = ImmutableArray<ParameterSymbol>.Empty; 63public override ImmutableArray<ParameterSymbol> Parameters

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.EqualsMethodSymbol.cs (3)

19private readonly ImmutableArray<ParameterSymbol> _parameters; 24_parameters = ImmutableArray.Create<ParameterSymbol>( 48public override ImmutableArray<ParameterSymbol> Parameters

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.GetHashCodeMethodSymbol.cs (2)

52public override ImmutableArray<ParameterSymbol> Parameters 54get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertyAccessorSymbol.cs (2)

49public override ImmutableArray<ParameterSymbol> Parameters 51get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertySymbol.cs (2)

141public override ImmutableArray<ParameterSymbol> Parameters 143get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ToStringMethodSymbol.cs (2)

52public override ImmutableArray<ParameterSymbol> Parameters 54get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\Attributes\SourceAttributeData.cs (2)

242ImmutableArray<ParameterSymbol> parameters = ctor.Parameters; 256bool matches(byte[] targetSignature, ImmutableArray<ParameterSymbol> parameters, ref TypeSymbol? lazySystemType)

Symbols\Compilation_WellKnownMembers.cs (8)

245internal static Symbol? GetRuntimeMember(NamedTypeSymbol declaringType, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt) 251internal static Symbol? GetRuntimeMember(ImmutableArray<Symbol> members, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt) 1005foreach (var param in sig.Parameters) 1061internal class SpecialMembersSignatureComparer : SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> 1131protected override ImmutableArray<ParameterSymbol> GetParameters(MethodSymbol method) 1136protected override ImmutableArray<ParameterSymbol> GetParameters(PropertySymbol property) 1141protected override TypeSymbol GetParamType(ParameterSymbol parameter) 1170protected override bool IsByRefParam(ParameterSymbol parameter)

Symbols\ErrorMethodSymbol.cs (2)

143public override ImmutableArray<ParameterSymbol> Parameters 145get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\ErrorPropertySymbol.cs (2)

86public override ImmutableArray<ParameterSymbol> Parameters { get { return ImmutableArray<ParameterSymbol>.Empty; } }

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (7)

446ImmutableArray<ParameterSymbol> originalParameters, 464var originalParam = originalParameters[i]; 597foreach (var param in Parameters) 611foreach (var param in Parameters) 769public override ImmutableArray<ParameterSymbol> Parameters => 770_parameters.Cast<FunctionPointerParameterSymbol, ParameterSymbol>(); 787foreach (var parameter in this.Parameters)

Symbols\MemberSignatureComparer.cs (4)

760ReadOnlySpan<ParameterSymbol> params1, 762ReadOnlySpan<ParameterSymbol> params2, 774var param1 = params1[i]; 775var param2 = params2[i];

Symbols\MemberSymbolExtensions.cs (4)

33internal static ImmutableArray<ParameterSymbol> GetParameters(this Symbol member) 42return ImmutableArray<ParameterSymbol>.Empty; 208foreach (ParameterSymbol param in method.Parameters) 257foreach (ParameterSymbol param in property.Parameters)

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

367foreach (var param in sig.Parameters)

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

247private static bool ParametersMatch(ParameterSymbol candidateParam, TypeMap candidateMethodTypeMap, ref ParamInfo<TypeSymbol> targetParam)

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

186foreach (var param in type.Signature.Parameters)

Symbols\Metadata\PE\PEMethodSymbol.cs (10)

34public readonly ImmutableArray<ParameterSymbol> Parameters; 37public SignatureData(SignatureHeader header, ImmutableArray<ParameterSymbol> parameters, PEParameterSymbol returnParam) 305public ParameterSymbol _lazyThisParameter; 437internal override bool TryGetThisParameter(out ParameterSymbol thisParameter) 658public override ImmutableArray<ParameterSymbol> Parameters => Signature.Parameters; 847ImmutableArray<ParameterSymbol> @params; 852var builder = ImmutableArray.CreateBuilder<ParameterSymbol>(count); 869@params = ImmutableArray<ParameterSymbol>.Empty; 1124var parameter = parameters[0]; 1481foreach (var param in Parameters)

Symbols\Metadata\PE\PEPropertySymbol.cs (6)

33private readonly ImmutableArray<ParameterSymbol> _parameters; 640public override ImmutableArray<ParameterSymbol> Parameters 880private static ImmutableArray<ParameterSymbol> GetParameters( 893return ImmutableArray<ParameterSymbol>.Empty; 898var parameters = new ParameterSymbol[propertyParams.Length - 1]; 989foreach (var param in Parameters)

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

220var param = type.Signature.Parameters[i];

Symbols\MethodSymbol.cs (5)

279internal ParameterSymbol ThisParameter 283ParameterSymbol thisParameter; 297internal virtual bool TryGetThisParameter(out ParameterSymbol thisParameter) 322public abstract ImmutableArray<ParameterSymbol> Parameters { get; } 1232ImmutableArray<IParameterSymbolInternal> IMethodSymbolInternal.Parameters => Parameters.Cast<ParameterSymbol, IParameterSymbolInternal>();

Symbols\NamedTypeSymbol.cs (1)

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

Symbols\NativeIntegerTypeSymbol.cs (6)

334private ImmutableArray<ParameterSymbol> _lazyParameters; 355public override ImmutableArray<ParameterSymbol> Parameters 361var parameters = UnderlyingMethod.Parameters.SelectAsArray((p, m) => (ParameterSymbol)new NativeIntegerParameterSymbol(m._container, m, p), this); 410internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, NativeIntegerMethodSymbol container, ParameterSymbol underlyingParameter) : base(underlyingParameter) 476public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty;

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

667foreach (ParameterSymbol param in currTypeBestMatch.GetParameters())

Symbols\ParameterSignature.cs (3)

31private static ParameterSignature MakeParamTypesAndRefKinds(ImmutableArray<ParameterSymbol> parameters) 43var parameter = parameters[parm]; 65internal static void PopulateParameterSignature(ImmutableArray<ParameterSymbol> parameters, ref ParameterSignature lazySignature)

Symbols\ParameterSymbol.cs (1)

30public new virtual ParameterSymbol OriginalDefinition

Symbols\PropertySymbol.cs (1)

103public abstract ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\PropertySymbolExtensions.cs (1)

71foreach (ParameterSymbol param in property.Parameters)

Symbols\PublicModel\ParameterSymbol.cs (2)

15private readonly Symbols.ParameterSymbol _underlying; 18public ParameterSymbol(Symbols.ParameterSymbol underlying)

Symbols\ReducedExtensionMethodSymbol.cs (6)

28private ImmutableArray<ParameterSymbol> _lazyParameters; 518public override ImmutableArray<ParameterSymbol> Parameters 556private ImmutableArray<ParameterSymbol> MakeParameters() 564return ImmutableArray<ParameterSymbol>.Empty; 568var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count - 1); 620public ReducedExtensionMethodParameterSymbol(ReducedExtensionMethodSymbol containingMethod, ParameterSymbol underlyingParameter) :

Symbols\Retargeting\RetargetingMethodSymbol.cs (7)

38private ImmutableArray<ParameterSymbol> _lazyParameters; 151public override ImmutableArray<ParameterSymbol> Parameters 164private ImmutableArray<ParameterSymbol> RetargetParameters() 171return ImmutableArray<ParameterSymbol>.Empty; 175var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count); 259internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 261if (!_underlyingMethod.TryGetThisParameter(out var underlyingParameter))

Symbols\Retargeting\RetargetingParameterSymbol.cs (3)

29protected RetargetingParameterSymbol(ParameterSymbol underlyingParameter) 155public RetargetingMethodParameterSymbol(RetargetingMethodSymbol retargetingMethod, ParameterSymbol underlyingParameter) 195public RetargetingPropertyParameterSymbol(RetargetingPropertySymbol retargetingProperty, ParameterSymbol underlyingParameter)

Symbols\Retargeting\RetargetingPropertySymbol.cs (7)

26private ImmutableArray<ParameterSymbol> _lazyParameters; 88public override ImmutableArray<ParameterSymbol> Parameters 94ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, this.RetargetParameters(), default(ImmutableArray<ParameterSymbol>)); 101private ImmutableArray<ParameterSymbol> RetargetParameters() 108return ImmutableArray<ParameterSymbol>.Empty; 112ParameterSymbol[] parameters = new ParameterSymbol[count];

Symbols\Retargeting\RetargetingSymbolTranslator.cs (4)

776foreach (var parameter in signature.Parameters) 1003static ParameterSymbol (param, translator) => new SignatureOnlyParameterSymbol( 1077static ParameterSymbol (param, self) => new SignatureOnlyParameterSymbol( 1354public override Symbol VisitParameter(ParameterSymbol symbol, RetargetOptions options)

Symbols\SignatureOnlyMethodSymbol.cs (3)

26private readonly ImmutableArray<ParameterSymbol> _parameters; 40ImmutableArray<ParameterSymbol> parameters, 87public override ImmutableArray<ParameterSymbol> Parameters { get { return _parameters; } }

Symbols\SignatureOnlyPropertySymbol.cs (3)

23private readonly ImmutableArray<ParameterSymbol> _parameters; 33ImmutableArray<ParameterSymbol> parameters, 58public override ImmutableArray<ParameterSymbol> Parameters { get { return _parameters; } }

Symbols\Source\CustomModifierUtils.cs (7)

26out ImmutableArray<ParameterSymbol> parameters, 115internal static ImmutableArray<ParameterSymbol> CopyParameterCustomModifiers(ImmutableArray<ParameterSymbol> sourceParameters, ImmutableArray<ParameterSymbol> destinationParameters, bool alsoCopyParamsModifier) 123ArrayBuilder<ParameterSymbol> builder = null; 129ParameterSymbol sourceParameter = sourceParameters[i]; 139builder = ArrayBuilder<ParameterSymbol>.GetInstance();

Symbols\Source\ExplicitInterfaceHelpers.cs (2)

397ImmutableArray<ParameterSymbol> implementedMemberParameters = implementedMember.GetParameters(); 398ImmutableArray<ParameterSymbol> collisionCandidateParameters = collisionCandidateMember.GetParameters();

Symbols\Source\LambdaSymbol.cs (6)

21private readonly ImmutableArray<ParameterSymbol> _parameters; 202public override ImmutableArray<ParameterSymbol> Parameters 207internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 282foreach (var parameter in _parameters) 321private ImmutableArray<ParameterSymbol> MakeParameters( 342var builder = ArrayBuilder<ParameterSymbol>.GetInstance(unboundLambda.ParameterCount);

Symbols\Source\LocalFunctionSymbol.cs (5)

25private ImmutableArray<ParameterSymbol> _lazyParameters; 116foreach (var p in _lazyParameters) 174public override ImmutableArray<ParameterSymbol> Parameters 203diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 389internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter)

Symbols\Source\ParameterHelpers.cs (22)

Symbols\Source\SourceComplexParameterSymbol.cs (7)

474ImmutableArray<ParameterSymbol> implParameters = this.ContainingSymbol switch 495ImmutableArray<ParameterSymbol> defParameters = this.ContainingSymbol switch 1269ImmutableArray<ParameterSymbol> containingSymbolParameters = ContainingSymbol.GetParameters(); 1272ArrayBuilder<ParameterSymbol?> parameters; 1283parameters = ArrayBuilder<ParameterSymbol?>.GetInstance(1); 1297parameters = ArrayBuilder<ParameterSymbol?>.GetInstance(constructorArgument.Values.Length); 1330(int Ordinal, ParameterSymbol? Parameter)? decodeName(TypedConstant constant, ref DecodeWellKnownAttributeArguments<AttributeSyntax, CSharpAttributeData, AttributeLocation> arguments)

Symbols\Source\SourceConstructorSymbolBase.cs (4)

19protected ImmutableArray<ParameterSymbol> _lazyParameters; 56diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 96foreach (var parameter in this.Parameters) 123public sealed override ImmutableArray<ParameterSymbol> Parameters

Symbols\Source\SourceDelegateClonedParameterSymbolForBeginAndEndInvoke.cs (1)

29internal override ParameterSymbol WithCustomModifiersAndParams(TypeSymbol newType, ImmutableArray<CustomModifier> newCustomModifiers, ImmutableArray<CustomModifier> newRefCustomModifiers, bool newIsParams)

Symbols\Source\SourceDelegateMethodSymbol.cs (10)

19private ImmutableArray<ParameterSymbol> _parameters; 39protected void InitializeParameters(ImmutableArray<ParameterSymbol> parameters) 115var parameterSymbol = invoke.Parameters[i]; 135public sealed override ImmutableArray<ParameterSymbol> Parameters 219InitializeParameters(ImmutableArray.Create<ParameterSymbol>( 290InitializeParameters(parameters.Cast<SourceParameterSymbol, ParameterSymbol>()); 357var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 397var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 420private static string GetUniqueParameterName(ArrayBuilder<ParameterSymbol> currentParameters, string name) 430private static bool IsUnique(ArrayBuilder<ParameterSymbol> currentParameters, string name)

Symbols\Source\SourceDestructorSymbol.cs (2)

104public override ImmutableArray<ParameterSymbol> Parameters 106get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\Source\SourceEventAccessorSymbol.cs (3)

21private readonly ImmutableArray<ParameterSymbol> _parameters; 49_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedEventAccessorValueParameterSymbol(this, 0)); 178public sealed override ImmutableArray<ParameterSymbol> Parameters

Symbols\Source\SourceMemberContainerSymbol.cs (15)

3948private static bool ParametersMatchPropertyAccessor(PropertySymbol propertySymbol, bool getNotSet, ImmutableArray<ParameterSymbol> methodParams) 3959var methodParam = methodParams[i]; 3979private static bool ParametersMatchEventAccessor(EventSymbol eventSymbol, ImmutableArray<ParameterSymbol> methodParams) 4304ctor.Parameters.SelectAsArray<ParameterSymbol, ParameterSymbol>(param => new SignatureOnlyParameterSymbol(param.TypeWithAnnotations, 4351ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4400ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4460ImmutableArray<ParameterSymbol>.Empty, 4528ImmutableArray<Symbol> addProperties(ImmutableArray<ParameterSymbol> recordParameters) 4532foreach (ParameterSymbol param in recordParameters) 4539ImmutableArray<ParameterSymbol>.Empty, 4610bool checkMemberNotHidden(Symbol symbol, ParameterSymbol param) 4634ImmutableArray<ParameterSymbol>.Empty, 4665ImmutableArray<ParameterSymbol>.Empty, 4727ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (11)

19internal delegate void ReportMismatchInParameterType<TArg>(BindingDiagnosticBag bag, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol parameter, bool topLevel, TArg arg); 1224(BindingDiagnosticBag diagnostics, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol overridingParameter, bool topLevel, Location location) 1293var baseParameter = baseParameters[i]; 1296var overrideParameter = overrideParameters[parameterIndex]; 1330var overrideParam = overrideParameters[i + overrideParameterOffset]; 1331var baseParam = baseParameters[i]; 1456var baseParameter = baseParameters[i]; 1457var overrideParameter = overrideParameters[i + overrideParameterOffset]; 1489ReportMismatchInParameterType<(ParameterSymbol BaseParameter, TArg Arg)> reportMismatchInParameterType, 1507var baseParameter = baseParameters[i]; 1508var overrideParameter = overrideParameters[i + overrideParameterOffset];

Symbols\Source\SourceMemberMethodSymbol.cs (8)

296private ParameterSymbol _lazyThisParameter; 338protected void CheckEffectiveAccessibility(TypeWithAnnotations returnType, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics) 360foreach (var parameter in parameters) 372protected void CheckFileTypeUsage(TypeWithAnnotations returnType, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics) 384foreach (var param in parameters) 814internal sealed override bool TryGetThisParameter(out ParameterSymbol thisParameter) 897foreach (var parameter in this.Parameters) 995foreach (var parameter in Parameters)

Symbols\Source\SourceMethodSymbol.cs (2)

63foreach (var parameter in Parameters) 79static Location getLocation(ParameterSymbol parameter, Location location)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

767foreach (var param in this.Parameters) 1400foreach (var param in Parameters)

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (4)

21private ImmutableArray<ParameterSymbol> _lazyParameters; 40protected MethodSymbol? MethodChecks(TypeWithAnnotations returnType, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics) 176public sealed override ImmutableArray<ParameterSymbol> Parameters 235foreach (var parameter in this.Parameters)

Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)

113private (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters, ImmutableArray<TypeParameterConstraintClause> DeclaredConstraintsForOverrideOrImplementation) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 125ImmutableArray<ParameterSymbol> parameters = ParameterHelpers.MakeParameters( 130diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 177foreach (var param in parameters)

Symbols\Source\SourceParameterSymbol.cs (1)

118internal override ParameterSymbol WithCustomModifiersAndParams(TypeSymbol newType, ImmutableArray<CustomModifier> newCustomModifiers, ImmutableArray<CustomModifier> newRefCustomModifiers, bool newIsParams)

Symbols\Source\SourceParameterSymbolBase.cs (1)

132internal abstract ParameterSymbol WithCustomModifiersAndParams(TypeSymbol newType, ImmutableArray<CustomModifier> newCustomModifiers, ImmutableArray<CustomModifier> newRefCustomModifiers, bool newIsParams);

Symbols\Source\SourcePropertyAccessorSymbol.cs (5)

20private ImmutableArray<ParameterSymbol> _lazyParameters; 325public sealed override ImmutableArray<ParameterSymbol> Parameters 759private ImmutableArray<ParameterSymbol> ComputeParameters() 768return ImmutableArray<ParameterSymbol>.Empty; 771var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(nParameters);

Symbols\Source\SourcePropertyClonedParameterSymbolForAccessors.cs (1)

25internal override ParameterSymbol WithCustomModifiersAndParams(TypeSymbol newType, ImmutableArray<CustomModifier> newCustomModifiers, ImmutableArray<CustomModifier> newRefCustomModifiers, bool newIsParams)

Symbols\Source\SourcePropertySymbol.cs (7)

553protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 599private static ImmutableArray<ParameterSymbol> MakeParameters( 604return ImmutableArray<ParameterSymbol>.Empty; 618diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 640private ImmutableArray<ParameterSymbol> ComputeParameters(Binder binder, CSharpSyntaxNode syntax, BindingDiagnosticBag diagnostics) 653foreach (ParameterSymbol param in Parameters) 663else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName)

Symbols\Source\SourcePropertySymbolBase.cs (4)

60private ImmutableArray<ParameterSymbol> _lazyParameters; 644public sealed override ImmutableArray<ParameterSymbol> Parameters 1765foreach (var parameter in this.Parameters) 1866protected abstract (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics);

Symbols\Source\SourceUserDefinedConversionSymbol.cs (1)

127protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics)

Symbols\Source\SourceUserDefinedOperatorSymbol.cs (1)

127protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics)

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

219protected (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BaseMethodDeclarationSyntax declarationSyntax, TypeSyntax returnTypeSyntax, BindingDiagnosticBag diagnostics) 222ImmutableArray<ParameterSymbol> parameters; 239diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 290protected abstract (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics); 332foreach (var p in this.Parameters)

Symbols\SubstitutedMethodSymbol.cs (8)

30private ImmutableArray<ParameterSymbol> _lazyParameters; 249public sealed override ImmutableArray<ParameterSymbol> Parameters 312internal sealed override bool TryGetThisParameter(out ParameterSymbol thisParameter) 319ParameterSymbol originalThisParameter; 332private ImmutableArray<ParameterSymbol> SubstituteParameters() 339return ImmutableArray<ParameterSymbol>.Empty; 343var substituted = ArrayBuilder<ParameterSymbol>.GetInstance(count); 345foreach (var p in unsubstitutedParameters)

Symbols\SubstitutedParameterSymbol.cs (4)

17internal SubstitutedParameterSymbol(MethodSymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 22internal SubstitutedParameterSymbol(PropertySymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 27private SubstitutedParameterSymbol(Symbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 35public override ParameterSymbol OriginalDefinition

Symbols\SubstitutedPropertySymbol.cs (5)

17private ImmutableArray<ParameterSymbol> _lazyParameters; 73public override ImmutableArray<ParameterSymbol> Parameters 79ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, SubstituteParameters(), default(ImmutableArray<ParameterSymbol>)); 147private ImmutableArray<ParameterSymbol> SubstituteParameters() 158var substituted = new ParameterSymbol[count];

Symbols\Symbol.cs (6)

1234internal bool DeriveUseSiteInfoFromParameter(ref UseSiteInfo<AssemblySymbol> result, ParameterSymbol param) 1243internal bool DeriveUseSiteInfoFromParameters(ref UseSiteInfo<AssemblySymbol> result, ImmutableArray<ParameterSymbol> parameters) 1245foreach (ParameterSymbol param in parameters) 1368internal static bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, ImmutableArray<ParameterSymbol> parameters, Symbol owner, ref HashSet<TypeSymbol> checkedTypes) 1370foreach (var parameter in parameters) 1668builder.AddValue(((ParameterSymbol)this).TypeWithAnnotations);

Symbols\SymbolDistinguisher.cs (1)

147symbol = ((ParameterSymbol)symbol).Type;

Symbols\SymbolExtensions.cs (7)

157internal static ParameterSymbol? EnclosingThisSymbol(this Symbol containingMember) 215public static bool IsSourceParameterWithEnumeratorCancellationAttribute(this ParameterSymbol parameter) 481ParameterSymbol parameter => parameter.FlowAnalysisAnnotations, 523ParameterSymbol parameter = (ParameterSymbol)symbol; 629internal static IParameterSymbol? GetPublicSymbol(this ParameterSymbol? symbol) 739internal static ImmutableArray<IParameterSymbol> GetPublicSymbols(this ImmutableArray<ParameterSymbol> symbols)

Symbols\SymbolVisitor.cs (1)

90public virtual void VisitParameter(ParameterSymbol symbol)

Symbols\SymbolVisitor`1.cs (1)

90public virtual TResult VisitParameter(ParameterSymbol symbol)

Symbols\SymbolVisitor`2.cs (2)

233/// Called when visiting a <see cref="ParameterSymbol" />; Override this with specific 239public virtual TResult VisitParameter(ParameterSymbol symbol, TArgument argument)

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListConstructor.cs (2)

18public override ImmutableArray<ParameterSymbol> Parameters { get; } 31var parameter = Parameters.Single();

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorConstructor.cs (2)

18public override ImmutableArray<ParameterSymbol> Parameters { get; } 31var parameter = Parameters.Single();

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

39public override ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\Synthesized\Records\SynthesizedPrimaryConstructor.cs (10)

17private IReadOnlyDictionary<ParameterSymbol, FieldSymbol>? _capturedParameters = null; 18private IReadOnlySet<ParameterSymbol>? _parametersPassedToTheBase = null; 32_parametersPassedToTheBase = SpecializedCollections.EmptyReadOnlySet<ParameterSymbol>(); 113IReadOnlyDictionary<ParameterSymbol, FieldSymbol> capturedParameters = GetCapturedParameters(); 123public IReadOnlyDictionary<ParameterSymbol, FieldSymbol> GetCapturedParameters() 132_capturedParameters = SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 190public IReadOnlySet<ParameterSymbol> GetParametersPassedToTheBase() 201_parametersPassedToTheBase = SpecializedCollections.EmptyReadOnlySet<ParameterSymbol>(); 207internal void SetParametersPassedToTheBase(IReadOnlySet<ParameterSymbol> value) 219foreach (ParameterSymbol p in Parameters)

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

19public readonly ParameterSymbol ParameterSymbol; 22ParameterSymbol parameterSymbol,

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

25protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 30Parameters: ImmutableArray.Create<ParameterSymbol>( 57ParameterSymbol parameter = Parameters[0];

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

96protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 101Parameters: ImmutableArray<ParameterSymbol>.Empty);

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

34public override ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (4)

31protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 36Parameters: _ctor.Parameters.SelectAsArray<ParameterSymbol, ImmutableArray<Location>, ParameterSymbol>( 63var parameter = Parameters[i];

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

80protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 83ImmutableArray<ParameterSymbol>.Empty);

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

64protected sealed override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 70Parameters: ImmutableArray.Create<ParameterSymbol>(

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

31protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) 38Parameters: ImmutableArray.Create<ParameterSymbol>(

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

29protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) 35Parameters: ImmutableArray<ParameterSymbol>.Empty);

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

26protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) 33Parameters: ImmutableArray.Create<ParameterSymbol>(

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

41protected abstract (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics);

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

89protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 95Parameters: ImmutableArray.Create<ParameterSymbol>(

Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (3)

19ParameterSymbol backingParameter, 93protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 96ImmutableArray<ParameterSymbol>.Empty);

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

38protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 44Parameters: ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)

23: base(accessor, ordinal, RefKind.None, ParameterSymbol.ValueParameterName, accessor.TryGetFirstLocation(),

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (4)

15private readonly ImmutableArray<ParameterSymbol> _parameters; 20_parameters = ImmutableArray.Create<ParameterSymbol>( 25public override ImmutableArray<ParameterSymbol> Parameters 181public override ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (4)

243_constructors = ImmutableArray.Create<MethodSymbol>(new SynthesizedEmbeddedAttributeConstructorSymbol(this, m => ImmutableArray<ParameterSymbol>.Empty)); 251private readonly ImmutableArray<ParameterSymbol> _parameters; 255Func<MethodSymbol, ImmutableArray<ParameterSymbol>> getParameters) : 261public override ImmutableArray<ParameterSymbol> Parameters => _parameters;

Symbols\Synthesized\SynthesizedEmbeddedLifetimeAnnotationAttributeSymbol.cs (1)

24getParameters: m => ImmutableArray<ParameterSymbol>.Empty,

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (2)

49m => ImmutableArray<ParameterSymbol>.Empty, 89private void GenerateBoolArrayConstructorBody(SyntheticBoundNodeFactory factory, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters)

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (7)

76private void GenerateByteArrayConstructorBody(SyntheticBoundNodeFactory factory, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters) 90private void GenerateSingleByteConstructorBody(SyntheticBoundNodeFactory factory, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters) 112private readonly ImmutableArray<ParameterSymbol> _parameters; 114private readonly Action<SyntheticBoundNodeFactory, ArrayBuilder<BoundStatement>, ImmutableArray<ParameterSymbol>> _getConstructorBody; 118Func<MethodSymbol, ImmutableArray<ParameterSymbol>> getParameters, 119Action<SyntheticBoundNodeFactory, ArrayBuilder<BoundStatement>, ImmutableArray<ParameterSymbol>> getConstructorBody) : 126public override ImmutableArray<ParameterSymbol> Parameters => _parameters;

Symbols\Synthesized\SynthesizedEmbeddedNullableContextAttributeSymbol.cs (1)

60private void GenerateConstructorBody(SyntheticBoundNodeFactory factory, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters)

Symbols\Synthesized\SynthesizedEmbeddedNullablePublicOnlyAttributeSymbol.cs (1)

57private void GenerateConstructorBody(SyntheticBoundNodeFactory factory, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters)

Symbols\Synthesized\SynthesizedEmbeddedRefSafetyRulesAttributeSymbol.cs (1)

52private void GenerateConstructorBody(SyntheticBoundNodeFactory factory, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters)

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (6)

336private readonly ImmutableArray<ParameterSymbol> _parameters; 390public override ImmutableArray<ParameterSymbol> Parameters => _parameters; 456public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 532private readonly ImmutableArray<ParameterSymbol> _parameters; 551public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (4)

25private ImmutableArray<ParameterSymbol> _parameters; 53protected void SetParameters(ImmutableArray<ParameterSymbol> parameters) 172public override ImmutableArray<ParameterSymbol> Parameters 179return ImmutableArray<ParameterSymbol>.Empty;

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (4)

12private readonly ImmutableArray<ParameterSymbol> _parameters; 24public override ImmutableArray<ParameterSymbol> Parameters => _parameters; 29public ParameterSymbol MessageParameter => _parameters[0]; 34public ParameterSymbol CodeParameter => _parameters[1];

Symbols\Synthesized\SynthesizedImplementationMethod.cs (2)

25private readonly ImmutableArray<ParameterSymbol> _parameters; 110public sealed override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedInlineArrayAsReadOnlySpanMethod.cs (1)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer"),

Symbols\Synthesized\SynthesizedInlineArrayAsSpanMethod.cs (1)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"),

Symbols\Synthesized\SynthesizedInlineArrayElementRefMethod.cs (1)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"),

Symbols\Synthesized\SynthesizedInlineArrayElementRefReadOnlyMethod.cs (1)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer"),

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefMethod.cs (1)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer")));

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefReadOnlyMethod.cs (1)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer")));

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

35public override ImmutableArray<ParameterSymbol> Parameters 37get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\Synthesized\SynthesizedInstanceMethodSymbol.cs (2)

19private ParameterSymbol _lazyThisParameter; 45internal override bool TryGetThisParameter(out ParameterSymbol thisParameter)

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (2)

134public override ImmutableArray<ParameterSymbol> Parameters 136get { return ImmutableArray<ParameterSymbol>.Empty; }

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (4)

19private readonly ImmutableArray<ParameterSymbol> _parameters; 44_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"), 53_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, container, 0, "value")); 254public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedParameterlessThrowMethod.cs (1)

21this.SetParameters(ImmutableArray<ParameterSymbol>.Empty);

Symbols\Synthesized\SynthesizedParameterSymbol.cs (4)

255public static ParameterSymbol Create( 298internal static ImmutableArray<ParameterSymbol> DeriveParameters(MethodSymbol sourceMethod, MethodSymbol destinationMethod) 305internal static ParameterSymbol DeriveParameter(Symbol destination, ParameterSymbol oldParam)

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (2)

27private readonly ImmutableArray<ParameterSymbol> _parameters; 217public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (2)

24private readonly ImmutableArray<ParameterSymbol> _parameters; 147public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedStaticConstructor.cs (3)

80public override ImmutableArray<ParameterSymbol> Parameters 84return ImmutableArray<ParameterSymbol>.Empty; 88internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter)

Symbols\Synthesized\SynthesizedStringHashFunctionSymbol.cs (2)

21this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s"))); 31this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s")));

Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (3)

14private readonly ImmutableArray<ParameterSymbol> _parameters; 28_parameters = ImmutableArray.Create<ParameterSymbol>( 32public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

29ParameterSymbol unmatchedValue = this.Parameters[0];

Symbols\TypeSymbolExtensions.cs (4)

573public static ImmutableArray<ParameterSymbol> DelegateParameters(this TypeSymbol type) 578return default(ImmutableArray<ParameterSymbol>); 583public static ImmutableArray<ParameterSymbol> DelegateOrFunctionPointerParameters(this TypeSymbol type) 2053foreach (var param in funcPtrType.Signature.Parameters)

Symbols\VarianceSafety.cs (2)

236private static void CheckParametersVarianceSafety(ImmutableArray<ParameterSymbol> parameters, Symbol context, BindingDiagnosticBag diagnostics) 238foreach (ParameterSymbol param in parameters)

Symbols\Wrapped\WrappedParameterSymbol.cs (3)

24protected readonly ParameterSymbol _underlyingParameter; 26protected WrappedParameterSymbol(ParameterSymbol underlyingParameter) 33public ParameterSymbol UnderlyingParameter => _underlyingParameter;

Utilities\TypeSymbolExtensions.cs (1)

118foreach (var param in funcPtr.Signature.Parameters)