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

53Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeType); 1863|| (param is null or { RefKind: not RefKind.None, Type.IsRefLikeType: true } && isArgumentRefEscape == isRefEscape)) 2025|| (param is null or { RefKind: not RefKind.None, Type.IsRefLikeType: true } && isArgumentRefEscape == isRefEscape)) 2150parameter.Type.IsRefLikeType && 2334if (parameter.Type.IsRefLikeType && parameter.RefKind != RefKind.Out && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel) 2639if (parameters[paramIndex] is not { IsParams: true, Type.TypeKind: TypeKind.Array }) 2971Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 3225Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 3496Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything)); 3903Debug.Assert(thisParam.Type.Equals(((BoundThisReference)expr).Type, TypeCompareKind.ConsiderEverything));

707if (parameter.IsParams && parameter.Type.IsSZArray()) 730parameter.Type.TypeKind == TypeKind.Array && 731!((TypeSymbol)reorderedArgument.TypeInternal!).Equals(parameter.Type, TypeCompareKind.AllIgnoreOptions)) 748reorderedArguments[^1] = new TypedConstant(paramArray.Type, ImmutableArray<TypedConstant>.Empty); 779return new TypedConstant(parameter.Type, ImmutableArray.Create(constructorArgsArray[currentArgumentIndex])); 788return new TypedConstant(parameter.Type, ImmutableArray<TypedConstant>.Empty); 811return new TypedConstant(parameter.Type, values.AsImmutableOrNull()); 826Conversion conversion = conversions.ClassifyBuiltInConversion((TypeSymbol)argument.TypeInternal, parameter.Type, isChecked: false, ref discardedUseSiteInfo);

843if (lambdaParameter.IsParams && !delegateParameter.IsParams && p == lambdaSymbol.ParameterCount - 1 && lambdaParameter.Type.IsSZArray()) 1307(Conversions.ConvertExtensionMethodThisArg(methodParameters[0].Type, receiverOpt!.Type, ref useSiteInfo).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty())); 1328if (!hasConversion(delegateType.TypeKind, Conversions, delegateParameter.Type, methodParameter.Type, delegateParameter.RefKind, methodParameter.RefKind, ref useSiteInfo))

506if (ContainsNestedTypeOfUnconstructedGenericType(parameterSymbols[i].Type)) 569if (ContainsNestedTypeOfUnconstructedGenericType(param.Type))

492defaultValueBinder.GenerateConversionForAssignment(parameter.Type, valueBeforeConversion, diagnostics, ConversionForAssignmentFlags.DefaultParameter)); 1931if (IsBadLocalOrParameterCapture(parameter, parameter.Type, parameter.RefKind)) 1934Error(diagnostics, parameter.Type.IsRefLikeType ? ErrorCode.ERR_AnonDelegateCantUseRefLike : ErrorCode.ERR_AnonDelegateCantUse, node, parameter.Name); 1942(parameter.RefKind != RefKind.None || parameter.Type.IsRefLikeType) && 1945Error(diagnostics, parameter.Type.IsRefLikeType ? ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRefLike : ErrorCode.ERR_UnsupportedPrimaryConstructorParameterCapturingRef, node, parameter.Name); 8675original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 8732original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 8733original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 9202var hasParamsArray = parameters is [.., { IsParams: true } p] && p.Type.IsSZArray();

860Debug.Assert(interpolatedStringParameter is { Type: NamedTypeSymbol { IsInterpolatedStringHandlerType: true } } 865Type: ArrayTypeSymbol { ElementType: NamedTypeSymbol { IsInterpolatedStringHandlerType: true } }, 874diagnostics.Add(ErrorCode.ERR_InterpolatedStringHandlerArgumentAttributeMalformed, unconvertedString.Syntax.Location, interpolatedStringParameter, interpolatedStringParameter.Type); 882interpolatedStringParameter.Type, 897interpolatedStringParameter.IsParams ? ((ArrayTypeSymbol)interpolatedStringParameter.Type).ElementType : interpolatedStringParameter.Type, 982placeholderType = parameter.Type; 1001placeholderType = parameter.Type; 1043(NamedTypeSymbol)interpolatedStringParameter.Type, 1056interpolatedStringParameter.Type,

1051receiverParameter.Type, diagnostics); 1166var parameterType = parameter.Type; 1348TypeSymbol parameterType = parameter.Type; 1812if (parameter.Name == name) return parameter.Type; 1818return (i < parameterList.Length) ? parameterList[i].Type : null;

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

1427CheckWhatCandidatesWeHave(members, parameter.Type, plainName, 1439Error(diagnostics, ErrorCode.ERR_AmbiguousPrimaryConstructorParameterAsColorColorReceiver, colorColorValueReceiver.Syntax, parameter.Name, parameter.Type, parameter); 1529var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo);

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

116else if (parameter.Type.IsUnsafe())

851? builder.GetEnumeratorInfo.Method.Parameters[0].Type 1320var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1333result.Parameters[0].Type);

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

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

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

233if (!thisParameter.Type.IsReferenceType) 240thisParameter.Type); 315if (parameter.Type.IsDynamic()) 353if (methodGroup.IsExtensionMethodGroup && !method.Parameters[0].Type.IsReferenceType)

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

1296op1Left = p[0].Type; 1297op1Right = p[1].Type; 1313op2Left = p[0].Type; 1314op2Right = p[1].Type;

918if (parameter.Type.ContainsTypeParameter(typeParameter)) 2227if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2577if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2920if (!anonymousFunction.ParameterType(p).Equals(fixedDelegateParameters[p].Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes))

1040return final.IsParams && ((ParameterSymbol)final.OriginalDefinition).Type.IsSZArray(); 1647var type = parameter.Type; 3022if (!Conversions.HasIdentityConversion(param1.Type, param2.Type))

1177TypeSymbol parameterType = UnwrapIfParamsArray(parameter, isLastParameter) is TypeSymbol t ? t : parameter.Type; 1308ArrayTypeSymbol arrayType = parameter.Type as ArrayTypeSymbol;

474: this(syntax, parameterSymbol, parameterSymbol.Type, hasErrors) 479: this(syntax, parameterSymbol, parameterSymbol.Type)

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

1386var parameterType = parameter.ParameterSymbol.Type; 3083EmitIndirectStore(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));

571if (!IsCompliantType(parameter.Type, context)) 573this.AddDiagnostic(ErrorCode.WRN_CLS_BadArgType, parameter.Locations[0], parameter.Type);

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

87F.Null(text.Type)),

245Visit(symbol.Type, builder);

622var otherType = (TypeSymbol?)Visit(param.Type); 862_comparer.Equals(parameter.Type, other.Type); 1126var translatedParamType = (TypeSymbol)Visit(param.Type);

52return ((PEModuleBuilder)context.Module).Translate(AdaptedParameterSymbol.Type, 92type = AdaptedParameterSymbol.Type;

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

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

1353&& !TypeIsImmutable(thisParameter.Type)) 2823return param.Type.IsNonNullableValueType();

365if (methodThisParameter.Type.SpecialType != SpecialType.None) 475foreach (var field in _emptyStructTypeCache.GetStructInstanceFields(parameter.Type))

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

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

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

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

632var conversionInputType = method.Parameters[0].Type; 639? Convert(Visit(node.Operand), node.Operand.Type, method.Parameters[0].Type, node.Checked, false) 768_bound.Typeof(_typeMap.SubstituteType(p.Type).Type), _bound.Literal(p.Name));

538_diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.Locations[0], p.Type.Name);

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

307var parameterLogger = GetLocalOrParameterStoreLogger(parameter.Type, parameter, refAssignmentSourceIsLocal: null, _factory.Syntax); 311MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)parameter.Ordinal))))); 426type = parameterSymbol.Type; 452if (parameter.Type.IsVoidPointer() && !targetType.IsPointerOrFunctionPointer()) 455Debug.Assert(!parameter.Type.IsManagedTypeNoUseSiteDiagnostics); 458(BoundExpression)new BoundAddressOfOperator(_factory.Syntax, value, isManaged: false, parameter.Type) : 459_factory.Sequence(new[] { value }, new BoundAddressOfOperator(_factory.Syntax, VariableRead(targetSymbol), isManaged: false, parameter.Type)); 464if (parameter.Type.SpecialType == SpecialType.System_String && targetType.SpecialType != SpecialType.System_String) 484return ImmutableArray.Create(_factory.Convert(parameter.Type, value), index);

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

911Debug.Assert(parameters[i].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }); 1030((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol : 1188argument = CreateParamArrayArgument(syntax, parameter.Type, paramArray.ToImmutableAndFree(), compilation, localRewriter: null); 1201BoundExpression argument = CreateParamArrayArgument(syntax, lastParam.Type, ImmutableArray<BoundExpression>.Empty, compilation, localRewriter: null); 1274var paramArrayType = parameters[paramsParam].Type;

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

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

140thisParameter.Type.IsReferenceType &&

251var proxyField = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, isPublic: !PreserveInitialParameterValuesAndThreadId); 256var field = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), isPublic: true); 430if (method.IsStatic || method.ThisParameter.Type.IsReferenceType)

264return new BoundThisReference(Syntax, CurrentFunction.ThisParameter.Type) { WasCompilerGenerated = true }; 285return new BoundParameter(Syntax, p, p.Type) { WasCompilerGenerated = true }; 1124NamedTypeSymbol baseType = CurrentFunction.ThisParameter.Type.BaseTypeNoUseSiteDiagnostics; 1372if (conversion.Method is { } && !TypeSymbol.Equals(conversion.Method.Parameters[0].Type, arg.Type, TypeCompareKind.ConsiderEverything2)) 1374arg = Convert(conversion.Method.Parameters[0].Type, arg);

2805Debug.Assert(!patternDisposeInfo.Expanded || patternDisposeInfo.Method.GetParameters().Last().OriginalDefinition.Type.IsSZArray());

248TypeSymbol parameterType = parameters[parameterIndex].Type;

1115return parameter.Type;

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

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

676&& new TypeConversions(ContainingAssembly).HasCallerLineNumberConversion(this.Type, ref discardedUseSiteInfo); 696&& new TypeConversions(ContainingAssembly).HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 717&& new TypeConversions(ContainingAssembly).HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 740&& new TypeConversions(ContainingAssembly).HasCallerInfoStringConversion(this.Type, ref discardedUseSiteInfo); 850else if (paramNames.IsDefault || Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true })

366if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || 367(thisParam.RefKind == RefKind.In && thisParam.Type.TypeKind != TypeKind.Struct))

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

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo); 242return _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,

708TypeSymbol parameterType = parameter.Type;

342new BoundLiteral(parameterSyntax, defaultValue, Type)); 973if (this.Type.IsReferenceType) 997else if (!compilation.Conversions.ClassifyConversionFromType((TypeSymbol)arg.TypeInternal, this.Type, isChecked: false, ref useSiteInfo).Kind.IsImplicitConversion()) 1213if (!Type.Equals(this.DeclaringCompilation.GetWellKnownType(WellKnownType.System_Threading_CancellationToken))) 1238if (Type is not NamedTypeSymbol { IsInterpolatedStringHandlerType: true } handlerType) 1241diagnostics.Add(ErrorCode.ERR_TypeIsNotAnInterpolatedStringHandlerType, errorLocation, Type);

99parameter.Type.CheckAllConstraints(compilation, conversions, parameter.Locations[0], diagnostics);

116diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.Locations[0], delegateType, parameterSymbol.Type); 118else if (!delegateTypeIsFile && parameterSymbol.Type.HasFileLocalTypes()) 120diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, delegateType.Locations[0], parameterSymbol.Type, delegateType);

3689if (!propertyParamType.Equals(methodParam.Type, TypeCompareKind.AllIgnoreOptions)) 3707eventSymbol.Type.Equals(methodParams[0].Type, TypeCompareKind.AllIgnoreOptions); 3972primaryAndCopyCtorAmbiguity = ctor.ParameterCount == 1 && ctor.Parameters[0].Type.Equals(this, TypeCompareKind.AllIgnoreOptions);

1396else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeType)) 1412else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeType))

268diagnostics.Add(code, Locations[0], this, parameter.Type); 289if (param.Type.HasFileLocalTypes()) 291diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Locations[0], param.Type, ContainingType);

69else if (parameter.Type.IsUnsafe()) 73else if (parameter.Type.IsRestrictedType()) 75diagnostics.Add(ErrorCode.ERR_BadSpecialByRefLocal, getLocation(parameter, location), parameter.Type);

957checkAndReportManagedTypes(param.Type, param.RefKind, param.GetNonNullSyntaxNode(), isParam: true, diagnostics);

245parameter.Type.CheckAllConstraints(compilation, conversions, parameter.Locations[0], diagnostics);

130newType = CustomModifierUtils.CopyTypeCustomModifiers(newType, this.Type, this.ContainingAssembly);

540if (!IsExplicitInterfaceImplementation && !this.IsNoMoreVisibleThan(param.Type, ref useSiteInfo)) 542diagnostics.Add(ErrorCode.ERR_BadVisIndexerParam, Location, this, param.Type); 544else if (param.Type.HasFileLocalTypes() && !this.ContainingType.HasFileLocalTypes()) 546diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, param.Type, this.ContainingType);

1467parameter.Type.CheckAllConstraints(DeclaringCompilation, conversions, parameter.Locations[0], diagnostics);

168return reduced.Parameters[0].Type;

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

68if (parameter.Type.IsErrorType())

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

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

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

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

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

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

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

46F.Null(argument.Type)),

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

241param.Type,

14433SemanticEdit(SemanticEditKind.Delete, c => c.GetMembers("C.set_P").FirstOrDefault(p => p.GetParameters()[0].Type.SpecialType == SpecialType.System_Int32)?.ISymbol, deletedSymbolContainerProvider: c => c.GetMember("C")), 14455SemanticEdit(SemanticEditKind.Delete, c => c.GetMembers("C.set_P").FirstOrDefault(p => p.GetParameters()[0].Type.SpecialType == SpecialType.System_Int32)?.ISymbol, deletedSymbolContainerProvider: c => c.GetMember("C")), 15697SemanticEdit(SemanticEditKind.Delete, c => c.GetMembers("C.set_Item").FirstOrDefault(p => p.GetParameters()[1].Type.SpecialType == SpecialType.System_Int32)?.ISymbol, deletedSymbolContainerProvider: c => c.GetMember("C")),

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, 5603CommonVerifyFunctionPointer((FunctionPointerTypeSymbol)param.Type); 5604Assert.Equal("delegate*<dynamic modopt(System.Object), ref readonly modreq(System.Runtime.InteropServices.InAttribute) modopt(System.Object) dynamic modopt(System.Object)>", param.Type.ToTestDisplayString()); 5714CommonVerifyFunctionPointer((FunctionPointerTypeSymbol)param.Type); 5715Assert.Equal(expectedType, param.Type.ToTestDisplayString()); 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; 7048verifyArray(funcPtr.Signature.Parameters.Single().Type); 7052verifyArray(funcPtr.Signature.Parameters.Single().Type); 7054funcPtr = (FunctionPointerTypeSymbol)m3.Parameters.Single().Type;

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

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

446var parameter1Type = parameter1.Type; 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); 2078Assert.Equal(invoke.Parameters[i].Type, beginInvoke.Parameters[i].Type); 2081Assert.Equal("System.AsyncCallback", beginInvoke.Parameters[invoke.Parameters.Length].Type.ToTestDisplayString()); 2082Assert.Equal("System.Object", beginInvoke.Parameters[invoke.Parameters.Length + 1].Type.ToTestDisplayString()); 2097Assert.Equal("System.IAsyncResult", endInvoke.Parameters[k++].Type.ToTestDisplayString());

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

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;

1600var type = parameter.Type;

97get { return this.Parameter.Type; }

141Debug.Assert(TypeSymbol.Equals(_thisParameter.Type, this.SubstitutedSourceMethod.ContainingType, TypeCompareKind.ConsiderEverything2));

37method.Parameters[0].Type);

90method.Parameters[0].Type);

34method.Parameters[0].Type);

396AssertEx.All(method.Parameters, parameter => method.IsContainingSymbolOfAllTypeParameters(parameter.Type));

2213var eeTypeParameterSymbol = (EETypeParameterSymbol)method.Parameters[0].Type;

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

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

3281Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3286Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3373Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3379Assert.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;

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

9043typeArg = ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.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()); 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()); 13886Assert.False(m1.Parameters[0].Type.IsNullableType()); 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()); 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()); 135163Assert.False(dGoo.Parameters[0].Type.IsNullableType()); 135191Assert.True(c2Goo.Parameters[0].Type.IsReferenceType); 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); 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;

376Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 380Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 447Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 451Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 494Assert.Equal("C", x.Type.ToTestDisplayString()); 560Assert.Equal(SpecialType.System_Int32, x.Type.SpecialType); 564Assert.Equal(SpecialType.System_String, y.Type.SpecialType); 594Assert.Equal(SpecialType.System_Int32, a.Type.SpecialType); 598Assert.Equal(SpecialType.System_String, b.Type.SpecialType); 630Assert.Equal(SpecialType.System_Int32, p1.Type.SpecialType); 636Assert.Equal(SpecialType.System_String, p2.Type.SpecialType); 642Assert.Equal(SpecialType.System_Int32, p2.Type.SpecialType); 653Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything)); 686Assert.Equal(SpecialType.System_Int32, p1.Type.SpecialType); 691Assert.Equal(SpecialType.System_String, p2.Type.SpecialType);

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

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

2350Assert.NotEqual(localC3Foo2.Parameters[0].Type, x1.Type); 2357Assert.Equal(2, ((ArrayTypeSymbol)x1.Type).Rank); 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;

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

2632verifyArray(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); 2603Assert.Equal(SpecialType.System_Object, method.Parameters.Single().Type.SpecialType); 4040Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType); 4046Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType); 4070Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType); 4076Assert.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));

217Assert.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 283Assert.Equal("IntPtr", p5.Type.Name);

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

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

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

717Assert.NotEqual(parameterTypesIndexer.Parameters.Last().Type, parameterTypesIndexer.GetMethod.Parameters.Last().Type); 1077Assert.Equal(property.Type, accessor.Parameters.Last().Type); 1084Assert.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);

391Assert.Same(varI1, param[0].Type); 392Assert.Same(varI2, param[1].Type); 396Assert.Same(varS1, param[0].Type); 397Assert.Same(varS2, param[1].Type); 422Assert.Same(varI1, param[0].Type); 423Assert.Same(varI2, param[1].Type); 427Assert.Same(varS1, param[0].Type); 428Assert.Same(varS2, param[1].Type); 453Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 454Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 463Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 464missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 471Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 472Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 505Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 506missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 513Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 514Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 518Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 519Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 520Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 521Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 540Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 541Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 542Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 543Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 547Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 548Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 549Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 550Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 570Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 571Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 572Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 573Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 577Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 578Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 579Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 580Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 605Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 606ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 611Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 612Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 692Assert.Same(varI1, param[0].Type); 693Assert.Same(varI2, param[1].Type); 697Assert.Same(varS1, param[0].Type); 698Assert.Same(varS2, param[1].Type); 723Assert.Same(varI1, param[0].Type); 724Assert.Same(varI2, param[1].Type); 728Assert.Same(varS1, param[0].Type); 729Assert.Same(varS2, param[1].Type); 754Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 755Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 764Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 765missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 772Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 773Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 806Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 807missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 814Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 815Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 819Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 820Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 821Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 822Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 841Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 842Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 843Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 844Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 848Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 849Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 850Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 851Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 871Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 872Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 873Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 874Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 878Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 879Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 880Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 881Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 906Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 907ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 912Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 913Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 996Assert.Same(varI1, param[0].Type); 997Assert.Same(varI2, param[1].Type); 1001Assert.Same(varS1, param[0].Type); 1002Assert.Same(varS2, param[1].Type); 1027Assert.Same(varI1, param[0].Type); 1028Assert.Same(varI2, param[1].Type); 1032Assert.Same(varS1, param[0].Type); 1033Assert.Same(varS2, param[1].Type); 1058Assert.Same(pia1_3.GlobalNamespace.GetTypeMembers("I1").Single(), param[0].Type); 1059Assert.Same(pia1_3.GlobalNamespace.GetMembers("NS1").OfType<NamespaceSymbol>().Single().GetTypeMembers("I2").Single(), param[1].Type); 1068Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1069missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 1076Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1077Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1110Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1111missing = (NoPiaMissingCanonicalTypeSymbol)param[0].Type; 1118Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1119Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1123Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1124Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1125Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1126Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1145Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1146Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1147Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1148Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1152Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1153Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1154Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1155Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1175Assert.Equal(TypeKind.Interface, param[0].Type.TypeKind); 1176Assert.Equal(TypeKind.Interface, param[1].Type.TypeKind); 1177Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 1178Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 1182Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1183Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[0].Type); 1184Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1185Assert.IsType<NoPiaMissingCanonicalTypeSymbol>(param[1].Type); 1210Assert.Equal(SymbolKind.ErrorType, param[0].Type.Kind); 1211ambiguous = (NoPiaAmbiguousCanonicalTypeSymbol)param[0].Type; 1216Assert.Equal(SymbolKind.ErrorType, param[1].Type.Kind); 1217Assert.IsType<NoPiaAmbiguousCanonicalTypeSymbol>(param[1].Type); 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);

96ArrayTypeSymbol p5Type = (ArrayTypeSymbol)p5.Type; 109PointerTypeSymbol p6Type = (PointerTypeSymbol)p6.Type; 209PointerTypeSymbol p1Type = (PointerTypeSymbol)p1.Type;

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

336CheckCustomModifier(inParameterType, ((ArrayTypeSymbol)method.Parameters.Single().Type).ElementTypeWithAnnotations.CustomModifiers); 1987var 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);

41Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 42Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 123Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 124Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 147Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 148Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug 193var t2 = element.Type; 345Assert.Equal(t, m.Parameters[0].Type); 366var refP = p1.Type; 374var outP = p2.Type; 1368Assert.Equal(classBTypeArguments[0], classBMethodMParameters[0].Type); 1369Assert.Equal(classBTypeArguments[1], classBMethodMParameters[1].Type); 1370Assert.Equal(classBMethodMTypeParameters[0], classBMethodMParameters[2].Type); 1391Assert.Equal(classCBaseTypeArguments[0], classCBaseMethodMParameters[0].Type); 1392Assert.Equal(classCBaseTypeArguments[1], classCBaseMethodMParameters[1].Type); 1393Assert.Equal(classCBaseMethodMTypeParameters[0], classCBaseMethodMParameters[2].Type);

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)); 1887getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32 && 1888getter.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));

2345Assert.Equal("Goo", param.Type.Name); 2346Assert.Equal(TypeKind.Error, param.Type.TypeKind);

518Assert.Equal(TypeKind.Array, p3.Type.TypeKind); 1543memType = paras[0].Type; 1545memType = paras[1].Type; 1559memType = paras[0].Type; 1561memType = paras[1].Type; 1575memType = paras[0].Type; 1577memType = paras[1].Type; 1621memType = paras[0].Type; 1623memType = paras[1].Type; 1637Assert.Same(topType, paras[0].Type.GetNullableUnderlyingType()); 1645memType = paras[0].Type; 1647memType = paras[1].Type;

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

538Assert.Equal(propertyOrEventType, accessor.Parameters.Single().Type); 561Assert.Equal(propertyParam.Type, accessorParam.Type); 569Assert.Equal(propertyOrEventType, valueParameter.Type);

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

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

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