ParameterSymbol

Binder\Binder.CapturedParametersFinder.cs (10)

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); 78foreach (var parameter in captured) 91foreach (var parameter in primaryConstructor.Parameters) 155if (candidate is ParameterSymbol parameter && parameter.ContainingSymbol == (object)_primaryConstructor)

Binder\Binder.ValueChecks.cs (34)

125public ImmutableArray<ParameterSymbol> Parameters; 357internal ParameterSymbol? Parameter { get; } 366internal MixableDestination(ParameterSymbol parameter, BoundExpression argument) 402internal ParameterSymbol? Parameter { get; } 408internal EscapeArgument(ParameterSymbol? parameter, BoundExpression argument, RefKind refKind, bool isArgList = false) 416public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out RefKind refKind) 438internal ParameterSymbol? Parameter { get; } 451internal EscapeValue(ParameterSymbol? parameter, BoundExpression argument, EscapeLevel escapeLevel, bool isRefEscape) 459public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out EscapeLevel escapeLevel, out bool isRefEscape) 1412ParameterSymbol parameterSymbol = parameter.ParameterSymbol; 1469static void reportReadOnlyParameterError(ParameterSymbol parameterSymbol, SyntaxNode node, BindValueKind valueKind, bool checkingReceiver, BindingDiagnosticBag diagnostics) 1525private static SafeContext GetParameterValEscape(ParameterSymbol parameter) 1535private static EscapeLevel? GetParameterValEscapeLevel(ParameterSymbol parameter) => 1538private static SafeContext GetParameterRefEscape(ParameterSymbol parameter) 1550private static EscapeLevel? GetParameterRefEscapeLevel(ParameterSymbol parameter) => 1553private bool CheckParameterValEscape(SyntaxNode node, ParameterSymbol parameter, SafeContext escapeTo, BindingDiagnosticBag diagnostics) 1571private bool CheckParameterRefEscape(SyntaxNode node, BoundExpression parameter, ParameterSymbol parameterSymbol, SafeContext escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics) 2432var extensionParameter = symbol.ContainingType.ExtensionParameter; 2715var parameter = argIndex < parameters.Length ? 2743static bool isMixableParameter([NotNullWhen(true)] ParameterSymbol? parameter) => 2795ParameterSymbol? thisParameter = null; 2900ParameterSymbol? extensionReceiver = null; 2957return method?.TryGetThisParameter(out var thisParameter) == true && thisParameter is not null && 2961static bool isRefToRefStruct(ParameterSymbol parameter) 3127private static string GetInvocationParameterName(ParameterSymbol? parameter) 3144ParameterSymbol? parameter, 3383private readonly ParameterSymbol _underlyingParameter; 3385internal TypeParameterThisParameterSymbol(ParameterSymbol underlyingParameter, TypeParameterSymbol type) 3777var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4072var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4384var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5081var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5752ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5792ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

Binder\Binder_Attributes.cs (4)

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

Binder\Binder_Await.cs (1)

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

Binder\Binder_Conversions.cs (8)

1435var readonlySpanParameter = collectionBuilderMethod.Parameters.Last(); 2969if (SourceMemberContainerTypeSymbol.RequiresValidScopedOverrideForRefSafety(delegateMethod, lambdaOrMethod.TryGetThisParameter(out var thisParameter) ? thisParameter : null)) 3011var lambdaParameter = lambdaSymbol.Parameters[p]; 3012var delegateParameter = delegateParameters[p]; 3077ParameterSymbol lambdaParameter, 3557var delegateParameter = delegateOrFuncPtrParameters[i]; 3558var methodParameter = methodParameters[isExtensionMethod ? i + 1 : i]; 3686internal static ParameterSymbol? GetReceiverParameter(MethodSymbol method)

Binder\Binder_Crefs.cs (7)

271ImmutableArray<ParameterSymbol> extensionParameterSymbols = BindCrefParameters(syntax.Parameters, diagnostics); 694ImmutableArray<ParameterSymbol> parameterSymbols = BindCrefParameters(parameterListSyntax, diagnostics); 766foreach (var param in signature.Parameters) 959private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder<Symbol> candidates, ImmutableArray<ParameterSymbol> parameterSymbols, int arity, MemberCrefSyntax memberSyntax, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics) 1130private ImmutableArray<ParameterSymbol> BindCrefParameters(BaseCrefParameterListSyntax parameterListSyntax, BindingDiagnosticBag diagnostics) 1132ArrayBuilder<ParameterSymbol> parameterBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameterListSyntax.Parameters.Count);

Binder\Binder_Expressions.cs (25)

492TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, result) is (ParameterSymbol parameter, SyntaxNode syntax) && 521ParameterSymbol parameter, 532ParameterSymbol parameter, 1832private ParameterSymbol GetShadowedPrimaryConstructorParameter(SimpleNameSyntax node, Symbol symbol, bool invoked, ArrayBuilder<Symbol> membersOpt) 1879if (singleSymbol is ParameterSymbol shadowedParameter && 2082var parameter = (ParameterSymbol)symbol; 2615ParameterSymbol? thisSymbol = this.ContainingMemberOrLambda.EnclosingThisSymbol(); 3561ImmutableArray<ParameterSymbol> parameters, 3617ImmutableArray<ParameterSymbol> parameters, 3650ImmutableArray<ParameterSymbol> parameters, 3733static ParameterSymbol getCorrespondingParameter(in MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, int arg) 3743ImmutableArray<ParameterSymbol> parameters, 3755var correspondingParameter = getCorrespondingParameter(in result, parameters, interpolatedStringArgNum); 3872var receiverParameter = ((NamedTypeSymbol)methodResult.Member.ContainingSymbol).ExtensionParameter; 3882var parameter = parameters[originalParameterIndex]; 3902var parameter = parameters[originalParameterIndex]; 3977private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter, 5116var parametersPassedToBase = new OrderedSet<ParameterSymbol>(); 5125if (TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, analyzedArguments.Argument(i)) is (ParameterSymbol parameter, SyntaxNode syntax)) 5129var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5222private static (ParameterSymbol, SyntaxNode) TryGetPrimaryConstructorParameterUsedAsValue(SynthesizedPrimaryConstructor primaryConstructor, BoundExpression boundExpression) 7727leftType = ((ParameterSymbol)leftSymbol).Type; 10286var parameter = property.Parameters[0];

Binder\Binder_Invocation.cs (17)

1269ParameterSymbol receiverParameter = method.Parameters.First(); 1371private BoundExpression CheckAndConvertExtensionReceiver(BoundExpression receiver, ParameterSymbol extensionParameter, BindingDiagnosticBag diagnostics) 1428private BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, BindingDiagnosticBag diagnostics) 1486internal static ParameterSymbol? GetCorrespondingParameter( 1488ImmutableArray<ParameterSymbol> parameters, 1493ParameterSymbol? parameter; 1531ImmutableArray<ParameterSymbol> parameters, 1547var parameter = GetCorrespondingParameter(i, parameters, argsToParamsOpt, expanded); 1608foreach (var parameter in parameters.AsSpan()[..lastIndex]) 1664BoundExpression bindDefaultArgument(SyntaxNode syntax, ParameterSymbol parameter, Symbol? containingMember, bool enableCallerInfo, BindingDiagnosticBag diagnostics, 1836private BoundExpression CreateParamsCollection(SyntaxNode node, ParameterSymbol paramsParameter, ImmutableArray<BoundExpression> collectionArgs, BindingDiagnosticBag diagnostics) 2120var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2140var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2159private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedArguments analyzedArguments, IEnumerable<ImmutableArray<ParameterSymbol>> parameterListList, BindingDiagnosticBag diagnostics) 2295private static TypeSymbol GetCorrespondingParameterType(AnalyzedArguments analyzedArguments, int i, ImmutableArray<ParameterSymbol> parameterList) 2301foreach (var parameter in parameterList) 2318return BuildArgumentsForErrorRecovery(analyzedArguments, Enumerable.Empty<ImmutableArray<ParameterSymbol>>(), BindingDiagnosticBag.Discarded);

Binder\Binder_Lookup.cs (1)

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

Binder\Binder_NameConflicts.cs (2)

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

Binder\Binder_Operators.cs (2)

3923var extensionParameter = op.ContainingType.ExtensionParameter; 4264ParameterSymbol parameterSymbol = parameterAccess.ParameterSymbol;

Binder\Binder_Patterns.cs (1)

1689ParameterSymbol? parameter = null;

Binder\Binder_Symbols.cs (3)

1490if (!isPossiblyCapturingPrimaryConstructorParameterReference(receiver, out ParameterSymbol parameter)) 1537bool isPossiblyCapturingPrimaryConstructorParameterReference(BoundExpression receiver, out ParameterSymbol parameterSymbol) 1541if (colorColorValueSymbol is ParameterSymbol { ContainingSymbol: SynthesizedPrimaryConstructor primaryConstructor } parameter &&

Binder\BinderFactory.BinderFactoryVisitor.cs (4)

1251if (isParamRef && method.TryGetInstanceExtensionParameter(out var _)) 1295ImmutableArray<ParameterSymbol> parameters = property.Parameters; 1297if (isParamRef && property.TryGetInstanceExtensionParameter(out var _)) 1324ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

Binder\ExecutableCodeBinder.cs (1)

112foreach (var parameter in parameters)

Binder\InMethodBinder.cs (5)

25private MultiDictionary<string, ParameterSymbol> _lazyParameterMap; 208parameterMap = new MultiDictionary<string, ParameterSymbol>(parameters.Length, EqualityComparer<string>.Default); 209foreach (var parameter in parameters) 223foreach (var parameterSymbol in parameterMap[name]) 233foreach (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)

684static ParameterSymbol? tryGetReceiverParameter(MethodSymbol method) 695return 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) 348ParameterSymbol thisParameter; 434public static void GetDelegateOrFunctionPointerArguments(SyntaxNode syntax, AnalyzedArguments analyzedArguments, ImmutableArray<ParameterSymbol> delegateParameters, CSharpCompilation compilation) 436foreach (var p in delegateParameters) 438ParameterSymbol parameter = p;

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

3418var sourceParam = sourceSig.Parameters[i]; 3419var destinationParam = destinationSig.Parameters[i];

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

1606var extensionParameter = method.ContainingType.ExtensionParameter;

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

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

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

1035foreach (var parameter in parameters) 1506ImmutableArray<ParameterSymbol> delegateParameters, 2448var sourceParam = sourceSignature.Parameters[i]; 2449var targetParam = targetSignature.Parameters[i]; 2798var sourceParam = sourceSignature.Parameters[i]; 2799var targetParam = targetSignature.Parameters[i];

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

1320ParameterSymbol final = member.GetParameters().Last(); 2543var m1LastParameter = m1LeastOverriddenParameters[^1]; 2544var m2LastParameter = m2LeastOverriddenParameters[^1]; 2548var parameter1 = getParameterOrExtensionParameter(i, m1.Result, m1LeastOverriddenParameters, m1.LeastOverriddenMember); 2549var parameter2 = getParameterOrExtensionParameter(i, m2.Result, m2LeastOverriddenParameters, m2.LeastOverriddenMember); 2577static TypeSymbol getParameterTypeAndRefKind(int i, MemberAnalysisResult memberResolutionResult, ImmutableArray<ParameterSymbol> parameters, 2580ParameterSymbol parameter = getParameterOrExtensionParameter(i, memberResolutionResult, parameters, member); 2598static ParameterSymbol getParameterOrExtensionParameter(int argIndex, MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, TMember member) 2605ParameterSymbol? extensionParameter = member.ContainingType.ExtensionParameter; 2619ImmutableArray<ParameterSymbol> parameters1, 2621ImmutableArray<ParameterSymbol> parameters2) 2629var p1 = getParameterOrExtensionParameter(i, m1.Result, parameters1, m1.Member); 2630var p2 = getParameterOrExtensionParameter(i, m2.Result, parameters2, m2.Member); 2685private static RefKind GetParameterBetternessRefKind<TMember>(ParameterSymbol parameter, TMember member) where TMember : Symbol 3778private static bool IdenticalParameters(ImmutableArray<ParameterSymbol> p1, ImmutableArray<ParameterSymbol> p2) 3793var param1 = p1[i]; 3794var param2 = p2[i]; 3904ImmutableArray<ParameterSymbol> parameters = member.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 3938var parameter = parameters[parm]; 3963ParameterSymbol parameter, 4075var 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)

933ImmutableArray<ParameterSymbol> parameters = badMember.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 1228ParameterSymbol parameter = parameters[parm]; 1409static bool isStringLiteralToInterpolatedStringHandlerArgumentConversion(BoundExpression argument, ParameterSymbol parameter) 1418static Symbol unwrapIfParamsCollection(MemberResolutionResult<TMember> badArg, ParameterSymbol parameter, bool isLastParameter)

Binder\WithLambdaParametersBinder.cs (9)

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) 96foreach (var parameterSymbol in parameterMap[name]) 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 (5)

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) 93foreach (var parameterSymbol in parameterMap[name])

BoundTree\BoundDagEvaluation.cs (2)

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

BoundTree\BoundDagTest.cs (1)

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

BoundTree\BoundTreeRewriter.cs (3)

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

BoundTree\Constructors.cs (2)

471public BoundParameter(SyntaxNode syntax, ParameterSymbol parameterSymbol, bool hasErrors = false) 476public BoundParameter(SyntaxNode syntax, ParameterSymbol parameterSymbol)

BoundTree\NullabilityRewriter.cs (1)

223case ParameterSymbol param:

BoundTree\UnboundLambda.cs (2)

1174foreach (var p in invoke.Parameters) 1333foreach (var parameter in lambda.Parameters)

CodeGen\CodeGenerator_RefSafety.cs (11)

12/// <inheritdoc cref="MightEscapeTemporaryRefs(bool, TypeSymbol, RefKind, ParameterSymbol?, ImmutableArray{ParameterSymbol})"/> 19thisParameterSymbol: node.Method.TryGetThisParameter(out var thisParameter) ? thisParameter : null, 23/// <inheritdoc cref="MightEscapeTemporaryRefs(bool, TypeSymbol, RefKind, ParameterSymbol?, ImmutableArray{ParameterSymbol})"/> 34/// <inheritdoc cref="MightEscapeTemporaryRefs(bool, TypeSymbol, RefKind, ParameterSymbol?, ImmutableArray{ParameterSymbol})"/> 65ParameterSymbol? thisParameterSymbol, 66ImmutableArray<ParameterSymbol> parameters) 84foreach (var parameter in parameters) 95static bool processParameter(ParameterSymbol parameter, ref bool anyRefSources, ref bool anyRefTargets)

CodeGen\EmitAddress.cs (1)

471ParameterSymbol parameterSymbol = parameter.ParameterSymbol;

CodeGen\EmitExpression.cs (3)

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

CodeGen\Optimizer.cs (1)

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

Compilation\CSharpSemanticModel.cs (12)

1810case ParameterSymbol _: 3234protected ParameterSymbol GetParameterSymbol( 3235ImmutableArray<ParameterSymbol> parameters, 3239foreach (var symbol in parameters) 3705var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind); 3750private static ParameterSymbol GetThisParameter(TypeSymbol typeOfThis, NamedTypeSymbol containingType, Symbol containingMember, out LookupResultKind resultKind) 3759ParameterSymbol thisParam; 4536ParameterSymbol param = FindNamedParameter(containingInvocationInfo.Symbol.GetSymbol().GetParameters(), argumentName); 4553ParameterSymbol param = FindNamedParameter(invocationSym.GetSymbol().GetParameters(), argumentName); 4575private static ParameterSymbol FindNamedParameter(ImmutableArray<ParameterSymbol> parameters, string argumentName) 4577foreach (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)

829private ParameterSymbol GetLambdaOrLocalFunctionParameterSymbol( 863private ParameterSymbol GetLambdaParameterSymbol( 2382Debug.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)

1016var parameterSymbol = containing.GetDeclaredSymbol(paramDecl).GetSymbol<ParameterSymbol>(); 1151ParameterSymbol parameterSymbol = GetDeclaredNonLambdaParameterSymbol(parameterDecl); 2028private ParameterSymbol GetExtensionParameterSymbol( 2052return extensionParameter.GetSymbol<ParameterSymbol>(); 2059private ParameterSymbol GetMethodParameterSymbol( 2096private ParameterSymbol GetIndexerParameterSymbol( 2123private ParameterSymbol GetDelegateParameterSymbol( 2176private ParameterSymbol GetDeclaredNonLambdaParameterSymbol(ParameterSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) 2452Debug.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)

539HashSet<ParameterSymbol>? documentedParameters; 583foreach (ParameterSymbol parameter in GetParameters(symbol)) 634out HashSet<ParameterSymbol>? documentedParameters, 753private static ImmutableArray<ParameterSymbol> GetParameters(Symbol symbol) 770return ImmutableArray<ParameterSymbol>.Empty; 1271ref HashSet<ParameterSymbol> documentedParameters, 1284documentedParameters = new HashSet<ParameterSymbol>(); 1338ParameterSymbol 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)

185var thisSymbol = accessor.ThisParameter; 200var parameter = accessor.Parameters[0]; 352ParameterSymbol 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)

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

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (3)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (7)

382public override Symbol VisitParameter(ParameterSymbol parameter) 422foreach (var param in sig.Parameters) 666private bool AreParametersEqual(ParameterSymbol parameter, ParameterSymbol other) 699private bool AreFunctionPointerParametersEqual(ParameterSymbol param, ParameterSymbol otherParam) 938foreach (var param in sig.Parameters)

Emitter\Model\MethodSymbolAdapter.cs (1)

220return 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)

1516internal ImmutableArray<Cci.IParameterTypeInformation> Translate(ImmutableArray<ParameterSymbol> @params) 1526return @params.SelectAsArray<ParameterSymbol, Cci.IParameterTypeInformation>(p => p.GetCciAdapter()); 1535private static bool MustBeWrapped(ParameterSymbol param) 1555private ImmutableArray<Cci.IParameterTypeInformation> TranslateAll(ImmutableArray<ParameterSymbol> @params) 1558foreach (var param in @params) 1565private Cci.IParameterTypeInformation CreateParameterTypeInformationWrapper(ParameterSymbol param) 1655internal SynthesizedAttributeData SynthesizeRequiresLocationAttribute(ParameterSymbol symbol) 1666internal SynthesizedAttributeData SynthesizeParamCollectionAttribute(ParameterSymbol symbol) 1846internal 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)

682ImmutableArray<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) 466protected ImmutableArray<ParameterSymbol> MethodParameters 471return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 479protected ParameterSymbol MethodThisParameter 483ParameterSymbol thisParameter = null; 1439else if (method.TryGetThisParameter(out var thisParameter) 3047var 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 (22)

71private PooledHashSet<ParameterSymbol>? _readParameters; 333ImmutableArray<ParameterSymbol> methodParameters = MethodParameters; 334ParameterSymbol methodThisParameter = MethodThisParameter; 348foreach (var parameter in primaryConstructor.Parameters) 372ParameterSymbol extensionParameter = null; 409protected virtual void ReportUnassignedOutParameter(ParameterSymbol parameter, SyntaxNode node, Location location) 641!(captured is ParameterSymbol { ContainingSymbol: SynthesizedPrimaryConstructor primaryConstructor } parameter && 659private void CheckCaptured(Symbol variable, ParameterSymbol? rangeVariableUnderlyingParameter = null) 698if (symbol is ParameterSymbol { ContainingSymbol: SynthesizedPrimaryConstructor } parameter) 700_readParameters ??= PooledHashSet<ParameterSymbol>.GetInstance(); 706ParameterSymbol rangeVariableUnderlyingParameter = null) 1187((ParameterSymbol)symbol).RefKind == RefKind.Out) 1189if (((ParameterSymbol)symbol).IsThis) 1339var self = MethodThisParameter; 1572var param = paramExpr.ParameterSymbol; 1765foreach (var parameter in method.Parameters) 1777if (method.TryGetThisParameter(out ParameterSymbol thisParameter) && thisParameter is not null) 1789if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter)) 1809foreach (var parameter in primaryConstructor.Parameters) 1841protected override void EnterParameter(ParameterSymbol parameter) 1897protected override void LeaveParameters(ImmutableArray<ParameterSymbol> parameters, SyntaxNode syntax, Location location) 1908protected override void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location)

FlowAnalysis\NullableWalker.cs (88)

FlowAnalysis\NullableWalker.Variables.cs (1)

357case 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)

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

69var thisParameter = rewriter._factory.CurrentFunction.ThisParameter; 79rewriter._proxies.Add(thisParameter, new CapturedToExpressionSymbolReplacement<ParameterSymbol>(hoistedThis, hoistedSymbols: [], isReusable: true)); 408var thisParameter = this._factory.CurrentFunction.ThisParameter;

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

212if (!_topLevelMethod.TryGetThisParameter(out var thisParam) || 346_topLevelMethod.TryGetThisParameter(out var thisParam); 569if (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, 624var potentialParameter = lambda.Parameters[i]; 768var parameter = (ParameterSymbol)symbol; 769ParameterSymbol parameterToUse; 836ParameterSymbol replacementParameter; 1565foreach (var parameter in node.Symbol.Parameters) 1572var oldFrameThis = _currentFrameThis;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (5)

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

Lowering\ClosureConversion\LambdaCapturedVariable.cs (9)

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; 178private readonly ParameterSymbol _parameter; 180public LambdaCapturedVariableForRegularParameter(SynthesizedClosureEnvironment frame, TypeWithAnnotations type, string fieldName, ParameterSymbol parameter) 189ParameterSymbol definition = _parameter.OriginalDefinition;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

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

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

619foreach (var p in lambda.Parameters)

Lowering\ExtensionMethodBodyRewriter.cs (5)

51private (RewrittenMethodSymbol, ImmutableDictionary<Symbol, Symbol>) EnterMethod(MethodSymbol symbol, RewrittenMethodSymbol rewritten, ReadOnlySpan<ParameterSymbol> rewrittenParameters) 61foreach (var parameter in symbol.Parameters) 87public override ParameterSymbol VisitParameterSymbol(ParameterSymbol symbol) 89return (ParameterSymbol)_symbolMap[symbol];

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (3)

307foreach (var parameter in _factory.CurrentFunction.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: true)) 442ParameterSymbol parameter, 498ParameterSymbol 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.cs (2)

1159ParameterSymbol? extensionParameter = member.ContainingType.ExtensionParameter; 1167private BoundExpression ConvertReceiverForExtensionIfNeeded(BoundExpression receiver, bool markAsChecked, ParameterSymbol extensionParameter)

Lowering\LocalRewriter\LocalRewriter_Call.cs (9)

244ParameterSymbol? methodThisParameter; 247ParameterSymbol? interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 248interceptor.TryGetThisParameter(out var interceptorThisParameter) ? interceptorThisParameter : null; 848ImmutableArray<ParameterSymbol> parameters, 1081ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 1220private static ImmutableArray<RefKind> GetEffectiveArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters) 1245static void fillRefKindsBuilder(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters, [NotNull] ref ArrayBuilder<RefKind>? refKindsBuilder) 1405ImmutableArray<ParameterSymbol> parameters, 1688ImmutableArray<ParameterSymbol> parameters,

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

591var readonlySpanParameter = constructMethod.Parameters.Last();

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

480ImmutableArray<ParameterSymbol> parameters = indexer.Parameters;

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (9)

106var parameter = (ParameterSymbol)variable; 118Debug.Assert(!allVariables.Any((s, method) => s.Symbol is ParameterSymbol { ContainingSymbol: var container } && container != method && container is not SynthesizedPrimaryConstructor, method)); 128!(symbol is ParameterSymbol { ContainingSymbol: var container } && container != method)) // Not interested in force hoisting parameters that do not belong to our method 147ParameterSymbol parameter => 222case ParameterSymbol { RefKind: RefKind.None }: 230var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type; 267protected override void EnterParameter(ParameterSymbol parameter) 318var thisSymbol = topLevelMethod.ThisParameter;

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

144var thisParameter = originalMethod.ThisParameter; 816var thisParameter = this.OriginalMethod.ThisParameter;

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (3)

93private readonly ParameterSymbol _parameter; 95public StateMachineFieldSymbolForRegularParameter(NamedTypeSymbol stateMachineType, TypeWithAnnotations type, string name, ParameterSymbol parameter, bool isPublic) 104var definition = _parameter.OriginalDefinition;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (5)

240var parameter = (ParameterSymbol)variable; 331foreach (var parameter in method.Parameters) 489foreach (var parameter in method.Parameters) 523protected 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)

31private ImmutableArray<ParameterSymbol> _parameters; 92public sealed override ImmutableArray<ParameterSymbol> Parameters 109protected virtual ImmutableArray<ParameterSymbol> BaseMethodParameters 114private ImmutableArray<ParameterSymbol> MakeParameters() 117var builder = ArrayBuilder<ParameterSymbol>.GetInstance(); 120foreach (var p in parameters)

Lowering\SyntheticBoundNodeFactory.cs (4)

191public StateMachineFieldSymbol StateMachineFieldForRegularParameter(TypeSymbol type, string name, ParameterSymbol parameter, bool isPublic) 249public BoundParameter Parameter(ParameterSymbol p) 643public ParameterSymbol SynthesizedParameter(TypeSymbol type, string name, MethodSymbol? container = null, int ordinal = 0) 1371public 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)

52internal 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)

143public override ImmutableArray<ParameterSymbol> Parameters 145get { 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)

130internal 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)

251internal static Symbol? GetRuntimeMember(NamedTypeSymbol declaringType, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt) 257internal static Symbol? GetRuntimeMember(ImmutableArray<Symbol> members, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt) 1047foreach (var param in sig.Parameters) 1103internal class SpecialMembersSignatureComparer : SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> 1173protected override ImmutableArray<ParameterSymbol> GetParameters(MethodSymbol method) 1178protected override ImmutableArray<ParameterSymbol> GetParameters(PropertySymbol property) 1183protected override TypeSymbol GetParamType(ParameterSymbol parameter) 1212protected override bool IsByRefParam(ParameterSymbol parameter)

Symbols\ErrorMethodSymbol.cs (2)

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

Symbols\ErrorPropertySymbol.cs (2)

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

Symbols\ErrorTypeSymbol.cs (1)

109internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\Extensions\ReceiverParameterSymbol.cs (1)

16public ReceiverParameterSymbol(NamedTypeSymbol containingType, ParameterSymbol originalParameter) :

Symbols\Extensions\RewrittenLambdaOrLocalFunctionSymbol.cs (4)

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

Symbols\Extensions\RewrittenMethodSymbol.cs (5)

17private ImmutableArray<ParameterSymbol> _lazyParameters; 105public sealed override ImmutableArray<ParameterSymbol> Parameters 117protected abstract ImmutableArray<ParameterSymbol> MakeParameters(); 126internal RewrittenMethodParameterSymbol(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter) 139protected RewrittenMethodParameterSymbolBase(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter) :

Symbols\Extensions\RewrittenParameterSymbol.cs (1)

11public RewrittenParameterSymbol(ParameterSymbol originalParameter) :

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (6)

119protected override ImmutableArray<ParameterSymbol> MakeParameters() 122var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(ParameterCount); 129foreach (var parameter in sourceParameters) 138internal static int GetImplementationParameterOrdinal(ParameterSymbol underlyingParameter) 155internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 187public ExtensionMetadataMethodParameterSymbol(SourceExtensionImplementationMethodSymbol containingMethod, ParameterSymbol sourceParameter) :

Symbols\Extensions\SynthesizedExtensionMarker.cs (3)

60protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 65ParameterSymbol? makeExtensionParameter(BindingDiagnosticBag diagnostics) 86ParameterSymbol? parameter = ParameterHelpers.MakeExtensionReceiverParameter(withTypeParametersBinder: signatureBinder, owner: this, parameterList, 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\MemberSignatureComparer.cs (4)

732ReadOnlySpan<ParameterSymbol> params1, 734ReadOnlySpan<ParameterSymbol> params2, 756ParameterSymbol param1, 758ParameterSymbol param2,

Symbols\MemberSymbolExtensions.cs (7)

35internal static ImmutableArray<ParameterSymbol> GetParameters(this Symbol member) 44return ImmutableArray<ParameterSymbol>.Empty; 106internal static bool TryGetInstanceExtensionParameter(this Symbol symbol, [NotNullWhen(true)] out ParameterSymbol? extensionParameter) 181internal static ImmutableArray<ParameterSymbol> GetParametersIncludingExtensionParameter(this Symbol symbol, bool skipExtensionIfStatic) 364if (member.TryGetInstanceExtensionParameter(out var extensionParameter) && 454foreach (ParameterSymbol param in method.Parameters) 503foreach (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)

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

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

35public readonly ImmutableArray<ParameterSymbol> Parameters; 38public SignatureData(SignatureHeader header, ImmutableArray<ParameterSymbol> parameters, PEParameterSymbol returnParam) 321public ParameterSymbol _lazyThisParameter; 455internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 680public override ImmutableArray<ParameterSymbol> Parameters => Signature.Parameters; 878ImmutableArray<ParameterSymbol> @params; 883var builder = ImmutableArray.CreateBuilder<ParameterSymbol>(count); 900@params = ImmutableArray<ParameterSymbol>.Empty; 1158var parameter = parameters[0]; 1606foreach (var param in Parameters)

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

197public StrongBox<ParameterSymbol?>? LazyExtensionParameter; 416internal sealed override ParameterSymbol? ExtensionParameter 429var extensionParameter = makeExtensionParameter(this, uncommon); 430Interlocked.CompareExchange(ref uncommon.LazyExtensionParameter, new StrongBox<ParameterSymbol?>(extensionParameter), null); 435static ParameterSymbol? makeExtensionParameter(PENamedTypeSymbol @this, ExtensionInfo uncommon)

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

927var param = parameters.FirstOrDefault(static (p, name) => string.Equals(p.Name, name, StringComparison.Ordinal), name);

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

34private readonly ImmutableArray<ParameterSymbol> _parameters; 702public override ImmutableArray<ParameterSymbol> Parameters 976private static ImmutableArray<ParameterSymbol> GetParameters( 989return ImmutableArray<ParameterSymbol>.Empty; 994var parameters = new ParameterSymbol[propertyParams.Length - 1]; 1085foreach (var param in Parameters)

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

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

Symbols\MethodSymbol.cs (5)

290internal ParameterSymbol? ThisParameter 294ParameterSymbol? thisParameter; 308internal virtual bool TryGetThisParameter(out ParameterSymbol? thisParameter) 335public abstract ImmutableArray<ParameterSymbol> Parameters { get; } 1249ImmutableArray<IParameterSymbolInternal> IMethodSymbolInternal.Parameters => Parameters.Cast<ParameterSymbol, IParameterSymbolInternal>();

Symbols\NamedTypeSymbol.cs (3)

366var thisParam = method.Parameters.First(); 382private static bool IsValidExtensionReceiverParameter(ParameterSymbol thisParam) 659internal abstract ParameterSymbol? ExtensionParameter { get; }

Symbols\NativeIntegerTypeSymbol.cs (9)

193internal sealed override ParameterSymbol? ExtensionParameter => null; 348private ImmutableArray<ParameterSymbol> _lazyParameters; 373public override ImmutableArray<ParameterSymbol> Parameters 379var parameters = UnderlyingMethod.Parameters.SelectAsArray((p, m) => (ParameterSymbol)new NativeIntegerParameterSymbol(m._container, m, p), this); 386internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 388if (UnderlyingMethod.TryGetThisParameter(out ParameterSymbol? underlyingThisParameter)) 450internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, NativeIntegerMethodSymbol container, ParameterSymbol underlyingParameter) : base(underlyingParameter) 521public 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)

29private ImmutableArray<ParameterSymbol> _lazyParameters; 523public override ImmutableArray<ParameterSymbol> Parameters 561private ImmutableArray<ParameterSymbol> MakeParameters() 569return ImmutableArray<ParameterSymbol>.Empty; 573var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count - 1); 627public ReducedExtensionMethodParameterSymbol(ReducedExtensionMethodSymbol containingMethod, ParameterSymbol underlyingParameter) :

Symbols\Retargeting\RetargetingMethodSymbol.cs (7)

38private ImmutableArray<ParameterSymbol> _lazyParameters; 155public override ImmutableArray<ParameterSymbol> Parameters 168private ImmutableArray<ParameterSymbol> RetargetParameters() 175return ImmutableArray<ParameterSymbol>.Empty; 179var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count); 265internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 267if (!_underlyingMethod.TryGetThisParameter(out var underlyingParameter))

Symbols\Retargeting\RetargetingNamedTypeSymbol.cs (3)

47private StrongBox<ParameterSymbol> _lazyExtensionParameter; 102internal sealed override ParameterSymbol ExtensionParameter 109Interlocked.CompareExchange(ref _lazyExtensionParameter, new StrongBox<ParameterSymbol>(extensionParameter), null);

Symbols\Retargeting\RetargetingParameterSymbol.cs (4)

30protected RetargetingParameterSymbol(ParameterSymbol underlyingParameter) 175public RetargetingMethodParameterSymbol(RetargetingMethodSymbol retargetingMethod, ParameterSymbol underlyingParameter) 197public RetargetingPropertyParameterSymbol(RetargetingPropertySymbol retargetingProperty, ParameterSymbol underlyingParameter) 219public 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)

433ImmutableArray<ParameterSymbol> implementedMemberParameters = implementedMember.GetParameters(); 434ImmutableArray<ParameterSymbol> collisionCandidateParameters = collisionCandidateMember.GetParameters();

Symbols\Source\ExtensionGroupingInfo.cs (4)

232ParameterSymbol? parameter1 = extension1.ExtensionParameter; 233ParameterSymbol? parameter2 = extension2.ExtensionParameter; 286ParameterSymbol? parameter1 = extension1.ExtensionParameter; 287ParameterSymbol? parameter2 = extension2.ExtensionParameter;

Symbols\Source\ImplicitNamedTypeSymbol.cs (1)

180internal sealed override ParameterSymbol ExtensionParameter => null;

Symbols\Source\LambdaSymbol.cs (6)

22private readonly ImmutableArray<ParameterSymbol> _parameters; 218public override ImmutableArray<ParameterSymbol> Parameters 223internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 298foreach (var parameter in _parameters) 337private ImmutableArray<ParameterSymbol> MakeParameters( 358var builder = ArrayBuilder<ParameterSymbol>.GetInstance(unboundLambda.ParameterCount);

Symbols\Source\LocalFunctionSymbol.cs (5)

25private ImmutableArray<ParameterSymbol> _lazyParameters; 123foreach (var p in _lazyParameters) 201public override ImmutableArray<ParameterSymbol> Parameters 230diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 439internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter)

Symbols\Source\ParameterHelpers.cs (29)

Symbols\Source\SourceComplexParameterSymbol.cs (6)

481ImmutableArray<ParameterSymbol> implParameters = this.ContainingSymbol.GetPartialImplementationPart()?.GetParameters() ?? default; 497ImmutableArray<ParameterSymbol> defParameters = this.ContainingSymbol.GetPartialDefinitionPart()?.GetParameters() ?? default; 704internal static int GetCallerArgumentExpressionParameterIndex(ParameterSymbol parameter, string parameterName) 1311ImmutableArray<ParameterSymbol> containingSymbolParameters = ContainingSymbol.GetParameters(); 1312ParameterSymbol? extensionParameter = ContainingType.ExtensionParameter; 1412var parameter = containingSymbolParameters.FirstOrDefault(static (param, name) => string.Equals(param.Name, name, StringComparison.Ordinal), name);

Symbols\Source\SourceConstructorSymbolBase.cs (4)

20protected ImmutableArray<ParameterSymbol> _lazyParameters; 57diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 97foreach (var parameter in this.Parameters) 131public 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 (11)

20private ImmutableArray<ParameterSymbol> _parameters; 40protected void InitializeParameters(ImmutableArray<ParameterSymbol> parameters) 116var parameterSymbol = invoke.Parameters[i]; 136public sealed override ImmutableArray<ParameterSymbol> Parameters 224InitializeParameters(ImmutableArray.Create<ParameterSymbol>( 297InitializeParameters(parameters.Cast<SourceParameterSymbol, ParameterSymbol>()); 364var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 406var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 429private static string GetUniqueParameterName(ArrayBuilder<ParameterSymbol> currentParameters, string name) 439private static bool IsUnique(ArrayBuilder<ParameterSymbol> currentParameters, string name) 441foreach (var p in currentParameters)

Symbols\Source\SourceDestructorSymbol.cs (2)

109public override ImmutableArray<ParameterSymbol> Parameters 111get { 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)

4627private static bool ParametersMatchPropertyAccessor(PropertySymbol propertySymbol, bool getNotSet, ImmutableArray<ParameterSymbol> methodParams) 4638var methodParam = methodParams[i]; 4658private static bool ParametersMatchEventAccessor(EventSymbol eventSymbol, ImmutableArray<ParameterSymbol> methodParams) 5143ctor.Parameters.SelectAsArray<ParameterSymbol, ParameterSymbol>(param => new SignatureOnlyParameterSymbol(param.TypeWithAnnotations, 5190ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5243ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5303ImmutableArray<ParameterSymbol>.Empty, 5371ImmutableArray<Symbol> addProperties(ImmutableArray<ParameterSymbol> recordParameters) 5375foreach (ParameterSymbol param in recordParameters) 5382ImmutableArray<ParameterSymbol>.Empty, 5453bool checkMemberNotHidden(Symbol symbol, ParameterSymbol param) 5477ImmutableArray<ParameterSymbol>.Empty, 5508ImmutableArray<ParameterSymbol>.Empty, 5570ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (13)

19internal delegate void ReportMismatchInParameterType<TArg>(BindingDiagnosticBag bag, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol parameter, bool topLevel, TArg arg); 1180if (RequiresValidScopedOverrideForRefSafety(overriddenMethod, overridingMethod.TryGetThisParameter(out var thisParam) ? thisParam : null)) 1260(BindingDiagnosticBag diagnostics, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol overridingParameter, bool topLevel, Location location) 1329var baseParameter = baseParameters[i]; 1332var overrideParameter = overrideParameters[parameterIndex]; 1366var overrideParam = overrideParameters[i + overrideParameterOffset]; 1367var baseParam = baseParameters[i]; 1412internal static bool RequiresValidScopedOverrideForRefSafety(MethodSymbol? method, ParameterSymbol? overrideThisParameter) 1505var baseParameter = baseParameters[i]; 1506var overrideParameter = overrideParameters[i + overrideParameterOffset]; 1538ReportMismatchInParameterType<(ParameterSymbol BaseParameter, TArg Arg)> reportMismatchInParameterType, 1556var baseParameter = baseParameters[i]; 1557var 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) 849internal sealed override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 925foreach (var parameter in this.Parameters) 1053foreach (var parameter in method.Parameters)

Symbols\Source\SourceMethodSymbol.cs (2)

66foreach (var parameter in parameters) 84static Location getLocation(ParameterSymbol parameter, Location location, bool isReceiverParameter)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

783foreach (var param in this.Parameters) 1412foreach (var param in Parameters)

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (6)

30public ParameterSymbol? LazyExtensionParameter; 331ParameterSymbol parameter = parameters[i]; 723ImmutableArray<ParameterSymbol> parameters = signature.Parameters; 731ParameterSymbol parameter = parameters[i]; 995foreach (var parameter in constructor.Parameters) 1011internal sealed override ParameterSymbol? ExtensionParameter

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (4)

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

Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)

115private (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters, ImmutableArray<TypeParameterConstraintClause> DeclaredConstraintsForOverrideOrImplementation) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 127ImmutableArray<ParameterSymbol> parameters = ParameterHelpers.MakeParameters( 132diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 179foreach (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 (2)

73internal static void AddSynthesizedAttributes(ParameterSymbol parameter, PEModuleBuilder moduleBuilder, ref ArrayBuilder<CSharpAttributeData> attributes) 135internal abstract ParameterSymbol WithCustomModifiersAndParams(TypeSymbol newType, ImmutableArray<CustomModifier> newCustomModifiers, ImmutableArray<CustomModifier> newRefCustomModifiers, bool newIsParams);

Symbols\Source\SourcePropertyAccessorSymbol.cs (5)

21private ImmutableArray<ParameterSymbol> _lazyParameters; 353public sealed override ImmutableArray<ParameterSymbol> Parameters 806private ImmutableArray<ParameterSymbol> ComputeParameters() 815return ImmutableArray<ParameterSymbol>.Empty; 818var 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)

563protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 618private static ImmutableArray<ParameterSymbol> MakeParameters( 623return ImmutableArray<ParameterSymbol>.Empty; 637diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 659private ImmutableArray<ParameterSymbol> ComputeParameters(Binder binder, CSharpSyntaxNode syntax, BindingDiagnosticBag diagnostics) 678foreach (ParameterSymbol param in Parameters) 688else if (SetMethod is object && param.Name == ParameterSymbol.ValueParameterName) 696if (ContainingType.TypeParameters.Any(static tp => tp.Name == ParameterSymbol.ValueParameterName)) 701if (ContainingType.ExtensionParameter is { Name: ParameterSymbol.ValueParameterName })

Symbols\Source\SourcePropertySymbolBase.cs (4)

62private ImmutableArray<ParameterSymbol> _lazyParameters; 670public sealed override ImmutableArray<ParameterSymbol> Parameters 1836foreach (var parameter in this.Parameters) 1945protected abstract (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics);

Symbols\Source\SourceUserDefinedConversionSymbol.cs (1)

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

Symbols\Source\SourceUserDefinedOperatorSymbol.cs (1)

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

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

310protected (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BaseMethodDeclarationSyntax declarationSyntax, TypeSyntax returnTypeSyntax, BindingDiagnosticBag diagnostics) 313ImmutableArray<ParameterSymbol> parameters; 330diagnostics: diagnostics).Cast<SourceParameterSymbol, ParameterSymbol>(); 381protected abstract (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics); 471foreach (var p in this.Parameters)

Symbols\Source\SynthesizedSourceOrdinaryMethodSymbol.cs (1)

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

Symbols\SubstitutedMethodSymbol.cs (8)

31private ImmutableArray<ParameterSymbol> _lazyParameters; 256public sealed override ImmutableArray<ParameterSymbol> Parameters 321internal sealed override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 328ParameterSymbol? originalThisParameter; 346private ImmutableArray<ParameterSymbol> SubstituteParameters() 353return ImmutableArray<ParameterSymbol>.Empty; 357var substituted = ArrayBuilder<ParameterSymbol>.GetInstance(count); 359foreach (var p in unsubstitutedParameters)

Symbols\SubstitutedNamedTypeSymbol.cs (5)

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

Symbols\SubstitutedParameterSymbol.cs (5)

19internal SubstitutedParameterSymbol(MethodSymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 24internal SubstitutedParameterSymbol(PropertySymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 29internal SubstitutedParameterSymbol(NamedTypeSymbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 34private SubstitutedParameterSymbol(Symbol containingSymbol, TypeMap map, ParameterSymbol originalParameter) : 42public 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)

1251internal bool DeriveUseSiteInfoFromParameter(ref UseSiteInfo<AssemblySymbol> result, ParameterSymbol param) 1260internal bool DeriveUseSiteInfoFromParameters(ref UseSiteInfo<AssemblySymbol> result, ImmutableArray<ParameterSymbol> parameters) 1262foreach (ParameterSymbol param in parameters) 1385internal static bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, ImmutableArray<ParameterSymbol> parameters, Symbol owner, ref HashSet<TypeSymbol> checkedTypes) 1387foreach (var parameter in parameters) 1706builder.AddValue(((ParameterSymbol)this).TypeWithAnnotations); 1780&& variable is ParameterSymbol { ContainingSymbol: NamedTypeSymbol { IsExtension: true } })

Symbols\SymbolDistinguisher.cs (1)

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

Symbols\SymbolExtensions.cs (8)

158internal static ParameterSymbol? EnclosingThisSymbol(this Symbol containingMember) 469ParameterSymbol parameter => parameter.FlowAnalysisAnnotations, 511ParameterSymbol parameter = (ParameterSymbol)symbol; 617internal static IParameterSymbol? GetPublicSymbol(this ParameterSymbol? symbol) 727internal static ImmutableArray<IParameterSymbol> GetPublicSymbols(this ImmutableArray<ParameterSymbol> symbols) 824internal static bool IsExtensionParameter(this ParameterSymbol parameter) 829internal 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)

195internal sealed override ParameterSymbol? ExtensionParameter => null;

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

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

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

908internal sealed override ParameterSymbol? ExtensionParameter => null;

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

18private IReadOnlyDictionary<ParameterSymbol, FieldSymbol>? _capturedParameters = null; 19private IReadOnlySet<ParameterSymbol>? _parametersPassedToTheBase = null; 33_parametersPassedToTheBase = SpecializedCollections.EmptyReadOnlySet<ParameterSymbol>(); 118IReadOnlyDictionary<ParameterSymbol, FieldSymbol> capturedParameters = GetCapturedParameters(); 128public IReadOnlyDictionary<ParameterSymbol, FieldSymbol> GetCapturedParameters() 137_capturedParameters = SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 195public IReadOnlySet<ParameterSymbol> GetParametersPassedToTheBase() 206_parametersPassedToTheBase = SpecializedCollections.EmptyReadOnlySet<ParameterSymbol>(); 212internal void SetParametersPassedToTheBase(IReadOnlySet<ParameterSymbol> value) 224foreach (ParameterSymbol p in Parameters)

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

20public readonly ParameterSymbol ParameterSymbol; 23ParameterSymbol 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)

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

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

66protected sealed override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) 72Parameters: 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)

27protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymbol> Parameters) 34Parameters: 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)

20ParameterSymbol backingParameter, 96protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 99ImmutableArray<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)

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

Symbols\Synthesized\SynthesizedCollectionBuilderProjectedMethodSymbol.cs (4)

38private ImmutableArray<ParameterSymbol> _lazyParameters; 90public override ImmutableArray<ParameterSymbol> Parameters 99var builder = ArrayBuilder<ParameterSymbol>.GetInstance(parameterCount); 123ParameterSymbol originalParameter) : WrappedParameterSymbol(originalParameter)

Symbols\Synthesized\SynthesizedContainer.cs (1)

51internal 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 186public override ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\Synthesized\SynthesizedEmbeddedAttributePropertySymbol.cs (2)

36public override ImmutableArray<ParameterSymbol> Parameters => []; 96public override ImmutableArray<ParameterSymbol> Parameters => [];

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (5)

125internal sealed override ParameterSymbol? ExtensionParameter => null; 256_constructors = ImmutableArray.Create<MethodSymbol>(new SynthesizedEmbeddedAttributeConstructorSymbol(this, m => ImmutableArray<ParameterSymbol>.Empty)); 264private readonly ImmutableArray<ParameterSymbol> _parameters; 268Func<MethodSymbol, ImmutableArray<ParameterSymbol>> getParameters) : 274public override ImmutableArray<ParameterSymbol> Parameters => _parameters;

Symbols\Synthesized\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (2)

39ImmutableArray<ParameterSymbol> getConstructorParameters(MethodSymbol ctor) 44void getConstructorBody(SyntheticBoundNodeFactory f, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters)

Symbols\Synthesized\SynthesizedEmbeddedLifetimeAnnotationAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedMemorySafetyRulesAttributeSymbol.cs (1)

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

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)

345private readonly ImmutableArray<ParameterSymbol> _parameters; 430public override ImmutableArray<ParameterSymbol> Parameters => _parameters; 496public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 573private readonly ImmutableArray<ParameterSymbol> _parameters; 592public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (4)

25private ImmutableArray<ParameterSymbol> _parameters; 53protected void SetParameters(ImmutableArray<ParameterSymbol> parameters) 174public override ImmutableArray<ParameterSymbol> Parameters 181return 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)

128internal 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)

116internal 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)

20private readonly ImmutableArray<ParameterSymbol> _parameters; 45_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, leftType, 0, "left"), 54_parameters = ImmutableArray.Create<ParameterSymbol>(new SynthesizedOperatorParameterSymbol(this, container, 0, "value")); 257public override ImmutableArray<ParameterSymbol> Parameters

Symbols\Synthesized\SynthesizedMethodSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedParameterlessThrowMethod.cs (1)

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

Symbols\Synthesized\SynthesizedParameterSymbol.cs (7)

257public static ParameterSymbol Create( 266ParameterSymbol? baseParameterForAttributes = null, 300internal static ImmutableArray<ParameterSymbol> DeriveParameters(MethodSymbol sourceMethod, MethodSymbol destinationMethod) 307internal static ParameterSymbol DeriveParameter(Symbol destination, ParameterSymbol oldParam) 343private readonly ParameterSymbol? _baseParameterForAttributes; 357ParameterSymbol? baseParameterForAttributes,

Symbols\Synthesized\SynthesizedPrivateImplementationDetailsType.cs (1)

99internal 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; 163public 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\Synthesized\SynthesizedUnionCtor.cs (2)

26Parameters = [SynthesizedParameterSymbol.Create(this, parameterType, ordinal: 0, RefKind.None, ParameterSymbol.ValueParameterName)]; 30public override ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\Synthesized\SynthesizedUnionValuePropertySymbol.cs (2)

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

Symbols\TypeSymbol.cs (1)

1876if (SourceMemberContainerTypeSymbol.RequiresValidScopedOverrideForRefSafety(implementedMethod, implementingMethod.TryGetThisParameter(out var thisParameter) ? thisParameter : null))

Symbols\TypeSymbolExtensions.cs (4)

614public static ImmutableArray<ParameterSymbol> DelegateParameters(this TypeSymbol type) 619return default(ImmutableArray<ParameterSymbol>); 624public static ImmutableArray<ParameterSymbol> DelegateOrFunctionPointerParameters(this TypeSymbol type) 2137foreach (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)