ParameterSymbol

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)

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

Binder\Binder_Conversions.cs (8)

1435var readonlySpanParameter = collectionBuilderMethod.Parameters.Last(); 2970if (SourceMemberContainerTypeSymbol.RequiresValidScopedOverrideForRefSafety(delegateMethod, lambdaOrMethod.TryGetThisParameter(out var thisParameter) ? thisParameter : null)) 3012var lambdaParameter = lambdaSymbol.Parameters[p]; 3013var delegateParameter = delegateParameters[p]; 3078ParameterSymbol lambdaParameter, 3550var delegateParameter = delegateOrFuncPtrParameters[i]; 3551var methodParameter = methodParameters[isExtensionMethod ? i + 1 : i]; 3679internal static ParameterSymbol? GetReceiverParameter(MethodSymbol method)

Binder\Binder_Crefs.cs (7)

277ImmutableArray<ParameterSymbol> extensionParameterSymbols = BindCrefParameters(syntax.Parameters, diagnostics); 700ImmutableArray<ParameterSymbol> parameterSymbols = BindCrefParameters(parameterListSyntax, diagnostics); 772foreach (var param in signature.Parameters) 965private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder<Symbol> candidates, ImmutableArray<ParameterSymbol> parameterSymbols, int arity, MemberCrefSyntax memberSyntax, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics) 1136private ImmutableArray<ParameterSymbol> BindCrefParameters(BaseCrefParameterListSyntax parameterListSyntax, BindingDiagnosticBag diagnostics) 1138ArrayBuilder<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, 1835private ParameterSymbol GetShadowedPrimaryConstructorParameter(SimpleNameSyntax node, Symbol symbol, bool invoked, ArrayBuilder<Symbol> membersOpt) 1882if (singleSymbol is ParameterSymbol shadowedParameter && 2085var parameter = (ParameterSymbol)symbol; 2618ParameterSymbol? thisSymbol = this.ContainingMemberOrLambda.EnclosingThisSymbol(); 3564ImmutableArray<ParameterSymbol> parameters, 3620ImmutableArray<ParameterSymbol> parameters, 3653ImmutableArray<ParameterSymbol> parameters, 3736static ParameterSymbol getCorrespondingParameter(in MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, int arg) 3746ImmutableArray<ParameterSymbol> parameters, 3758var correspondingParameter = getCorrespondingParameter(in result, parameters, interpolatedStringArgNum); 3875var receiverParameter = ((NamedTypeSymbol)methodResult.Member.ContainingSymbol).ExtensionParameter; 3885var parameter = parameters[originalParameterIndex]; 3905var parameter = parameters[originalParameterIndex]; 3980private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter, 5131var parametersPassedToBase = new OrderedSet<ParameterSymbol>(); 5140if (TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, analyzedArguments.Argument(i)) is (ParameterSymbol parameter, SyntaxNode syntax)) 5144var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5237private static (ParameterSymbol, SyntaxNode) TryGetPrimaryConstructorParameterUsedAsValue(SynthesizedPrimaryConstructor primaryConstructor, BoundExpression boundExpression) 7757leftType = ((ParameterSymbol)leftSymbol).Type; 11006var parameter = property.Parameters[0];

Binder\Binder_Invocation.cs (17)

1294ParameterSymbol receiverParameter = method.Parameters.First(); 1396private BoundExpression CheckAndConvertExtensionReceiver(BoundExpression receiver, ParameterSymbol extensionParameter, BindingDiagnosticBag diagnostics) 1465private BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, BindingDiagnosticBag diagnostics) 1523internal static ParameterSymbol? GetCorrespondingParameter( 1525ImmutableArray<ParameterSymbol> parameters, 1530ParameterSymbol? parameter; 1568ImmutableArray<ParameterSymbol> parameters, 1584var parameter = GetCorrespondingParameter(i, parameters, argsToParamsOpt, expanded); 1645foreach (var parameter in parameters.AsSpan()[..lastIndex]) 1701BoundExpression bindDefaultArgument(SyntaxNode syntax, ParameterSymbol parameter, Symbol? containingMember, bool enableCallerInfo, BindingDiagnosticBag diagnostics, 1873private BoundExpression CreateParamsCollection(SyntaxNode node, ParameterSymbol paramsParameter, ImmutableArray<BoundExpression> collectionArgs, BindingDiagnosticBag diagnostics) 2157var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2177var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2196private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedArguments analyzedArguments, IEnumerable<ImmutableArray<ParameterSymbol>> parameterListList, BindingDiagnosticBag diagnostics) 2332private static TypeSymbol GetCorrespondingParameterType(AnalyzedArguments analyzedArguments, int i, ImmutableArray<ParameterSymbol> parameterList) 2338foreach (var parameter in parameterList) 2355return BuildArgumentsForErrorRecovery(analyzedArguments, Enumerable.Empty<ImmutableArray<ParameterSymbol>>(), BindingDiagnosticBag.Discarded);

Binder\Binder_Lookup.cs (1)

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

1293ParameterSymbol? 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\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)

105public ImmutableArray<ParameterSymbol> Parameters; 343internal ParameterSymbol? Parameter { get; } 352internal MixableDestination(ParameterSymbol parameter, BoundExpression argument) 388internal ParameterSymbol? Parameter { get; } 394internal EscapeArgument(ParameterSymbol? parameter, BoundExpression argument, RefKind refKind, bool isArgList = false) 402public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out RefKind refKind) 424internal ParameterSymbol? Parameter { get; } 437internal EscapeValue(ParameterSymbol? parameter, BoundExpression argument, EscapeLevel escapeLevel, bool isRefEscape) 445public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out EscapeLevel escapeLevel, out bool isRefEscape) 1409ParameterSymbol parameterSymbol = parameter.ParameterSymbol; 1466static void reportReadOnlyParameterError(ParameterSymbol parameterSymbol, SyntaxNode node, BindValueKind valueKind, bool checkingReceiver, BindingDiagnosticBag diagnostics) 1522private static SafeContext GetParameterValEscape(ParameterSymbol parameter) 1532private static EscapeLevel? GetParameterValEscapeLevel(ParameterSymbol parameter) => 1535private static SafeContext GetParameterRefEscape(ParameterSymbol parameter) 1547private static EscapeLevel? GetParameterRefEscapeLevel(ParameterSymbol parameter) => 1550private bool CheckParameterValEscape(SyntaxNode node, ParameterSymbol parameter, SafeContext escapeTo, BindingDiagnosticBag diagnostics) 1568private bool CheckParameterRefEscape(SyntaxNode node, BoundExpression parameter, ParameterSymbol parameterSymbol, SafeContext escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics) 2430var extensionParameter = symbol.ContainingType.ExtensionParameter; 2713var parameter = argIndex < parameters.Length ? 2741static bool isMixableParameter([NotNullWhen(true)] ParameterSymbol? parameter) => 2768ParameterSymbol? thisParameter = null; 2873ParameterSymbol? extensionReceiver = null; 2930return method?.TryGetThisParameter(out var thisParameter) == true && thisParameter is not null && 2934static bool isRefToRefStruct(ParameterSymbol parameter) 3100private static string GetInvocationParameterName(ParameterSymbol? parameter) 3117ParameterSymbol? parameter, 3356private readonly ParameterSymbol _underlyingParameter; 3358internal TypeParameterThisParameterSymbol(ParameterSymbol underlyingParameter, TypeParameterSymbol type) 3757var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4056var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4368var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5069var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5744ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5784ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

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; 198parameterMap = new MultiDictionary<string, ParameterSymbol>(parameters.Length, EqualityComparer<string>.Default); 199foreach (var parameter in parameters) 213foreach (var parameterSymbol in parameterMap[name]) 223foreach (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)

704static ParameterSymbol? tryGetReceiverParameter(MethodSymbol method) 715return 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_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\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\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\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)

512ParameterSymbol parameterSymbol = parameter.ParameterSymbol;

CodeGen\EmitExpression.cs (3)

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

CodeGen\Optimizer.cs (1)

1266private 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)

836private ParameterSymbol GetLambdaOrLocalFunctionParameterSymbol( 870private ParameterSymbol GetLambdaParameterSymbol( 2393Debug.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\ParameterSymbolAdapter.cs (2)

227internal ParameterSymbol AdaptedParameterSymbol => this; 229internal new ParameterSymbol GetCciAdapter()

Emitter\Model\ParameterTypeInformation.cs (2)

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

Emitter\Model\PEModuleBuilder.cs (8)

1516internal ImmutableArray<Cci.IParameterTypeInformation> Translate(ImmutableArray<ParameterSymbol> @params) 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\SynthesizedPrivateImplementationDetailsStaticConstructor.cs (1)

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

Emitter\NoPia\EmbeddedParameter.cs (2)

17using ParameterSymbolAdapter = Microsoft.CodeAnalysis.CSharp.Symbols.ParameterSymbol; 25EmbeddedTypesManager.CommonEmbeddedMember containingPropertyOrMethod, ParameterSymbolAdapter underlyingParameter) :

Emitter\NoPia\EmbeddedTypesManager.cs (3)

25using ParameterSymbolAdapter = Microsoft.CodeAnalysis.CSharp.Symbols.ParameterSymbol; 35NamedTypeSymbolAdapter, FieldSymbolAdapter, MethodSymbolAdapter, EventSymbolAdapter, PropertySymbolAdapter, ParameterSymbolAdapter, TypeParameterSymbolAdapter, 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)

625foreach (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_Call.cs (9)

244ParameterSymbol? methodThisParameter; 247ParameterSymbol? interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 248interceptor.TryGetThisParameter(out var interceptorThisParameter) ? interceptorThisParameter : null; 893ImmutableArray<ParameterSymbol> parameters, 1187ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 1326private static ImmutableArray<RefKind> GetEffectiveArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters) 1351static void fillRefKindsBuilder(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters, [NotNull] ref ArrayBuilder<RefKind>? refKindsBuilder) 1515ImmutableArray<ParameterSymbol> parameters, 1798ImmutableArray<ParameterSymbol> parameters,

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

518ImmutableArray<ParameterSymbol> parameters = indexer.Parameters;

Lowering\LocalRewriter\LocalRewriter.cs (2)

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

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)

57public 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) 1392public 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)

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

89public 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)

21Debug.Assert(lambdaOrLocalFunctionSymbol.TryGetThisParameter(out var thisParameter) && thisParameter is null); 29internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 38protected override ImmutableArray<ParameterSymbol> MakeParameters() 40return 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)

120protected override ImmutableArray<ParameterSymbol> MakeParameters() 123var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(ParameterCount); 130foreach (var parameter in sourceParameters) 139internal static int GetImplementationParameterOrdinal(ParameterSymbol underlyingParameter) 156internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 190public 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]; 1599foreach (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; 699public override ImmutableArray<ParameterSymbol> Parameters 973private static ImmutableArray<ParameterSymbol> GetParameters( 986return ImmutableArray<ParameterSymbol>.Empty; 991var parameters = new ParameterSymbol[propertyParams.Length - 1]; 1083foreach (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 (4)

410var thisParam = method.Parameters.First(); 426private static bool IsValidExtensionReceiverParameter(ParameterSymbol thisParam) 703internal abstract ParameterSymbol? ExtensionParameter { get; } 2692var parameter = factory.Parameters[0];

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)) 452internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, NativeIntegerMethodSymbol container, ParameterSymbol underlyingParameter) : base(underlyingParameter) 523public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty;

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)

31public 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)

27private ImmutableArray<ParameterSymbol> _lazyParameters; 89public override ImmutableArray<ParameterSymbol> Parameters 95ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, this.RetargetParameters(), default(ImmutableArray<ParameterSymbol>)); 102private ImmutableArray<ParameterSymbol> RetargetParameters() 109return ImmutableArray<ParameterSymbol>.Empty; 113ParameterSymbol[] 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)

21private ImmutableArray<ParameterSymbol> _parameters; 41protected void InitializeParameters(ImmutableArray<ParameterSymbol> parameters) 117var parameterSymbol = invoke.Parameters[i]; 137public sealed override ImmutableArray<ParameterSymbol> Parameters 225InitializeParameters(ImmutableArray.Create<ParameterSymbol>( 298InitializeParameters(parameters.Cast<SourceParameterSymbol, ParameterSymbol>()); 365var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 407var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 430private static string GetUniqueParameterName(ArrayBuilder<ParameterSymbol> currentParameters, string name) 440private static bool IsUnique(ArrayBuilder<ParameterSymbol> currentParameters, string name) 442foreach (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_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\SourceMemberContainerSymbol.cs (15)

4653private static bool ParametersMatchPropertyAccessor(PropertySymbol propertySymbol, bool getNotSet, ImmutableArray<ParameterSymbol> methodParams) 4664var methodParam = methodParams[i]; 4684private static bool ParametersMatchEventAccessor(EventSymbol eventSymbol, ImmutableArray<ParameterSymbol> methodParams) 5178ctor.Parameters.SelectAsArray<ParameterSymbol, ParameterSymbol>(param => new SignatureOnlyParameterSymbol(param.TypeWithAnnotations, 5225ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5278ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5338ImmutableArray<ParameterSymbol>.Empty, 5406ImmutableArray<Symbol> addProperties(ImmutableArray<ParameterSymbol> recordParameters) 5410foreach (ParameterSymbol param in recordParameters) 5417ImmutableArray<ParameterSymbol>.Empty, 5488bool checkMemberNotHidden(Symbol symbol, ParameterSymbol param) 5512ImmutableArray<ParameterSymbol>.Empty, 5543ImmutableArray<ParameterSymbol>.Empty, 5605ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(

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) 1045foreach (var parameter in method.Parameters)

Symbols\Source\SourceMethodSymbol.cs (2)

67foreach (var parameter in parameters) 85static 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)

63private ImmutableArray<ParameterSymbol> _lazyParameters; 671public sealed override ImmutableArray<ParameterSymbol> Parameters 1854foreach (var parameter in this.Parameters) 1963protected 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)

18private ImmutableArray<ParameterSymbol> _lazyParameters; 74public override ImmutableArray<ParameterSymbol> Parameters 80ImmutableInterlocked.InterlockedCompareExchange(ref _lazyParameters, SubstituteParameters(), default(ImmutableArray<ParameterSymbol>)); 150private ImmutableArray<ParameterSymbol> SubstituteParameters() 161var substituted = new ParameterSymbol[count];

Symbols\Symbol.cs (7)

1254internal bool DeriveUseSiteInfoFromParameter(ref UseSiteInfo<AssemblySymbol> result, ParameterSymbol param) 1263internal bool DeriveUseSiteInfoFromParameters(ref UseSiteInfo<AssemblySymbol> result, ImmutableArray<ParameterSymbol> parameters) 1265foreach (ParameterSymbol param in parameters) 1388internal static bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, ImmutableArray<ParameterSymbol> parameters, Symbol owner, ref HashSet<TypeSymbol> checkedTypes) 1390foreach (var parameter in parameters) 1709builder.AddValue(((ParameterSymbol)this).TypeWithAnnotations); 1783&& 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)

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

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

915internal sealed override ParameterSymbol? ExtensionParameter => null;

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

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)

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)

83protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 86ImmutableArray<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)

21ParameterSymbol backingParameter, 97protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 100ImmutableArray<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)

37public override ImmutableArray<ParameterSymbol> Parameters => []; 97public 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 (2)

18this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"), 50ParameterSymbol inlineArrayParameter = inlineArrayHelperMethod.Parameters[0];

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)

73protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 76ImmutableArray<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)