168if (IsTypeOrValueReceiver(enclosingBinder, id, parameter.Type, out SyntaxNode? memberAccessNode, out string? memberName, out int targetMemberArity, out bool invoked)) 171if (TreatAsInstanceMemberAccess(enclosingBinder, parameter.Type, memberAccessNode, memberName, targetMemberArity, invoked, lookupResult))

367Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2312(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2543(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2692parameter.Type.IsRefLikeOrAllowsRefLikeType() && 2911parameter.Type.IsRefLikeOrAllowsRefLikeType(); 2994if (parameter.Type.IsRefLikeOrAllowsRefLikeType() && parameter.RefKind != RefKind.Out && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel) 3054if (parameter.Type.IsRefLikeOrAllowsRefLikeType()) 3722Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4013Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4322Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 4761Debug.Assert(parameter.Type.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions)); 4766if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type)) 4981Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything));

728parameter.Type.TypeKind == TypeKind.Array && 729!((TypeSymbol)reorderedArgument.TypeInternal!).Equals(parameter.Type, TypeCompareKind.AllIgnoreOptions))

361BoundExpression argument = CreateConversion(placeholder, argumentConversion, destination: method.Parameters[0].Type, diagnostics); 461method.Parameters[0].Type,

580method.Parameters[0].Type is ArrayTypeSymbol { IsSZArray: true, ElementType: TypeParameterSymbol }); 590static (readonlySpanType, method) => method.Parameters[0].Type.IsSpan() && 640arg.source.Equals(parameter.Type.OriginalDefinition, TypeCompareKind.ConsiderEverything) && 646((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(typeArgument.Type, TypeCompareKind.ConsiderEverything) && 669Parameters: [{ Type.SpecialType: SpecialType.System_String }] 1061var parameterType = (NamedTypeSymbol)collectionBuilderMethod.Parameters[0].Type; 1494bool thisTypeIsOpen = typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0]); 1507if (!typeParameters.Any((typeParameter, parameter) => parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[1])) 1529TypeSymbol secondArgumentType = (constructed ?? member).Parameters[1].Type; 1556var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1563else if (typeParameters.Any((typeParameter, parameter) => !parameter.Type.ContainsTypeParameter(typeParameter), member.Parameters[0])) 1875if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 1893var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2835(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty())); 2859source: delegateParameter.Type, 2860destination: methodParameter.Type,

689if (ContainsNestedTypeOfUnconstructedGenericType(parameterSymbols[i].Type)) 752if (ContainsNestedTypeOfUnconstructedGenericType(param.Type))

518defaultValueBinder.GenerateConversionForAssignment(parameter.Type, valueBeforeConversion, diagnostics, ConversionForAssignmentFlags.DefaultParameter)); 2142if (IsBadLocalOrParameterCapture(parameter, parameter.Type, parameter.RefKind)) 2150else if (parameter.Type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2152Error(diagnostics, ErrorCode.ERR_SpecialByRefInLambda, node, parameter.Type); 2156Debug.Assert(parameter.Type.IsRefLikeOrAllowsRefLikeType()); 2166(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2173else if (parameter.Type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2175Error(diagnostics, ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefAny, node, parameter.Type); 2179Debug.Assert(parameter.Type.IsRefLikeOrAllowsRefLikeType()); 3588if (parameters[paramsIndex].Type.IsSZArray()) 3798placeholderType = receiverParameter.Type; 3819placeholderType = parameter.Type; 3838placeholderType = parameter.Type; 10378original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10479original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10480original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };

689!candidate.Member.GetParameters().Last().Type.IsSZArray()) 1268receiverParameter.Type, diagnostics); 1381receiver = CreateConversion(receiver, extensionParameter.Type, diagnostics); 1429var parameterType = parameter.Type; 1663TypeSymbol parameterType = parameter.Type; 1782TypeSymbol collectionType = paramsParameter.Type; 1911!(d.Arguments is [ParameterSymbol shadowedParameter] && shadowedParameter.Type.Equals(typeOrValue.Data.ValueExpression.Type, TypeCompareKind.AllIgnoreOptions))) // If the type and the name match, we would resolve to the same type rather than a value at the end. 2236if (parameter.Name == name) return parameter.Type; 2242return (i < parameterList.Length) ? parameterList[i].Type : null;

467BoundExpression rightConverted = CreateConversion(right, overloadResolutionResult.ValidResult.Result.ConversionForArg(isExtension ? 1 : 0), method.Parameters[0].Type, diagnostics); 496leftConversion = CreateConversion(node, leftPlaceholder, conversion, isCast: false, conversionGroupOpt: null, method.ContainingType.ExtensionParameter.Type, diagnostics); 505rightType: method.Parameters[0].Type, 1485var trueFalseParameterType = (resultKind.Operator() == BinaryOperatorKind.And ? falseOperator : trueOperator).Parameters[0].Type; 1602TypeSymbol parameterType = userDefinedOperator.Parameters[0].Type; 3452operandConversion = CreateConversion(node, operandPlaceholder, conversion, isCast: false, conversionGroupOpt: null, method.ContainingType.ExtensionParameter.Type, diagnostics); 3734!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3735(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None)))

2212Error(diagnostics, ErrorFacts.GetStaticClassParameterCode(useWarning: false), anonymousFunction.ParameterLocation(i), delegateParameters[i].Type); 2237var delegateParameterType = delegateParameters[i].Type;

1484CheckWhatCandidatesWeHave(members, parameter.Type, plainName, 1497Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, receiver.Syntax, parameter.Name, parameter.Type, parameter);

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

120else if (parameter.Type.IsPointerOrFunctionPointer() && !isReceiverParameter)

1044builder.CollectionType = builder.GetEnumeratorInfo.Method.Parameters[0].Type; 1048builder.CollectionType = builder.GetEnumeratorInfo.Method.ContainingType.ExtensionParameter.Type; 1569var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1582result.Parameters[0].Type);

211if ((this.Flags & BinderFlags.InEEMethodBinder) != 0 && parameter.Type.IsDisplayClassType())

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

970if (parameter?.Type?.IsRefLikeOrAllowsRefLikeType() != true ||

175if (!IsSymbolAccessibleCore(param.Type, within, throughTypeOpt: null, out failedThroughTypeCheck, compilation, ref useSiteInfo, basesBeingResolved))

350if (thisParameter?.Type.IsReferenceType == false) 357thisParameter.Type); 432if (parameter.Type.IsDynamic()) 473if (!(method.GetIsNewExtensionMember() && method.IsStatic) && !Binder.GetReceiverParameter(method).Type.IsReferenceType)

1525if (!delegateParameters[p].Type.Equals(anonymousFunction.ParameterType(p), TypeCompareKind.AllIgnoreOptions))

1370op1Left = p[0].Type; 1371op1Right = p[1].Type; 1387op2Left = p[0].Type; 1388op2Right = p[1].Type; 1607return SourceUserDefinedOperatorSymbolBase.ExtensionOperatorParameterTypeMatchesExtendedType(method.Parameters[paramIndex].Type, extensionParameter.Type); 1617if (!candidate.Method.ContainingType.ExtensionParameter.Type.IsValidNullableTypeArgument() || 1618!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 1623else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)

233if (!candidate.Method.ContainingType.ExtensionParameter.Type.IsValidNullableTypeArgument() || 234!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 239else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 301result = Hash.Combine(result, typeComparer.GetHashCode(parameter.Type));

1035if (parameter.Type.ContainsTypeParameter(typeParameter)) 2449if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2799if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 3127if (!anonymousFunction.ParameterType(p).Equals(fixedDelegateParameters[p].Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) 3197Debug.Assert(!extension.ExtensionParameter.Type.IsDynamic());

1313if ((final.IsParamsArray && final.Type.IsSZArray()) || 1314(final.IsParamsCollection && !final.Type.IsSZArray() && !disallowExpandedNonArrayParams && 1317return TryInferParamsCollectionIterationType(binder, final.OriginalDefinition.Type, out definitionElementType); 2551TypeSymbol t1 = m1LeastOverriddenParameters[^1].Type; 2552TypeSymbol t2 = m2LeastOverriddenParameters[^1].Type; 2575var type = parameter.Type; 3779if (!Conversions.HasIdentityConversion(param1.Type, param2.Type))

1214TypeSymbol parameterType = unwrapIfParamsCollection(badArg, parameter, isLastParameter) is TypeSymbol t ? t : parameter.Type; 1372parameter.Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true };

460: this(syntax, parameterSymbol, parameterSymbol.Type, hasErrors) 465: this(syntax, parameterSymbol, parameterSymbol.Type)

97if (parameter.Type.IsRefLikeOrAllowsRefLikeType() && parameter.EffectiveScope != ScopedKind.ScopedValue)

385if (parameters[0].Type.SpecialType != SpecialType.System_Object) continue; 386var p1t = parameters[1].Type.SpecialType;

1437var parameterType = parameter.ParameterSymbol.Type; 3340EmitIndirectStore(parameter.ParameterSymbol.Type, parameter.Syntax);

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

578if (!IsCompliantType(parameter.Type, context)) 580this.AddDiagnostic(ErrorCode.WRN_CLS_BadArgType, parameter.GetFirstLocation(), parameter.Type);

184thisReference = new BoundThisReference(syntax, thisSymbol.Type) { WasCompilerGenerated = true }; 280field.IsStatic ? null : new BoundThisReference(syntax, accessor.ThisParameter.Type), 378new BoundThisReference(syntax, thisParameter.Type) { WasCompilerGenerated = true };

87F.Null(text.Type)),

249Visit(symbol.Type, builder);

424var otherType = (TypeSymbol?)Visit(param.Type); 672_comparer.Equals(parameter.Type, other.Type); 940var translatedParamType = (TypeSymbol)Visit(param.Type);

55return ((PEModuleBuilder)context.Module).Translate(AdaptedParameterSymbol.Type, 95type = AdaptedParameterSymbol.Type;

53return ((PEModuleBuilder)context.Module).Translate(_underlyingParameter.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

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

1440&& !TypeIsImmutable(thisParameter.Type)) 3047return param.Type.IsNonNullableValueType();

365if (methodThisParameter.Type.SpecialType.CanOptimizeBehavior()) 483TypeSymbol parameterType = parameter.Type;

3778(p1, p2) => p1.Type.Equals(p2.Type, TypeCompareKind.AllNullableIgnoreOptions | TypeCompareKind.IgnoreTupleNames)) && 11303parameterOpt?.Type.IsNonNullableValueType() == true && parameterType.IsNullableType() ? parameterOpt.Type : parameterType, // Compensate for operator lifting

216parameter.Type.Equals(F.Compilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken), TypeCompareKind.ConsiderEverything))

689type = ((ParameterSymbol)capturedVariable).Type;

247Debug.Assert(thisParameter is null || TypeSymbol.Equals(thisParameter.Type, thisType, TypeCompareKind.ConsiderEverything2)); 602if ((object)_currentFrameThis != null && TypeSymbol.Equals(_currentFrameThis.Type, frameClass, TypeCompareKind.ConsiderEverything2)) 615if (TypeSymbol.Equals(potentialParameter.Type.OriginalDefinition, frameClass, TypeCompareKind.ConsiderEverything2)) 902var frameType = (NamedTypeSymbol)loweredSymbol.Parameters[i].Type.OriginalDefinition;

702var conversionInputType = method.Parameters[0].Type; 709? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 767unquoted = _bound.Call(_bound.MethodInfo(method, createDelegate.ContainingType), createDelegate, _bound.Typeof(delegateType, createDelegate.Parameters[0].Type), receiver); 774_bound.Typeof(delegateType, createDelegate.Parameters[0].Type), 776_bound.MethodInfo(method, createDelegate.Parameters[2].Type)); 847_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name));

625_diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.GetFirstLocation(), p.Type.Name);

370if (parameters.Length == 2 && TypeSymbol.Equals(parameters[0].Type, t, TypeCompareKind.ConsiderEverything2) && TypeSymbol.Equals(parameters[1].Type, t, TypeCompareKind.ConsiderEverything2))

123Debug.Assert(receiverOpt.Type!.Equals(method.Parameters[0].Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));

312var parameterLogger = GetLocalOrParameterStoreLogger(parameter.Type, parameter, refAssignmentSourceIsLocal: null, _factory.Syntax); 320MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)ordinal))))); 428type = parameterSymbol.Type; 455if (parameter.Type.IsVoidPointer() && !targetType.IsPointerOrFunctionPointer()) 458Debug.Assert(!parameter.Type.IsManagedTypeNoUseSiteDiagnostics); 461(BoundExpression)new BoundAddressOfOperator(_factory.Syntax, value, isManaged: false, parameter.Type) : 462_factory.Sequence(new[] { value }, new BoundAddressOfOperator(_factory.Syntax, VariableRead(targetSymbol), isManaged: false, parameter.Type)); 467if (parameter.Type.SpecialType == SpecialType.System_String && targetType.SpecialType != SpecialType.System_String) 487return ImmutableArray.Create(_factory.Convert(parameter.Type, value), index);

186member is MethodSymbol { Parameters: [.., { RefKind: RefKind.None, Type: { } lastParamType }] parametersWithCancellationToken } overload &&

1153Debug.Assert(Conversions.IsValidExtensionMethodThisArgConversion(this._compilation.Conversions.ClassifyConversionFromType(receiver.Type, extensionParameter.Type, isChecked: false, ref discardedUseSiteInfo))); 1157return MakeConversionNode(receiver, extensionParameter.Type, @checked: false, acceptFailingConversion: false, markAsChecked: markAsChecked);

191var outputTemp = new BoundDagTemp(d.Syntax, parameter.Type, d, i - extensionExtra); 247Debug.Assert(e.Property.GetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Int32);

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

253case (not null, not null) when !methodThisParameter.Type.Equals(interceptorThisParameterForCompare.Type, TypeCompareKind.ObliviousNullableModifierMatchesAny) 296Debug.Assert(receiverOpt.Type.Equals(interceptor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions) 297|| (!receiverOpt.Type.IsReferenceType && interceptor.Parameters[0].Type.IsReferenceType)); 298receiverOpt = MakeConversionNode(receiverOpt, interceptor.Parameters[0].Type, @checked: false, markAsChecked: true); 1234Debug.Assert(parameters[i].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }); 1305return ((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol; 1311return methodOrIndexer.ContainingType.ExtensionParameter.Type as NamedTypeSymbol;

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

258return symbol.GetIsNewExtensionMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false };

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

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

282MethodSymbol createSpan = getCreateSpanHelper(node, spanType: getItemOrSliceHelper.ContainingType, intType: (NamedTypeSymbol)getItemOrSliceHelper.Parameters[0].Type);

701(memberSymbol.GetIsNewExtensionMember() && !memberSymbol.IsStatic && ConversionsBase.IsValidExtensionMethodThisArgConversion(_compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType.ExtensionParameter!.Type, isChecked: false, ref discardedUseSiteInfo))) ||

149!parameter.Type.IsRestrictedType(), 230var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type;

145thisParameter.Type.IsReferenceType &&

255var proxyField = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, parameter, isPublic: !PreserveInitialParameterValuesAndThreadId); 260var field = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), parameter, isPublic: true); 444if (method.IsStatic || method.ThisParameter.Type.IsReferenceType)

225return new BoundThisReference(Syntax, CurrentFunction.ThisParameter.Type) { WasCompilerGenerated = true }; 246return new BoundParameter(Syntax, p, p.Type) { WasCompilerGenerated = true }; 1205NamedTypeSymbol baseType = CurrentFunction.ThisParameter.Type.BaseTypeNoUseSiteDiagnostics; 1514if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1516arg = Convert(conversion.Method.Parameters[0].Type, arg);

282TypeSymbol parameterType = parameters[parameterIndex].Type;

1157return parameter.Type;

851return method.ReturnType.ContainsTupleNames() || method.Parameters.Any(static p => p.Type.ContainsTupleNames());

205TypeSymbol.Equals(_removeMethod.Parameters[0].Type, token, TypeCompareKind.ConsiderEverything2);

695&& ContainingAssembly.TypeConversions.HasCallerLineNumberConversion(this.Type, ref discardedUseSiteInfo); 715&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 736&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 759&& ContainingAssembly.TypeConversions.HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 869else if (paramNames.IsDefault || Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true })

363if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || 364(thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && thisParam.Type.TypeKind != TypeKind.Struct))

670Debug.Assert(!param.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: false));

468ITypeSymbolInternal IParameterSymbolInternal.Type => Type;

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 250return _reducedFrom.Parameters[0].Type;

132sourceParameter.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: true) || 134destinationParameter.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: true) || // Could happen if the associated property has custom modifiers. 144builder.Add(destinationParameter.WithCustomModifiersAndParams(sourceParameter.Type,

550extensionParameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters); 559parameter.Type.VisitType(collectTypeParameters, arg: usedTypeParameters); 930TypeSymbol parameterType = parameter.Type;

356new BoundLiteral(parameterSyntax, defaultValue, Type)); 410if (Type.IsNullableType()) 412convertedExpression = binder.GenerateConversionForAssignment(Type.GetNullableUnderlyingType(), 885return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 995if (this.Type.IsReferenceType) 1019else if (!compilation.Conversions.ClassifyConversionFromType((TypeSymbol)arg.TypeInternal, this.Type, isChecked: false, ref useSiteInfo).Kind.IsImplicitConversion()) 1228if (!Type.Equals(this.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken))) 1251if (Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true } handlerType) 1254diagnostics.Add(ErrorCode.ERR_TypeIsNotAnInterpolatedStringHandlerType, arguments.AttributeSyntaxOpt.Location, Type); 1530public sealed override bool IsParamsArray => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && this.Type.IsSZArray(); 1532public sealed override bool IsParamsCollection => (_parameterSyntaxKind & ParameterFlags.ParamsParameter) != 0 && !this.Type.IsSZArray(); 1560if (DeclaredScope == ScopedKind.ScopedValue && !Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 1577var collectionTypeKind = ConversionsBase.GetCollectionExpressionTypeKind(DeclaringCompilation, Type, out TypeWithAnnotations elementTypeWithAnnotations); 1591binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1599if (!binder.HasCollectionExpressionApplicableConstructor(syntax, Type, out MethodSymbol? constructor, isExpanded: out _, diagnostics, isParamsModifierValidation: true)) 1609if (!binder.HasCollectionExpressionApplicableAddMethod(syntax, Type, out ImmutableArray<MethodSymbol> addMethods, diagnostics)) 1618diagnostics.Add(ErrorCode.ERR_ParamsCollectionExtensionAddMethod, syntax, Type); 1649binder.TryGetCollectionIterationType(syntax, Type, out elementTypeWithAnnotations); 1657MethodSymbol? collectionBuilderMethod = binder.GetAndValidateCollectionBuilderMethod(syntax, (NamedTypeSymbol)Type, diagnostics, elementType: out _);

99parameter.Type.CheckAllConstraints(compilation, conversions, parameter.GetFirstLocation(), diagnostics);

120diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.GetFirstLocation(), delegateType, parameterSymbol.Type); 122else if (!delegateTypeIsFile && parameterSymbol.Type.HasFileLocalTypes()) 124diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, delegateType.GetFirstLocation(), parameterSymbol.Type, delegateType);

1423if (this.ExtensionParameter is { Type: NamedTypeSymbol { Name: var extendedTypeName } }) 4472if (!propertyParamType.Equals(methodParam.Type, TypeCompareKind.AllIgnoreOptions)) 4490eventSymbol.Type.Equals(methodParams[0].Type, TypeCompareKind.AllIgnoreOptions); 4823primaryAndCopyCtorAmbiguity = ctor.ParameterCount == 1 && ctor.Parameters[0].Type.Equals(this, TypeCompareKind.AllIgnoreOptions);

1397p.Type.IsRefLikeOrAllowsRefLikeType())) 1407if ((overrideThisParameter is { RefKind: RefKind.Ref or RefKind.Out } && overrideThisParameter.Type.IsRefLikeOrAllowsRefLikeType()) || 1413else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1429else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType()))

377diagnostics.Add(code, GetFirstLocation(), this, parameter.Type); 386diagnostics.Add(code, GetFirstLocation(), this, extensionParameter.Type); 414if (param.Type.HasFileLocalTypes()) 416diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, GetFirstLocation(), param.Type, containingType);

75else if (parameter.Type.IsPointerOrFunctionPointer() && !isExtensionParameter) 80else if (parameter.Type.IsRestrictedType()) 82diagnostics.Add(ErrorCode.ERR_BadSpecialByRefParameter, getLocation(parameter, location, isExtensionParameter), parameter.Type);

1015Debug.Assert(arguments.Attribute.AttributeConstructor.Parameters is [{ Type.SpecialType: SpecialType.System_Int32 }, { Type.SpecialType: SpecialType.System_String }]); 1410checkAndReportManagedTypes(param.Type, param.RefKind, param.GetNonNullSyntaxNode(), isParam: true, diagnostics);

1906if (indexer.Parameters is [{ Type: { } type }] && 1937conversion.Parameters[0].Type.Equals(this, TypeCompareKind.AllIgnoreOptions) &&

1191Conversion conversion = compilation.Conversions.ConvertExtensionMethodThisArg(parameterType: result.ContainingType.ExtensionParameter.Type, receiverType, ref discardedUseSiteInfo, isMethodGroupConversion: false);

237parameter.Type.CheckAllConstraints(compilation, conversions, parameter.GetFirstLocation(), diagnostics);

125newType = CustomModifierUtils.CopyTypeCustomModifiers(newType, this.Type, this.ContainingAssembly); 245else if (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType())

681if (!IsExplicitInterfaceImplementation && !this.IsNoMoreVisibleThan(param.Type, ref useSiteInfo)) 683diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, param.Type); 685else if (param.Type.HasFileLocalTypes() && !containingTypeForFileTypeCheck.HasFileLocalTypes()) 687diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, param.Type, containingTypeForFileTypeCheck); 709!this.IsNoMoreVisibleThan(extensionParameter.Type, ref useSiteInfo)) 711diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, extensionParameter.Type);

1808parameter.Type.CheckAllConstraints(DeclaringCompilation, conversions, parameter.GetFirstLocation(), diagnostics);

81if (this.ContainingType is { IsExtension: true, ExtensionParameter.Type.IsStatic: true }) 385if (ContainingType is { IsExtension: true, ExtensionParameter: { Type.IsStatic: false } extensionParameter } && !IsStatic && 408if (extensionParameter.Type.IsStructType()) 416switch (extensionParameter.Type) 895if (ContainingType is { IsExtension: true, ExtensionParameter.Type: var extendedType })

169return reduced.Parameters[0].Type;

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

59if (parameter.Type.IsErrorType())

125ctor.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

147method.Parameters[0].Type.Equals(containingType, TypeCompareKind.AllIgnoreOptions) &&

73if (!parameter.Type.Equals(type, TypeCompareKind.AllIgnoreOptions))

47candidate.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))

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

355var arguments = Parameters.SelectAsArray((p, s) => (BoundExpression)new BoundParameter(s, p, p.Type), _userMainReturnTypeSyntax);

447if (!TypeSymbol.Equals(_parameters[i].Type, other._parameters[i].Type, compareKind))

388public override bool IsParamsArray => _isParams && Type.IsSZArray(); 390public override bool IsParamsCollection => _isParams && !Type.IsSZArray();

33Debug.Assert(unmatchedValue.Type.SpecialType == SpecialType.System_Object);

244param.Type,

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; 745VerifyFunctionPointerSymbol(param.Type, CallingConvention.Default, 5611CommonVerifyFunctionPointer((FunctionPointerTypeSymbol)param.Type); 5612Assert.Equal("delegate*<dynamic modopt(System.Object), ref readonly modreq(System.Runtime.InteropServices.InAttribute) modopt(System.Object) dynamic modopt(System.Object)>", param.Type.ToTestDisplayString()); 5722CommonVerifyFunctionPointer((FunctionPointerTypeSymbol)param.Type); 5723Assert.Equal(expectedType, param.Type.ToTestDisplayString()); 6307Assert.True(baseM1.Parameters.Single().Type.Equals(derivedM1.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 6309Assert.True(baseM3.Parameters.Single().Type.Equals(derivedM3.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 7060var funcPtr = (FunctionPointerTypeSymbol)m1.Parameters.Single().Type; 7062verifyArray(funcPtr.Signature.Parameters.Single().Type); 7066verifyArray(funcPtr.Signature.Parameters.Single().Type); 7068funcPtr = (FunctionPointerTypeSymbol)m3.Parameters.Single().Type;

4623var m2Tuple = (NamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("M2").Parameters[0].Type;

447var parameter1Type = parameter1.Type; 451Assert.Same(module.GetCorLibType(SpecialType.System_Boolean), m2.Parameters.Single().Type); 452Assert.Same(module.GetCorLibType(SpecialType.System_Char), m3.Parameters.Single().Type); 454var method4ParamTypes = m4.Parameters.Select(p => p.Type).ToArray(); 472Assert.Same(m5.TypeParameters[0], m5.Parameters[0].Type); 473Assert.Same(m5.TypeParameters[1], m5.Parameters[1].Type); 2080Assert.Equal(invoke.Parameters[i].Type, beginInvoke.Parameters[i].Type); 2083Assert.Equal("System.AsyncCallback", beginInvoke.Parameters[invoke.Parameters.Length].Type.ToTestDisplayString()); 2084Assert.Equal("System.Object", beginInvoke.Parameters[invoke.Parameters.Length + 1].Type.ToTestDisplayString()); 2099Assert.Equal("System.IAsyncResult", endInvoke.Parameters[k++].Type.ToTestDisplayString());

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

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

354Assert.Equal(SpecialType.System_Object, sender.Type.SpecialType);

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

920var ptr = (FunctionPointerTypeSymbol)p.Type; 1251var ptr = (FunctionPointerTypeSymbol)p.Type; 1443var p = ((FunctionPointerTypeSymbol)f.Type).Signature.Parameters.Single(); 1500var ptr = (FunctionPointerTypeSymbol)p.Type;

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

4386Assert.True(extensions[0].ExtensionParameter.Type.IsNativeIntegerType); 4387Assert.True(extensions[1].ExtensionParameter.Type.IsNativeIntegerType);

23153var tupleElements = extension.ExtensionParameter.Type.TupleElementTypesWithAnnotations; 23268var typeArguments = ((NamedTypeSymbol)extension.ExtensionParameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics;

412Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 416Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 483Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 487Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 530Assert.Equal("C", x.Type.ToTestDisplayString()); 596Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 600Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 682Assert.Equal(SpecialType.System_Int32, a.Type.SpecialType); 686Assert.Equal(SpecialType.System_String, b.Type.SpecialType); 718Assert.Equal(SpecialType.System_Int32, p1.Type.SpecialType); 724Assert.Equal(SpecialType.System_String, p2.Type.SpecialType); 730Assert.Equal(SpecialType.System_Int32, p2.Type.SpecialType); 741Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything)); 774Assert.Equal(SpecialType.System_Int32, p1.Type.SpecialType); 779Assert.Equal(SpecialType.System_String, p2.Type.SpecialType);

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

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

3286Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3291Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3378Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3384Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType());

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;

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

9055typeArg = ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single(); 11455Assert.True(m1.Parameters[0].Type.IsNullableType()); 11456Assert.True(m1.Parameters[0].Type.IsValueType); 11457Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11506Assert.True(m1.Parameters[0].Type.IsNullableType()); 11507Assert.False(m1.Parameters[0].Type.IsReferenceType); 11569Assert.True(m1.Parameters[0].Type.IsNullableType()); 11570Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11573Assert.False(m2.Parameters[0].Type.IsNullableType()); 11574Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11577Assert.True(m3.Parameters[0].Type.IsNullableType()); 11578Assert.True(m3.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11628Assert.True(m1.Parameters[0].Type.IsNullableType()); 11629Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11633Assert.True(m2.Parameters[0].Type.IsNullableType()); 11634Assert.True(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11702Assert.True(((NamedTypeSymbol)m3.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11703Assert.True(((NamedTypeSymbol)m3.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11704Assert.True(((NamedTypeSymbol)m4.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11705Assert.True(((NamedTypeSymbol)m4.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11706Assert.True(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 11733Assert.True(m1.Parameters[0].Type.IsNullableType()); 11734Assert.True(m1.Parameters[0].Type.StrippedType().IsValueType); 11768Assert.True(m1.Parameters[0].Type.IsNullableType()); 11769Assert.False(m1.Parameters[0].Type.StrippedType().IsValueType); 11770Assert.False(m1.Parameters[0].Type.StrippedType().IsReferenceType); 11852Assert.True(m1.Parameters[0].Type.IsNullableType()); 11853Assert.True(m2.Parameters[0].Type.IsNullableType()); 11854Assert.True(m3.Parameters[0].Type.IsNullableType()); 11855Assert.True(m4.Parameters[0].Type.IsNullableType()); 11893Assert.True(m1.Parameters[0].Type.IsNullableType()); 12099Assert.False(m1.Parameters[0].Type.IsNullableType()); 12101Assert.True(m1.Parameters[0].Type.IsReferenceType); 12102Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 12105Assert.False(m4.Parameters[0].Type.IsNullableType()); 12109Assert.False(m5.Parameters[0].Type.IsNullableType()); 12258Assert.True(b.GetMember<MethodSymbol>("M1").Parameters[0].Type.IsNullableType()); 12259Assert.True(b.GetMember<MethodSymbol>("M2").Parameters[0].Type.IsNullableType()); 12260Assert.False(b.GetMember<MethodSymbol>("M3").Parameters[0].Type.IsNullableType()); 12261Assert.True(b.GetMember<MethodSymbol>("M4").Parameters[0].Type.IsNullableType()); 12262Assert.True(b.GetMember<MethodSymbol>("M5").Parameters[0].Type.IsNullableType()); 13898Assert.False(m1.Parameters[0].Type.IsNullableType()); 13900Assert.True(m1.Parameters[0].Type.IsReferenceType); 13901Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 13969Assert.True(((NamedTypeSymbol)m3.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13970Assert.True(((NamedTypeSymbol)m3.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13971Assert.True(((NamedTypeSymbol)m4.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13972Assert.True(((NamedTypeSymbol)m4.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13973Assert.False(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13974Assert.False(((NamedTypeSymbol)m5.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 14229Assert.False(m1.Parameters[0].Type.IsNullableType()); 14230Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14234Assert.False(m2.Parameters[0].Type.IsNullableType()); 14235Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14285Assert.True(m1.Parameters[0].Type.IsNullableType()); 14286Assert.True(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14290Assert.True(m2.Parameters[0].Type.IsNullableType()); 14291Assert.True(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 139463Assert.False(dGoo.Parameters[0].Type.IsNullableType()); 139491Assert.True(c2Goo.Parameters[0].Type.IsReferenceType); 139519Assert.True(((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementType.IsReferenceType); 139520Assert.Equal(NullableAnnotation.Annotated, ((ArrayTypeSymbol)c2Goo.Parameters[0].Type).ElementTypeWithAnnotations.NullableAnnotation); 139547Assert.True(c2Goo.Parameters[0].Type.IsNullableType()); 139548var tuple = c2Goo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 139662Assert.True(dGoo.Parameters[0].Type.IsReferenceType); 139685Assert.True(((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementType.IsReferenceType); 139686Assert.Equal(NullableAnnotation.Annotated, ((ArrayTypeSymbol)dGoo.Parameters[0].Type).ElementTypeWithAnnotations.NullableAnnotation); 139708Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 139709var tuple = dGoo.Parameters[0].Type.GetMemberTypeArgumentsNoUseSiteDiagnostics()[0]; 139813Assert.True(dGoo.Parameters[0].Type.IsNullableType()); 139815var tuple = dGoo.Parameters[1].Type;

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

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

1270Single(m => m.Parameters.Single().Type.SpecialType == SpecialType.System_Int32); 1602.Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1611Assert.Equal(typeArgument, actualSymbol.GetParameters().Single().Type); 1636var expectedOriginalParameterTypes = expectedOriginalDefinitionSymbol.Parameters.Select(p => p.Type).Cast<TypeParameterSymbol>(); 1637var actualParameterTypes = actualSymbol.GetParameters().Select(p => p.Type).Cast<TypeParameterSymbol>(); 1669var actualParameterType = actualWinner.GetParameters().Single().Type; 1707var actualParameterType = actualWinner.GetParameters().Single().Type; 1735Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter); 1761Single(method => method.Parameters.Single().Type.TypeKind == TypeKind.TypeParameter);

2351Assert.NotEqual(localC3Foo2.Parameters[0].Type, x1.Type); 2358Assert.Equal(2, ((ArrayTypeSymbol)x1.Type).Rank); 2361Assert.NotEqual(localC3Foo2.Parameters[1].Type, x2.Type); 2365Assert.Same(localC3Foo2.Parameters[2].Type, x3.Type);

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

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

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

43Assert.Equal(SpecialType.System_Object, parameter.Type.SpecialType); 49Assert.Equal(SpecialType.System_Object, parameter.Type.SpecialType); 55Assert.Equal(TypeKind.TypeParameter, parameter.Type.TypeKind); 2597Assert.Equal(SpecialType.System_Object, method.Parameters.Single().Type.SpecialType); 4034Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType); 4040Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType); 4064Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType); 4070Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType);

43var pointerType = (FunctionPointerTypeSymbol)m.Parameters.Single().Type; 173=> Assert.Equal(expected, ((FunctionPointerTypeSymbol)actual.Type).Signature.RefKind); 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; 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; 445var type = ((FunctionPointerTypeSymbol)parameterTypes[index].Type); 515var type = ((FunctionPointerTypeSymbol)parameterTypes[index].Type); 657var type = ((FunctionPointerTypeSymbol)parameterTypes[index].Type); 679var signature = ((FunctionPointerTypeSymbol)m.Parameters.Single().Type).Signature; 680Assert.True(signature.Parameters.Single().Type.IsVoidType()); 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, 1063Assert.False(param1.Type.Equals(param2.Type, TypeCompareKind.ConsiderEverything)); 1067Assert.True(param1.Type.Equals(param2.Type, TypeCompareKind.ConsiderEverything)); 1070Assert.True(param1.Type.Equals(param2.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds));

219Assert.Equal(parameter.Type.SpecialType, expectedTypes[i]);

266Assert.Equal("String", p2.Type.Name); 269Assert.Equal("System.Byte[]", p3.Type.ToTestDisplayString()); //array types do not have names - use ToTestDisplayString 285Assert.Equal("IntPtr", p5.Type.Name);

298var type3 = (member2.Parameters[2] as ParameterSymbol).Type as ArrayTypeSymbol;

88ArrayTypeSymbol p5Type = (ArrayTypeSymbol)p5.Type; 100PointerTypeSymbol p6Type = (PointerTypeSymbol)p6.Type;

116Assert.Equal(@event.Type, accessor.Parameters.Single().Type); 135Assert.NotEqual(mismatchedAddEvent.Type, mismatchedAddEvent.AddMethod.Parameters.Single().Type); 138Assert.NotEqual(mismatchedRemoveEvent.Type, mismatchedRemoveEvent.RemoveMethod.Parameters.Single().Type);

717Assert.NotEqual(parameterTypesIndexer.Parameters.Last().Type, parameterTypesIndexer.GetMethod.Parameters.Last().Type); 1087Assert.Equal(property.Type, accessor.Parameters.Last().Type); 1094Assert.Equal(property.Parameters[i].Type, accessor.Parameters[i].Type);

82Assert.Same(varI1, param[0].Type); 83Assert.Same(varI2, param[1].Type); 87Assert.Same(varS1, param[0].Type); 88Assert.Same(varS2, param[1].Type); 113Assert.Same(varI1, param[0].Type); 114Assert.Same(varI2, param[1].Type); 118Assert.Same(varS1, param[0].Type); 119Assert.Same(varS2, param[1].Type); 146Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 147Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 156Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 157missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 164Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 165Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 200Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 201missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 208Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 209Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 213Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 214Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 215Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 216Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 237Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 238Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 239Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 240Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 244Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 245Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 246Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 247Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 268Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 269Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 270Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 271Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 275Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 276Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 277Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 278Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 304Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 305ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 311Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 312Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 423Assert.Same(varI1, param[0].Type); 424Assert.Same(varI2, param[1].Type); 428Assert.Same(varS1, param[0].Type); 429Assert.Same(varS2, param[1].Type); 454Assert.Same(varI1, param[0].Type); 455Assert.Same(varI2, param[1].Type); 459Assert.Same(varS1, param[0].Type); 460Assert.Same(varS2, param[1].Type); 486Assert.Same(varI1, param[0].Type); 487Assert.Same(varI2, param[1].Type); 491Assert.Same(varS1, param[0].Type); 492Assert.Same(varS2, param[1].Type); 528Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 529missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 537Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 538Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 542Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 543missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 550Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 551Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 571Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 572Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 573Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 574Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 578Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 579Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 580Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 581Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 602Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 603Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 604Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 605Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 606Assert.Same(pia4_7.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 607Assert.Same(pia4_7, param[1].Type.ContainingAssembly); 608Assert.Equal("NS1.I2", param[1].Type.ToTestDisplayString()); 612Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 613Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 614Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 615Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 640Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 641ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 646Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 647Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type);

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()); 184Assert.Equal(SymbolKind.ErrorType, importedProperty.Parameters.Single(arg => arg.Name == "x").Type.Kind); 185Assert.IsType<NoPiaIllegalGenericInstantiationSymbol>(importedProperty.Parameters.Single(arg => arg.Name == "x").Type); 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); 446Assert.True(m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.IsFromCompilation(localConsumer));

45Assert.Same(canonicalType1, param.Where(arg => arg.Type.Name == "I1").Select(arg => arg).Single().Type); 46Assert.Same(canonicalType2, param.Where(arg => arg.Type.Name == "I2").Select(arg => arg).Single().Type); 102Assert.Equal(SymbolKind.NamedType, methodSymbol.Parameters.Single(arg => arg.Name == "arg").Type.Kind); 141NoPiaMissingCanonicalTypeSymbol missing = (NoPiaMissingCanonicalTypeSymbol)param.First().Type; 149Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 203Assert.Same(canonicalTypeInter, param.First().Type); 204Assert.IsAssignableFrom<PENamedTypeSymbol>(param.First().Type); 372NoPiaAmbiguousCanonicalTypeSymbol ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param.First().Type; 374Assert.Equal(SymbolKind.ErrorType, param.First().Type.Kind); 375Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param.First().Type);

392Assert.Same(varI1, param[0].Type); 393Assert.Same(varI2, param[1].Type); 397Assert.Same(varS1, param[0].Type); 398Assert.Same(varS2, param[1].Type); 423Assert.Same(varI1, param[0].Type); 424Assert.Same(varI2, param[1].Type); 428Assert.Same(varS1, param[0].Type); 429Assert.Same(varS2, param[1].Type); 454Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 455Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 464Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 465missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 472Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 473Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 506Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 507missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 514Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 515Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 519Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 520Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 521Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 522Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 541Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 542Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 543Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 544Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 548Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 549Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 550Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 551Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 571Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 572Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 573Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 574Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 578Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 579Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 580Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 581Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 606Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 607ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 612Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 613Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 693Assert.Same(varI1, param[0].Type); 694Assert.Same(varI2, param[1].Type); 698Assert.Same(varS1, param[0].Type); 699Assert.Same(varS2, param[1].Type); 724Assert.Same(varI1, param[0].Type); 725Assert.Same(varI2, param[1].Type); 729Assert.Same(varS1, param[0].Type); 730Assert.Same(varS2, param[1].Type); 755Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 756Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 765Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 766missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 773Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 774Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 807Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 808missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 815Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 816Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 820Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 821Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 822Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 823Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 842Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 843Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 844Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 845Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 849Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 850Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 851Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 852Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 872Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 873Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 874Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 875Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 879Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 880Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 881Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 882Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 907Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 908ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 913Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 914Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 997Assert.Same(varI1, param[0].Type); 998Assert.Same(varI2, param[1].Type); 1002Assert.Same(varS1, param[0].Type); 1003Assert.Same(varS2, param[1].Type); 1028Assert.Same(varI1, param[0].Type); 1029Assert.Same(varI2, param[1].Type); 1033Assert.Same(varS1, param[0].Type); 1034Assert.Same(varS2, param[1].Type); 1059Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 1060Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 1069Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1070missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 1077Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1078Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1111Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1112missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 1119Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1120Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1124Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1125Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1126Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1127Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1146Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1147Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1148Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1149Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1153Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1154Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1155Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1156Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1176Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 1177Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 1178Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 1179Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 1183Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1184Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1185Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1186Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1211Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1212ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 1217Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1218Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 2053Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2054Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2068Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2069Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2083Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2084Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2098Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2099Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2178Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2179Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2193Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2194Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2208Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2209Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2223Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2224Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2303Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2304Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2318Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2319Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2333Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2334Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2348Assert.Equal("LocalTypes2", test2.Parameters[0].Type.ContainingAssembly.Name); 2349Assert.Equal("LocalTypes2", test2.Parameters[1].Type.ContainingAssembly.Name); 2415Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2416Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2430Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2431Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2511Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2512Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2526Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2527Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2541Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2542Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type); 2556Assert.Equal("Pia", test2.Parameters[0].Type.ContainingAssembly.Name); 2557Assert.IsType<UnsupportedMetadataTypeSymbol>(test2.Parameters[1].Type);

97ArrayTypeSymbol p5Type = (ArrayTypeSymbol)p5.Type; 110PointerTypeSymbol p6Type = (PointerTypeSymbol)p6.Type; 210PointerTypeSymbol p1Type = (PointerTypeSymbol)p1.Type;

885param1Original.Type, 886param1Retargeted.Type); 895param2Original.Type, 896param2Retargeted.Type);

455CheckCustomModifier(inParameterType, ((ArrayTypeSymbol)method.Parameters.Single().Type).ElementTypeWithAnnotations.CustomModifiers); 2130var paramType = s.GetParameters().Single().Type;

115Assert.Equal(comp.GetSpecialType(SpecialType.System_Object), ctor.Parameters[0].Type); 116Assert.Equal(comp.GetSpecialType(SpecialType.System_IntPtr), ctor.Parameters[1].Type); 166Assert.Equal(invoke.Parameters[i].Type, beginInvoke.Parameters[i].Type); 169var lastParameterType = beginInvoke.Parameters[invoke.Parameters.Length].Type; 172Assert.Equal("System.Object", beginInvoke.Parameters[invoke.Parameters.Length + 1].Type.ToTestDisplayString()); 181Assert.Equal(invoke.Parameters[i].Type, endInvoke.Parameters[k].Type); 185lastParameterType = endInvoke.Parameters[k++].Type; 214Assert.Equal(d.DelegateInvokeMethod.Parameters[0].Type, q);

274Assert.Equal(SpecialType.System_Int32, i.Type.SpecialType); 277Assert.Equal(SpecialType.System_Int32, i.Type.SpecialType);

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

42Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 43Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 124Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 125Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 148Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 149Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 194var t2 = element.Type; 346Assert.Equal(t, m.Parameters[0].Type); 367var refP = p1.Type; 375var outP = p2.Type; 1369Assert.Equal(classBTypeArguments[0], classBMethodMParameters[0].Type); 1370Assert.Equal(classBTypeArguments[1], classBMethodMParameters[1].Type); 1371Assert.Equal(classBMethodMTypeParameters[0], classBMethodMParameters[2].Type); 1392Assert.Equal(classCBaseTypeArguments[0], classCBaseMethodMParameters[0].Type); 1393Assert.Equal(classCBaseTypeArguments[1], classCBaseMethodMParameters[1].Type); 1394Assert.Equal(classCBaseMethodMTypeParameters[0], classCBaseMethodMParameters[2].Type);

1884Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32)); 1885Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_String)); 1888getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32 && 1889getter.Parameters[1].Type.SpecialType == SpecialType.System_String));

36Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 40Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 56Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 60Assert.Equal(c.TypeParameters[0], t.Type); 88Assert.Equal(SpecialType.System_Int32, a.Type.SpecialType); 92Assert.Equal(SpecialType.System_String, b.Type.SpecialType); 121Assert.Equal(SpecialType.System_Int32, p1.Type.SpecialType); 127Assert.Equal(SpecialType.System_String, p2.Type.SpecialType); 133Assert.Equal(SpecialType.System_Int32, p2.Type.SpecialType); 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));

2349Assert.Equal("Goo", param.Type.Name); 2350Assert.Equal(TypeKind.Error, param.Type.TypeKind);

519Assert.Equal(TypeKind.Array, p3.Type.TypeKind); 1544memType = paras[0].Type; 1546memType = paras[1].Type; 1560memType = paras[0].Type; 1562memType = paras[1].Type; 1578memType = paras[0].Type; 1580memType = paras[1].Type; 1624memType = paras[0].Type; 1626memType = paras[1].Type; 1640Assert.Same(topType, paras[0].Type.GetNullableUnderlyingType()); 1648memType = paras[0].Type; 1650memType = paras[1].Type;

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

578Assert.Equal(propertyOrEventType, accessor.Parameters.Single().Type); 601Assert.Equal(propertyParam.Type, accessorParam.Type); 609Assert.Equal(propertyOrEventType, valueParameter.Type);

306argumentVerifiers[i].TypeVerifier(parameter.Type);

375AppendSignatureType(result, parameter.Type, parameter.RefKind);

54var pt = ((PEParameterSymbol)(func.Parameters[0])).Type as PENamedTypeSymbol;