164public override ImmutableArray<ParameterSymbol> Parameters

103public 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

143public override ImmutableArray<ParameterSymbol> Parameters

766public override ImmutableArray<ParameterSymbol> Parameters =>

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

333public override ImmutableArray<ParameterSymbol> Parameters

510public override ImmutableArray<ParameterSymbol> Parameters

151public override ImmutableArray<ParameterSymbol> Parameters

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

199public override ImmutableArray<ParameterSymbol> Parameters

150public override ImmutableArray<ParameterSymbol> Parameters

133public sealed override ImmutableArray<ParameterSymbol> Parameters

140public sealed override ImmutableArray<ParameterSymbol> Parameters

97public override ImmutableArray<ParameterSymbol> Parameters

189public sealed override ImmutableArray<ParameterSymbol> Parameters

183public sealed override ImmutableArray<ParameterSymbol> Parameters

321public sealed override ImmutableArray<ParameterSymbol> Parameters

248public sealed override ImmutableArray<ParameterSymbol> Parameters

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

377public override ImmutableArray<ParameterSymbol> Parameters => _parameters; 443public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty; 538public override ImmutableArray<ParameterSymbol> Parameters

166public override ImmutableArray<ParameterSymbol> Parameters

110public override ImmutableArray<ParameterSymbol> Parameters

35public override ImmutableArray<ParameterSymbol> Parameters

134public override ImmutableArray<ParameterSymbol> Parameters

254public override ImmutableArray<ParameterSymbol> Parameters

217public override ImmutableArray<ParameterSymbol> Parameters

138public override ImmutableArray<ParameterSymbol> Parameters

80public override ImmutableArray<ParameterSymbol> Parameters

56public override ImmutableArray<ParameterSymbol> Parameters

352public override ImmutableArray<ParameterSymbol> Parameters

144public override ImmutableArray<ParameterSymbol> Parameters

115public override ImmutableArray<ParameterSymbol> Parameters

341var parameters = accessorForDefaultArguments.Parameters; 3022methodSymbol.Parameters, 3101methodSymbol.Parameters, 3268methodSymbol.Parameters, 3348methodSymbol.Parameters, 3586call.Method.Parameters, 3652call.Method.Parameters, 3684constructorSymbol.Parameters, 4013methodSymbol.Parameters, 4097methodSymbol.Parameters, 4138constructorSymbol.Parameters, 4547call.Method.Parameters[0].EffectiveScope == ScopedKind.ScopedValue)

227attributeConstructor.Parameters, 239if (attributeConstructor.Parameters.Any(static p => p.RefKind == RefKind.In)) 291ValidateTypeForAttributeParameters(attributeConstructor.Parameters, ((AttributeSyntax)boundAttribute.Syntax).Name, diagnostics, ref hasErrors); 697ImmutableArray<ParameterSymbol> parameters = attributeConstructor.Parameters;

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

1290var delegateOrFuncPtrParameters = delegateOrFuncPtrMethod.Parameters; 1291var methodParameters = method.Parameters;

567foreach (var param in signature.Parameters)

684var parameters = deconstructMethod.Parameters;

4308var baseParameter = GetCorrespondingParameter(i, resultMember.Parameters, argsToParamsOpt, expanded: true); 4321BindDefaultArguments(nonNullSyntax, resultMember.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, ref argsToParamsOpt, out var defaultArguments, expanded, enableCallerInfo, diagnostics); 5731BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, ref argToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 8732original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 8733original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 9190var parameters = methodSymbol.Parameters;

744var parameters = localFunction.Parameters; 1030BindDefaultArguments(node, method.Parameters, analyzedArguments.Arguments, analyzedArguments.RefKinds, ref argsToParams, out var defaultArguments, expanded, enableCallerInfo: true, diagnostics); 1043ParameterSymbol receiverParameter = method.Parameters.First(); 1651parameterListList.Add(m.Parameters);

1065parameter = deconstructMethod.Parameters[parameterIndex];

1529var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo);

1220return new WithParametersBinder(method.Parameters, nextBinder); 1252parameters = parameters.Add(property.SetMethod.Parameters.Last()); 1267ImmutableArray<ParameterSymbol> parameters = invokeMethod.Parameters;

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

110foreach (var parameter in iterator.Parameters)

848Debug.Assert(!(viaExtensionMethod && builder.GetEnumeratorInfo.Method.Parameters.IsDefaultOrEmpty)); 851? builder.GetEnumeratorInfo.Method.Parameters[0].Type 911if (getEnumeratorMethod?.Parameters[0].IsOptional == false) 1037patternDisposeMethod.Parameters, 1260result.Parameters, 1320var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1333result.Parameters[0].Type); 1732method.Parameters,

206var parameters = _methodSymbol.Parameters; 232foreach (var parameter in _methodSymbol.Parameters) 324var parameters = _methodSymbol.Parameters;

271MethodSymbol methodSymbol => methodSymbol.Parameters, 289return method.Parameters; 303return method.Parameters; 317return invokeMethod.Parameters;

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

593method.Parameters, 647constructor.Parameters, 761var parameters = deconstructMethod.Parameters;

158GetDelegateOrFunctionPointerArguments(source.Syntax, analyzedArguments, delegateInvokeMethodOpt.Parameters, binder.Compilation); 232var thisParameter = method.Parameters[0]; 286GetDelegateOrFunctionPointerArguments(syntax, analyzedArguments, delegateInvokeMethod.Parameters, Compilation); 353if (methodGroup.IsExtensionMethodGroup && !method.Parameters[0].Type.IsReferenceType)

1419var delegateParameters = invokeMethod.Parameters;

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

233disposeMethod.Parameters,

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

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

1069foreach (var p in invoke.Parameters)

382var parameters = m.Parameters;

1623EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 1774EmitArguments(arguments, method.Parameters, call.ArgumentRefKindsOpt); 2232EmitArguments(expression.Arguments, constructor.Parameters, expression.ArgumentRefKindsOpt); 2416if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2490EmitArguments(objCreation.Arguments, constructor.Parameters, objCreation.ArgumentRefKindsOpt);

1136var rewrittenArguments = VisitArguments(node.Arguments, method.Parameters, node.ArgumentRefKindsOpt); 1252var rewrittenArguments = VisitArguments(node.Arguments, constructor.Parameters, node.ArgumentRefKindsOpt);

2053if (method.Parameters.Length == 0) 2058if (method.Parameters.Length > 1) 2068var firstType = method.Parameters[0].TypeWithAnnotations;

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

2028GetParameterSymbol(method.Parameters, parameter, cancellationToken) ?? 2029((object)method.PartialDefinitionPart == null ? null : GetParameterSymbol(method.PartialDefinitionPart.Parameters, parameter, cancellationToken)); 2089return 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));

249CheckParameterCompliance(symbol.DelegateInvokeMethod.Parameters, symbol); 308CheckForMeaninglessOnParameter(symbol.Parameters); 323CheckParameterCompliance(symbol.Parameters, symbol.ContainingType); 470CheckForMeaninglessOnParameter(method.Parameters); 477CheckForMeaninglessOnParameter(method.Parameters);

616return delegateInvoke.Parameters;

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

91var submissionArrayReference = new BoundParameter(syntax, submissionConstructor.Parameters[0]) { WasCompilerGenerated = true }; 197var parameter = accessor.Parameters[0]; 294accessor.Parameters[0]); 384parameterSymbol: accessor.Parameters[0])

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

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

726invokeMethod.Parameters.SequenceEqual(otherInvokeMethod.Parameters, 809method.Parameters.SequenceEqual(other.Parameters, AreParametersEqual) &&

90return moduleBeingBuilt.Translate(UnderlyingMethod.Parameters);

206return moduleBeingBuilt.Translate(AdaptedMethodSymbol.Parameters); 212Debug.Assert(AdaptedMethodSymbol.Parameters.All(p => p.IsDefinition)); 215return AdaptedMethodSymbol.Parameters.SelectAsArray<ParameterSymbol, Cci.IParameterDefinition>(p => p.GetCciAdapter());

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

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

472return (object)method == null ? ImmutableArray<ParameterSymbol>.Empty : method.Parameters; 2822var param = method.Parameters[0];

1692foreach (var parameter in method.Parameters)

2724var methodParameters = methodSymbol.Parameters; 2725var signatureParameters = (_useDelegateInvokeParameterTypes ? _delegateInvokeMethod! : methodSymbol).Parameters; 2865EnforceNotNullIfNotNull(node.Syntax, this.State, method.Parameters, method.ReturnNotNullIfParameterNotNull, ResultType.State, outputParam: null); 3401return invokeMethod!.Parameters.SequenceEqual(l.Parameters, 3461node, arguments, node.ArgumentRefKindsOpt, constructor?.Parameters ?? default, 3529argumentsCompletion(argumentResults, constructor?.Parameters ?? default, constructor); 3915addMethod.Parameters, 3971node, containingType, visitArgumentsCompletion.Invoke(argumentResults, addMethod.Parameters, addMethod).method, 4421if ((leftType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[0].Name)) || 4422(rightType.IsNotNull && methodOpt.ReturnNotNullIfParameterNotNull.Contains(methodOpt.Parameters[1].Name))) 4659var parameters = method.Parameters; 5698(method, results, returnNotNull) = VisitArguments(node, node.Arguments, refKindsOpt, method!.Parameters, node.ArgsToParamsOpt, node.DefaultArguments, 5775var parameterType = method.Parameters[0].TypeWithAnnotations; 6119return VisitArguments(node, arguments, refKindsOpt, method is null ? default : method.Parameters, argsToParamsOpt, defaultArguments, expanded, invokedAsExtensionMethod, method); 6211parametersOpt = method.Parameters; 7997NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters), 8486var parameter = method.Parameters[0]; 8782method = CheckMethodGroupReceiverNullability(group, delegateInvokeMethod.Parameters, method, node.IsExtensionMethod); 8938CheckExtensionMethodThisNullability(receiverOpt, Conversion.Identity, method.Parameters[0], receiverType); 9312var parameters = deconstructMethod.Parameters; 9320CheckExtensionMethodThisNullability(right, argConversion, deconstructMethod.Parameters[0], rightResult); 9552targetTypeOfOperandConversion = incrementOperator.Parameters[0].TypeWithAnnotations; 9554parameter = incrementOperator.Parameters[0]; 9670VisitArguments(node, ImmutableArray.Create(node.Left, right), method.ParameterRefKinds, method.Parameters, argsToParamsOpt: default, defaultArguments: default, 9998if (node.EnumeratorInfoOpt?.GetEnumeratorInfo is { Method: { IsExtensionMethod: true, Parameters: var parameters } } enumeratorMethodInfo) 10345var parameter = method.Parameters[0]; 10472ReportArgumentWarnings(left!, leftType, trueFalseOperator.Parameters[0]); 10477ReportArgumentWarnings(left!, leftType, logicalOperator.Parameters[0]); 10487ReportArgumentWarnings(right, rightType, logicalOperator.Parameters[1]);

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

85foreach (var p in m.Parameters)

142if (_isEnumerable && this.method.Parameters.Any(static p => p.IsSourceParameterWithEnumeratorCancellationAttribute())) 169bodyBuilder.Add(F.Assignment(F.InstanceField(stateField), F.Parameter(F.CurrentFunction.Parameters[0]))); // this.state = state; 232BoundParameter tokenParameter = F.Parameter(getEnumeratorMethod.Parameters[0]); 512F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetResult, F.Parameter(IValueTaskSourceOfBool_GetResult.Parameters[0])))); 537F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetStatus, F.Parameter(IValueTaskSourceOfBool_GetStatus.Parameters[0])))); 565F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[0]), 566F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[1]), 567F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[2]), 568F.Parameter(IValueTaskSourceOfBool_OnCompleted.Parameters[3]))), 590F.ExpressionStatement(F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetResult, F.Parameter(IValueTaskSource_GetResult.Parameters[0]))), 614F.Call(F.InstanceField(_promiseOfValueOrEndField), promise_GetStatus, F.Parameter(IValueTaskSource_GetStatus.Parameters[0])))); 638F.Parameter(IValueTaskSource_OnCompleted.Parameters[0]), 639F.Parameter(IValueTaskSource_OnCompleted.Parameters[1]), 640F.Parameter(IValueTaskSource_OnCompleted.Parameters[2]), 641F.Parameter(IValueTaskSource_OnCompleted.Parameters[3]))),

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

372DeclareLocals(_currentScope, _topLevelMethod.Parameters); 575DeclareLocals(_currentScope, functionSymbol.Parameters, _inExpressionTree);

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

632var conversionInputType = method.Parameters[0].Type; 639? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false)

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

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

300foreach (var parameter in _factory.CurrentFunction.Parameters) 311MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)parameter.Ordinal))))); 407MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, assignment, refAssignmentSourceIndex, targetIndex)) 537MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex))); 600MakeStoreLoggerArguments(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null, targetIndex)));

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

998symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

1030((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol :

1609Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1715Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked);

302_factory.Convert(addRemove.Parameters[0].Type, rewrittenReceiver), 303_factory.Convert(addRemove.Parameters[1].Type, rewrittenArgument));

146Debug.Assert(addMethod.Parameters 165if (addMethod.Parameters[0].RefKind == RefKind.Ref) 170var builder = ArrayBuilder<RefKind>.GetInstance(addMethod.Parameters.Length, RefKind.None);

500Debug.Assert(method.Parameters.AsSpan()[1..].All(assertParametersAreOptional, (p, assertOptional) => (p.IsOptional || p.IsParams || !assertOptional) && p.RefKind == RefKind.None)); 505Debug.Assert(!assertParametersAreOptional || method.Parameters.All(p => p.IsOptional || p.IsParams));

317foreach (var parameter in method.Parameters) 467foreach (var parameter in method.Parameters)

122get { return this.BaseMethod.Parameters; }

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

130Debug.Assert(this.AttributeConstructor.Parameters[parameterIndex].IsOptional); 208ImmutableArray<ParameterSymbol> parameters = ctor.Parameters;

1105return method.Parameters;

38return ((MethodSymbol)member).Parameters; 208foreach (ParameterSymbol param in method.Parameters) 572return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

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

310return this.Parameters.Length; 892ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 905ParameterSignature.PopulateParameterSignature(this.Parameters, ref _lazyParameterSignature); 951DeriveUseSiteInfoFromParameters(ref result, this.Parameters)) 965GetUnificationUseSiteDiagnosticRecursive(ref diagnosticInfo, this.Parameters, this, ref unificationCheckedTypes) ||

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

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

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

128return _underlying.Parameters.GetPublicSymbols();

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo); 242return _reducedFrom.Parameters[0].Type; 247_reducedFrom.Parameters[0].TypeWithAnnotations.ToPublicAnnotation(); 531internal override bool IsEffectivelyReadOnly => _reducedFrom.Parameters[0].RefKind == RefKind.In; 550var reducedFromParameters = _reducedFrom.Parameters;

166var list = _underlyingMethod.Parameters;

1023var targetParamsBuilder = ArrayBuilder<ParameterSymbol>.GetInstance(method.Parameters.Length); 1024foreach (var param in method.Parameters)

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

2055var refKind1 = method1.Parameters[i].RefKind; 2056var refKind2 = method2.Parameters[i].RefKind; 3603ParametersMatchPropertyAccessor(propertySymbol, getNotSet, methodSymbol.Parameters)) 3639ParametersMatchEventAccessor(eventSymbol, methodSymbol.Parameters))

1259var baseParameters = baseMethod.Parameters; 1260var overrideParameters = overrideMethod.Parameters; 1384var parameters = method.Parameters; 1450var baseParameters = baseMethod.Parameters; 1451var overrideParameters = overrideMethod.Parameters;

786foreach (var parameter in this.Parameters) 884foreach (var parameter in Parameters)

63foreach (var parameter in Parameters)

708foreach (var param in this.Parameters) 955foreach (var param in Parameters) 1143var enumeratorCancellationCount = Parameters.Count(p => p.IsSourceParameterWithEnumeratorCancellationAttribute());

168return reduced.Parameters[0].Type; 333var unsubstitutedParameters = OriginalDefinition.Parameters;

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

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

132method.Parameters[0].Type.Equals(containingType, TypeCompareKind.AllIgnoreOptions) && 133method.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))

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

282foreach (var oldParam in sourceMethod.Parameters)

1603interfaceMethod.Parameters,

516return invokeMethod.Parameters; 891(TypeWithAnnotations nextTypeWithAnnotations, TypeSymbol? nextType) = getNextIterationElements(currentPointer.Parameters[i].TypeWithAnnotations, canDigThroughNullable); 908next = currentPointer.Parameters[i].TypeWithAnnotations;

169CheckParametersVarianceSafety(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) 5600var param = m.Parameters.Single(); 5713var param = method.Parameters.Single(); 6293Assert.True(baseM1.Parameters.Single().Type.Equals(derivedM1.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 6295Assert.True(baseM3.Parameters.Single().Type.Equals(derivedM3.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 7046var funcPtr = (FunctionPointerTypeSymbol)m1.Parameters.Single().Type; 7054funcPtr = (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]; 4116var parameterB = fooB.Parameters[0];

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

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

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

603var parameter = method.Parameters.Single(); 659var baseParameter = baseMethod.Parameters.Single(); 667var derivedParameter = derivedMethod.Parameters.Single();

445var parameter1 = m1.Parameters.Single(); 450Assert.Same(module.GetCorLibType(SpecialType.System_Boolean), m2.Parameters.Single().Type); 451Assert.Same(module.GetCorLibType(SpecialType.System_Char), m3.Parameters.Single().Type); 453var method4ParamTypes = m4.Parameters.Select(p => p.Type).ToArray(); 471Assert.Same(m5.TypeParameters[0], m5.Parameters[0].Type); 472Assert.Same(m5.TypeParameters[1], m5.Parameters[1].Type); 638Assert.Equal(0, cctor.Parameters.Length); 1306Assert.Empty(attribute.AttributeConstructor.Parameters); 2025Assert.Equal(RefKind.None, m.Parameters[0].RefKind); 2026Assert.Equal(RefKind.Ref, m.Parameters[1].RefKind); 2027Assert.Equal(RefKind.Out, m.Parameters[2].RefKind); 2073Assert.Equal(invoke.Parameters.Length + 2, beginInvoke.Parameters.Length); 2076for (int i = 0; i < invoke.Parameters.Length; i++) 2078Assert.Equal(invoke.Parameters[i].Type, beginInvoke.Parameters[i].Type); 2079Assert.Equal(invoke.Parameters[i].RefKind, beginInvoke.Parameters[i].RefKind); 2081Assert.Equal("System.AsyncCallback", beginInvoke.Parameters[invoke.Parameters.Length].Type.ToTestDisplayString()); 2082Assert.Equal("System.Object", beginInvoke.Parameters[invoke.Parameters.Length + 1].Type.ToTestDisplayString()); 2089for (int i = 0; i < invoke.Parameters.Length; i++) 2091if (invoke.Parameters[i].RefKind != RefKind.None) 2093Assert.Equal(invoke.Parameters[i].TypeWithAnnotations, endInvoke.Parameters[k].TypeWithAnnotations); 2094Assert.Equal(invoke.Parameters[i].RefKind, endInvoke.Parameters[k++].RefKind); 2097Assert.Equal("System.IAsyncResult", endInvoke.Parameters[k++].Type.ToTestDisplayString()); 2098Assert.Equal(k, endInvoke.Parameters.Length); 2599var parameters = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters; 2609var delegateParameters = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters; 2617var lambdaParameters = module.GlobalNamespace.GetTypeMember("C").GetTypeMember("<>c").GetMethod("<M>b__0_0").Parameters;

1647var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 1667var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 1954var invokeParameter = type.DelegateInvokeMethod.Parameters.Single(); 1958var beginInvokeParameter = type.GetMethod("BeginInvoke").Parameters.First(); 1962var endInvokeParameter = type.GetMethod("EndInvoke").Parameters.First(); 2002var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 2022var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("Method").Parameters.Single(); 2062var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("op_LogicalNot").Parameters.Single(); 2082var parameters = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod("op_Addition").Parameters; 2106var parameter = module.ContainingAssembly.GetTypeByMetadataName("Test").GetMethod(".ctor").Parameters.Single(); 2493var parameter = type.GetMethod("M").Parameters.Single(); 2519var parameter = type.GetMethod("M").Parameters.Single(); 2541var parameter = type.GetMethod("M").Parameters.Single(); 2566var parameter = type.GetMethod("M").Parameters.Single(); 2588var parameter = type.GetMethod("M").Parameters.Single(); 2615var implicitParameter = type.GetMethod("M").Parameters.Single(); 2622var explicitParameter = explicitImplementation.Parameters.Single(); 2643var parameter = type.GetMethod("M").Parameters.Single(); 2669var parameter = type.GetMethod("M").Parameters.Single(); 2691var parameter = type.GetMethod("M").Parameters.Single(); 2716var parameter = type.GetMethod("Parent.M").Parameters.Single(); 3322var explicitParameter = explicitImplementation.Parameters.First(); 3664var parameter = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters.Single(); 3736var parameter = module.ContainingAssembly.GetTypeByMetadataName("D").DelegateInvokeMethod.Parameters.Single(); 4496Assert.Empty(parentMethod.Parameters.Single().RefCustomModifiers); 4501Assert.Empty(childMethod.Parameters.Single().RefCustomModifiers); 4506AssertSingleInAttributeRequiredModifier(interfaceMethod.Parameters.Single().RefCustomModifiers); 4511AssertSingleInAttributeRequiredModifier(proxyMethod.Parameters.Single().RefCustomModifiers); 4539Assert.Empty(parentMethod.Parameters.Single().RefCustomModifiers); 4547AssertSingleInAttributeRequiredModifier(interfaceMethod.Parameters.Single().RefCustomModifiers); 4552AssertSingleInAttributeRequiredModifier(proxyMethod.Parameters.Single().RefCustomModifiers);

5671var p = (PEParameterSymbol)m.Parameters[0]; 5739var p = (PEParameterSymbol)m.Parameters[0]; 5780AssertParametersWithoutNames(compilation.GlobalNamespace.GetMember<NamedTypeSymbol>("I1").GetMember<MethodSymbol>("M1").Parameters, false); 5786AssertParametersWithoutNames(module.GlobalNamespace.GetMember<NamedTypeSymbol>("I1").GetMember<MethodSymbol>("M1").Parameters, true); 5789p = (PEParameterSymbol)module.GlobalNamespace.GetMember<NamedTypeSymbol>("Program").GetMember<MethodSymbol>("M").Parameters[0]; 5793p = (PEParameterSymbol)module.GlobalNamespace.GetMember<NamedTypeSymbol>("Program").GetMember<MethodSymbol>("M1").Parameters[0]; 5797p = (PEParameterSymbol)module.GlobalNamespace.GetMember<NamedTypeSymbol>("Program").GetMember<MethodSymbol>("M2").Parameters[0];

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

2652Assert.Equal("II", GetSingleAttributeName(event9.AddMethod.Parameters.Single())); 3144attrs = mem.Parameters[0].GetAttributes(); 3146attrs = mem.Parameters[1].GetAttributes(); 3416Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParams); 3553Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParams); 3973attrs = setter.Parameters[0].GetAttributes(attributeTypeForParam); 4807var param = gooMethod.Parameters[0];

4393var attr = ctor.Parameters.Single().GetAttributes().Single(); 4423var 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)

1109AssertNativeIntegerAttribute(method.Parameters[0].GetAttributes()); 1156AssertNativeIntegerAttribute(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());

414parm = method.Parameters[0]; 421parm = method.Parameters[0]; 431parm = method.Parameters[1]; 446parm = method.Parameters[0]; 451parm = method.Parameters[1]; 457parm = method.Parameters[2]; 1369var param = (SourceParameterSymbol)partialDefPart.Parameters[0]; 1373param = (SourceParameterSymbol)partialImplPart.Parameters[0]; 4985var paramsParameter = useParamsMethod.Parameters[0]; 4989var noParamsParameter = noParamsMethod.Parameters[0]; 9655var param = method.Parameters.Single(); 13365var attribute = module.ContainingAssembly.GetTypeByMetadataName("Program").GetMethod("Test").Parameters.Single().GetAttributes().Single(); 13370Assert.Equal("transformFlags", attribute.AttributeConstructor.Parameters.Single().Name);

563verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 564verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 10314var nintType = method.Parameters[0].Type; 10318var intPtrType = method.Parameters[1].Type; 10327var nuintType = method.Parameters[2].Type; 10331var uintPtrType = method.Parameters[3].Type;

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

399foreach (var parameter in m.Parameters) 1322foreach (var p in sourceMethod.Parameters) 1359foreach (var parameter in currentFrame.Parameters)

106var otherParameter = method.Parameters[otherOrdinal];

146foreach (var substitutedSourceParameter in this.SubstitutedSourceMethod.Parameters)

37method.Parameters[0].Type);

80m => method.Parameters.SelectAsArray(p => SynthesizedParameterSymbol.Create(m, p.TypeWithAnnotations, p.Ordinal, p.RefKind, p.Name, p.EffectiveScope, refCustomModifiers: p.RefCustomModifiers))); 90method.Parameters[0].Type);

34method.Parameters[0].Type);

396AssertEx.All(method.Parameters, parameter => method.IsContainingSymbolOfAllTypeParameters(parameter.Type)); 451: candidates.FirstOrDefault(c => parameterTypeNames.SequenceEqual(((MethodSymbol)c).Parameters.Select(p => p.TypeWithAnnotations.Type.Name)));

785var parameter = ((MethodSymbol)methodData.Method).Parameters[0]; 1033var parameter = ((MethodSymbol)methodData.Method).Parameters[0]; 2212Assert.Equal(1, method.Parameters.Length); 2213var eeTypeParameterSymbol = (EETypeParameterSymbol)method.Parameters[0].Type;

1109Assert.Equal(method.Parameters[0].Type, method.ReturnType); 1120Assert.Equal(method.Parameters[0].Type, method.ReturnType);

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

1935Assert.Equal("i", method.Parameters[0].Name); 1957Assert.Equal("i", method.Parameters[0].Name); 2569var x = foo.Parameters[0];

3919var 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());

3276Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3281Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3286Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3367Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3373Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3379Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3483Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3576Assert.True(property0.SetMethod.Parameters[1].HasUnsupportedMetadata); 3813Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3901Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata); 3990Assert.True(property0.SetMethod.Parameters[0].HasUnsupportedMetadata);

6794var sParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 6820var sParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 6852var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 6887var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 6927var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 6962var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7002var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7040var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7080var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7115var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7155var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 7190var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7223var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7263var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7303var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7343var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7383var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 7418var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 7460var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 7495var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod(".ctor").Parameters.Single(); 7537var cParam = comp.GetTypeByMetadataName("C").GetMethod(".ctor").Parameters.Single(); 7577var cParam = substitutedC.GetMethod("M").Parameters.Single(); 7618var cParam = comp.GetTypeByMetadataName("C`1").GetMethod("M").Parameters.Single(); 7686var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.First(); 7780var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.First(); 7892var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7958var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 7988var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8161var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8221var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 8341var cParam = verifier.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8571var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(3).Single(); 8696var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8847var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8958var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9025var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9081var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9438var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 9700var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 9776var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 11834var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single();

3629return 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();

117VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: true); 122VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: false); 212VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: true); 216VerifyTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: false); 502var parameters = method.Parameters; 503Assert.Equal(parameters, method.Parameters); // same array 566VerifyMember(method.Parameters[i], underlyingMethod.Parameters[i], signed); 716VerifyErrorTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: true); 720VerifyErrorTypes((NamedTypeSymbol)method.Parameters[0].Type, (NamedTypeSymbol)method.Parameters[1].Type, signed: false); 1963verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 1964verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2133verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2134verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2229verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2230verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2356verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.M1").Parameters[0].Type, signed: true); 2357verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.M2").Parameters[0].Type, signed: false); 2476verifyType((NamedTypeSymbol)compB.GetMember<MethodSymbol>("Program.M1").Parameters[0].Type, signed: true); 2477verifyType((NamedTypeSymbol)compB.GetMember<MethodSymbol>("Program.M2").Parameters[0].Type, signed: false); 2632verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2633verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2734verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2735verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 2874verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F1").Parameters[0].Type, signed: true); 2875verifyType((NamedTypeSymbol)comp.GetMember<MethodSymbol>("Program.F2").Parameters[0].Type, signed: false); 3683var underlyingType0 = (NamedTypeSymbol)method.Parameters[0].Type; 3684var underlyingType1 = (NamedTypeSymbol)method.Parameters[1].Type; 3717var underlyingType0 = (NamedTypeSymbol)method.Parameters[0].Type; 3718var underlyingType1 = (NamedTypeSymbol)method.Parameters[1].Type; 3751var underlyingType0 = (NamedTypeSymbol)method.Parameters[0].Type; 3752var underlyingType1 = (NamedTypeSymbol)method.Parameters[1].Type;

8796TypeWithAnnotations getParameterType(CSharpCompilation c) => c.GetMember<MethodSymbol>("A.F").Parameters[0].TypeWithAnnotations; 8930Assert.Equal(NullableAnnotation.Oblivious, method.Parameters[0].TypeWithAnnotations.NullableAnnotation); 8980verifyTuple(method.Parameters[0].TypeWithAnnotations); 9041var parameter = method.Parameters.Single(); 11443Assert.True(m1.Parameters[0].Type.IsNullableType()); 11444Assert.True(m1.Parameters[0].Type.IsValueType); 11445Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11494Assert.True(m1.Parameters[0].Type.IsNullableType()); 11495Assert.False(m1.Parameters[0].Type.IsReferenceType); 11557Assert.True(m1.Parameters[0].Type.IsNullableType()); 11558Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11561Assert.False(m2.Parameters[0].Type.IsNullableType()); 11562Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11565Assert.True(m3.Parameters[0].Type.IsNullableType()); 11566Assert.True(m3.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11616Assert.True(m1.Parameters[0].Type.IsNullableType()); 11617Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11621Assert.True(m2.Parameters[0].Type.IsNullableType()); 11622Assert.True(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11690Assert.True(((NamedTypeSymbol)m3.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11691Assert.True(((NamedTypeSymbol)m3.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11692Assert.True(((NamedTypeSymbol)m4.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11693Assert.True(((NamedTypeSymbol)m4.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11694Assert.True(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11721Assert.True(m1.Parameters[0].Type.IsNullableType()); 11722Assert.True(m1.Parameters[0].Type.StrippedType().IsValueType); 11756Assert.True(m1.Parameters[0].Type.IsNullableType()); 11757Assert.False(m1.Parameters[0].Type.StrippedType().IsValueType); 11758Assert.False(m1.Parameters[0].Type.StrippedType().IsReferenceType); 11840Assert.True(m1.Parameters[0].Type.IsNullableType()); 11841Assert.True(m2.Parameters[0].Type.IsNullableType()); 11842Assert.True(m3.Parameters[0].Type.IsNullableType()); 11843Assert.True(m4.Parameters[0].Type.IsNullableType()); 11881Assert.True(m1.Parameters[0].Type.IsNullableType()); 12087Assert.False(m1.Parameters[0].Type.IsNullableType()); 12088Assert.Equal(NullableAnnotation.Annotated, m1.Parameters[0].TypeWithAnnotations.NullableAnnotation); 12089Assert.True(m1.Parameters[0].Type.IsReferenceType); 12090Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 12093Assert.False(m4.Parameters[0].Type.IsNullableType()); 12097Assert.False(m5.Parameters[0].Type.IsNullableType()); 12246Assert.True(b.GetMember<MethodSymbol>("M1").Parameters[0].Type.IsNullableType()); 12247Assert.True(b.GetMember<MethodSymbol>("M2").Parameters[0].Type.IsNullableType()); 12248Assert.False(b.GetMember<MethodSymbol>("M3").Parameters[0].Type.IsNullableType()); 12249Assert.True(b.GetMember<MethodSymbol>("M4").Parameters[0].Type.IsNullableType()); 12250Assert.True(b.GetMember<MethodSymbol>("M5").Parameters[0].Type.IsNullableType()); 12335Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12336Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12417Assert.Equal(expectMatch, member.Parameters.Single().TypeWithAnnotations.Equals(member.OverriddenMethod.Parameters.Single().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12703Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12704Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12791Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12792Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 12888Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 13040Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 13131Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 13676Assert.False(m1.Parameters[0].TypeWithAnnotations.Equals(m1.OverriddenMethod.ConstructIfGeneric(m1.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 13886Assert.False(m1.Parameters[0].Type.IsNullableType()); 13887Assert.Equal(NullableAnnotation.Annotated, m1.Parameters[0].TypeWithAnnotations.NullableAnnotation); 13888Assert.True(m1.Parameters[0].Type.IsReferenceType); 13889Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 13957Assert.True(((NamedTypeSymbol)m3.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13958Assert.True(((NamedTypeSymbol)m3.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13959Assert.True(((NamedTypeSymbol)m4.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13960Assert.True(((NamedTypeSymbol)m4.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13961Assert.False(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13962Assert.False(((NamedTypeSymbol)m5.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 14123Assert.False(member.Parameters[0].TypeWithAnnotations.Equals(member.OverriddenMethod.ConstructIfGeneric(member.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 14128Assert.True(m3.Parameters[0].TypeWithAnnotations.Equals(m3.OverriddenMethod.ConstructIfGeneric(m3.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 14217Assert.False(m1.Parameters[0].Type.IsNullableType()); 14218Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14222Assert.False(m2.Parameters[0].Type.IsNullableType()); 14223Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14273Assert.True(m1.Parameters[0].Type.IsNullableType()); 14274Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14278Assert.True(m2.Parameters[0].Type.IsNullableType()); 14279Assert.True(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 16474Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 16482Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 16618Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 16700Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 16782Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything)); 17695Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 17703Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 17842Assert.False(m1Impl.Parameters[i].TypeWithAnnotations.Equals(m1Def.Parameters[i].TypeWithAnnotations, 17846Assert.True(m1Impl.Parameters[3].TypeWithAnnotations.Equals(m1Def.Parameters[3].TypeWithAnnotations, 36130var actual = method.Parameters.Select(p => p.FlowAnalysisAnnotations); 38919var setterValueAttributes = setter.Parameters.Last().GetAttributes().Select(a => a.ToString()); 38920Assert.Equal(FlowAnalysisAnnotations.AllowNull, setter.Parameters.Last().FlowAnalysisAnnotations); 38980var setterValueAttributes = setter.Parameters.Last().GetAttributes().Select(a => a.ToString()); 38981Assert.Equal(FlowAnalysisAnnotations.AllowNull | FlowAnalysisAnnotations.DisallowNull, setter.Parameters.Last().FlowAnalysisAnnotations); 42607var setterValueAttributes = setter.Parameters.Last().GetAttributes().Select(a => a.ToString()); 42608Assert.Equal(FlowAnalysisAnnotations.DisallowNull, setter.Parameters.Last().FlowAnalysisAnnotations); 135163Assert.False(dGoo.Parameters[0].Type.IsNullableType()); 135164Assert.True(dGoo.Parameters[0].TypeWithAnnotations.NullableAnnotation == NullableAnnotation.Annotated); 135191Assert.True(c2Goo.Parameters[0].Type.IsReferenceType); 135192Assert.Equal(NullableAnnotation.Annotated, c2Goo.Parameters[0].TypeWithAnnotations.NullableAnnotation); 135219Assert.True(((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementType.IsReferenceType); 135220Assert.Equal(NullableAnnotation.Annotated, ((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementTypeWithAnnotations.NullableAnnotation); 135247Assert.True(c2Goo.Parameters[0].Type.IsNullableType()); 135248var tuple = c2Goo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 135362Assert.True(dGoo.Parameters[0].Type.IsReferenceType); 135363Assert.Equal(NullableAnnotation.Annotated, dGoo.Parameters[0].TypeWithAnnotations.NullableAnnotation); 135385Assert.True(((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementType.IsReferenceType); 135386Assert.Equal(NullableAnnotation.Annotated, ((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementTypeWithAnnotations.NullableAnnotation); 135408Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 135409var tuple = dGoo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 135513Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 135515var tuple = dGoo.Parameters[1].Type; 145606var parameterType = method.Parameters[0].TypeWithAnnotations;

375var x = ctor.Parameters[0]; 379var y = ctor.Parameters[1]; 446var x = ctor.Parameters[0]; 450var y = ctor.Parameters[1]; 493var x = ctor.Parameters[0]; 559var x = ctor.Parameters[0]; 563var y = ctor.Parameters[1]; 593var a = ctor.Parameters[0]; 597var b = ctor.Parameters[1]; 629var p1 = ctor.Parameters[0]; 631var p2 = ctor.Parameters[1]; 653Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything)); 685var p1 = ctor.Parameters[0]; 687var p2 = ctor.Parameters[1]; 2930var param1 = @class.InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0]; 2994Assert.Empty(comp.GetTypeByMetadataName("Test1").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes()); 2995Assert.Equal(2, comp.GetTypeByMetadataName("Test2").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes().Count()); 3037Assert.Empty(comp.GetTypeByMetadataName("Test1").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes()); 3038Assert.Equal(1, comp.GetTypeByMetadataName("Test2").InstanceConstructors.Where(c => !c.IsDefaultValueTypeConstructor()).Single().Parameters[0].GetAttributes().Count()); 5715var constructor = cMember.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.IsEmpty).Single();

5076var sParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 5104var sParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5141var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5181var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 5228var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5268var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5315var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5358var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5405var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5445var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5492var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5532var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 5579var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5626var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5673var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Skip(1).Single(); 5713var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 5762var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.Single(); 5802var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod(".ctor").Parameters.Single(); 5851var cParam = comp.GetTypeByMetadataName("C").GetMethod(".ctor").Parameters.Single(); 5896var cParam = substitutedC.GetMethod("M").Parameters.Single(); 5944var cParam = comp.GetTypeByMetadataName("C`1").GetMethod("M").Parameters.Single(); 5974var cParam = comp.GetTypeByMetadataName("C").GetMethod("M").Parameters.First(); 6100var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6169var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6199var cParam = comp.SourceModule.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6436var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6498var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single(); 6620var cParam = verifier.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 6852var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(3).Single(); 6979var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7132var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7245var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7316var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7376var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 7740var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(2).Single(); 8013var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 8092var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Single(); 8519var cParam = module.GlobalNamespace.GetTypeMember("C").GetMethod("M").Parameters.Skip(1).Single();

3411Assert.Equal(RefKind.Out, deconstruct.Parameters[0].RefKind); 3412Assert.Equal("X", deconstruct.Parameters[0].Name); 3414Assert.Equal(RefKind.Out, deconstruct.Parameters[1].RefKind); 3415Assert.Equal("Y", deconstruct.Parameters[1].Name); 10508var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0];

517Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 549Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[0].DeclaringSyntaxReferences.Single().GetSyntax()); 550Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 551Assert.IsType<ParameterSyntax>(primaryCtor.Parameters[2].DeclaringSyntaxReferences.Single().GetSyntax()); 575Assert.IsType<ParameterSyntax>(ctor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 576Assert.Equal(0, ctor.Parameters[1].Locations.Single().SourceSpan.Length); 603Assert.IsType<ParameterSyntax>(ctor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 604Assert.Equal(0, ctor.Parameters[1].Locations.Single().SourceSpan.Length); 638Assert.IsType<ParameterSyntax>(comp.GetMember<NamedTypeSymbol>("A").Constructors[0].Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 672Assert.IsType<ParameterSyntax>(comp.GetMember<NamedTypeSymbol>("A").Constructors[0].Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 697Assert.IsType<ParameterSyntax>(ctor.Parameters[0].DeclaringSyntaxReferences.Single().GetSyntax()); 698Assert.IsType<ParameterSyntax>(ctor.Parameters[1].DeclaringSyntaxReferences.Single().GetSyntax()); 12392foreach (var parameter in accessor.Parameters) 12503var parameterType = method.Parameters[0].TypeWithAnnotations; 12504Assert.True(method.OverriddenMethod.Parameters[0].TypeWithAnnotations.Equals(parameterType, TypeCompareKind.ConsiderEverything)); 14123Assert.Equal(RefKind.Out, deconstruct.Parameters[0].RefKind); 14124Assert.Equal("X", deconstruct.Parameters[0].Name); 14126Assert.Equal(RefKind.Out, deconstruct.Parameters[1].RefKind); 14127Assert.Equal("Y", deconstruct.Parameters[1].Name); 25103var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25163var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25240var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25297var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25372var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25456var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 25526var param1 = @class.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.AsSingleton()?.Name == "P1").Single().Parameters[0]; 28528var constructor = cMember.GetMembers(".ctor").OfType<MethodSymbol>().Where(m => m.Parameters.IsEmpty).Single();

10468var parameters = comp.GetMember<MethodSymbol>("A.F1").Parameters; 10472parameters = comp.GetMember<MethodSymbol>("A.F2").Parameters; 10476parameters = comp.GetMember<MethodSymbol>("A.F3").Parameters; 10480parameters = comp.GetMember<MethodSymbol>("A.F4").Parameters; 10518VerifyParameterSymbol(comp.GetMember<NamedTypeSymbol>("A").Constructors.Single(c => !c.IsImplicitlyDeclared).Parameters[0], "scoped ref T t", RefKind.Ref, ScopedKind.ScopedRef); 10519VerifyParameterSymbol(comp.GetMember<PropertySymbol>("A.this[]").GetMethod.Parameters[0], "scoped in System.Object o", RefKind.In, ScopedKind.ScopedRef); 10671VerifyParameterSymbol(delegateType.DelegateInvokeMethod.Parameters[parameterIndex], $"{expectedDisplayType} arg{parameterIndex + 1}", expectedRefKind, expectedScope, expectedHasUnscopedRefAttribute); 10708VerifyParameterSymbol(comp.GetMember<NamedTypeSymbol>("D1").DelegateInvokeMethod.Parameters[0], "scoped R r1", RefKind.None, ScopedKind.ScopedValue); 10709VerifyParameterSymbol(comp.GetMember<NamedTypeSymbol>("D2").DelegateInvokeMethod.Parameters[0], "scoped ref R r2", RefKind.Ref, ScopedKind.ScopedRef); 10796VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F0").Parameters[0], "scoped R r", RefKind.None, ScopedKind.ScopedValue); 10797VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F3").Parameters[0], "scoped ref R r", RefKind.Ref, ScopedKind.ScopedRef); 10798VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F6").Parameters[0], "scoped in R r", RefKind.In, ScopedKind.ScopedRef); 10799VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F9").Parameters[0], "out R r", RefKind.Out, ScopedKind.ScopedRef); 10906VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F0").Parameters[0], "scoped s", RefKind.None, ScopedKind.None); 10907VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F1").Parameters[0], "scoped scoped s", RefKind.None, ScopedKind.ScopedValue); 10908VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "ref scoped s", RefKind.Ref, ScopedKind.None); 10909VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F4").Parameters[0], "scoped ref scoped s", RefKind.Ref, ScopedKind.ScopedRef); 10910VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F5").Parameters[0], "in scoped s", RefKind.In, ScopedKind.None); 10911VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F7").Parameters[0], "scoped in scoped s", RefKind.In, ScopedKind.ScopedRef); 10912VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F8").Parameters[0], "out scoped s", RefKind.Out, ScopedKind.ScopedRef); 10913VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.FA").Parameters[0], "out scoped s", RefKind.Out, ScopedKind.ScopedRef); 11021var parameters = comp.GetMember<MethodSymbol>("A.F").Parameters; 11059VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.ReturnRef").Parameters[0], "scoped ref R r", RefKind.Ref, ScopedKind.ScopedRef); 11153VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F0").Parameters[0], "R<System.Object> r", RefKind.None, ScopedKind.None); 11154VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F1").Parameters[0], "scoped R<System.Object> r", RefKind.None, ScopedKind.ScopedValue); 11155VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F2").Parameters[0], "scoped", RefKind.None, ScopedKind.None); 11156VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Extensions.F3").Parameters[0], "scoped ref T t", RefKind.Ref, ScopedKind.ScopedRef); 11174VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "scoped params System.Object[] args", RefKind.None, ScopedKind.ScopedValue); 11437VerifyParameterSymbol(property.SetMethod.Parameters[0], expectedDisplayString, expectedRefKind, expectedScope); 11457VerifyParameterSymbol(method.Parameters[0], "scoped R<System.Int32> x", RefKind.None, ScopedKind.ScopedValue); 11458VerifyParameterSymbol(method.Parameters[1], "scoped in System.Int32 y", RefKind.In, ScopedKind.ScopedRef); 17401VerifyParameterSymbol(delegateInvokeMethods[0].Parameters[0], "R arg1", RefKind.None, ScopedKind.None); 17402VerifyParameterSymbol(delegateInvokeMethods[0].Parameters[1], "scoped R arg2", RefKind.None, ScopedKind.ScopedValue); 17403VerifyParameterSymbol(delegateInvokeMethods[1].Parameters[1], "scoped ref System.Int32 arg2", RefKind.Ref, ScopedKind.ScopedRef); 22518var parameters = comp.GetMember<MethodSymbol>("Program.ReturnRefStructRef").Parameters; 22582VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "ref R<System.Int32> r1", RefKind.Ref, ScopedKind.None); 22583VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped ref R<System.Int32> r2", RefKind.Ref, ScopedKind.ScopedRef); 22671VerifyParameterSymbol(type.GetMethod("F1").Parameters[0], "ref R<T> r1", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22672VerifyParameterSymbol(type.GetMethod("F2").Parameters[0], "out T t2", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22673VerifyParameterSymbol(type.GetMethod("F3").Parameters[0], "in R<T> t3", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22674VerifyParameterSymbol(type.GetMethod("F4").Parameters[0], "R<T> t4", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22755VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "ref R<System.Int32> r4", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22777var parameters = comp.GetMember<MethodSymbol>("Program.F").Parameters; 22805var parameters = comp.GetMember<MethodSymbol>("Program.ReturnOut").Parameters; 22865VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "out System.Int32 t1", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 22866VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "out System.Int32 t2", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 22867VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "out System.Int32 t3", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22930VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "ref System.Int32 t1", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 22931VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped ref System.Int32 t2", RefKind.Ref, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 22932VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "ref System.Int32 t3", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22933VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "ref System.Int32 t4", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22996VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "in System.Int32 t1", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 22997VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped in System.Int32 t2", RefKind.In, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 22998VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "in System.Int32 t3", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 22999VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "in System.Int32 t4", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23086VerifyParameterSymbol(baseType.GetMethod("F1A").Parameters[0], "R<System.Int32> r1", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 23087VerifyParameterSymbol(baseType.GetMethod("F2A").Parameters[0], "scoped R<System.Int32> r2", RefKind.None, ScopedKind.ScopedValue, expectedHasUnscopedRefAttribute: false); 23088VerifyParameterSymbol(baseType.GetMethod("F3A").Parameters[0], "R<System.Int32> r3", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23089VerifyParameterSymbol(baseType.GetMethod("F4A").Parameters[0], "R<System.Int32> r4", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23114VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F1").Parameters[0], "R<T> r1", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23115VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "ref R<T> r2", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23116VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F3").Parameters[0], "in R<T> r3", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23117VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F4").Parameters[0], "out R<T> r4", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23860VerifyParameterSymbol(typeA.GetMethod("NoAttributes").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 23861VerifyParameterSymbol(typeA.GetMethod("ScopedRefOnly").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 23862VerifyParameterSymbol(typeA.GetMethod("UnscopedRefOnly").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23863VerifyParameterSymbol(typeA.GetMethod("ScopedRefAndUnscopedRef").Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23962VerifyParameterSymbol(typeA.GetMethod("NoAttributes").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 23963VerifyParameterSymbol(typeA.GetMethod("ScopedRefOnly").Parameters[0], "scoped ref R x", RefKind.Ref, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 23964VerifyParameterSymbol(typeA.GetMethod("UnscopedRefOnly").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 23965VerifyParameterSymbol(typeA.GetMethod("ScopedRefAndUnscopedRef").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24070VerifyParameterSymbol(typeA.GetMethod("NoAttributes").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 24071VerifyParameterSymbol(typeA.GetMethod("ScopedRefOnly").Parameters[0], "scoped in R x", RefKind.In, ScopedKind.ScopedRef, expectedHasUnscopedRefAttribute: false); 24072VerifyParameterSymbol(typeA.GetMethod("UnscopedRefOnly").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24073VerifyParameterSymbol(typeA.GetMethod("ScopedRefAndUnscopedRef").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24130VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F3").Parameters[0], "out System.Int32 i3", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 24131VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F4").Parameters[0], "ref R r4", RefKind.Ref, ScopedKind.None); 24132VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F5").Parameters[0], "in R r5", RefKind.In, ScopedKind.None); 24173VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F3").Parameters[0], "out System.Int32 i3", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 24174VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F4").Parameters[0], "ref R r4", RefKind.Ref, ScopedKind.None); 24175VerifyParameterSymbol(comp.GetMember<MethodSymbol>("A.F5").Parameters[0], "in R r5", RefKind.In, ScopedKind.None); 24214VerifyParameterSymbol(delegateType.DelegateInvokeMethod.Parameters[parameterIndex], $"{expectedDisplayType} arg", expectedRefKind, expectedScope); 24255VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F1").Parameters[0], "out modreq(System.Runtime.InteropServices.OutAttribute) System.Int32", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 24256VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F2").Parameters[0], "R", RefKind.None, ScopedKind.None); 24257VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F3").Parameters[0], "ref R", RefKind.Ref, ScopedKind.None); 24258VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F4").Parameters[0], "in modreq(System.Runtime.InteropServices.InAttribute) R", RefKind.In, ScopedKind.None); 24259VerifyParameterSymbol(getFunctionPointerMethod(comp, "A.F5").Parameters[0], "out modreq(System.Runtime.InteropServices.OutAttribute) R", RefKind.Out, useUpdatedRules ? ScopedKind.ScopedRef : ScopedKind.None); 24317VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F1").Parameters[0], "out System.Int32 i1", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24318VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F2").Parameters[0], "R r2", RefKind.None, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24319VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F3").Parameters[0], "ref R r3", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24320VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F4").Parameters[0], "in R r4", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24321VerifyParameterSymbol(comp.GetMember<MethodSymbol>("Program.F5").Parameters[0], "out R r5", RefKind.Out, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24934VerifyParameterSymbol(typeA.GetMethod("F1").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 24935VerifyParameterSymbol(typeA.GetMethod("F2").Parameters[0], "ref R x", RefKind.Ref, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 24936VerifyParameterSymbol(typeA.GetMethod("F3").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: false); 24937VerifyParameterSymbol(typeA.GetMethod("F4").Parameters[0], "in R x", RefKind.In, ScopedKind.None, expectedHasUnscopedRefAttribute: true); 25675VerifyParameterSymbol(method.Parameters[0], "out System.Int32 i", RefKind.Out, version == 11 ? ScopedKind.ScopedRef : ScopedKind.None); 25714VerifyParameterSymbol(method.Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None); 25753VerifyParameterSymbol(method.Parameters[0], "out System.Int32 i", RefKind.Out, ScopedKind.None); 25803VerifyParameterSymbol(method.Parameters[0], "out T t", RefKind.Out, expectedUseUpdatedEscapeRules ? ScopedKind.ScopedRef : ScopedKind.None); 26039Assert.Equal(ScopedKind.None, type.DelegateInvokeMethod.Parameters.Single().EffectiveScope); 26091Assert.Equal(ScopedKind.None, type.DelegateInvokeMethod.Parameters.Single().EffectiveScope); 26143Assert.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);

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

6020var 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);

1285Assert.Equal("p2", method.Parameters.Single().Name); 1342Assert.Equal("p2", method.Parameters.Single().Name); 1405Assert.Equal("p2", method.Parameters.Single().Name); 1468Assert.Equal("p2", method.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; 804var expectedValueParameter = indexer.SetMethod.Parameters.Last().ISymbol;

2329var foo1Params = foo1.Parameters; 2337var foo2Params = foo2.Parameters; 2339Assert.Same(localC3Foo2.Parameters[0], ((RetargetingParameterSymbol)foo2Params[0]).UnderlyingParameter); 2340Assert.Same(localC3Foo2.Parameters[1], ((RetargetingParameterSymbol)foo2Params[1]).UnderlyingParameter); 2341Assert.Same(localC3Foo2.Parameters[2], ((RetargetingParameterSymbol)foo2Params[2]).UnderlyingParameter); 2342Assert.Same(localC3Foo2.Parameters[3], ((RetargetingParameterSymbol)foo2Params[3]).UnderlyingParameter); 2350Assert.NotEqual(localC3Foo2.Parameters[0].Type, x1.Type); 2351Assert.Equal(localC3Foo2.Parameters[0].ToTestDisplayString(), x1.ToTestDisplayString()); 2360Assert.NotEqual(localC3Foo2.Parameters[1].Type, x2.Type); 2364Assert.Same(localC3Foo2.Parameters[2].Type, x3.Type);

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

44Parameters[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;

2632verifyArray(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); 4039var parameter = method.Parameters[0]; 4045parameter = method.Parameters[0]; 4069var parameter = method.Parameters[0]; 4075parameter = method.Parameters[0];

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)

187CheckParameters(getter.Parameters, expectedParameterTypes); 199CheckParameters(setter.Parameters, expectedParameterTypes.Concat(new[] { expectedType }).ToArray()); 2405Assert.False(indexer.GetMethod.Parameters.IsEmpty); 2407foreach (var p in indexer.GetMethod.Parameters)

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; 330Assert.Equal(2, member1.Parameters.Length); 350Assert.Equal(2, member1.Parameters.Length); 351var p1 = member1.Parameters[0] as ParameterSymbol; 352var p2 = member1.Parameters[1] as ParameterSymbol;

295Assert.Equal(3, member2.Parameters.Length); 297var 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);

117Assert.Equal(@event.Type, accessor.Parameters.Single().Type); 136Assert.NotEqual(mismatchedAddEvent.Type, mismatchedAddEvent.AddMethod.Parameters.Single().Type); 139Assert.NotEqual(mismatchedRemoveEvent.Type, mismatchedRemoveEvent.RemoveMethod.Parameters.Single().Type); 159Assert.Equal(0, noParamAddEvent.AddMethod.Parameters.Length); 162Assert.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; 1077Assert.Equal(property.Type, accessor.Parameters.Last().Type); 1084Assert.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;

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];

389param = test1.Parameters; 394param = test2.Parameters; 420param = test1.Parameters; 425param = test2.Parameters; 451param = test1.Parameters; 459param = test2.Parameters; 503param = test1.Parameters; 516param = test2.Parameters; 538param = test1.Parameters; 545param = test2.Parameters; 568param = test1.Parameters; 575param = test2.Parameters; 601param = test1.Parameters; 690param = test1.Parameters; 695param = test2.Parameters; 721param = test1.Parameters; 726param = test2.Parameters; 752param = test1.Parameters; 760param = test2.Parameters; 804param = test1.Parameters; 817param = test2.Parameters; 839param = test1.Parameters; 846param = test2.Parameters; 869param = test1.Parameters; 876param = test2.Parameters; 902param = test1.Parameters; 994param = test1.Parameters; 999param = test2.Parameters; 1025param = test1.Parameters; 1030param = test2.Parameters; 1056param = test1.Parameters; 1064param = test2.Parameters; 1108param = test1.Parameters; 1121param = test2.Parameters; 1143param = test1.Parameters; 1150param = test2.Parameters; 1173param = test1.Parameters; 1180param = test2.Parameters; 1206param = test1.Parameters; 2052Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2053Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2067Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2068Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2082Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2083Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2097Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2098Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2177Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2178Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2192Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2193Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2207Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2208Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2222Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2223Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2302Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2303Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2317Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2318Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2332Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2333Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2347Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2348Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2414Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2415Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2429Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2430Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2510Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2511Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2525Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2526Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2540Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2541Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2555Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2556Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type);

256ParameterSymbol testParameter = testMethod.Parameters[0];

57ParameterSymbol p1 = m1.Parameters[0]; 58ParameterSymbol p2 = modifiers.GetMembers("F2").OfType<MethodSymbol>().Single().Parameters[0]; 61ParameterSymbol p5 = m5.Parameters[0]; 63ParameterSymbol p6 = modifiers.GetMembers("F6").OfType<MethodSymbol>().Single().Parameters[0]; 202ParameterSymbol p1 = m1.Parameters[0];

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

334if (method.Parameters.Any()) 336CheckCustomModifier(inParameterType, ((ArrayTypeSymbol)method.Parameters.Single().Type).ElementTypeWithAnnotations.CustomModifiers); 337CheckCustomModifier(onParameterType, method.Parameters.Single().TypeWithAnnotations.CustomModifiers); 433Assert.False(class3Method1.Parameters.Single().TypeWithAnnotations.CustomModifiers.Any()); 477var classMethod1CustomModifiers = classMethod1.Parameters.Single().TypeWithAnnotations.CustomModifiers; 532Assert.True(baseM.Parameters.Single().IsParams, "Base.M.IsParams should be true"); 533Assert.False(baseN.Parameters.Single().IsParams, "Base.N.IsParams should be false"); 534Assert.True(derivedM.Parameters.Single().IsParams, "Derived.M.IsParams should be true"); //NB: does not reflect source 535Assert.False(derivedN.Parameters.Single().IsParams, "Derived.N.IsParams should be false"); //NB: does not reflect source 536Assert.True(derived2M.Parameters.Single().IsParams, "Derived2.M.IsParams should be true"); 537Assert.False(derived2N.Parameters.Single().IsParams, "Derived2.N.IsParams should be false"); 1652Assert.Equal(int16Type, baseProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1653Assert.Equal(int16Type, derivedProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1658Assert.Equal(int16Type, baseIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1659Assert.Equal(int16Type, derivedIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1661Assert.Equal(int32Type, baseIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1662Assert.Equal(int32Type, derivedIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1664Assert.Equal(int64Type, baseIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1665Assert.Equal(int64Type, derivedIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1866Assert.Equal(int16Type, interfaceProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1867Assert.Equal(int16Type, implementationProperty.SetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1872Assert.Equal(int16Type, interfaceIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1873Assert.Equal(int16Type, implementationIndexer.GetMethod.Parameters.Single().TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1875Assert.Equal(int32Type, interfaceIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1876Assert.Equal(int32Type, implementationIndexer.SetMethod.Parameters[0].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1878Assert.Equal(int64Type, interfaceIndexer.SetMethod.Parameters[1].TypeWithAnnotations.CustomModifiers.Single().Modifier()); 1879Assert.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; 804Assert.Equal(RefKind.In, d.DelegateInvokeMethod.Parameters[0].RefKind);

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

40var p = m.Parameters[0];

39var x = m.Parameters[0]; 121var x = m.Parameters[0]; 145var x = m.Parameters[0]; 192var element = add.Parameters[0]; 345Assert.Equal(t, m.Parameters[0].Type); 361var p1 = m.Parameters[0]; 362var p2 = m.Parameters[1]; 409var p1 = m.Parameters[0]; 452var p1 = method.Parameters[0]; 453var p2 = method.Parameters[1]; 532var param = mem1.Parameters.First() as ParameterSymbol; 1366var classBMethodMParameters = classBMethodM.Parameters; 1389var classCBaseMethodMParameters = classCBaseMethodM.Parameters; 1636ParameterSymbol pin = mreturn.Parameters.Single(); 2138var substitutedParameter1 = constructedMethod1.Parameters.Single(); 2139var substitutedParameter2 = constructedMethod2.Parameters.Single(); 2163var extensionParameter1 = reducedMethod1.Parameters.Single(); 2164var extensionParameter2 = reducedMethod2.Parameters.Single();

1880Assert.Equal(2, getters.Count(getter => getter.Parameters.Length == 1)); 1881Assert.Equal(1, getters.Count(getter => getter.Parameters.Length == 2)); 1883Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32)); 1884Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_String)); 1886getter.Parameters.Length == 2 && 1887getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32 && 1888getter.Parameters[1].Type.SpecialType == SpecialType.System_String)); 1960Assert.Equal(1, accessor.Parameters.Length); 1961var locs = accessor.Parameters[0].Locations; 1967Assert.Equal(2, accessor.Parameters.Length); 1969locs = 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));

24694Assert.Equal("System.Int32 modopt(I1) value", c2M01Set.Parameters.Single().ToTestDisplayString()); 24734Assert.Equal("System.Int32 modopt(I2) value", c3M01Set.Parameters.Single().ToTestDisplayString()); 27162Assert.Equal("System.Action<System.Int32> value", c1M01Add.Parameters.Single().ToTestDisplayString()); 27173Assert.Equal("System.Action<System.Int32> value", c1M01Remove.Parameters.Single().ToTestDisplayString()); 27239Assert.Equal("System.Action<System.Int32 modopt(I1)> value", c2M01Add.Parameters.Single().ToTestDisplayString()); 27251Assert.Equal("System.Action<System.Int32 modopt(I1)> value", c2M01Remove.Parameters.Single().ToTestDisplayString()); 27273Assert.Equal("System.Action value", c3M02Add.Parameters.Single().ToTestDisplayString()); 27352Assert.Equal("System.Action value", c4M02Add.Parameters.Single().ToTestDisplayString()); 27365Assert.Equal("System.Action value", c4M02Remove.Parameters.Single().ToTestDisplayString());

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

2344var param = mem2.Parameters[0]; 3358var param = mem1.Parameters[0] as ParameterSymbol; 3702Assert.Equal("T t", f.Parameters[0].ToTestDisplayString());

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

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

538Assert.Equal(propertyOrEventType, accessor.Parameters.Single().Type); 555var accessorParameters = accessor.Parameters;

75var parameters = method.Parameters;

57VisitList(method.Parameters);

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