public static bool IsReadOnly(this TypeAccessModifiers modifiers) => (modifiers & TypeAccessModifiers.Readable) != 0;
public static TypeAccessModifiers GetRequiredAccessModifiers(this ITypeSymbol source, ITypeSymbol destination, out TypeAccessModifiers destModifiers)
{
Debug.Assert(source != null && destination != null);
var sourceExtended = source as IExtendedTypeSymbol;
var destinationExtended = destination as IExtendedTypeSymbol;
var sourceModifiers = sourceExtended?.AccessModifiers ?? TypeAccessModifiers.None;
destModifiers = destinationExtended?.AccessModifiers ?? TypeAccessModifiers.None;
if (sourceModifiers == destModifiers)
{
return(TypeAccessModifiers.None);
}
if ((destModifiers & TypeAccessModifiers.Readable) != 0 && sourceModifiers == 0)
{
sourceModifiers = TypeAccessModifiers.Readable;
}
var requiredModifiers = sourceModifiers ^ destModifiers;
return(requiredModifiers);
}
public static bool IsNone(this TypeAccessModifiers modifiers) => modifiers == TypeAccessModifiers.None;
public ExtendedArrayTypeSymbol(TypeSymbolWithAnnotations arrayWithAnnotations, ArrayTypeSymbol underlyingArray, TypeAccessModifiers accessModifiers) : base(underlyingArray.ElementType, underlyingArray.BaseTypeNoUseSiteDiagnostics)
{
_underlyingArray = underlyingArray;
_accessModifiers = accessModifiers;
}
//public static bool IsRef(this TypeAccessModifiers modifiers) => (modifiers & TypeAccessModifiers.Ref) != 0;
public static bool IsTransient(this TypeAccessModifiers modifiers) => (modifiers & TypeAccessModifiers.Transient) != 0;
public static TypeSymbol CreateExtendedTypeSymbol(CSharpSyntaxNode syntax, TypeSymbolWithAnnotations baseSymbol, TypeAccessModifiers accessModifiers)
{
if (baseSymbol.Kind == SymbolKind.NamedType)
{
return(new ExtendedNamedTypeSymbol(baseSymbol, accessModifiers));
}
if (baseSymbol.Kind == SymbolKind.ArrayType)
{
return(new ExtendedArrayTypeSymbol(baseSymbol, (ArrayTypeSymbol)baseSymbol.TypeSymbol, accessModifiers));
}
if (baseSymbol.Kind == SymbolKind.TypeParameter)
{
return(new ExtendedTypeParameterSymbol((TypeParameterSymbol)baseSymbol.TypeSymbol, accessModifiers));
}
throw new NotSupportedException($"The syntax `{syntax}` is not supported for extended type");
}
public ExtendedNamedTypeSymbol(TypeSymbolWithAnnotations elementType, TypeAccessModifiers accessModifiers) : base((NamedTypeSymbol)elementType.TypeSymbol)
{
_elementType = elementType;
_accessModifiers = accessModifiers;
}
internal override TypeSymbol MakeExtendedTypeSymbol(PEModuleSymbol moduleSymbol, TypeSymbol type, TypeAccessModifiers typeAccessModifiers)
{
switch (type.TypeKind)
{
case TypeKind.Array:
return(new ExtendedArrayTypeSymbol(TypeSymbolWithAnnotations.Create(type), (ArrayTypeSymbol)type, typeAccessModifiers));
case TypeKind.Class:
case TypeKind.Interface:
case TypeKind.Struct:
case TypeKind.Enum:
return(new ExtendedNamedTypeSymbol(TypeSymbolWithAnnotations.Create(type), typeAccessModifiers));
case TypeKind.TypeParameter:
return(new ExtendedTypeParameterSymbol((TypeParameterSymbol)type, typeAccessModifiers));
case TypeKind.ConstLiteral:
case TypeKind.Module:
case TypeKind.Submission:
case TypeKind.Pointer:
default:
throw ExceptionUtilities.UnexpectedValue(type.TypeKind);
}
}
public static bool IsRef(this TypeAccessModifiers modifiers) => (modifiers & TypeAccessModifiers.Ref) != 0;
protected TypeSymbol MakeExtendedTypeSymbol(TypeSymbol elementType, TypeAccessModifiers typeAccessModifieres)
{
return(_factory.MakeExtendedTypeSymbol(this.moduleSymbol, elementType, typeAccessModifieres));
}
public ExtendedTypeParameterSymbol(TypeParameterSymbol underlyingTypeParameter, TypeAccessModifiers modifiers) : base(underlyingTypeParameter)
{
AccessModifiers = modifiers;
}
internal abstract TypeSymbol MakeExtendedTypeSymbol(ModuleSymbol moduleSymbol, TypeSymbol type, TypeAccessModifiers typeAccessModifiers);
