858 references to Type
Microsoft.CodeAnalysis.CSharp (858)
Binder\Binder.NamespaceOrTypeOrAliasSymbolWithAnnotations.cs (1)
37internal Symbol Symbol => _symbol ?? TypeWithAnnotations.Type;
Binder\Binder.ValueChecks.cs (3)
4803Debug.Assert(elementType.Type is { }); 4807return LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, elementType.Type) 4812Debug.Assert(elementType.Type is { });
Binder\Binder_Attributes.cs (3)
55var boundTypeSymbol = (NamedTypeSymbol)boundType.Type; 405if (!paramType.Type.IsValidAttributeParameterType(Compilation)) 407Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type);
Binder\Binder_Await.cs (1)
442if ((object)unsubstitutedReturnType != method.TypeArgumentsWithAnnotations[0].Type)
Binder\Binder_Constraints.cs (9)
456diagnostics.Add(ErrorCode.ERR_BadVisBound, location, containingSymbol, constraintType.Type); 459if (constraintType.Type.HasFileLocalTypes()) 472diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, location, constraintType.Type, containingSymbol); 500Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name); 514Error(diagnostics, ErrorCode.ERR_ClassBoundNotFirst, syntax, type.Type); 529Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 538Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 544Error(diagnostics, ErrorCode.ERR_UnmanagedBoundWithClass, syntax, type.Type); 562TypeSymbol type = typeWithAnnotations.Type;
Binder\Binder_Conversions.cs (14)
448new BoundValuePlaceholder(source.Syntax, sourceTypes[i].Type), 454destTypes[i].Type, 690var sourceElementType = ((NamedTypeSymbol)source).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 691var destinationElementType = ((NamedTypeSymbol)destination).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 721typeArgument.Type.IsReferenceType && 723((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(typeArgument.Type, TypeCompareKind.ConsiderEverything) && 725((NamedTypeSymbol)method.ReturnType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(((NamedTypeSymbol)arg.destination).TypeParameters[0], TypeCompareKind.ConsiderEverything)); 1511namedType, forParams, elementTypeOriginalDefinition.Type, builderType, methodName, ref useSiteInfo); 1597var elementType = parameterType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2364Debug.Assert(elementTypeWithAnnotations.Type is null); // GetCollectionExpressionTypeKind() does not set elementType for these cases. 2385var elementType = elementTypeWithAnnotations.Type; 3200convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, InConversionGroupFlags.Unspecified, destType.Type, diagnostics)); 3459bool isAccessible = this.IsSymbolAccessibleConditional(memberSymbol.GetTypeOrReturnType().Type, containingType, ref useSiteInfo);
Binder\Binder_Crefs.cs (3)
789if (ContainsNestedTypeOfUnconstructedGenericType(typeArgument.Type)) 1106(!unusedDiagnostics.HasAnyErrors() && typeArgument.Type is CrefTypeParameterSymbol)); 1175TypeSymbol type = parameterOrReturnTypeBinder.BindType(typeSyntax, localDiagnostics).Type;
Binder\Binder_Deconstruct.cs (7)
858var type = declTypeWithAnnotations.Type; 898CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeWithAnnotations.Type, diagnostics, typeSyntax); 902localSymbol.Scope == ScopedKind.ScopedValue && !declTypeWithAnnotations.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 915return new BoundLocal(syntax, localSymbol, BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declTypeWithAnnotations.Type, hasErrors: hasErrors); 953Debug.Assert(TypeSymbol.Equals(declTypeWithAnnotations.Type, fieldType.Type, TypeCompareKind.ConsiderEverything2)); 960type: fieldType.Type);
Binder\Binder_Expressions.cs (37)
489field.GetFieldType(initializerBinder.FieldsBeingBound).Type, diagnostics); 1273return new BoundRefValueOperator(node, typeWithAnnotations.NullableAnnotation, argument, typeWithAnnotations.Type, hasErrors); 1413TypeSymbol type = typeWithAnnotations.Type; 1441var type = typeWithAnnotations.Type; 1466TypeSymbol type = typeWithAnnotations.Type; 1633TypeSymbol type = typeWithAnnotations.Type; 2306type = localSymbol.GetTypeWithAnnotations(node, diagnostics).Type; 2662TypeSymbol targetType = targetTypeWithAnnotations.Type; 2824TypeSymbol targetType = targetTypeWithAnnotations.Type; 2982var targetElementType = targetElementTypesWithAnnotations[i].Type; 3009TypeWithAnnotations underlyingTargetTypeWithAnnotations = targetTypeWithAnnotations.Type.GetNullableUnderlyingTypeWithAnnotations(); 3010var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3254var type = declType.Type; 3310CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax); 3312if (localSymbol.Scope == ScopedKind.ScopedValue && !declType.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 3317return new BoundLocal(declarationExpression, localSymbol, BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declType.Type); 3354TypeSymbol fieldType = expressionVariableField.GetFieldType(this.FieldsBeingBound).Type; 3576coercedArgument = bindInterpolatedStringHandlerInMemberCall(argument, parameterTypeWithAnnotations.Type, argumentsForInterpolationConversion, parameters, in methodResult, arg, receiver, diagnostics); 3583coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, parameterTypeWithAnnotations.Type, diagnostics); 3604coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, parameterTypeWithAnnotations.Type, diagnostics); 3658Debug.Assert(methodResult.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 3725if (!methodResult.Member.IsIndexer() && !argument.HasAnyErrors && parameterTypeWithAnnotations.Type.ContainsPointerOrFunctionPointer()) 4118var type = (ArrayTypeSymbol)BindArrayType(node.Type, diagnostics, permitDimensions: true, basesBeingResolved: null, disallowRestrictedTypes: true).Type; 4601var arrayType = (ArrayTypeSymbol)BindArrayType(arrayTypeSyntax, diagnostics, permitDimensions: true, basesBeingResolved: null, disallowRestrictedTypes: false).Type; 4605if (!elementType.Type.IsErrorType()) 4607hasErrors = hasErrors || CheckManagedAddr(Compilation, elementType.Type, elementTypeSyntax.Location, diagnostics, errorForManaged: true); 4658? new BoundStackAllocArrayCreation(node, elementType.Type, count, initializerOpt: null, type, hasErrors: hasErrors) 4659: BindStackAllocWithInitializer(node, node.StackAllocKeyword, node.Initializer, type, elementType.Type, count, diagnostics, hasErrors); 5286var type = typeWithAnnotations.Type; 7720leftType = fieldSymbol.GetFieldType(this.FieldsBeingBound).Type; 7829if (typeArgument.Type.IsPointerOrFunctionPointer() || typeArgument.Type.IsRestrictedType()) 7832Error(diagnostics, ErrorCode.ERR_BadTypeArgument, typeArgumentsSyntax[i], typeArgument.Type); 8554resultType = ((FieldSymbol)symbolOpt).GetFieldType(this.FieldsBeingBound).Type; 9223TypeSymbol fieldType = fieldSymbol.GetFieldType(this.FieldsBeingBound).Type; 11510Debug.Assert(returnType.Type is { }); // Expecting System.Void rather than null return type. 11513bool returnsVoid = returnType.Type.IsVoidType();
Binder\Binder_Invocation.cs (1)
2345TypeSymbol returnType = members[i].GetTypeOrReturnType().Type;
Binder\Binder_Lambda.cs (1)
304var type = returnType.Type;
Binder\Binder_Lookup.cs (1)
1787type = ((FieldSymbol)symbol).GetFieldType(fieldsBeingBound).Type;
Binder\Binder_Operators.cs (4)
1381namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte; 3981result = Hash.Combine(result, typeComparer.GetHashCode(typeWithAnnotations.Type)); 5020TypeSymbol targetType = targetTypeWithAnnotations.Type; 5373TypeSymbol targetType = targetTypeWithAnnotations.Type;
Binder\Binder_Patterns.cs (6)
1467hasErrors |= CheckValidPatternType(typeSyntax, unionType, inputType, declType.Type, diagnostics: diagnostics); 1502CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax ?? (SyntaxNode)designation); 1506syntax: designation, localSymbol: localSymbol, localSymbol.IsVar ? BoundLocalDeclarationKind.WithInferredType : BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declType.Type); 1587TypeSymbol declType = declTypeWithAnnotations.Type; 1782TypeSymbol elementType = isError ? CreateErrorType() : elementTypesWithAnnotations[i].Type; 2085TypeSymbol elementType = isError ? CreateErrorType() : elementTypes[i].Type;
Binder\Binder_Statements.cs (16)
237TypeSymbol elementType = GetIteratorElementType().Type; 854Error(diagnostics, ErrorCode.ERR_VarDeclIsStaticClass, typeSyntax, declType.Type); 857if (isConst && !declType.Type.CanBeConst()) 859Error(diagnostics, ErrorCode.ERR_BadConstType, typeSyntax, declType.Type); 1034Error(localDiagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, declarator, declTypeOpt.Type); 1039if (!declTypeOpt.Type.IsErrorType()) 1063initializerOpt = BindPossibleArrayInitializer(value, declTypeOpt.Type, valueKind, diagnostics); 1068declTypeOpt.Type, 1090if (!declTypeOpt.Type.IsPointerType()) 1094Error(localDiagnostics, declTypeOpt.Type.IsFunctionPointer() ? ErrorCode.ERR_CannotUseFunctionPointerAsFixedLocal : ErrorCode.ERR_BadFixedInitType, declarator); 1098else if (!IsValidFixedVariableInitializer(declTypeOpt.Type, ref initializerOpt, localDiagnostics)) 1104CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeOpt.Type, localDiagnostics, typeSyntax); 1106if (localSymbol.Scope == ScopedKind.ScopedValue && !declTypeOpt.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 2105conversionError(diagnostics, ErrorCode.ERR_ExpressionTreeMustHaveDelegate, ((NamedTypeSymbol)targetType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 2568var targetElementType = targetElementTypes[i].Type; 3314type = this.BindType(declaration.Type, diagnostics).Type;
Binder\Binder_Symbols.cs (8)
338if (symbol.TypeWithAnnotations.IsResolved) ReportDiagnosticsIfUnsafeMemberAccess(diagnostics, symbol.TypeWithAnnotations.Type, syntax); 542else if (LazyMissingNonNullTypesContextDiagnosticInfo.IsNullableReference(typeArgument.Type)) 566ReportUseSite(constructedType.Type.OriginalDefinition, diagnostics, syntax); 567var type = (NamedTypeSymbol)constructedType.Type; 610CheckManagedAddr(Compilation, elementType.Type, node.Location, diagnostics); 625if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8()) 650Error(diagnostics, ErrorCode.ERR_ArrayOfStaticClass, node.ElementType, type.Type); 661Error(diagnostics, ErrorCode.ERR_ArrayElementCantBeRefAny, node.ElementType, type.Type);
Binder\Binder_TupleOperators.cs (1)
392.SelectAsArray((t, s) => (BoundExpression)new BoundTupleOperandPlaceholder(s, t.Type), expr.Syntax);
Binder\Binder_Unsafe.cs (2)
63typeArguments[i].Type is NamedTypeSymbol typeArgument) 79typeSymbol.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[i].Type is NamedTypeSymbol typeArgument)
Binder\ForEachEnumeratorInfo.cs (2)
25public TypeSymbol ElementType => ElementTypeWithAnnotations.Type; 110public TypeSymbol ElementType => ElementTypeWithAnnotations.Type;
Binder\ForEachLoopBinder.cs (13)
200var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, inferredType.Type ?? CreateErrorType("var")); 326CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax); 328if (local.Scope == ScopedKind.ScopedValue && !declType.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 385var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, iterationVariableType.Type).MakeCompilerGenerated(); 441hasErrors = hasErrors || boundIterationVariableType.HasErrors || iterationVariableType.Type.IsErrorType(); 484Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 488Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 492var elementPlaceholder = new BoundValuePlaceholder(_syntax, inferredType.Type).MakeCompilerGenerated(); 500diagnostics.Add(ErrorCode.ERR_AmbigUDConv, foreachKeyword.GetLocation(), originalUserDefinedConversions[0], originalUserDefinedConversions[1], inferredType.Type, iterationVariableType); 504SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, inferredType.Type, iterationVariableType.Type); 516BoundExpression elementConversion = CreateConversion(_syntax, elementPlaceholder, elementConversionClassification, isCast: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, iterationVariableType.Type, createConversionDiagnostics);
Binder\RefSafetyAnalysis.cs (1)
1333var safeContext = node.Elements.Length == 0 || LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(node, elementType.Type)
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)
166var elementType = elementTypeWithAnnotations.Type; 176elementType = elementTypeWithAnnotations.Type;
Binder\Semantics\Conversions\ConversionsBase.cs (41)
1503!invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions)) 1618var delegateType = type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1895var type = typeWithAnnotations.Type; 1908Conversion conversion = ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo); 1976conversions.ClassifyImplicitExtensionMethodThisArgConversion(s, s.Type, d.Type, ref u, isMethodGroupConversion: false), 1998return conversions.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, s.Type, d.Type, ref u, isMethodGroupConversion: false); 2311=> conversions.ClassifyImplicitConversionFromExpression(s, d.Type, ref u), 2329conversions.ClassifyConversionFromExpression(s, d.Type, isChecked: isChecked, ref u, forCast: forCast), 2383Conversion conversion = conversions.ClassifyImplicitConversionFromType(s.Type, d.Type, ref u); 2405Conversion conversion = conversions.ClassifyConversionFromType(s.Type, d.Type, isChecked: isChecked, ref u, forCast); 2620return HasIdentityOrImplicitReferenceConversion(elementType.Type, argument0.Type, ref useSiteInfo); 2634HasIdentityConversionInternal(source.Type, destination.Type, includeNullability: true)) 2639return HasImplicitReferenceConversion(source.Type, destination.Type, ref useSiteInfo); 3202if (HasIdentityConversionInternal(sourceTypeArgument.Type, destinationTypeArgument.Type) && 3208TypeParameterSymbol typeParameterSymbol = (TypeParameterSymbol)typeParameters[paramIndex].Type; 3221TypeSymbol.Equals(destinationTypeArgument.Type, sourceTypeArgument.Type, TypeCompareKind.AllNullableIgnoreOptions) && 3441&& (HasIdentityOrImplicitReferenceConversion(sourceType.Type, destinationType.Type, ref useSiteInfo) 3442|| HasImplicitPointerToVoidConversion(sourceType.Type, destinationType.Type) 3443|| HasImplicitPointerConversion(sourceType.Type, destinationType.Type, ref useSiteInfo)); 3447&& HasIdentityConversion(sourceType.Type, destinationType.Type); 3708var sourceArg = sourceTypeArguments[i].Type; 3709var destinationArg = destinationTypeArguments[i].Type; 3791if (HasExplicitReferenceConversion(sourceArray.ElementType, ((NamedTypeSymbol)destination).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type, ref useSiteInfo)) 3811var sourceElement = ((NamedTypeSymbol)source).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type; 4028return HasIdentityConversionInternal(source.Type, destination.Type) && 4050return HasIdentityOrReferenceConversion(elementType.Type, spanElementType.Type, ref useSiteInfo) &&
Binder\Semantics\OverloadResolution\MethodTypeInference.cs (77)
470if (!fixedResultType.Type.IsErrorType()) 479var errorTypeName = fixedResultType.Type.Name; 508TypeParameterSymbol typeParameter = (TypeParameterSymbol)type.Type; 541var methodTypeParameter = (TypeParameterSymbol)methodTypeParameterWithAnnotations.Type; 575return typeMap.SubstituteType(delegateOrFunctionPointerType).Type; 615ExactOrBoundsKind kind = GetRefKind(arg).IsManagedReference() || target.Type.IsPointerType() ? ExactOrBoundsKind.Exact : ExactOrBoundsKind.LowerBound; 637if (argument.Kind == BoundKind.UnboundLambda && target.Type.GetDelegateType() is { }) 651if (IsReallyAType(argumentType.Type)) 657var ordinal = GetOrdinal((TypeParameterSymbol)target.Type); 670TypeSymbol targetType = target.Type; 705Debug.Assert(target.Type is { }); 706if (target.Type is null) 727if (target.Type.Kind != SymbolKind.NamedType) 733var destination = (NamedTypeSymbol)target.Type; 889if (HasUnfixedParamInOutputType(argument, formalType.Type) && !HasUnfixedParamInInputType(argument, formalType.Type)) 907if (!binder.TryGetCollectionIterationType((ExpressionSyntax)argument.Syntax, formalType.Type, out TypeWithAnnotations targetElementType)) 923if (formalType.Type.Kind != SymbolKind.NamedType) 929var destination = (NamedTypeSymbol)formalType.Type; 1146var formalParameterType = _formalParameterTypes[iArg].Type; 1388if (MethodGroupReturnTypeInference(binder, expression, target.Type, ref useSiteInfo)) 1410var delegateType = target.Type.GetDelegateType(); 1432Debug.Assert(inferredReturnType.Type is not FunctionTypeSymbol); 1571var delegateType = target.Type.GetDelegateType(); 1624var delegateInvokeMethod = target.Type.GetDelegateType()?.DelegateInvokeMethod(); 1669if (ExactSpanInference(source.Type, target.Type, ref useSiteInfo)) 1714if (!source.Type.IsArray() || !target.Type.IsArray()) 1719var arraySource = (ArrayTypeSymbol)source.Type; 1720var arrayTarget = (ArrayTypeSymbol)target.Type; 1809ExactOrBoundsInference(kind, ((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ((NamedTypeSymbol)target.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ref useSiteInfo); 1843if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) || 1844!target.Type.TryGetElementTypesWithAnnotationsIfTupleType(out targetTypes) || 1867var namedSource = source.Type as NamedTypeSymbol; 1873var namedTarget = target.Type as NamedTypeSymbol; 1892ExactInference(((PointerTypeSymbol)source.Type).PointedAtTypeWithAnnotations, ((PointerTypeSymbol)target.Type).PointedAtTypeWithAnnotations, ref useSiteInfo); 1895else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1896target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 2006if (LowerBoundArrayInference(source.Type, target.Type, ref useSiteInfo)) 2013if (LowerBoundSpanInference(source.Type, target.Type, ref useSiteInfo)) 2050if (LowerBoundConstructedInference(source.Type, target.Type, ref useSiteInfo)) 2055if (LowerBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2139if (elementSource.Type.IsReferenceType) 2174if (!sourceElementType.Type.IsReferenceType || target.IsSpan()) 2407if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.Out) 2411else if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.In) 2514Debug.Assert(source.Type.IsReferenceType || source.Type.IsFunctionPointer()); 2531if (UpperBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2566if (!target.Type.IsArray()) 2570var arrayTarget = (ArrayTypeSymbol)target.Type; 2572var elementSource = GetMatchingElementType(arrayTarget, source.Type, ref useSiteInfo); 2578if (elementSource.Type.IsReferenceType) 2599var source = sourceWithAnnotations.Type; 2600var target = targetWithAnnotations.Type; 2757if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.Out) 2761else if (sourceTypeArgument.Type.IsReferenceType && typeParameter.Variance == VarianceKind.In) 2851Debug.Assert(best.Type.Type.Equals(withoutNullability.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 3016functionType = type.Type as FunctionTypeSymbol; 3023return constraintTypes.Any(static t => isExpressionType(t.Type)); 3042var source = sourceWithAnnotations.Type; 3043var destination = destinationWithAnnotations.Type; 3319if (!dest.Type.ContainsTypeParameter(pParam)) 3463var newBound = TypeWithAnnotations.Create(oldBound.Type, newAnnotation); 3489if (newCandidate.Type.IsDynamic()) 3520return obj.Type.GetHashCode(); 3527if (x.Type.IsDynamic() ^ y.Type.IsDynamic()) { return false; }
Binder\Semantics\OverloadResolution\OverloadResolution.cs (20)
1266expandedResult.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel) 1355if (elementType.Type is null) 1377Debug.Assert(elementType.Type is { }); 2589Debug.Assert(paramsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 2590return paramsElementTypeOpt.Type; 3244t1, kind1, elementType1.Type, underlyingElementConversions1: [], 3245t2, kind2, elementType2.Type, underlyingElementConversions2: [], 3259elementType = typeArg.Type; 3302if (x.HasType && Conversions.HasIdentityConversion(x.Type, y)) 3312y = ((NamedTypeSymbol)y).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3405if (!ExpressionMatchExactly(sourceArguments[i], destTypes[i].Type, ref useSiteInfo)) 3552return BetterConversionTargetCore(((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3553((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3663var type1Element = ((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3664var type2Element = ((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 4083TryInferParamsCollectionIterationType(binder, type.Type, out paramsIterationType); 4356if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions)) 4604&& parameters.ParameterTypes[argumentPosition].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }) 4617parameters.ParameterTypes[argumentPosition].Type, 4629(ignoreOpenTypes && TypeContainsTypeParameterFromContainer(candidate, parameters.ParameterTypes[argumentPosition].Type))));
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (2)
1423Debug.Assert(badArg.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 1424return badArg.Result.ParamsElementTypeOpt.Type;
BoundTree\BoundDiscardExpression.cs (1)
16return this.Update(type.NullableAnnotation, isInferred: true, type.Type);
BoundTree\Constructors.cs (2)
485: this(syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, typeWithAnnotations.Type, hasErrors) 487Debug.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)
228if ((object)type.Type == NoReturnExpression) 240Debug.Assert(bestType.Type is not FunctionTypeSymbol); 426bool hasErrors = !types.IsDefault && types.Any(static t => t.Type?.Kind == SymbolKind.ErrorType); 513public TypeSymbol ParameterType(int index) { return ParameterTypeWithAnnotations(index).Type; } 658yield return type.Type; 667yield return type.Type; 880if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 975if (targetParameterTypes[i].Type.ContainsPointerOrFunctionPointer()) 1138value = Hash.Combine(type.Type, value); 1276if (!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\CodeGenerator.cs (2)
183var returnType = returnTypeWithAnnotations.Type; 209result = AllocateTemp(returnTypeWithAnnotations.Type, _boundBody.Syntax, slotConstraints);
CodeGen\EmitStackAllocInitializer.cs (1)
29: ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]).Type;
CodeGen\EmitStatement.cs (1)
1824Debug.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)
2355var array = (ArrayTypeSymbol)firstType.Type; 4398(t, a) => TypeWithAnnotations.Create(t.Type, a.ToInternalAnnotation())));
Compilation\CSharpSemanticModel.cs (3)
300crefSymbols = ImmutableArray.Create<Symbol>(binder.BindType(expression, BindingDiagnosticBag.Discarded).Type); 417NamedTypeSymbol attributeType = (NamedTypeSymbol)binder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type; 2783var 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 (6)
310var newType = (TypeSymbol?)v.Visit(t.Type); 316newType = t.Type; 539var otherType = type.WithTypeAndModifiers((TypeSymbol?)this.Visit(type.Type), this.VisitCustomModifiers(type.CustomModifiers)); 758return AreTypesEqual(type.Type, other.Type); 897var 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)
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)
266yield return moduleBeingBuilt.Translate(arg.Type,
Emitter\Model\NamedTypeSymbolAdapter.cs (1)
896var 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)
1175else if (!_alreadyReported[slot] && !symbol.GetTypeOrReturnType().Type.IsErrorType()) 1645TypeSymbol structType = variable.Symbol.GetTypeOrReturnType().Type; 1681TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type; 1717TypeSymbol 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 (93)
149Debug.Assert(TypeSymbol.Equals(RValueType.Type, LValueType.Type, TypeCompareKind.ConsiderEverything)); 806if (symbolType.Type.IsValueType || symbolType.Type.IsErrorType()) 839var badState = symbolType.Type.IsPossiblyNullableReferenceTypeTypeParameter() && (annotations & FlowAnalysisAnnotations.NotNull) == 0 897SetState(ref this.State, memberSlot, type.Type.IsPossiblyNullableReferenceTypeTypeParameter() ? NullableFlowState.MaybeDefault : NullableFlowState.MaybeNull); 2069_variables[containingSlot].Symbol.GetTypeOrReturnType().Type is NamedTypeSymbol { IsUnionType: true, UnionCaseTypes: not [] } unionType && 2424type.Type.IsValueType) 2441if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8() && !(type.Type is TypeParameterSymbol { IsNotNullable: true })) 2467!targetType.Type.Equals(valueType.Type, TypeCompareKind.AllIgnoreOptions)) 2700InheritDefaultState(targetType.Type, targetSlot); 2706if (targetType.Type.IsReferenceType || 2715else if (EmptyStructTypeCache.IsTrackableStructType(targetType.Type)) 2717InheritNullableStateOfTrackableStruct(targetType.Type, targetSlot, valueSlot, isDefaultValue: !(valueOpt is null) && IsDefaultValue(valueOpt), skipSlot: targetSlot); 2723target.Type.Equals(assignedValue.Type, TypeCompareKind.AllIgnoreOptions); 2795if (fieldOrPropertyType.Type.IsReferenceType || 2824else if (EmptyStructTypeCache.IsTrackableStructType(fieldOrPropertyType.Type)) 2834InheritNullableStateOfTrackableStruct(fieldOrPropertyType.Type, targetMemberSlot, valueMemberSlot, isDefaultValue: isDefaultValue, skipSlot); 2917private static TypeSymbol GetTypeOrReturnType(Symbol symbol) => symbol.GetTypeOrReturnType().Type; 2949typeWithAnnotations = TypeWithAnnotations.Create(typeWithAnnotations.Type, nullableAnnotation); 3050if (EmptyStructTypeCache.IsTrackableStructType(parameterType.Type)) 3053parameterType.Type, 3086return TypeWithState.Create(parameterType.Type, NullableFlowState.MaybeDefault); 3091return TypeWithState.Create(parameterType.Type, NullableFlowState.NotNull); 3115returnType.Type.SpecialType == SpecialType.System_Boolean) 3223type = ((NamedTypeSymbol)returnType.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single(); 3249if (!node.Type.Equals(type.Type, TypeCompareKind.ConsiderEverything | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamicAndTupleNames)) 3254Debug.Assert(node.Type.IsErrorType() || type.Type.IsErrorType()); 3617VisitObjectCreationInitializer(resultSlot, resultType.Type, withExpr.InitializerExpression, delayCompletionForType: false); 3695InheritDefaultState(GetDeclaredLocalResult(local).Type, slot); 3753Debug.Assert(type.Type.IsErrorType()); 3832return AnonymousTypeManager.GetAnonymousTypeFieldTypes(type).Any(static t => canIgnoreAnyType(t.Type)); 4184var strippedTargetCollectionType = targetCollectionType.Type.StrippedType(); 4358Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4360var type = resultTypeWithAnnotations.Type; 4437if (AreNullableAndUnderlyingTypes(type, parameterType.Type, out TypeWithAnnotations underlyingType)) 4871Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4929Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 5181inferredType = TypeWithState.Create(inferredType.Type, elementState).ToTypeWithAnnotations(compilation); 5777if (isLifted && targetTypeWithNullability.Type.IsNonNullableValueType()) 6162Debug.Assert(targetType.Type.ContainsErrorType() || 6164TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions)); 6168leftSlot = GetNullableOfTValueSlot(targetType.Type, leftSlot, out _); 6174Debug.Assert(TypeSymbol.Equals(targetType.Type, rightResult.Type, TypeCompareKind.AllIgnoreOptions)); 6178TypeWithState resultType = TypeWithState.Create(targetType.Type, rightResult.State); 6441TypeSymbol accessType = accessTypeWithAnnotations.Type; 6635var typeWithState = TypeWithState.Create(resultTypeWithAnnotations.Type, resultState); 6648return TypeWithState.Create(resultTypeWithAnnotations.Type, resultState); 6763new BoundExpressionWithNullability(expr.Syntax, expr, type.NullableAnnotation, type.Type); 8217conversion = GenerateConversion(_conversions, argumentNoConversion, argumentResultType, parameterType.Type, fromExplicitCast: false, extensionMethodThisArgument: false, isChecked: conversionOpt?.Checked ?? false); 8221ReportNullabilityMismatchInArgument(argumentNoConversion.Syntax, argumentResultType, parameter, parameterType.Type, forOutput: false); 8253if (IsNullabilityMismatch(lvalueResultType.Type, parameterType.Type)) 8256ReportNullabilityMismatchInRefArgument(argumentNoConversion, argumentType: lvalueResultType.Type, parameter, parameterType.Type); 8361parameterWithState = TypeWithState.Create(parameterType.Type, adjustedState); 8418if (!_conversions.HasIdentityOrImplicitReferenceConversion(parameterType.Type, lValueType.Type, ref discardedUseSiteInfo)) 8420ReportNullabilityMismatchInArgument(argument.Syntax, lValueType.Type, parameter, parameterType.Type, forOutput: true); 8674OverloadResolution.TryInferParamsCollectionIterationType(_binder, type.Type, out paramsIterationType); 8925return new BoundExpressionWithNullability(argument.Syntax, argument, argumentType.NullableAnnotation, argumentType.Type); 9240if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type)) 9353if (typeArg.Type.Equals(underlyingTypeOpt, TypeCompareKind.AllIgnoreOptions)) 9590Debug.Assert(targetField.TypeWithAnnotations.Type.StrippedType() is NamedTypeSymbol { IsUnionType: true }); 9834operandType = completion(targetTypeWithNullability.Type.GetNullableUnderlyingTypeWithAnnotations()); 9862TypeSymbol targetType = targetTypeWithNullability.Type; 10236if (targetType.Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == true) 10245dependsOnTypeParameter(typeParameter1, (TypeParameterSymbol)targetType.Type, NullableAnnotation.NotAnnotated, out var annotation)) 10252if (targetType.Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == false) 10276targetType.Type is TypeParameterSymbol typeParameter2) 10326if (constraintType.Type is TypeParameterSymbol constraintTypeParameter && 10437TypeSymbol targetType = targetTypeWithNullability.Type; 10594var resultType = TypeWithState.Create(targetTypeWithNullability.Type, NullableFlowState.NotNull); 10605Debug.Assert(TypeSymbol.Equals(targetTypeWithNullability.Type.StrippedType(), analysis.Operator.MethodKind == MethodKind.Constructor ? analysis.Operator.ContainingType : analysis.Operator.ReturnType, TypeCompareKind.AllIgnoreOptions)); 10606Debug.Assert(TypeSymbol.Equals(targetTypeWithNullability.Type.StrippedType(), analysis.ToType, TypeCompareKind.AllIgnoreOptions)); 10624TypeSymbol targetType = targetTypeWithNullability.Type; 10641Debug.Assert(TypeSymbol.Equals(analysis.FromType, parameterType.Type, TypeCompareKind.AllIgnoreOptions)); 10695targetTypeWithNullability.Type.StrippedType() is NamedTypeSymbol { IsUnionType: true } unionType && 10777bool typeNeedsLifting = returnType.Type.IsNonNullableValueType(); 10778TypeSymbol type = typeNeedsLifting ? MakeNullableOf(returnType) : returnType.Type; 10822var conversion = _conversions.ClassifyStandardConversion(operandType.Type, targetType.Type, ref discardedUseSiteInfo); 10827ReportNullabilityMismatchInArgument(diagnosticLocation, operandType.Type, parameterOpt, targetType.Type, forOutput: false); 10831ReportNullabilityMismatchInAssignment(diagnosticLocation, operandType.Type, targetType.Type); 10912Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 10913var delegateType = (NamedTypeSymbol)resultTypeWithAnnotations.Type; 11092arguments.Add(new BoundExpressionWithNullability(syntax, new BoundParameter(syntax, parameter), parameterType.NullableAnnotation, parameterType.Type)); 11265SetResult(node, TypeWithState.Create(leftLValueType.Type, rightState.State), leftLValueType); 11603AreNullableAndUnderlyingTypes(lvalueType.Type, operandType.Type, out TypeWithAnnotations underlyingType)) 11608var valueBeforeNullableWrapping = TypeWithState.Create(underlyingType.Type, NullableFlowState.NotNull); 11609TrackNullableStateOfNullableValue(targetSlot, lvalueType.Type, rightPart, valueBeforeNullableWrapping, valueSlot); 12627conversion = _conversions.ClassifyImplicitConversionFromType(sourceType.Type, destinationType.Type, ref discardedUseSiteInfo);
FlowAnalysis\NullableWalker_Patterns.cs (8)
637inferredType = TypeWithAnnotations.Create(inferredType.Type, existingType.NullableAnnotation.Join(inferredType.NullableAnnotation)); 703addToTempMap(output, outputSlot, parameterType.Type); 771addToTempMap(output, outputSlot, type.Type); 786addToTempMap(output, outputSlot, type.Type); 794addToTempMap(output, outputSlot, type.Type); 805addToTempMap(output, outputSlot, type.Type); 816addToTempMap(output, outputSlot, type.Type); 1122TypeWithState 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\BoundTreeToDifferentEnclosingContextRewriter.cs (1)
117return TypeMap.SubstituteType(type).Type;
Lowering\ClosureConversion\ClosureConversion.cs (5)
1009while (!TypeSymbol.Equals(oldTypeArg.Type, newTypeArg.Type, TypeCompareKind.ConsiderEverything)); 1013Debug.Assert((object)oldTypeArg.Type == newTypeArg.Type); 1708var cacheVariableType = containerAsFrame.TypeMap.SubstituteType(node.Type).Type;
Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)
743var intermediate = nullable.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 867_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name));
Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)
136return 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)
75var fieldType = TypeParameters.IsEmpty ? delegateType : TypeMap.SubstituteType(delegateType).Type;
Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (6)
334ShouldUseRuntimeHelpersCreateSpan(node, elementType.Type)) 337Debug.Assert(!IsAllocatingRefStructCollectionExpression(node, CollectionExpressionTypeKind.ReadOnlySpan, elementType.Type, _compilation)); 341return _factory.New(constructor, _factory.Array(elementType.Type, rewrittenElements)); 347Debug.Assert(!IsAllocatingRefStructCollectionExpression(node, isReadOnlySpan ? CollectionExpressionTypeKind.ReadOnlySpan : CollectionExpressionTypeKind.Span, elementType.Type, _compilation)); 1025asSpanMethod = collectionsMarshalAsSpanMethod.Construct(namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 1278var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
Lowering\LocalRewriter\LocalRewriter_Conversion.cs (6)
96var byteType = ((NamedTypeSymbol)node.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 617createSpan = createSpan.Construct(rewrittenOperand.Type, spanType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type); 641TypeSymbol parameterType = method.ParameterTypesWithAnnotations[0].Type; 670Debug.Assert(implicitOperator.ParameterTypesWithAnnotations[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 704Debug.Assert(method.ParameterTypesWithAnnotations[0].Type.Equals(rewrittenOperand.Type, TypeCompareKind.AllIgnoreOptions)); 1039var 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; 124constantValueOpt: null, destElementTypes[i].Type, boundConversion.HasErrors); 483conversionGroupOpt: null, InConversionGroupFlags.TupleBinaryOperatorPendingLowering, constantValueOpt: null, type: type.Type);
Lowering\MethodToClassRewriter.cs (1)
148visitedTypeArgs.Add(typeArg.WithTypeAndModifiers(VisitType(typeArg.Type), typeArg.CustomModifiers));
Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)
328proxy = new CapturedToStateMachineFieldReplacement(GetOrAllocateReusableHoistedField(TypeMap.SubstituteType(local.Type).Type, out reused, local), isReusable: true);
Lowering\StateMachineRewriter\RefInitializationHoister.cs (1)
96var type = _typeMap.SubstituteType(local.Type).Type;
Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)
189var fieldType = typeMap.SubstituteType(local.Type).Type; 259var proxyField = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, parameter, isPublic: !PreserveInitialParameterValuesAndThreadId); 264var field = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), parameter, isPublic: true);
Lowering\SyntheticBoundNodeFactory.cs (2)
1265return new BoundPointerIndirectionOperator(Syntax, Default(new PointerTypeSymbol(type)), refersToLocation: false, type.Type); 1315return 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\AbstractTypeParameterMap.cs (1)
45result.Append(' ').Append(kv.Key).Append(':').Append(kv.Value.Type);
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)
230var original = TypeWithAnnotations.Create(genericFieldTypes[index].Type);
Symbols\ArrayTypeSymbol.cs (2)
217return _elementTypeWithAnnotations.Type; 524var newInterfaces = _interfaces.SelectAsArray((i, t) => i.OriginalDefinition.Construct(t), newElementType.Type);
Symbols\Compilation_WellKnownMembers.cs (2)
1069twa.Type.VisitType(visitor, (transformFlagsBuilder, addCustomModifierFlags)); 1152return 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; 956if (typeArgument.Type.IsPointerOrFunctionPointer() || typeArgument.IsRestrictedType(ignoreSpanLikeTypes: true) || typeArgument.IsVoidType()) 959diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BadTypeArgument, typeArgument.Type)))); 963if (typeArgument.Type.IsRefLikeOrAllowsRefLikeType()) 984diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NotRefStructConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 992diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_GenericArgIsStaticClass, typeArgument.Type)))); 998if (!typeArgument.Type.IsReferenceType) 1001diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_RefConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1011var managedKind = typeArgument.Type.GetManagedKind(ref useSiteInfo); 1014if (managedKind == ManagedKind.Managed || !typeArgument.Type.IsNonNullableValueType()) 1017diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_UnmanagedConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1040if (typeParameter.HasValueTypeConstraint && !typeArgument.Type.IsNonNullableValueType()) 1043diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_ValConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1069if (typeArgument.Type.IsErrorType()) 1091if (typeArgument.Type is NamedTypeSymbol { IsInterface: true } iface && SelfOrBaseHasStaticAbstractMember(iface, ref useSiteInfo, out Symbol member)) 1120var error = SatisfiesConstructorConstraint(typeArgument.Type); 1128diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1132diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintCannotHaveRequiredMembers, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1149if (typeParameter.HasNotNullConstraint && typeArgument.GetValueNullableAnnotation().IsAnnotated() && !typeArgument.Type.IsNonNullableValueType()) 1189if (typeArgument.Type.IsReferenceType) 1195errorCode = constraintType.Type.IsInterfaceType() ? ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface : ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum; 1209if (constraintType.Type.Equals(typeArgument.Type, TypeCompareKind.AllIgnoreOptions)) 1211constraintTypeErrorArgument = constraintType.Type; 1212typeArgumentErrorArgument = typeArgument.Type; 1217SymbolDistinguisher distinguisher = new SymbolDistinguisher(args.CurrentCompilation, constraintType.Type, typeArgument.Type); 1228var type = typeWithAnnotations.Type; 1271var type = typeWithAnnotations.Type; 1350if (constraintType.Type.IsErrorType()) 1361if (conversions.HasIdentityOrImplicitReferenceConversion(typeArgument.Type, constraintType.Type, ref useSiteInfo)) 1366if (typeArgument.Type.IsValueType) 1370if (conversions.HasBoxingConversion(typeArgument.Type.IsNullableType() ? ((NamedTypeSymbol)typeArgument.Type).ConstructedFrom : typeArgument.Type, 1371constraintType.Type, ref useSiteInfo)) 1376if (typeArgument.Type is NamedTypeSymbol { IsRefLikeType: true } refLike && 1377conversions.ImplementsVarianceCompatibleInterface(refLike, constraintType.Type, ref useSiteInfo)) 1385var typeParameter = (TypeParameterSymbol)typeArgument.Type; 1389if (conversions.HasImplicitTypeParameterConversion(typeParameter, constraintType.Type, ref useSiteInfo))
Symbols\DiscardSymbol.cs (1)
15Debug.Assert(typeWithAnnotations.Type is object);
Symbols\EventSymbol.cs (1)
59public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\Extensions\SynthesizedExtensionMarker.cs (1)
90TypeSymbol parameterType = parameter.TypeWithAnnotations.Type;
Symbols\FieldSymbol.cs (1)
75public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\LocalSymbol.cs (1)
83public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\MemberSignatureComparer.cs (1)
727result.Add(SubstituteType(typeMap, type).Type);
Symbols\MemberSymbolExtensions.cs (5)
358if (parameterType.Type.ContainsPointerOrFunctionPointer()) 452count += methodReturnType.Type.CustomModifierCount(); 458count += paramType.Type.CustomModifierCount(); 501count += type.Type.CustomModifierCount(); 507count += 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)
93TypeSymbol originalEventType = _eventTypeWithAnnotations.Type; 173TypeSymbol.Equals(_eventTypeWithAnnotations.Type, ((NamedTypeSymbol)candidateAssociatedFieldType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, TypeCompareKind.ConsiderEverything2)) 180if (TypeSymbol.Equals(candidateAssociatedFieldType, _eventTypeWithAnnotations.Type, TypeCompareKind.ConsiderEverything2))
Symbols\Metadata\PE\PEFieldSymbol.cs (1)
358_lazyFixedImplementationType = type.Type as NamedTypeSymbol;
Symbols\Metadata\PE\PENamedTypeSymbol.cs (2)
773baseType = (NamedTypeSymbol)NullableTypeDecoder.TransformType(TypeWithAnnotations.Create(decodedType), _handle, moduleSymbol, accessSymbol: this, nullableContext: this).Type; 833typeSymbol = NullableTypeDecoder.TransformType(TypeWithAnnotations.Create(typeSymbol), interfaceImpl, moduleSymbol, accessSymbol: this, nullableContext: this).Type;
Symbols\Metadata\PE\PEParameterSymbol.cs (2)
309var typeSymbol = DynamicTypeDecoder.TransformType(typeWithAnnotations.Type, countOfCustomModifiers, handle, moduleSymbol, refKind); 337else 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)
256public TypeSymbol ReturnType => ReturnTypeWithAnnotations.Type; 923internal TypeSymbol GetParameterType(int index) => ParameterTypesWithAnnotations[index].Type; 1178if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1180AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 1183if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1185AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1188if (type.Type.ContainsTupleNames() && compilation.HasTupleNamesAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1190AddSynthesizedAttribute(ref attributes, compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\NamedTypeSymbol.cs (5)
78typeArgument.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 87result.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 1404internal static readonly Func<TypeWithAnnotations, bool> TypeWithAnnotationsIsErrorType = type => type.HasType && type.Type.IsErrorType(); 1515builder.Add(argument.Type); 2038typeToCheck = ((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)
77public 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 (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)) 1119if (TypeSymbol.Equals(retargetedEvent.Type, targetType.Type, TypeCompareKind.ConsiderEverything2))
Symbols\SignatureOnlyParameterSymbol.cs (4)
30Debug.Assert((object)type.Type != null); 124TypeSymbol.Equals(_type.Type, other._type.Type, compareKind) && 135_type.Type.GetHashCode(),
Symbols\Source\CustomModifierUtils.cs (2)
48TypeSymbol returnTypeSymbol = returnType.Type; 56TypeSymbol returnTypeWithCustomModifiers = sourceMethodReturnType.Type;
Symbols\Source\ExplicitInterfaceHelpers.cs (1)
58explicitInterfaceTypeOpt = binder.BindType(explicitInterfaceName, diagnostics).Type;
Symbols\Source\FieldSymbolWithAttributesAndModifiers.cs (6)
401if (type.Type.ContainsDynamic()) 404compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 407if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 409AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 412if (type.Type.ContainsTupleNames()) 415compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Source\GlobalExpressionVariable.cs (2)
137TypeSymbol.Equals(originalType, type.Type, TypeCompareKind.ConsiderEverything2)); 141TypeChecks(type.Type, diagnostics);
Symbols\Source\LambdaSymbol.cs (1)
172Debug.Assert((object)_returnType.Type == ReturnTypeIsBeingInferred);
Symbols\Source\LocalFunctionOrSourceMemberMethodSymbol.cs (2)
38Debug.Assert(TypeSymbol.Equals(_lazyIteratorElementType.Value.Type, elementType.Type, TypeCompareKind.ConsiderEverything));
Symbols\Source\LocalFunctionSymbol.cs (2)
281if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 298diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);
Symbols\Source\ParameterHelpers.cs (2)
885typeWithAnnotations.Type); 899diagnostics.Add(ErrorCode.ERR_MethodArgCantBeRefAny, syntax.Location, typeWithAnnotations.Type);
Symbols\Source\SourceComplexParameterSymbol.cs (11)
1094else if (!compilation.Conversions.HasCallerLineNumberConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1098diagnostics.Add(ErrorCode.ERR_NoConversionForCallerLineNumberParam, node.Name.Location, intType, TypeWithAnnotations.Type); 1122else if (!compilation.Conversions.HasCallerInfoStringConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1126diagnostics.Add(ErrorCode.ERR_NoConversionForCallerFilePathParam, node.Name.Location, stringType, TypeWithAnnotations.Type); 1155else if (!compilation.Conversions.HasCallerInfoStringConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1159diagnostics.Add(ErrorCode.ERR_NoConversionForCallerMemberNameParam, node.Name.Location, stringType, TypeWithAnnotations.Type); 1196else if (!compilation.Conversions.HasCallerInfoStringConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1200diagnostics.Add(ErrorCode.ERR_NoConversionForCallerArgumentExpressionParam, node.Name.Location, stringType, TypeWithAnnotations.Type); 1615var elementType = elementTypeWithAnnotations.Type; 1628elementType = elementTypeWithAnnotations.Type; 1687elementType = elementTypeWithAnnotations.Type;
Symbols\Source\SourceDelegateMethodSymbol.cs (1)
68diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);
Symbols\Source\SourceEventSymbol.cs (8)
393if (type.Type.ContainsDynamic()) 395AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 398if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 400AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 403if (type.Type.ContainsTupleNames()) 406DeclaringCompilation.SynthesizeTupleNamesAttribute(type.Type)); 741if (type.Type.Equals(overriddenEventType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 743type = type.WithTypeAndModifiers(CustomModifierUtils.CopyTypeCustomModifiers(overriddenEventType, type.Type, containingAssembly),
Symbols\Source\SourceLocalSymbol.cs (3)
486Debug.Assert(newType.Type is object); 493originalType.Value.DefaultType.IsErrorType() && newType.Type.IsErrorType() || 497(newType.Type != (object)DeclaringCompilation.ImplicitlyTypedVariableInferenceFailedType ||
Symbols\Source\SourceMemberContainerSymbol.cs (4)
4644var propertyParamType = (((i == numParams - 1) && !getNotSet) ? propertySymbol.TypeWithAnnotations : propertyParams[i].TypeWithAnnotations).Type; 5006Conversion c = compilation.Conversions.ClassifyImplicitConversionFromType(parameterType.Type, compilation.GetSpecialType(SpecialType.System_Object), ref useSiteInfo); 5009if (!SynthesizedUnionCtor.IsValidParameterTypeConversion(c) && !parameterType.Type.IsErrorType()) 5011diagnostics.Add(ErrorCode.ERR_NoImplicitConversionToObject, typeSyntax, parameterType.Type);
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (16)
811if (IsOrContainsErrorType(parameterType.Type)) 980if (!IsOrContainsErrorType(overridingMemberType.Type)) 982diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1026if (DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMethod.ReturnTypeWithAnnotations.Type, overriddenMethod.ReturnTypeWithAnnotations.Type, ref discardedUseSiteInfo)) 1091if (!IsOrContainsErrorType(overridingMemberType.Type)) 1096DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMemberType.Type, overriddenMemberType.Type, ref discardedUseSiteInfo)) 1100diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantPropertiesOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1112diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1240var result = DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingReturnType.Type, overriddenReturnType.Type, ref useSiteInfo); 1305overrideReturnType.Type, 1306baseMethod.ReturnTypeWithAnnotations.Type)) 1338baseParameterType.Type, 1339overrideParameterType.Type))
Symbols\Source\SourceMemberFieldSymbol.cs (3)
544if (type.Type.IsRefLikeOrAllowsRefLikeType()) 617var elementType = ((PointerTypeSymbol)type.Type).PointedAtType; 632TypeChecks(type.Type, diagnostics);
Symbols\Source\SourceMemberMethodSymbol.cs (3)
365diagnostics.Add(code, GetFirstLocation(), this, returnType.Type); 407if (returnType.Type.HasFileLocalTypes()) 409diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, GetFirstLocation(), returnType.Type, containingType);
Symbols\Source\SourceMethodSymbolWithAttributes.cs (1)
1602ParameterTypesWithAnnotations.Any(static (p, cancellationTokenType) => p.Type.Equals(cancellationTokenType), cancellationTokenType))
Symbols\Source\SourceNamedTypeSymbol.cs (2)
64TypeSymbol bt = baseBinder.BindType(t, BindingDiagnosticBag.Discarded).Type; 2035if (!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(), 526baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type; 595baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type;
Symbols\Source\SourceNamedTypeSymbol_Enum.cs (1)
62var type = baseBinder.BindType(typeSyntax, diagnostics).Type;
Symbols\Source\SourceNamedTypeSymbol_Extension.cs (10)
70AppendClrType(extendedType.Type, extendedType.CustomModifiers, builder); 122AppendClrType(typeConstraint.Type, typeConstraint.CustomModifiers, constraintBuilder.Builder); 174AppendClrType(pointedAtType.Type, pointedAtType.CustomModifiers, builder); 255AppendClrType(typeArgument.Type, typeArgument.CustomModifiers, builder); 284AppendClrType(elementType.Type, elementType.CustomModifiers, builder); 315AppendClrType(returnType.Type, returnType.CustomModifiers, builder); 333AppendClrType(parameterType.Type, parameterType.CustomModifiers, builder); 435appendType(type.Type, builder); 438if (!type.Type.IsValueType) 1003AppendClrType(parameterType.Type, parameterType.CustomModifiers, builder);
Symbols\Source\SourceOrdinaryMethodSymbol.cs (5)
151diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType.Type); 213if (!parameter0Type.Type.IsValidExtensionParameterType()) 219diagnostics.Add(ErrorCode.ERR_BadTypeforThis, loc, parameter0Type.Type); 221else if (parameter0RefKind == RefKind.Ref && !parameter0Type.Type.IsValueType) 226&& !parameter0Type.Type.IsValidInOrRefReadonlyExtensionParameterType())
Symbols\Source\SourceParameterSymbolBase.cs (6)
98if (type.Type.ContainsDynamic()) 100AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + parameter.RefCustomModifiers.Length, parameter.RefKind)); 103if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 105AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(parameter, type.Type)); 113if (type.Type.ContainsTupleNames()) 116compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Source\SourcePropertyAccessorSymbol.cs (2)
324CustomModifierUtils.CopyTypeCustomModifiers(type.Type, _lazyReturnType.Type, this.ContainingAssembly),
Symbols\Source\SourcePropertySymbol.cs (3)
584diagnostics.Add((this.IsIndexer ? ErrorCode.ERR_BadVisIndexerReturn : ErrorCode.ERR_BadVisPropertyType), Location, this, type.Type); 587if (type.Type.HasFileLocalTypes()) 597diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, type.Type, containingType);
Symbols\Source\SourcePropertySymbolBase.cs (10)
258if (type.Type.Equals(overriddenPropertyType.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 261CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1406if (type.Type.ContainsDynamic()) 1409compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + RefCustomModifiers.Length, _refKind)); 1412if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1414AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1417if (type.Type.ContainsTupleNames()) 1420compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Source\SourceTypeParameterSymbol.cs (2)
267if (!diagnostics.ReportUseSite(constraintType.Type, args.Args.Location)) 269constraintType.Type.CheckAllConstraints(args);
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (4)
350diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type); 353if (returnType.Type.IsStatic) 358diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(useWarning: false), returnTypeSyntax.Location, returnType.Type); 929p.ConstraintTypesNoUseSiteDiagnostics.Any((typeArgument, containingType) => typeArgument.Type.Equals(containingType, ComparisonForUserDefinedOperators),
Symbols\Source\TypeParameterConstraintClause.cs (2)
173TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType; 233TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType;
Symbols\SubstitutedFieldSymbol.cs (1)
105return (NamedTypeSymbol)_containingType.TypeSubstitution.SubstituteType(OriginalDefinition.FixedImplementationType(emitModule)).Type;
Symbols\SubstitutedMethodSymbol.cs (3)
183Debug.Assert(notUsed.Type is null && OriginalDefinition.ReducedFrom is not null); 408code = Hash.Combine(arg.Type, code); 429typeArguments[i].Type,
Symbols\Symbol.cs (1)
1247return DeriveUseSiteInfoFromType(ref result, type.Type) ||
Symbols\Symbol_Attributes.cs (1)
556var 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)
651Debug.Assert(TypeSymbol.Equals(initializeResult.Type, _returnType.Type, TypeCompareKind.ConsiderEverything2));
Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)
54var type = typeWithAnnotations.Type;
Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)
277MergeUseSiteInfo(ref result, ReturnTypeWithAnnotations.Type.GetUseSiteInfo());
Symbols\Synthesized\SynthesizedParameterSymbol.cs (6)
154if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None) && compilation.CanEmitBoolean()) 156AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 159if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 161AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 169if (type.Type.ContainsTupleNames() && 174compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Tuples\TupleFieldSymbol.cs (1)
225newUnderlyingOwner = (NamedTypeSymbol)newUnderlyingOwner.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type;
Symbols\Tuples\TupleTypeSymbol.cs (5)
144underlyingType = ((NamedTypeSymbol)underlyingType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type); 212currentType = (NamedTypeSymbol)currentType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type; 711currentValueTuple = (NamedTypeSymbol)oldUnderlying.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestIndex].Type; 792found = (NamedTypeSymbol)found.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type; 984var extensionTupleElementTypes = tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type.TupleElementTypesWithAnnotations;
Symbols\TypeMap.cs (1)
23public static readonly Func<TypeWithAnnotations, TypeSymbol> AsTypeSymbol = t => t.Type;
Symbols\TypeParameterSymbol.cs (5)
100((TypeSymbol)constraint.Type.OriginalDefinition).AddUseSiteInfo(ref useSiteInfo); 441if (ConstraintImpliesReferenceType(constraintType.Type)) 472if (constraintType.Type.IsNonNullableValueType()) 487bool? isNotNullable = ((TypeParameterSymbol)constraintType.Type).IsNotNullable; 511if (constraintType.Type.IsValueType)
Symbols\TypeParameterSymbolExtensions.cs (1)
23if (constraintType.Type is TypeParameterSymbol typeParameter)
Symbols\TypeSymbolExtensions.cs (15)
123if (constraintType.Type.IsNullableTypeOrTypeParameter()) 155return type.GetNullableUnderlyingTypeWithAnnotations().Type; 163underlyingType = nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 483type = ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 794/// instead of <see cref="TypeWithAnnotations.Type"/> to avoid early resolution of nullable types</param> 816TypeSymbol current = type ?? (useDefaultType ? typeWithAnnotationsOpt.DefaultType : typeWithAnnotationsOpt.Type); 1339return type.Type?.ContainsNativeIntegerWrapperType() == true; 1682code = Hash.Combine(arg.Type, code); 1704typeArguments[i].Type.OriginalDefinition, 2038var type = typeWithAnnotations.Type; 2060var typeArgNormalized = typeWithModifier.Type; 2178if (type.Type.ContainsTupleNames()) 2180addIfNotNull(builder, compilation.SynthesizeTupleNamesAttribute(type.Type)); 2182if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 2184addIfNotNull(builder, moduleBuilder.SynthesizeNativeIntegerAttribute(declaringSymbol, type.Type));
Symbols\TypeUnification.cs (25)
36return (NamedTypeSymbol)SubstituteAllTypeParameters(substitution, TypeWithAnnotations.Create(candidateSubtype)).Type; 54Debug.Assert(substituted1.Type.Equals(substituted2.Type, TypeCompareKind.CLRSignatureCompareOptions)); 111if (TypeSymbol.Equals(t1.Type, t2.Type, TypeCompareKind.CLRSignatureCompareOptions) && t1.CustomModifiers.SequenceEqual(t2.CustomModifiers)) 118if (!t1.Type.IsTypeParameter() && t2.Type.IsTypeParameter()) 126Debug.Assert(t1.Type.IsTypeParameter() || !t2.Type.IsTypeParameter()); 128switch (t1.Type.Kind) 137ArrayTypeSymbol at1 = (ArrayTypeSymbol)t1.Type; 138ArrayTypeSymbol at2 = (ArrayTypeSymbol)t2.Type; 154PointerTypeSymbol pt1 = (PointerTypeSymbol)t1.Type; 155PointerTypeSymbol pt2 = (PointerTypeSymbol)t2.Type; 167NamedTypeSymbol nt1 = (NamedTypeSymbol)t1.Type; 168NamedTypeSymbol nt2 = (NamedTypeSymbol)t2.Type; 204if (t2.Type.IsPointerOrFunctionPointer() || t2.IsVoidType()) 209TypeParameterSymbol tp1 = (TypeParameterSymbol)t1.Type; 213if (Contains(t2.Type, tp1)) 226AddSubstitution(ref substitution, tp1, TypeWithAnnotations.Create(t2.Type)); 234TypeWithAnnotations.Create(t2.Type, 239if (t2.Type.IsTypeParameter()) 241var tp2 = (TypeParameterSymbol)t2.Type; 253TypeWithAnnotations.Create(t1.Type, 301if (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)
267IsVarianceUnsafe(constraintType.Type, 389TypeSymbol typeArg = namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[i].Type;
Utilities\TypeSymbolExtensions.cs (2)
76=> typeWithAnnotations.CustomModifiers.Length + typeWithAnnotations.Type.CustomModifierCount(); 158=> typeWithAnnotations.CustomModifiers.Any() || typeWithAnnotations.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds);