Type

Binder\Binder.NamespaceOrTypeOrAliasSymbolWithAnnotations.cs (1)

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

Binder\Binder_Attributes.cs (3)

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

Binder\Binder_Constraints.cs (9)

414diagnostics.Add(ErrorCode.ERR_BadVisBound, location, containingSymbol, constraintType.Type); 417if (constraintType.Type.HasFileLocalTypes()) 430diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, location, constraintType.Type, containingSymbol); 458Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name); 472Error(diagnostics, ErrorCode.ERR_ClassBoundNotFirst, syntax, type.Type); 487Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 496Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 502Error(diagnostics, ErrorCode.ERR_UnmanagedBoundWithClass, syntax, type.Type); 520TypeSymbol type = typeWithAnnotations.Type;

Binder\Binder_Conversions.cs (2)

957convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics)); 1209bool isAccessible = this.IsSymbolAccessibleConditional(memberSymbol.GetTypeOrReturnType().Type, containingType, ref useSiteInfo);

Binder\Binder_Crefs.cs (3)

590if (ContainsNestedTypeOfUnconstructedGenericType(typeArgument.Type)) 905(!unusedDiagnostics.HasAnyErrors() && typeArgument.Type is CrefTypeParameterSymbol)); 969TypeSymbol 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.IsErrorTypeOrRefLikeType()) 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 (34)

Binder\Binder_Invocation.cs (1)

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

Binder\Binder_Lambda.cs (1)

294var type = returnType.Type;

Binder\Binder_Lookup.cs (1)

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

Binder\Binder_Operators.cs (3)

852namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte; 3298TypeSymbol targetType = targetTypeWithAnnotations.Type; 3621TypeSymbol targetType = targetTypeWithAnnotations.Type;

Binder\Binder_Patterns.cs (6)

852hasErrors |= CheckValidPatternType(typeSyntax, inputType, declType.Type, diagnostics: diagnostics); 887CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax ?? (SyntaxNode)designation); 891syntax: designation, localSymbol: localSymbol, localSymbol.IsVar ? BoundLocalDeclarationKind.WithInferredType : BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declType.Type); 965TypeSymbol declType = declTypeWithAnnotations.Type; 1163TypeSymbol elementType = isError ? CreateErrorType() : elementTypesWithAnnotations[i].Type; 1436TypeSymbol elementType = isError ? CreateErrorType() : elementTypes[i].Type;

Binder\Binder_Statements.cs (16)

238TypeSymbol elementType = GetIteratorElementType().Type; 850Error(diagnostics, ErrorCode.ERR_VarDeclIsStaticClass, typeSyntax, declType.Type); 853if (isConst && !declType.Type.CanBeConst()) 855Error(diagnostics, ErrorCode.ERR_BadConstType, typeSyntax, declType.Type); 1030Error(localDiagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, declarator, declTypeOpt.Type); 1035if (!declTypeOpt.Type.IsErrorType()) 1059initializerOpt = BindPossibleArrayInitializer(value, declTypeOpt.Type, valueKind, diagnostics); 1064declTypeOpt.Type, 1086if (!declTypeOpt.Type.IsPointerType()) 1090Error(localDiagnostics, declTypeOpt.Type.IsFunctionPointer() ? ErrorCode.ERR_CannotUseFunctionPointerAsFixedLocal : ErrorCode.ERR_BadFixedInitType, declarator); 1094else if (!IsValidFixedVariableInitializer(declTypeOpt.Type, ref initializerOpt, localDiagnostics)) 1100CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeOpt.Type, localDiagnostics, typeSyntax); 1102if (localSymbol.Scope == ScopedKind.ScopedValue && !declTypeOpt.Type.IsErrorTypeOrRefLikeType()) 2030Error(diagnostics, ErrorCode.ERR_ExpressionTreeMustHaveDelegate, syntax, ((NamedTypeSymbol)targetType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 2482var targetElementType = targetElementTypes[i].Type; 3148type = this.BindType(declaration.Type, diagnostics).Type;

Binder\Binder_Symbols.cs (7)

528else if (LazyMissingNonNullTypesContextDiagnosticInfo.IsNullableReference(typeArgument.Type)) 552ReportUseSite(constructedType.Type.OriginalDefinition, diagnostics, syntax); 553var type = (NamedTypeSymbol)constructedType.Type; 596CheckManagedAddr(Compilation, elementType.Type, node.Location, diagnostics); 611if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8()) 636Error(diagnostics, ErrorCode.ERR_ArrayOfStaticClass, node.ElementType, type.Type); 647Error(diagnostics, ErrorCode.ERR_ArrayElementCantBeRefAny, node.ElementType, type.Type);

Binder\Binder_TupleOperators.cs (1)

385.SelectAsArray((t, s) => (BoundExpression)new BoundTupleOperandPlaceholder(s, t.Type), expr.Syntax);

Binder\ForEachEnumeratorInfo.cs (2)

20public TypeSymbol ElementType => ElementTypeWithAnnotations.Type; 86public TypeSymbol ElementType => ElementTypeWithAnnotations.Type;

Binder\ForEachLoopBinder.cs (13)

185var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, inferredType.Type ?? CreateErrorType("var")); 301CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax); 303if (local.Scope == ScopedKind.ScopedValue && !declType.Type.IsErrorTypeOrRefLikeType()) 353var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, iterationVariableType.Type).MakeCompilerGenerated(); 409hasErrors = hasErrors || boundIterationVariableType.HasErrors || iterationVariableType.Type.IsErrorType(); 447Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 451Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 455var elementPlaceholder = new BoundValuePlaceholder(_syntax, inferredType.Type).MakeCompilerGenerated(); 463diagnostics.Add(ErrorCode.ERR_AmbigUDConv, foreachKeyword.GetLocation(), originalUserDefinedConversions[0], originalUserDefinedConversions[1], inferredType.Type, iterationVariableType); 467SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, inferredType.Type, iterationVariableType.Type); 479BoundExpression 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\ConversionsBase.cs (40)

1203HasImplicitConstantExpressionConversion(source, nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type)) 1231var underlyingTupleConversion = GetImplicitTupleLiteralConversion(source, nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, ref useSiteInfo); 1262var underlyingTupleConversion = GetExplicitTupleLiteralConversion(source, nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, isChecked: isChecked, ref useSiteInfo, forCast); 1413!invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions)) 1527var delegateType = type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1740var type = typeWithAnnotations.Type; 1754ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo).Kind != ConversionKind.NoConversion; 1814conversions.ClassifyImplicitExtensionMethodThisArgConversion(s, s.Type, d.Type, ref u), 1836return conversions.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, s.Type, d.Type, ref u); 2148=> conversions.ClassifyImplicitConversionFromExpression(s, d.Type, ref u), 2166conversions.ClassifyConversionFromExpression(s, d.Type, isChecked: isChecked, ref u, forCast: forCast), 2224return conversions.ClassifyImplicitConversionFromType(s.Type, d.Type, ref u); 2243return conversions.ClassifyConversionFromType(s.Type, d.Type, isChecked: isChecked, ref u, forCast); 2451return HasIdentityOrImplicitReferenceConversion(elementType.Type, argument0.Type, ref useSiteInfo); 2465HasIdentityConversionInternal(source.Type, destination.Type, includeNullability: true)) 2470return HasImplicitReferenceConversion(source.Type, destination.Type, ref useSiteInfo); 2958if (HasIdentityConversionInternal(sourceTypeArgument.Type, destinationTypeArgument.Type) && 2964TypeParameterSymbol typeParameterSymbol = (TypeParameterSymbol)typeParameters[paramIndex].Type; 2977TypeSymbol.Equals(destinationTypeArgument.Type, sourceTypeArgument.Type, TypeCompareKind.AllNullableIgnoreOptions) && 3192&& (HasIdentityOrImplicitReferenceConversion(sourceType.Type, destinationType.Type, ref useSiteInfo) 3193|| HasImplicitPointerToVoidConversion(sourceType.Type, destinationType.Type) 3194|| HasImplicitPointerConversion(sourceType.Type, destinationType.Type, ref useSiteInfo)); 3198&& HasIdentityConversion(sourceType.Type, destinationType.Type); 3449var sourceArg = sourceTypeArguments[i].Type; 3450var destinationArg = destinationTypeArguments[i].Type; 3532if (HasExplicitReferenceConversion(sourceArray.ElementType, ((NamedTypeSymbol)destination).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type, ref useSiteInfo)) 3552var sourceElement = ((NamedTypeSymbol)source).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type;

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

451if (!fixedResultType.Type.IsErrorType()) 460var errorTypeName = fixedResultType.Type.Name; 489TypeParameterSymbol typeParameter = (TypeParameterSymbol)type.Type; 512var methodTypeParameter = (TypeParameterSymbol)methodTypeParameterWithAnnotations.Type; 546return typeMap.SubstituteType(delegateOrFunctionPointerType).Type; 586ExactOrBoundsKind kind = GetRefKind(arg).IsManagedReference() || target.Type.IsPointerType() ? ExactOrBoundsKind.Exact : ExactOrBoundsKind.LowerBound; 607if (argument.Kind == BoundKind.UnboundLambda && target.Type.GetDelegateType() is { }) 617if (IsReallyAType(argumentType.Type)) 623var ordinal = ((TypeParameterSymbol)target.Type).Ordinal; 635if (target.Type.Kind != SymbolKind.NamedType) 641var destination = (NamedTypeSymbol)target.Type; 793if (HasUnfixedParamInOutputType(argument, formalType.Type) && !HasUnfixedParamInInputType(argument, formalType.Type)) 806if (formalType.Type.Kind != SymbolKind.NamedType) 812var destination = (NamedTypeSymbol)formalType.Type; 1027var formalParameterType = _formalParameterTypes[iArg].Type; 1269if (MethodGroupReturnTypeInference(binder, expression, target.Type, ref useSiteInfo)) 1291var delegateType = target.Type.GetDelegateType(); 1313Debug.Assert(inferredReturnType.Type is not FunctionTypeSymbol); 1448var delegateType = target.Type.GetDelegateType(); 1501var delegateInvokeMethod = target.Type.GetDelegateType()?.DelegateInvokeMethod(); 1584if (!source.Type.IsArray() || !target.Type.IsArray()) 1589var arraySource = (ArrayTypeSymbol)source.Type; 1590var arrayTarget = (ArrayTypeSymbol)target.Type; 1630ExactOrBoundsInference(kind, ((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ((NamedTypeSymbol)target.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ref useSiteInfo); 1664if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) || 1665!target.Type.TryGetElementTypesWithAnnotationsIfTupleType(out targetTypes) || 1688var namedSource = source.Type as NamedTypeSymbol; 1694var namedTarget = target.Type as NamedTypeSymbol; 1713ExactInference(((PointerTypeSymbol)source.Type).PointedAtTypeWithAnnotations, ((PointerTypeSymbol)target.Type).PointedAtTypeWithAnnotations, ref useSiteInfo); 1716else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1717target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 1827if (LowerBoundArrayInference(source.Type, target.Type, ref useSiteInfo)) 1864if (LowerBoundConstructedInference(source.Type, target.Type, ref useSiteInfo)) 1869if (LowerBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 1953if (elementSource.Type.IsReferenceType) 2183if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.Out) 2187else if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.In) 2290Debug.Assert(source.Type.IsReferenceType || source.Type.IsFunctionPointer()); 2307if (UpperBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2342if (!target.Type.IsArray()) 2346var arrayTarget = (ArrayTypeSymbol)target.Type; 2348var elementSource = GetMatchingElementType(arrayTarget, source.Type, ref useSiteInfo); 2354if (elementSource.Type.IsReferenceType) 2375var source = sourceWithAnnotations.Type; 2376var target = targetWithAnnotations.Type; 2533if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.Out) 2537else if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.In) 2627Debug.Assert(best.Type.Type.Equals(withoutNullability.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 2788functionType = type.Type as FunctionTypeSymbol; 2795return constraintTypes.Any(static t => isExpressionType(t.Type)); 2832var source = sourceWithAnnotations.Type; 2833var destination = destinationWithAnnotations.Type; 3055if (!dest.Type.ContainsTypeParameter(pParam)) 3180var newBound = TypeWithAnnotations.Create(oldBound.Type, newAnnotation); 3206if (newCandidate.Type.IsDynamic()) 3237return obj.Type.GetHashCode(); 3244if (x.Type.IsDynamic() ^ y.Type.IsDynamic()) { return false; }

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

2549if (x.HasType && Conversions.HasIdentityConversion(x.Type, y)) 2559y = ((NamedTypeSymbol)y).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2652if (!ExpressionMatchExactly(sourceArguments[i], destTypes[i].Type, ref useSiteInfo)) 2789return BetterConversionTargetCore(((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 2790((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3247types.Add(parm == parameters.Length - 1 ? ((ArrayTypeSymbol)type.Type).ElementTypeWithAnnotations : type); 3509if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions)) 3680&& parameters.ParameterTypes[argumentPosition].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }) 3693parameters.ParameterTypes[argumentPosition].Type,

BoundTree\BoundDiscardExpression.cs (1)

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

BoundTree\Constructors.cs (2)

487: this(syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, typeWithAnnotations.Type, hasErrors) 489Debug.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 (10)

216if ((object)type.Type == NoReturnExpression) 228Debug.Assert(bestType.Type is not FunctionTypeSymbol); 410bool hasErrors = !types.IsDefault && types.Any(static t => t.Type?.Kind == SymbolKind.ErrorType); 481public TypeSymbol ParameterType(int index) { return ParameterTypeWithAnnotations(index).Type; } 599yield return type.Type; 608yield return type.Type; 789if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 882if (targetParameterTypes[i].Type.IsUnsafe()) 1033value = Hash.Combine(type.Type, value); 1169if (!returnType.HasType || returnType.Type.ContainsTypeParameter())

BoundTree\VariablePendingInference.cs (4)

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

CodeGen\EmitStackAllocInitializer.cs (1)

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

CodeGen\EmitStatement.cs (1)

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

Compilation\BuiltInOperators.cs (1)

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

Compilation\CSharpCompilation.cs (2)

2074var array = (ArrayTypeSymbol)firstType.Type; 3872(t, a) => TypeWithAnnotations.Create(t.Type, a.ToInternalAnnotation())));

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

279paramType.Type.GetAttributeParameterTypedConstantKind(_compilation) == TypedConstantKind.Error) 554if (!IsCompliantType(constraintType.Type, context)) 559this.AddDiagnostic(ErrorCode.WRN_CLS_BadTypeVar, typeParameter.Locations[0], constraintType.Type); 1039if (!IsCompliantType(typeArg.Type, context)) 1362TypeSymbol xType = xParameterTypes[i].Type; 1363TypeSymbol yType = yParameterTypes[i].Type;

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

208Visit(typeArgument.Type, builder);

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (6)

508var newType = (TypeSymbol?)v.Visit(t.Type); 514newType = t.Type; 735var otherType = type.WithTypeAndModifiers((TypeSymbol?)this.Visit(type.Type), this.VisitCustomModifiers(type.CustomModifiers)); 944return AreTypesEqual(type.Type, other.Type); 1083var translatedTypeArguments = type.GetAllTypeArguments(ref discardedUseSiteInfo).SelectAsArray((t, v) => t.WithTypeAndModifiers((TypeSymbol)v.Visit(t.Type),

Emitter\Model\ArrayTypeSymbolAdapter.cs (1)

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

Emitter\Model\FieldSymbolAdapter.cs (1)

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

261yield return moduleBeingBuilt.Translate(arg.Type,

Emitter\Model\NamedTypeSymbolAdapter.cs (1)

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

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

1178else if (!_alreadyReported[slot] && !symbol.GetTypeOrReturnType().Type.IsErrorType()) 1579TypeSymbol structType = variable.Symbol.GetTypeOrReturnType().Type; 1608TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type; 1644TypeSymbol 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 (85)

FlowAnalysis\NullableWalker_Patterns.cs (14)

414var output = new BoundDagTemp(e.Syntax, parameterType.Type, e, i); 417addToTempMap(output, outputSlot, parameterType.Type); 452var output = new BoundDagTemp(e.Syntax, type.Type, e); 488addToTempMap(output, outputSlot, type.Type); 496var output = new BoundDagTemp(e.Syntax, type.Type, e); 503addToTempMap(output, outputSlot, type.Type); 521var output = new BoundDagTemp(e.Syntax, type.Type, e); 525addToTempMap(output, outputSlot, type.Type); 533var output = new BoundDagTemp(e.Syntax, type.Type, e); 536addToTempMap(output, outputSlot, type.Type); 648inferredType = TypeWithAnnotations.Create(inferredType.Type, existingType.NullableAnnotation.Join(inferredType.NullableAnnotation)); 800var output = new BoundDagTemp(e.Syntax, type.Type, e, index: index); 803addToTempMap(output, outputSlot, type.Type); 975TypeWithState 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)

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

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

659var intermediate = nullable.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 768_bound.Typeof(_typeMap.SubstituteType(p.Type).Type), _bound.Literal(p.Name));

Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)

116return 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_Conversion.cs (2)

89var byteType = ((NamedTypeSymbol)node.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 828var 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; 334visitedTypeArgs.Add(typeArg.WithTypeAndModifiers(VisitType(typeArg.Type), typeArg.CustomModifiers));

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

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

Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)

182var fieldType = typeMap.SubstituteType(local.Type).Type; 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);

Lowering\SyntheticBoundNodeFactory.cs (2)

1163return new BoundPointerIndirectionOperator(Syntax, Default(new PointerTypeSymbol(type)), refersToLocation: false, type.Type); 1197return Typeof(type.Type);

Symbols\AbstractTypeMap.cs (6)

297var substituted = SubstituteType(t).Type; 356!type.Type.ContainsTypeParameters(ignoreTypesDependentOnTypeParametersOpt)) 367!type.Type.ContainsTypeParameters(ignoreTypesDependentOnTypeParametersOpt)) 371if (!map.TryGetValue(substituted.Type, out int mergeWith)) 373map.Add(substituted.Type, result.Count); 395return substituted.WithTypeAndModifiers(dynamicEraser.EraseDynamic(substituted.Type), substituted.CustomModifiers);

Symbols\AbstractTypeParameterMap.cs (1)

45result.Append(" ").Append(kv.Key).Append(":").Append(kv.Value.Type);

Symbols\AliasSymbol.cs (1)

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

Symbols\AnonymousTypes\AnonymousTypeField.cs (1)

34public TypeSymbol Type => TypeWithAnnotations.Type;

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

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

Symbols\ArrayTypeSymbol.cs (2)

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

Symbols\Compilation_WellKnownMembers.cs (2)

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

Symbols\ConstraintsHelper.cs (48)

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)

708result.Add(typeMap.SubstituteType(type).Type);

Symbols\MemberSymbolExtensions.cs (5)

118if (parameterType.Type.IsUnsafe()) 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)

75if (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)

334_lazyFixedImplementationType = type.Type as NamedTypeSymbol;

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

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

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

293var typeSymbol = DynamicTypeDecoder.TransformType(typeWithAnnotations.Type, countOfCustomModifiers, handle, moduleSymbol, refKind); 321else if (typeWithAnnotations.Type.IsRefLikeType)

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

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

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

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

Symbols\MethodSymbol.cs (8)

243public TypeSymbol ReturnType => ReturnTypeWithAnnotations.Type; 896internal TypeSymbol GetParameterType(int index) => ParameterTypesWithAnnotations[index].Type; 1151if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1153AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 1156if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1158AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1161if (type.Type.ContainsTupleNames() && compilation.HasTupleNamesAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1163AddSynthesizedAttribute(ref attributes, compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\NamedTypeSymbol.cs (5)

78typeArgument.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 87result.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 1170internal static readonly Func<TypeWithAnnotations, bool> TypeWithAnnotationsIsErrorType = type => type.HasType && type.Type.IsErrorType(); 1281builder.Add(argument.Type); 1662typeToCheck = ((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)

90public TypeSymbol Type => TypeWithAnnotations.Type;

Symbols\Retargeting\RetargetingPropertySymbol.cs (1)

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

Symbols\Retargeting\RetargetingSymbolTranslator.cs (7)

182var newTypeSymbol = Retarget(underlyingType.Type, options); 192if (modifiersHaveChanged || !TypeSymbol.Equals(underlyingType.Type, newTypeSymbol, TypeCompareKind.ConsiderEverything2)) 603if (IsOrClosedOverAnExplicitLocalType(oldArguments[i].Type)) 616if (MetadataDecoder.IsOrClosedOverATypeFromAssemblies(oldArguments[i].Type, assembliesToEmbedTypesFrom)) 629if (MetadataDecoder.IsOrClosedOverATypeFromAssemblies(newArguments[i].Type, linkedAssemblies)) 673if (IsOrClosedOverAnExplicitLocalType(argument.Type)) 1146if (TypeSymbol.Equals(retargetedEvent.Type, targetType.Type, TypeCompareKind.ConsiderEverything2))

Symbols\SignatureOnlyParameterSymbol.cs (4)

28Debug.Assert((object)type.Type != null); 113TypeSymbol.Equals(_type.Type, other._type.Type, compareKind) && 123_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)

135TypeSymbol.Equals(originalType, type.Type, TypeCompareKind.ConsiderEverything2)); 139TypeChecks(type.Type, diagnostics);

Symbols\Source\LambdaSymbol.cs (1)

159Debug.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)

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

Symbols\Source\ParameterHelpers.cs (2)

651typeWithAnnotations.Type); 663diagnostics.Add(ErrorCode.ERR_MethodArgCantBeRefAny, syntax.Location, typeWithAnnotations.Type);

Symbols\Source\SourceComplexParameterSymbol.cs (10)

Symbols\Source\SourceDelegateMethodSymbol.cs (1)

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

Symbols\Source\SourceEventSymbol.cs (8)

323if (type.Type.ContainsDynamic()) 325AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 328if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 330AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 333if (type.Type.ContainsTupleNames()) 336DeclaringCompilation.SynthesizeTupleNamesAttribute(type.Type)); 624if (type.Type.Equals(overriddenEventType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 626type = type.WithTypeAndModifiers(CustomModifierUtils.CopyTypeCustomModifiers(overriddenEventType, type.Type, containingAssembly),

Symbols\Source\SourceLocalSymbol.cs (2)

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

Symbols\Source\SourceMemberContainerSymbol.cs (1)

3688var 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)) 1065if (!IsOrContainsErrorType(overridingMemberType.Type)) 1070DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMemberType.Type, overriddenMemberType.Type, ref discardedUseSiteInfo)) 1074diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantPropertiesOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1086diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1205var result = DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingReturnType.Type, overriddenReturnType.Type, ref useSiteInfo); 1270overrideReturnType.Type, 1271baseMethod.ReturnTypeWithAnnotations.Type)) 1303baseParameterType.Type, 1304overrideParameterType.Type))

Symbols\Source\SourceMemberFieldSymbol.cs (3)

496if (type.Type?.IsRefLikeType == true) 569var elementType = ((PointerTypeSymbol)type.Type).PointedAtType; 587TypeChecks(type.Type, diagnostics);

Symbols\Source\SourceMemberMethodSymbol.cs (3)

256diagnostics.Add(code, Locations[0], this, returnType.Type); 282if (returnType.Type.HasFileLocalTypes()) 284diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Locations[0], returnType.Type, ContainingType);

Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)

1145ParameterTypesWithAnnotations.Any(static (p, cancellationTokenType) => p.Type.Equals(cancellationTokenType), cancellationTokenType))

Symbols\Source\SourceNamedTypeSymbol.cs (1)

72TypeSymbol bt = baseBinder.BindType(t, BindingDiagnosticBag.Discarded).Type;

Symbols\Source\SourceNamedTypeSymbol_Bases.cs (4)

225var curBaseSym = baseBinder.BindType(b, BindingDiagnosticBag.Discarded).Type; 350static (type, arg, flag) => !type.Type.IsValueType && !type.NullableAnnotation.IsOblivious(), 470baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type; 539baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type;

Symbols\Source\SourceNamedTypeSymbol_Enum.cs (1)

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

Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)

161diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType.Type); 223if (!parameter0Type.Type.IsValidExtensionParameterType()) 229diagnostics.Add(ErrorCode.ERR_BadTypeforThis, loc, parameter0Type.Type); 231else if (parameter0RefKind == RefKind.Ref && !parameter0Type.Type.IsValueType)

Symbols\Source\SourceParameterSymbolBase.cs (6)

91if (type.Type.ContainsDynamic()) 93AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 96if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 98AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 106if (type.Type.ContainsTupleNames()) 109compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\Source\SourcePropertyAccessorSymbol.cs (2)

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

Symbols\Source\SourcePropertySymbol.cs (3)

459diagnostics.Add((this.IsIndexer ? ErrorCode.ERR_BadVisIndexerReturn : ErrorCode.ERR_BadVisPropertyType), Location, this, type.Type); 462if (type.Type.HasFileLocalTypes() && !ContainingType.HasFileLocalTypes()) 464diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, type.Type, ContainingType);

Symbols\Source\SourcePropertySymbolBase.cs (10)

223if (type.Type.Equals(overriddenPropertyType.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 226CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1124if (type.Type.ContainsDynamic()) 1127compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + RefCustomModifiers.Length, _refKind)); 1130if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1132AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1135if (type.Type.ContainsTupleNames()) 1138compilation.SynthesizeTupleNamesAttribute(type.Type));

Symbols\Source\SourceTypeParameterSymbol.cs (2)

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

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (4)

256diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type); 259if (returnType.Type.IsStatic) 264diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(useWarning: false), returnTypeSyntax.Location, returnType.Type); 703p.ConstraintTypesNoUseSiteDiagnostics.Any((typeArgument, containingType) => typeArgument.Type.Equals(containingType, ComparisonForUserDefinedOperators),

Symbols\Source\TypeParameterConstraintClause.cs (2)

170TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType; 230TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType;

Symbols\SubstitutedFieldSymbol.cs (1)

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

Symbols\SubstitutedMethodSymbol.cs (3)

178return this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type; 392code = Hash.Combine(arg.Type, code); 413typeArguments[i].Type,

Symbols\Symbol.cs (1)

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

Symbols\Symbol_Attributes.cs (1)

536var boundTypeSymbol = (NamedTypeSymbol)boundType.Type;

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

125printableMembers.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)

596Debug.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)

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

Symbols\Tuples\TupleFieldSymbol.cs (1)

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

Symbols\Tuples\TupleTypeSymbol.cs (5)

151underlyingType = ((NamedTypeSymbol)underlyingType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type); 219currentType = (NamedTypeSymbol)currentType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type; 718currentValueTuple = (NamedTypeSymbol)oldUnderlying.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestIndex].Type; 799found = (NamedTypeSymbol)found.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type; 991var 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)

114if (constraintType.Type.IsNullableTypeOrTypeParameter()) 146return type.GetNullableUnderlyingTypeWithAnnotations().Type; 383type = ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 669/// instead of <see cref="TypeWithAnnotations.Type"/> to avoid early resolution of nullable types</param> 691TypeSymbol current = type ?? (useDefaultType ? typeWithAnnotationsOpt.DefaultType : typeWithAnnotationsOpt.Type); 1166return type.Type?.ContainsNativeIntegerWrapperType() == true; 1506code = Hash.Combine(arg.Type, code); 1528typeArguments[i].Type.OriginalDefinition, 1863var type = typeWithAnnotations.Type; 1885var typeArgNormalized = typeWithModifier.Type; 2003if (type.Type.ContainsTupleNames()) 2005addIfNotNull(builder, compilation.SynthesizeTupleNamesAttribute(type.Type)); 2007if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 2009addIfNotNull(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 (48)

60public override string ToString() => Type.ToString(); 107if (NullableAnnotation.IsAnnotated() || (Type.IsValueType && Type.IsNullableType())) 112return Create(Type, NullableAnnotation.Annotated, CustomModifiers); 117if (NullableAnnotation.IsNotAnnotated() || (Type.IsValueType && !Type.IsNullableType())) 122return Create(Type, NullableAnnotation.NotAnnotated, CustomModifiers); 133if (Type?.IsPossiblyNullableReferenceTypeTypeParameter() == true) 138if (Type.IsNullableTypeOrTypeParameter()) 157return Type.IsNullableTypeOrTypeParameter(); 190var typeSymbol = this.Type; 235TypeSymbol typeSymbol = other.Type; 237TypeSymbol type = Type.MergeEquivalentTypes(typeSymbol, variance); 255public bool IsNullableType() => Type.IsNullableType(); 258/// The list of custom modifiers, if any, associated with the <see cref="Type"/>. 262public TypeKind TypeKind => Type.TypeKind; 264public Cci.PrimitiveTypeCode PrimitiveTypeCode => Type.PrimitiveTypeCode; 293var str = !HasType ? "<null>" : Type.ToDisplayString(format); 298(!HasType || (!IsNullableType() && !Type.IsValueType))) 304(!HasType || (!Type.IsValueType && !Type.IsTypeParameterDisallowingAnnotationInCSharp8()))) 366TypeSymbol type = Type; 397return obj.Type.GetHashCode(); 415return Type.GetUnificationUseSiteDiagnosticRecursive(ref result, owner, ref checkedTypes) || 434TypeSymbol typeSymbol = this.Type; 443if (typeSymbol.Equals(newTypeWithModifiers.Type, TypeCompareKind.ConsiderEverything) && 454return Create(newTypeWithModifiers.Type, NullableAnnotation, newCustomModifiers); 467if (newTypeWithModifiers.Type is PlaceholderTypeArgumentSymbol) 473Debug.Assert(newTypeWithModifiers.Type is not IndexedTypeParameterSymbol || newTypeWithModifiers.NullableAnnotation == NullableAnnotation.Ignored); 506newTypeWithModifiers.Type, 516return Type.Equals(other.Type, comparison); 521binder.ReportDiagnosticsIfObsolete(diagnostics, Type, syntax, hasBaseReceiver: false); 568typeWithAnnotationsPredicate: (t, a, b) => t.NullableAnnotation != NullableAnnotation.Oblivious && !t.Type.IsErrorType() && !t.Type.IsValueType, 601var type = typeWithAnnotations.Type; 637TypeSymbol oldTypeSymbol = Type; 698var typeSymbol = Type; 709var typeSymbol = Type; 746return Type.GetHashCode(); 782return TypeWithState.Create(Type, getFlowState(Type, NullableAnnotation)); 950TryForceResolve(asValueType: _underlying.Type.IsValueType); 956internal override TypeSymbol GetNullableUnderlyingTypeOrSelf(TypeSymbol typeSymbol) => _underlying.Type; 1010if (!_underlying.Type.IsValueType) 1027if (newUnderlying.Type.Equals(this._underlying.Type, TypeCompareKind.ConsiderEverything) && 1069_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);