nub31/nub-lang
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

WIP: dev #1

Draft
nub31 wants to merge 103 commits from dev into master
pull from: dev
merge into: nub31:master
Conversation 0 Commits 103 Files Changed 75 +242 -78
4 changed files with 242 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 3ebaa67b6d - Show all commits

108
compiler/ModuleGraph.cs
View File

@@ -191,7 +191,7 @@ public class ModuleGraph
return node switch
{
NodeTypeBool => NubTypeBool.Instance,
NodeTypeCustom type => ResolveCustomType(type, currentModule),
NodeTypeNamed type => ResolveNamedType(type, currentModule),
NodeTypeFunc type => NubTypeFunc.Get(type.Parameters.Select(x => ResolveType(x, currentModule)).ToList(), ResolveType(type.ReturnType, currentModule)),
NodeTypePointer type => NubTypePointer.Get(ResolveType(type.To, currentModule)),
NodeTypeSInt type => NubTypeSInt.Get(type.Width),
@@ -202,25 +202,103 @@ public class ModuleGraph
};
}
NubType ResolveCustomType(NodeTypeCustom type, string currentModule)
NubType ResolveNamedType(NodeTypeNamed type, string currentModule)
{
var module = modules.GetValueOrDefault(type.Module.Ident);
if (module == null)
throw new CompileException(Diagnostic.Error($"Unknown module: {type.Module.Ident}").Build());
var includePrivate = currentModule == type.Module.Ident;
if (!module.TryResolveType(type.Name.Ident, includePrivate, out var customType))
throw new CompileException(Diagnostic.Error($"Unknown custom type: {type.Module.Ident}::{type.Name.Ident}").Build());
return customType switch
return type.Sections.Count switch
{
Module.TypeInfoStruct => NubTypeStruct.Get(type.Module.Ident, type.Name.Ident),
Module.TypeInfoEnum => NubTypeEnum.Get(type.Module.Ident, type.Name.Ident),
_ => throw new ArgumentOutOfRangeException(nameof(customType))
3 => ResolveThreePartType(type.Sections[0], type.Sections[1], type.Sections[2], currentModule),
2 => ResolveTwoPartType(type.Sections[0], type.Sections[1], currentModule),
1 => ResolveOnePartType(type.Sections[0], currentModule),
_ => throw BasicError("Invalid type name")
};
}
NubType ResolveThreePartType(TokenIdent first, TokenIdent second, TokenIdent third, string currentModule)
{
var module = ResolveModule(first);
if (!module.TryResolveType(second.Ident, currentModule == module.Name, out var typeInfo))
throw BasicError($"Named type '{module.Name}::{second.Ident}' not found");
if (typeInfo is not Module.TypeInfoEnum enumInfo)
throw BasicError($"'{module.Name}::{second.Ident}' is not an enum");
var variant = enumInfo.Variants.FirstOrDefault(v => v.Name == third.Ident);
if (variant == null)
throw BasicError($"Enum '{module.Name}::{second.Ident}' does not have a variant named '{third.Ident}'");
return NubTypeEnumVariant.Get(NubTypeEnum.Get(module.Name, second.Ident), third.Ident);
}
NubType ResolveTwoPartType(TokenIdent first, TokenIdent second, string currentModule)
{
if (TryResolveEnumVariant(currentModule, first.Ident, second.Ident, out var variant))
return variant;
var module = ResolveModule(first);
if (!module.TryResolveType(second.Ident, currentModule == module.Name, out var typeInfo))
throw BasicError($"Named type '{module.Name}::{second.Ident}' not found");
return typeInfo switch
{
Module.TypeInfoStruct => NubTypeStruct.Get(module.Name, second.Ident),
Module.TypeInfoEnum => NubTypeEnum.Get(module.Name, second.Ident),
_ => throw new ArgumentOutOfRangeException(nameof(typeInfo))
};
}
NubType ResolveOnePartType(TokenIdent name, string currentModule)
{
if (!modules.TryGetValue(currentModule, out var module))
throw BasicError($"Module '{currentModule}' not found");
if (!module.TryResolveType(name.Ident, true, out var typeInfo))
throw BasicError($"Named type '{module.Name}::{name.Ident}' not found");
return typeInfo switch
{
Module.TypeInfoStruct => NubTypeStruct.Get(module.Name, name.Ident),
Module.TypeInfoEnum => NubTypeEnum.Get(module.Name, name.Ident),
_ => throw new ArgumentOutOfRangeException(nameof(typeInfo))
};
}
Module ResolveModule(TokenIdent name)
{
if (!modules.TryGetValue(name.Ident, out var module))
throw BasicError($"Module '{name.Ident}' not found");
return module;
}
bool TryResolveEnumVariant(string moduleName, string enumName, string variantName, [NotNullWhen(true)] out NubType? result)
{
result = null;
if (!modules.TryGetValue(moduleName, out var module))
return false;
if (!module.TryResolveType(enumName, true, out var typeInfo))
return false;
if (typeInfo is not Module.TypeInfoEnum enumInfo)
return false;
var variant = enumInfo.Variants.FirstOrDefault(v => v.Name == variantName);
if (variant == null)
return false;
result = NubTypeEnumVariant.Get(
NubTypeEnum.Get(moduleName, enumName),
variantName);
return true;
}
Exception BasicError(string message)
{
return new CompileException(Diagnostic.Error(message).Build());
}
Module GetOrCreateModule(string name)
{
if (!modules.TryGetValue(name, out var module))

18
compiler/Parser.cs
View File

@@ -384,7 +384,7 @@ public class Parser
var module = ExpectIdent();
ExpectSymbol(Symbol.ColonColon);
var enumName = ExpectIdent();
ExpectSymbol(Symbol.Period);
ExpectSymbol(Symbol.ColonColon);
var variantName = ExpectIdent();
var initializers = new List<NodeExpressionEnumLiteral.Initializer>();
@@ -484,9 +484,14 @@ public class Parser
case "u64":
return new NodeTypeUInt(TokensFrom(startIndex), 64);
default:
ExpectSymbol(Symbol.ColonColon);
var name = ExpectIdent();
return new NodeTypeCustom(TokensFrom(startIndex), ident, name);
List<TokenIdent> secitons = [ident];
while (TryExpectSymbol(Symbol.ColonColon))
{
ident = ExpectIdent();
secitons.Add(ident);
}
return new NodeTypeNamed(TokensFrom(startIndex), secitons);
}
}
@@ -938,10 +943,9 @@ public class NodeTypeBool(List<Token> tokens) : NodeType(tokens);
public class NodeTypeString(List<Token> tokens) : NodeType(tokens);
public class NodeTypeCustom(List<Token> tokens, TokenIdent module, TokenIdent name) : NodeType(tokens)
public class NodeTypeNamed(List<Token> tokens, List<TokenIdent> sections) : NodeType(tokens)
{
public TokenIdent Module { get; } = module;
public TokenIdent Name { get; } = name;
public List<TokenIdent> Sections { get; } = sections;
}
public class NodeTypePointer(List<Token> tokens, NodeType to) : NodeType(tokens)

190
compiler/TypeChecker.cs
View File

@@ -1,22 +1,25 @@
namespace Compiler;
using System.Data.Common;
using System.Diagnostics.CodeAnalysis;
namespace Compiler;
public class TypeChecker
{
public static TypedNodeDefinitionFunc? CheckFunction(string fileName, string moduleName, NodeDefinitionFunc function, ModuleGraph moduleGraph, out List<Diagnostic> diagnostics)
public static TypedNodeDefinitionFunc? CheckFunction(string fileName, string currentModule, NodeDefinitionFunc function, ModuleGraph moduleGraph, out List<Diagnostic> diagnostics)
{
return new TypeChecker(fileName, moduleName, function, moduleGraph).CheckFunction(out diagnostics);
return new TypeChecker(fileName, currentModule, function, moduleGraph).CheckFunction(out diagnostics);
}
private TypeChecker(string fileName, string moduleName, NodeDefinitionFunc function, ModuleGraph moduleGraph)
private TypeChecker(string fileName, string currentModule, NodeDefinitionFunc function, ModuleGraph moduleGraph)
{
this.fileName = fileName;
this.moduleName = moduleName;
this.currentModule = currentModule;
this.function = function;
this.moduleGraph = moduleGraph;
}
private readonly string fileName;
private readonly string moduleName;
private readonly string currentModule;
private readonly NodeDefinitionFunc function;
private readonly ModuleGraph moduleGraph;
private readonly Scope scope = new();
@@ -72,7 +75,7 @@ public class TypeChecker
if (body == null || returnType is null || invalidParameter)
return null;
return new TypedNodeDefinitionFunc(function.Tokens, moduleName, function.Name, parameters, body, returnType);
return new TypedNodeDefinitionFunc(function.Tokens, currentModule, function.Name, parameters, body, returnType);
}
}
@@ -329,15 +332,9 @@ public class TypeChecker
private TypedNodeExpressionModuleIdent CheckExpressionModuleIdent(NodeExpressionModuleIdent expression)
{
if (!moduleGraph.TryResolveModule(expression.Module.Ident, out var module))
throw new CompileException(Diagnostic.Error($"Module '{expression.Module.Ident}' not found").At(fileName, expression.Module).Build());
var includePrivate = expression.Module.Ident == moduleName;
if (!module.TryResolveIdentifier(expression.Value.Ident, includePrivate, out var identifierType))
throw new CompileException(Diagnostic.Error($"Identifier '{expression.Module.Ident}::{expression.Value.Ident}' not found").At(fileName, expression.Value).Build());
return new TypedNodeExpressionModuleIdent(expression.Tokens, identifierType.Type, expression.Module, expression.Value);
var module = ResolveModule(expression.Module);
var info = ResolveModuleIdentifier(module, expression.Value);
return new TypedNodeExpressionModuleIdent(expression.Tokens, info.Type, expression.Module, expression.Value);
}
private TypedNodeExpressionIntLiteral CheckExpressionIntLiteral(NodeExpressionIntLiteral expression)
@@ -356,7 +353,7 @@ public class TypeChecker
if (!moduleGraph.TryResolveModule(structType.Module, out var module))
throw new CompileException(Diagnostic.Error($"Module '{structType.Module}' not found").At(fileName, expression.Target).Build());
if (!module.TryResolveType(structType.Name, moduleName == structType.Module, out var typeDef))
if (!module.TryResolveType(structType.Name, currentModule == structType.Module, out var typeDef))
throw new CompileException(Diagnostic.Error($"Type '{structType.Name}' not found in module '{structType.Module}'").At(fileName, expression.Target).Build());
if (typeDef is not Module.TypeInfoStruct structDef)
@@ -373,7 +370,7 @@ public class TypeChecker
if (!moduleGraph.TryResolveModule(enumVariantType.EnumType.Module, out var module))
throw new CompileException(Diagnostic.Error($"Module '{enumVariantType.EnumType.Module}' not found").At(fileName, expression.Target).Build());
if (!module.TryResolveType(enumVariantType.EnumType.Name, moduleName == enumVariantType.EnumType.Module, out var typeDef))
if (!module.TryResolveType(enumVariantType.EnumType.Name, currentModule == enumVariantType.EnumType.Module, out var typeDef))
throw new CompileException(Diagnostic.Error($"Type '{enumVariantType.EnumType.Name}' not found in module '{enumVariantType.EnumType.Module}'").At(fileName, expression.Target).Build());
if (typeDef is not Module.TypeInfoEnum enumDef)
@@ -412,21 +409,12 @@ public class TypeChecker
private TypedNodeExpressionStructLiteral CheckExpressionStructLiteral(NodeExpressionStructLiteral expression)
{
if (!moduleGraph.TryResolveModule(expression.Module.Ident, out var module))
throw new CompileException(Diagnostic.Error($"Module '{expression.Module.Ident}' not found").At(fileName, expression.Module).Build());
var includePrivate = expression.Module.Ident == moduleName;
if (!module.TryResolveType(expression.Name.Ident, includePrivate, out var typeDef))
throw new CompileException(Diagnostic.Error($"Struct '{expression.Module.Ident}::{expression.Name.Ident}' not found").At(fileName, expression.Name).Build());
if (typeDef is not Module.TypeInfoStruct structDef)
throw new CompileException(Diagnostic.Error($"Cannot create struct literal of non-struct type '{expression.Module.Ident}::{expression.Name.Ident}'").At(fileName, expression.Name).Build());
var info = ResolveModuleStruct(ResolveModule(expression.Module), expression.Name);
var initializers = new List<TypedNodeExpressionStructLiteral.Initializer>();
foreach (var initializer in expression.Initializers)
{
var field = structDef.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident);
var field = info.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident);
if (field == null)
throw new CompileException(Diagnostic.Error($"Field '{initializer.Name.Ident}' does not exist on struct '{expression.Module.Ident}::{expression.Name.Ident}'").At(fileName, initializer.Name).Build());
@@ -442,18 +430,9 @@ public class TypeChecker
private TypedNodeExpressionEnumLiteral CheckExpressionEnumLiteral(NodeExpressionEnumLiteral expression)
{
if (!moduleGraph.TryResolveModule(expression.Module.Ident, out var module))
throw new CompileException(Diagnostic.Error($"Module '{expression.Module.Ident}' not found").At(fileName, expression.Module).Build());
var info = ResolveModuleEnum(ResolveModule(expression.Module), expression.EnumName);
var includePrivate = expression.Module.Ident == moduleName;
if (!module.TryResolveType(expression.EnumName.Ident, includePrivate, out var typeDef))
throw new CompileException(Diagnostic.Error($"Enum '{expression.Module.Ident}::{expression.EnumName.Ident}' not found").At(fileName, expression.EnumName).Build());
if (typeDef is not Module.TypeInfoEnum enumDef)
throw new CompileException(Diagnostic.Error($"Cannot create enum literal of non-enum type '{expression.Module.Ident}::{expression.EnumName.Ident}'").At(fileName, expression.EnumName).Build());
var variant = enumDef.Variants.FirstOrDefault(x => x.Name == expression.VariantName.Ident);
var variant = info.Variants.FirstOrDefault(x => x.Name == expression.VariantName.Ident);
if (variant == null)
throw new CompileException(Diagnostic.Error($"Enum '{expression.Module.Ident}::{expression.EnumName.Ident}' does not have a variant '{expression.VariantName.Ident}'").At(fileName, expression.VariantName).Build());
@@ -479,7 +458,7 @@ public class TypeChecker
return node switch
{
NodeTypeBool => NubTypeBool.Instance,
NodeTypeCustom type => ResolveCustomType(type),
NodeTypeNamed type => ResolveNamedType(type),
NodeTypeFunc type => NubTypeFunc.Get(type.Parameters.Select(ResolveType).ToList(), ResolveType(type.ReturnType)),
NodeTypePointer type => NubTypePointer.Get(ResolveType(type.To)),
NodeTypeSInt type => NubTypeSInt.Get(type.Width),
@@ -490,24 +469,127 @@ public class TypeChecker
};
}
private NubType ResolveCustomType(NodeTypeCustom type)
private NubType ResolveNamedType(NodeTypeNamed type)
{
if (!moduleGraph.TryResolveModule(type.Module.Ident, out var module))
throw new CompileException(Diagnostic.Error($"Module '{type.Module.Ident}' not found").At(fileName, type.Module).Build());
var includePrivate = type.Module.Ident == moduleName;
if (!module.TryResolveType(type.Name.Ident, includePrivate, out var customType))
throw new CompileException(Diagnostic.Error($"Custom type '{type.Module.Ident}::{type.Name.Ident}' not found").At(fileName, type.Name).Build());
return customType switch
return type.Sections.Count switch
{
Module.TypeInfoStruct => NubTypeStruct.Get(type.Module.Ident, type.Name.Ident),
Module.TypeInfoEnum => NubTypeEnum.Get(type.Module.Ident, type.Name.Ident),
_ => throw new ArgumentOutOfRangeException(nameof(customType))
3 => ResolveThreePartType(type.Sections[0], type.Sections[1], type.Sections[2]),
2 => ResolveTwoPartType(type.Sections[0], type.Sections[1]),
1 => ResolveOnePartType(type.Sections[0]),
_ => throw BasicError("Invalid type name", type)
};
}
private NubType ResolveThreePartType(TokenIdent first, TokenIdent second, TokenIdent third)
{
if (TryResolveEnumVariant(currentModule, second.Ident, third.Ident, out var variantType))
return variantType;
throw BasicError($"Enum '{first.Ident}::{second.Ident}::{third.Ident}' does not have a variant named '{third.Ident}'", third);
}
private NubType ResolveTwoPartType(TokenIdent first, TokenIdent second)
{
if (TryResolveEnumVariant(currentModule, first.Ident, second.Ident, out var variantType))
return variantType;
var typeInfo = ResolveModuleTypeInfo(ResolveModule(first), second);
return typeInfo switch
{
Module.TypeInfoStruct => NubTypeStruct.Get(first.Ident, second.Ident),
Module.TypeInfoEnum => NubTypeEnum.Get(first.Ident, second.Ident),
_ => throw new ArgumentOutOfRangeException(nameof(typeInfo))
};
}
private NubType ResolveOnePartType(TokenIdent name)
{
if (!moduleGraph.TryResolveModule(currentModule, out var module))
throw BasicError($"Module '{currentModule}' not found", name);
var typeInfo = ResolveModuleTypeInfo(module, name);
return typeInfo switch
{
Module.TypeInfoStruct => NubTypeStruct.Get(currentModule, name.Ident),
Module.TypeInfoEnum => NubTypeEnum.Get(currentModule, name.Ident),
_ => throw new ArgumentOutOfRangeException(nameof(typeInfo))
};
}
private Module ResolveModule(TokenIdent name)
{
if (!moduleGraph.TryResolveModule(name.Ident, out var module))
throw BasicError($"Module '{name.Ident}' not found", name);
return module;
}
private Module.IdentifierInfo ResolveModuleIdentifier(Module module, TokenIdent name)
{
if (!module.TryResolveIdentifier(name.Ident, currentModule == module.Name, out var type))
throw BasicError($"Identifier '{module.Name}::{name.Ident}' not found", name);
return type;
}
private Module.TypeInfo ResolveModuleTypeInfo(Module module, TokenIdent name)
{
if (!module.TryResolveType(name.Ident, currentModule == module.Name, out var type))
throw BasicError($"Named type '{module.Name}::{name.Ident}' not found", name);
return type;
}
private Module.TypeInfoEnum ResolveModuleEnum(Module module, TokenIdent name)
{
var type = ResolveModuleTypeInfo(module, name);
if (type is not Module.TypeInfoEnum info)
throw BasicError($"'{module.Name}::{name.Ident}' is not an enum", name);
return info;
}
private Module.TypeInfoStruct ResolveModuleStruct(Module module, TokenIdent name)
{
var type = ResolveModuleTypeInfo(module, name);
if (type is not Module.TypeInfoStruct info)
throw BasicError($"'{module.Name}::{name.Ident}' is not a struct", name);
return info;
}
private bool TryResolveEnumVariant(string moduleName, string enumName, string variantName, [NotNullWhen(true)] out NubType? result)
{
result = null;
if (!moduleGraph.TryResolveModule(moduleName, out var module))
return false;
if (!module.TryResolveType(enumName, true, out var type))
return false;
if (type is not Module.TypeInfoEnum enumInfo)
return false;
var variant = enumInfo.Variants.FirstOrDefault(v => v.Name == variantName);
if (variant == null)
return false;
result = NubTypeEnumVariant.Get(NubTypeEnum.Get(moduleName, enumName), variantName);
return true;
}
private CompileException BasicError(string message, TokenIdent ident)
{
return new CompileException(Diagnostic.Error(message).At(fileName, ident).Build());
}
private CompileException BasicError(string message, Node node)
{
return new CompileException(Diagnostic.Error(message).At(fileName, node).Build());
}
private sealed class Scope
{
private readonly Stack<Dictionary<string, NubType>> scopes = new();

4
examples/math/math.nub
View File

@@ -3,7 +3,7 @@ module math
struct vec2 { x: i32 y: i32 }
struct vec3 { x: i32 y: i32 z: i32 }
struct color { r: i32 g: i32 b: i32 a: i32 }
struct example { a: math::vec2 b: math::vec3 c: math::color }
struct example { a: vec2 b: vec3 c: color }
export enum message {
quit
@@ -15,7 +15,7 @@ export enum message {
export func add(a: i32 b: i32): i32
{
let message: math::message = enum math::message.move { x = 1 y = 1 }
let message: message = enum math::message::move { x = 1 y = 1 }
match message {
quit q {}