private ES_AstTypeDeclaration_TypeReference GenerateASTTypeRef(
ArrayPointer <byte> transUnitName, SymbolStack <FrontendSymbol> symbols, SourceData src,
ES_AstTypeDeclaration typeDecl
)
{
Debug.Assert(typeDecl is not null);
if (typeDecl is ES_AstTypeDeclaration_TypeReference)
{
return((typeDecl as ES_AstTypeDeclaration_TypeReference) !);
}
var type = ResolveTypeDeclaration(transUnitName, symbols, src, typeDecl);
if (type == null)
{
type = Environment !.TypeUnknownValue;
}
return(new ES_AstTypeDeclaration_TypeReference(typeDecl, type));
}
private ES_TypeInfo *ResolveTypeDeclaration(
ArrayPointer <byte> transUnitName, SymbolStack <FrontendSymbol> symbols, SourceData src,
ES_AstTypeDeclaration typeDecl
)
{
Debug.Assert(EnvironmentBuilder is not null);
switch (typeDecl)
{
case ES_AstTypeDeclaration_TypeName typeName: {
var type = GetType(symbols, src, typeName);
switch (type->AccessModifier)
{
case ES_AccessModifier.Public: break;
case ES_AccessModifier.Internal:
if (!type->SourceUnit.Equals(transUnitName))
{
using var symbolName = PooledArray <char> .GetArray(typeName.GetStringLength());
typeName.ToString(symbolName);
var err = ES_FrontendErrors.GenInaccessibleProtectionLevel(
symbolName.Span.GetPooledString(), src, typeName.NodeBounds
);
errorList.Add(err);
}
break;
default:
throw new NotImplementedException("Access modifier not implemented yet.");
}
return(type);
}
case ES_AstTypeDeclaration_TypeReference typeRef:
return(typeRef.Reference);
case ES_AstTypeDeclaration_Array arrayDecl: {
var elemType = ResolveTypeDeclaration(transUnitName, symbols, src, arrayDecl.ElementType);
return(EnvironmentBuilder.CreateArrayType(elemType, arrayDecl.Dimensions));
}
case ES_AstTypeDeclaration_Basic basicDecl: {
var innerType = ResolveTypeDeclaration(transUnitName, symbols, src, basicDecl.Inner !);
switch (basicDecl.Type)
{
case ES_AstTypeDeclaration_Basic.DeclType.Const:
if (innerType->IsConstant())
{
errorList.Add(ES_FrontendErrors.GenTypeAlreadyConst(
false, innerType->TypeTag == ES_TypeTag.Immutable,
src, basicDecl.NodeBounds
));
return(innerType);
}
return(EnvironmentBuilder.CreateConstType(innerType));
case ES_AstTypeDeclaration_Basic.DeclType.Immutable:
if (innerType->IsConstant())
{
errorList.Add(ES_FrontendErrors.GenTypeAlreadyConst(
false, innerType->TypeTag == ES_TypeTag.Immutable,
src, basicDecl.NodeBounds
));
return(innerType);
}
return(EnvironmentBuilder.CreateImmutableType(innerType));
case ES_AstTypeDeclaration_Basic.DeclType.Nullable:
return(EnvironmentBuilder.CreateNullableType(innerType));
case ES_AstTypeDeclaration_Basic.DeclType.Reference:
return(EnvironmentBuilder.CreateReferenceType(innerType));
default:
throw new NotImplementedException("Basic declaration type not implemented.");
}
}
default:
throw new NotImplementedException("Declaration type not implemented.");
}
}
