807 references to Type
Microsoft.CodeAnalysis.CSharp (807)
Binder\Binder.NamespaceOrTypeOrAliasSymbolWithAnnotations.cs (1)
37internal Symbol Symbol => _symbol ?? TypeWithAnnotations.Type;
Binder\Binder.ValueChecks.cs (3)
4632Debug.Assert(elementType.Type is { }); 4633return !LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, elementType.Type); 4653if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type))
Binder\Binder_Attributes.cs (3)
55var boundTypeSymbol = (NamedTypeSymbol)boundType.Type; 403if (!paramType.Type.IsValidAttributeParameterType(Compilation)) 405Error(diagnostics, ErrorCode.ERR_BadAttributeParamType, syntax, parameter.Name, paramType.Type);
Binder\Binder_Constraints.cs (9)
455diagnostics.Add(ErrorCode.ERR_BadVisBound, location, containingSymbol, constraintType.Type); 458if (constraintType.Type.HasFileLocalTypes()) 471diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, location, constraintType.Type, containingSymbol); 499Error(diagnostics, ErrorCode.ERR_DuplicateBound, syntax, type.Type.SetUnknownNullabilityForReferenceTypes(), typeParameter.Name); 513Error(diagnostics, ErrorCode.ERR_ClassBoundNotFirst, syntax, type.Type); 528Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 537Error(diagnostics, ErrorCode.ERR_RefValBoundWithClass, syntax, type.Type); 543Error(diagnostics, ErrorCode.ERR_UnmanagedBoundWithClass, syntax, type.Type); 561TypeSymbol type = typeWithAnnotations.Type;
Binder\Binder_Conversions.cs (14)
384new BoundValuePlaceholder(source.Syntax, sourceTypes[i].Type), 389destTypes[i].Type, 613var sourceElementType = ((NamedTypeSymbol)source).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 614var destinationElementType = ((NamedTypeSymbol)destination).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 644typeArgument.Type.IsReferenceType && 646((NamedTypeSymbol)parameter.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(typeArgument.Type, TypeCompareKind.ConsiderEverything) && 648((NamedTypeSymbol)method.ReturnType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type.Equals(((NamedTypeSymbol)arg.destination).TypeParameters[0], TypeCompareKind.ConsiderEverything)); 1048collectionBuilderMethod = GetCollectionBuilderMethod(namedType, elementTypeOriginalDefinition.Type, builderType, methodName, ref useSiteInfo, out collectionBuilderReturnTypeConversion); 1064elementType = parameterType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1764Debug.Assert(elementTypeWithAnnotations.Type is null); // GetCollectionExpressionTypeKind() does not set elementType for these cases. 1785var elementType = elementTypeWithAnnotations.Type; 1906var spanTypeArg = ((NamedTypeSymbol)methodWithTargetTypeParameters.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 2501convertedArguments.Add(CreateConversion(argument.Syntax, argument, elementConversion, isCast: isCast, elementConversionGroup, destType.Type, diagnostics));
Binder\Binder_Crefs.cs (3)
590if (ContainsNestedTypeOfUnconstructedGenericType(typeArgument.Type)) 905(!unusedDiagnostics.HasAnyErrors() && typeArgument.Type is CrefTypeParameterSymbol)); 974TypeSymbol type = parameterOrReturnTypeBinder.BindType(typeSyntax, localDiagnostics).Type;
Binder\Binder_Deconstruct.cs (7)
856var type = declTypeWithAnnotations.Type; 896CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeWithAnnotations.Type, diagnostics, typeSyntax); 900localSymbol.Scope == ScopedKind.ScopedValue && !declTypeWithAnnotations.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 913return new BoundLocal(syntax, localSymbol, BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declTypeWithAnnotations.Type, hasErrors: hasErrors); 951Debug.Assert(TypeSymbol.Equals(declTypeWithAnnotations.Type, fieldType.Type, TypeCompareKind.ConsiderEverything2)); 958type: fieldType.Type);
Binder\Binder_Expressions.cs (35)
457field.GetFieldType(initializerBinder.FieldsBeingBound).Type, diagnostics); 1241return new BoundRefValueOperator(node, typeWithAnnotations.NullableAnnotation, argument, typeWithAnnotations.Type, hasErrors); 1381TypeSymbol type = typeWithAnnotations.Type; 1409var type = typeWithAnnotations.Type; 1434TypeSymbol type = typeWithAnnotations.Type; 1574TypeSymbol type = typeWithAnnotations.Type; 2586TypeSymbol targetType = targetTypeWithAnnotations.Type; 2748TypeSymbol targetType = targetTypeWithAnnotations.Type; 2906var targetElementType = targetElementTypesWithAnnotations[i].Type; 2933TypeWithAnnotations underlyingTargetTypeWithAnnotations = targetTypeWithAnnotations.Type.GetNullableUnderlyingTypeWithAnnotations(); 2934var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3178var type = declType.Type; 3234CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax); 3236if (localSymbol.Scope == ScopedKind.ScopedValue && !declType.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 3241return new BoundLocal(declarationExpression, localSymbol, BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declType.Type); 3278TypeSymbol fieldType = expressionVariableField.GetFieldType(this.FieldsBeingBound).Type; 3500coercedArgument = bindInterpolatedStringHandlerInMemberCall(argument, parameterTypeWithAnnotations.Type, argumentsForInterpolationConversion, parameters, in result, arg, receiver, diagnostics); 3507coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, parameterTypeWithAnnotations.Type, diagnostics); 3528coercedArgument = CreateConversion(argument.Syntax, argument, kind, isCast: false, conversionGroupOpt: null, parameterTypeWithAnnotations.Type, diagnostics); 3582Debug.Assert(methodResult.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 3649if (!methodResult.Member.IsIndexer() && !argument.HasAnyErrors && parameterTypeWithAnnotations.Type.ContainsPointerOrFunctionPointer()) 4029var type = (ArrayTypeSymbol)BindArrayType(node.Type, diagnostics, permitDimensions: true, basesBeingResolved: null, disallowRestrictedTypes: true).Type; 4512var arrayType = (ArrayTypeSymbol)BindArrayType(arrayTypeSyntax, diagnostics, permitDimensions: true, basesBeingResolved: null, disallowRestrictedTypes: false).Type; 4516if (!elementType.Type.IsErrorType()) 4518hasErrors = hasErrors || CheckManagedAddr(Compilation, elementType.Type, elementTypeSyntax.Location, diagnostics, errorForManaged: true); 4569? new BoundStackAllocArrayCreation(node, elementType.Type, count, initializerOpt: null, type, hasErrors: hasErrors) 4570: BindStackAllocWithInitializer(node, node.StackAllocKeyword, node.Initializer, type, elementType.Type, count, diagnostics, hasErrors); 5194var type = typeWithAnnotations.Type; 7611if (typeArgument.Type.IsPointerOrFunctionPointer() || typeArgument.Type.IsRestrictedType()) 7614Error(diagnostics, ErrorCode.ERR_BadTypeArgument, typeArgumentsSyntax[i], typeArgument.Type); 8327resultType = ((FieldSymbol)symbolOpt).GetFieldType(this.FieldsBeingBound).Type; 8993TypeSymbol fieldType = fieldSymbol.GetFieldType(this.FieldsBeingBound).Type; 11196Debug.Assert(returnType.Type is { }); // Expecting System.Void rather than null return type. 11199bool returnsVoid = returnType.Type.IsVoidType();
Binder\Binder_Invocation.cs (1)
2245TypeSymbol returnType = members[i].GetTypeOrReturnType().Type;
Binder\Binder_Lambda.cs (1)
303var type = returnType.Type;
Binder\Binder_Lookup.cs (1)
1823type = ((FieldSymbol)symbol).GetFieldType(this.FieldsBeingBound).Type;
Binder\Binder_Operators.cs (3)
883namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte; 3346TypeSymbol targetType = targetTypeWithAnnotations.Type; 3698TypeSymbol targetType = targetTypeWithAnnotations.Type;
Binder\Binder_Patterns.cs (6)
861hasErrors |= CheckValidPatternType(typeSyntax, inputType, declType.Type, diagnostics: diagnostics); 896CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declType.Type, diagnostics, typeSyntax ?? (SyntaxNode)designation); 900syntax: designation, localSymbol: localSymbol, localSymbol.IsVar ? BoundLocalDeclarationKind.WithInferredType : BoundLocalDeclarationKind.WithExplicitType, constantValueOpt: null, isNullableUnknown: false, type: declType.Type); 974TypeSymbol declType = declTypeWithAnnotations.Type; 1172TypeSymbol elementType = isError ? CreateErrorType() : elementTypesWithAnnotations[i].Type; 1445TypeSymbol elementType = isError ? CreateErrorType() : elementTypes[i].Type;
Binder\Binder_Statements.cs (16)
237TypeSymbol elementType = GetIteratorElementType().Type; 849Error(diagnostics, ErrorCode.ERR_VarDeclIsStaticClass, typeSyntax, declType.Type); 852if (isConst && !declType.Type.CanBeConst()) 854Error(diagnostics, ErrorCode.ERR_BadConstType, typeSyntax, declType.Type); 1029Error(localDiagnostics, ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, declarator, declTypeOpt.Type); 1034if (!declTypeOpt.Type.IsErrorType()) 1058initializerOpt = BindPossibleArrayInitializer(value, declTypeOpt.Type, valueKind, diagnostics); 1063declTypeOpt.Type, 1085if (!declTypeOpt.Type.IsPointerType()) 1089Error(localDiagnostics, declTypeOpt.Type.IsFunctionPointer() ? ErrorCode.ERR_CannotUseFunctionPointerAsFixedLocal : ErrorCode.ERR_BadFixedInitType, declarator); 1093else if (!IsValidFixedVariableInitializer(declTypeOpt.Type, ref initializerOpt, localDiagnostics)) 1099CheckRestrictedTypeInAsyncMethod(this.ContainingMemberOrLambda, declTypeOpt.Type, localDiagnostics, typeSyntax); 1101if (localSymbol.Scope == ScopedKind.ScopedValue && !declTypeOpt.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 2075conversionError(diagnostics, ErrorCode.ERR_ExpressionTreeMustHaveDelegate, ((NamedTypeSymbol)targetType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 2538var targetElementType = targetElementTypes[i].Type; 3265type = this.BindType(declaration.Type, diagnostics).Type;
Binder\Binder_Symbols.cs (7)
538else if (LazyMissingNonNullTypesContextDiagnosticInfo.IsNullableReference(typeArgument.Type)) 562ReportUseSite(constructedType.Type.OriginalDefinition, diagnostics, syntax); 563var type = (NamedTypeSymbol)constructedType.Type; 606CheckManagedAddr(Compilation, elementType.Type, node.Location, diagnostics); 621if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8()) 646Error(diagnostics, ErrorCode.ERR_ArrayOfStaticClass, node.ElementType, type.Type); 657Error(diagnostics, ErrorCode.ERR_ArrayElementCantBeRefAny, node.ElementType, type.Type);
Binder\ForEachEnumeratorInfo.cs (2)
25public TypeSymbol ElementType => ElementTypeWithAnnotations.Type; 102public TypeSymbol ElementType => ElementTypeWithAnnotations.Type;
Binder\ForEachLoopBinder.cs (13)
200var valuePlaceholder = new BoundDeconstructValuePlaceholder(_syntax.Expression, variableSymbol: null, isDiscardExpression: false, inferredType.Type ?? CreateErrorType("var")); 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(); 479Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 483Error(diagnostics, ErrorCode.ERR_RefAssignmentMustHaveIdentityConversion, collectionExpr.Syntax, iterationVariableType.Type); 487var elementPlaceholder = new BoundValuePlaceholder(_syntax, inferredType.Type).MakeCompilerGenerated(); 495diagnostics.Add(ErrorCode.ERR_AmbigUDConv, foreachKeyword.GetLocation(), originalUserDefinedConversions[0], originalUserDefinedConversions[1], inferredType.Type, iterationVariableType); 499SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, inferredType.Type, iterationVariableType.Type); 511BoundExpression elementConversion = CreateConversion(_syntax, elementPlaceholder, elementConversionClassification, isCast: false, conversionGroupOpt: null, iterationVariableType.Type, createConversionDiagnostics);
Binder\Semantics\AccessCheck.cs (3)
164return IsSymbolAccessibleCore(((DiscardSymbol)symbol).TypeWithAnnotations.Type, within, null, out failedThroughTypeCheck, compilation, ref useSiteInfo, basesBeingResolved); 239if (typeArg.Type.Kind != SymbolKind.TypeParameter && !IsSymbolAccessibleCore(typeArg.Type, within, null, out unused, compilation, ref useSiteInfo, basesBeingResolved))
Binder\Semantics\Conversions\Conversions.cs (2)
166var elementType = elementTypeWithAnnotations.Type; 176elementType = elementTypeWithAnnotations.Type;
Binder\Semantics\Conversions\ConversionsBase.cs (36)
1488!invokeMethod.ReturnType.Equals(returnType.Type, TypeCompareKind.AllIgnoreOptions)) 1603var delegateType = type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 1880var type = typeWithAnnotations.Type; 1894ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo).Kind != ConversionKind.NoConversion; 1960conversions.ClassifyImplicitExtensionMethodThisArgConversion(s, s.Type, d.Type, ref u, isMethodGroupConversion: false), 1982return conversions.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, s.Type, d.Type, ref u, isMethodGroupConversion: false); 2295=> conversions.ClassifyImplicitConversionFromExpression(s, d.Type, ref u), 2313conversions.ClassifyConversionFromExpression(s, d.Type, isChecked: isChecked, ref u, forCast: forCast), 2371return conversions.ClassifyImplicitConversionFromType(s.Type, d.Type, ref u); 2390return conversions.ClassifyConversionFromType(s.Type, d.Type, isChecked: isChecked, ref u, forCast); 2598return HasIdentityOrImplicitReferenceConversion(elementType.Type, argument0.Type, ref useSiteInfo); 2612HasIdentityConversionInternal(source.Type, destination.Type, includeNullability: true)) 2617return HasImplicitReferenceConversion(source.Type, destination.Type, ref useSiteInfo); 3419&& (HasIdentityOrImplicitReferenceConversion(sourceType.Type, destinationType.Type, ref useSiteInfo) 3420|| HasImplicitPointerToVoidConversion(sourceType.Type, destinationType.Type) 3421|| HasImplicitPointerConversion(sourceType.Type, destinationType.Type, ref useSiteInfo)); 3425&& HasIdentityConversion(sourceType.Type, destinationType.Type); 3686var sourceArg = sourceTypeArguments[i].Type; 3687var destinationArg = destinationTypeArguments[i].Type; 3769if (HasExplicitReferenceConversion(sourceArray.ElementType, ((NamedTypeSymbol)destination).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type, ref useSiteInfo)) 3789var sourceElement = ((NamedTypeSymbol)source).TypeArgumentWithDefinitionUseSiteDiagnostics(0, ref useSiteInfo).Type; 4006return HasIdentityConversionInternal(source.Type, destination.Type) && 4028return HasIdentityOrReferenceConversion(elementType.Type, spanElementType.Type, ref useSiteInfo) &&
Binder\Semantics\OverloadResolution\MethodTypeInference.cs (72)
467if (!fixedResultType.Type.IsErrorType()) 476var errorTypeName = fixedResultType.Type.Name; 505TypeParameterSymbol typeParameter = (TypeParameterSymbol)type.Type; 538var methodTypeParameter = (TypeParameterSymbol)methodTypeParameterWithAnnotations.Type; 572return typeMap.SubstituteType(delegateOrFunctionPointerType).Type; 612ExactOrBoundsKind kind = GetRefKind(arg).IsManagedReference() || target.Type.IsPointerType() ? ExactOrBoundsKind.Exact : ExactOrBoundsKind.LowerBound; 634if (argument.Kind == BoundKind.UnboundLambda && target.Type.GetDelegateType() is { }) 648if (IsReallyAType(argumentType.Type)) 654var ordinal = GetOrdinal((TypeParameterSymbol)target.Type); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : test nullability scenario where the override of ordinals matters 667TypeSymbol targetType = target.Type; 702Debug.Assert(target.Type is { }); 703if (target.Type is null) 724if (target.Type.Kind != SymbolKind.NamedType) 730var destination = (NamedTypeSymbol)target.Type; 886if (HasUnfixedParamInOutputType(argument, formalType.Type) && !HasUnfixedParamInInputType(argument, formalType.Type)) 904if (!binder.TryGetCollectionIterationType((ExpressionSyntax)argument.Syntax, formalType.Type, out TypeWithAnnotations targetElementType)) 920if (formalType.Type.Kind != SymbolKind.NamedType) 926var destination = (NamedTypeSymbol)formalType.Type; 1143var formalParameterType = _formalParameterTypes[iArg].Type; 1385if (MethodGroupReturnTypeInference(binder, expression, target.Type, ref useSiteInfo)) 1407var delegateType = target.Type.GetDelegateType(); 1429Debug.Assert(inferredReturnType.Type is not FunctionTypeSymbol); 1568var delegateType = target.Type.GetDelegateType(); 1621var delegateInvokeMethod = target.Type.GetDelegateType()?.DelegateInvokeMethod(); 1666if (ExactSpanInference(source.Type, target.Type, ref useSiteInfo)) 1711if (!source.Type.IsArray() || !target.Type.IsArray()) 1716var arraySource = (ArrayTypeSymbol)source.Type; 1717var arrayTarget = (ArrayTypeSymbol)target.Type; 1806ExactOrBoundsInference(kind, ((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ((NamedTypeSymbol)target.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ref useSiteInfo); 1840if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) || 1841!target.Type.TryGetElementTypesWithAnnotationsIfTupleType(out targetTypes) || 1864var namedSource = source.Type as NamedTypeSymbol; 1870var namedTarget = target.Type as NamedTypeSymbol; 1889ExactInference(((PointerTypeSymbol)source.Type).PointedAtTypeWithAnnotations, ((PointerTypeSymbol)target.Type).PointedAtTypeWithAnnotations, ref useSiteInfo); 1892else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1893target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 2003if (LowerBoundArrayInference(source.Type, target.Type, ref useSiteInfo)) 2010if (LowerBoundSpanInference(source.Type, target.Type, ref useSiteInfo)) 2047if (LowerBoundConstructedInference(source.Type, target.Type, ref useSiteInfo)) 2052if (LowerBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2136if (elementSource.Type.IsReferenceType) 2171if (!sourceElementType.Type.IsReferenceType || target.IsSpan()) 2511Debug.Assert(source.Type.IsReferenceType || source.Type.IsFunctionPointer()); 2528if (UpperBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2563if (!target.Type.IsArray()) 2567var arrayTarget = (ArrayTypeSymbol)target.Type; 2569var elementSource = GetMatchingElementType(arrayTarget, source.Type, ref useSiteInfo); 2575if (elementSource.Type.IsReferenceType) 2596var source = sourceWithAnnotations.Type; 2597var target = targetWithAnnotations.Type; 2848Debug.Assert(best.Type.Type.Equals(withoutNullability.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 3012functionType = type.Type as FunctionTypeSymbol; 3019return constraintTypes.Any(static t => isExpressionType(t.Type)); 3038var source = sourceWithAnnotations.Type; 3039var destination = destinationWithAnnotations.Type; 3317if (!dest.Type.ContainsTypeParameter(pParam)) 3461var newBound = TypeWithAnnotations.Create(oldBound.Type, newAnnotation); 3487if (newCandidate.Type.IsDynamic()) 3518return obj.Type.GetHashCode(); 3525if (x.Type.IsDynamic() ^ y.Type.IsDynamic()) { return false; }
Binder\Semantics\OverloadResolution\OverloadResolution.cs (20)
1264expandedResult.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel) 1347if (elementType.Type is null) 1368Debug.Assert(elementType.Type is { }); 2598Debug.Assert(paramsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 2599return paramsElementTypeOpt.Type; 3221t1, kind1, elementType1.Type, underlyingElementConversions1: [], 3222t2, kind2, elementType2.Type, underlyingElementConversions2: [], 3236elementType = typeArg.Type; 3279if (x.HasType && Conversions.HasIdentityConversion(x.Type, y)) 3289y = ((NamedTypeSymbol)y).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3382if (!ExpressionMatchExactly(sourceArguments[i], destTypes[i].Type, ref useSiteInfo)) 3529return BetterConversionTargetCore(((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3530((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3640var type1Element = ((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3641var type2Element = ((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 4060TryInferParamsCollectionIterationType(binder, type.Type, out paramsIterationType); 4333if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions)) 4625&& parameters.ParameterTypes[argumentPosition].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }) 4638parameters.ParameterTypes[argumentPosition].Type, 4650(ignoreOpenTypes && parameters.ParameterTypes[argumentPosition].Type.ContainsTypeParameter(parameterContainer: (MethodSymbol)candidate))));
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (2)
1384Debug.Assert(badArg.Result.ParamsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 1385return badArg.Result.ParamsElementTypeOpt.Type;
BoundTree\BoundDiscardExpression.cs (1)
16return this.Update(type.NullableAnnotation, isInferred: true, type.Type);
BoundTree\Constructors.cs (2)
506: this(syntax, aliasOpt, boundContainingTypeOpt, boundDimensionsOpt, typeWithAnnotations, typeWithAnnotations.Type, hasErrors) 508Debug.Assert((object)typeWithAnnotations.Type != null, "Field 'type' cannot be null");
BoundTree\OutDeconstructVarPendingInference.cs (1)
18Placeholder = new BoundDeconstructValuePlaceholder(this.Syntax, variableSymbol: VariableSymbol, isDiscardExpression: IsDiscardExpression, type.Type, hasErrors: this.HasErrors || !success);
BoundTree\UnboundLambda.cs (9)
228Debug.Assert(bestType.Type is not FunctionTypeSymbol); 409bool hasErrors = !types.IsDefault && types.Any(static t => t.Type?.Kind == SymbolKind.ErrorType); 495public TypeSymbol ParameterType(int index) { return ParameterTypeWithAnnotations(index).Type; } 640yield return type.Type; 649yield return type.Type; 850if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 943if (targetParameterTypes[i].Type.ContainsPointerOrFunctionPointer()) 1094value = Hash.Combine(type.Type, value); 1230if (!returnType.HasType || returnType.Type.ContainsTypeParameter())
BoundTree\VariablePendingInference.cs (4)
65Binder.CheckRestrictedTypeInAsyncMethod(localSymbol.ContainingSymbol, type.Type, diagnosticsOpt, typeOrDesignationSyntax); 67if (localSymbol.Scope == ScopedKind.ScopedValue && !type.Type.IsErrorOrRefLikeOrAllowsRefLikeType()) 76return new BoundLocal(this.Syntax, localSymbol, BoundLocalDeclarationKind.WithInferredType, constantValueOpt: null, isNullableUnknown: false, type: type.Type, hasErrors: this.HasErrors || inferenceFailed).WithWasConverted(); 106type: type.Type,
CodeGen\EmitStackAllocInitializer.cs (1)
29: ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0]).Type;
CodeGen\EmitStatement.cs (1)
1790Debug.Assert(local.TypeWithAnnotations.Type.IsPointerType());
Compilation\BuiltInOperators.cs (1)
693Debug.Assert(((NamedTypeSymbol)readonlySpanOfByte).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte);
Compilation\CSharpCompilation.cs (1)
2252var array = (ArrayTypeSymbol)firstType.Type;
Compilation\CSharpSemanticModel.cs (3)
298crefSymbols = ImmutableArray.Create<Symbol>(binder.BindType(expression, BindingDiagnosticBag.Discarded).Type); 413NamedTypeSymbol attributeType = (NamedTypeSymbol)binder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type; 2780var attributeType = (NamedTypeSymbol)binder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type;
Compilation\PublicSemanticModel.cs (1)
20var attributeType = (NamedTypeSymbol)enclosingBinder.BindType(attribute.Name, BindingDiagnosticBag.Discarded, out aliasOpt).Type;
Compiler\ClsComplianceChecker.cs (6)
286paramType.Type.GetAttributeParameterTypedConstantKind(_compilation) == TypedConstantKind.Error) 561if (!IsCompliantType(constraintType.Type, context)) 566this.AddDiagnostic(ErrorCode.WRN_CLS_BadTypeVar, typeParameter.GetFirstLocation(), constraintType.Type); 1046if (!IsCompliantType(typeArg.Type, context)) 1369TypeSymbol xType = xParameterTypes[i].Type; 1370TypeSymbol yType = yParameterTypes[i].Type;
DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)
208Visit(typeArgument.Type, builder);
Emitter\EditAndContinue\CSharpSymbolMatcher.cs (3)
526var otherType = type.WithTypeAndModifiers((TypeSymbol?)this.Visit(type.Type), this.VisitCustomModifiers(type.CustomModifiers)); 744return AreTypesEqual(type.Type, other.Type);
Emitter\Model\ArrayTypeSymbolAdapter.cs (1)
27var type = moduleBeingBuilt.Translate(elementType.Type, syntaxNodeOpt: (CSharpSyntaxNode?)context.SyntaxNode, diagnostics: context.Diagnostics);
Emitter\Model\FieldSymbolAdapter.cs (1)
38var implType = isFixed ? AdaptedFieldSymbol.FixedImplementationType(moduleBeingBuilt) : fieldTypeWithAnnotations.Type;
Emitter\Model\GenericMethodInstanceReference.cs (1)
37yield return moduleBeingBuilt.Translate(arg.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics);
Emitter\Model\GenericTypeInstanceReference.cs (1)
44builder.Add(moduleBeingBuilt.Translate(type.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNode, diagnostics: context.Diagnostics));
Emitter\Model\MethodSymbolAdapter.cs (1)
256yield return moduleBeingBuilt.Translate(arg.Type,
Emitter\Model\NamedTypeSymbolAdapter.cs (1)
880var 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)
1237else if (!_alreadyReported[slot] && !symbol.GetTypeOrReturnType().Type.IsErrorType()) 1707TypeSymbol structType = variable.Symbol.GetTypeOrReturnType().Type; 1743TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type; 1779TypeSymbol 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)
130Debug.Assert(TypeSymbol.Equals(RValueType.Type, LValueType.Type, TypeCompareKind.ConsiderEverything)); 761if (symbolType.Type.IsValueType || symbolType.Type.IsErrorType()) 793var badState = symbolType.Type.IsPossiblyNullableReferenceTypeTypeParameter() && (annotations & FlowAnalysisAnnotations.NotNull) == 0 851SetState(ref this.State, memberSlot, type.Type.IsPossiblyNullableReferenceTypeTypeParameter() ? NullableFlowState.MaybeDefault : NullableFlowState.MaybeNull); 2348type.Type.IsValueType) 2365if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8() && !(type.Type is TypeParameterSymbol { IsNotNullable: true })) 2391!targetType.Type.Equals(valueType.Type, TypeCompareKind.AllIgnoreOptions)) 2624InheritDefaultState(targetType.Type, targetSlot); 2630if (targetType.Type.IsReferenceType || 2639else if (EmptyStructTypeCache.IsTrackableStructType(targetType.Type)) 2641InheritNullableStateOfTrackableStruct(targetType.Type, targetSlot, valueSlot, isDefaultValue: !(valueOpt is null) && IsDefaultValue(valueOpt), skipSlot: targetSlot); 2647target.Type.Equals(assignedValue.Type, TypeCompareKind.AllIgnoreOptions); 2718if (fieldOrPropertyType.Type.IsReferenceType || 2747else if (EmptyStructTypeCache.IsTrackableStructType(fieldOrPropertyType.Type)) 2757InheritNullableStateOfTrackableStruct(fieldOrPropertyType.Type, targetMemberSlot, valueMemberSlot, isDefaultValue: isDefaultValue, skipSlot); 2840private static TypeSymbol GetTypeOrReturnType(Symbol symbol) => symbol.GetTypeOrReturnType().Type; 2872typeWithAnnotations = TypeWithAnnotations.Create(typeWithAnnotations.Type, nullableAnnotation); 2973if (EmptyStructTypeCache.IsTrackableStructType(parameterType.Type)) 2976parameterType.Type, 3009return TypeWithState.Create(parameterType.Type, NullableFlowState.MaybeDefault); 3014return TypeWithState.Create(parameterType.Type, NullableFlowState.NotNull); 3038returnType.Type.SpecialType == SpecialType.System_Boolean) 3145type = ((NamedTypeSymbol)returnType.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single(); 3172if (!node.Type.Equals(type.Type, TypeCompareKind.ConsiderEverything | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamicAndTupleNames)) 3177Debug.Assert(node.Type.IsErrorType() || type.Type.IsErrorType()); 3540VisitObjectCreationInitializer(resultSlot, resultType.Type, withExpr.InitializerExpression, delayCompletionForType: false); 3593InheritDefaultState(GetDeclaredLocalResult(local).Type, slot); 3651Debug.Assert(type.Type.IsErrorType()); 3730return AnonymousTypeManager.GetAnonymousTypeFieldTypes(type).Any(static t => canIgnoreAnyType(t.Type)); 3910var strippedTargetCollectionType = targetCollectionType.Type.StrippedType(); 4067Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4069var type = resultTypeWithAnnotations.Type; 4146if (AreNullableAndUnderlyingTypes(type, parameterType.Type, out TypeWithAnnotations underlyingType)) 4473Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4531Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4783inferredType = TypeWithState.Create(inferredType.Type, elementState).ToTypeWithAnnotations(compilation); 5264if (isLifted && targetTypeWithNullability.Type.IsNonNullableValueType()) 5707Debug.Assert(targetType.Type.ContainsErrorType() || 5709TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions)); 5713leftSlot = GetNullableOfTValueSlot(targetType.Type, leftSlot, out _); 5719Debug.Assert(TypeSymbol.Equals(targetType.Type, rightResult.Type, TypeCompareKind.AllIgnoreOptions)); 5723TypeWithState resultType = TypeWithState.Create(targetType.Type, rightResult.State); 5983TypeSymbol accessType = accessTypeWithAnnotations.Type; 6177var typeWithState = TypeWithState.Create(resultTypeWithAnnotations.Type, resultState); 6190return TypeWithState.Create(resultTypeWithAnnotations.Type, resultState); 6305new BoundExpressionWithNullability(expr.Syntax, expr, type.NullableAnnotation, type.Type); 7529conversion = GenerateConversion(_conversions, argumentNoConversion, argumentResultType, parameterType.Type, fromExplicitCast: false, extensionMethodThisArgument: false, isChecked: conversionOpt?.Checked ?? false); 7533ReportNullabilityMismatchInArgument(argumentNoConversion.Syntax, argumentResultType, parameter, parameterType.Type, forOutput: false); 7565if (IsNullabilityMismatch(lvalueResultType.Type, parameterType.Type)) 7568ReportNullabilityMismatchInRefArgument(argumentNoConversion, argumentType: lvalueResultType.Type, parameter, parameterType.Type); 7672parameterWithState = TypeWithState.Create(parameterType.Type, adjustedState); 7729if (!_conversions.HasIdentityOrImplicitReferenceConversion(parameterType.Type, lValueType.Type, ref discardedUseSiteInfo)) 7731ReportNullabilityMismatchInArgument(argument.Syntax, lValueType.Type, parameter, parameterType.Type, forOutput: true); 7966OverloadResolution.TryInferParamsCollectionIterationType(_binder, type.Type, out paramsIterationType); 8155return new BoundExpressionWithNullability(argument.Syntax, argument, argumentType.NullableAnnotation, argumentType.Type); 8437if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type)) 8550if (typeArg.Type.Equals(underlyingTypeOpt, TypeCompareKind.AllIgnoreOptions)) 8971operandType = completion(targetTypeWithNullability.Type.GetNullableUnderlyingTypeWithAnnotations()); 8999TypeSymbol targetType = targetTypeWithNullability.Type; 9317if (targetType.Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == true) 9326dependsOnTypeParameter(typeParameter1, (TypeParameterSymbol)targetType.Type, NullableAnnotation.NotAnnotated, out var annotation)) 9333if (targetType.Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == false) 9357targetType.Type is TypeParameterSymbol typeParameter2) 9407if (constraintType.Type is TypeParameterSymbol constraintTypeParameter && 9511TypeSymbol targetType = targetTypeWithNullability.Type; 9681bool typeNeedsLifting = returnType.Type.IsNonNullableValueType(); 9682TypeSymbol type = typeNeedsLifting ? MakeNullableOf(returnType) : returnType.Type; 9726var conversion = _conversions.ClassifyStandardConversion(operandType.Type, targetType.Type, ref discardedUseSiteInfo); 9731ReportNullabilityMismatchInArgument(diagnosticLocation, operandType.Type, parameterOpt, targetType.Type, forOutput: false); 9735ReportNullabilityMismatchInAssignment(diagnosticLocation, operandType.Type, targetType.Type); 9816Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 9817var delegateType = (NamedTypeSymbol)resultTypeWithAnnotations.Type; 9994arguments.Add(new BoundExpressionWithNullability(syntax, new BoundParameter(syntax, parameter), parameterType.NullableAnnotation, parameterType.Type)); 10158SetResult(node, TypeWithState.Create(leftLValueType.Type, rightState.State), leftLValueType); 10500var valueBeforeNullableWrapping = TypeWithState.Create(underlyingType.Type, NullableFlowState.NotNull); 10784if (argumentType.Type is { } argType && IsNullabilityMismatch(paramType.Type, argType)) 10786ReportNullabilityMismatchInArgument(argument.Syntax, argType, parameter, paramType.Type, forOutput: false); 11306conversion = _conversions.ClassifyImplicitConversionFromType(sourceType.Type, destinationType.Type, ref discardedUseSiteInfo);
FlowAnalysis\NullableWalker_Patterns.cs (14)
452var output = new BoundDagTemp(e.Syntax, parameterType.Type, e, i); 455addToTempMap(output, outputSlot, parameterType.Type); 490var output = new BoundDagTemp(e.Syntax, type.Type, e); 528addToTempMap(output, outputSlot, type.Type); 536var output = new BoundDagTemp(e.Syntax, type.Type, e); 543addToTempMap(output, outputSlot, type.Type); 561var output = new BoundDagTemp(e.Syntax, type.Type, e); 565addToTempMap(output, outputSlot, type.Type); 573var output = new BoundDagTemp(e.Syntax, type.Type, e); 576addToTempMap(output, outputSlot, type.Type); 688inferredType = TypeWithAnnotations.Create(inferredType.Type, existingType.NullableAnnotation.Join(inferredType.NullableAnnotation)); 840var output = new BoundDagTemp(e.Syntax, type.Type, e, index: index); 843addToTempMap(output, outputSlot, type.Type); 1020TypeWithState resultType = TypeWithState.Create(inferredTypeWithAnnotations.Type, inferredState);
Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (2)
256var resultType = returnType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 263resultType = typeMap.SubstituteType(resultType).Type;
Lowering\AsyncRewriter\AsyncRewriter.AsyncIteratorRewriter.cs (1)
45Debug.Assert(!TypeSymbol.Equals(method.IteratorElementTypeWithAnnotations.Type, null, TypeCompareKind.ConsiderEverything2));
Lowering\AsyncRewriter\AsyncStateMachine.cs (1)
35var elementType = TypeMap.SubstituteType(asyncMethod.IteratorElementTypeWithAnnotations).Type;
Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)
111return TypeMap.SubstituteType(type).Type;
Lowering\ClosureConversion\ClosureConversion.cs (5)
994while (!TypeSymbol.Equals(oldTypeArg.Type, newTypeArg.Type, TypeCompareKind.ConsiderEverything)); 998Debug.Assert((object)oldTypeArg.Type == newTypeArg.Type); 1692var cacheVariableType = containerAsFrame.TypeMap.SubstituteType(node.Type).Type;
Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)
733var intermediate = nullable.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 847_bound.Typeof(_typeMap.SubstituteType(p.Type).Type, _bound.WellKnownType(WellKnownType.System_Type)), _bound.Literal(p.Name));
Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)
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)
74var fieldType = TypeParameters.IsEmpty ? delegateType : TypeMap.SubstituteType(delegateType).Type;
Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (7)
275ShouldUseRuntimeHelpersCreateSpan(node, elementType.Type)) 278Debug.Assert(!IsAllocatingRefStructCollectionExpression(node, collectionTypeKind, elementType.Type, _compilation)); 281return _factory.New(constructor, _factory.Array(elementType.Type, rewrittenElements)); 287Debug.Assert(!IsAllocatingRefStructCollectionExpression(node, collectionTypeKind, elementType.Type, _compilation)); 295Debug.Assert(IsAllocatingRefStructCollectionExpression(node, collectionTypeKind, elementType.Type, _compilation)); 893asSpanMethod = collectionsMarshalAsSpanMethod.Construct(namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type); 1129var elementType = ((NamedTypeSymbol)spanTemp.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
Lowering\LocalRewriter\LocalRewriter_Conversion.cs (6)
96var byteType = ((NamedTypeSymbol)node.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type; 609createSpan = createSpan.Construct(rewrittenOperand.Type, spanType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type); 633rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 656rewrittenOperand = _factory.Convert(implicitOperator.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 690rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand); 968var 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 (1)
151visitedTypeArgs.Add(typeArg.WithTypeAndModifiers(VisitType(typeArg.Type), typeArg.CustomModifiers));
Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)
324proxy = new CapturedToStateMachineFieldReplacement(GetOrAllocateReusableHoistedField(TypeMap.SubstituteType(local.Type).Type, out reused, local), isReusable: true); 557var type = TypeMap.SubstituteType(local.Type).Type;
Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)
185var fieldType = typeMap.SubstituteType(local.Type).Type; 255var proxyField = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, parameter.Name, parameter, isPublic: !PreserveInitialParameterValuesAndThreadId); 260var field = F.StateMachineFieldForRegularParameter(typeMap.SubstituteType(parameter.Type).Type, GeneratedNames.StateMachineParameterProxyFieldName(parameter.Name), parameter, isPublic: true);
Lowering\SyntheticBoundNodeFactory.cs (2)
1244return new BoundPointerIndirectionOperator(Syntax, Default(new PointerTypeSymbol(type)), refersToLocation: false, type.Type); 1294return Typeof(type.Type, systemType);
Symbols\AbstractTypeMap.cs (6)
298var substituted = SubstituteType(t).Type; 357!type.Type.ContainsTypeParameters(ignoreTypesDependentOnTypeParametersOpt)) 368!type.Type.ContainsTypeParameters(ignoreTypesDependentOnTypeParametersOpt)) 372if (!map.TryGetValue(substituted.Type, out int mergeWith)) 374map.Add(substituted.Type, result.Count); 396return substituted.WithTypeAndModifiers(dynamicEraser.EraseDynamic(substituted.Type), substituted.CustomModifiers);
Symbols\AliasSymbol.cs (1)
410annotatedNamespaceOrType.TypeWithAnnotations.Type?.IsReferenceType is true)
Symbols\AnonymousTypes\AnonymousTypeField.cs (1)
34public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)
236var original = TypeWithAnnotations.Create(genericFieldTypes[index].Type);
Symbols\ArrayTypeSymbol.cs (2)
216return _elementTypeWithAnnotations.Type; 525var newInterfaces = _interfaces.SelectAsArray((i, t) => i.OriginalDefinition.Construct(t), newElementType.Type);
Symbols\Compilation_WellKnownMembers.cs (2)
1027twa.Type.VisitType(visitor, (transformFlagsBuilder, addCustomModifierFlags)); 1110return named.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[argumentIndex].Type;
Symbols\ConstraintsHelper.cs (52)
161Debug.Assert(!constraintType.Type.ContainsDynamic()); 170var constraintTypeParameter = (TypeParameterSymbol)constraintType.Type; 225if (constraintType.Type.IsInterfaceType()) 227AddInterface(interfacesBuilder, (NamedTypeSymbol)constraintType.Type); 233constraintEffectiveBase = (NamedTypeSymbol)constraintType.Type; 234constraintDeducedBase = constraintType.Type; 241var underlyingType = constraintType.Type.GetNullableUnderlyingType(); 259constraintDeducedBase = constraintType.Type; 265constraintDeducedBase = constraintType.Type; 271constraintDeducedBase = constraintType.Type; 275constraintEffectiveBase = (NamedTypeSymbol)constraintType.Type; 276constraintDeducedBase = constraintType.Type; 935if (typeArgument.Type.IsPointerOrFunctionPointer() || typeArgument.IsRestrictedType(ignoreSpanLikeTypes: true) || typeArgument.IsVoidType()) 938diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BadTypeArgument, typeArgument.Type)))); 942if (typeArgument.Type.IsRefLikeOrAllowsRefLikeType()) 961diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NotRefStructConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 969diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_GenericArgIsStaticClass, typeArgument.Type)))); 975if (!typeArgument.Type.IsReferenceType) 978diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_RefConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 988var managedKind = typeArgument.Type.GetManagedKind(ref useSiteInfo); 991if (managedKind == ManagedKind.Managed || !typeArgument.Type.IsNonNullableValueType()) 994diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_UnmanagedConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1015if (typeParameter.HasValueTypeConstraint && !typeArgument.Type.IsNonNullableValueType()) 1018diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_ValConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1044if (typeArgument.Type.IsErrorType()) 1066if (typeArgument.Type is NamedTypeSymbol { IsInterface: true } iface && SelfOrBaseHasStaticAbstractMember(iface, ref useSiteInfo, out Symbol member)) 1095var error = SatisfiesConstructorConstraint(typeArgument.Type); 1103diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1107diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintCannotHaveRequiredMembers, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1124if (typeParameter.HasNotNullConstraint && typeArgument.GetValueNullableAnnotation().IsAnnotated() && !typeArgument.Type.IsNonNullableValueType()) 1164if (typeArgument.Type.IsReferenceType) 1170errorCode = constraintType.Type.IsInterfaceType() ? ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface : ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum; 1184if (constraintType.Type.Equals(typeArgument.Type, TypeCompareKind.AllIgnoreOptions)) 1186constraintTypeErrorArgument = constraintType.Type; 1187typeArgumentErrorArgument = typeArgument.Type; 1191SymbolDistinguisher distinguisher = new SymbolDistinguisher(args.CurrentCompilation, constraintType.Type, typeArgument.Type); 1201var type = typeWithAnnotations.Type; 1244var type = typeWithAnnotations.Type; 1323if (constraintType.Type.IsErrorType()) 1334if (conversions.HasIdentityOrImplicitReferenceConversion(typeArgument.Type, constraintType.Type, ref useSiteInfo)) 1339if (typeArgument.Type.IsValueType) 1343if (conversions.HasBoxingConversion(typeArgument.Type.IsNullableType() ? ((NamedTypeSymbol)typeArgument.Type).ConstructedFrom : typeArgument.Type, 1344constraintType.Type, ref useSiteInfo)) 1349if (typeArgument.Type is NamedTypeSymbol { IsRefLikeType: true } refLike && 1350conversions.ImplementsVarianceCompatibleInterface(refLike, constraintType.Type, ref useSiteInfo)) 1358var typeParameter = (TypeParameterSymbol)typeArgument.Type; 1362if (conversions.HasImplicitTypeParameterConversion(typeParameter, constraintType.Type, ref useSiteInfo))
Symbols\DiscardSymbol.cs (1)
15Debug.Assert(typeWithAnnotations.Type is object);
Symbols\EventSymbol.cs (1)
58public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\Extensions\SynthesizedExtensionMarker.cs (1)
82TypeSymbol parameterType = parameter.TypeWithAnnotations.Type;
Symbols\FieldSymbol.cs (1)
75public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\LocalSymbol.cs (1)
73public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\MemberSignatureComparer.cs (1)
755result.Add(SubstituteType(typeMap, type).Type);
Symbols\MemberSymbolExtensions.cs (5)
290if (parameterType.Type.ContainsPointerOrFunctionPointer()) 378count += methodReturnType.Type.CustomModifierCount(); 384count += paramType.Type.CustomModifierCount(); 427count += type.Type.CustomModifierCount(); 433count += paramType.Type.CustomModifierCount();
Symbols\Metadata\PE\DynamicTypeDecoder.cs (4)
281TypeSymbol transformedTypeArg = TransformType(typeArg.Type); 290anyTransformed |= !TypeSymbol.Equals(transformedTypeArg, typeArg.Type, TypeCompareKind.ConsiderEverything2); 407var transformedType = decoder.TransformType(typeWithAnnotations.Type); 413if (transformedType.Equals(typeWithAnnotations.Type, TypeCompareKind.ConsiderEverything))
Symbols\Metadata\PE\MemberRefMetadataDecoder.cs (3)
185TypeSymbol.Equals((fieldType = field.TypeWithAnnotations).Type, fieldInfo.Type, TypeCompareKind.CLRSignatureCompareOptions) && 261if (!TypeSymbol.Equals(substituted.Type, targetParam.Type, TypeCompareKind.CLRSignatureCompareOptions)) 289if (!TypeSymbol.Equals(substituted.Type, targetReturnType, TypeCompareKind.CLRSignatureCompareOptions))
Symbols\Metadata\PE\MetadataDecoder.cs (1)
255if (IsOrClosedOverATypeFromAssemblies(arguments[i].Type, assemblies))
Symbols\Metadata\PE\NativeIntegerTypeDecoder.cs (1)
74if (TransformType(type.Type) is { } transformedType)
Symbols\Metadata\PE\PEEventSymbol.cs (4)
90TypeSymbol originalEventType = _eventTypeWithAnnotations.Type; 170TypeSymbol.Equals(_eventTypeWithAnnotations.Type, ((NamedTypeSymbol)candidateAssociatedFieldType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, TypeCompareKind.ConsiderEverything2)) 177if (TypeSymbol.Equals(candidateAssociatedFieldType, _eventTypeWithAnnotations.Type, TypeCompareKind.ConsiderEverything2))
Symbols\Metadata\PE\PEFieldSymbol.cs (1)
336_lazyFixedImplementationType = type.Type as NamedTypeSymbol;
Symbols\Metadata\PE\PENamedTypeSymbol.cs (2)
717baseType = (NamedTypeSymbol)NullableTypeDecoder.TransformType(TypeWithAnnotations.Create(decodedType), _handle, moduleSymbol, accessSymbol: this, nullableContext: this).Type; 777typeSymbol = NullableTypeDecoder.TransformType(TypeWithAnnotations.Create(typeSymbol), interfaceImpl, moduleSymbol, accessSymbol: this, nullableContext: this).Type;
Symbols\Metadata\PE\PEParameterSymbol.cs (2)
308var typeSymbol = DynamicTypeDecoder.TransformType(typeWithAnnotations.Type, countOfCustomModifiers, handle, moduleSymbol, refKind); 336else if (typeWithAnnotations.Type.IsRefLikeOrAllowsRefLikeType())
Symbols\Metadata\PE\PETypeParameterSymbol.cs (1)
311if (!(constraintType.Type is PETypeParameterSymbol typeParameter) ||
Symbols\Metadata\PE\TupleTypeDecoder.cs (2)
117TypeSymbol type = metadataType.Type; 342TypeSymbol type = typeWithAnnotations.Type;
Symbols\MethodSymbol.cs (8)
247public TypeSymbol ReturnType => ReturnTypeWithAnnotations.Type; 906internal TypeSymbol GetParameterType(int index) => ParameterTypesWithAnnotations[index].Type; 1161if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1163AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 1166if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1168AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1171if (type.Type.ContainsTupleNames() && compilation.HasTupleNamesAttributes(BindingDiagnosticBag.Discarded, Location.None)) 1173AddSynthesizedAttribute(ref attributes, compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\NamedTypeSymbol.cs (5)
78typeArgument.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 87result.Type.OriginalDefinition.AddUseSiteInfo(ref useSiteInfo); 1175internal static readonly Func<TypeWithAnnotations, bool> TypeWithAnnotationsIsErrorType = type => type.HasType && type.Type.IsErrorType(); 1286builder.Add(argument.Type); 1671typeToCheck = ((NamedTypeSymbol)typeToCheck).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type;
Symbols\NullableAnnotationExtensions.cs (2)
110return type.Type?.GetITypeSymbol(type.ToPublicAnnotation()); 119ToPublicAnnotation(type.Type, type.NullableAnnotation);
Symbols\OverriddenOrHiddenMembersHelpers.cs (2)
895methodReturnType.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: false); 900propertyType.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: false);
Symbols\ParameterSymbol.cs (1)
54public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\PointerTypeSymbol.cs (1)
76public TypeSymbol PointedAtType => PointedAtTypeWithAnnotations.Type;
Symbols\PropertySymbol.cs (1)
91public TypeSymbol Type => TypeWithAnnotations.Type;
Symbols\Retargeting\RetargetingPropertySymbol.cs (1)
70if (type.Type.TryAsDynamicIfNoPia(this.ContainingType, out TypeSymbol asDynamic))
Symbols\Retargeting\RetargetingSymbolTranslator.cs (4)
182var newTypeSymbol = Retarget(underlyingType.Type, options); 192if (modifiersHaveChanged || !TypeSymbol.Equals(underlyingType.Type, newTypeSymbol, TypeCompareKind.ConsiderEverything2)) 673if (IsOrClosedOverAnExplicitLocalType(argument.Type)) 1119if (TypeSymbol.Equals(retargetedEvent.Type, targetType.Type, TypeCompareKind.ConsiderEverything2))
Symbols\SignatureOnlyParameterSymbol.cs (4)
30Debug.Assert((object)type.Type != null); 120TypeSymbol.Equals(_type.Type, other._type.Type, compareKind) && 131_type.Type.GetHashCode(),
Symbols\Source\CustomModifierUtils.cs (2)
48TypeSymbol returnTypeSymbol = returnType.Type; 56TypeSymbol returnTypeWithCustomModifiers = sourceMethodReturnType.Type;
Symbols\Source\ExplicitInterfaceHelpers.cs (1)
54explicitInterfaceTypeOpt = binder.BindType(explicitInterfaceName, diagnostics).Type;
Symbols\Source\FieldSymbolWithAttributesAndModifiers.cs (6)
400if (type.Type.ContainsDynamic()) 403compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 406if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 408AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 411if (type.Type.ContainsTupleNames()) 414compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Source\GlobalExpressionVariable.cs (2)
136TypeSymbol.Equals(originalType, type.Type, TypeCompareKind.ConsiderEverything2)); 140TypeChecks(type.Type, diagnostics);
Symbols\Source\LambdaSymbol.cs (1)
162Debug.Assert(_returnType.Type.IsErrorType());
Symbols\Source\LocalFunctionOrSourceMemberMethodSymbol.cs (2)
38Debug.Assert(TypeSymbol.Equals(_lazyIteratorElementType.Value.Type, elementType.Type, TypeCompareKind.ConsiderEverything));
Symbols\Source\LocalFunctionSymbol.cs (2)
272if (compilation.ShouldEmitNativeIntegerAttributes(returnType.Type)) 289diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);
Symbols\Source\ParameterHelpers.cs (2)
804typeWithAnnotations.Type); 818diagnostics.Add(ErrorCode.ERR_MethodArgCantBeRefAny, syntax.Location, typeWithAnnotations.Type);
Symbols\Source\SourceComplexParameterSymbol.cs (11)
1066else if (!compilation.Conversions.HasCallerLineNumberConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1070diagnostics.Add(ErrorCode.ERR_NoConversionForCallerLineNumberParam, node.Name.Location, intType, TypeWithAnnotations.Type); 1094else if (!compilation.Conversions.HasCallerInfoStringConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1098diagnostics.Add(ErrorCode.ERR_NoConversionForCallerFilePathParam, node.Name.Location, stringType, TypeWithAnnotations.Type); 1127else if (!compilation.Conversions.HasCallerInfoStringConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1131diagnostics.Add(ErrorCode.ERR_NoConversionForCallerMemberNameParam, node.Name.Location, stringType, TypeWithAnnotations.Type); 1168else if (!compilation.Conversions.HasCallerInfoStringConversion(TypeWithAnnotations.Type, ref useSiteInfo)) 1172diagnostics.Add(ErrorCode.ERR_NoConversionForCallerArgumentExpressionParam, node.Name.Location, stringType, TypeWithAnnotations.Type); 1554var elementType = elementTypeWithAnnotations.Type; 1567elementType = elementTypeWithAnnotations.Type; 1625elementType = elementTypeWithAnnotations.Type;
Symbols\Source\SourceDelegateMethodSymbol.cs (1)
67diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);
Symbols\Source\SourceEventSymbol.cs (8)
376if (type.Type.ContainsDynamic()) 378AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length)); 381if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 383AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 386if (type.Type.ContainsTupleNames()) 389DeclaringCompilation.SynthesizeTupleNamesAttribute(type.Type)); 703if (type.Type.Equals(overriddenEventType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 705type = type.WithTypeAndModifiers(CustomModifierUtils.CopyTypeCustomModifiers(overriddenEventType, type.Type, containingAssembly),
Symbols\Source\SourceLocalSymbol.cs (2)
390Debug.Assert(newType.Type is object); 397originalType.Value.DefaultType.IsErrorType() && newType.Type.IsErrorType() ||
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (16)
796if (IsOrContainsErrorType(parameterType.Type)) 961if (!IsOrContainsErrorType(overridingMemberType.Type)) 963diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 999if (DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMethod.ReturnTypeWithAnnotations.Type, overriddenMethod.ReturnTypeWithAnnotations.Type, ref discardedUseSiteInfo)) 1064if (!IsOrContainsErrorType(overridingMemberType.Type)) 1069DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMemberType.Type, overriddenMemberType.Type, ref discardedUseSiteInfo)) 1073diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantPropertiesOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1085diagnostics.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)
510if (type.Type.IsRefLikeOrAllowsRefLikeType()) 583var elementType = ((PointerTypeSymbol)type.Type).PointedAtType; 601TypeChecks(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\SourceNamedTypeSymbol.cs (2)
62TypeSymbol bt = baseBinder.BindType(t, BindingDiagnosticBag.Discarded).Type; 1932if (!fieldSupported || elementType.Type.IsPointerOrFunctionPointer() || elementType.IsRestrictedType(ignoreSpanLikeTypes: true))
Symbols\Source\SourceNamedTypeSymbol_Bases.cs (4)
226var curBaseSym = baseBinder.BindType(b, BindingDiagnosticBag.Discarded).Type; 351static (type, arg, flag) => !type.Type.IsValueType && !type.NullableAnnotation.IsOblivious(), 471baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type; 540baseType = baseBinder.BindType(typeSyntax, diagnostics, newBasesBeingResolved).Type;
Symbols\Source\SourceNamedTypeSymbol_Enum.cs (1)
62var type = baseBinder.BindType(typeSyntax, diagnostics).Type;
Symbols\Source\SourceOrdinaryMethodSymbol.cs (4)
149diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, syntax.ReturnType.Location, returnType.Type); 211if (!parameter0Type.Type.IsValidExtensionParameterType()) 217diagnostics.Add(ErrorCode.ERR_BadTypeforThis, loc, parameter0Type.Type); 219else if (parameter0RefKind == RefKind.Ref && !parameter0Type.Type.IsValueType)
Symbols\Source\SourceParameterSymbolBase.cs (6)
95if (type.Type.ContainsDynamic()) 97AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 100if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 102AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 110if (type.Type.ContainsTupleNames()) 113compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Source\SourcePropertyAccessorSymbol.cs (2)
293CustomModifierUtils.CopyTypeCustomModifiers(type.Type, _lazyReturnType.Type, this.ContainingAssembly),
Symbols\Source\SourcePropertySymbol.cs (3)
587diagnostics.Add((this.IsIndexer ? ErrorCode.ERR_BadVisIndexerReturn : ErrorCode.ERR_BadVisPropertyType), Location, this, type.Type); 590if (type.Type.HasFileLocalTypes()) 600diagnostics.Add(ErrorCode.ERR_FileTypeDisallowedInSignature, Location, type.Type, containingType);
Symbols\Source\SourcePropertySymbolBase.cs (10)
257if (type.Type.Equals(overriddenPropertyType.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic)) 260CustomModifierUtils.CopyTypeCustomModifiers(overriddenPropertyType.Type, type.Type, this.ContainingAssembly), 1389if (type.Type.ContainsDynamic()) 1392compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + RefCustomModifiers.Length, _refKind)); 1395if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 1397AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 1400if (type.Type.ContainsTupleNames()) 1403compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Source\SourceTypeParameterSymbol.cs (2)
266if (!diagnostics.ReportUseSite(constraintType.Type, args.Args.Location)) 268constraintType.Type.CheckAllConstraints(args);
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (3)
259diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type); 262if (returnType.Type.IsStatic) 267diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(useWarning: false), returnTypeSyntax.Location, returnType.Type);
Symbols\Source\TypeParameterConstraintClause.cs (2)
174TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType; 234TypeSymbol type = constraintType.IsResolved ? constraintType.Type : constraintType.DefaultType;
Symbols\SubstitutedFieldSymbol.cs (1)
103return (NamedTypeSymbol)_containingType.TypeSubstitution.SubstituteType(OriginalDefinition.FixedImplementationType(emitModule)).Type;
Symbols\SubstitutedMethodSymbol.cs (3)
179return this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type; 394code = Hash.Combine(arg.Type, code); 415typeArguments[i].Type,
Symbols\Symbol.cs (1)
1231return DeriveUseSiteInfoFromType(ref result, type.Type) ||
Symbols\Symbol_Attributes.cs (1)
551var boundTypeSymbol = (NamedTypeSymbol)boundType.Type;
Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)
124printableMembers.Any(static m => m.GetTypeOrReturnType().Type.IsErrorType()))
Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)
40boolArrayType.Type,
Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (1)
44byteArrayType.Type,
Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (1)
610Debug.Assert(TypeSymbol.Equals(initializeResult.Type, _returnType.Type, TypeCompareKind.ConsiderEverything2));
Symbols\Synthesized\SynthesizedFieldSymbolBase.cs (1)
52var type = typeWithAnnotations.Type;
Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)
277MergeUseSiteInfo(ref result, ReturnTypeWithAnnotations.Type.GetUseSiteInfo());
Symbols\Synthesized\SynthesizedParameterSymbol.cs (6)
156if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes(BindingDiagnosticBag.Discarded, Location.None) && compilation.CanEmitBoolean()) 158AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind)); 161if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 163AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNativeIntegerAttribute(this, type.Type)); 171if (type.Type.ContainsTupleNames() && 176compilation.SynthesizeTupleNamesAttribute(type.Type));
Symbols\Tuples\TupleFieldSymbol.cs (1)
223newUnderlyingOwner = (NamedTypeSymbol)newUnderlyingOwner.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type;
Symbols\Tuples\TupleTypeSymbol.cs (5)
145underlyingType = ((NamedTypeSymbol)underlyingType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestIndex].Type); 213currentType = (NamedTypeSymbol)currentType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[NamedTypeSymbol.ValueTupleRestPosition - 1].Type; 712currentValueTuple = (NamedTypeSymbol)oldUnderlying.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestIndex].Type; 793found = (NamedTypeSymbol)found.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type; 985var extensionTupleElementTypes = tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[ValueTupleRestPosition - 1].Type.TupleElementTypesWithAnnotations;
Symbols\TypeMap.cs (1)
24public static readonly Func<TypeWithAnnotations, TypeSymbol> AsTypeSymbol = t => t.Type;
Symbols\TypeParameterSymbol.cs (5)
99((TypeSymbol)constraint.Type.OriginalDefinition).AddUseSiteInfo(ref useSiteInfo); 440if (ConstraintImpliesReferenceType(constraintType.Type)) 471if (constraintType.Type.IsNonNullableValueType()) 486bool? isNotNullable = ((TypeParameterSymbol)constraintType.Type).IsNotNullable; 510if (constraintType.Type.IsValueType)
Symbols\TypeParameterSymbolExtensions.cs (1)
23if (constraintType.Type is TypeParameterSymbol typeParameter)
Symbols\TypeSymbolExtensions.cs (14)
122if (constraintType.Type.IsNullableTypeOrTypeParameter()) 154return type.GetNullableUnderlyingTypeWithAnnotations().Type; 162underlyingType = nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 442type = ((NamedTypeSymbol)type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 748/// instead of <see cref="TypeWithAnnotations.Type"/> to avoid early resolution of nullable types</param> 770TypeSymbol current = type ?? (useDefaultType ? typeWithAnnotationsOpt.DefaultType : typeWithAnnotationsOpt.Type); 1255return type.Type?.ContainsNativeIntegerWrapperType() == true; 1598code = Hash.Combine(arg.Type, code); 1620typeArguments[i].Type.OriginalDefinition, 1954var type = typeWithAnnotations.Type; 2094if (type.Type.ContainsTupleNames()) 2096addIfNotNull(builder, compilation.SynthesizeTupleNamesAttribute(type.Type)); 2098if (compilation.ShouldEmitNativeIntegerAttributes(type.Type)) 2100addIfNotNull(builder, moduleBuilder.SynthesizeNativeIntegerAttribute(declaringSymbol, type.Type));
Symbols\TypeUnification.cs (24)
33Debug.Assert(substituted1.Type.Equals(substituted2.Type, TypeCompareKind.CLRSignatureCompareOptions)); 92if (TypeSymbol.Equals(t1.Type, t2.Type, TypeCompareKind.CLRSignatureCompareOptions) && t1.CustomModifiers.SequenceEqual(t2.CustomModifiers)) 99if (!t1.Type.IsTypeParameter() && t2.Type.IsTypeParameter()) 107Debug.Assert(t1.Type.IsTypeParameter() || !t2.Type.IsTypeParameter()); 109switch (t1.Type.Kind) 118ArrayTypeSymbol at1 = (ArrayTypeSymbol)t1.Type; 119ArrayTypeSymbol at2 = (ArrayTypeSymbol)t2.Type; 135PointerTypeSymbol pt1 = (PointerTypeSymbol)t1.Type; 136PointerTypeSymbol pt2 = (PointerTypeSymbol)t2.Type; 148NamedTypeSymbol nt1 = (NamedTypeSymbol)t1.Type; 149NamedTypeSymbol nt2 = (NamedTypeSymbol)t2.Type; 185if (t2.Type.IsPointerOrFunctionPointer() || t2.IsVoidType()) 190TypeParameterSymbol tp1 = (TypeParameterSymbol)t1.Type; 194if (Contains(t2.Type, tp1)) 207AddSubstitution(ref substitution, tp1, TypeWithAnnotations.Create(t2.Type)); 215TypeWithAnnotations.Create(t2.Type, 220if (t2.Type.IsTypeParameter()) 222var tp2 = (TypeParameterSymbol)t2.Type; 234TypeWithAnnotations.Create(t1.Type, 282if (Contains(typePart.Type, typeParam))
Symbols\TypeWithAnnotations.cs (49)
63public override string ToString() => Type.ToString(); 110if (NullableAnnotation.IsAnnotated() || (Type.IsValueType && Type.IsNullableType())) 115return Create(Type, NullableAnnotation.Annotated, CustomModifiers); 120if (NullableAnnotation.IsNotAnnotated() || (Type.IsValueType && !Type.IsNullableType())) 125return Create(Type, NullableAnnotation.NotAnnotated, CustomModifiers); 136if (Type?.IsPossiblyNullableReferenceTypeTypeParameter() == true) 141if (Type.IsNullableTypeOrTypeParameter()) 160return Type.IsNullableTypeOrTypeParameter(); 198var typeSymbol = this.Type; 243TypeSymbol typeSymbol = other.Type; 245TypeSymbol type = Type.MergeEquivalentTypes(typeSymbol, variance); 264public bool IsNullableType() => Type.IsNullableType(); 267/// The list of custom modifiers, if any, associated with the <see cref="Type"/>. 271public TypeKind TypeKind => Type.TypeKind; 273public Cci.PrimitiveTypeCode PrimitiveTypeCode => Type.PrimitiveTypeCode; 304var str = !HasType ? "<null>" : Type.ToDisplayString(format); 309(!HasType || (!IsNullableType() && !Type.IsValueType))) 315(!HasType || (!Type.IsValueType && !Type.IsTypeParameterDisallowingAnnotationInCSharp8()))) 377TypeSymbol type = Type; 408return obj.Type.GetHashCode(); 426return Type.GetUnificationUseSiteDiagnosticRecursive(ref result, owner, ref checkedTypes) || 445TypeSymbol typeSymbol = this.Type; 454if (typeSymbol.Equals(newTypeWithModifiers.Type, TypeCompareKind.ConsiderEverything) && 465return Create(newTypeWithModifiers.Type, NullableAnnotation, newCustomModifiers); 478if (newTypeWithModifiers.Type is PlaceholderTypeArgumentSymbol) 484Debug.Assert(newTypeWithModifiers.Type is not IndexedTypeParameterSymbol || newTypeWithModifiers.NullableAnnotation == NullableAnnotation.Ignored); 512Debug.Assert((object)newTypeWithModifiers.DefaultType == newTypeWithModifiers.Type); 534newTypeWithModifiers.Type, 544return Type.Equals(other.Type, comparison); 549binder.ReportDiagnosticsIfObsolete(diagnostics, Type, syntax, hasBaseReceiver: false); 596typeWithAnnotationsPredicate: (t, a, b) => t.NullableAnnotation != NullableAnnotation.Oblivious && !t.Type.IsErrorType() && !t.Type.IsValueType, 629var type = typeWithAnnotations.Type; 665TypeSymbol oldTypeSymbol = Type; 726var typeSymbol = Type; 737var typeSymbol = Type; 775return Type.GetHashCode(); 811return TypeWithState.Create(Type, getFlowState(Type, NullableAnnotation)); 1084TryForceResolve(asValueType: _underlying.Type.IsValueType); 1090internal override TypeSymbol GetNullableUnderlyingTypeOrSelf(TypeSymbol typeSymbol) => _underlying.Type; 1145if (!_underlying.Type.IsValueType) 1162if (newUnderlying.Type.Equals(this._underlying.Type, TypeCompareKind.ConsiderEverything) && 1204_underlying.Type;
Symbols\TypeWithState.cs (1)
42var type = typeWithAnnotations.Type;
Symbols\VarianceSafety.cs (2)
264IsVarianceUnsafe(constraintType.Type, 386TypeSymbol typeArg = namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[i].Type;
Utilities\TypeSymbolExtensions.cs (2)
76=> typeWithAnnotations.CustomModifiers.Length + typeWithAnnotations.Type.CustomModifierCount(); 158=> typeWithAnnotations.CustomModifiers.Any() || typeWithAnnotations.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds);