private static TypeSymbolWithAnnotations SubstituteAllTypeParameters(AbstractTypeMap substitution, TypeSymbolWithAnnotations type)
{
if (substitution != null)
{
TypeSymbolWithAnnotations previous;
do
{
previous = type;
type = type.SubstituteType(substitution);
} while (!type.IsSameAs(previous));
}
return(type);
}
internal override bool ApplyNullableTransforms(byte defaultTransformFlag, ImmutableArray <byte> transforms, ref int position, out TypeSymbol result)
{
TypeSymbolWithAnnotations oldElementType = ElementType;
TypeSymbolWithAnnotations newElementType;
if (!oldElementType.ApplyNullableTransforms(defaultTransformFlag, transforms, ref position, out newElementType))
{
result = this;
return(false);
}
result = WithElementType(newElementType);
return(true);
}
/// <summary>
/// If the type reference has an associated NullableAttribute, this method
/// returns the type transformed to have IsNullable set to true or false
/// (but not null) for each reference type in the type.
/// </summary>
internal static TypeSymbolWithAnnotations TransformType(
TypeSymbolWithAnnotations metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule,
INonNullTypesContext nonNullTypesContext)
{
Debug.Assert(!metadataType.IsNull);
ImmutableArray <bool> nullableTransformFlags;
containingModule.Module.HasNullableAttribute(targetSymbolToken, out nullableTransformFlags);
return(TransformType(metadataType, nullableTransformFlags, nonNullTypesContext));
}
internal static TypeSymbolWithAnnotations TransformType(TypeSymbolWithAnnotations metadataType, ImmutableArray <bool> nullableTransformFlags, INonNullTypesContext nonNullTypesContext)
{
int position = 0;
TypeSymbolWithAnnotations result;
if (metadataType.ApplyNullableTransforms(nullableTransformFlags, nonNullTypesContext, ref position, out result) &&
(nullableTransformFlags.IsDefault || position == nullableTransformFlags.Length))
{
return(result);
}
// No NullableAttribute applied to the target symbol, or flags do not line-up, return unchanged metadataType.
return(metadataType);
}
public SignatureOnlyParameterSymbol(
TypeSymbolWithAnnotations type,
ImmutableArray <CustomModifier> refCustomModifiers,
bool isParams,
RefKind refKind)
{
Debug.Assert((object)type.TypeSymbol != null);
Debug.Assert(!refCustomModifiers.IsDefault);
_type = type;
_refCustomModifiers = refCustomModifiers;
_isParams = isParams;
_refKind = refKind;
}
/// <summary>
/// If the type reference has an associated NullableAttribute, this method
/// returns the type transformed to have IsNullable set to true or false
/// (but not null) for each reference type in the type.
/// </summary>
internal static TypeSymbolWithAnnotations TransformType(
TypeSymbolWithAnnotations metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule)
{
Debug.Assert(!metadataType.IsNull);
byte defaultTransformFlag;
ImmutableArray <byte> nullableTransformFlags;
containingModule.Module.HasNullableAttribute(targetSymbolToken, out defaultTransformFlag, out nullableTransformFlags);
return(TransformType(metadataType, defaultTransformFlag, nullableTransformFlags));
}
private BoundLocal GetBoundPatternMatchingLocal(TypeSymbol type)
{
// All synthesized pattern matching locals are associated with the Switch statement syntax node.
// Their ordinals are zero.
// EnC local slot variable matching logic find the right slot based on the type of the local.
if (!localByType.TryGetValue(type, out var localSymbol))
{
localSymbol = new SynthesizedLocal(_enclosingSymbol as MethodSymbol, TypeSymbolWithAnnotations.Create(type), SynthesizedLocalKind.SwitchCasePatternMatching, _switchSyntax);
localByType.Add(type, localSymbol);
}
return(new BoundLocal(_switchSyntax, localSymbol, null, type));
}
private LambdaCapturedVariable(SynthesizedContainer frame, TypeSymbolWithAnnotations type, string fieldName, bool isThisParameter)
: base(frame,
fieldName,
isPublic: true,
isReadOnly: false,
isStatic: false)
{
Debug.Assert(!type.IsNull);
// lifted fields do not need to have the CompilerGeneratedAttribute attached to it, the closure is already
// marked as being compiler generated.
_type = type;
_isThis = isThisParameter;
}
public EELocalSymbol(
MethodSymbol method,
ImmutableArray <Location> locations,
string nameOpt,
int ordinal,
LocalDeclarationKind declarationKind,
TypeSymbol type,
RefKind refKind,
bool isPinned,
bool isCompilerGenerated,
bool canScheduleToStack)
: this(method, locations, nameOpt, ordinal, declarationKind, TypeSymbolWithAnnotations.Create(type), refKind, isPinned, isCompilerGenerated, canScheduleToStack)
{
}
private TypeSymbolWithAnnotations GetTypeSymbol()
{
var diagnostics = DiagnosticBag.GetInstance();
Binder typeBinder = this.TypeSyntaxBinder;
bool isVar;
TypeSymbolWithAnnotations declType;
if (_typeSyntax == null) // In recursive patterns the type may be omitted.
{
isVar = true;
declType = default;
}
else
{
declType = typeBinder.BindTypeOrVarKeyword(_typeSyntax, diagnostics, out isVar);
}
if (isVar)
{
var inferredType = InferTypeOfVarVariable(diagnostics);
// If we got a valid result that was not void then use the inferred type
// else create an error type.
if (!inferredType.IsNull &&
inferredType.SpecialType != SpecialType.System_Void)
{
declType = inferredType;
}
else
{
declType = TypeSymbolWithAnnotations.Create(typeBinder.CreateErrorType("var"));
}
}
Debug.Assert(!declType.IsNull);
//
// Note that we drop the diagnostics on the floor! That is because this code is invoked mainly in
// IDE scenarios where we are attempting to use the types of a variable before we have processed
// the code which causes the variable's type to be inferred. In batch compilation, on the
// other hand, local variables have their type inferred, if necessary, in the course of binding
// the statements of a method from top to bottom, and an inferred type is given to a variable
// before the variable's type is used by the compiler.
//
diagnostics.Free();
return(declType);
}
public static ParameterSymbol Create(
MethodSymbol container,
TypeSymbolWithAnnotations type,
int ordinal,
RefKind refKind,
string name = "",
ImmutableArray <CustomModifier> refCustomModifiers = default(ImmutableArray <CustomModifier>))
{
if (refCustomModifiers.IsDefaultOrEmpty)
{
return(new SynthesizedParameterSymbol(container, type, ordinal, refKind, name));
}
return(new SynthesizedParameterSymbolWithCustomModifiers(container, type, ordinal, refKind, name, refCustomModifiers));
}
// https://github.com/dotnet/roslyn/issues/29821 external annotations should be removed or fully designed/productized
internal static TypeSymbolWithAnnotations TransformType(
TypeSymbolWithAnnotations metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule,
ImmutableArray <byte> extraAnnotations)
{
if (extraAnnotations.IsDefault)
{
return(NullableTypeDecoder.TransformType(metadataType, targetSymbolToken, containingModule));
}
else
{
return(NullableTypeDecoder.TransformType(metadataType, defaultTransformFlag: 0, extraAnnotations));
}
}
// https://github.com/dotnet/roslyn/issues/29821 external annotations should be removed or fully designed/productized
internal static TypeSymbolWithAnnotations TransformType(
TypeSymbolWithAnnotations metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule,
ImmutableArray <bool> extraAnnotations)
{
if (extraAnnotations.IsDefault)
{
return(NullableTypeDecoder.TransformType(metadataType, targetSymbolToken, containingModule));
}
else
{
return(NullableTypeDecoder.TransformType(metadataType, extraAnnotations).WithNonNullTypesContext(NonNullTypesTrueContext.Instance));
}
}
private void VisitTypeSymbolWithAnnotations(TypeSymbolWithAnnotations type, AbstractSymbolDisplayVisitor visitorOpt = null)
{
var visitor = (SymbolDisplayVisitor)(visitorOpt ?? this.NotFirstVisitor);
var typeSymbol = type.TypeSymbol;
if (typeSymbol.TypeKind == TypeKind.Array)
{
visitor.VisitArrayType((IArrayTypeSymbol)typeSymbol, typeOpt: type);
}
else
{
typeSymbol.Accept(visitor);
AddNullableAnnotations(type);
}
}
internal static ArrayTypeSymbol CreateMDArray(
TypeSymbolWithAnnotations elementType,
int rank,
ImmutableArray <int> sizes,
ImmutableArray <int> lowerBounds,
NamedTypeSymbol array)
{
// Optimize for most common case - no sizes and all dimensions are zero lower bound.
if (sizes.IsDefaultOrEmpty && lowerBounds.IsDefault)
{
return(new MDArrayNoSizesOrBounds(elementType, rank, array));
}
return(new MDArrayWithSizesAndBounds(elementType, rank, sizes, lowerBounds, array));
}
Cci.ITypeReference Cci.IFieldReference.GetType(EmitContext context)
{
TypeSymbolWithAnnotations oldType = _underlyingField.Type;
var customModifiers = oldType.CustomModifiers;
var type = ((PEModuleBuilder)context.Module).Translate(oldType.TypeSymbol, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics);
if (customModifiers.Length == 0)
{
return(type);
}
else
{
return(new Cci.ModifiedTypeReference(type, customModifiers.As <Cci.ICustomModifier>()));
}
}
Cci.ITypeReference Cci.IArrayTypeReference.GetElementType(EmitContext context)
{
PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module;
TypeSymbolWithAnnotations elementType = this.ElementType;
var type = moduleBeingBuilt.Translate(elementType.TypeSymbol, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics);
if (elementType.CustomModifiers.Length == 0)
{
return(type);
}
else
{
return(new Cci.ModifiedTypeReference(type, elementType.CustomModifiers.As <Cci.ICustomModifier>()));
}
}
internal void SetType(TypeSymbolWithAnnotations newType)
{
Debug.Assert(!(newType.TypeSymbol is null));
TypeSymbol originalType = _type.DefaultType;
// In the event that we race to set the type of a local, we should
// always deduce the same type, or deduce that the type is an error.
Debug.Assert((object)originalType == null ||
originalType.IsErrorType() && newType.IsErrorType() ||
TypeSymbol.Equals(originalType, newType.TypeSymbol, TypeCompareKind.ConsiderEverything2));
if ((object)originalType == null)
{
_type.InterlockedInitialize(newType);
}
}
public SynthesizedParameterSymbolBase(
MethodSymbol container,
TypeSymbolWithAnnotations type,
int ordinal,
RefKind refKind,
string name = "")
{
Debug.Assert(!type.IsNull);
Debug.Assert(name != null);
Debug.Assert(ordinal >= 0);
_container = container;
_type = type;
_ordinal = ordinal;
_refKind = refKind;
_name = name;
}
public static TypeSymbolWithAnnotations CreateExtendedTypeSymbol(CSharpSyntaxNode syntax, TypeSymbolWithAnnotations baseSymbol, TypeAccessModifiers accessModifiers, DiagnosticBag diagnostics)
{
if (baseSymbol.Kind == SymbolKind.NamedType)
{
return(TypeSymbolWithAnnotations.Create(new ExtendedNamedTypeSymbol(baseSymbol, accessModifiers)));
}
if (baseSymbol.Kind == SymbolKind.ArrayType)
{
return(TypeSymbolWithAnnotations.Create(new ExtendedArrayTypeSymbol(baseSymbol, (ArrayTypeSymbol)baseSymbol.TypeSymbol, accessModifiers)));
}
if (baseSymbol.Kind == SymbolKind.TypeParameter)
{
return(TypeSymbolWithAnnotations.Create(new ExtendedTypeParameterSymbol((TypeParameterSymbol)baseSymbol.TypeSymbol, accessModifiers)));
}
throw new NotSupportedException($"The syntax `{syntax}` is not supported");
}
private static SmallDictionary <TypeParameterSymbol, TypeSymbolWithAnnotations> ConstructMapping(ImmutableArray <TypeParameterSymbol> from, ImmutableArray <TypeSymbolWithAnnotations> to)
{
var mapping = new SmallDictionary <TypeParameterSymbol, TypeSymbolWithAnnotations>(ReferenceEqualityComparer.Instance);
Debug.Assert(from.Length == to.Length);
for (int i = 0; i < from.Length; i++)
{
TypeParameterSymbol tp = from[i];
TypeSymbolWithAnnotations ta = to[i];
if (!ta.Is(tp))
{
mapping.Add(tp, ta);
}
}
return(mapping);
}
public PEParameterSymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
ImmutableArray <ModifierInfo <TypeSymbol> > refCustomModifiers,
TypeSymbolWithAnnotations type,
ImmutableArray <bool> extraAnnotations,
ParameterHandle handle,
out bool isBad) :
base(moduleSymbol, containingSymbol, ordinal, isByRef, type, extraAnnotations, handle,
refCustomModifiers.NullToEmpty().Length + type.CustomModifiers.Length,
out isBad)
{
_refCustomModifiers = CSharpCustomModifier.Convert(refCustomModifiers);
Debug.Assert(_refCustomModifiers.IsEmpty || isByRef);
}
private static ImmutableArray <MethodSymbol> GetAdditionalNullableAttributeConstructors(
CSharpCompilation compilation,
NamedTypeSymbol containingType,
DiagnosticBag diagnostics)
{
var boolType = compilation.GetSpecialType(SpecialType.System_Boolean);
Binder.ReportUseSiteDiagnostics(boolType, diagnostics, Location.None);
var boolArray = TypeSymbolWithAnnotations.Create(
ArrayTypeSymbol.CreateSZArray(
boolType.ContainingAssembly,
TypeSymbolWithAnnotations.Create(boolType)));
return(ImmutableArray.Create <MethodSymbol>(
new SynthesizedEmbeddedAttributeConstructorSymbol(
containingType,
m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, boolArray, 0, RefKind.None)))));
}
protected override TypeSymbolWithAnnotations InferTypeOfVarVariable(DiagnosticBag diagnostics)
{
switch (_nodeToBind.Kind())
{
case SyntaxKind.ThisConstructorInitializer:
case SyntaxKind.BaseConstructorInitializer:
var initializer = (ConstructorInitializerSyntax)_nodeToBind;
_nodeBinder.BindConstructorInitializer(initializer, diagnostics);
break;
case SyntaxKind.ArgumentList:
var invocation = (ConstructorInitializerSyntax)_nodeToBind.Parent;
_nodeBinder.BindConstructorInitializer(invocation, diagnostics);
break;
case SyntaxKind.CasePatternSwitchLabel:
_nodeBinder.BindPatternSwitchLabelForInference((CasePatternSwitchLabelSyntax)_nodeToBind, diagnostics);
break;
//case SyntaxKind.VariableDeclaration:
// // This occurs, for example, in
// // int x, y[out var Z, 1 is int I];
// // for (int x, y[out var Z, 1 is int I]; ;) {}
// _nodeBinder.BindDeclaratorArguments((VariableDeclarationSyntax)_nodeToBind, diagnostics);
// break;
case SyntaxKind.SwitchExpressionArm:
var arm = (SwitchExpressionArmSyntax)_nodeToBind;
var armBinder = (SwitchExpressionArmBinder)_nodeBinder;
armBinder.BindSwitchExpressionArm(arm, diagnostics);
break;
default:
_nodeBinder.BindExpression((ExpressionSyntax)_nodeToBind, diagnostics);
break;
}
if (this._type.IsNull)
{
Debug.Assert(this.DeclarationKind == LocalDeclarationKind.DeclarationExpressionVariable);
SetType(TypeSymbolWithAnnotations.Create(_nodeBinder.CreateErrorType("var")));
}
return(_type.ToType());
}
private ArrayTypeSymbol SubstituteArrayType(ArrayTypeSymbol t)
{
var oldElement = t.ElementType;
TypeSymbolWithAnnotations element = oldElement.SubstituteTypeWithTupleUnification(this);
if (element.IsSameAs(oldElement))
{
return(t);
}
if (t.IsSZArray)
{
ImmutableArray <NamedTypeSymbol> interfaces = t.InterfacesNoUseSiteDiagnostics();
Debug.Assert(0 <= interfaces.Length && interfaces.Length <= 2);
if (interfaces.Length == 1)
{
Debug.Assert(interfaces[0] is NamedTypeSymbol); // IList<T>
interfaces = ImmutableArray.Create <NamedTypeSymbol>(SubstituteNamedType(interfaces[0]));
}
else if (interfaces.Length == 2)
{
Debug.Assert(interfaces[0] is NamedTypeSymbol); // IList<T>
interfaces = ImmutableArray.Create <NamedTypeSymbol>(SubstituteNamedType(interfaces[0]), SubstituteNamedType(interfaces[1]));
}
else if (interfaces.Length != 0)
{
throw ExceptionUtilities.Unreachable;
}
return(ArrayTypeSymbol.CreateSZArray(
element,
t.BaseTypeNoUseSiteDiagnostics,
interfaces));
}
return(ArrayTypeSymbol.CreateMDArray(
element,
t.Rank,
t.Sizes,
t.LowerBounds,
t.BaseTypeNoUseSiteDiagnostics));
}
private TypeSymbolWithAnnotations ComputeReturnType(DiagnosticBag diagnostics)
{
if (this.MethodKind == MethodKind.PropertyGet)
{
var type = _property.Type;
if (!ContainingType.IsInterfaceType() && type.TypeSymbol.IsStatic)
{
// '{0}': static types cannot be used as return types
diagnostics.Add(ErrorCode.ERR_ReturnTypeIsStaticClass, this.locations[0], type.TypeSymbol);
}
return(type);
}
else
{
var binder = GetBinder();
return(TypeSymbolWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_Void, diagnostics, this.GetSyntax())));
}
}
internal SynthesizedSubmissionConstructor(NamedTypeSymbol containingType, DiagnosticBag diagnostics)
: base(containingType)
{
Debug.Assert(containingType.TypeKind == TypeKind.Submission);
Debug.Assert(diagnostics != null);
var compilation = containingType.DeclaringCompilation;
var submissionArrayType = compilation.CreateArrayTypeSymbol(compilation.GetSpecialType(SpecialType.System_Object));
var useSiteError = submissionArrayType.GetUseSiteDiagnostic();
if (useSiteError != null)
{
diagnostics.Add(useSiteError, NoLocation.Singleton);
}
_parameters = ImmutableArray.Create <ParameterSymbol>(
SynthesizedParameterSymbol.Create(this, TypeSymbolWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray"));
}
/// <remarks>
/// Out params are updated by assignment. If you require thread-safety, pass temps and then
/// CompareExchange them back into shared memory.
/// </remarks>
internal static void CopyMethodCustomModifiers(
MethodSymbol sourceMethod,
MethodSymbol destinationMethod,
out TypeSymbolWithAnnotations returnType,
out ImmutableArray <CustomModifier> customModifiers,
out ImmutableArray <ParameterSymbol> parameters,
bool alsoCopyParamsModifier) // Last since always named.
{
Debug.Assert((object)sourceMethod != null);
// Assert: none of the method's type parameters have been substituted
Debug.Assert((object)sourceMethod == sourceMethod.ConstructedFrom);
// For the most part, we will copy custom modifiers by copying types.
// The only time when this fails is when the type refers to a type parameter
// owned by the overridden method. We need to replace all such references
// with (equivalent) type parameters owned by this method. We know that
// we can perform this mapping positionally, because the method signatures
// have already been compared.
MethodSymbol constructedSourceMethod = sourceMethod.ConstructIfGeneric(destinationMethod.TypeArguments);
customModifiers =
destinationMethod.RefKind != RefKind.None ? constructedSourceMethod.RefCustomModifiers : ImmutableArray <CustomModifier> .Empty;
parameters = CopyParameterCustomModifiers(constructedSourceMethod.Parameters, destinationMethod.Parameters, alsoCopyParamsModifier);
returnType = destinationMethod.ReturnType; // Default value - in case we don't copy the custom modifiers.
TypeSymbol returnTypeSymbol = returnType.TypeSymbol;
var sourceMethodReturnType = constructedSourceMethod.ReturnType;
// We do an extra check before copying the return type to handle the case where the overriding
// method (incorrectly) has a different return type than the overridden method. In such cases,
// we want to retain the original (incorrect) return type to avoid hiding the return type
// given in source.
TypeSymbol returnTypeWithCustomModifiers = sourceMethodReturnType.TypeSymbol;
if (returnTypeSymbol.Equals(returnTypeWithCustomModifiers, TypeCompareKind.AllIgnoreOptions))
{
returnType = returnType.WithTypeAndModifiers(CopyTypeCustomModifiers(returnTypeWithCustomModifiers, returnTypeSymbol, destinationMethod.ContainingAssembly),
sourceMethodReturnType.CustomModifiers);
}
}
public SignatureOnlyPropertySymbol(
string name,
TypeSymbol containingType,
ImmutableArray <ParameterSymbol> parameters,
RefKind refKind,
TypeSymbolWithAnnotations type,
ImmutableArray <CustomModifier> refCustomModifiers,
bool isStatic,
ImmutableArray <PropertySymbol> explicitInterfaceImplementations)
{
_refKind = refKind;
_type = type;
_refCustomModifiers = refCustomModifiers;
_isStatic = isStatic;
_parameters = parameters;
_explicitInterfaceImplementations = explicitInterfaceImplementations.NullToEmpty();
_containingType = containingType;
_name = name;
}
internal static TypeSymbolWithAnnotations TransformType(TypeSymbolWithAnnotations metadataType, byte defaultTransformFlag, ImmutableArray <byte> nullableTransformFlags)
{
if (nullableTransformFlags.IsDefault && defaultTransformFlag == 0)
{
return(metadataType);
}
int position = 0;
TypeSymbolWithAnnotations result;
if (metadataType.ApplyNullableTransforms(defaultTransformFlag, nullableTransformFlags, ref position, out result) &&
(nullableTransformFlags.IsDefault || position == nullableTransformFlags.Length))
{
return(result);
}
// No NullableAttribute applied to the target symbol, or flags do not line-up, return unchanged metadataType.
return(metadataType);
}
