808 references to Type
Microsoft.CodeAnalysis.CSharp (808)
Binder\Binder.NamespaceOrTypeOrAliasSymbolWithAnnotations.cs (1)
37internal Symbol Symbol => _symbol ?? TypeWithAnnotations.Type;
Binder\Binder.ValueChecks.cs (3)
4641Debug.Assert(elementType.Type is { }); 4642return !LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, elementType.Type); 4662if (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)
609if (ContainsNestedTypeOfUnconstructedGenericType(typeArgument.Type)) 924(!unusedDiagnostics.HasAnyErrors() && typeArgument.Type is CrefTypeParameterSymbol)); 993TypeSymbol 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)
2270TypeSymbol returnType = members[i].GetTypeOrReturnType().Type;
Binder\Binder_Lambda.cs (1)
303var type = returnType.Type;
Binder\Binder_Lookup.cs (1)
1827type = ((FieldSymbol)symbol).GetFieldType(this.FieldsBeingBound).Type;
Binder\Binder_Operators.cs (4)
1028namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type.SpecialType is SpecialType.System_Byte; 2764result = Hash.Combine(result, typeComparer.GetHashCode(typeWithAnnotations.Type)); 3736TypeSymbol targetType = targetTypeWithAnnotations.Type; 4088TypeSymbol 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)
468if (!fixedResultType.Type.IsErrorType()) 477var errorTypeName = fixedResultType.Type.Name; 506TypeParameterSymbol typeParameter = (TypeParameterSymbol)type.Type; 539var methodTypeParameter = (TypeParameterSymbol)methodTypeParameterWithAnnotations.Type; 573return typeMap.SubstituteType(delegateOrFunctionPointerType).Type; 613ExactOrBoundsKind kind = GetRefKind(arg).IsManagedReference() || target.Type.IsPointerType() ? ExactOrBoundsKind.Exact : ExactOrBoundsKind.LowerBound; 635if (argument.Kind == BoundKind.UnboundLambda && target.Type.GetDelegateType() is { }) 649if (IsReallyAType(argumentType.Type)) 655var ordinal = GetOrdinal((TypeParameterSymbol)target.Type); // Tracked by https://github.com/dotnet/roslyn/issues/76130 : test nullability scenario where the override of ordinals matters 668TypeSymbol targetType = target.Type; 703Debug.Assert(target.Type is { }); 704if (target.Type is null) 725if (target.Type.Kind != SymbolKind.NamedType) 731var destination = (NamedTypeSymbol)target.Type; 887if (HasUnfixedParamInOutputType(argument, formalType.Type) && !HasUnfixedParamInInputType(argument, formalType.Type)) 905if (!binder.TryGetCollectionIterationType((ExpressionSyntax)argument.Syntax, formalType.Type, out TypeWithAnnotations targetElementType)) 921if (formalType.Type.Kind != SymbolKind.NamedType) 927var destination = (NamedTypeSymbol)formalType.Type; 1144var formalParameterType = _formalParameterTypes[iArg].Type; 1386if (MethodGroupReturnTypeInference(binder, expression, target.Type, ref useSiteInfo)) 1408var delegateType = target.Type.GetDelegateType(); 1430Debug.Assert(inferredReturnType.Type is not FunctionTypeSymbol); 1569var delegateType = target.Type.GetDelegateType(); 1622var delegateInvokeMethod = target.Type.GetDelegateType()?.DelegateInvokeMethod(); 1667if (ExactSpanInference(source.Type, target.Type, ref useSiteInfo)) 1712if (!source.Type.IsArray() || !target.Type.IsArray()) 1717var arraySource = (ArrayTypeSymbol)source.Type; 1718var arrayTarget = (ArrayTypeSymbol)target.Type; 1807ExactOrBoundsInference(kind, ((NamedTypeSymbol)source.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ((NamedTypeSymbol)target.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0], ref useSiteInfo); 1841if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) || 1842!target.Type.TryGetElementTypesWithAnnotationsIfTupleType(out targetTypes) || 1865var namedSource = source.Type as NamedTypeSymbol; 1871var namedTarget = target.Type as NamedTypeSymbol; 1890ExactInference(((PointerTypeSymbol)source.Type).PointedAtTypeWithAnnotations, ((PointerTypeSymbol)target.Type).PointedAtTypeWithAnnotations, ref useSiteInfo); 1893else if (source.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int sourceParameterCount } sourceSignature } && 1894target.Type is FunctionPointerTypeSymbol { Signature: { ParameterCount: int targetParameterCount } targetSignature } && 2004if (LowerBoundArrayInference(source.Type, target.Type, ref useSiteInfo)) 2011if (LowerBoundSpanInference(source.Type, target.Type, ref useSiteInfo)) 2048if (LowerBoundConstructedInference(source.Type, target.Type, ref useSiteInfo)) 2053if (LowerBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2137if (elementSource.Type.IsReferenceType) 2172if (!sourceElementType.Type.IsReferenceType || target.IsSpan()) 2512Debug.Assert(source.Type.IsReferenceType || source.Type.IsFunctionPointer()); 2529if (UpperBoundFunctionPointerTypeInference(source.Type, target.Type, ref useSiteInfo)) 2564if (!target.Type.IsArray()) 2568var arrayTarget = (ArrayTypeSymbol)target.Type; 2570var elementSource = GetMatchingElementType(arrayTarget, source.Type, ref useSiteInfo); 2576if (elementSource.Type.IsReferenceType) 2597var source = sourceWithAnnotations.Type; 2598var target = targetWithAnnotations.Type; 2849Debug.Assert(best.Type.Type.Equals(withoutNullability.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 3013functionType = type.Type as FunctionTypeSymbol; 3020return constraintTypes.Any(static t => isExpressionType(t.Type)); 3039var source = sourceWithAnnotations.Type; 3040var destination = destinationWithAnnotations.Type; 3318if (!dest.Type.ContainsTypeParameter(pParam)) 3462var newBound = TypeWithAnnotations.Create(oldBound.Type, newAnnotation); 3488if (newCandidate.Type.IsDynamic()) 3519return obj.Type.GetHashCode(); 3526if (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 { }); 2602Debug.Assert(paramsElementTypeOpt.Type != (object)ErrorTypeSymbol.EmptyParamsCollectionElementTypeSentinel); 2603return paramsElementTypeOpt.Type; 3225t1, kind1, elementType1.Type, underlyingElementConversions1: [], 3226t2, kind2, elementType2.Type, underlyingElementConversions2: [], 3240elementType = typeArg.Type; 3283if (x.HasType && Conversions.HasIdentityConversion(x.Type, y)) 3293y = ((NamedTypeSymbol)y).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3386if (!ExpressionMatchExactly(sourceArguments[i], destTypes[i].Type, ref useSiteInfo)) 3533return BetterConversionTargetCore(((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3534((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, 3644var type1Element = ((NamedTypeSymbol)type1).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 3645var type2Element = ((NamedTypeSymbol)type2).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type; 4064TryInferParamsCollectionIterationType(binder, type.Type, out paramsIterationType); 4337if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions)) 4579&& parameters.ParameterTypes[argumentPosition].Type is NamedTypeSymbol { IsInterpolatedStringHandlerType: true, IsValueType: true }) 4592parameters.ParameterTypes[argumentPosition].Type, 4604(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)
525var otherType = type.WithTypeAndModifiers((TypeSymbol?)this.Visit(type.Type), this.VisitCustomModifiers(type.CustomModifiers)); 743return 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)
1222else if (!_alreadyReported[slot] && !symbol.GetTypeOrReturnType().Type.IsErrorType()) 1692TypeSymbol structType = variable.Symbol.GetTypeOrReturnType().Type; 1728TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type; 1764TypeSymbol type = id.Symbol.GetTypeOrReturnType().Type;
FlowAnalysis\DefiniteAssignment.LocalFunctions.cs (1)
105var type = id.Symbol.GetTypeOrReturnType().Type;
FlowAnalysis\LocalDataFlowPass.cs (1)
126var variableType = symbol.GetTypeOrReturnType().Type;
FlowAnalysis\NullableWalker.cs (85)
130Debug.Assert(TypeSymbol.Equals(RValueType.Type, LValueType.Type, TypeCompareKind.ConsiderEverything)); 765if (symbolType.Type.IsValueType || symbolType.Type.IsErrorType()) 797var badState = symbolType.Type.IsPossiblyNullableReferenceTypeTypeParameter() && (annotations & FlowAnalysisAnnotations.NotNull) == 0 855SetState(ref this.State, memberSlot, type.Type.IsPossiblyNullableReferenceTypeTypeParameter() ? NullableFlowState.MaybeDefault : NullableFlowState.MaybeNull); 2363type.Type.IsValueType) 2380if (type.Type.IsTypeParameterDisallowingAnnotationInCSharp8() && !(type.Type is TypeParameterSymbol { IsNotNullable: true })) 2406!targetType.Type.Equals(valueType.Type, TypeCompareKind.AllIgnoreOptions)) 2639InheritDefaultState(targetType.Type, targetSlot); 2645if (targetType.Type.IsReferenceType || 2654else if (EmptyStructTypeCache.IsTrackableStructType(targetType.Type)) 2656InheritNullableStateOfTrackableStruct(targetType.Type, targetSlot, valueSlot, isDefaultValue: !(valueOpt is null) && IsDefaultValue(valueOpt), skipSlot: targetSlot); 2662target.Type.Equals(assignedValue.Type, TypeCompareKind.AllIgnoreOptions); 2733if (fieldOrPropertyType.Type.IsReferenceType || 2762else if (EmptyStructTypeCache.IsTrackableStructType(fieldOrPropertyType.Type)) 2772InheritNullableStateOfTrackableStruct(fieldOrPropertyType.Type, targetMemberSlot, valueMemberSlot, isDefaultValue: isDefaultValue, skipSlot); 2855private static TypeSymbol GetTypeOrReturnType(Symbol symbol) => symbol.GetTypeOrReturnType().Type; 2887typeWithAnnotations = TypeWithAnnotations.Create(typeWithAnnotations.Type, nullableAnnotation); 2988if (EmptyStructTypeCache.IsTrackableStructType(parameterType.Type)) 2991parameterType.Type, 3024return TypeWithState.Create(parameterType.Type, NullableFlowState.MaybeDefault); 3029return TypeWithState.Create(parameterType.Type, NullableFlowState.NotNull); 3053returnType.Type.SpecialType == SpecialType.System_Boolean) 3161type = ((NamedTypeSymbol)returnType.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single(); 3188if (!node.Type.Equals(type.Type, TypeCompareKind.ConsiderEverything | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamicAndTupleNames)) 3193Debug.Assert(node.Type.IsErrorType() || type.Type.IsErrorType()); 3556VisitObjectCreationInitializer(resultSlot, resultType.Type, withExpr.InitializerExpression, delayCompletionForType: false); 3609InheritDefaultState(GetDeclaredLocalResult(local).Type, slot); 3667Debug.Assert(type.Type.IsErrorType()); 3746return AnonymousTypeManager.GetAnonymousTypeFieldTypes(type).Any(static t => canIgnoreAnyType(t.Type)); 3926var strippedTargetCollectionType = targetCollectionType.Type.StrippedType(); 4083Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4085var type = resultTypeWithAnnotations.Type; 4162if (AreNullableAndUnderlyingTypes(type, parameterType.Type, out TypeWithAnnotations underlyingType)) 4489Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4547Debug.Assert(TypeSymbol.Equals(containingType, receiverResult.LValueType.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 4799inferredType = TypeWithState.Create(inferredType.Type, elementState).ToTypeWithAnnotations(compilation); 5339if (isLifted && targetTypeWithNullability.Type.IsNonNullableValueType()) 5718Debug.Assert(targetType.Type.ContainsErrorType() || 5720TypeSymbol.Equals(targetType.Type.GetNullableUnderlyingType(), node.Type, TypeCompareKind.AllIgnoreOptions)); 5724leftSlot = GetNullableOfTValueSlot(targetType.Type, leftSlot, out _); 5730Debug.Assert(TypeSymbol.Equals(targetType.Type, rightResult.Type, TypeCompareKind.AllIgnoreOptions)); 5734TypeWithState resultType = TypeWithState.Create(targetType.Type, rightResult.State); 5994TypeSymbol accessType = accessTypeWithAnnotations.Type; 6188var typeWithState = TypeWithState.Create(resultTypeWithAnnotations.Type, resultState); 6201return TypeWithState.Create(resultTypeWithAnnotations.Type, resultState); 6316new BoundExpressionWithNullability(expr.Syntax, expr, type.NullableAnnotation, type.Type); 7655conversion = GenerateConversion(_conversions, argumentNoConversion, argumentResultType, parameterType.Type, fromExplicitCast: false, extensionMethodThisArgument: false, isChecked: conversionOpt?.Checked ?? false); 7659ReportNullabilityMismatchInArgument(argumentNoConversion.Syntax, argumentResultType, parameter, parameterType.Type, forOutput: false); 7691if (IsNullabilityMismatch(lvalueResultType.Type, parameterType.Type)) 7694ReportNullabilityMismatchInRefArgument(argumentNoConversion, argumentType: lvalueResultType.Type, parameter, parameterType.Type); 7798parameterWithState = TypeWithState.Create(parameterType.Type, adjustedState); 7855if (!_conversions.HasIdentityOrImplicitReferenceConversion(parameterType.Type, lValueType.Type, ref discardedUseSiteInfo)) 7857ReportNullabilityMismatchInArgument(argument.Syntax, lValueType.Type, parameter, parameterType.Type, forOutput: true); 8092OverloadResolution.TryInferParamsCollectionIterationType(_binder, type.Type, out paramsIterationType); 8285return new BoundExpressionWithNullability(argument.Syntax, argument, argumentType.NullableAnnotation, argumentType.Type); 8569if (TypeAllowsConditionalState(targetType.Type) && TypeAllowsConditionalState(operand.Type)) 8682if (typeArg.Type.Equals(underlyingTypeOpt, TypeCompareKind.AllIgnoreOptions)) 9103operandType = completion(targetTypeWithNullability.Type.GetNullableUnderlyingTypeWithAnnotations()); 9131TypeSymbol targetType = targetTypeWithNullability.Type; 9447if (targetType.Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == true) 9456dependsOnTypeParameter(typeParameter1, (TypeParameterSymbol)targetType.Type, NullableAnnotation.NotAnnotated, out var annotation)) 9463if (targetType.Type?.IsTypeParameterDisallowingAnnotationInCSharp8() == false) 9487targetType.Type is TypeParameterSymbol typeParameter2) 9537if (constraintType.Type is TypeParameterSymbol constraintTypeParameter && 9641TypeSymbol targetType = targetTypeWithNullability.Type; 9811bool typeNeedsLifting = returnType.Type.IsNonNullableValueType(); 9812TypeSymbol type = typeNeedsLifting ? MakeNullableOf(returnType) : returnType.Type; 9856var conversion = _conversions.ClassifyStandardConversion(operandType.Type, targetType.Type, ref discardedUseSiteInfo); 9861ReportNullabilityMismatchInArgument(diagnosticLocation, operandType.Type, parameterOpt, targetType.Type, forOutput: false); 9865ReportNullabilityMismatchInAssignment(diagnosticLocation, operandType.Type, targetType.Type); 9946Debug.Assert(TypeSymbol.Equals(resultTypeWithAnnotations.Type, node.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); 9947var delegateType = (NamedTypeSymbol)resultTypeWithAnnotations.Type; 10126arguments.Add(new BoundExpressionWithNullability(syntax, new BoundParameter(syntax, parameter), parameterType.NullableAnnotation, parameterType.Type)); 10299SetResult(node, TypeWithState.Create(leftLValueType.Type, rightState.State), leftLValueType); 10643var valueBeforeNullableWrapping = TypeWithState.Create(underlyingType.Type, NullableFlowState.NotNull); 10959if (argumentType.Type is { } argType && IsNullabilityMismatch(paramType.Type, argType)) 10961ReportNullabilityMismatchInArgument(argument.Syntax, argType, parameter, paramType.Type, forOutput: false); 11483conversion = _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)
117return TypeMap.SubstituteType(type).Type;
Lowering\ClosureConversion\ClosureConversion.cs (5)
999while (!TypeSymbol.Equals(oldTypeArg.Type, newTypeArg.Type, TypeCompareKind.ConsiderEverything)); 1003Debug.Assert((object)oldTypeArg.Type == newTypeArg.Type); 1697var 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)
148visitedTypeArgs.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); 564var 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; 950if (typeArgument.Type.IsPointerOrFunctionPointer() || typeArgument.IsRestrictedType(ignoreSpanLikeTypes: true) || typeArgument.IsVoidType()) 953diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_BadTypeArgument, typeArgument.Type)))); 957if (typeArgument.Type.IsRefLikeOrAllowsRefLikeType()) 976diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NotRefStructConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 984diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_GenericArgIsStaticClass, typeArgument.Type)))); 990if (!typeArgument.Type.IsReferenceType) 993diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_RefConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1003var managedKind = typeArgument.Type.GetManagedKind(ref useSiteInfo); 1006if (managedKind == ManagedKind.Managed || !typeArgument.Type.IsNonNullableValueType()) 1009diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_UnmanagedConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1030if (typeParameter.HasValueTypeConstraint && !typeArgument.Type.IsNonNullableValueType()) 1033diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_ValConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1059if (typeArgument.Type.IsErrorType()) 1081if (typeArgument.Type is NamedTypeSymbol { IsInterface: true } iface && SelfOrBaseHasStaticAbstractMember(iface, ref useSiteInfo, out Symbol member)) 1110var error = SatisfiesConstructorConstraint(typeArgument.Type); 1118diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintNotSatisfied, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1122diagnosticsBuilder.Add(new TypeParameterDiagnosticInfo(typeParameter, new UseSiteInfo<AssemblySymbol>(new CSDiagnosticInfo(ErrorCode.ERR_NewConstraintCannotHaveRequiredMembers, containingSymbol.ConstructedFrom(), typeParameter, typeArgument.Type)))); 1139if (typeParameter.HasNotNullConstraint && typeArgument.GetValueNullableAnnotation().IsAnnotated() && !typeArgument.Type.IsNonNullableValueType()) 1179if (typeArgument.Type.IsReferenceType) 1185errorCode = constraintType.Type.IsInterfaceType() ? ErrorCode.ERR_GenericConstraintNotSatisfiedNullableInterface : ErrorCode.ERR_GenericConstraintNotSatisfiedNullableEnum; 1199if (constraintType.Type.Equals(typeArgument.Type, TypeCompareKind.AllIgnoreOptions)) 1201constraintTypeErrorArgument = constraintType.Type; 1202typeArgumentErrorArgument = typeArgument.Type; 1206SymbolDistinguisher distinguisher = new SymbolDistinguisher(args.CurrentCompilation, constraintType.Type, typeArgument.Type); 1216var type = typeWithAnnotations.Type; 1259var type = typeWithAnnotations.Type; 1338if (constraintType.Type.IsErrorType()) 1349if (conversions.HasIdentityOrImplicitReferenceConversion(typeArgument.Type, constraintType.Type, ref useSiteInfo)) 1354if (typeArgument.Type.IsValueType) 1358if (conversions.HasBoxingConversion(typeArgument.Type.IsNullableType() ? ((NamedTypeSymbol)typeArgument.Type).ConstructedFrom : typeArgument.Type, 1359constraintType.Type, ref useSiteInfo)) 1364if (typeArgument.Type is NamedTypeSymbol { IsRefLikeType: true } refLike && 1365conversions.ImplementsVarianceCompatibleInterface(refLike, constraintType.Type, ref useSiteInfo)) 1373var typeParameter = (TypeParameterSymbol)typeArgument.Type; 1377if (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)
352if (parameterType.Type.ContainsPointerOrFunctionPointer()) 440count += methodReturnType.Type.CustomModifierCount(); 446count += paramType.Type.CustomModifierCount(); 489count += type.Type.CustomModifierCount(); 495count += 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)) 965if (!IsOrContainsErrorType(overridingMemberType.Type)) 967diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1003if (DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMethod.ReturnTypeWithAnnotations.Type, overriddenMethod.ReturnTypeWithAnnotations.Type, ref discardedUseSiteInfo)) 1068if (!IsOrContainsErrorType(overridingMemberType.Type)) 1073DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingMemberType.Type, overriddenMemberType.Type, ref discardedUseSiteInfo)) 1077diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportCovariantPropertiesOfClasses, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1089diagnostics.Add(ErrorCode.ERR_CantChangeTypeOnOverride, overridingMemberLocation, overridingMember, overriddenMember, overriddenMemberType.Type); 1209var result = DeclaringCompilation.Conversions.HasIdentityOrImplicitReferenceConversion(overridingReturnType.Type, overriddenReturnType.Type, ref useSiteInfo); 1274overrideReturnType.Type, 1275baseMethod.ReturnTypeWithAnnotations.Type)) 1307baseParameterType.Type, 1308overrideParameterType.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)
343diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type); 346if (returnType.Type.IsStatic) 351diagnostics.Add(ErrorFacts.GetStaticClassReturnCode(useWarning: false), returnTypeSyntax.Location, returnType.Type);
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)
103return (NamedTypeSymbol)_containingType.TypeSubstitution.SubstituteType(OriginalDefinition.FixedImplementationType(emitModule)).Type;
Symbols\SubstitutedMethodSymbol.cs (3)
179return this.TypeArgumentsWithAnnotations[reducedFromTypeParameter.Ordinal].Type; 397code = Hash.Combine(arg.Type, code); 418typeArguments[i].Type,
Symbols\Symbol.cs (1)
1231return DeriveUseSiteInfoFromType(ref result, type.Type) ||
Symbols\Symbol_Attributes.cs (1)
550var 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)
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)
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)
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);