164public override ImmutableArray<ParameterSymbol> Parameters

92public sealed override ImmutableArray<ParameterSymbol> Parameters

63public override ImmutableArray<ParameterSymbol> Parameters

48public override ImmutableArray<ParameterSymbol> Parameters

52public override ImmutableArray<ParameterSymbol> Parameters

49public override ImmutableArray<ParameterSymbol> Parameters

52public override ImmutableArray<ParameterSymbol> Parameters

145public override ImmutableArray<ParameterSymbol> Parameters

96public sealed override ImmutableArray<ParameterSymbol> Parameters

769public override ImmutableArray<ParameterSymbol> Parameters =>

658public override ImmutableArray<ParameterSymbol> Parameters => Signature.Parameters;

358public override ImmutableArray<ParameterSymbol> Parameters

520public override ImmutableArray<ParameterSymbol> Parameters

151public override ImmutableArray<ParameterSymbol> Parameters

87public override ImmutableArray<ParameterSymbol> Parameters { get { return _parameters; } }

203public override ImmutableArray<ParameterSymbol> Parameters

174public override ImmutableArray<ParameterSymbol> Parameters

131public sealed override ImmutableArray<ParameterSymbol> Parameters

136public sealed override ImmutableArray<ParameterSymbol> Parameters

105public override ImmutableArray<ParameterSymbol> Parameters

178public sealed override ImmutableArray<ParameterSymbol> Parameters

176public sealed override ImmutableArray<ParameterSymbol> Parameters

326public sealed override ImmutableArray<ParameterSymbol> Parameters

251public sealed override ImmutableArray<ParameterSymbol> Parameters

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

392public override ImmutableArray<ParameterSymbol> Parameters => _parameters; 458public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 553public override ImmutableArray<ParameterSymbol> Parameters

174public override ImmutableArray<ParameterSymbol> Parameters

110public sealed override ImmutableArray<ParameterSymbol> Parameters

35public override ImmutableArray<ParameterSymbol> Parameters

134public override ImmutableArray<ParameterSymbol> Parameters

255public override ImmutableArray<ParameterSymbol> Parameters

217public override ImmutableArray<ParameterSymbol> Parameters

147public override ImmutableArray<ParameterSymbol> Parameters

80public override ImmutableArray<ParameterSymbol> Parameters

438var parameters = accessorForDefaultArguments.Parameters; 3540methodSymbol.Parameters, 3623methodSymbol.Parameters, 3865methodSymbol.Parameters, 3948methodSymbol.Parameters, 4262call.Method.Parameters, 4332call.Method.Parameters, 4387constructorSymbol.Parameters, 4432unaryMethod.Parameters, 4485operatorMethod.Parameters, 4522incrementMethod.Parameters, 4546compoundMethod.Parameters, 4571binaryMethod.Parameters, 4595uo.LogicalOperator.Parameters, 4695if (constructMethod is not { Parameters: [{ RefKind: RefKind.None } parameter] }) 4804methodInfo.Method.Parameters, 5014methodSymbol.Parameters, 5102methodSymbol.Parameters, 5169constructorSymbol.Parameters, 5236unaryMethod.Parameters, 5304operatorMethod.Parameters, 5343incrementMethod.Parameters, 5369compoundMethod.Parameters, 5403binaryMethod.Parameters, 5435uo.LogicalOperator.Parameters, 5852call.Method.Parameters[0].EffectiveScope == ScopedKind.ScopedValue)

238attributeConstructor.Parameters, 250if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter)) 300ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 710ImmutableArray<ParameterSymbol> parameters = attributeConstructor.Parameters;

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

580method.Parameters[0].Type is ArrayTypeSymbol { IsSZArray: true, ElementType: TypeParameterSymbol }); 590static (readonlySpanType, method) => method.Parameters[0].Type.IsSpan() && 636Parameters: [{ } parameter], 669Parameters: [{ Type.SpecialType: SpecialType.System_String }] 1061var parameterType = (NamedTypeSymbol)collectionBuilderMethod.Parameters[0].Type; 1480bool thisTypeIsOpen = typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0]); 1493if (!typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[1])) 1515TypeSymbol secondArgumentType = (constructed ?? member).Parameters[1].Type; 1542var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1549else if (typeParameters.Any((typeParameter, parameter) => !parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0])) 1893if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 1911var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2842var delegateOrFuncPtrParameters = delegateOrFuncPtrMethod.Parameters; 2843var methodParameters = method.Parameters; 2992return method.Parameters[0];

750foreach (var param in signature.Parameters)

685var parameters = deconstructMethod.Parameters;

5050var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 5071BindDefaultArguments(nonNullSyntax, resultMember.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParamsOpt, out var defaultArguments, expanded, enableCallerInfo, diagnostics); 6830BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 10481original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10482original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 11183var parameters = methodSymbol.Parameters;

942argumentSyntax, singleCandidate.Parameters.Last().Name, singleCandidate.Name); 1241BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, analyzedArguments.Names, ref argsToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 1254ParameterSymbol receiverParameter = method.Parameters.First();

467BoundExpression rightConverted = CreateConversion(right, overloadResolutionResult.ValidResult.Result.ConversionForArg(isExtension ? 1 : 0), method.Parameters[0].Type, diagnostics); 505rightType: method.Parameters[0].Type, 1485var trueFalseParameterType = (resultKind.Operator() == BinaryOperatorKind.And ? falseOperator : trueOperator).Parameters[0].Type; 1602TypeSymbol parameterType = userDefinedOperator.Parameters[0].Type; 3677(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In);

1075parameter = deconstructMethod.Parameters[parameterIndex];

1249return new WithParametersBinder(method.Parameters, nextBinder); 1293parameters = parameters.Add(property.SetMethod.Parameters.Last()); 1310ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

541var element = new BoundDagTemp(syntax, method.Parameters[i + extensionExtra].Type, evaluation, i);

1035Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.IsExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty)); 1044builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type; 1119if (getEnumeratorMethod?.Parameters[0].IsOptional == false) 1240patternDisposeMethod.Parameters, 1496result.Parameters, 1569var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1582result.Parameters[0].Type); 1976method.Parameters,

207var parameters = _methodSymbol.Parameters; 233foreach (var parameter in _methodSymbol.Parameters) 333var parameters = _methodSymbol.Parameters;

311MethodSymbol methodSymbol => methodSymbol.Parameters, 329return method.Parameters; 343return method.Parameters; 357return invokeMethod.Parameters;

543int count = method.Parameters.Length - extensionExtra; 547var elementTemp = new BoundDagTemp(e.Syntax, method.Parameters[j + extensionExtra].Type, e, j);

561compoundMethod.Parameters, 575compoundMethod.Parameters, 644return method.Parameters is [{ } firstParameter, ..] ? firstParameter : null; 728method.Parameters, 830constructor.Parameters, 859constructor.Parameters, 1013var parameters = deconstructMethod.Parameters;

257GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 339thisParameter = method.Parameters[0]; 403GetDelegateOrFunctionPointerArguments(syntax, analyzedArguments, delegateInvokeMethod.Parameters, Compilation);

1494var delegateParameters = invokeMethod.Parameters;

1607return SourceUserDefinedOperatorSymbolBase.ExtensionOperatorParameterTypeMatchesExtendedType(method.Parameters[paramIndex].Type, extensionParameter.Type);

286foreach (var parameter in op.OriginalDefinition.AsMember(groupingKey.NormalizedExtension).Parameters)

3688if (!IdenticalParameters(invoke1.Parameters, invoke2.Parameters))

214disposeMethod.Parameters,

38foreach (var parameter in _lazyPrimaryCtorWithParameters.Parameters) 83var parameters = _lazyPrimaryCtorWithParameters.Parameters;

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

1130foreach (var p in invoke.Parameters)

20parameters: node.Method.Parameters); 31parameters: node.Constructor.Parameters);

383var parameters = m.Parameters;

1665EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 2010EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 2468EmitArguments(expression.Arguments, constructor.Parameters, expression.ArgumentRefKindsOpt); 2654if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2731EmitArguments(objCreation.Arguments, constructor.Parameters, objCreation.ArgumentRefKindsOpt);

1197var rewrittenArguments = VisitArguments(node.Arguments, node.Method.Parameters, node.ArgumentRefKindsOpt); 1328var rewrittenArguments = VisitArguments(node.Arguments, constructor.Parameters, node.ArgumentRefKindsOpt);

2255if (method.Parameters.Length == 0) 2260if (method.Parameters.Length > 1) 2270var firstType = method.Parameters[0].TypeWithAnnotations;

856return GetParameterSymbol(localFunction.Parameters, parameter, cancellationToken);

2092return GetParameterSymbol(method.Parameters, parameter, cancellationToken); 2152return GetParameterSymbol(delegateInvoke.Parameters, parameter, cancellationToken);

283retExpression = F.StaticCall(manager.System_String, formatMethod, F.Null(formatMethod.Parameters[0].Type), format, F.ArrayOrEmpty(manager.System_Object, arguments));

256CheckParameterCompliance(symbol.DelegateInvokeMethod.Parameters, symbol); 315CheckForMeaninglessOnParameter(symbol.Parameters); 330CheckParameterCompliance(symbol.Parameters, symbol.ContainingType); 477CheckForMeaninglessOnParameter(method.Parameters); 484CheckForMeaninglessOnParameter(method.Parameters);

658return delegateInvoke.Parameters;

563parameters = ((MethodSymbol)memberSymbol).Parameters; 573parameters = typeSymbol.DelegateInvokeMethod.Parameters;

92var submissionArrayReference = new BoundParameter(syntax, submissionConstructor.Parameters[0]) { WasCompilerGenerated = true }; 198var parameter = accessor.Parameters[0]; 296accessor.Parameters[0]); 387parameterSymbol: accessor.Parameters[0])

460foreach (var param in F.CurrentFunction.Parameters)

111if (symbol.Parameters.Any() || symbol.IsVararg) 113s_parameterOrReturnTypeInstance.VisitParameters(symbol.Parameters, symbol.IsVararg, builder);

523invokeMethod.Parameters.SequenceEqual(otherInvokeMethod.Parameters, 610method.Parameters.SequenceEqual(other.Parameters, AreParametersEqual) &&

82return moduleBeingBuilt.Translate(UnderlyingMethod.Parameters);

201return moduleBeingBuilt.Translate(AdaptedMethodSymbol.Parameters); 207Debug.Assert(AdaptedMethodSymbol.Parameters.All(p => p.IsDefinition)); 210return AdaptedMethodSymbol.Parameters.SelectAsArray<ParameterSymbol, Cci.IParameterDefinition>(p => p.GetCciAdapter());

42return EmbeddedTypesManager.EmbedParameters(this, UnderlyingMethod.AdaptedMethodSymbol.Parameters);

147ImmutableArray.Create(new TypedConstant(ctor.Parameters[0].Type, TypedConstantKind.Type, ctor.ContainingAssembly.GetSpecialType(SpecialType.System_Object))),

470return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 1556if (method is null || Binder.GetCorrespondingParameter(i, method.Parameters, argsToParamsOpt, expanded)?.RefKind.IsWritableReference() != false) 3045var param = method.Parameters[0];

91if (!localFunc.WasCompilerGenerated) EnterParameters(localFuncSymbol.Parameters); 116LeaveParameters(localFuncSymbol.Parameters, localFunc.Syntax, location); 127LeaveParameters(localFuncSymbol.Parameters,

46MakeSlots(node.Symbol.Parameters); 52MakeSlots(node.Symbol.Parameters);

1813foreach (var parameter in method.Parameters) 2450if (!node.WasCompilerGenerated) EnterParameters(node.Symbol.Parameters); 2456LeaveParameters(node.Symbol.Parameters, node.Syntax, null); 2465LeaveParameters(node.Symbol.Parameters, pending.Branch.Syntax, null);

2965var methodParameters = methodSymbol.Parameters; 2966var signatureParameters = (_useDelegateInvokeParameterTypes ? _delegateInvokeMethod! : methodSymbol).Parameters; 3777return invokeMethod!.Parameters.SequenceEqual(l.Parameters, 3920var reinferredParameter = reinferredAddMethod.Parameters[argIndex]; 4080node, arguments, node.ArgumentRefKindsOpt, constructor?.Parameters ?? default, 4148argumentsCompletion(argumentResults, constructor?.Parameters ?? default, constructor); 4537addMethod.Parameters, 4593node, containingType, visitArgumentsCompletion.Invoke(argumentResults, addMethod.Parameters, addMethod).member, 5072if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 5073(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 5326var parameters = method.Parameters; 6517annotations = GetCorrespondingParameter(0, node.Method.Parameters, node.ArgsToParamsOpt, node.Expanded, ref paramsIterationType).Annotations; 6632ImmutableArray<ParameterSymbol> parameters = getParameters(method.Parameters, adjustForNewExtension, method); 6787var parameterType = method.Parameters[0].TypeWithAnnotations; 7151return VisitArguments(node, arguments, refKindsOpt, method is null ? default : method.Parameters, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod, method); 9361NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 9886var parameter = method.Parameters[0]; 10185method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod); 10348ParameterSymbol? receiverParameter = isNewExtensionMethod ? method.ContainingType.ExtensionParameter : method.Parameters[0]; 10729var parameters = deconstructMethod.Parameters; 10737var receiverParameter = isNewExtension ? deconstructMethod.ContainingType.ExtensionParameter : deconstructMethod.Parameters[0]; 11043targetTypeOfOperandConversion = incrementOperator.Parameters[0].TypeWithAnnotations; 11051parameter = incrementOperator.Parameters[0]; 11979var parameter = method.Parameters[0]; 12201var parameters = logicalOperator.Parameters; 12212var trueFalseParameter = trueFalseOperator.Parameters[0];

451var parameterType = method.Parameters[i + extensionExtra].TypeWithAnnotations;

85foreach (var p in m.Parameters)

105foreach (var parameter in node.Symbol.Parameters) 118foreach (var parameter in node.Symbol.Parameters)

142if (_isEnumerable && this.method.Parameters.Any(static p => !p.IsExtensionParameterImplementation() && p.HasEnumeratorCancellationAttribute)) 169bodyBuilder.Add(F.Assignment(F.InstanceField(stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state; 233BoundParameter tokenParameter = F.Parameter(getEnumeratorMethod.Parameters[0]); 513F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetResult, F.Parameter(IValueTaskSourceOfBool_GetResult.Parameters[0])))); 538F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetStatus, F.Parameter(IValueTaskSourceOfBool_GetStatus.Parameters[0])))); 566F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[0]), 567F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[1]), 568F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[2]), 569F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[3]))), 591F.ExpressionStatement(F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetResult, F.Parameter(IValueTaskSource_GetResult.Parameters[0]))), 615F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetStatus, F.Parameter(IValueTaskSource_GetStatus.Parameters[0])))); 639F.Parameter(IValueTaskSource_OnCompleted.Parameters[0]), 640F.Parameter(IValueTaskSource_OnCompleted.Parameters[1]), 641F.Parameter(IValueTaskSource_OnCompleted.Parameters[2]), 642F.Parameter(IValueTaskSource_OnCompleted.Parameters[3]))),

185new BoundExpression[] { F.Parameter(F.CurrentFunction.Parameters[0]) })),

390DeclareLocals(_currentScope, _topLevelMethod.Parameters); 594DeclareLocals(_currentScope, functionSymbol.Parameters, _inExpressionTree);

1554foreach (var parameter in node.Symbol.Parameters)

702var conversionInputType = method.Parameters[0].Type; 709? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 767unquoted = _bound.Call(_bound.MethodInfo(method, createDelegate.ContainingType), createDelegate, _bound.Typeof(delegateType, createDelegate.Parameters[0].Type), receiver); 774_bound.Typeof(delegateType, createDelegate.Parameters[0].Type), 776_bound.MethodInfo(method, createDelegate.Parameters[2].Type)); 839foreach (var p in node.Symbol.Parameters) 860foreach (var p in node.Symbol.Parameters)

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

617foreach (var p in lambda.Parameters)

244if (method.Parameters[i].RefKind != RefKind.None && (argumentRefKindsOpt.IsDefault || argumentRefKindsOpt[i] == RefKind.None)) return true;

59Debug.Assert(symbol.Parameters.Length == rewrittenParameters.Length); 64foreach (var parameter in symbol.Parameters)

105var receiverRefKind = method.Parameters[0].RefKind; 123Debug.Assert(receiverOpt.Type!.Equals(method.Parameters[0].Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));

305foreach (var parameter in _factory.CurrentFunction.Parameters) 316MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)parameter.Ordinal))))); 405MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, assignment, refAssignmentSourceIndex, targetIndex)) 535MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex))); 598MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex)));

186member is MethodSymbol { Parameters: [.., { RefKind: RefKind.None, Type: { } lastParamType }] parametersWithCancellationToken } overload && 189methodDefinition.Parameters.Length == parametersWithCancellationToken.Length - 1 && 196methodDefinition.Parameters.AsSpan(), 198parametersWithCancellationToken.AsSpan(0, methodDefinition.Parameters.Length),

282bodyBuilder.Add(F.Assignment(F.Field(F.This(), stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state;

334delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 337if (node.Symbol.Parameters.LastOrDefault(static (p) => p.IsParamsCollection) is { } parameter) 1128symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

189ParameterSymbol parameter = method.Parameters[i]; 247Debug.Assert(e.Property.GetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Int32);

769var parameterType = leftTruthOperator.Parameters[0].Type;

247ParameterSymbol? interceptorThisParameterForCompare = needToReduce ? interceptor.Parameters[0] : 267this._diagnostics.Add(ErrorCode.ERR_InterceptorMustHaveMatchingThisParameter, attributeLocation, method.Parameters[0], method); 296Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 297|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 298receiverOpt = MakeConversionNode(receiverOpt, interceptor.Parameters[0].Type, @checked: false, markAsChecked: true); 322argumentRefKindsOpt = method.Parameters.SelectAsArray(static param => param.RefKind); 1241return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol;

177if (!ShouldUseIEnumerableBulkAddMethod(singleSpread.Expression.Type, toListOfElementType.Parameters[0].Type, singleSpread.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 225ConversionsBase.HasIdentityConversion(builder.Parameters[0].Type, spreadType) && 226(!builder.ReturnType.IsRefLikeType || builder.Parameters[0].EffectiveScope == ScopedKind.ScopedValue)) 327Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions)); 479var spanType = (NamedTypeSymbol)constructMethod.Parameters[0].Type; 680&& ShouldUseIEnumerableBulkAddMethod(spreadExpression.Type!, linqToArrayMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method)) 1182if (!ShouldUseIEnumerableBulkAddMethod(rewrittenSpreadOperand.Type, addRangeMethod.Parameters[0].Type, spreadElement.EnumeratorInfoOpt?.GetEnumeratorInfo.Method))

744delegateInvoke.Parameters.Any(static (p) => p.IsParamsCollection)) 1764Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1870Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked);

310BoundExpression eventInfo = _factory.New(ctor, _factory.Typeof(node.Event.ContainingType, ctor.Parameters[0].Type), _factory.Literal(node.Event.MetadataName)); 312_factory.Convert(addRemove.Parameters[0].Type, rewrittenReceiver), 313_factory.Convert(addRemove.Parameters[1].Type, rewrittenArgument));

243MethodSymbol createSpan = getCreateSpanHelper(node, spanType: getItemOrSliceHelper.ContainingType, intType: (NamedTypeSymbol)getItemOrSliceHelper.Parameters[0].Type); 273possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref);

184Debug.Assert(addMethod.Parameters 203if (initializer.InvokedAsExtensionMethod && addMethod.Parameters[0].RefKind == RefKind.Ref) 208var builder = ArrayBuilder<RefKind>.GetInstance(addMethod.Parameters.Length, RefKind.None);

443readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out) 481Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out); 488argumentRefKindsOpt: [readOnlySpanCtorRefParamChar.Parameters[0].RefKind == RefKind.Ref ? RefKind.Ref : RefKindExtensions.StrictIn],

500Debug.Assert(method.Parameters.AsSpan()[1..].All(static (p) => (p.IsOptional || p.IsParams) && p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 504Debug.Assert(method.Parameters.All(p => p.IsOptional || p.IsParams));

327foreach (var parameter in method.Parameters) 485foreach (var parameter in method.Parameters)

111get { return this.BaseMethod.Parameters; }

1514if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1516arg = Convert(conversion.Method.Parameters[0].Type, arg);

152Debug.Assert(this.AttributeConstructor.Parameters[parameterIndex].IsOptional || 153this.AttributeConstructor.Parameters[parameterIndex].IsParamsArray); 242ImmutableArray<ParameterSymbol> parameters = ctor.Parameters;

1135return method.Parameters;

38return ImmutableArray<ParameterSymbol>.CastUp(_originalMethod.Parameters.SelectAsArray(static (p, @this) => new RewrittenMethodParameterSymbol(@this, p), this));

122var sourceParameters = _originalMethod.Parameters;

40return ((MethodSymbol)member).Parameters; 442foreach (ParameterSymbol param in method.Parameters) 850return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

238if (!ParametersMatch(candidateMethod.Parameters[i], candidateMethodTypeMap, ref targetParamInfo[i + 1 /*for return type*/]))

418return new ReceiverParameterSymbol(@this, methodSymbol.Parameters[0]); 514candidate.Parameters[0], 526candidate.Parameters.AsSpan(additionalParameterCount, candidate.ParameterCount - additionalParameterCount), 528method.Parameters.AsSpan(),

316return this.Parameters.Length; 906ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 919ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 965DeriveUseSiteInfoFromParameters(ref result, this.Parameters)) 979GetUnificationUseSiteDiagnosticRecursive(ref diagnosticInfo, this.Parameters, this, ref unificationCheckedTypes) || 1236ImmutableArray<IParameterSymbolInternal> IMethodSymbolInternal.Parameters => Parameters.Cast<ParameterSymbol, IParameterSymbolInternal>();

18return method.ParameterCount != 0 && method.Parameters[method.ParameterCount - 1].IsParams;

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

364var parameters = UnderlyingMethod.Parameters.SelectAsArray((p, m) => (ParameterSymbol)new NativeIntegerParameterSymbol(m._container, m, p), this);

128static underlying => underlying.Parameters.GetPublicSymbols(),

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 250return _reducedFrom.Parameters[0].Type; 255_reducedFrom.Parameters[0].TypeWithAnnotations.ToPublicAnnotation(); 541internal override bool IsEffectivelyReadOnly => _reducedFrom.Parameters[0].RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 560var reducedFromParameters = _reducedFrom.Parameters;

166var list = _underlyingMethod.Parameters;

1002var targetParams = method.Parameters.SelectAsArray(

45parameters = CopyParameterCustomModifiers(constructedSourceMethod.Parameters, destinationMethod.Parameters, alsoCopyParamsModifier);

2224var refKind1 = method1.Parameters[i].RefKind; 2225var refKind2 = method2.Parameters[i].RefKind; 4438ParametersMatchPropertyAccessor(propertySymbol, getNotSet, methodSymbol.Parameters)) 4477ParametersMatchEventAccessor(eventSymbol, methodSymbol.Parameters))

1263var baseParameters = baseMethod.Parameters; 1264var overrideParameters = overrideMethod.Parameters; 1388var parameters = method.Parameters; 1467var baseParameters = baseMethod.Parameters; 1468var overrideParameters = overrideMethod.Parameters; 1518var baseParameters = baseMethod.Parameters; 1519var overrideParameters = overrideMethod.Parameters;

925foreach (var parameter in this.Parameters) 1023foreach (var parameter in method.Parameters)

766foreach (var param in this.Parameters) 1003Debug.Assert(arguments.Attribute.AttributeConstructor.Parameters is [{ Type.SpecialType: SpecialType.System_Int32 }, { Type.SpecialType: SpecialType.System_String }]); 1396foreach (var param in Parameters) 1584var enumeratorCancellationCount = Parameters.Count(p => p.HasEnumeratorCancellationAttribute);

1027foreach (var parameter in constructor.Parameters) 1054if (_lazyExtensionInfo.LazyExtensionParameter == null && markerMethod is { Parameters: [var parameter, ..] })

169return reduced.Parameters[0].Type; 339var unsubstitutedParameters = OriginalDefinition.Parameters;

440if (property.GetOwnOrInheritedSetMethod()?.Parameters.Last().FlowAnalysisAnnotations is { } setterAnnotations)

561var parameterReference = f.Parameter(method.Parameters[0]); 597var parameterReference0 = f.Parameter(method.Parameters[0]); 598var parameterReference1 = f.Parameter(method.Parameters[1]); 654var parameterReference = f.Parameter(method.Parameters[0]); 688var parameterReference = f.Parameter(method.Parameters[0]);

124if (ctor.ParameterCount == 1 && ctor.Parameters[0].RefKind == RefKind.None && 125ctor.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

147method.Parameters[0].Type.Equals(containingType, TypeCompareKind.AllIgnoreOptions) && 148method.Parameters[0].RefKind == RefKind.None;

45if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None && 47candidate.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

126F.Convert(baseEquals.Parameters[0].Type, other));

302return sourceMethod.Parameters.SelectAsArray(

1623interfaceMethod.Parameters,

581return invokeMethod.Parameters; 981(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(currentPointer.Parameters[i].TypeWithAnnotations, canDigThroughNullable); 998next = currentPointer.Parameters[i].TypeWithAnnotations;

172CheckParametersVarianceSafety(method.Parameters, method, diagnostics);

203var paramType = m.Parameters[0].Type; 226var paramType = m.Parameters[0].Type; 646var paramType = m.Parameters[0].Type; 688var param = (FunctionPointerTypeSymbol)m.Parameters[0].Type; 743foreach (var param in m.Parameters) 5608var param = m.Parameters.Single(); 5721var param = method.Parameters.Single(); 6307Assert.True(baseM1.Parameters.Single().Type.Equals(derivedM1.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 6309Assert.True(baseM3.Parameters.Single().Type.Equals(derivedM3.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 7060var funcPtr = (FunctionPointerTypeSymbol)m1.Parameters.Single().Type; 7068funcPtr = (FunctionPointerTypeSymbol)m3.Parameters.Single().Type;

5365var param = localFn1.Parameters.Single(); 5398var param = localFn1.Parameters.Single(); 5431var param = localFn1.Parameters.Single(); 5639Assert.Equal(new[] { "Attr" }, GetAttributeNames(localFn1.Parameters.Single().GetAttributes())); 5650Assert.Empty(localFn1.Parameters.Single().GetAttributes()); 5998var methodParam = ((CSharpCompilation)verifier.Compilation).GetMember<MethodSymbol>("Program.M").Parameters[0]; 6008var methodParam = module.GlobalNamespace.GetMember<MethodSymbol>("Program.M").Parameters[0]; 6012var localFunctionParam = module.GlobalNamespace.GetMember<MethodSymbol>("Program.<M>g__local|0_0").Parameters[0]; 6054var methodParam = ((CSharpCompilation)verifier.Compilation).GetMember<MethodSymbol>("Program.M").Parameters[0]; 6064var methodParam = module.GlobalNamespace.GetMember<MethodSymbol>("Program.M").Parameters[0]; 6068var localFunctionParam = module.GlobalNamespace.GetMember<MethodSymbol>("Program.<M>g__local|0_0").Parameters[0]; 6111var methodParam = ((CSharpCompilation)verifier.Compilation).GetMember<MethodSymbol>("Program.M").Parameters[0]; 6121var methodParam = module.GlobalNamespace.GetMember<MethodSymbol>("Program.M").Parameters[0]; 6125var localFunctionParam = module.GlobalNamespace.GetMember<MethodSymbol>("Program.<M>g__local|0_0").Parameters[0];

4110var parameterA = fooA.Parameters[0]; 4118var parameterB = fooB.Parameters[0];

951var partialParamType = partialNamesMethod.Parameters.Single().TypeWithAnnotations; 957var allNullParamType = allNullNamesMethod.Parameters.Single().TypeWithAnnotations; 4623var m2Tuple = (NamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M2").Parameters[0].Type; 11631var parameters1 = ((MethodSymbol)members1[i]).Parameters; 11632var parameters2 = ((MethodSymbol)members2[i]).Parameters; 13538Assert.Same(m9Test, m9Test.Parameters.Single().ContainingSymbol);

835Assert.Equal(0, destructor.Parameters.Length);

604var parameter = method.Parameters.Single(); 660var baseParameter = baseMethod.Parameters.Single(); 668var derivedParameter = derivedMethod.Parameters.Single();

446var parameter1 = m1.Parameters.Single(); 451Assert.Same(module.GetCorLibType(SpecialType.System_Boolean), m2.Parameters.Single().Type); 452Assert.Same(module.GetCorLibType(SpecialType.System_Char), m3.Parameters.Single().Type); 454var method4ParamTypes = m4.Parameters.Select(p => p.Type).ToArray(); 472Assert.Same(m5.TypeParameters[0], m5.Parameters[0].Type); 473Assert.Same(m5.TypeParameters[1], m5.Parameters[1].Type); 639Assert.Equal(0, cctor.Parameters.Length); 1307Assert.Empty(attribute.AttributeConstructor.Parameters); 2027Assert.Equal(RefKind.None, m.Parameters[0].RefKind); 2028Assert.Equal(RefKind.Ref, m.Parameters[1].RefKind); 2029Assert.Equal(RefKind.Out, m.Parameters[2].RefKind); 2075Assert.Equal(invoke.Parameters.Length + 2, beginInvoke.Parameters.Length); 2078for (int i = 0; i < invoke.Parameters.Length; i++) 2080Assert.Equal(invoke.Parameters[i].Type, beginInvoke.Parameters[i].Type); 2081Assert.Equal(invoke.Parameters[i].RefKind, beginInvoke.Parameters[i].RefKind); 2083Assert.Equal("System.AsyncCallback", beginInvoke.Parameters[invoke.Parameters.Length].Type.ToTestDisplayString()); 2084Assert.Equal("System.Object", beginInvoke.Parameters[invoke.Parameters.Length + 1].Type.ToTestDisplayString()); 2091for (int i = 0; i < invoke.Parameters.Length; i++) 2093if (invoke.Parameters[i].RefKind != RefKind.None) 2095Assert.Equal(invoke.Parameters[i].TypeWithAnnotations, endInvoke.Parameters[k].TypeWithAnnotations); 2096Assert.Equal(invoke.Parameters[i].RefKind, endInvoke.Parameters[k++].RefKind); 2099Assert.Equal("System.IAsyncResult", endInvoke.Parameters[k++].Type.ToTestDisplayString()); 2100Assert.Equal(k, endInvoke.Parameters.Length); 2601var parameters = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters; 2611var delegateParameters = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters; 2619var lambdaParameters = module.GlobalNamespace.GetTypeMember("C").GetTypeMember("<>c").GetMethod("<M>b__0_0").Parameters;

1654var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 1674var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 1961var invokeParameter = type.DelegateInvokeMethod.Parameters.Single(); 1965var beginInvokeParameter = type.GetMethod("BeginInvoke").Parameters.First(); 1969var endInvokeParameter = type.GetMethod("EndInvoke").Parameters.First(); 2009var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 2029var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 2069var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("op_LogicalNot").Parameters.Single(); 2089var parameters = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("op_Addition").Parameters; 2113var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); 2500var parameter = type.GetMethod("M").Parameters.Single(); 2526var parameter = type.GetMethod("M").Parameters.Single(); 2548var parameter = type.GetMethod("M").Parameters.Single(); 2573var parameter = type.GetMethod("M").Parameters.Single(); 2595var parameter = type.GetMethod("M").Parameters.Single(); 2622var implicitParameter = type.GetMethod("M").Parameters.Single(); 2629var explicitParameter = explicitImplementation.Parameters.Single(); 2650var parameter = type.GetMethod("M").Parameters.Single(); 2676var parameter = type.GetMethod("M").Parameters.Single(); 2698var parameter = type.GetMethod("M").Parameters.Single(); 2723var parameter = type.GetMethod("Parent.M").Parameters.Single(); 3329var explicitParameter = explicitImplementation.Parameters.First(); 3671var parameter = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters.Single(); 3743var parameter = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters.Single(); 4503Assert.Empty(parentMethod.Parameters.Single().RefCustomModifiers); 4508Assert.Empty(childMethod.Parameters.Single().RefCustomModifiers); 4513AssertSingleInAttributeRequiredModifier(interfaceMethod.Parameters.Single().RefCustomModifiers); 4518AssertSingleInAttributeRequiredModifier(proxyMethod.Parameters.Single().RefCustomModifiers); 4546Assert.Empty(parentMethod.Parameters.Single().RefCustomModifiers); 4554AssertSingleInAttributeRequiredModifier(interfaceMethod.Parameters.Single().RefCustomModifiers); 4559AssertSingleInAttributeRequiredModifier(proxyMethod.Parameters.Single().RefCustomModifiers);

149VerifyDefaultValueAttribute(type.GetMember<MethodSymbol>("F").Parameters[0], "DecimalConstantAttribute", 1, false); 151VerifyDefaultValueAttribute(type.GetMember<MethodSymbol>("get_Item").Parameters[1], "DecimalConstantAttribute", 2, false); 152VerifyDefaultValueAttribute(type.GetMember<MethodSymbol>("set_Item").Parameters[1], "DecimalConstantAttribute", 2, false); 154VerifyDefaultValueAttribute(type.GetMember<MethodSymbol>("Invoke").Parameters[0], "DecimalConstantAttribute", 3, false); 155VerifyDefaultValueAttribute(type.GetMember<MethodSymbol>("BeginInvoke").Parameters[0], "DecimalConstantAttribute", 3, false); 212VerifyDefaultValueAttribute(type.GetMember<MethodSymbol>("F").Parameters[0], "DecimalConstantAttribute", 2, false);

194Assert.Equal(1, ((PointerTypeSymbol)member1.Parameters[0].Type).PointedAtTypeWithAnnotations.CustomModifiers.Length); 201Assert.Equal(1, ((PointerTypeSymbol)other.Parameters[0].Type).PointedAtTypeWithAnnotations.CustomModifiers.Length);

569verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 570verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 10354var nintType = method.Parameters[0].Type; 10358var intPtrType = method.Parameters[1].Type; 10367var nuintType = method.Parameters[2].Type; 10371var uintPtrType = method.Parameters[3].Type;

2690Assert.Equal("II", GetSingleAttributeName(event9.AddMethod.Parameters.Single())); 3182attrs = mem.Parameters[0].GetAttributes(); 3184attrs = mem.Parameters[1].GetAttributes(); 3454Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParams); 3455Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParamsArray); 3456Assert.False(attrs.First().AttributeConstructor.Parameters.Last().IsParamsCollection); 3593Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParams); 3594Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParamsArray); 3595Assert.False(attrs.First().AttributeConstructor.Parameters.Last().IsParamsCollection); 4015attrs = setter.Parameters[0].GetAttributes(attributeTypeForParam); 5105var param = gooMethod.Parameters[0];

3243AssertEx.Equal(["System.Runtime.CompilerServices.CallerLineNumberAttribute"], goo.Parameters[0].GetAttributes().SelectAsArray(attr => attr.ToString())); 3244AssertEx.Equal(["System.Runtime.CompilerServices.CallerMemberNameAttribute"], goo.Parameters[1].GetAttributes().SelectAsArray(attr => attr.ToString())); 3245AssertEx.Equal(["System.Runtime.CompilerServices.CallerFilePathAttribute"], goo.Parameters[2].GetAttributes().SelectAsArray(attr => attr.ToString())); 4406var attr = ctor.Parameters.Single().GetAttributes().Single(); 4436var attr = ctor.Parameters.Single().GetAttributes()[0];

148var param1 = methodM.Parameters[0]; 161attributesArrayBuilder.Add(propSetMethod.Parameters[0].GetAttributes()); 176attributesArrayBuilder.Add(propSetMethod.Parameters[0].GetAttributes()); 632var paramY = gooCtor.Parameters[0];

335ValidateDynamicAttribute(f1.Parameters[0].GetAttributes(), expectedDynamicAttribute: true); 346ValidateDynamicAttribute(f2.Parameters[0].GetAttributes(), expectedDynamicAttribute: true, expectedTransformFlags: _expectedTransformFlags); 356ValidateDynamicAttribute(f3.Parameters[0].GetAttributes(), expectedDynamicAttribute: true, expectedTransformFlags: _expectedTransformFlags); 367ValidateDynamicAttribute(f4.Parameters[0].GetAttributes(), expectedDynamicAttribute: true, expectedTransformFlags: _expectedTransformFlags); 378ValidateDynamicAttribute(f5.Parameters[0].GetAttributes(), expectedDynamicAttribute: true, expectedTransformFlags: _expectedTransformFlags); 407ValidateDynamicAttribute(prop2.SetMethod.Parameters[0].GetAttributes(), expectedDynamicAttribute: true, expectedTransformFlags: _expectedTransformFlags); 423ValidateDynamicAttribute(indexer.GetMethod.Parameters[0].GetAttributes(), expectedDynamicAttribute: true); 431ValidateDynamicAttribute(indexer.SetMethod.Parameters[0].GetAttributes(), expectedDynamicAttribute: true); 432ValidateDynamicAttribute(indexer.SetMethod.Parameters[1].GetAttributes(), expectedDynamicAttribute: true); 472foreach (var param in ctor.Parameters) 488ValidateDynamicAttribute(invokeMethod.Parameters[0].GetAttributes(), expectedDynamicAttribute: true, expectedTransformFlags: expectedTransformFlags); 502var parameters = beginInvokeMethod.Parameters; 516ValidateDynamicAttribute(endInvokeMethod.Parameters[0].GetAttributes(), expectedDynamicAttribute: false); 533Assert.Empty(dynamicAttribute.AttributeConstructor.Parameters); 538Assert.Equal("System.Boolean[]", dynamicAttribute.AttributeConstructor.Parameters.Single().TypeWithAnnotations.ToTestDisplayString());

262var parameter = method.Parameters[0]; 267parameter = method.Parameters[0]; 272parameter = method.Parameters[1]; 277parameter = method.Parameters[0];

73foreach (ParameterSymbol parameter in method.Parameters)

1111AssertNativeIntegerAttribute(method.Parameters[0].GetAttributes()); 1158AssertNativeIntegerAttribute(method.Parameters[0].GetAttributes());

2198AssertAttributes(method.Parameters[0].GetAttributes()); 2225AssertAttributes(method.Parameters[0].GetAttributes()); 2226AssertNullableAttribute(method.Parameters[1].GetAttributes()); 2301AssertNullableAttribute(method.Parameters[0].GetAttributes()); 2302AssertNoNullableAttribute(method.Parameters[1].GetAttributes()); 4996var attributes = method.Parameters[0].GetAttributes();

152foreach (var parameter in method.Parameters) 175foreach (var parameter in method.Parameters) 204foreach (var parameter in method.Parameters) 231var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); 250var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); 275var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); 1311var parameter = method.Parameters.Single(); 1348var parameter = method.Parameters.Single(); 1593Assert.Empty(method.Parameters.Single().GetAttributes()); 1596Assert.Empty(@operator.Parameters[0].GetAttributes()); 1597Assert.Empty(@operator.Parameters[1].GetAttributes()); 1635Assert.Empty(method.Parameters.Single().GetAttributes()); 1638Assert.Empty(@operator.Parameters[0].GetAttributes()); 1639Assert.Empty(@operator.Parameters[1].GetAttributes()); 1679Assert.Empty(method.Parameters.Single().GetAttributes()); 1682Assert.Empty(@operator.Parameters[0].GetAttributes()); 1683Assert.Empty(@operator.Parameters[1].GetAttributes()); 1728Assert.Empty(method.Parameters.Single().GetAttributes()); 1775Assert.Empty(method.Parameters.Single().GetAttributes()); 1819Assert.Empty(method.Parameters.Single().GetAttributes()); 1868Assert.Empty(method.Parameters.Single().GetAttributes()); 1908Assert.Empty(method.Parameters.Single().GetAttributes()); 1911Assert.Empty(@operator.Parameters[0].GetAttributes()); 1912Assert.Empty(@operator.Parameters[1].GetAttributes()); 1977Assert.Empty(method.Parameters.Single().GetAttributes()); 2026Assert.Empty(method.Parameters.Single().GetAttributes()); 2066Assert.Empty(method.Parameters.Single().GetAttributes()); 2108Assert.Empty(method.Parameters.Single().GetAttributes()); 2370Assert.Equal(RefKind.RefReadOnly, method.Parameters[0].RefKind); 2371Assert.Equal(RefKind.Ref, method.Parameters[1].RefKind); 2417Assert.Equal(RefKind.Ref, method.Parameters[0].RefKind); 2418Assert.Equal(RefKind.RefReadOnly, method.Parameters[1].RefKind);

65Assert.Equal("System.Int32", attribute.AttributeConstructor.Parameters.Single().TypeWithAnnotations.ToTestDisplayString()); 76Assert.Empty(attribute.AttributeConstructor.Parameters); 93Assert.Equal("System.Diagnostics.DebuggableAttribute.DebuggingModes", attribute.AttributeConstructor.Parameters.Single().TypeWithAnnotations.ToTestDisplayString()); 585var parameter = baseMethodWrapper.Parameters.Single(); 628var parameter = baseMethodWrapper.Parameters.Single(); 1616Assert.Empty(unverifiableCode.AttributeConstructor.Parameters);

352var sender = invokeMethod.Parameters[0]; 357var args = invokeMethod.Parameters[1]; 536ValidateTupleNameAttribute(method2.Parameters.Single().GetAttributes(), 547ValidateTupleNameAttribute(method3.Parameters.Single().GetAttributes(), 558ValidateTupleNameAttribute(method4.Parameters.Single().GetAttributes(), 571ValidateTupleNameAttribute(method5.Parameters.Single().GetAttributes(), expectedTupleNamesAttribute: false); 629Assert.Equal("System.String[]", tupleAttr.AttributeConstructor.Parameters.Single().TypeWithAnnotations.ToTestDisplayString());

415parm = method.Parameters[0]; 422parm = method.Parameters[0]; 432parm = method.Parameters[1]; 447parm = method.Parameters[0]; 452parm = method.Parameters[1]; 458parm = method.Parameters[2]; 1370var param = (SourceParameterSymbol)partialDefPart.Parameters[0]; 1374param = (SourceParameterSymbol)partialImplPart.Parameters[0]; 5074var paramsParameter = useParamsMethod.Parameters[0]; 5078var noParamsParameter = noParamsMethod.Parameters[0]; 9741var param = method.Parameters.Single(); 13541var attribute = module.ContainingAssembly.GetTypeByMetadataName("Program").GetMethod("Test").Parameters.Single().GetAttributes().Single(); 13546Assert.Equal("transformFlags", attribute.AttributeConstructor.Parameters.Single().Name);

81Assert.Equal(2, sourceConstructor.Parameters.Length); 82Assert.Equal(0, synthesizedConstructor.Parameters.Length);

63if (m.Parameters[0].Type.Name == "I1")

3078AssertEx.Equal("x", indexer.Parameters.Single().Name); 3382AssertEx.Equal(["A(23)"], e.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 3385AssertEx.Equal(["A(24)"], e.RemoveMethod.Parameters.Single().GetAttributes().ToStrings()); 3393AssertEx.Equal(["A(23)"], eImpl.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 3396AssertEx.Equal(["A(24)"], eImpl.RemoveMethod.Parameters.Single().GetAttributes().ToStrings()); 3403AssertEx.Equal(["A(22)", "A(21)"], f.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 3406AssertEx.Equal(["A(22)", "A(21)"], f.RemoveMethod.Parameters.Single().GetAttributes().ToStrings()); 3414AssertEx.Equal(["A(22)", "A(21)"], fImpl.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 3417AssertEx.Equal(["A(22)", "A(21)"], fImpl.RemoveMethod.Parameters.Single().GetAttributes().ToStrings());

129var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 158var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 332var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 441var p = comp.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 529var p = comp.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 549var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 570var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 591var p = m.GlobalNamespace.GetMember<MethodSymbol>("C..ctor").Parameters.Single(); 643var p = m.GlobalNamespace.GetMember<MethodSymbol>("C..ctor").Parameters.Single(); 665var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 666var p = ctor.Parameters.Single(); 687var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 688var p = ctor.Parameters.Single(); 708var ctor = c.InstanceConstructors.Single(s => s.Parameters is [{ Name: "p" }]); 709var p = ctor.Parameters.Single(); 822var p = m.GlobalNamespace.GetMember<MethodSymbol>("D.Invoke").Parameters.Single(); 845var p = m.GlobalNamespace.GetMember<MethodSymbol>("Program.<>c.<<Main>$>b__0_0").Parameters.Single(); 869var p = m.GlobalNamespace.GetMember<MethodSymbol>("Program.<<Main>$>g__local|0_0").Parameters.Single(); 894var p = m.GlobalNamespace.GetMember<MethodSymbol>("<>A{00000004}.Invoke").Parameters.Single(); 919var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 1250var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 1442var f = ((CSharpCompilation)comp).GetMember<MethodSymbol>("C.M").Parameters.Single(); 1499var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 1643var p = comp.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 1664var p = comp.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 1683var p = comp.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 5884var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 5927var p = m.GlobalNamespace.GetMember<MethodSymbol>("C.M").Parameters.Single(); 6032var p = m.GlobalNamespace.GetMember<MethodSymbol>("B.M").Parameters.Single(); 7104var methodFromClass = comp.GetMembers("C.M").Cast<MethodSymbol>().Single(m => m.Parameters.Single().RefKind == refKind); 7132var methodFromClass = comp.GetMembers("C.M").Cast<MethodSymbol>().Single(m => m.Parameters.Single().RefKind == RefKind.RefReadOnlyParameter); 7171var parameter = method.Parameters.Single();

21240var parameter = model.GetSymbolInfo(lambda).Symbol.GetSymbol<MethodSymbol>().Parameters[0]; 21250parameter = model.GetDeclaredSymbol(localFunction).GetSymbol<MethodSymbol>().Parameters[0]; 21262var p = m.GlobalNamespace.GetMember<MethodSymbol>("Helper.Test1").Parameters[0]; 21510var p = m.GlobalNamespace.GetMember<MethodSymbol>("Helper.Test1").Parameters[0]; 21647var p = m.GlobalNamespace.GetMember<MethodSymbol>("Helper.Test1").Parameters[0]; 21651p = m.GlobalNamespace.GetMember<MethodSymbol>("Helper.Test2").Parameters[0]; 21655p = m.GlobalNamespace.GetMember<MethodSymbol>("Helper.Test3").Parameters[0];

19285var collectionType = (NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F").Parameters[0].Type; 19345var collectionType = (NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F").Parameters[0].Type; 19404var collectionType = (NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F").Parameters[0].Type; 19455var collectionType = (NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F").Parameters[0].Type;

3706Assert.Equal(RefKind.RefReadOnlyParameter, m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.<>E__0.<Extension>$").Parameters[0].RefKind); 4136AssertEx.Equal(ScopedKind.ScopedRef, m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.<>E__0.<Extension>$").Parameters[0].EffectiveScope); 4183AssertEx.Equal("System.String?", m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.<>E__0.<Extension>$").Parameters[0].TypeWithAnnotations.ToTestDisplayString()); 4184AssertEx.Equal("System.String?", m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.<>E__1.<Extension>$").Parameters[0].TypeWithAnnotations.ToTestDisplayString()); 4215Assert.True(m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.<>E__0.<Extension>$").Parameters[0].Type.IsNativeIntegerType); 4216Assert.True(m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.<>E__1.<Extension>$").Parameters[0].Type.IsNativeIntegerType); 22238Assert.True(m.Parameters[0].HasInterpolatedStringHandlerArgumentError); 22239Assert.True(m.Parameters[0].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22241Assert.False(implM.Parameters[0].HasInterpolatedStringHandlerArgumentError); 22242Assert.True(implM.Parameters[0].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22243Assert.True(implM.Parameters[1].HasInterpolatedStringHandlerArgumentError); 22244Assert.True(implM.Parameters[1].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22292Assert.True(implM.Parameters[0].HasInterpolatedStringHandlerArgumentError); 22293Assert.True(implM.Parameters[0].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22416Assert.True(implM.Parameters[0].HasInterpolatedStringHandlerArgumentError); 22417Assert.True(implM.Parameters[0].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22462Assert.True(m.Parameters[0].HasInterpolatedStringHandlerArgumentError); 22463Assert.True(m.Parameters[0].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22465Assert.False(implM.Parameters[0].HasInterpolatedStringHandlerArgumentError); 22466Assert.True(implM.Parameters[0].InterpolatedStringHandlerArgumentIndexes.IsEmpty); 22467Assert.True(implM.Parameters[1].HasInterpolatedStringHandlerArgumentError); 22468Assert.True(implM.Parameters[1].InterpolatedStringHandlerArgumentIndexes.IsEmpty);

816var parameterSymbol = (PEParameterSymbol)m.GlobalNamespace.GetMember<MethodSymbol>("E.M").Parameters[1]; 841m.GlobalNamespace.GetMember<MethodSymbol>("E.M").Parameters[1].GetAttributes().ToStrings()); 868m.GlobalNamespace.GetMember<MethodSymbol>("E.M").Parameters[0].GetAttributes().ToStrings()); 871m.GlobalNamespace.GetMember<MethodSymbol>("E.get_Property").Parameters[0].GetAttributes().ToStrings()); 926var parameterSymbol = (PEParameterSymbol)m.GlobalNamespace.GetMember<MethodSymbol>("E.get_P").Parameters[0]; 929parameterSymbol = (PEParameterSymbol)m.GlobalNamespace.GetMember<MethodSymbol>("E.get_P2").Parameters[0]; 1633Assert.Empty(m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P").Parameters[0].GetAttributes()); 1638Assert.Empty(m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P2").Parameters[0].GetAttributes()); 1700Assert.Empty(m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P").Parameters[0].GetAttributes()); 1705Assert.Empty(m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P2").Parameters[0].GetAttributes()); 1746m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P").Parameters[0].GetAttributes().ToStrings()); 1750Assert.Empty(m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P2").Parameters[0].GetAttributes()); 1809m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P").Parameters[0].GetAttributes().ToStrings()); 1813Assert.Empty(m.GlobalNamespace.GetMember<MethodSymbol>("E.set_P2").Parameters[0].GetAttributes());

17279Assert.Null(a.Parameters[2].ExplicitDefaultValue); 17280Assert.True(a.Parameters[2].HasExplicitDefaultValue); 17308Assert.Null(a.Parameters[1].ExplicitDefaultValue); 17309Assert.True(a.Parameters[1].HasExplicitDefaultValue); 17347Assert.Null(a.Parameters[1].ExplicitDefaultValue); 17348Assert.True(a.Parameters[1].HasExplicitDefaultValue);

106VerifyParams(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 110VerifyParamsAndAttribute(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 284VerifyParams(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 288VerifyParamsAndAttribute(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 597VerifyParams(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 601VerifyParamsAndAttribute(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 1269VerifyParams(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 1273VerifyParamsAndAttribute(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 2420VerifyParams(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 2424VerifyParamsAndAttribute(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 2609VerifyParams(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 2613VerifyParamsAndAttribute(m.GlobalNamespace.GetMember<MethodSymbol>("Program.Test").Parameters.Last(), isParamCollection: true); 2745VerifyParamsAndAttribute(l1.Parameters.Last()); 2801VerifyParamsAndAttribute(l1.Parameters.Last()); 2947VerifyParamsAndAttribute(l1.Parameters.Last()); 2996VerifyParamsAndAttribute(l1.Parameters.Last()); 4210Assert.True(m.GlobalNamespace.GetTypeMember("<>f__AnonymousDelegate0").DelegateInvokeMethod.Parameters.Last().IsParams); 4356ParameterSymbol parameter = lambda.Parameters.Single(); 4362parameter = lambda.Parameters.Single(); 4468VerifyParamsAndAttribute(delegateInvokeMethod1.Parameters.Last(), isParamCollection: true); 4472VerifyParamsAndAttribute(delegateInvokeMethod2.Parameters.Last(), isParamArray: true); 4530VerifyParamsAndAttribute(delegateInvokeMethod1.Parameters.Last(), isParamCollection: true); 4534VerifyParamsAndAttribute(delegateInvokeMethod2.Parameters.Last(), isParamArray: true); 4540VerifyParamsAndAttribute(l1.Parameters.Last()); 4544VerifyParamsAndAttribute(l2.Parameters.Last()); 4683VerifyParamsAndAttribute(delegateInvokeMethod1.Parameters.Last(), isParamCollection: true); 4687VerifyParamsAndAttribute(delegateInvokeMethod2.Parameters.Last(), isParamArray: true); 4693VerifyParamsAndAttribute(l1.Parameters.Last()); 4697VerifyParamsAndAttribute(l2.Parameters.Last()); 4823VerifyParamsAndAttribute(delegateInvokeMethod.Parameters[0], isParamArray: false, isParamCollection: true); 9012assertAttributes(expected, expectUnscopedRefAttribute, module, (PEParameterSymbol)getMethod.Parameters[p1.Ordinal]); 9017assertAttributes(expected, expectUnscopedRefAttribute, module, (PEParameterSymbol)setMethod.Parameters[p1.Ordinal]); 9057Assert.Equal(scope, getMethod.Parameters[p.Ordinal].EffectiveScope); 9062Assert.Equal(scope, setMethod.Parameters[p.Ordinal].EffectiveScope); 9275Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 9276Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9277Assert.False(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 9279Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 9280Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9281Assert.False(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 9283Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 9284Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9316Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 9317Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9318Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 9320Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 9321Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9322Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 9324Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 9325Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9368Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9369Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9370Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9422Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9423Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9424Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9426Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 9480Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9481Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9482Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9484Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9485Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9486Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9537Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9538Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9539Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9541Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9542Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9543Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9607Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9608Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9609Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9611Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9612Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9613Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9695Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9696Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9697Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9699Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9700Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9701Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9762Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9763Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9764Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9803Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9804Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9805Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9855Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9856Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9857Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9916Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9917Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9918Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9963Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 9964Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 9965Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope); 10016Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 10017Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 10018Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope); 10071Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 10072Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 10073Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 10075Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 10076Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 10077Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope); 10127Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 10128Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 10129Assert.Equal(ScopedKind.None, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 10131Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 10132Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 10133Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope); 10134Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 10135Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 10136Assert.Equal(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope); 10172Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 10173Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 10174Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 10176Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 10177Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 10178Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 10180Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 10181Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 10182Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 10214Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 10215Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 10216Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 10218Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 10219Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 10220Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 10222Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 10223Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 10224Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 10256Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope); 10257Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 10258Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 10260Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope); 10261Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 10262Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 10264Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope); 10265Assert.Equal(ScopedKind.ScopedValue, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 10266Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 10392var test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10393var test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10409test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10410test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10515var test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10516var test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10533test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10534test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10639var test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10640var test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10657test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10658test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10757var test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10758var test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 10774test1 = comp.GetMember<MethodSymbol>("Params.Test1").Parameters.Last(); 10775test2 = comp.GetMember<MethodSymbol>("Params.Test2").Parameters.Last(); 12823VerifyParamsAndAttribute(member.Parameters[0], isParamCollection: true); 13142var parameter = method.Parameters.Single(); 13173var parameter = method.Parameters.Single(); 13202var parameter = method.Parameters.Single(); 13233var parameter = method.Parameters.Single(); 13265var parameter = method.Parameters.Single(); 13296var parameter = method.Parameters.Single(); 15273VerifyParams(comp.GetMember<MethodSymbol>("C1.Test").Parameters.Single(), isParamCollection: true); 15274VerifyParams(comp.GetMember<MethodSymbol>("C2.Test").Parameters.Single(), isParamCollection: true); 15297VerifyParams(comp.GetMember<MethodSymbol>("C1.Test").Parameters.Single()); 15298VerifyParams(comp.GetMember<MethodSymbol>("C2.Test").Parameters.Single());

411var x = ctor.Parameters[0]; 415var y = ctor.Parameters[1]; 482var x = ctor.Parameters[0]; 486var y = ctor.Parameters[1]; 529var x = ctor.Parameters[0]; 595var x = ctor.Parameters[0]; 599var y = ctor.Parameters[1]; 681var a = ctor.Parameters[0]; 685var b = ctor.Parameters[1]; 717var p1 = ctor.Parameters[0]; 719var p2 = ctor.Parameters[1]; 741Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything)); 773var p1 = ctor.Parameters[0]; 775var p2 = ctor.Parameters[1]; 3039var param1 = @class.InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0]; 3103Assert.Empty(comp.GetTypeByMetadataName("Test1").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes()); 3104Assert.Equal(2, comp.GetTypeByMetadataName("Test2").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes().Count()); 3146Assert.Empty(comp.GetTypeByMetadataName("Test1").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes()); 3147Assert.Equal(1, comp.GetTypeByMetadataName("Test2").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes().Count()); 6331var constructor = cMember.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.IsEmpty).Single();

507Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 539Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[0].DeclaringSyntaxReferences.Single().GetSyntax()); 540Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 541Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[2].DeclaringSyntaxReferences.Single().GetSyntax()); 565Assert.IsType<ParameterSyntax>(ctor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 566Assert.Equal(0, ctor.Parameters[1].Locations.Single().SourceSpan.Length); 593Assert.IsType<ParameterSyntax>(ctor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 594Assert.Equal(3, ctor.Parameters[1].Locations.Single().SourceSpan.Length); 628Assert.IsType<ParameterSyntax>(comp.GetMember<NamedTypeSymbol>("A").Constructors[0].Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 662Assert.IsType<ParameterSyntax>(comp.GetMember<NamedTypeSymbol>("A").Constructors[0].Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 687Assert.IsType<ParameterSyntax>(ctor.Parameters[0].DeclaringSyntaxReferences.Single().GetSyntax()); 688Assert.IsType<ParameterSyntax>(ctor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 12447foreach (var parameter in accessor.Parameters) 12558var parameterType = method.Parameters[0].TypeWithAnnotations; 12559Assert.True(method.OverriddenMethod.Parameters[0].TypeWithAnnotations.Equals(parameterType, TypeCompareKind.ConsiderEverything)); 14226Assert.Equal(RefKind.Out, deconstruct.Parameters[0].RefKind); 14227Assert.Equal("X", deconstruct.Parameters[0].Name); 14229Assert.Equal(RefKind.Out, deconstruct.Parameters[1].RefKind); 14230Assert.Equal("Y", deconstruct.Parameters[1].Name); 25197var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25257var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25334var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25391var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25466var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25550var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25620var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 28654var constructor = cMember.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.IsEmpty).Single();

988Assert.Equal(0, m1.Parameters.Length); 992Assert.Equal(1, m2.Parameters.Length); 996Assert.Equal(1, m3.Parameters.Length); 1000Assert.Equal(1, m4.Parameters.Length); 1047Assert.Equal(0, m1.Parameters.Length); 1051Assert.Equal(1, m2.Parameters.Length); 1074Assert.Equal(0, m1.Parameters.Length); 1078Assert.Equal(1, m2.Parameters.Length); 1082Assert.Equal(1, m3.Parameters.Length); 1086Assert.Equal(1, m4.Parameters.Length); 1106Assert.Equal(0, conversion.Parameters.Length); 1126Assert.Equal(1, conversion.Parameters.Length); 1146Assert.Equal(1, conversion.Parameters.Length); 1166Assert.Equal(1, conversion.Parameters.Length); 1184Assert.Equal(0, constructor.Parameters.Length); 1202Assert.Equal(1, constructor.Parameters.Length); 1220Assert.Equal(1, constructor.Parameters.Length); 1238Assert.Equal(1, constructor.Parameters.Length); 1260Assert.Equal(0, getter.Parameters.Length); 1264Assert.Equal(1, setter.Parameters.Length); 1286Assert.Equal(1, getter.Parameters.Length); 1290Assert.Equal(2, setter.Parameters.Length); 1312Assert.Equal(1, getter.Parameters.Length); 1316Assert.Equal(2, setter.Parameters.Length); 1338Assert.Equal(1, getter.Parameters.Length); 1342Assert.Equal(2, setter.Parameters.Length);

1968Assert.Equal("i", method.Parameters[0].Name); 1990Assert.Equal("i", method.Parameters[0].Name); 2602var x = foo.Parameters[0];

3940var type = (FunctionPointerTypeSymbol)m.Parameters[1].Type;

8443Assert.True(c2Goo.Parameters[0].Type.IsNullableType()); 8470Assert.True(((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementType.IsNullableType()); 8497Assert.True(c2Goo.Parameters[0].Type.IsNullableType()); 8498var tuple = c2Goo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 8606Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 8628Assert.True(((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementType.IsNullableType()); 8650Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 8651var tuple = dGoo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 8748Assert.True(c2Goo.Parameters[0].Type.IsNullableType()); 8777Assert.True(dGoo.Parameters[0].Type.IsNullableType());

3281Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3286Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3291Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3372Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3378Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3384Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3491Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3587Assert.True(property0.SetMethod.Parameters[1].HasUnsupportedMetadata); 3824Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3912Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 4001Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata);

6836var sParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 6862var sParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 6894var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 6929var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 6969var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 7004var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7044var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7082var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7122var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7157var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7197var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 7232var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7265var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7305var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7345var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7385var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7425var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7460var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 7502var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 7537var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod(".ctor").Parameters.Single(); 7579var cParam = comp.GetTypeByMetadataName("C").GetMethod(".ctor").Parameters.Single(); 7619var cParam = substitutedC.GetMethod("M").Parameters.Single(); 7660var cParam = comp.GetTypeByMetadataName("C`1").GetMethod("M").Parameters.Single(); 7728var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.First(); 7822var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.First(); 7934var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8000var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8030var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8132var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8274var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8334var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8454var cParam = verifier.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8692var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(3).Single(); 8817var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8968var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9079var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9146var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9202var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9559var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9820var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 9895var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 11954var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 18534Assert.Null(a.Parameters[1].ExplicitDefaultValue); 18535Assert.True(a.Parameters[1].HasExplicitDefaultValue); 18570Assert.Null(a.Parameters[1].ExplicitDefaultValue); 18571Assert.True(a.Parameters[1].HasExplicitDefaultValue);

3632return format(expr, method.GetAttributes(), method.GetReturnTypeAttributes(), method.Parameters.SelectMany(p => p.GetAttributes()));

2009var m = ms.Where(mm => mm.Parameters[0].Type.SpecialType == SpecialType.System_Int32).Single();

535var szArray = (ArrayTypeSymbol)m2.Parameters.First().Type; 542var mdArray = (ArrayTypeSymbol)m2.Parameters.Last().Type;

2050var parameters = methods.Select(m => m.Parameters.Single()).ToArray(); 2132var parameters = methods.Select(m => m.Parameters.Single()).ToArray(); 2183var parameters = methods.Select(m => m.Parameters.Single()).ToArray(); 2266var parameters = methods.Select(m => m.Parameters.Single()).ToArray(); 2348var parameters = methods.Select(m => m.Parameters.Single()).ToArray(); 2462var param = method.Parameters.Single();

122VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: true); 127VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: false); 217VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: true); 221VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: false); 507var parameters = method.Parameters; 508Assert.Equal(parameters, method.Parameters); // same array 571VerifyMember(method.Parameters[i], underlyingMethod.Parameters[i], signed); 721VerifyErrorTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: true); 725VerifyErrorTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: false); 1968verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 1969verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2138verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2139verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2234verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2235verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2361verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.M1").Parameters[0].Type, signed: true); 2362verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.M2").Parameters[0].Type, signed: false); 2481verifyType((NamedTypeSymbol)compB.GetMember<MethodSymbol>("Program.M1").Parameters[0].Type, signed: true); 2482verifyType((NamedTypeSymbol)compB.GetMember<MethodSymbol>("Program.M2").Parameters[0].Type, signed: false); 2637verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2638verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2739verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2740verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2879verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2880verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 3688var underlyingType0 = (NamedTypeSymbol)method.Parameters[0].Type; 3689var underlyingType1 = (NamedTypeSymbol)method.Parameters[1].Type; 3722var underlyingType0 = (NamedTypeSymbol)method.Parameters[0].Type; 3723var underlyingType1 = (NamedTypeSymbol)method.Parameters[1].Type; 3756var underlyingType0 = (NamedTypeSymbol)method.Parameters[0].Type; 3757var underlyingType1 = (NamedTypeSymbol)method.Parameters[1].Type;

8808TypeWithAnnotations getParameterType(CSharpCompilation c) => c.GetMember<MethodSymbol>("A.F").Parameters[0].TypeWithAnnotations; 8942Assert.Equal(NullableAnnotation.Oblivious, method.Parameters[0].TypeWithAnnotations.NullableAnnotation); 8992verifyTuple(method.Parameters[0].TypeWithAnnotations); 9053var parameter = method.Parameters.Single(); 11455Assert.True(m1.Parameters[0].Type.IsNullableType()); 11456Assert.True(m1.Parameters[0].Type.IsValueType); 11457Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11506Assert.True(m1.Parameters[0].Type.IsNullableType()); 11507Assert.False(m1.Parameters[0].Type.IsReferenceType); 11569Assert.True(m1.Parameters[0].Type.IsNullableType()); 11570Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11573Assert.False(m2.Parameters[0].Type.IsNullableType()); 11574Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11577Assert.True(m3.Parameters[0].Type.IsNullableType()); 11578Assert.True(m3.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11628Assert.True(m1.Parameters[0].Type.IsNullableType()); 11629Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11633Assert.True(m2.Parameters[0].Type.IsNullableType()); 11634Assert.True(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11702Assert.True(((NamedTypeSymbol)m3.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11703Assert.True(((NamedTypeSymbol)m3.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11704Assert.True(((NamedTypeSymbol)m4.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11705Assert.True(((NamedTypeSymbol)m4.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11706Assert.True(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11733Assert.True(m1.Parameters[0].Type.IsNullableType()); 11734Assert.True(m1.Parameters[0].Type.StrippedType().IsValueType); 11768Assert.True(m1.Parameters[0].Type.IsNullableType()); 11769Assert.False(m1.Parameters[0].Type.StrippedType().IsValueType); 11770Assert.False(m1.Parameters[0].Type.StrippedType().IsReferenceType); 11852Assert.True(m1.Parameters[0].Type.IsNullableType()); 11853Assert.True(m2.Parameters[0].Type.IsNullableType()); 11854Assert.True(m3.Parameters[0].Type.IsNullableType()); 11855Assert.True(m4.Parameters[0].Type.IsNullableType()); 11893Assert.True(m1.Parameters[0].Type.IsNullableType()); 12099Assert.False(m1.Parameters[0].Type.IsNullableType()); 12100Assert.Equal(NullableAnnotation.Annotated, m1.Parameters[0].TypeWithAnnotations.NullableAnnotation); 12101Assert.True(m1.Parameters[0].Type.IsReferenceType); 12102Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 12105Assert.False(m4.Parameters[0].Type.IsNullableType()); 12109Assert.False(m5.Parameters[0].Type.IsNullableType()); 12258Assert.True(b.GetMember<MethodSymbol>("M1").Parameters[0].Type.IsNullableType()); 12259Assert.True(b.GetMember<MethodSymbol>("M2").Parameters[0].Type.IsNullableType()); 12260Assert.False(b.GetMember<MethodSymbol>("M3").Parameters[0].Type.IsNullableType()); 12261Assert.True(b.GetMember<MethodSymbol>("M4").Parameters[0].Type.IsNullableType()); 12262Assert.True(b.GetMember<MethodSymbol>("M5").Parameters[0].Type.IsNullableType()); 12347Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12348Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12429Assert.Equal(expectMatch, member.Parameters.Single().TypeWithAnnotations.Equals(member.OverriddenMethod.Parameters.Single().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12715Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12716Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12803Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12804Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12900Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 13052Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 13143Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 13688Assert.False(m1.Parameters[0].TypeWithAnnotations.Equals(m1.OverriddenMethod.ConstructIfGeneric(m1.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 13898Assert.False(m1.Parameters[0].Type.IsNullableType()); 13899Assert.Equal(NullableAnnotation.Annotated, m1.Parameters[0].TypeWithAnnotations.NullableAnnotation); 13900Assert.True(m1.Parameters[0].Type.IsReferenceType); 13901Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 13969Assert.True(((NamedTypeSymbol)m3.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13970Assert.True(((NamedTypeSymbol)m3.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13971Assert.True(((NamedTypeSymbol)m4.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13972Assert.True(((NamedTypeSymbol)m4.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13973Assert.False(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13974Assert.False(((NamedTypeSymbol)m5.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 14135Assert.False(member.Parameters[0].TypeWithAnnotations.Equals(member.OverriddenMethod.ConstructIfGeneric(member.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 14140Assert.True(m3.Parameters[0].TypeWithAnnotations.Equals(m3.OverriddenMethod.ConstructIfGeneric(m3.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 14229Assert.False(m1.Parameters[0].Type.IsNullableType()); 14230Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14234Assert.False(m2.Parameters[0].Type.IsNullableType()); 14235Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14285Assert.True(m1.Parameters[0].Type.IsNullableType()); 14286Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14290Assert.True(m2.Parameters[0].Type.IsNullableType()); 14291Assert.True(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 16504Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 16512Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 16651Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 16736Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 16821Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 17734Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 17742Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 17881Assert.False(m1Impl.Parameters[i].TypeWithAnnotations.Equals(m1Def.Parameters[i].TypeWithAnnotations, 17885Assert.True(m1Impl.Parameters[3].TypeWithAnnotations.Equals(m1Def.Parameters[3].TypeWithAnnotations, 38068var actual = method.Parameters.Select(p => p.FlowAnalysisAnnotations); 40985var setterValueAttributes = setter.Parameters.Last().GetAttributes().Select(a => a.ToString()); 40986Assert.Equal(FlowAnalysisAnnotations.AllowNull, setter.Parameters.Last().FlowAnalysisAnnotations); 41046var setterValueAttributes = setter.Parameters.Last().GetAttributes().Select(a => a.ToString()); 41047Assert.Equal(FlowAnalysisAnnotations.AllowNull | FlowAnalysisAnnotations.DisallowNull, setter.Parameters.Last().FlowAnalysisAnnotations); 44673var setterValueAttributes = setter.Parameters.Last().GetAttributes().Select(a => a.ToString()); 44674Assert.Equal(FlowAnalysisAnnotations.DisallowNull, setter.Parameters.Last().FlowAnalysisAnnotations); 139463Assert.False(dGoo.Parameters[0].Type.IsNullableType()); 139464Assert.True(dGoo.Parameters[0].TypeWithAnnotations.NullableAnnotation == NullableAnnotation.Annotated); 139491Assert.True(c2Goo.Parameters[0].Type.IsReferenceType); 139492Assert.Equal(NullableAnnotation.Annotated, c2Goo.Parameters[0].TypeWithAnnotations.NullableAnnotation); 139519Assert.True(((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementType.IsReferenceType); 139520Assert.Equal(NullableAnnotation.Annotated, ((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementTypeWithAnnotations.NullableAnnotation); 139547Assert.True(c2Goo.Parameters[0].Type.IsNullableType()); 139548var tuple = c2Goo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 139662Assert.True(dGoo.Parameters[0].Type.IsReferenceType); 139663Assert.Equal(NullableAnnotation.Annotated, dGoo.Parameters[0].TypeWithAnnotations.NullableAnnotation); 139685Assert.True(((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementType.IsReferenceType); 139686Assert.Equal(NullableAnnotation.Annotated, ((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementTypeWithAnnotations.NullableAnnotation); 139708Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 139709var tuple = dGoo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 139813Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 139815var tuple = dGoo.Parameters[1].Type; 150036var parameterType = method.Parameters[0].TypeWithAnnotations;

5088var sParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 5116var sParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5153var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5193var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 5240var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5280var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5327var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5370var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5417var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5457var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5504var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5544var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5591var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5638var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5685var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5725var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 5774var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5814var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod(".ctor").Parameters.Single(); 5863var cParam = comp.GetTypeByMetadataName("C").GetMethod(".ctor").Parameters.Single(); 5908var cParam = substitutedC.GetMethod("M").Parameters.Single(); 5956var cParam = comp.GetTypeByMetadataName("C`1").GetMethod("M").Parameters.Single(); 5986var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.First(); 6112var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6181var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6211var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6445var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6507var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6629var cParam = verifier.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 6869var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(3).Single(); 6996var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7149var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7262var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7333var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7393var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7757var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8029var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 8107var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 8534var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single();

3513Assert.Equal(RefKind.Out, deconstruct.Parameters[0].RefKind); 3514Assert.Equal("X", deconstruct.Parameters[0].Name); 3516Assert.Equal(RefKind.Out, deconstruct.Parameters[1].RefKind); 3517Assert.Equal("Y", deconstruct.Parameters[1].Name); 10578var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0];

10980var parameters = comp.GetMember<MethodSymbol>("A.F1").Parameters; 10984parameters = comp.GetMember<MethodSymbol>("A.F2").Parameters; 10988parameters = comp.GetMember<MethodSymbol>("A.F3").Parameters; 10992parameters = comp.GetMember<MethodSymbol>("A.F4").Parameters; 11030VerifyParameterSymbol(comp.GetMember<NamedTypeSymbol>("A").Constructors.Single(c => !c.IsImplicitlyDeclared).Parameters[0], "scoped ref T t", RefKind.Ref, ScopedKind.ScopedRef); 11031VerifyParameterSymbol(comp.GetMember<PropertySymbol>("A.this[]").GetMethod.Parameters[0], "scoped in System.Object o", RefKind.In, ScopedKind.ScopedRef); 11183VerifyParameterSymbol(delegateType.DelegateInvokeMethod.Parameters[parameterIndex], $"{expectedDisplayType} arg{parameterIndex + 1}", expectedRefKind, expectedScope, expectedHasUnscopedRefAttributeInDelegate); 11220VerifyParameterSymbol(comp.GetMember<NamedTypeSymbol>("D1").DelegateInvokeMethod.Parameters[0], "scoped R r1", RefKind.None, ScopedKind.ScopedValue); 11221VerifyParameterSymbol(comp.GetMember<NamedTypeSymbol>("D2").DelegateInvokeMethod.Parameters[0], "scoped ref R r2", RefKind.Ref, ScopedKind.ScopedRef); 11308VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F0").Parameters[0], "scoped R r", RefKind.None, ScopedKind.ScopedValue); 11309VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F3").Parameters[0], "scoped ref R r", RefKind.Ref, ScopedKind.ScopedRef); 11310VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F6").Parameters[0], "scoped in R r", RefKind.In, ScopedKind.ScopedRef); 11311VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F9").Parameters[0], "out R r", RefKind.Out, ScopedKind.ScopedRef); 11422VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F0").Parameters[0], "scoped s", RefKind.None, ScopedKind.None); 11423VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F1").Parameters[0], "scoped scoped s", RefKind.None, ScopedKind.ScopedValue); 11424VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "ref scoped s", RefKind.Ref, ScopedKind.None); 11425VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F4").Parameters[0], "scoped ref scoped s", RefKind.Ref, ScopedKind.ScopedRef); 11426VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F5").Parameters[0], "in scoped s", RefKind.In, ScopedKind.None); 11427VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F7").Parameters[0], "scoped in scoped s", RefKind.In, ScopedKind.ScopedRef); 11428VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F8").Parameters[0], "out scoped s", RefKind.Out, ScopedKind.ScopedRef); 11429VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.FA").Parameters[0], "out scoped s", RefKind.Out, ScopedKind.ScopedRef); 11537var parameters = comp.GetMember<MethodSymbol>("A.F").Parameters; 11575VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.ReturnRef").Parameters[0], "scoped ref R r", RefKind.Ref, ScopedKind.ScopedRef); 11669VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F0").Parameters[0], "R<System.Object> r", RefKind.None, ScopedKind.None); 11670VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F1").Parameters[0], "scoped R<System.Object> r", RefKind.None, ScopedKind.ScopedValue); 11671VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F2").Parameters[0], "scoped", RefKind.None, ScopedKind.None); 11672VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F3").Parameters[0], "scoped ref T t", RefKind.Ref, ScopedKind.ScopedRef); 11690VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "params scoped System.Object[] args", RefKind.None, ScopedKind.ScopedValue); 11997VerifyParameterSymbol(property.SetMethod.Parameters[0], expectedDisplayString, expectedRefKind, expectedScope); 12017VerifyParameterSymbol(method.Parameters[0], "scoped R<System.Int32> x", RefKind.None, ScopedKind.ScopedValue); 12018VerifyParameterSymbol(method.Parameters[1], "scoped in System.Int32 y", RefKind.In, ScopedKind.ScopedRef); 18016VerifyParameterSymbol(delegateInvokeMethods[0].Parameters[0], "R arg1", RefKind.None, ScopedKind.None); 18017VerifyParameterSymbol(delegateInvokeMethods[0].Parameters[1], "scoped R arg2", RefKind.None, ScopedKind.ScopedValue); 18018VerifyParameterSymbol(delegateInvokeMethods[1].Parameters[1], "scoped ref System.Int32 arg2", RefKind.Ref, ScopedKind.ScopedRef); 22692var a = m.Parameters[0].GetAttributes().Single().AttributeClass.ToTestDisplayString(); 22737Assert.Empty(m.Parameters[0].GetAttributes()); 23665var parameters = comp.GetMember<MethodSymbol>("Program.ReturnRefStructRef").Parameters; 23729VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "ref R<System.Int32> r1", RefKind.Ref, ScopedKind.None); 23730VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped ref R<System.Int32> r2", RefKind.Ref, ScopedKind.ScopedRef); 23818VerifyParameterSymbol(type.GetMethod("F1").Parameters[0], "ref R<T> r1", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23819VerifyParameterSymbol(type.GetMethod("F2").Parameters[0], "out T t2", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23820VerifyParameterSymbol(type.GetMethod("F3").Parameters[0], "in R<T> t3", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23821VerifyParameterSymbol(type.GetMethod("F4").Parameters[0], "R<T> t4", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23902VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "ref R<System.Int32> r4", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23924var parameters = comp.GetMember<MethodSymbol>("Program.F").Parameters; 23952var parameters = comp.GetMember<MethodSymbol>("Program.ReturnOut").Parameters; 24012VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "out System.Int32 t1", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 24013VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "out System.Int32 t2", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 24014VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "out System.Int32 t3", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24077VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "ref System.Int32 t1", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 24078VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped ref System.Int32 t2", RefKind.Ref, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 24079VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "ref System.Int32 t3", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24080VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "ref System.Int32 t4", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24143VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "in System.Int32 t1", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 24144VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped in System.Int32 t2", RefKind.In, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 24145VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "in System.Int32 t3", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24146VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "in System.Int32 t4", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24233VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "R<System.Int32> r1", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 24234VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped R<System.Int32> r2", RefKind.None, ScopedKind.ScopedValue, expectedHasUnscopedRefAttribute: false); 24235VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "R<System.Int32> r3", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24236VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "R<System.Int32> r4", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24261VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F1").Parameters[0], "R<T> r1", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24262VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "ref R<T> r2", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24263VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F3").Parameters[0], "in R<T> r3", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24264VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F4").Parameters[0], "out R<T> r4", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25007VerifyParameterSymbol(typeA.GetMethod("NoAttributes").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 25008VerifyParameterSymbol(typeA.GetMethod("ScopedRefOnly").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 25009VerifyParameterSymbol(typeA.GetMethod("UnscopedRefOnly").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25010VerifyParameterSymbol(typeA.GetMethod("ScopedRefAndUnscopedRef").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25109VerifyParameterSymbol(typeA.GetMethod("NoAttributes").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 25110VerifyParameterSymbol(typeA.GetMethod("ScopedRefOnly").Parameters[0], "scoped ref R x", RefKind.Ref, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 25111VerifyParameterSymbol(typeA.GetMethod("UnscopedRefOnly").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25112VerifyParameterSymbol(typeA.GetMethod("ScopedRefAndUnscopedRef").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25217VerifyParameterSymbol(typeA.GetMethod("NoAttributes").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 25218VerifyParameterSymbol(typeA.GetMethod("ScopedRefOnly").Parameters[0], "scoped in R x", RefKind.In, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 25219VerifyParameterSymbol(typeA.GetMethod("UnscopedRefOnly").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25220VerifyParameterSymbol(typeA.GetMethod("ScopedRefAndUnscopedRef").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25277VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F3").Parameters[0], "out System.Int32 i3", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 25278VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F4").Parameters[0], "ref R r4", RefKind.Ref, ScopedKind.None); 25279VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F5").Parameters[0], "in R r5", RefKind.In, ScopedKind.None); 25320VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F3").Parameters[0], "out System.Int32 i3", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 25321VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F4").Parameters[0], "ref R r4", RefKind.Ref, ScopedKind.None); 25322VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F5").Parameters[0], "in R r5", RefKind.In, ScopedKind.None); 25361VerifyParameterSymbol(delegateType.DelegateInvokeMethod.Parameters[parameterIndex], $"{expectedDisplayType} arg", expectedRefKind, expectedScope); 25402VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F1").Parameters[0], "out modreq(System.Runtime.InteropServices.OutAttribute) System.Int32", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 25403VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F2").Parameters[0], "R", RefKind.None, ScopedKind.None); 25404VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F3").Parameters[0], "ref R", RefKind.Ref, ScopedKind.None); 25405VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F4").Parameters[0], "in modreq(System.Runtime.InteropServices.InAttribute) R", RefKind.In, ScopedKind.None); 25406VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F5").Parameters[0], "out modreq(System.Runtime.InteropServices.OutAttribute) R", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 25474VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F1").Parameters[0], "out System.Int32 i1", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25475VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "R r2", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25476VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F3").Parameters[0], "ref R r3", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25477VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F4").Parameters[0], "in R r4", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25478VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F5").Parameters[0], "out R r5", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 26091VerifyParameterSymbol(typeA.GetMethod("F1").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 26092VerifyParameterSymbol(typeA.GetMethod("F2").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 26093VerifyParameterSymbol(typeA.GetMethod("F3").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 26094VerifyParameterSymbol(typeA.GetMethod("F4").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 27047VerifyParameterSymbol(method.Parameters[0], "out System.Int32 i", RefKind.Out, version == 11 ? ScopedKind.ScopedRef : ScopedKind.None); 27086VerifyParameterSymbol(method.Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None); 27125VerifyParameterSymbol(method.Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None); 27175VerifyParameterSymbol(method.Parameters[0], "out T t", RefKind.Out, expectedUseUpdatedEscapeRules ? ScopedKind.ScopedRef : ScopedKind.None); 27411Assert.Equal(ScopedKind.None, type.DelegateInvokeMethod.Parameters.Single().EffectiveScope); 27463Assert.Equal(ScopedKind.None, type.DelegateInvokeMethod.Parameters.Single().EffectiveScope); 27515Assert.Equal(ScopedKind.None, type.DelegateInvokeMethod.Parameters.Single().EffectiveScope);

1338Assert.Equal(0, call.Constructor.Parameters.Length); 1367Assert.Equal(1, call.Constructor.Parameters.Length); 1395Assert.Equal(1, call.Constructor.Parameters.Length); 1396Assert.Equal("capacity", call.Constructor.Parameters[0].Name); 1431Assert.Equal(0, call.Constructor.Parameters.Length); 1466Assert.Equal(1, call.Constructor.Parameters.Length); 1467Assert.Equal("a", call.Constructor.Parameters[0].Name); 1468Assert.Equal("Int32", call.Constructor.Parameters[0].TypeWithAnnotations.Type.Name); 1501Assert.Equal(1, call.Constructor.Parameters.Length); 1502Assert.Equal("a", call.Constructor.Parameters[0].Name); 1503Assert.Equal("String", call.Constructor.Parameters[0].TypeWithAnnotations.Type.Name); 1536Assert.Equal(1, newExpr.Constructor.Parameters.Length); 1537Assert.Equal("a", newExpr.Constructor.Parameters[0].Name); 1538Assert.Equal("Int32", newExpr.Constructor.Parameters[0].TypeWithAnnotations.Type.Name);

25122Assert.Null(a.Parameters[1].ExplicitDefaultValue); 25123Assert.True(a.Parameters[1].HasExplicitDefaultValue);

3553Assert.True(g1.Parameters[0].HasExplicitDefaultValue); 3554Assert.Null(g1.Parameters[0].ExplicitDefaultValue); 3555Assert.True(g1.Parameters[0].ExplicitDefaultConstantValue.IsNull); 3558Assert.True(g2.Parameters[0].HasExplicitDefaultValue); 3559Assert.Null(g2.Parameters[0].ExplicitDefaultValue); 3560Assert.True(g2.Parameters[0].ExplicitDefaultConstantValue.IsNull); 3580Assert.True(g1.Parameters[0].HasExplicitDefaultValue); 3581Assert.False((bool)g1.Parameters[0].ExplicitDefaultValue); 3582Assert.False(g1.Parameters[0].ExplicitDefaultConstantValue.IsNull); 3585Assert.True(g2.Parameters[0].HasExplicitDefaultValue); 3586Assert.False((bool)g2.Parameters[0].ExplicitDefaultValue); 3587Assert.False(g2.Parameters[0].ExplicitDefaultConstantValue.BooleanValue);

8858var pointerType = methodSymbol.Parameters[0].Type;

4064Assert.Equal(SpecialType.System_Collections_Generic_ICollection_T, ((TypeSymbol)reducedFrom1.Parameters[0].Type.OriginalDefinition).SpecialType); 4075Assert.Equal(SpecialType.System_Collections_Generic_ICollection_T, ((TypeSymbol)reducedFrom2.Parameters[0].Type.OriginalDefinition).SpecialType);

311var parameterType = method.Parameters.Single(); 354var parameterType = method.Parameters.Single();

60var constructorSymbol = _widgetClass.InstanceConstructors.Single(c => !c.IsStatic && c.Parameters.Length == 0); 72var parameterizedConstructorSymbol = _widgetClass.InstanceConstructors.Single(c => !c.IsStatic && c.Parameters.Length == 1);

1270Single(m => m.Parameters.Single().Type.SpecialType == SpecialType.System_Int32); 1602.Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1636var expectedOriginalParameterTypes = expectedOriginalDefinitionSymbol.Parameters.Select(p => p.Type).Cast<TypeParameterSymbol>(); 1735Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1761Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter);

1291Assert.Equal("p2", method.Parameters.Single().Name); 1348Assert.Equal("p2", method.Parameters.Single().Name); 1411Assert.Equal("p2", method.Parameters.Single().Name); 1474Assert.Equal("p2", method.Parameters.Single().Name); 3039Assert.Equal("p2", ctor.Parameters.Single().Name); 3106Assert.Equal("p2", ctor.Parameters.Single().Name); 3173Assert.Equal("p2", ctor.Parameters.Single().Name); 3234Assert.Equal("p2", ctor.Parameters.Single().Name);

256var symbol = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M").Parameters.Single();

63var parameter = method.Parameters.Single().ISymbol; 140var parameter = property.SetMethod.Parameters.Single().ISymbol; 165var parameter = indexer.SetMethod.Parameters.Last().ISymbol; 278var parameter = method.Parameters.Single().ISymbol; 304var parameters = method.Parameters.GetPublicSymbols(); 331var parameters = method.Parameters.GetPublicSymbols(); 380var parameter = method.Parameters.Single().ISymbol;

2330var foo1Params = foo1.Parameters; 2338var foo2Params = foo2.Parameters; 2340Assert.Same(localC3Foo2.Parameters[0], ((RetargetingParameterSymbol)foo2Params[0]).UnderlyingParameter); 2341Assert.Same(localC3Foo2.Parameters[1], ((RetargetingParameterSymbol)foo2Params[1]).UnderlyingParameter); 2342Assert.Same(localC3Foo2.Parameters[2], ((RetargetingParameterSymbol)foo2Params[2]).UnderlyingParameter); 2343Assert.Same(localC3Foo2.Parameters[3], ((RetargetingParameterSymbol)foo2Params[3]).UnderlyingParameter); 2351Assert.NotEqual(localC3Foo2.Parameters[0].Type, x1.Type); 2352Assert.Equal(localC3Foo2.Parameters[0].ToTestDisplayString(), x1.ToTestDisplayString()); 2361Assert.NotEqual(localC3Foo2.Parameters[1].Type, x2.Type); 2365Assert.Same(localC3Foo2.Parameters[2].Type, x3.Type);

312var typeIntArrayWithCustomModifiers = interfaceI3.GetMember<MethodSymbol>("M1").Parameters.Single().Type;

45Parameters[0].TypeWithAnnotations;

160Assert.True(onParameterMethod.Parameters[0].HasUnsupportedMetadata); 224Assert.True(onIndexedPropertyParameter.GetMember<MethodSymbol>("get_Property").Parameters[0].HasUnsupportedMetadata); 225Assert.True(onIndexedPropertyParameter.GetMember<MethodSymbol>("set_Property").Parameters[0].HasUnsupportedMetadata);

1235Assert.True(test.GetMethod.ReturnTypeWithAnnotations.CustomModifiers.SequenceEqual(test.SetMethod.Parameters.First().TypeWithAnnotations.CustomModifiers)); 1522Assert.Same(compilation1.SourceModule.CorLibrary(), test.Parameters.First().Type.OriginalDefinition.ContainingAssembly); 1523Assert.Same(compilation1.SourceModule.CorLibrary(), ((CSharpCustomModifier)((NamedTypeSymbol)test.Parameters.First().Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].CustomModifiers.First()).ModifierSymbol.ContainingAssembly); 1531Assert.Same(compilation2.SourceModule.CorLibrary(), test.Parameters.First().Type.OriginalDefinition.ContainingAssembly); 1532Assert.Same(compilation2.SourceModule.CorLibrary(), ((CSharpCustomModifier)((NamedTypeSymbol)test.Parameters.First().Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].CustomModifiers.First()).ModifierSymbol.ContainingAssembly); 2482var t1 = test1.Parameters[0].TypeWithAnnotations; 2483var t2 = test2.Parameters[0].TypeWithAnnotations;

69337foreach (var p in m01.Parameters)

3040verifyArray(m1.Parameters[0].Type);

42var parameter = method.Parameters[0]; 48parameter = method.Parameters[0]; 54parameter = method.Parameters[0]; 122Assert.Equal(0, method.Parameters.Length); 128Assert.Equal(1, method.Parameters.Length); 136Assert.Equal(0, method.Parameters.Length); 142Assert.Equal(1, method.Parameters.Length); 148Assert.Equal(1, method.Parameters.Length); 4033var parameter = method.Parameters[0]; 4039parameter = method.Parameters[0]; 4063var parameter = method.Parameters[0]; 4069parameter = method.Parameters[0]; 4128Assert.Null(a.Parameters[1].ExplicitDefaultValue); 4129Assert.True(a.Parameters[1].HasExplicitDefaultValue);

43var pointerType = (FunctionPointerTypeSymbol)m.Parameters.Single().Type; 110var mParams = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters; 196var firstSignature = ((FunctionPointerTypeSymbol)m.Parameters[0].Type).Signature; 197var secondSignature = ((FunctionPointerTypeSymbol)m.Parameters[1].Type).Signature; 264var pointerType = (FunctionPointerTypeSymbol)m.Parameters.Single().Type; 326var m1PointerType = (FunctionPointerTypeSymbol)m1.Parameters.Single().Type; 330var m2PointerType = (FunctionPointerTypeSymbol)m2.Parameters.Single().Type; 334var m3PointerType = (FunctionPointerTypeSymbol)m3.Parameters.Single().Type; 377var parameterTypes = m.Parameters; 380Assert.Equal(SpecialType.System_Int32, firstParam.Parameters.Single().Type.SpecialType); 383Assert.Equal(SpecialType.System_Object, secondParam.Parameters.Single().Type.SpecialType); 386Assert.Equal(c, thirdParam.Parameters.Single().Type); 390Assert.Equal(SpecialType.System_Object, fourthParam.Parameters[0].Type.SpecialType); 391Assert.Equal(SpecialType.System_Object, fourthParam.Parameters[1].Type.SpecialType); 395Assert.Equal(t, fifthParam.Parameters[0].Type); 396Assert.Equal(SpecialType.System_Object, fifthParam.Parameters[1].Type.SpecialType); 399var sixthParamParam = ((FunctionPointerTypeSymbol)sixthParam.Parameters.Single().Type).Signature; 469var parameterTypes = m.Parameters; 472Assert.Equal(RefKind.Ref, firstParam.Parameters.Single().RefKind); 475Assert.Equal(RefKind.In, secondParam.Parameters.Single().RefKind); 478Assert.Equal(RefKind.Out, thirdParam.Parameters.Single().RefKind); 481Assert.Equal(RefKind.None, fourthParam.Parameters.Single().RefKind); 571var parameterTypes = m.Parameters; 574Assert.Equal(RefKind.None, firstParam.Parameters.Single().RefKind); 577Assert.Equal(RefKind.None, secondParam.Parameters.Single().RefKind); 580Assert.Equal(RefKind.Ref, thirdParam.Parameters.Single().RefKind); 583Assert.Equal(RefKind.In, fourthParam.Parameters.Single().RefKind); 586Assert.Equal(RefKind.Out, fifthParam.Parameters.Single().RefKind); 589Assert.Equal(RefKind.In, sixthParam.Parameters.Single().RefKind); 592Assert.Equal(RefKind.Ref, seventhParam.Parameters.Single().RefKind); 595Assert.Equal(RefKind.Out, eightParam.Parameters.Single().RefKind); 598Assert.Equal(RefKind.Ref, ninthParam.Parameters.Single().RefKind); 679var signature = ((FunctionPointerTypeSymbol)m.Parameters.Single().Type).Signature; 709AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, returnEquality: Equality.Equal, callingConventionEquality: Equality.Equal); 726AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 745AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 763AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 782AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 800AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 818AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 836AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 854AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 872AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 890AssertEqualityAndHashCode((FunctionPointerTypeSymbol)m.Parameters[0].Type, (FunctionPointerTypeSymbol)m.Parameters[1].Type, 1057foreach (var param1 in m.Parameters) 1059foreach (var param2 in m.Parameters)

189CheckParameters(getter.Parameters, expectedParameterTypes); 201CheckParameters(setter.Parameters, expectedParameterTypes.Concat(new[] { expectedType }).ToArray()); 2407Assert.False(indexer.GetMethod.Parameters.IsEmpty); 2409foreach (var p in indexer.GetMethod.Parameters) 2957Assert.Null(a.Parameters[1].ExplicitDefaultValue); 2958Assert.True(a.Parameters[1].HasExplicitDefaultValue);

226Assert.Equal(6, member1.Parameters.Length); 251Assert.Equal(6, member1.Parameters.Length); 252var p1 = member1.Parameters[0] as ParameterSymbol; 253var p2 = member1.Parameters[1] as ParameterSymbol; 254var p3 = member1.Parameters[2] as ParameterSymbol; 255var p4 = member1.Parameters[3] as ParameterSymbol; 256var p5 = member1.Parameters[4] as ParameterSymbol; 257var p6 = member1.Parameters[5] as ParameterSymbol; 332Assert.Equal(2, member1.Parameters.Length); 352Assert.Equal(2, member1.Parameters.Length); 353var p1 = member1.Parameters[0] as ParameterSymbol; 354var p2 = member1.Parameters[1] as ParameterSymbol;

296Assert.Equal(3, member2.Parameters.Length); 298var type3 = (member2.Parameters[2] as ParameterSymbol).Type as ArrayTypeSymbol;

276Assert.Equal(RefKind.Ref, f2.Parameters[0].RefKind); 283Assert.Equal(RefKind.None, f3.Parameters[0].RefKind); 307Assert.Equal(RefKind.None, f4.Parameters[0].RefKind);

174var x = ((MethodSymbol)m1).Parameters[0]; 378var x = ((MethodSymbol)m1).Parameters[0];

44ParameterSymbol p1 = m1.Parameters[0]; 45ParameterSymbol p2 = modifiers.GetMembers("F2").OfType<MethodSymbol>().Single().Parameters[0]; 47ParameterSymbol p4 = modifiers.GetMembers("F4").OfType<MethodSymbol>().Single().Parameters[0]; 50ParameterSymbol p5 = m5.Parameters[0]; 52ParameterSymbol p6 = modifiers.GetMembers("F6").OfType<MethodSymbol>().Single().Parameters[0]; 73Assert.Equal("System.Int32 modopt(System.Int32) modopt(System.Runtime.CompilerServices.IsConst) modopt(System.Runtime.CompilerServices.IsConst) p", modifiers.GetMembers("F3").OfType<MethodSymbol>().Single().Parameters[0].ToTestDisplayString());

226var sub1P1 = sub1.Parameters.Single(p => p.Name == "p1"); 1001attrSym = mtd.Parameters[0].GetAttribute(attrObj2);

116Assert.Equal(@event.Type, accessor.Parameters.Single().Type); 135Assert.NotEqual(mismatchedAddEvent.Type, mismatchedAddEvent.AddMethod.Parameters.Single().Type); 138Assert.NotEqual(mismatchedRemoveEvent.Type, mismatchedRemoveEvent.RemoveMethod.Parameters.Single().Type); 158Assert.Equal(0, noParamAddEvent.AddMethod.Parameters.Length); 161Assert.Equal(0, noParamRemoveEvent.RemoveMethod.Parameters.Length);

717Assert.NotEqual(parameterTypesIndexer.Parameters.Last().Type, parameterTypesIndexer.GetMethod.Parameters.Last().Type); 727Assert.NotEqual(parameterModoptIndexer.Parameters.Last().TypeWithAnnotations.CustomModifiers.Length, parameterModoptIndexer.GetMethod.Parameters.Last().TypeWithAnnotations.CustomModifiers.Length); 792Assert.NotEqual(property1ParamName, property1.GetMethod.Parameters.Single().Name); 793Assert.Equal(property1ParamName, property1.SetMethod.Parameters.First().Name); 798Assert.Equal(property2ParamName, property2.GetMethod.Parameters.Single().Name); 803Assert.Equal(property3ParamName, property3.SetMethod.Parameters.First().Name); 845var accessParam0Name = accessor.Parameters[0].Name; 846var accessParam1Name = accessor.Parameters[1].Name; 1087Assert.Equal(property.Type, accessor.Parameters.Last().Type); 1094Assert.Equal(property.Parameters[i].Type, accessor.Parameters[i].Type);

64var localM1_1 = localM2.Parameters[0]; 117Assert.False(basicC1_M1.Parameters[0].IsOptional); 118Assert.False(basicC1_M1.Parameters[0].HasExplicitDefaultValue); 119Assert.Same(module4, basicC1_M1.Parameters[0].Locations.Single().MetadataModuleInternal); 121Assert.True(basicC1_M2.Parameters[0].IsOptional); 122Assert.False(basicC1_M2.Parameters[0].HasExplicitDefaultValue); 124Assert.True(basicC1_M3.Parameters[0].IsOptional); 125Assert.True(basicC1_M3.Parameters[0].HasExplicitDefaultValue); 127Assert.True(basicC1_M4.Parameters[0].IsOptional); 128Assert.False(basicC1_M4.Parameters[0].HasExplicitDefaultValue);

360int withParameterIndex = constructors[0].Parameters.Any() ? 0 : 1; 363Assert.Equal(0, constructors[withoutParameterIndex].Parameters.Length);

80param = test1.Parameters; 85param = test2.Parameters; 111param = test1.Parameters; 116param = test2.Parameters; 144param = test1.Parameters; 152param = test2.Parameters; 198param = test1.Parameters; 211param = test2.Parameters; 235param = test1.Parameters; 242param = test2.Parameters; 266param = test1.Parameters; 273param = test2.Parameters; 300param = test1.Parameters; 421param = test1.Parameters; 426param = test2.Parameters; 452param = test1.Parameters; 457param = test2.Parameters; 484param = test1.Parameters; 489param = test2.Parameters; 524param = test1.Parameters; 540param = test2.Parameters; 569param = test1.Parameters; 576param = test2.Parameters; 600param = test1.Parameters; 610param = test2.Parameters; 636param = test1.Parameters;

138if (m.Parameters.Length > 0) 140Assert.Equal(SymbolKind.ErrorType, m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.BaseType().Kind); 141Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.BaseType()); 222Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 223Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 241Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 242Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 260Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 261Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 298Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type.Kind); 299Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Where(arg => arg.Name == "x").Select(arg => arg).Single().Type); 317Assert.Equal(SymbolKind.ErrorType, importedMethod.Parameters.Single(arg => arg.Name == "x").Type.Kind); 318Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedMethod.Parameters.Single(arg => arg.Name == "x").Type); 443if (m.Parameters.Length > 0) 445Assert.Equal(SymbolKind.Parameter, m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Kind); 446Assert.True(m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.IsFromCompilation(localConsumer));

43ImmutableArray<ParameterSymbol> param = methodSymbol.Parameters; 102Assert.Equal(SymbolKind.NamedType, methodSymbol.Parameters.Single(arg => arg.Name == "arg").Type.Kind); 140ImmutableArray<ParameterSymbol> param = refMethodSymbol.Parameters; 200ImmutableArray<ParameterSymbol> param = refMethodSymbol.Parameters; 371ImmutableArray<ParameterSymbol> param = refMethodSymbol.Parameters;

3866AssertEx.Equal(["A(2)", "B(2)", "A(1)", "B(1)"], accessor.Parameters.Single().GetAttributes().ToStrings()); 3867AssertEx.Equal(["A(2)", "B(2)", "A(1)", "B(1)"], accessor.PartialImplementationPart!.Parameters.Single().GetAttributes().ToStrings()); 3930verify(indexer.GetMethod!.Parameters.Single()); 3931verify(indexer.SetMethod!.Parameters[0]); 3934verify(indexer.PartialImplementationPart!.GetMethod!.Parameters.Single()); 3935verify(indexer.PartialImplementationPart!.SetMethod!.Parameters[0]); 3994AssertEx.Equal(["Attr", "Attr"], property.SetMethod!.Parameters.Single().GetAttributes().ToStrings()); 4055AssertEx.Equal(["Attr", "Attr"], property.GetMethod!.Parameters[0].GetAttributes().ToStrings()); 4056AssertEx.Equal(["Attr", "Attr"], property.GetMethod!.Parameters[1].GetAttributes().ToStrings()); 4058AssertEx.Equal(["Attr", "Attr"], property.SetMethod!.Parameters[0].GetAttributes().ToStrings()); 4059AssertEx.Equal(["Attr", "Attr"], property.SetMethod!.Parameters[1].GetAttributes().ToStrings()); 4060AssertEx.Equal(["Attr", "Attr"], property.SetMethod!.Parameters[2].GetAttributes().ToStrings()); 4335Assert.True(indexer.GetMethod!.Parameters[0].HasUnscopedRefAttribute); 4336Assert.True(indexer.GetMethod!.PartialImplementationPart!.Parameters[0].HasUnscopedRefAttribute);

106var x = m.Parameters[0]; 107var y = m.Parameters[1]; 108var z = m.Parameters[2]; 124var x1 = m1.Parameters[0]; 131var y2 = m2.Parameters[0];

390param = test1.Parameters; 395param = test2.Parameters; 421param = test1.Parameters; 426param = test2.Parameters; 452param = test1.Parameters; 460param = test2.Parameters; 504param = test1.Parameters; 517param = test2.Parameters; 539param = test1.Parameters; 546param = test2.Parameters; 569param = test1.Parameters; 576param = test2.Parameters; 602param = test1.Parameters; 691param = test1.Parameters; 696param = test2.Parameters; 722param = test1.Parameters; 727param = test2.Parameters; 753param = test1.Parameters; 761param = test2.Parameters; 805param = test1.Parameters; 818param = test2.Parameters; 840param = test1.Parameters; 847param = test2.Parameters; 870param = test1.Parameters; 877param = test2.Parameters; 903param = test1.Parameters; 995param = test1.Parameters; 1000param = test2.Parameters; 1026param = test1.Parameters; 1031param = test2.Parameters; 1057param = test1.Parameters; 1065param = test2.Parameters; 1109param = test1.Parameters; 1122param = test2.Parameters; 1144param = test1.Parameters; 1151param = test2.Parameters; 1174param = test1.Parameters; 1181param = test2.Parameters; 1207param = test1.Parameters; 2053Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2054Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2068Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2069Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2083Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2084Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2098Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2099Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2178Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2179Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2193Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2194Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2208Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2209Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2223Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2224Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2303Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2304Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2318Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2319Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2333Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2334Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2348Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2349Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2415Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2416Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2430Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2431Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2511Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2512Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2526Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2527Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2541Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2542Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2556Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2557Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type);

257ParameterSymbol testParameter = testMethod.Parameters[0];

58ParameterSymbol p1 = m1.Parameters[0]; 59ParameterSymbol p2 = modifiers.GetMembers("F2").OfType<MethodSymbol>().Single().Parameters[0]; 62ParameterSymbol p5 = m5.Parameters[0]; 64ParameterSymbol p6 = modifiers.GetMembers("F6").OfType<MethodSymbol>().Single().Parameters[0]; 203ParameterSymbol p1 = m1.Parameters[0];

692CheckParameters(sourceMethod.Parameters, retargetingMethod.Parameters); 1232CheckSymbols(a.Parameters, b.Parameters, false);

453if (method.Parameters.Any()) 455CheckCustomModifier(inParameterType, ((ArrayTypeSymbol)method.Parameters.Single().Type).ElementTypeWithAnnotations.CustomModifiers); 456CheckCustomModifier(onParameterType, method.Parameters.Single().TypeWithAnnotations.CustomModifiers); 552Assert.False(class3Method1.Parameters.Single().TypeWithAnnotations.CustomModifiers.Any()); 596var classMethod1CustomModifiers = classMethod1.Parameters.Single().TypeWithAnnotations.CustomModifiers; 651Assert.True(baseM.Parameters.Single().IsParams, "Base.M.IsParams should be true"); 652Assert.True(baseM.Parameters.Single().IsParamsArray, "Base.M.IsParams should be true"); 653Assert.False(baseM.Parameters.Single().IsParamsCollection); 654Assert.False(baseN.Parameters.Single().IsParams, "Base.N.IsParams should be false"); 655Assert.False(baseN.Parameters.Single().IsParamsArray, "Base.N.IsParams should be false"); 656Assert.False(baseN.Parameters.Single().IsParamsCollection); 657Assert.True(derivedM.Parameters.Single().IsParams, "Derived.M.IsParams should be true"); //NB: does not reflect source 658Assert.True(derivedM.Parameters.Single().IsParamsArray, "Derived.M.IsParams should be true"); //NB: does not reflect source 659Assert.False(derivedM.Parameters.Single().IsParamsCollection); 660Assert.False(derivedN.Parameters.Single().IsParams, "Derived.N.IsParams should be false"); //NB: does not reflect source 661Assert.False(derivedN.Parameters.Single().IsParamsArray, "Derived.N.IsParams should be false"); //NB: does not reflect source 662Assert.False(derivedN.Parameters.Single().IsParamsCollection); 663Assert.True(derived2M.Parameters.Single().IsParams, "Derived2.M.IsParams should be true"); 664Assert.True(derived2M.Parameters.Single().IsParamsArray, "Derived2.M.IsParams should be true"); 665Assert.False(derived2M.Parameters.Single().IsParamsCollection); 666Assert.False(derived2N.Parameters.Single().IsParams, "Derived2.N.IsParams should be false"); 667Assert.False(derived2N.Parameters.Single().IsParamsArray, "Derived2.N.IsParams should be false"); 668Assert.False(derived2N.Parameters.Single().IsParamsCollection); 1795Assert.Equal(int16Type, baseProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1796Assert.Equal(int16Type, derivedProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1801Assert.Equal(int16Type, baseIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1802Assert.Equal(int16Type, derivedIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1804Assert.Equal(int32Type, baseIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1805Assert.Equal(int32Type, derivedIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1807Assert.Equal(int64Type, baseIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1808Assert.Equal(int64Type, derivedIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2009Assert.Equal(int16Type, interfaceProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2010Assert.Equal(int16Type, implementationProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2015Assert.Equal(int16Type, interfaceIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2016Assert.Equal(int16Type, implementationIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2018Assert.Equal(int32Type, interfaceIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2019Assert.Equal(int32Type, implementationIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2021Assert.Equal(int64Type, interfaceIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 2022Assert.Equal(int64Type, implementationIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier());

114Assert.Equal(2, ctor.Parameters.Length); 115Assert.Equal(comp.GetSpecialType(SpecialType.System_Object), ctor.Parameters[0].Type); 116Assert.Equal(comp.GetSpecialType(SpecialType.System_IntPtr), ctor.Parameters[1].Type); 136Assert.Equal(1, v.DelegateInvokeMethod.Parameters.Length); 161Assert.Equal(invoke.Parameters.Length + 2, beginInvoke.Parameters.Length); 164for (int i = 0; i < invoke.Parameters.Length; i++) 166Assert.Equal(invoke.Parameters[i].Type, beginInvoke.Parameters[i].Type); 167Assert.Equal(invoke.Parameters[i].RefKind, beginInvoke.Parameters[i].RefKind); 169var lastParameterType = beginInvoke.Parameters[invoke.Parameters.Length].Type; 172Assert.Equal("System.Object", beginInvoke.Parameters[invoke.Parameters.Length + 1].Type.ToTestDisplayString()); 177for (int i = 0; i < invoke.Parameters.Length; i++) 179if (invoke.Parameters[i].RefKind != RefKind.None) 181Assert.Equal(invoke.Parameters[i].Type, endInvoke.Parameters[k].Type); 182Assert.Equal(invoke.Parameters[i].RefKind, endInvoke.Parameters[k++].RefKind); 185lastParameterType = endInvoke.Parameters[k++].Type; 188Assert.Equal(k, endInvoke.Parameters.Length); 214Assert.Equal(d.DelegateInvokeMethod.Parameters[0].Type, q); 341ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters; 348ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters; 357ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters; 395ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters; 400ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters; 407ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters; 426ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters; 431ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters; 438ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters; 457ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters; 463ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters; 471ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters; 491ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters; 497ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters; 505ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters; 803Assert.Equal(RefKind.In, d.DelegateInvokeMethod.Parameters[0].RefKind);

2860AssertEx.Equal(["A(3)"], e.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 2863AssertEx.Equal(["A(3)"], e.RemoveMethod.Parameters.Single().GetAttributes().ToStrings()); 2870AssertEx.Equal(["A(3)"], f.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 2873AssertEx.Equal(["A(3)"], f.RemoveMethod.Parameters.Single().GetAttributes().ToStrings()); 2879AssertEx.Equal(["A(23)"], g.AddMethod.Parameters.Single().GetAttributes().ToStrings()); 2882AssertEx.Equal(["A(33)"], g.RemoveMethod.Parameters.Single().GetAttributes().ToStrings());

562Assert.Equal(RefKind.In, p.GetMethod.Parameters[0].RefKind); 590Assert.Equal(RefKind.In, p.GetMethod.Parameters[0].RefKind);

2327var cInt = (ConstructedNamedTypeSymbol)del1.DelegateInvokeMethod.Parameters[0].Type; 2459verifyConstructedFileType(comp.GetMember<MethodSymbol>("C1.M1").Parameters[0].Type);

40var p = m.Parameters[0];

40var x = m.Parameters[0]; 122var x = m.Parameters[0]; 146var x = m.Parameters[0]; 193var element = add.Parameters[0]; 346Assert.Equal(t, m.Parameters[0].Type); 362var p1 = m.Parameters[0]; 363var p2 = m.Parameters[1]; 410var p1 = m.Parameters[0]; 453var p1 = method.Parameters[0]; 454var p2 = method.Parameters[1]; 533var param = mem1.Parameters.First() as ParameterSymbol; 1367var classBMethodMParameters = classBMethodM.Parameters; 1390var classCBaseMethodMParameters = classCBaseMethodM.Parameters; 1637ParameterSymbol pin = mreturn.Parameters.Single(); 2139var substitutedParameter1 = constructedMethod1.Parameters.Single(); 2140var substitutedParameter2 = constructedMethod2.Parameters.Single(); 2164var extensionParameter1 = reducedMethod1.Parameters.Single(); 2165var extensionParameter2 = reducedMethod2.Parameters.Single();

1881Assert.Equal(2, getters.Count(getter => getter.Parameters.Length == 1)); 1882Assert.Equal(1, getters.Count(getter => getter.Parameters.Length == 2)); 1884Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32)); 1885Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_String)); 1887getter.Parameters.Length == 2 && 1888getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32 && 1889getter.Parameters[1].Type.SpecialType == SpecialType.System_String)); 1961Assert.Equal(1, accessor.Parameters.Length); 1962var locs = accessor.Parameters[0].Locations; 1968Assert.Equal(2, accessor.Parameters.Length); 1970locs = accessor.Parameters[0].Locations;

35var x = ctor.Parameters[0]; 39var y = ctor.Parameters[1]; 55var x = ctor.Parameters[0]; 59var t = ctor.Parameters[1]; 87var a = ctor.Parameters[0]; 91var b = ctor.Parameters[1]; 120var p1 = ctor.Parameters[0]; 122var p2 = ctor.Parameters[1]; 139Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything)); 750Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything)); 803Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything)); 900Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything));

25208Assert.Equal("System.Int32 modopt(I1) value", c2M01Set.Parameters.Single().ToTestDisplayString()); 25248Assert.Equal("System.Int32 modopt(I2) value", c3M01Set.Parameters.Single().ToTestDisplayString()); 27676Assert.Equal("System.Action<System.Int32> value", c1M01Add.Parameters.Single().ToTestDisplayString()); 27687Assert.Equal("System.Action<System.Int32> value", c1M01Remove.Parameters.Single().ToTestDisplayString()); 27753Assert.Equal("System.Action<System.Int32 modopt(I1)> value", c2M01Add.Parameters.Single().ToTestDisplayString()); 27765Assert.Equal("System.Action<System.Int32 modopt(I1)> value", c2M01Remove.Parameters.Single().ToTestDisplayString()); 27787Assert.Equal("System.Action value", c3M02Add.Parameters.Single().ToTestDisplayString()); 27866Assert.Equal("System.Action value", c4M02Add.Parameters.Single().ToTestDisplayString()); 27879Assert.Equal("System.Action value", c4M02Remove.Parameters.Single().ToTestDisplayString()); 34212var modifier = m01.Parameters.First().RefCustomModifiers.Single(); 34218Assert.Empty(m01.Parameters.Last().RefCustomModifiers); 34269var modifier = m01.Parameters.Last().RefCustomModifiers.Single(); 34273Assert.Empty(m01.Parameters.First().RefCustomModifiers);

188var sourceParameter = sourceAssembly.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M").Parameters.Single(); 189var referencedParameter = referencedAssembly.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M").Parameters.Single(); 264var sourceParameter = sourceAssembly.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M").Parameters.Single(); 265var referencedParameter = referencedAssembly.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M").Parameters.Single();

2348var param = mem2.Parameters[0]; 3373var param = mem1.Parameters[0] as ParameterSymbol; 3763Assert.Equal("T t", f.Parameters[0].ToTestDisplayString());

510var paramList = (method as MethodSymbol).Parameters; 511var p1 = method.Parameters[0]; 512var p2 = method.Parameters[1]; 513var p3 = method.Parameters[2];

97Assert.Equal(reducedMethod.CallsiteReducedFromMethod.Parameters[0].Type, reducedMethod.ReceiverType);

578Assert.Equal(propertyOrEventType, accessor.Parameters.Single().Type); 595var accessorParameters = accessor.Parameters;

75var parameters = method.Parameters;

57VisitList(method.Parameters);

56AddIfUsesIsNullable(symbol, symbol.Parameters, inProgress: null);