ParameterSymbol

Binder\Binder.CapturedParametersFinder.cs (9)

20private readonly ArrayBuilder<ParameterSymbol> _captured; 22private CapturedParametersFinder(SynthesizedPrimaryConstructor primaryConstructor, HashSet<string> namesToCheck, ArrayBuilder<ParameterSymbol> captured) 29public static IReadOnlyDictionary<ParameterSymbol, FieldSymbol> GetCapturedParameters(SynthesizedPrimaryConstructor primaryConstructor) 37return SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 40var captured = ArrayBuilder<ParameterSymbol>.GetInstance(primaryConstructor.Parameters.Length); 72return SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 75var result = new Dictionary<ParameterSymbol, FieldSymbol>(ReferenceEqualityComparer.Instance); 90foreach (var parameter in primaryConstructor.Parameters) 154if (candidate is ParameterSymbol parameter && parameter.ContainingSymbol == (object)_primaryConstructor)

Binder\Binder.ValueChecks.cs (46)

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

2331var lambdaParameter = lambdaSymbol.Parameters[p]; 2332var delegateParameter = delegateParameters[p]; 2397ParameterSymbol lambdaParameter, 2854var delegateParameter = delegateOrFuncPtrParameters[i]; 2855var methodParameter = methodParameters[isExtensionMethod ? i + 1 : i]; 2983internal static ParameterSymbol? GetReceiverParameter(MethodSymbol method)

Binder\Binder_Crefs.cs (6)

514ImmutableArray<ParameterSymbol> parameterSymbols = BindCrefParameters(parameterListSyntax, diagnostics); 586foreach (var param in signature.Parameters) 777private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder<Symbol> candidates, ImmutableArray<ParameterSymbol> parameterSymbols, int arity, MemberCrefSyntax memberSyntax, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics) 948private ImmutableArray<ParameterSymbol> BindCrefParameters(BaseCrefParameterListSyntax parameterListSyntax, BindingDiagnosticBag diagnostics) 950ArrayBuilder<ParameterSymbol> parameterBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameterListSyntax.Parameters.Count);

Binder\Binder_Expressions.cs (22)

460TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, result) is (ParameterSymbol parameter, SyntaxNode syntax) && 489ParameterSymbol parameter, 500ParameterSymbol parameter, 1810if (GetSymbolOrMethodOrPropertyGroup(lookupResult, node, name, node.Arity, members, diagnostics, out bool isError, qualifierOpt: null) is ParameterSymbol shadowedParameter && 2114var parameter = (ParameterSymbol)symbol; 2539ParameterSymbol? thisSymbol = this.ContainingMemberOrLambda.EnclosingThisSymbol(); 3485ImmutableArray<ParameterSymbol> parameters, 3541ImmutableArray<ParameterSymbol> parameters, 3574ImmutableArray<ParameterSymbol> parameters, 3657static ParameterSymbol getCorrespondingParameter(in MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, int arg) 3667ImmutableArray<ParameterSymbol> parameters, 3678var correspondingParameter = getCorrespondingParameter(in memberAnalysisResult, parameters, interpolatedStringArgNum); 3795var parameter = parameters[originalParameterIndex]; 3815var parameter = parameters[originalParameterIndex]; 3888private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter, 5026var parametersPassedToBase = new OrderedSet<ParameterSymbol>(); 5035if (TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, analyzedArguments.Argument(i)) is (ParameterSymbol parameter, SyntaxNode syntax)) 5039var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5130private static (ParameterSymbol, SyntaxNode) TryGetPrimaryConstructorParameterUsedAsValue(SynthesizedPrimaryConstructor primaryConstructor, BoundExpression boundExpression) 10014var parameter = property.Parameters[0];

Binder\Binder_Invocation.cs (18)

1253ParameterSymbol receiverParameter = method.Parameters.First(); 1362private BoundExpression CheckAndConvertExtensionReceiver(BoundExpression receiver, ParameterSymbol extensionParameter, BindingDiagnosticBag diagnostics) 1419private BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, BindingDiagnosticBag diagnostics) 1477internal static ParameterSymbol? GetCorrespondingParameter( 1479ImmutableArray<ParameterSymbol> parameters, 1484ParameterSymbol? parameter; 1521ImmutableArray<ParameterSymbol> parameters, 1536var parameter = GetCorrespondingParameter(i, parameters, argsToParamsOpt, expanded); 1597foreach (var parameter in parameters.AsSpan()[..lastIndex]) 1653BoundExpression bindDefaultArgument(SyntaxNode syntax, ParameterSymbol parameter, Symbol? containingMember, bool enableCallerInfo, BindingDiagnosticBag diagnostics, ArrayBuilder<BoundExpression> argumentsBuilder, int argumentsCount, ImmutableArray<int> argsToParamsOpt) 1772private BoundExpression CreateParamsCollection(SyntaxNode node, ParameterSymbol paramsParameter, ImmutableArray<BoundExpression> collectionArgs, BindingDiagnosticBag diagnostics) 1903!(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. 2047var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2067var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2086private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedArguments analyzedArguments, IEnumerable<ImmutableArray<ParameterSymbol>> parameterListList) 2220private static TypeSymbol GetCorrespondingParameterType(AnalyzedArguments analyzedArguments, int i, ImmutableArray<ParameterSymbol> parameterList) 2226foreach (var parameter in parameterList) 2243return BuildArgumentsForErrorRecovery(analyzedArguments, Enumerable.Empty<ImmutableArray<ParameterSymbol>>());

Binder\Binder_Lookup.cs (1)

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

3036ParameterSymbol parameterSymbol = parameterAccess.ParameterSymbol;

Binder\Binder_Patterns.cs (1)

1068ParameterSymbol? parameter = null;

Binder\Binder_Symbols.cs (2)

1449if (IsPossiblyCapturingPrimaryConstructorParameterReference(colorColorValueReceiver, out ParameterSymbol parameter)) 1514private bool IsPossiblyCapturingPrimaryConstructorParameterReference(BoundExpression colorColorValueReceiver, out ParameterSymbol parameterSymbol)

Binder\BinderFactory.BinderFactoryVisitor.cs (4)

1244if (isParamRef && method.TryGetInstanceExtensionParameter(out var _)) 1281ImmutableArray<ParameterSymbol> parameters = property.Parameters; 1283if (isParamRef && property.TryGetInstanceExtensionParameter(out var _)) 1310ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

Binder\ExecutableCodeBinder.cs (1)

112foreach (var parameter in 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)

312ParameterSymbol parameter when parameter.ContainingSymbol is not NamedTypeSymbol => getAllParameters(parameter), 324static ImmutableArray<ParameterSymbol> getAllParameters(ParameterSymbol parameter) 338static ImmutableArray<ParameterSymbol> getMethodParametersFromTypeParameter(TypeParameterSymbol typeParameter) 352static ImmutableArray<ParameterSymbol> getDelegateParameters(NamedTypeSymbol delegateType) 364static ImmutableArray<ParameterSymbol> getSetterParameters(SourcePropertyAccessorSymbol setter)

Binder\RefSafetyAnalysis.cs (2)

640static ParameterSymbol? tryGetThisParameter(MethodSymbol method) 647return 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) 335ParameterSymbol thisParameter; 421public static void GetDelegateOrFunctionPointerArguments(SyntaxNode syntax, AnalyzedArguments analyzedArguments, ImmutableArray<ParameterSymbol> delegateParameters, CSharpCompilation compilation) 423foreach (var p in delegateParameters) 425ParameterSymbol parameter = p;

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

3396var sourceParam = sourceSig.Parameters[i]; 3397var destinationParam = destinationSig.Parameters[i];

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

1033foreach (var parameter in parameters) 1504ImmutableArray<ParameterSymbol> delegateParameters, 2446var sourceParam = sourceSignature.Parameters[i]; 2447var targetParam = targetSignature.Parameters[i]; 2796var sourceParam = sourceSignature.Parameters[i]; 2797var targetParam = targetSignature.Parameters[i];

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

1312ParameterSymbol final = member.GetParameters().Last(); 2091private static ParameterSymbol GetParameterOrExtensionParameter<TMember>(int argIndex, MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, TMember member) 2098ParameterSymbol? extensionParameter = member.ContainingType.ExtensionParameter; 2561var parameter1 = GetParameterOrExtensionParameter(i, m1.Result, m1LeastOverriddenParameters, m1.LeastOverriddenMember); 2562var parameter2 = GetParameterOrExtensionParameter(i, m2.Result, m2LeastOverriddenParameters, m2.LeastOverriddenMember); 2590static TypeSymbol getParameterTypeAndRefKind(int i, MemberAnalysisResult memberResolutionResult, ImmutableArray<ParameterSymbol> parameters, 2593ParameterSymbol parameter = GetParameterOrExtensionParameter(i, memberResolutionResult, parameters, member); 2638ImmutableArray<ParameterSymbol> parameters1, 2640ImmutableArray<ParameterSymbol> parameters2) 2649var p1 = GetParameterOrExtensionParameter(i, m1.Result, parameters1, m1.Member); 2650var p2 = GetParameterOrExtensionParameter(i, m2.Result, parameters2, m2.Member); 3759private static bool IdenticalParameters(ImmutableArray<ParameterSymbol> p1, ImmutableArray<ParameterSymbol> p2) 3774var param1 = p1[i]; 3775var param2 = p2[i]; 3885ImmutableArray<ParameterSymbol> parameters = member.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 3919var parameter = parameters[parm]; 3944ParameterSymbol parameter, 4056var parameter = parameters[parm];

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

74ImmutableArray<ParameterSymbol> parameters = symbol.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 240ImmutableArray<ParameterSymbol> memberParameters, 348ImmutableArray<ParameterSymbol> parameters, 388private static bool CanBeOptional(ParameterSymbol parameter, bool isMethodGroupConversion) 441ImmutableArray<ParameterSymbol> parameters,

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

898ImmutableArray<ParameterSymbol> parameters = badMember.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 1189ParameterSymbol parameter = parameters[parm]; 1370static bool isStringLiteralToInterpolatedStringHandlerArgumentConversion(BoundExpression argument, ParameterSymbol parameter) 1379static 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\BoundTreeRewriter.cs (3)

100public virtual ParameterSymbol VisitParameterSymbol(ParameterSymbol symbol) 139return VisitParameterSymbol((ParameterSymbol)symbol);

BoundTree\Constructors.cs (2)

492public BoundParameter(SyntaxNode syntax, ParameterSymbol parameterSymbol, bool hasErrors = false) 497public BoundParameter(SyntaxNode syntax, ParameterSymbol parameterSymbol)

BoundTree\NullabilityRewriter.cs (1)

144case ParameterSymbol param:

BoundTree\UnboundLambda.cs (2)

1130foreach (var p in invoke.Parameters) 1286foreach (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)

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

Compilation\CSharpSemanticModel.cs (12)

1791case ParameterSymbol _: 3231protected ParameterSymbol GetParameterSymbol( 3232ImmutableArray<ParameterSymbol> parameters, 3236foreach (var symbol in parameters) 3694var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind); 3739private static ParameterSymbol GetThisParameter(TypeSymbol typeOfThis, NamedTypeSymbol containingType, Symbol containingMember, out LookupResultKind resultKind) 3748ParameterSymbol thisParam; 4520ParameterSymbol param = FindNamedParameter(containingInvocationInfo.Symbol.GetSymbol().GetParameters(), argumentName); 4537ParameterSymbol param = FindNamedParameter(invocationSym.GetSymbol().GetParameters(), argumentName); 4559private static ParameterSymbol FindNamedParameter(ImmutableArray<ParameterSymbol> parameters, string argumentName) 4561foreach (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 (10)

1018var parameterSymbol = containing.GetDeclaredSymbol(paramDecl).GetSymbol<ParameterSymbol>(); 1154ParameterSymbol parameterSymbol = GetDeclaredNonLambdaParameterSymbol(parameterDecl); 2030private ParameterSymbol GetExtensionParameterSymbol( 2054return extensionParameter.GetSymbol<ParameterSymbol>(); 2061private ParameterSymbol GetMethodParameterSymbol( 2098private ParameterSymbol GetIndexerParameterSymbol( 2125private ParameterSymbol GetDelegateParameterSymbol( 2178private ParameterSymbol GetDeclaredNonLambdaParameterSymbol(ParameterSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) 2442Debug.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)

364HashSet<ParameterSymbol> documentedParameters; 416foreach (ParameterSymbol parameter in GetParameters(symbol)) 533out HashSet<ParameterSymbol> documentedParameters, 650private static ImmutableArray<ParameterSymbol> GetParameters(Symbol symbol) 667return ImmutableArray<ParameterSymbol>.Empty; 1164ref HashSet<ParameterSymbol> documentedParameters, 1177documentedParameters = new HashSet<ParameterSymbol>(); 1231ParameterSymbol 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)

1258IReadOnlyDictionary<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)

374public override Symbol VisitParameter(ParameterSymbol parameter) 414foreach (var param in sig.Parameters) 659private bool AreParametersEqual(ParameterSymbol parameter, ParameterSymbol other) 692private bool AreFunctionPointerParametersEqual(ParameterSymbol param, ParameterSymbol otherParam) 931foreach (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)

1363internal ImmutableArray<Cci.IParameterTypeInformation> Translate(ImmutableArray<ParameterSymbol> @params) 1373return @params.SelectAsArray<ParameterSymbol, Cci.IParameterTypeInformation>(p => p.GetCciAdapter()); 1382private static bool MustBeWrapped(ParameterSymbol param) 1402private ImmutableArray<Cci.IParameterTypeInformation> TranslateAll(ImmutableArray<ParameterSymbol> @params) 1405foreach (var param in @params) 1412private Cci.IParameterTypeInformation CreateParameterTypeInformationWrapper(ParameterSymbol param) 1502internal SynthesizedAttributeData SynthesizeRequiresLocationAttribute(ParameterSymbol symbol) 1513internal SynthesizedAttributeData SynthesizeParamCollectionAttribute(ParameterSymbol symbol) 1682internal 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)

629ImmutableArray<ParameterSymbol> underlyingParameters)

FlowAnalysis\AbstractFlowPass.cs (12)

315protected virtual void EnterParameters(ImmutableArray<ParameterSymbol> parameters) 317foreach (var parameter in parameters) 323protected virtual void EnterParameter(ParameterSymbol parameter) 327ImmutableArray<ParameterSymbol> parameters, 331foreach (ParameterSymbol parameter in parameters) 337protected virtual void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location) 465protected ImmutableArray<ParameterSymbol> MethodParameters 470return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 478protected ParameterSymbol MethodThisParameter 482ParameterSymbol thisParameter = null; 1437else if (method.TryGetThisParameter(out var thisParameter) 3024var param = method.Parameters[0];

FlowAnalysis\AbstractRegionDataFlowPass.cs (3)

37if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter)) 61private void MakeSlots(ImmutableArray<ParameterSymbol> parameters) 64foreach (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; 371ParameterSymbol extensionParameter = null; 457protected 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) 1836if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter)) 1888protected override void EnterParameter(ParameterSymbol parameter) 1944protected override void LeaveParameters(ImmutableArray<ParameterSymbol> parameters, SyntaxNode syntax, Location location) 1955protected override void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location)

FlowAnalysis\NullableWalker.cs (78)

FlowAnalysis\NullableWalker.Variables.cs (1)

358case ParameterSymbol:

FlowAnalysis\ReadWriteWalker.cs (6)

85foreach (var p in m.Parameters) 90if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter) && extensionParameter.RefKind != RefKind.None) 99var thisParameter = m.ThisParameter; 130protected override void NoteRead(Symbol variable, ParameterSymbol rangeVariableUnderlyingParameter = null) 291ParameterSymbol rangeVariableUnderlyingParameter = GetRangeVariableUnderlyingParameter(node.Value); 300private 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 (17)

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; 164ParameterSymbol? thisParameter, 207Debug.Assert(localOrParameter is LocalSymbol || localOrParameter is ParameterSymbol || 234ParameterSymbol? thisParameter, 614var potentialParameter = lambda.Parameters[i]; 758var parameter = (ParameterSymbol)symbol; 759ParameterSymbol parameterToUse; 826ParameterSymbol replacementParameter; 1554foreach (var parameter in node.Symbol.Parameters) 1561var 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)

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

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

617foreach (var p in lambda.Parameters)

Lowering\ExtensionMethodBodyRewriter.cs (5)

54private (RewrittenMethodSymbol, ImmutableDictionary<Symbol, Symbol>) EnterMethod(MethodSymbol symbol, RewrittenMethodSymbol rewritten, ReadOnlySpan<ParameterSymbol> rewrittenParameters) 64foreach (var parameter in symbol.Parameters) 90public override ParameterSymbol VisitParameterSymbol(ParameterSymbol symbol) 92return (ParameterSymbol)_symbolMap[symbol];

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

231method.TryGetThisParameter(out var methodThisParameter); 828ImmutableArray<ParameterSymbol> parameters, 1018ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 1157private static ImmutableArray<RefKind> GetEffectiveArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters) 1192static void fillRefKindsBuilder(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters, [NotNull] ref ArrayBuilder<RefKind>? refKindsBuilder) 1320ImmutableArray<ParameterSymbol> parameters, 1616ImmutableArray<ParameterSymbol> parameters,

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

387ImmutableArray<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) 299var thisSymbol = topLevelMethod.ThisParameter;

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

142var thisParameter = originalMethod.ThisParameter; 970var 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; 91public sealed override ImmutableArray<ParameterSymbol> Parameters 108protected virtual ImmutableArray<ParameterSymbol> BaseMethodParameters 113private ImmutableArray<ParameterSymbol> MakeParameters() 116var builder = ArrayBuilder<ParameterSymbol>.GetInstance(); 119foreach (var p in parameters)

Lowering\SyntheticBoundNodeFactory.cs (4)

186public StateMachineFieldSymbol StateMachineFieldForRegularParameter(TypeSymbol type, string name, ParameterSymbol parameter, bool isPublic) 244public BoundParameter Parameter(ParameterSymbol p) 637public ParameterSymbol SynthesizedParameter(TypeSymbol type, string name, MethodSymbol? container = null, int ordinal = 0) 1350public 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\PublicSymbols\AnonymousManager.TypeOrDelegatePublicSymbol.cs (1)

49internal sealed override ParameterSymbol? ExtensionParameter => null;

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\AnonymousTypes\SynthesizedSymbols\AnonymousType.TypeOrDelegateTemplateSymbol.cs (1)

127internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\ArrayTypeSymbol.cs (1)

238internal sealed override ParameterSymbol? ExtensionParameter => null;

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\DynamicTypeSymbol.cs (1)

109internal sealed override ParameterSymbol? ExtensionParameter => null;

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\ErrorTypeSymbol.cs (1)

108internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\Extensions\ReceiverParameterSymbol.cs (1)

11public ReceiverParameterSymbol(NamedTypeSymbol containingType, ParameterSymbol originalParameter) :

Symbols\Extensions\RewrittenLambdaOrLocalFunctionSymbol.cs (4)

19Debug.Assert(lambdaOrLocalFunctionSymbol.TryGetThisParameter(out var thisParameter) && thisParameter is null); 27internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 36protected override ImmutableArray<ParameterSymbol> MakeParameters() 38return ImmutableArray<ParameterSymbol>.CastUp(_originalMethod.Parameters.SelectAsArray(static (p, @this) => new RewrittenMethodParameterSymbol(@this, p), this));

Symbols\Extensions\RewrittenMethodSymbol.cs (4)

16private ImmutableArray<ParameterSymbol> _lazyParameters; 94public sealed override ImmutableArray<ParameterSymbol> Parameters 106protected abstract ImmutableArray<ParameterSymbol> MakeParameters(); 118public RewrittenMethodParameterSymbol(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter) :

Symbols\Extensions\RewrittenParameterSymbol.cs (1)

12public RewrittenParameterSymbol(ParameterSymbol originalParameter) :

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (5)

99protected override ImmutableArray<ParameterSymbol> MakeParameters() 102var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(ParameterCount); 111foreach (var parameter in sourceParameters) 120internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 152public ExtensionMetadataMethodParameterSymbol(SourceExtensionImplementationMethodSymbol containingMethod, ParameterSymbol sourceParameter) :

Symbols\Extensions\SynthesizedExtensionMarker.cs (4)

50protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 55ParameterSymbol? makeExtensionParameter(BindingDiagnosticBag diagnostics) 76ParameterSymbol? parameter = ParameterHelpers.MakeExtensionReceiverParameter(withTypeParametersBinder: signatureBinder, owner: this, parameterList, diagnostics); 116static void checkUnderspecifiedGenericExtension(ParameterSymbol parameter, ImmutableArray<TypeParameterSymbol> typeParameters, BindingDiagnosticBag diagnostics)

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\FunctionPointers\FunctionPointerTypeSymbol.cs (1)

75internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\FunctionTypeSymbol.cs (1)

102internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\MemberSignatureComparer.cs (4)

760ReadOnlySpan<ParameterSymbol> params1, 762ReadOnlySpan<ParameterSymbol> params2, 784ParameterSymbol param1, 786ParameterSymbol param2,

Symbols\MemberSymbolExtensions.cs (6)

35internal static ImmutableArray<ParameterSymbol> GetParameters(this Symbol member) 44return ImmutableArray<ParameterSymbol>.Empty; 105internal static bool TryGetInstanceExtensionParameter(this Symbol symbol, [NotNullWhen(true)] out ParameterSymbol? extensionParameter) 180internal static ImmutableArray<ParameterSymbol> GetParametersIncludingExtensionParameter(this Symbol symbol, bool skipExtensionIfStatic) 442foreach (ParameterSymbol param in method.Parameters) 491foreach (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; 1125var parameter = parameters[0]; 1542foreach (var param in Parameters)

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

186public StrongBox<ParameterSymbol?>? LazyExtensionParameter; 386internal sealed override ParameterSymbol? ExtensionParameter 399var extensionParameter = makeExtensionParameter(this, uncommon); 400Interlocked.CompareExchange(ref uncommon.LazyExtensionParameter, new StrongBox<ParameterSymbol?>(extensionParameter), null); 405static ParameterSymbol? makeExtensionParameter(PENamedTypeSymbol @this, ExtensionInfo uncommon)

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

187internal sealed override ParameterSymbol? ExtensionParameter => null; 336private ImmutableArray<ParameterSymbol> _lazyParameters; 357public override ImmutableArray<ParameterSymbol> Parameters 363var parameters = UnderlyingMethod.Parameters.SelectAsArray((p, m) => (ParameterSymbol)new NativeIntegerParameterSymbol(m._container, m, p), this); 415internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, NativeIntegerMethodSymbol container, ParameterSymbol underlyingParameter) : base(underlyingParameter) 483public 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\PointerTypeSymbol.cs (1)

109internal sealed override ParameterSymbol? ExtensionParameter => null;

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\RetargetingNamedTypeSymbol.cs (3)

42private StrongBox<ParameterSymbol> _lazyExtensionParameter; 96internal sealed override ParameterSymbol ExtensionParameter 105Interlocked.CompareExchange(ref _lazyExtensionParameter, new StrongBox<ParameterSymbol>(extensionParameter), null);

Symbols\Retargeting\RetargetingParameterSymbol.cs (4)

29protected RetargetingParameterSymbol(ParameterSymbol underlyingParameter) 171public RetargetingMethodParameterSymbol(RetargetingMethodSymbol retargetingMethod, ParameterSymbol underlyingParameter) 193public RetargetingPropertyParameterSymbol(RetargetingPropertySymbol retargetingProperty, ParameterSymbol underlyingParameter) 215public RetargetingExtensionReceiverParameterSymbol(RetargetingNamedTypeSymbol retargetingType, 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\ImplicitNamedTypeSymbol.cs (1)

178internal sealed override ParameterSymbol ExtensionParameter => null;

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>(); 394internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter)

Symbols\Source\ParameterHelpers.cs (24)

Symbols\Source\SourceComplexParameterSymbol.cs (7)

474ImmutableArray<ParameterSymbol> implParameters = this.ContainingSymbol.GetPartialImplementationPart()?.GetParameters() ?? default; 490ImmutableArray<ParameterSymbol> defParameters = this.ContainingSymbol.GetPartialDefinitionPart()?.GetParameters() ?? default; 1259ImmutableArray<ParameterSymbol> containingSymbolParameters = ContainingSymbol.GetParameters(); 1262ArrayBuilder<ParameterSymbol?> parameters; 1273parameters = ArrayBuilder<ParameterSymbol?>.GetInstance(1); 1287parameters = ArrayBuilder<ParameterSymbol?>.GetInstance(constructorArgument.Values.Length); 1320(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) 130public 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_ImplementationChecks.cs (11)

19internal delegate void ReportMismatchInParameterType<TArg>(BindingDiagnosticBag bag, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol parameter, bool topLevel, TArg arg); 1229(BindingDiagnosticBag diagnostics, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol overridingParameter, bool topLevel, Location location) 1298var baseParameter = baseParameters[i]; 1301var overrideParameter = overrideParameters[parameterIndex]; 1335var overrideParam = overrideParameters[i + overrideParameterOffset]; 1336var baseParam = baseParameters[i]; 1473var baseParameter = baseParameters[i]; 1474var overrideParameter = overrideParameters[i + overrideParameterOffset]; 1506ReportMismatchInParameterType<(ParameterSymbol BaseParameter, TArg Arg)> reportMismatchInParameterType, 1524var baseParameter = baseParameters[i]; 1525var overrideParameter = overrideParameters[i + overrideParameterOffset];

Symbols\Source\SourceMemberMethodSymbol.cs (8)

308private ParameterSymbol _lazyThisParameter; 350protected void CheckEffectiveAccessibility(TypeWithAnnotations returnType, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics) 372foreach (var parameter in parameters) 393protected void CheckFileTypeUsage(TypeWithAnnotations returnType, ImmutableArray<ParameterSymbol> parameters, BindingDiagnosticBag diagnostics) 412foreach (var param in parameters) 842internal sealed override bool TryGetThisParameter(out ParameterSymbol thisParameter) 925foreach (var parameter in this.Parameters) 1023foreach (var parameter in Parameters)

Symbols\Source\SourceMethodSymbol.cs (2)

68foreach (var parameter in parameters) 86static Location getLocation(ParameterSymbol parameter, Location location, bool isReceiverParameter)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

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

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (2)

25public ParameterSymbol? LazyExtensionParameter; 66internal sealed override ParameterSymbol? ExtensionParameter

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 766private ImmutableArray<ParameterSymbol> ComputeParameters() 775return ImmutableArray<ParameterSymbol>.Empty; 778var 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 (9)

566protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 621private static ImmutableArray<ParameterSymbol> MakeParameters( 626return ImmutableArray<ParameterSymbol>.Empty; 640diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 662private ImmutableArray<ParameterSymbol> ComputeParameters(Binder binder, CSharpSyntaxNode syntax, BindingDiagnosticBag diagnostics) 681foreach (ParameterSymbol param in Parameters) 691else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName) 699if (ContainingType.TypeParameters.Any(static tp => tp.Name == ParameterSymbol.ValueParameterName)) 704if (ContainingType.ExtensionParameter is { Name: ParameterSymbol.ValueParameterName })

Symbols\Source\SourcePropertySymbolBase.cs (4)

61private ImmutableArray<ParameterSymbol> _lazyParameters; 667public sealed override ImmutableArray<ParameterSymbol> Parameters 1790foreach (var parameter in this.Parameters) 1899protected abstract (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics);

Symbols\Source\SourceUserDefinedConversionSymbol.cs (1)

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

Symbols\Source\SourceUserDefinedOperatorSymbol.cs (1)

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

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

303protected (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BaseMethodDeclarationSyntax declarationSyntax, TypeSyntax returnTypeSyntax, BindingDiagnosticBag diagnostics) 306ImmutableArray<ParameterSymbol> parameters; 323diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 374protected abstract (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics); 416foreach (var p in this.Parameters)

Symbols\Source\SynthesizedSourceOrdinaryMethodSymbol.cs (1)

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

Symbols\SubstitutedMethodSymbol.cs (8)

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

Symbols\SubstitutedNamedTypeSymbol.cs (5)

44private StrongBox<ParameterSymbol?> _lazyExtensionParameter; 496internal sealed override ParameterSymbol? ExtensionParameter 502Interlocked.CompareExchange(ref _lazyExtensionParameter, new StrongBox<ParameterSymbol?>(substituteParameter()), null); 507ParameterSymbol? substituteParameter() 514var unsubstitutedParameter = OriginalDefinition.ExtensionParameter;

Symbols\SubstitutedParameterSymbol.cs (5)

17internal SubstitutedParameterSymbol(MethodSymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 22internal SubstitutedParameterSymbol(PropertySymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 27internal SubstitutedParameterSymbol(NamedTypeSymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 32private SubstitutedParameterSymbol(Symbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 40public 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 (7)

1235internal bool DeriveUseSiteInfoFromParameter(ref UseSiteInfo<AssemblySymbol> result, ParameterSymbol param) 1244internal bool DeriveUseSiteInfoFromParameters(ref UseSiteInfo<AssemblySymbol> result, ImmutableArray<ParameterSymbol> parameters) 1246foreach (ParameterSymbol param in parameters) 1369internal static bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, ImmutableArray<ParameterSymbol> parameters, Symbol owner, ref HashSet<TypeSymbol> checkedTypes) 1371foreach (var parameter in parameters) 1669builder.AddValue(((ParameterSymbol)this).TypeWithAnnotations); 1745&& variable is ParameterSymbol { ContainingSymbol: TypeSymbol { IsExtension: true } })

Symbols\SymbolDistinguisher.cs (1)

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

Symbols\SymbolExtensions.cs (8)

157internal static ParameterSymbol? EnclosingThisSymbol(this Symbol containingMember) 468ParameterSymbol parameter => parameter.FlowAnalysisAnnotations, 510ParameterSymbol parameter = (ParameterSymbol)symbol; 616internal static IParameterSymbol? GetPublicSymbol(this ParameterSymbol? symbol) 726internal static ImmutableArray<IParameterSymbol> GetPublicSymbols(this ImmutableArray<ParameterSymbol> symbols) 823internal static bool IsExtensionParameter(this ParameterSymbol parameter) 828internal static bool IsExtensionParameterImplementation(this ParameterSymbol parameter)

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\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

179internal sealed override ParameterSymbol? ExtensionParameter => null;

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

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

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

856internal sealed override ParameterSymbol? ExtensionParameter => null;

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)

65protected sealed override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 71Parameters: 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\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\SynthesizedContainer.cs (1)

49internal sealed override ParameterSymbol ExtensionParameter => null;

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

120internal sealed override ParameterSymbol ExtensionParameter => null; 248_constructors = ImmutableArray.Create<MethodSymbol>(new SynthesizedEmbeddedAttributeConstructorSymbol(this, m => ImmutableArray<ParameterSymbol>.Empty)); 256private readonly ImmutableArray<ParameterSymbol> _parameters; 260Func<MethodSymbol, ImmutableArray<ParameterSymbol>> getParameters) : 266public 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\SynthesizedHotReloadExceptionSymbol.cs (1)

113internal sealed override ParameterSymbol? ExtensionParameter => null;

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\SynthesizedInlineArrayTypeSymbol.cs (1)

110internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

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

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\SynthesizedMethodSymbol.cs (2)

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

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\SynthesizedPrivateImplementationDetailsType.cs (1)

93internal sealed override ParameterSymbol? ExtensionParameter => null;

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\TypeParameterSymbol.cs (1)

594internal sealed override ParameterSymbol ExtensionParameter => null;

Symbols\TypeSymbol.cs (1)

565internal abstract ParameterSymbol? ExtensionParameter { get; }

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)

239private static void CheckParametersVarianceSafety(ImmutableArray<ParameterSymbol> parameters, Symbol context, BindingDiagnosticBag diagnostics) 241foreach (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)