Type

Binder\Binder.NamespaceOrTypeOrAliasSymbolWithAnnotations.cs (1)

37internal Symbol Symbol => _symbol ?? TypeWithAnnotations.Type;

Binder\Binder.ValueChecks.cs (3)

4529Debug.Assert(elementType.Type is { }); 4530return !LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, elementType.Type); 4550if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type))

Binder\Binder_Attributes.cs (3)

55var boundTypeSymbol = (NamedTypeSymbol)boundType.Type; 403if (!paramType.Type.IsValidAttributeParameterType(Compilation)) 405Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type);

Binder\Binder_Constraints.cs (9)

455diagnostics.Add(ErrorCode.ERR_BadVisBound, location, containingSymbol, constraintType.Type); 458if (constraintType.Type.HasFileLocalTypes()) 471diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, location, constraintType.Type, containingSymbol); 499Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name); 513Error(diagnostics, ErrorCode.ERR_ClassBoundNotFirst, syntax, type.Type); 528Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 537Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 543Error(diagnostics, ErrorCode.ERR_UnmanagedBoundWithClass, syntax, type.Type); 561TypeSymbol type = typeWithAnnotations.Type;

Binder\Binder_Conversions.cs (14)

384new BoundValuePlaceholder(source.Syntax, sourceTypes[i].Type), 389destTypes[i].Type, 613var sourceElementType = ((NamedTypeSymbol)source).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 614var destinationElementType = ((NamedTypeSymbol)destination).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 644typeArgument.Type.IsReferenceType && 646((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(typeArgument.Type, TypeCompareKind.ConsiderEverything) && 648((NamedTypeSymbol)method.ReturnType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(((NamedTypeSymbol)arg.destination).TypeParameters[0], TypeCompareKind.ConsiderEverything)); 1048collectionBuilderMethod = GetCollectionBuilderMethod(namedType, elementTypeOriginalDefinition.Type, builderType, methodName, ref useSiteInfo, out collectionBuilderReturnTypeConversion); 1064elementType = parameterType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1752Debug.Assert(elementTypeWithAnnotations.Type is null); // GetCollectionExpressionTypeKind() does not set elementType for these cases. 1773var elementType = elementTypeWithAnnotations.Type; 1894var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2489convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics));

Binder\Binder_Crefs.cs (3)

590if (ContainsNestedTypeOfUnconstructedGenericType(typeArgument.Type)) 905(!unusedDiagnostics.HasAnyErrors() && typeArgument.Type is CrefTypeParameterSymbol)); 974TypeSymbol type = parameterOrReturnTypeBinder.BindType(typeSyntax, localDiagnostics).Type;

Binder\Binder_Deconstruct.cs (7)

855var type = declTypeWithAnnotations.Type; 893CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeWithAnnotations.Type, diagnostics, typeSyntax); 897localSymbol.Scope == ScopedKind.ScopedValue && !declTypeWithAnnotations.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 910return new BoundLocal(syntax, localSymbol, BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declTypeWithAnnotations.Type, hasErrors: hasErrors); 948Debug.Assert(TypeSymbol.Equals(declTypeWithAnnotations.Type, fieldType.Type, TypeCompareKind.ConsiderEverything2)); 955type: fieldType.Type);

Binder\Binder_Expressions.cs (35)

Binder\Binder_Invocation.cs (1)

2190TypeSymbol returnType = members[i].GetTypeOrReturnType().Type;

Binder\Binder_Lambda.cs (1)

292var type = returnType.Type;

Binder\Binder_Lookup.cs (1)

1737type = ((FieldSymbol)symbol).GetFieldType(this.FieldsBeingBound).Type;

Binder\Binder_Operators.cs (3)

883namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte; 3346TypeSymbol targetType = targetTypeWithAnnotations.Type; 3698TypeSymbol targetType = targetTypeWithAnnotations.Type;

Binder\Binder_Patterns.cs (6)

861hasErrors |= CheckValidPatternType(typeSyntax, inputType, declType.Type, diagnostics: diagnostics); 896CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax ?? (SyntaxNode)designation); 900syntax: designation, localSymbol: localSymbol, localSymbol.IsVar ? BoundLocalDeclarationKind.WithInferredType : BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declType.Type); 974TypeSymbol declType = declTypeWithAnnotations.Type; 1172TypeSymbol elementType = isError ? CreateErrorType() : elementTypesWithAnnotations[i].Type; 1445TypeSymbol elementType = isError ? CreateErrorType() : elementTypes[i].Type;

Binder\Binder_Statements.cs (16)

237TypeSymbol elementType = GetIteratorElementType().Type; 847Error(diagnostics, ErrorCode.ERR_VarDeclIsStaticClass, typeSyntax, declType.Type); 850if (isConst && !declType.Type.CanBeConst()) 852Error(diagnostics, ErrorCode.ERR_BadConstType, typeSyntax, declType.Type); 1027Error(localDiagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, declarator, declTypeOpt.Type); 1032if (!declTypeOpt.Type.IsErrorType()) 1056initializerOpt = BindPossibleArrayInitializer(value, declTypeOpt.Type, valueKind, diagnostics); 1061declTypeOpt.Type, 1083if (!declTypeOpt.Type.IsPointerType()) 1087Error(localDiagnostics, declTypeOpt.Type.IsFunctionPointer() ? ErrorCode.ERR_CannotUseFunctionPointerAsFixedLocal : ErrorCode.ERR_BadFixedInitType, declarator); 1091else if (!IsValidFixedVariableInitializer(declTypeOpt.Type, ref initializerOpt, localDiagnostics)) 1097CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeOpt.Type, localDiagnostics, typeSyntax); 1099if (localSymbol.Scope == ScopedKind.ScopedValue && !declTypeOpt.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 2063conversionError(diagnostics, ErrorCode.ERR_ExpressionTreeMustHaveDelegate, ((NamedTypeSymbol)targetType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 2522var targetElementType = targetElementTypes[i].Type; 3249type = this.BindType(declaration.Type, diagnostics).Type;

Binder\Binder_Symbols.cs (7)

530else if (LazyMissingNonNullTypesContextDiagnosticInfo.IsNullableReference(typeArgument.Type)) 554ReportUseSite(constructedType.Type.OriginalDefinition, diagnostics, syntax); 555var type = (NamedTypeSymbol)constructedType.Type; 598CheckManagedAddr(Compilation, elementType.Type, node.Location, diagnostics); 613if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8()) 638Error(diagnostics, ErrorCode.ERR_ArrayOfStaticClass, node.ElementType, type.Type); 649Error(diagnostics, ErrorCode.ERR_ArrayElementCantBeRefAny, node.ElementType, type.Type);

Binder\ForEachEnumeratorInfo.cs (2)

25public TypeSymbol ElementType => ElementTypeWithAnnotations.Type; 102public TypeSymbol ElementType => ElementTypeWithAnnotations.Type;

Binder\ForEachLoopBinder.cs (13)

200var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, inferredType.Type ?? CreateErrorType("var")); 316CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax); 318if (local.Scope == ScopedKind.ScopedValue && !declType.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 375var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, iterationVariableType.Type).MakeCompilerGenerated(); 431hasErrors = hasErrors || boundIterationVariableType.HasErrors || iterationVariableType.Type.IsErrorType(); 469Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 473Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 477var elementPlaceholder = new BoundValuePlaceholder(_syntax, inferredType.Type).MakeCompilerGenerated(); 485diagnostics.Add(ErrorCode.ERR_AmbigUDConv, foreachKeyword.GetLocation(), originalUserDefinedConversions[0], originalUserDefinedConversions[1], inferredType.Type, iterationVariableType); 489SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, inferredType.Type, iterationVariableType.Type); 501BoundExpression elementConversion = CreateConversion(_syntax, elementPlaceholder, elementConversionClassification, isCast: false, conversionGroupOpt: null, iterationVariableType.Type, createConversionDiagnostics);

Binder\Semantics\AccessCheck.cs (3)

164return IsSymbolAccessibleCore(((DiscardSymbol)symbol).TypeWithAnnotations.Type, within, null, out failedThroughTypeCheck, compilation, ref useSiteInfo, basesBeingResolved); 239if (typeArg.Type.Kind != SymbolKind.TypeParameter && !IsSymbolAccessibleCore(typeArg.Type, within, null, out unused, compilation, ref useSiteInfo, basesBeingResolved))

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

164var elementType = elementTypeWithAnnotations.Type; 174elementType = elementTypeWithAnnotations.Type;

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

1488!invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions)) 1605var delegateType = type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1882var type = typeWithAnnotations.Type; 1896ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo).Kind != ConversionKind.NoConversion; 1962conversions.ClassifyImplicitExtensionMethodThisArgConversion(s, s.Type, d.Type, ref u, isMethodGroupConversion: false), 1984return conversions.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, s.Type, d.Type, ref u, isMethodGroupConversion: false); 2297=> conversions.ClassifyImplicitConversionFromExpression(s, d.Type, ref u), 2315conversions.ClassifyConversionFromExpression(s, d.Type, isChecked: isChecked, ref u, forCast: forCast), 2373return conversions.ClassifyImplicitConversionFromType(s.Type, d.Type, ref u); 2392return conversions.ClassifyConversionFromType(s.Type, d.Type, isChecked: isChecked, ref u, forCast); 2600return HasIdentityOrImplicitReferenceConversion(elementType.Type, argument0.Type, ref useSiteInfo); 2614HasIdentityConversionInternal(source.Type, destination.Type, includeNullability: true)) 2619return HasImplicitReferenceConversion(source.Type, destination.Type, ref useSiteInfo); 3421&& (HasIdentityOrImplicitReferenceConversion(sourceType.Type, destinationType.Type, ref useSiteInfo) 3422|| HasImplicitPointerToVoidConversion(sourceType.Type, destinationType.Type) 3423|| HasImplicitPointerConversion(sourceType.Type, destinationType.Type, ref useSiteInfo)); 3427&& HasIdentityConversion(sourceType.Type, destinationType.Type); 3688var sourceArg = sourceTypeArguments[i].Type; 3689var destinationArg = destinationTypeArguments[i].Type; 3771if (HasExplicitReferenceConversion(sourceArray.ElementType, ((NamedTypeSymbol)destination).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type, ref useSiteInfo)) 3791var sourceElement = ((NamedTypeSymbol)source).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type; 4008return HasIdentityConversionInternal(source.Type, destination.Type) && 4030return HasIdentityOrReferenceConversion(elementType.Type, spanElementType.Type, ref useSiteInfo) &&

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (72)

452if (!fixedResultType.Type.IsErrorType()) 461var errorTypeName = fixedResultType.Type.Name; 490TypeParameterSymbol typeParameter = (TypeParameterSymbol)type.Type; 513var methodTypeParameter = (TypeParameterSymbol)methodTypeParameterWithAnnotations.Type; 547return typeMap.SubstituteType(delegateOrFunctionPointerType).Type; 587ExactOrBoundsKind kind = GetRefKind(arg).IsManagedReference() || target.Type.IsPointerType() ? ExactOrBoundsKind.Exact : ExactOrBoundsKind.LowerBound; 609if (argument.Kind == BoundKind.UnboundLambda && target.Type.GetDelegateType() is { }) 623if (IsReallyAType(argumentType.Type)) 629var ordinal = ((TypeParameterSymbol)target.Type).Ordinal; 642TypeSymbol targetType = target.Type; 677Debug.Assert(target.Type is { }); 678if (target.Type is null) 699if (target.Type.Kind != SymbolKind.NamedType) 705var destination = (NamedTypeSymbol)target.Type; 861if (HasUnfixedParamInOutputType(argument, formalType.Type) && !HasUnfixedParamInInputType(argument, formalType.Type)) 879if (!binder.TryGetCollectionIterationType((ExpressionSyntax)argument.Syntax, formalType.Type, out TypeWithAnnotations targetElementType)) 895if (formalType.Type.Kind != SymbolKind.NamedType) 901var destination = (NamedTypeSymbol)formalType.Type; 1118var formalParameterType = _formalParameterTypes[iArg].Type; 1360if (MethodGroupReturnTypeInference(binder, expression, target.Type, ref useSiteInfo)) 1382var delegateType = target.Type.GetDelegateType(); 1404Debug.Assert(inferredReturnType.Type is not FunctionTypeSymbol); 1541var delegateType = target.Type.GetDelegateType(); 1594var delegateInvokeMethod = target.Type.GetDelegateType()?.DelegateInvokeMethod(); 1639if (ExactSpanInference(source.Type, target.Type, ref useSiteInfo)) 1684if (!source.Type.IsArray() || !target.Type.IsArray()) 1689var arraySource = (ArrayTypeSymbol)source.Type; 1690var arrayTarget = (ArrayTypeSymbol)target.Type; 1779ExactOrBoundsInference(kind, ((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ((NamedTypeSymbol)target.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ref useSiteInfo); 1813if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) || 1814!target.Type.TryGetElementTypesWithAnnotationsIfTupleType(out targetTypes) || 1837var namedSource = source.Type as NamedTypeSymbol; 1843var namedTarget = target.Type as NamedTypeSymbol; 1862ExactInference(((PointerTypeSymbol)source.Type).PointedAtTypeWithAnnotations, ((PointerTypeSymbol)target.Type).PointedAtTypeWithAnnotations, ref useSiteInfo); 1865else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1866target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 1976if (LowerBoundArrayInference(source.Type, target.Type, ref useSiteInfo)) 1983if (LowerBoundSpanInference(source.Type, target.Type, ref useSiteInfo)) 2020if (LowerBoundConstructedInference(source.Type, target.Type, ref useSiteInfo)) 2025if (LowerBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2109if (elementSource.Type.IsReferenceType) 2144if (!sourceElementType.Type.IsReferenceType || target.IsSpan()) 2484Debug.Assert(source.Type.IsReferenceType || source.Type.IsFunctionPointer()); 2501if (UpperBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2536if (!target.Type.IsArray()) 2540var arrayTarget = (ArrayTypeSymbol)target.Type; 2542var elementSource = GetMatchingElementType(arrayTarget, source.Type, ref useSiteInfo); 2548if (elementSource.Type.IsReferenceType) 2569var source = sourceWithAnnotations.Type; 2570var target = targetWithAnnotations.Type; 2821Debug.Assert(best.Type.Type.Equals(withoutNullability.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 2985functionType = type.Type as FunctionTypeSymbol; 2992return constraintTypes.Any(static t => isExpressionType(t.Type)); 3011var source = sourceWithAnnotations.Type; 3012var destination = destinationWithAnnotations.Type; 3251if (!dest.Type.ContainsTypeParameter(pParam)) 3395var newBound = TypeWithAnnotations.Create(oldBound.Type, newAnnotation); 3421if (newCandidate.Type.IsDynamic()) 3452return obj.Type.GetHashCode(); 3459if (x.Type.IsDynamic() ^ y.Type.IsDynamic()) { return false; }

Binder\Semantics\OverloadResolution\OverloadResolution.cs (18)

1253expandedResult.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel) 1336if (elementType.Type is null) 1357Debug.Assert(elementType.Type is { }); 2568Debug.Assert(paramsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 2569return paramsElementTypeOpt.Type; 3203t1, kind1, elementType1.Type, underlyingElementConversions1: [], 3204t2, kind2, elementType2.Type, underlyingElementConversions2: [], 3218elementType = typeArg.Type; 3261if (x.HasType && Conversions.HasIdentityConversion(x.Type, y)) 3271y = ((NamedTypeSymbol)y).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3364if (!ExpressionMatchExactly(sourceArguments[i], destTypes[i].Type, ref useSiteInfo)) 3490return BetterConversionTargetCore(((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3491((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3996TryInferParamsCollectionIterationType(binder, type.Type, out paramsIterationType); 4265if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions)) 4466&& parameters.ParameterTypes[argumentPosition].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }) 4479parameters.ParameterTypes[argumentPosition].Type, 4491(ignoreOpenTypes && parameters.ParameterTypes[argumentPosition].Type.ContainsTypeParameter(parameterContainer: (MethodSymbol)candidate))));

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (2)

1382Debug.Assert(badArg.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 1383return badArg.Result.ParamsElementTypeOpt.Type;

BoundTree\BoundDiscardExpression.cs (1)

16return this.Update(type.NullableAnnotation, isInferred: true, type.Type);

BoundTree\Constructors.cs (2)

544: this(syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, typeWithAnnotations.Type, hasErrors) 546Debug.Assert((object)typeWithAnnotations.Type != null, "Field 'type' cannot be null");

BoundTree\OutDeconstructVarPendingInference.cs (1)

18Placeholder = new BoundDeconstructValuePlaceholder(this.Syntax, variableSymbol: VariableSymbol, isDiscardExpression: IsDiscardExpression, type.Type, hasErrors: this.HasErrors || !success);

BoundTree\UnboundLambda.cs (9)

228Debug.Assert(bestType.Type is not FunctionTypeSymbol); 409bool hasErrors = !types.IsDefault && types.Any(static t => t.Type?.Kind == SymbolKind.ErrorType); 479public TypeSymbol ParameterType(int index) { return ParameterTypeWithAnnotations(index).Type; } 619yield return type.Type; 628yield return type.Type; 829if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 922if (targetParameterTypes[i].Type.ContainsPointer()) 1073value = Hash.Combine(type.Type, value); 1209if (!returnType.HasType || returnType.Type.ContainsTypeParameter())

BoundTree\VariablePendingInference.cs (4)

65Binder.CheckRestrictedTypeInAsyncMethod(localSymbol.ContainingSymbol, type.Type, diagnosticsOpt, typeOrDesignationSyntax); 67if (localSymbol.Scope == ScopedKind.ScopedValue && !type.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 76return new BoundLocal(this.Syntax, localSymbol, BoundLocalDeclarationKind.WithInferredType, constantValueOpt: null, isNullableUnknown: false, type: type.Type, hasErrors: this.HasErrors || inferenceFailed).WithWasConverted(); 106type: type.Type,

CodeGen\EmitStackAllocInitializer.cs (1)

29: ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]).Type;

CodeGen\EmitStatement.cs (1)

1790Debug.Assert(local.TypeWithAnnotations.Type.IsPointerType());

Compilation\BuiltInOperators.cs (1)

693Debug.Assert(((NamedTypeSymbol)readonlySpanOfByte).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte);

Compilation\CSharpCompilation.cs (1)

2252var array = (ArrayTypeSymbol)firstType.Type;

Compilation\CSharpSemanticModel.cs (3)

298crefSymbols = ImmutableArray.Create<Symbol>(binder.BindType(expression, BindingDiagnosticBag.Discarded).Type); 413NamedTypeSymbol attributeType = (NamedTypeSymbol)binder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type; 2772var attributeType = (NamedTypeSymbol)binder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type;

Compilation\PublicSemanticModel.cs (1)

20var attributeType = (NamedTypeSymbol)enclosingBinder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type;

Compiler\ClsComplianceChecker.cs (6)

286paramType.Type.GetAttributeParameterTypedConstantKind(_compilation) == TypedConstantKind.Error) 561if (!IsCompliantType(constraintType.Type, context)) 566this.AddDiagnostic(ErrorCode.WRN_CLS_BadTypeVar, typeParameter.GetFirstLocation(), constraintType.Type); 1046if (!IsCompliantType(typeArg.Type, context)) 1369TypeSymbol xType = xParameterTypes[i].Type; 1370TypeSymbol yType = yParameterTypes[i].Type;

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

208Visit(typeArgument.Type, builder);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)

526var otherType = type.WithTypeAndModifiers((TypeSymbol?)this.Visit(type.Type), this.VisitCustomModifiers(type.CustomModifiers)); 744return AreTypesEqual(type.Type, other.Type);

Emitter\Model\ArrayTypeSymbolAdapter.cs (1)

27var type = moduleBeingBuilt.Translate(elementType.Type, syntaxNodeOpt: (CSharpSyntaxNode?)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\FieldSymbolAdapter.cs (1)

38var implType = isFixed ? AdaptedFieldSymbol.FixedImplementationType(moduleBeingBuilt) : fieldTypeWithAnnotations.Type;

Emitter\Model\GenericMethodInstanceReference.cs (1)

37yield return moduleBeingBuilt.Translate(arg.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\GenericTypeInstanceReference.cs (1)

44builder.Add(moduleBeingBuilt.Translate(type.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics));

Emitter\Model\MethodSymbolAdapter.cs (1)

256yield return moduleBeingBuilt.Translate(arg.Type,

Emitter\Model\NamedTypeSymbolAdapter.cs (1)

875var arg = moduleBeingBuilt.Translate(arguments[i].Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\SpecializedFieldReference.cs (1)

65var type = ((PEModuleBuilder)context.Module).Translate(oldType.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\SpecializedGenericMethodInstanceReference.cs (1)

38yield return moduleBeingBuilt.Translate(arg.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);

Emitter\Model\SpecializedGenericNestedTypeInstanceReference.cs (1)

43builder.Add(moduleBeingBuilt.Translate(type.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics));

Emitter\Model\TypeParameterSymbolAdapter.cs (1)

268var typeRef = moduleBeingBuilt.Translate(type.Type,

Errors\LazyArrayElementCantBeRefAnyDiagnosticInfo.cs (1)

36return new CSDiagnosticInfo(ErrorCode.ERR_ArrayElementCantBeRefAny, _possiblyRestrictedTypeSymbol.Type);

Errors\LazyMissingNonNullTypesContextDiagnosticInfo.cs (1)

86protected override DiagnosticInfo ResolveInfo() => IsNullableReference(_type.Type) ? _info : null;

Errors\LazyObsoleteDiagnosticInfo.cs (1)

42var symbol = (_symbolOrSymbolWithAnnotations as Symbol) ?? ((TypeWithAnnotations)_symbolOrSymbolWithAnnotations).Type;

Errors\LazyUseSiteDiagnosticsInfoForNullableType.cs (1)

35return _possiblyNullableTypeSymbol.Type.OriginalDefinition.GetUseSiteInfo().DiagnosticInfo;

FlowAnalysis\DefiniteAssignment.cs (4)

1222else if (!_alreadyReported[slot] && !symbol.GetTypeOrReturnType().Type.IsErrorType()) 1692TypeSymbol structType = variable.Symbol.GetTypeOrReturnType().Type; 1728TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type; 1764TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type;

FlowAnalysis\DefiniteAssignment.LocalFunctions.cs (1)

105var type = id.Symbol.GetTypeOrReturnType().Type;

FlowAnalysis\LocalDataFlowPass.cs (1)

126var variableType = symbol.GetTypeOrReturnType().Type;

FlowAnalysis\NullableWalker.cs (91)

FlowAnalysis\NullableWalker_Patterns.cs (14)

452var output = new BoundDagTemp(e.Syntax, parameterType.Type, e, i); 455addToTempMap(output, outputSlot, parameterType.Type); 490var output = new BoundDagTemp(e.Syntax, type.Type, e); 528addToTempMap(output, outputSlot, type.Type); 536var output = new BoundDagTemp(e.Syntax, type.Type, e); 543addToTempMap(output, outputSlot, type.Type); 561var output = new BoundDagTemp(e.Syntax, type.Type, e); 565addToTempMap(output, outputSlot, type.Type); 573var output = new BoundDagTemp(e.Syntax, type.Type, e); 576addToTempMap(output, outputSlot, type.Type); 688inferredType = TypeWithAnnotations.Create(inferredType.Type, existingType.NullableAnnotation.Join(inferredType.NullableAnnotation)); 840var output = new BoundDagTemp(e.Syntax, type.Type, e, index: index); 843addToTempMap(output, outputSlot, type.Type); 1020TypeWithState resultType = TypeWithState.Create(inferredTypeWithAnnotations.Type, inferredState);

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (2)

256var resultType = returnType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 263resultType = typeMap.SubstituteType(resultType).Type;

Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (1)

45Debug.Assert(!TypeSymbol.Equals(method.IteratorElementTypeWithAnnotations.Type, null, TypeCompareKind.ConsiderEverything2));

Lowering\AsyncRewriter\AsyncStateMachine.cs (1)

35var elementType = TypeMap.SubstituteType(asyncMethod.IteratorElementTypeWithAnnotations).Type;

Lowering\ClosureConversion\ClosureConversion.cs (5)

994while (!TypeSymbol.Equals(oldTypeArg.Type, newTypeArg.Type, TypeCompareKind.ConsiderEverything)); 998Debug.Assert((object)oldTypeArg.Type == newTypeArg.Type); 1694var cacheVariableType = containerAsFrame.TypeMap.SubstituteType(node.Type).Type;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

733var intermediate = nullable.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 847_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name));

Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)

117return frame.TypeMap.SubstituteType(((object)local != null ? local.TypeWithAnnotations : ((ParameterSymbol)variable).TypeWithAnnotations).Type).Type;

Lowering\IteratorRewriter\IteratorRewriter.cs (1)

258var IEnumerableOfElementType = F.SpecialType(SpecialType.System_Collections_Generic_IEnumerable_T).Construct(_elementType.Type);

Lowering\IteratorRewriter\IteratorStateMachine.cs (2)

34interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T).Construct(ElementType.Type)); 38interfaces.Add(ContainingAssembly.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerator_T).Construct(ElementType.Type));

Lowering\LocalRewriter\DelegateCacheContainer.cs (1)

69var fieldType = TypeParameters.IsEmpty ? delegateType : TypeMap.SubstituteType(delegateType).Type;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (7)

275ShouldUseRuntimeHelpersCreateSpan(node, elementType.Type)) 278Debug.Assert(!IsAllocatingRefStructCollectionExpression(node, collectionTypeKind, elementType.Type, _compilation)); 281return _factory.New(constructor, _factory.Array(elementType.Type, rewrittenElements)); 287Debug.Assert(!IsAllocatingRefStructCollectionExpression(node, collectionTypeKind, elementType.Type, _compilation)); 295Debug.Assert(IsAllocatingRefStructCollectionExpression(node, collectionTypeKind, elementType.Type, _compilation)); 893asSpanMethod = collectionsMarshalAsSpanMethod.Construct(namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 1129var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (6)

96var byteType = ((NamedTypeSymbol)node.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 611createSpan = createSpan.Construct(rewrittenOperand.Type, spanType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type); 635rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 658rewrittenOperand = _factory.Convert(implicitOperator.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 692rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 970var convertedFieldAccess = MakeConversionNode(syntax, fieldAccess, elementConversions[i], destElementTypes[i].Type, @checked, explicitCastInCode);

Lowering\LocalRewriter\LocalRewriter_Field.cs (1)

89currentLinkType = (NamedTypeSymbol)currentLinkType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type;

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (3)

69var elementType = resultTypes[i].Type; 121syntax, fieldAccess, elementConversions[i], boundConversion.Checked, boundConversion.ExplicitCastInCode, null, null, destElementTypes[i].Type, boundConversion.HasErrors); 476conversionGroupOpt: null, constantValueOpt: null, type: type.Type);

Lowering\MethodToClassRewriter.cs (2)

212return TypeMap.SubstituteType(type).Type; 339visitedTypeArgs.Add(typeArg.WithTypeAndModifiers(VisitType(typeArg.Type), typeArg.CustomModifiers));

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

324proxy = new CapturedToStateMachineFieldReplacement(GetOrAllocateReusableHoistedField(TypeMap.SubstituteType(local.Type).Type, out reused, local), isReusable: true); 557var type = TypeMap.SubstituteType(local.Type).Type;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)

185var fieldType = typeMap.SubstituteType(local.Type).Type; 255var proxyField = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, isPublic: !PreserveInitialParameterValuesAndThreadId); 260var field = F.StateMachineField(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), isPublic: true);

Lowering\SyntheticBoundNodeFactory.cs (2)

1226return new BoundPointerIndirectionOperator(Syntax, Default(new PointerTypeSymbol(type)), refersToLocation: false, type.Type); 1276return Typeof(type.Type, systemType);

Symbols\AbstractTypeMap.cs (6)

298var substituted = SubstituteType(t).Type; 357!type.Type.ContainsTypeParameters(ignoreTypesDependentOnTypeParametersOpt)) 368!type.Type.ContainsTypeParameters(ignoreTypesDependentOnTypeParametersOpt)) 372if (!map.TryGetValue(substituted.Type, out int mergeWith)) 374map.Add(substituted.Type, result.Count); 396return substituted.WithTypeAndModifiers(dynamicEraser.EraseDynamic(substituted.Type), substituted.CustomModifiers);

Symbols\AliasSymbol.cs (1)

410annotatedNamespaceOrType.TypeWithAnnotations.Type?.IsReferenceType is true)

Symbols\AnonymousTypes\AnonymousTypeField.cs (1)

34public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

236var original = TypeWithAnnotations.Create(genericFieldTypes[index].Type);

Symbols\ArrayTypeSymbol.cs (2)

216return _elementTypeWithAnnotations.Type; 523var newInterfaces = _interfaces.SelectAsArray((i, t) => i.OriginalDefinition.Construct(t), newElementType.Type);

Symbols\Compilation_WellKnownMembers.cs (2)

1027twa.Type.VisitType(visitor, (transformFlagsBuilder, addCustomModifierFlags)); 1110return named.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[argumentIndex].Type;

Symbols\ConstraintsHelper.cs (52)

161Debug.Assert(!constraintType.Type.ContainsDynamic()); 170var constraintTypeParameter = (TypeParameterSymbol)constraintType.Type; 225if (constraintType.Type.IsInterfaceType()) 227AddInterface(interfacesBuilder, (NamedTypeSymbol)constraintType.Type); 233constraintEffectiveBase = (NamedTypeSymbol)constraintType.Type; 234constraintDeducedBase = constraintType.Type; 241var underlyingType = constraintType.Type.GetNullableUnderlyingType(); 259constraintDeducedBase = constraintType.Type; 265constraintDeducedBase = constraintType.Type; 271constraintDeducedBase = constraintType.Type; 275constraintEffectiveBase = (NamedTypeSymbol)constraintType.Type; 276constraintDeducedBase = constraintType.Type; 935if (typeArgument.Type.IsPointerOrFunctionPointer() || typeArgument.IsRestrictedType(ignoreSpanLikeTypes: true) || typeArgument.IsVoidType()) 938diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BadTypeArgument, typeArgument.Type)))); 942if (typeArgument.Type.IsRefLikeOrAllowsRefLikeType()) 961diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NotRefStructConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 969diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_GenericArgIsStaticClass, typeArgument.Type)))); 975if (!typeArgument.Type.IsReferenceType) 978diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_RefConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 988var managedKind = typeArgument.Type.GetManagedKind(ref useSiteInfo); 991if (managedKind == ManagedKind.Managed || !typeArgument.Type.IsNonNullableValueType()) 994diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_UnmanagedConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1015if (typeParameter.HasValueTypeConstraint && !typeArgument.Type.IsNonNullableValueType()) 1018diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_ValConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1044if (typeArgument.Type.IsErrorType()) 1066if (typeArgument.Type is NamedTypeSymbol { IsInterface: true } iface && SelfOrBaseHasStaticAbstractMember(iface, ref useSiteInfo, out Symbol member)) 1095var error = SatisfiesConstructorConstraint(typeArgument.Type); 1103diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1107diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintCannotHaveRequiredMembers, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1124if (typeParameter.HasNotNullConstraint && typeArgument.GetValueNullableAnnotation().IsAnnotated() && !typeArgument.Type.IsNonNullableValueType()) 1164if (typeArgument.Type.IsReferenceType) 1170errorCode = constraintType.Type.IsInterfaceType() ? ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface : ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum; 1184if (constraintType.Type.Equals(typeArgument.Type, TypeCompareKind.AllIgnoreOptions)) 1186constraintTypeErrorArgument = constraintType.Type; 1187typeArgumentErrorArgument = typeArgument.Type; 1191SymbolDistinguisher distinguisher = new SymbolDistinguisher(args.CurrentCompilation, constraintType.Type, typeArgument.Type); 1201var type = typeWithAnnotations.Type; 1244var type = typeWithAnnotations.Type; 1323if (constraintType.Type.IsErrorType()) 1334if (conversions.HasIdentityOrImplicitReferenceConversion(typeArgument.Type, constraintType.Type, ref useSiteInfo)) 1339if (typeArgument.Type.IsValueType) 1343if (conversions.HasBoxingConversion(typeArgument.Type.IsNullableType() ? ((NamedTypeSymbol)typeArgument.Type).ConstructedFrom : typeArgument.Type, 1344constraintType.Type, ref useSiteInfo)) 1349if (typeArgument.Type is NamedTypeSymbol { IsRefLikeType: true } refLike && 1350conversions.ImplementsVarianceCompatibleInterface(refLike, constraintType.Type, ref useSiteInfo)) 1358var typeParameter = (TypeParameterSymbol)typeArgument.Type; 1362if (conversions.HasImplicitTypeParameterConversion(typeParameter, constraintType.Type, ref useSiteInfo))

Symbols\DiscardSymbol.cs (1)

15Debug.Assert(typeWithAnnotations.Type is object);

Symbols\EventSymbol.cs (1)

58public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\FieldSymbol.cs (1)

75public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\LocalSymbol.cs (1)

73public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\MemberSignatureComparer.cs (1)

755result.Add(SubstituteType(typeMap, type).Type);

Symbols\MemberSymbolExtensions.cs (5)

118if (parameterType.Type.ContainsPointer()) 206count += methodReturnType.Type.CustomModifierCount(); 212count += paramType.Type.CustomModifierCount(); 255count += type.Type.CustomModifierCount(); 261count += paramType.Type.CustomModifierCount();

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

281TypeSymbol transformedTypeArg = TransformType(typeArg.Type); 290anyTransformed |= !TypeSymbol.Equals(transformedTypeArg, typeArg.Type, TypeCompareKind.ConsiderEverything2); 407var transformedType = decoder.TransformType(typeWithAnnotations.Type); 413if (transformedType.Equals(typeWithAnnotations.Type, TypeCompareKind.ConsiderEverything))

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

185TypeSymbol.Equals((fieldType = field.TypeWithAnnotations).Type, fieldInfo.Type, TypeCompareKind.CLRSignatureCompareOptions) && 261if (!TypeSymbol.Equals(substituted.Type, targetParam.Type, TypeCompareKind.CLRSignatureCompareOptions)) 289if (!TypeSymbol.Equals(substituted.Type, targetReturnType, TypeCompareKind.CLRSignatureCompareOptions))

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

255if (IsOrClosedOverATypeFromAssemblies(arguments[i].Type, assemblies))

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

74if (TransformType(type.Type) is { } transformedType)

Symbols\Metadata\PE\PEEventSymbol.cs (4)

90TypeSymbol originalEventType = _eventTypeWithAnnotations.Type; 170TypeSymbol.Equals(_eventTypeWithAnnotations.Type, ((NamedTypeSymbol)candidateAssociatedFieldType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, TypeCompareKind.ConsiderEverything2)) 177if (TypeSymbol.Equals(candidateAssociatedFieldType, _eventTypeWithAnnotations.Type, TypeCompareKind.ConsiderEverything2))

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

336_lazyFixedImplementationType = type.Type as NamedTypeSymbol;

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

522baseType = (NamedTypeSymbol)NullableTypeDecoder.TransformType(TypeWithAnnotations.Create(decodedType), _handle, moduleSymbol, accessSymbol: this, nullableContext: this).Type; 582typeSymbol = NullableTypeDecoder.TransformType(TypeWithAnnotations.Create(typeSymbol), interfaceImpl, moduleSymbol, accessSymbol: this, nullableContext: this).Type;

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

308var typeSymbol = DynamicTypeDecoder.TransformType(typeWithAnnotations.Type, countOfCustomModifiers, handle, moduleSymbol, refKind); 336else if (typeWithAnnotations.Type.IsRefLikeOrAllowsRefLikeType())

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

311if (!(constraintType.Type is PETypeParameterSymbol typeParameter) ||

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

117TypeSymbol type = metadataType.Type; 342TypeSymbol type = typeWithAnnotations.Type;

Symbols\MethodSymbol.cs (8)

247public TypeSymbol ReturnType => ReturnTypeWithAnnotations.Type; 906internal TypeSymbol GetParameterType(int index) => ParameterTypesWithAnnotations[index].Type; 1161if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1163AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 1166if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1168AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1171if (type.Type.ContainsTupleNames() && compilation.HasTupleNamesAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1173AddSynthesizedAttribute(ref attributes, compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\NamedTypeSymbol.cs (5)

78typeArgument.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 87result.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 1159internal static readonly Func<TypeWithAnnotations, bool> TypeWithAnnotationsIsErrorType = type => type.HasType && type.Type.IsErrorType(); 1270builder.Add(argument.Type); 1655typeToCheck = ((NamedTypeSymbol)typeToCheck).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type;

Symbols\NullableAnnotationExtensions.cs (2)

110return type.Type?.GetITypeSymbol(type.ToPublicAnnotation()); 119ToPublicAnnotation(type.Type, type.NullableAnnotation);

Symbols\OverriddenOrHiddenMembersHelpers.cs (2)

895methodReturnType.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: false); 900propertyType.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: false);

Symbols\ParameterSymbol.cs (1)

54public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\PointerTypeSymbol.cs (1)

76public TypeSymbol PointedAtType => PointedAtTypeWithAnnotations.Type;

Symbols\PropertySymbol.cs (1)

91public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\Retargeting\RetargetingPropertySymbol.cs (1)

70if (type.Type.TryAsDynamicIfNoPia(this.ContainingType, out TypeSymbol asDynamic))

Symbols\Retargeting\RetargetingSymbolTranslator.cs (4)

182var newTypeSymbol = Retarget(underlyingType.Type, options); 192if (modifiersHaveChanged || !TypeSymbol.Equals(underlyingType.Type, newTypeSymbol, TypeCompareKind.ConsiderEverything2)) 673if (IsOrClosedOverAnExplicitLocalType(argument.Type)) 1119if (TypeSymbol.Equals(retargetedEvent.Type, targetType.Type, TypeCompareKind.ConsiderEverything2))

Symbols\SignatureOnlyParameterSymbol.cs (4)

30Debug.Assert((object)type.Type != null); 118TypeSymbol.Equals(_type.Type, other._type.Type, compareKind) && 129_type.Type.GetHashCode(),

Symbols\Source\CustomModifierUtils.cs (2)

48TypeSymbol returnTypeSymbol = returnType.Type; 56TypeSymbol returnTypeWithCustomModifiers = sourceMethodReturnType.Type;

Symbols\Source\ExplicitInterfaceHelpers.cs (1)

54explicitInterfaceTypeOpt = binder.BindType(explicitInterfaceName, diagnostics).Type;

Symbols\Source\FieldSymbolWithAttributesAndModifiers.cs (6)

400if (type.Type.ContainsDynamic()) 403compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 406if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 408AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 411if (type.Type.ContainsTupleNames()) 414compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\Source\GlobalExpressionVariable.cs (2)

136TypeSymbol.Equals(originalType, type.Type, TypeCompareKind.ConsiderEverything2)); 140TypeChecks(type.Type, diagnostics);

Symbols\Source\LambdaSymbol.cs (1)

162Debug.Assert(_returnType.Type.IsErrorType());

Symbols\Source\LocalFunctionOrSourceMemberMethodSymbol.cs (2)

38Debug.Assert(TypeSymbol.Equals(_lazyIteratorElementType.Value.Type, elementType.Type, TypeCompareKind.ConsiderEverything));

Symbols\Source\LocalFunctionSymbol.cs (2)

267if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 284diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);

Symbols\Source\ParameterHelpers.cs (2)

683typeWithAnnotations.Type); 695diagnostics.Add(ErrorCode.ERR_MethodArgCantBeRefAny, syntax.Location, typeWithAnnotations.Type);

Symbols\Source\SourceComplexParameterSymbol.cs (11)

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

67diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);

Symbols\Source\SourceEventSymbol.cs (8)

331if (type.Type.ContainsDynamic()) 333AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 336if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 338AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 341if (type.Type.ContainsTupleNames()) 344DeclaringCompilation.SynthesizeTupleNamesAttribute(type.Type)); 632if (type.Type.Equals(overriddenEventType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 634type = type.WithTypeAndModifiers(CustomModifierUtils.CopyTypeCustomModifiers(overriddenEventType, type.Type, containingAssembly),

Symbols\Source\SourceLocalSymbol.cs (2)

390Debug.Assert(newType.Type is object); 397originalType.Value.DefaultType.IsErrorType() && newType.Type.IsErrorType() ||

Symbols\Source\SourceMemberContainerSymbol.cs (1)

3965var propertyParamType = (((i == numParams - 1) && !getNotSet) ? propertySymbol.TypeWithAnnotations : propertyParams[i].TypeWithAnnotations).Type;

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (16)

795if (IsOrContainsErrorType(parameterType.Type)) 960if (!IsOrContainsErrorType(overridingMemberType.Type)) 962diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 998if (DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMethod.ReturnTypeWithAnnotations.Type, overriddenMethod.ReturnTypeWithAnnotations.Type, ref discardedUseSiteInfo)) 1063if (!IsOrContainsErrorType(overridingMemberType.Type)) 1068DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMemberType.Type, overriddenMemberType.Type, ref discardedUseSiteInfo)) 1072diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantPropertiesOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1084diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1204var result = DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingReturnType.Type, overriddenReturnType.Type, ref useSiteInfo); 1269overrideReturnType.Type, 1270baseMethod.ReturnTypeWithAnnotations.Type)) 1302baseParameterType.Type, 1303overrideParameterType.Type))

Symbols\Source\SourceMemberFieldSymbol.cs (3)

500if (type.Type.IsRefLikeOrAllowsRefLikeType()) 573var elementType = ((PointerTypeSymbol)type.Type).PointedAtType; 591TypeChecks(type.Type, diagnostics);

Symbols\Source\SourceMemberMethodSymbol.cs (3)

353diagnostics.Add(code, GetFirstLocation(), this, returnType.Type); 379if (returnType.Type.HasFileLocalTypes()) 381diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, GetFirstLocation(), returnType.Type, ContainingType);

Symbols\Source\SourceNamedTypeSymbol.cs (2)

61TypeSymbol bt = baseBinder.BindType(t, BindingDiagnosticBag.Discarded).Type; 1888if (!fieldSupported || elementType.Type.IsPointerOrFunctionPointer() || elementType.IsRestrictedType(ignoreSpanLikeTypes: true))

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (4)

226var curBaseSym = baseBinder.BindType(b, BindingDiagnosticBag.Discarded).Type; 351static (type, arg, flag) => !type.Type.IsValueType && !type.NullableAnnotation.IsOblivious(), 471baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type; 540baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type;

Symbols\Source\SourceNamedTypeSymbol_Enum.cs (1)

62var type = baseBinder.BindType(typeSyntax, diagnostics).Type;

Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)

149diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType.Type); 210if (!parameter0Type.Type.IsValidExtensionParameterType()) 216diagnostics.Add(ErrorCode.ERR_BadTypeforThis, loc, parameter0Type.Type); 218else if (parameter0RefKind == RefKind.Ref && !parameter0Type.Type.IsValueType)

Symbols\Source\SourceParameterSymbolBase.cs (6)

95if (type.Type.ContainsDynamic()) 97AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 100if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 102AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 110if (type.Type.ContainsTupleNames()) 113compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\Source\SourcePropertyAccessorSymbol.cs (2)

293CustomModifierUtils.CopyTypeCustomModifiers(type.Type, _lazyReturnType.Type, this.ContainingAssembly),

Symbols\Source\SourcePropertySymbol.cs (3)

574diagnostics.Add((this.IsIndexer ? ErrorCode.ERR_BadVisIndexerReturn : ErrorCode.ERR_BadVisPropertyType), Location, this, type.Type); 577if (type.Type.HasFileLocalTypes() && !ContainingType.HasFileLocalTypes()) 579diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, type.Type, ContainingType);

Symbols\Source\SourcePropertySymbolBase.cs (10)

256if (type.Type.Equals(overriddenPropertyType.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 259CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1370if (type.Type.ContainsDynamic()) 1373compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + RefCustomModifiers.Length, _refKind)); 1376if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1378AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1381if (type.Type.ContainsTupleNames()) 1384compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\Source\SourceTypeParameterSymbol.cs (2)

266if (!diagnostics.ReportUseSite(constraintType.Type, args.Args.Location)) 268constraintType.Type.CheckAllConstraints(args);

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (3)

259diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type); 262if (returnType.Type.IsStatic) 267diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(useWarning: false), returnTypeSyntax.Location, returnType.Type);

Symbols\Source\TypeParameterConstraintClause.cs (2)

174TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType; 234TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType;

Symbols\SubstitutedFieldSymbol.cs (1)

103return (NamedTypeSymbol)_containingType.TypeSubstitution.SubstituteType(OriginalDefinition.FixedImplementationType(emitModule)).Type;

Symbols\SubstitutedMethodSymbol.cs (3)

179return this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type; 394code = Hash.Combine(arg.Type, code); 415typeArguments[i].Type,

Symbols\Symbol.cs (1)

1230return DeriveUseSiteInfoFromType(ref result, type.Type) ||

Symbols\Symbol_Attributes.cs (1)

551var boundTypeSymbol = (NamedTypeSymbol)boundType.Type;

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

124printableMembers.Any(static m => m.GetTypeOrReturnType().Type.IsErrorType()))

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)

40boolArrayType.Type,

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (1)

44byteArrayType.Type,

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)

610Debug.Assert(TypeSymbol.Equals(initializeResult.Type, _returnType.Type, TypeCompareKind.ConsiderEverything2));

Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)

52var type = typeWithAnnotations.Type;

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)

277MergeUseSiteInfo(ref result, ReturnTypeWithAnnotations.Type.GetUseSiteInfo());

Symbols\Synthesized\SynthesizedParameterSymbol.cs (6)

156if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None) && compilation.CanEmitBoolean()) 158AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 161if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 163AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 171if (type.Type.ContainsTupleNames() && 176compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\Tuples\TupleFieldSymbol.cs (1)

223newUnderlyingOwner = (NamedTypeSymbol)newUnderlyingOwner.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type;

Symbols\Tuples\TupleTypeSymbol.cs (5)

145underlyingType = ((NamedTypeSymbol)underlyingType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type); 213currentType = (NamedTypeSymbol)currentType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type; 712currentValueTuple = (NamedTypeSymbol)oldUnderlying.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestIndex].Type; 793found = (NamedTypeSymbol)found.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type; 985var extensionTupleElementTypes = tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type.TupleElementTypesWithAnnotations;

Symbols\TypeMap.cs (1)

24public static readonly Func<TypeWithAnnotations, TypeSymbol> AsTypeSymbol = t => t.Type;

Symbols\TypeParameterSymbol.cs (5)

99((TypeSymbol)constraint.Type.OriginalDefinition).AddUseSiteInfo(ref useSiteInfo); 440if (ConstraintImpliesReferenceType(constraintType.Type)) 471if (constraintType.Type.IsNonNullableValueType()) 486bool? isNotNullable = ((TypeParameterSymbol)constraintType.Type).IsNotNullable; 510if (constraintType.Type.IsValueType)

Symbols\TypeParameterSymbolExtensions.cs (1)

23if (constraintType.Type is TypeParameterSymbol typeParameter)

Symbols\TypeSymbolExtensions.cs (14)

122if (constraintType.Type.IsNullableTypeOrTypeParameter()) 154return type.GetNullableUnderlyingTypeWithAnnotations().Type; 162underlyingType = nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 442type = ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 748/// instead of <see cref="TypeWithAnnotations.Type"/> to avoid early resolution of nullable types</param> 770TypeSymbol current = type ?? (useDefaultType ? typeWithAnnotationsOpt.DefaultType : typeWithAnnotationsOpt.Type); 1254return type.Type?.ContainsNativeIntegerWrapperType() == true; 1597code = Hash.Combine(arg.Type, code); 1619typeArguments[i].Type.OriginalDefinition, 1954var type = typeWithAnnotations.Type; 2094if (type.Type.ContainsTupleNames()) 2096addIfNotNull(builder, compilation.SynthesizeTupleNamesAttribute(type.Type)); 2098if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 2100addIfNotNull(builder, moduleBuilder.SynthesizeNativeIntegerAttribute(declaringSymbol, type.Type));

Symbols\TypeUnification.cs (24)

33Debug.Assert(substituted1.Type.Equals(substituted2.Type, TypeCompareKind.CLRSignatureCompareOptions)); 92if (TypeSymbol.Equals(t1.Type, t2.Type, TypeCompareKind.CLRSignatureCompareOptions) && t1.CustomModifiers.SequenceEqual(t2.CustomModifiers)) 99if (!t1.Type.IsTypeParameter() && t2.Type.IsTypeParameter()) 107Debug.Assert(t1.Type.IsTypeParameter() || !t2.Type.IsTypeParameter()); 109switch (t1.Type.Kind) 118ArrayTypeSymbol at1 = (ArrayTypeSymbol)t1.Type; 119ArrayTypeSymbol at2 = (ArrayTypeSymbol)t2.Type; 135PointerTypeSymbol pt1 = (PointerTypeSymbol)t1.Type; 136PointerTypeSymbol pt2 = (PointerTypeSymbol)t2.Type; 148NamedTypeSymbol nt1 = (NamedTypeSymbol)t1.Type; 149NamedTypeSymbol nt2 = (NamedTypeSymbol)t2.Type; 185if (t2.Type.IsPointerOrFunctionPointer() || t2.IsVoidType()) 190TypeParameterSymbol tp1 = (TypeParameterSymbol)t1.Type; 194if (Contains(t2.Type, tp1)) 207AddSubstitution(ref substitution, tp1, TypeWithAnnotations.Create(t2.Type)); 215TypeWithAnnotations.Create(t2.Type, 220if (t2.Type.IsTypeParameter()) 222var tp2 = (TypeParameterSymbol)t2.Type; 234TypeWithAnnotations.Create(t1.Type, 282if (Contains(typePart.Type, typeParam))

Symbols\TypeWithAnnotations.cs (49)

63public override string ToString() => Type.ToString(); 110if (NullableAnnotation.IsAnnotated() || (Type.IsValueType && Type.IsNullableType())) 115return Create(Type, NullableAnnotation.Annotated, CustomModifiers); 120if (NullableAnnotation.IsNotAnnotated() || (Type.IsValueType && !Type.IsNullableType())) 125return Create(Type, NullableAnnotation.NotAnnotated, CustomModifiers); 136if (Type?.IsPossiblyNullableReferenceTypeTypeParameter() == true) 141if (Type.IsNullableTypeOrTypeParameter()) 160return Type.IsNullableTypeOrTypeParameter(); 198var typeSymbol = this.Type; 243TypeSymbol typeSymbol = other.Type; 245TypeSymbol type = Type.MergeEquivalentTypes(typeSymbol, variance); 264public bool IsNullableType() => Type.IsNullableType(); 267/// The list of custom modifiers, if any, associated with the <see cref="Type"/>. 271public TypeKind TypeKind => Type.TypeKind; 273public Cci.PrimitiveTypeCode PrimitiveTypeCode => Type.PrimitiveTypeCode; 304var str = !HasType ? "<null>" : Type.ToDisplayString(format); 309(!HasType || (!IsNullableType() && !Type.IsValueType))) 315(!HasType || (!Type.IsValueType && !Type.IsTypeParameterDisallowingAnnotationInCSharp8()))) 377TypeSymbol type = Type; 408return obj.Type.GetHashCode(); 426return Type.GetUnificationUseSiteDiagnosticRecursive(ref result, owner, ref checkedTypes) || 445TypeSymbol typeSymbol = this.Type; 454if (typeSymbol.Equals(newTypeWithModifiers.Type, TypeCompareKind.ConsiderEverything) && 465return Create(newTypeWithModifiers.Type, NullableAnnotation, newCustomModifiers); 478if (newTypeWithModifiers.Type is PlaceholderTypeArgumentSymbol) 484Debug.Assert(newTypeWithModifiers.Type is not IndexedTypeParameterSymbol || newTypeWithModifiers.NullableAnnotation == NullableAnnotation.Ignored); 512Debug.Assert((object)newTypeWithModifiers.DefaultType == newTypeWithModifiers.Type); 534newTypeWithModifiers.Type, 544return Type.Equals(other.Type, comparison); 549binder.ReportDiagnosticsIfObsolete(diagnostics, Type, syntax, hasBaseReceiver: false); 596typeWithAnnotationsPredicate: (t, a, b) => t.NullableAnnotation != NullableAnnotation.Oblivious && !t.Type.IsErrorType() && !t.Type.IsValueType, 629var type = typeWithAnnotations.Type; 665TypeSymbol oldTypeSymbol = Type; 726var typeSymbol = Type; 737var typeSymbol = Type; 775return Type.GetHashCode(); 811return TypeWithState.Create(Type, getFlowState(Type, NullableAnnotation)); 1084TryForceResolve(asValueType: _underlying.Type.IsValueType); 1090internal override TypeSymbol GetNullableUnderlyingTypeOrSelf(TypeSymbol typeSymbol) => _underlying.Type; 1145if (!_underlying.Type.IsValueType) 1162if (newUnderlying.Type.Equals(this._underlying.Type, TypeCompareKind.ConsiderEverything) && 1204_underlying.Type;

Symbols\TypeWithState.cs (1)

42var type = typeWithAnnotations.Type;

Symbols\VarianceSafety.cs (2)

264IsVarianceUnsafe(constraintType.Type, 386TypeSymbol typeArg = namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[i].Type;

Utilities\TypeSymbolExtensions.cs (2)

76=> typeWithAnnotations.CustomModifiers.Length + typeWithAnnotations.Type.CustomModifierCount(); 158=> typeWithAnnotations.CustomModifiers.Any() || typeWithAnnotations.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds);