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)

126public ImmutableArray<ParameterSymbol> Parameters; 356internal ParameterSymbol? Parameter { get; } 365internal MixableDestination(ParameterSymbol parameter, BoundExpression argument) 401internal ParameterSymbol? Parameter { get; } 407internal EscapeArgument(ParameterSymbol? parameter, BoundExpression argument, RefKind refKind, bool isArgList = false) 415public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out RefKind refKind) 437internal ParameterSymbol? Parameter { get; } 450internal EscapeValue(ParameterSymbol? parameter, BoundExpression argument, EscapeLevel escapeLevel, bool isRefEscape) 458public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out EscapeLevel escapeLevel, out bool isRefEscape) 1364ParameterSymbol parameterSymbol = parameter.ParameterSymbol; 1421static void reportReadOnlyParameterError(ParameterSymbol parameterSymbol, SyntaxNode node, BindValueKind valueKind, bool checkingReceiver, BindingDiagnosticBag diagnostics) 1477private static SafeContext GetParameterValEscape(ParameterSymbol parameter) 1487private static EscapeLevel? GetParameterValEscapeLevel(ParameterSymbol parameter) => 1490private static SafeContext GetParameterRefEscape(ParameterSymbol parameter) 1502private static EscapeLevel? GetParameterRefEscapeLevel(ParameterSymbol parameter) => 1505private bool CheckParameterValEscape(SyntaxNode node, ParameterSymbol parameter, SafeContext escapeTo, BindingDiagnosticBag diagnostics) 1523private bool CheckParameterRefEscape(SyntaxNode node, BoundExpression parameter, ParameterSymbol parameterSymbol, SafeContext escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics) 2378var extensionParameter = symbol.ContainingType.ExtensionParameter; 2664var parameter = argIndex < parameters.Length ? 2692static bool isMixableParameter([NotNullWhen(true)] ParameterSymbol? parameter) => 2744ParameterSymbol? thisParameter = null; 2849ParameterSymbol? extensionReceiver = null; 2906return method?.TryGetThisParameter(out var thisParameter) == true && thisParameter is not null && 2910static bool isRefToRefStruct(ParameterSymbol parameter) 3076private static string GetInvocationParameterName(ParameterSymbol? parameter) 3093ParameterSymbol? parameter, 3335private readonly ParameterSymbol _underlyingParameter; 3337internal TypeParameterThisParameterSymbol(ParameterSymbol underlyingParameter, TypeParameterSymbol type) 3729var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4030var thisParam = ((MethodSymbol)_symbol).ThisParameter; 4349var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5018var thisParam = ((MethodSymbol)_symbol).ThisParameter; 5700ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5740ImmutableArray.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) 712ImmutableArray<ParameterSymbol> parameters = attributeConstructor.Parameters; 719ParameterSymbol parameter = parameters[paramIndex];

Binder\Binder_Await.cs (1)

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

Binder\Binder_Conversions.cs (7)

2276if (SourceMemberContainerTypeSymbol.RequiresValidScopedOverrideForRefSafety(delegateMethod, lambdaOrMethod.TryGetThisParameter(out var thisParameter) ? thisParameter : null)) 2318var lambdaParameter = lambdaSymbol.Parameters[p]; 2319var delegateParameter = delegateParameters[p]; 2384ParameterSymbol lambdaParameter, 2841var delegateParameter = delegateOrFuncPtrParameters[i]; 2842var methodParameter = methodParameters[isExtensionMethod ? i + 1 : i]; 2970internal 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) 957private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder<Symbol> candidates, ImmutableArray<ParameterSymbol> parameterSymbols, int arity, MemberCrefSyntax memberSyntax, out Symbol? ambiguityWinner, BindingDiagnosticBag diagnostics) 1128private ImmutableArray<ParameterSymbol> BindCrefParameters(BaseCrefParameterListSyntax parameterListSyntax, BindingDiagnosticBag diagnostics) 1130ArrayBuilder<ParameterSymbol> parameterBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(parameterListSyntax.Parameters.Count);

Binder\Binder_Expressions.cs (23)

466TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, result) is (ParameterSymbol parameter, SyntaxNode syntax) && 495ParameterSymbol parameter, 506ParameterSymbol parameter, 1840if (GetSymbolOrMethodOrPropertyGroup(lookupResult, node, name, node.Arity, members, diagnostics, out bool isError, qualifierOpt: null) is ParameterSymbol shadowedParameter && 2128var parameter = (ParameterSymbol)symbol; 2553ParameterSymbol? thisSymbol = this.ContainingMemberOrLambda.EnclosingThisSymbol(); 3499ImmutableArray<ParameterSymbol> parameters, 3555ImmutableArray<ParameterSymbol> parameters, 3588ImmutableArray<ParameterSymbol> parameters, 3671static ParameterSymbol getCorrespondingParameter(in MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, int arg) 3681ImmutableArray<ParameterSymbol> parameters, 3693var correspondingParameter = getCorrespondingParameter(in result, parameters, interpolatedStringArgNum); 3807var receiverParameter = ((NamedTypeSymbol)methodResult.Member.ContainingSymbol).ExtensionParameter; 3817var parameter = parameters[originalParameterIndex]; 3837var parameter = parameters[originalParameterIndex]; 3911private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter, 5049var parametersPassedToBase = new OrderedSet<ParameterSymbol>(); 5058if (TryGetPrimaryConstructorParameterUsedAsValue(primaryConstructor, analyzedArguments.Argument(i)) is (ParameterSymbol parameter, SyntaxNode syntax)) 5062var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5155private static (ParameterSymbol, SyntaxNode) TryGetPrimaryConstructorParameterUsedAsValue(SynthesizedPrimaryConstructor primaryConstructor, BoundExpression boundExpression) 10033var parameter = property.Parameters[0];

Binder\Binder_Invocation.cs (18)

1262ParameterSymbol receiverParameter = method.Parameters.First(); 1372private BoundExpression CheckAndConvertExtensionReceiver(BoundExpression receiver, ParameterSymbol extensionParameter, BindingDiagnosticBag diagnostics) 1429private BoundExpression GetDefaultParameterSpecialNoConversion(SyntaxNode syntax, ParameterSymbol parameter, BindingDiagnosticBag diagnostics) 1487internal static ParameterSymbol? GetCorrespondingParameter( 1489ImmutableArray<ParameterSymbol> parameters, 1494ParameterSymbol? parameter; 1532ImmutableArray<ParameterSymbol> parameters, 1548var parameter = GetCorrespondingParameter(i, parameters, argsToParamsOpt, expanded); 1609foreach (var parameter in parameters.AsSpan()[..lastIndex]) 1665BoundExpression bindDefaultArgument(SyntaxNode syntax, ParameterSymbol parameter, Symbol? containingMember, bool enableCallerInfo, BindingDiagnosticBag diagnostics, 1836private BoundExpression CreateParamsCollection(SyntaxNode node, ParameterSymbol paramsParameter, ImmutableArray<BoundExpression> collectionArgs, BindingDiagnosticBag diagnostics) 1967!(d.Arguments is [ParameterSymbol shadowedParameter] && shadowedParameter.Type.Equals(typeOrValue.Data.ValueExpression.Type, TypeCompareKind.AllIgnoreOptions))) // If the type and the name match, we would resolve to the same type rather than a value at the end. 2112var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2132var parameterListList = ArrayBuilder<ImmutableArray<ParameterSymbol>>.GetInstance(); 2151private ImmutableArray<BoundExpression> BuildArgumentsForErrorRecovery(AnalyzedArguments analyzedArguments, IEnumerable<ImmutableArray<ParameterSymbol>> parameterListList, BindingDiagnosticBag diagnostics) 2287private static TypeSymbol GetCorrespondingParameterType(AnalyzedArguments analyzedArguments, int i, ImmutableArray<ParameterSymbol> parameterList) 2293foreach (var parameter in parameterList) 2310return BuildArgumentsForErrorRecovery(analyzedArguments, Enumerable.Empty<ImmutableArray<ParameterSymbol>>(), BindingDiagnosticBag.Discarded);

Binder\Binder_Lookup.cs (1)

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

3766var extensionParameter = op.ContainingType.ExtensionParameter; 4100ParameterSymbol parameterSymbol = parameterAccess.ParameterSymbol;

Binder\Binder_Patterns.cs (1)

1080ParameterSymbol? parameter = null;

Binder\Binder_Symbols.cs (2)

1476if (!isPossiblyCapturingPrimaryConstructorParameterReference(receiver, out ParameterSymbol parameter)) 1523bool isPossiblyCapturingPrimaryConstructorParameterReference(BoundExpression receiver, out ParameterSymbol parameterSymbol)

Binder\BinderFactory.BinderFactoryVisitor.cs (4)

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

Binder\ExecutableCodeBinder.cs (1)

112foreach (var parameter in parameters)

Binder\InMethodBinder.cs (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) 335ParameterSymbol thisParameter; 421public static void GetDelegateOrFunctionPointerArguments(SyntaxNode syntax, AnalyzedArguments analyzedArguments, ImmutableArray<ParameterSymbol> delegateParameters, CSharpCompilation compilation) 423foreach (var p in delegateParameters) 425ParameterSymbol parameter = p;

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

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

Binder\Semantics\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)

1312ParameterSymbol final = member.GetParameters().Last(); 2534var m1LastParameter = m1LeastOverriddenParameters[^1]; 2535var m2LastParameter = m2LeastOverriddenParameters[^1]; 2539var parameter1 = getParameterOrExtensionParameter(i, m1.Result, m1LeastOverriddenParameters, m1.LeastOverriddenMember); 2540var parameter2 = getParameterOrExtensionParameter(i, m2.Result, m2LeastOverriddenParameters, m2.LeastOverriddenMember); 2568static TypeSymbol getParameterTypeAndRefKind(int i, MemberAnalysisResult memberResolutionResult, ImmutableArray<ParameterSymbol> parameters, 2571ParameterSymbol parameter = getParameterOrExtensionParameter(i, memberResolutionResult, parameters, member); 2589static ParameterSymbol getParameterOrExtensionParameter(int argIndex, MemberAnalysisResult result, ImmutableArray<ParameterSymbol> parameters, TMember member) 2596ParameterSymbol? extensionParameter = member.ContainingType.ExtensionParameter; 2610ImmutableArray<ParameterSymbol> parameters1, 2612ImmutableArray<ParameterSymbol> parameters2) 2620var p1 = getParameterOrExtensionParameter(i, m1.Result, parameters1, m1.Member); 2621var p2 = getParameterOrExtensionParameter(i, m2.Result, parameters2, m2.Member); 2676private static RefKind GetParameterBetternessRefKind<TMember>(ParameterSymbol parameter, TMember member) where TMember : Symbol 3769private static bool IdenticalParameters(ImmutableArray<ParameterSymbol> p1, ImmutableArray<ParameterSymbol> p2) 3784var param1 = p1[i]; 3785var param2 = p2[i]; 3895ImmutableArray<ParameterSymbol> parameters = member.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 3929var parameter = parameters[parm]; 3954ParameterSymbol parameter, 4066var 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)

928ImmutableArray<ParameterSymbol> parameters = badMember.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: false); 1219ParameterSymbol parameter = parameters[parm]; 1400static bool isStringLiteralToInterpolatedStringHandlerArgumentConversion(BoundExpression argument, ParameterSymbol parameter) 1409static 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\BoundDagTest.cs (1)

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

BoundTree\BoundTreeRewriter.cs (3)

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

BoundTree\Constructors.cs (2)

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

BoundTree\NullabilityRewriter.cs (1)

221case ParameterSymbol param:

BoundTree\UnboundLambda.cs (2)

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

1797case ParameterSymbol _: 3224protected ParameterSymbol GetParameterSymbol( 3225ImmutableArray<ParameterSymbol> parameters, 3229foreach (var symbol in parameters) 3687var thisParam = GetThisParameter(boundNode.Type, containingType, containingMember, out resultKind); 3732private static ParameterSymbol GetThisParameter(TypeSymbol typeOfThis, NamedTypeSymbol containingType, Symbol containingMember, out LookupResultKind resultKind) 3741ParameterSymbol thisParam; 4518ParameterSymbol param = FindNamedParameter(containingInvocationInfo.Symbol.GetSymbol().GetParameters(), argumentName); 4535ParameterSymbol param = FindNamedParameter(invocationSym.GetSymbol().GetParameters(), argumentName); 4557private static ParameterSymbol FindNamedParameter(ImmutableArray<ParameterSymbol> parameters, string argumentName) 4559foreach (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( 2381Debug.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); 2027private ParameterSymbol GetExtensionParameterSymbol( 2051return extensionParameter.GetSymbol<ParameterSymbol>(); 2058private ParameterSymbol GetMethodParameterSymbol( 2095private ParameterSymbol GetIndexerParameterSymbol( 2122private ParameterSymbol GetDelegateParameterSymbol( 2175private ParameterSymbol GetDeclaredNonLambdaParameterSymbol(ParameterSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) 2451Debug.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; 1267ref HashSet<ParameterSymbol> documentedParameters, 1280documentedParameters = new HashSet<ParameterSymbol>(); 1334ParameterSymbol parameter = (ParameterSymbol)referencedSymbol;

Compiler\DocumentationCommentCompiler.DocumentationCommentWalker.cs (3)

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

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (5)

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

Compiler\MethodBodySynthesizer.cs (3)

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

Compiler\MethodBodySynthesizer.Lowered.cs (3)

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

Compiler\MethodCompiler.cs (1)

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

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (3)

75private void VisitParameters(ImmutableArray<ParameterSymbol> parameters, bool isVararg, StringBuilder builder) 80foreach (var parameter in parameters) 242public 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)

1514internal ImmutableArray<Cci.IParameterTypeInformation> Translate(ImmutableArray<ParameterSymbol> @params) 1524return @params.SelectAsArray<ParameterSymbol, Cci.IParameterTypeInformation>(p => p.GetCciAdapter()); 1533private static bool MustBeWrapped(ParameterSymbol param) 1553private ImmutableArray<Cci.IParameterTypeInformation> TranslateAll(ImmutableArray<ParameterSymbol> @params) 1556foreach (var param in @params) 1563private Cci.IParameterTypeInformation CreateParameterTypeInformationWrapper(ParameterSymbol param) 1653internal SynthesizedAttributeData SynthesizeRequiresLocationAttribute(ParameterSymbol symbol) 1664internal SynthesizedAttributeData SynthesizeParamCollectionAttribute(ParameterSymbol symbol) 1844internal SynthesizedAttributeData SynthesizeScopedRefAttribute(ParameterSymbol symbol, ScopedKind scope)

Emitter\Model\PropertySymbolAdapter.cs (2)

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

Emitter\Model\SynthesizedPrivateImplementationDetailsStaticConstructor.cs (1)

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

Emitter\NoPia\EmbeddedTypesManager.cs (1)

629ImmutableArray<ParameterSymbol> underlyingParameters)

FlowAnalysis\AbstractFlowPass.cs (12)

315protected virtual void EnterParameters(ImmutableArray<ParameterSymbol> parameters) 317foreach (var parameter in parameters) 323protected virtual void EnterParameter(ParameterSymbol parameter) 327ImmutableArray<ParameterSymbol> parameters, 331foreach (ParameterSymbol parameter in parameters) 337protected virtual void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location) 465protected ImmutableArray<ParameterSymbol> MethodParameters 470return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 478protected ParameterSymbol MethodThisParameter 482ParameterSymbol thisParameter = null; 1438else if (method.TryGetThisParameter(out var thisParameter) 3046var 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) 1186((ParameterSymbol)symbol).RefKind == RefKind.Out) 1188if (((ParameterSymbol)symbol).IsThis) 1338var self = MethodThisParameter; 1571var param = paramExpr.ParameterSymbol; 1764foreach (var parameter in method.Parameters) 1776if (method.TryGetThisParameter(out ParameterSymbol thisParameter) && thisParameter is not null) 1788if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter)) 1808foreach (var parameter in primaryConstructor.Parameters) 1840protected override void EnterParameter(ParameterSymbol parameter) 1896protected override void LeaveParameters(ImmutableArray<ParameterSymbol> parameters, SyntaxNode syntax, Location location) 1907protected override void LeaveParameter(ParameterSymbol parameter, SyntaxNode syntax, Location location)

FlowAnalysis\NullableWalker.cs (83)

FlowAnalysis\NullableWalker.Variables.cs (1)

358case ParameterSymbol:

FlowAnalysis\ReadWriteWalker.cs (6)

85foreach (var p in m.Parameters) 90if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter) && extensionParameter.RefKind != RefKind.None) 99var thisParameter = m.ThisParameter; 130protected override void NoteRead(Symbol variable, ParameterSymbol rangeVariableUnderlyingParameter = null) 291ParameterSymbol rangeVariableUnderlyingParameter = GetRangeVariableUnderlyingParameter(node.Value); 300private static ParameterSymbol GetRangeVariableUnderlyingParameter(BoundNode underlying)

FlowAnalysis\UnassignedVariablesWalker.cs (1)

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

FlowAnalysis\VariablesDeclaredWalker.cs (2)

105foreach (var parameter in node.Symbol.Parameters) 118foreach (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)

55var thisParameter = rewriter._factory.CurrentFunction.ThisParameter; 65rewriter._proxies.Add(thisParameter, new CapturedToExpressionSymbolReplacement<ParameterSymbol>(hoistedThis, hoistedSymbols: [], isReusable: true)); 305var 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, 614var potentialParameter = lambda.Parameters[i]; 758var parameter = (ParameterSymbol)symbol; 759ParameterSymbol parameterToUse; 826ParameterSymbol replacementParameter; 1554foreach (var parameter in node.Symbol.Parameters) 1561var oldFrameThis = _currentFrameThis;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (5)

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

Lowering\ClosureConversion\LambdaCapturedVariable.cs (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; 176private readonly ParameterSymbol _parameter; 178public LambdaCapturedVariableForRegularParameter(SynthesizedClosureEnvironment frame, TypeWithAnnotations type, string fieldName, ParameterSymbol parameter) 187ParameterSymbol definition = _parameter.OriginalDefinition;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

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

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

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

305foreach (var parameter in _factory.CurrentFunction.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: true)) 440ParameterSymbol parameter, 494ParameterSymbol 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 (1)

1149ParameterSymbol? extensionParameter = member.ContainingType.ExtensionParameter;

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

189ParameterSymbol parameter = method.Parameters[i];

Lowering\LocalRewriter\LocalRewriter_Call.cs (9)

244ParameterSymbol? methodThisParameter; 247ParameterSymbol? interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 248interceptor.TryGetThisParameter(out var interceptorThisParameter) ? interceptorThisParameter : null; 844ImmutableArray<ParameterSymbol> parameters, 1077ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters(); 1216private static ImmutableArray<RefKind> GetEffectiveArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters) 1241static void fillRefKindsBuilder(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters, [NotNull] ref ArrayBuilder<RefKind>? refKindsBuilder) 1401ImmutableArray<ParameterSymbol> parameters, 1684ImmutableArray<ParameterSymbol> parameters,

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)

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

Lowering\StateMachineRewriter\StateMachineRewriter.cs (5)

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

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)

56public override ImmutableArray<ParameterSymbol> Parameters

Lowering\SynthesizedMethodBaseSymbol.cs (6)

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)

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

Operations\CSharpOperationFactory_Methods.cs (3)

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

Symbols\AbstractTypeMap.cs (1)

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

Symbols\AnonymousTypes\PublicSymbols\AnonymousManager.TypeOrDelegatePublicSymbol.cs (1)

50internal sealed override ParameterSymbol? ExtensionParameter => null;

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

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

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

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

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

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

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

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

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

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

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

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

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TypeOrDelegateTemplateSymbol.cs (1)

128internal 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) 1023foreach (var param in sig.Parameters) 1079internal class SpecialMembersSignatureComparer : SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> 1149protected override ImmutableArray<ParameterSymbol> GetParameters(MethodSymbol method) 1154protected override ImmutableArray<ParameterSymbol> GetParameters(PropertySymbol property) 1159protected override TypeSymbol GetParamType(ParameterSymbol parameter) 1188protected override bool IsByRefParam(ParameterSymbol parameter)

Symbols\ErrorMethodSymbol.cs (2)

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

Symbols\ErrorPropertySymbol.cs (2)

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

Symbols\ErrorTypeSymbol.cs (1)

109internal sealed override ParameterSymbol? ExtensionParameter => null;

Symbols\Extensions\ReceiverParameterSymbol.cs (1)

14public ReceiverParameterSymbol(NamedTypeSymbol containingType, ParameterSymbol originalParameter) :

Symbols\Extensions\RewrittenLambdaOrLocalFunctionSymbol.cs (4)

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

Symbols\Extensions\RewrittenMethodSymbol.cs (4)

15private ImmutableArray<ParameterSymbol> _lazyParameters; 99public sealed override ImmutableArray<ParameterSymbol> Parameters 111protected abstract ImmutableArray<ParameterSymbol> MakeParameters(); 122public RewrittenMethodParameterSymbol(RewrittenMethodSymbol containingMethod, ParameterSymbol originalParameter) :

Symbols\Extensions\RewrittenParameterSymbol.cs (1)

11public RewrittenParameterSymbol(ParameterSymbol originalParameter) :

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (6)

118protected override ImmutableArray<ParameterSymbol> MakeParameters() 121var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(ParameterCount); 128foreach (var parameter in sourceParameters) 137internal static int GetImplementationParameterOrdinal(ParameterSymbol underlyingParameter) 154internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 186public 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 (6)

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) 448foreach (ParameterSymbol param in method.Parameters) 497foreach (ParameterSymbol param in property.Parameters)

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

367foreach (var param in sig.Parameters)

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

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

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

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

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

34public readonly ImmutableArray<ParameterSymbol> Parameters; 37public SignatureData(SignatureHeader header, ImmutableArray<ParameterSymbol> parameters, PEParameterSymbol returnParam) 305public ParameterSymbol _lazyThisParameter; 439internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 662public override ImmutableArray<ParameterSymbol> Parameters => Signature.Parameters; 851ImmutableArray<ParameterSymbol> @params; 856var builder = ImmutableArray.CreateBuilder<ParameterSymbol>(count); 873@params = ImmutableArray<ParameterSymbol>.Empty; 1131var parameter = parameters[0]; 1548foreach (var param in Parameters)

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

189public StrongBox<ParameterSymbol?>? LazyExtensionParameter; 408internal sealed override ParameterSymbol? ExtensionParameter 421var extensionParameter = makeExtensionParameter(this, uncommon); 422Interlocked.CompareExchange(ref uncommon.LazyExtensionParameter, new StrongBox<ParameterSymbol?>(extensionParameter), null); 427static ParameterSymbol? makeExtensionParameter(PENamedTypeSymbol @this, ExtensionInfo uncommon)

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

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

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

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

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

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

Symbols\MethodSymbol.cs (5)

283internal ParameterSymbol? ThisParameter 287ParameterSymbol? thisParameter; 301internal virtual bool TryGetThisParameter(out ParameterSymbol? thisParameter) 328public abstract ImmutableArray<ParameterSymbol> Parameters { get; } 1242ImmutableArray<IParameterSymbolInternal> IMethodSymbolInternal.Parameters => Parameters.Cast<ParameterSymbol, IParameterSymbolInternal>();

Symbols\NamedTypeSymbol.cs (3)

374var thisParam = method.Parameters.First(); 388private static bool IsValidExtensionReceiverParameter(ParameterSymbol thisParam) 630internal abstract ParameterSymbol? ExtensionParameter { get; }

Symbols\NativeIntegerTypeSymbol.cs (9)

188internal sealed override ParameterSymbol? ExtensionParameter => null; 341private ImmutableArray<ParameterSymbol> _lazyParameters; 362public override ImmutableArray<ParameterSymbol> Parameters 368var parameters = UnderlyingMethod.Parameters.SelectAsArray((p, m) => (ParameterSymbol)new NativeIntegerParameterSymbol(m._container, m, p), this); 375internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 377if (UnderlyingMethod.TryGetThisParameter(out ParameterSymbol? underlyingThisParameter)) 436internal NativeIntegerParameterSymbol(NativeIntegerTypeSymbol containingType, NativeIntegerMethodSymbol container, ParameterSymbol underlyingParameter) : base(underlyingParameter) 504public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty;

Symbols\OverriddenOrHiddenMembersHelpers.cs (1)

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

Symbols\ParameterSignature.cs (3)

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

Symbols\ParameterSymbol.cs (1)

30public new virtual ParameterSymbol OriginalDefinition

Symbols\PropertySymbol.cs (1)

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

Symbols\PropertySymbolExtensions.cs (1)

71foreach (ParameterSymbol param in property.Parameters)

Symbols\PublicModel\ParameterSymbol.cs (2)

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

Symbols\ReducedExtensionMethodSymbol.cs (6)

28private ImmutableArray<ParameterSymbol> _lazyParameters; 520public override ImmutableArray<ParameterSymbol> Parameters 558private ImmutableArray<ParameterSymbol> MakeParameters() 566return ImmutableArray<ParameterSymbol>.Empty; 570var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count - 1); 622public ReducedExtensionMethodParameterSymbol(ReducedExtensionMethodSymbol containingMethod, ParameterSymbol underlyingParameter) :

Symbols\Retargeting\RetargetingMethodSymbol.cs (7)

38private ImmutableArray<ParameterSymbol> _lazyParameters; 151public override ImmutableArray<ParameterSymbol> Parameters 164private ImmutableArray<ParameterSymbol> RetargetParameters() 171return ImmutableArray<ParameterSymbol>.Empty; 175var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(count); 261internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 263if (!_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)

29protected RetargetingParameterSymbol(ParameterSymbol underlyingParameter) 171public RetargetingMethodParameterSymbol(RetargetingMethodSymbol retargetingMethod, ParameterSymbol underlyingParameter) 193public RetargetingPropertyParameterSymbol(RetargetingPropertySymbol retargetingProperty, ParameterSymbol underlyingParameter) 215public RetargetingExtensionReceiverParameterSymbol(RetargetingNamedTypeSymbol retargetingType, ParameterSymbol underlyingParameter)

Symbols\Retargeting\RetargetingPropertySymbol.cs (7)

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

Symbols\Retargeting\RetargetingSymbolTranslator.cs (4)

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

Symbols\SignatureOnlyMethodSymbol.cs (3)

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

Symbols\SignatureOnlyPropertySymbol.cs (3)

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

Symbols\Source\CustomModifierUtils.cs (7)

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

Symbols\Source\ExplicitInterfaceHelpers.cs (2)

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)

178internal sealed override ParameterSymbol ExtensionParameter => null;

Symbols\Source\LambdaSymbol.cs (6)

22private readonly ImmutableArray<ParameterSymbol> _parameters; 203public override ImmutableArray<ParameterSymbol> Parameters 208internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 283foreach (var parameter in _parameters) 322private ImmutableArray<ParameterSymbol> MakeParameters( 343var builder = ArrayBuilder<ParameterSymbol>.GetInstance(unboundLambda.ParameterCount);

Symbols\Source\LocalFunctionSymbol.cs (5)

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

Symbols\Source\ParameterHelpers.cs (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) 1316ImmutableArray<ParameterSymbol> containingSymbolParameters = ContainingSymbol.GetParameters(); 1317ParameterSymbol? extensionParameter = ContainingType.ExtensionParameter; 1417var 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 220InitializeParameters(ImmutableArray.Create<ParameterSymbol>( 291InitializeParameters(parameters.Cast<SourceParameterSymbol, ParameterSymbol>()); 358var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 398var parameters = ArrayBuilder<ParameterSymbol>.GetInstance(); 421private static string GetUniqueParameterName(ArrayBuilder<ParameterSymbol> currentParameters, string name) 431private static bool IsUnique(ArrayBuilder<ParameterSymbol> currentParameters, string name) 433foreach (var p in currentParameters)

Symbols\Source\SourceDestructorSymbol.cs (2)

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

4455private static bool ParametersMatchPropertyAccessor(PropertySymbol propertySymbol, bool getNotSet, ImmutableArray<ParameterSymbol> methodParams) 4466var methodParam = methodParams[i]; 4486private static bool ParametersMatchEventAccessor(EventSymbol eventSymbol, ImmutableArray<ParameterSymbol> methodParams) 4879ctor.Parameters.SelectAsArray<ParameterSymbol, ParameterSymbol>(param => new SignatureOnlyParameterSymbol(param.TypeWithAnnotations, 4926ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 4979ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol( 5039ImmutableArray<ParameterSymbol>.Empty, 5107ImmutableArray<Symbol> addProperties(ImmutableArray<ParameterSymbol> recordParameters) 5111foreach (ParameterSymbol param in recordParameters) 5118ImmutableArray<ParameterSymbol>.Empty, 5189bool checkMemberNotHidden(Symbol symbol, ParameterSymbol param) 5213ImmutableArray<ParameterSymbol>.Empty, 5244ImmutableArray<ParameterSymbol>.Empty, 5306ImmutableArray.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); 1157if (RequiresValidScopedOverrideForRefSafety(overriddenMethod, overridingMethod.TryGetThisParameter(out var thisParam) ? thisParam : null)) 1229(BindingDiagnosticBag diagnostics, MethodSymbol overriddenMethod, MethodSymbol overridingMethod, ParameterSymbol overridingParameter, bool topLevel, Location location) 1298var baseParameter = baseParameters[i]; 1301var overrideParameter = overrideParameters[parameterIndex]; 1335var overrideParam = overrideParameters[i + overrideParameterOffset]; 1336var baseParam = baseParameters[i]; 1381internal static bool RequiresValidScopedOverrideForRefSafety(MethodSymbol? method, ParameterSymbol? overrideThisParameter) 1474var baseParameter = baseParameters[i]; 1475var overrideParameter = overrideParameters[i + overrideParameterOffset]; 1507ReportMismatchInParameterType<(ParameterSymbol BaseParameter, TArg Arg)> reportMismatchInParameterType, 1525var baseParameter = baseParameters[i]; 1526var 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) 844internal sealed override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 920foreach (var parameter in this.Parameters) 1027foreach (var parameter in method.Parameters)

Symbols\Source\SourceMethodSymbol.cs (2)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

777foreach (var param in this.Parameters) 1408foreach (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) 176public sealed override ImmutableArray<ParameterSymbol> Parameters 235foreach (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; 326public sealed override ImmutableArray<ParameterSymbol> Parameters 767private ImmutableArray<ParameterSymbol> ComputeParameters() 776return ImmutableArray<ParameterSymbol>.Empty; 779var 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; 668public sealed override ImmutableArray<ParameterSymbol> Parameters 1804foreach (var parameter in this.Parameters) 1913protected 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)

30private ImmutableArray<ParameterSymbol> _lazyParameters; 251public sealed override ImmutableArray<ParameterSymbol> Parameters 316internal sealed override bool TryGetThisParameter(out ParameterSymbol? thisParameter) 323ParameterSymbol? originalThisParameter; 341private ImmutableArray<ParameterSymbol> SubstituteParameters() 348return ImmutableArray<ParameterSymbol>.Empty; 352var substituted = ArrayBuilder<ParameterSymbol>.GetInstance(count); 354foreach (var p in unsubstitutedParameters)

Symbols\SubstitutedNamedTypeSymbol.cs (5)

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

Symbols\SubstitutedParameterSymbol.cs (5)

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

Symbols\SubstitutedPropertySymbol.cs (5)

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

Symbols\Symbol.cs (7)

1246internal bool DeriveUseSiteInfoFromParameter(ref UseSiteInfo<AssemblySymbol> result, ParameterSymbol param) 1255internal bool DeriveUseSiteInfoFromParameters(ref UseSiteInfo<AssemblySymbol> result, ImmutableArray<ParameterSymbol> parameters) 1257foreach (ParameterSymbol param in parameters) 1380internal static bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, ImmutableArray<ParameterSymbol> parameters, Symbol owner, ref HashSet<TypeSymbol> checkedTypes) 1382foreach (var parameter in parameters) 1685builder.AddValue(((ParameterSymbol)this).TypeWithAnnotations); 1761&& variable is ParameterSymbol { ContainingSymbol: NamedTypeSymbol { IsExtension: true } })

Symbols\SymbolDistinguisher.cs (1)

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

Symbols\SymbolExtensions.cs (8)

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

Symbols\SymbolVisitor.cs (1)

90public virtual void VisitParameter(ParameterSymbol symbol)

Symbols\SymbolVisitor`1.cs (1)

90public virtual TResult VisitParameter(ParameterSymbol symbol)

Symbols\SymbolVisitor`2.cs (2)

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

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

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

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

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

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

181internal sealed override ParameterSymbol? ExtensionParameter => null;

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

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

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

858internal 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>(); 114IReadOnlyDictionary<ParameterSymbol, FieldSymbol> capturedParameters = GetCapturedParameters(); 124public IReadOnlyDictionary<ParameterSymbol, FieldSymbol> GetCapturedParameters() 133_capturedParameters = SpecializedCollections.EmptyReadOnlyDictionary<ParameterSymbol, FieldSymbol>(); 191public IReadOnlySet<ParameterSymbol> GetParametersPassedToTheBase() 202_parametersPassedToTheBase = SpecializedCollections.EmptyReadOnlySet<ParameterSymbol>(); 208internal void SetParametersPassedToTheBase(IReadOnlySet<ParameterSymbol> value) 220foreach (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)

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

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

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

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

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

20ParameterSymbol backingParameter, 94protected override (TypeWithAnnotations Type, ImmutableArray<ParameterSymbol> Parameters) MakeParametersAndBindType(BindingDiagnosticBag diagnostics) 97ImmutableArray<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\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 181public override ImmutableArray<ParameterSymbol> Parameters { get; }

Symbols\Synthesized\SynthesizedEmbeddedAttributeSymbol.cs (5)

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

Symbols\Synthesized\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (4)

41ImmutableArray<ParameterSymbol> getConstructorParameters(MethodSymbol ctor) 46void getConstructorBody(SyntheticBoundNodeFactory f, ArrayBuilder<BoundStatement> statements, ImmutableArray<ParameterSymbol> parameters) 109public override ImmutableArray<ParameterSymbol> Parameters => []; 174public override ImmutableArray<ParameterSymbol> Parameters => [];

Symbols\Synthesized\SynthesizedEmbeddedLifetimeAnnotationAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (7)

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

Symbols\Synthesized\SynthesizedEmbeddedNullableContextAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedNullablePublicOnlyAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedRefSafetyRulesAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (6)

338private readonly ImmutableArray<ParameterSymbol> _parameters; 393public override ImmutableArray<ParameterSymbol> Parameters => _parameters; 459public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 536private readonly ImmutableArray<ParameterSymbol> _parameters; 555public 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)

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

112internal 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")); 255public 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)

95internal 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; 152public 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\TypeSymbol.cs (1)

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

Symbols\TypeSymbolExtensions.cs (4)

574public static ImmutableArray<ParameterSymbol> DelegateParameters(this TypeSymbol type) 579return default(ImmutableArray<ParameterSymbol>); 584public static ImmutableArray<ParameterSymbol> DelegateOrFunctionPointerParameters(this TypeSymbol type) 2059foreach (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)