diff --git a/compiler/ModuleGraph.cs b/compiler/ModuleGraph.cs index e41ad03..6559b27 100644 --- a/compiler/ModuleGraph.cs +++ b/compiler/ModuleGraph.cs @@ -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)) diff --git a/compiler/Parser.cs b/compiler/Parser.cs index 253c2d5..ed30ba6 100644 --- a/compiler/Parser.cs +++ b/compiler/Parser.cs @@ -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(); @@ -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 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 tokens) : NodeType(tokens); public class NodeTypeString(List tokens) : NodeType(tokens); -public class NodeTypeCustom(List tokens, TokenIdent module, TokenIdent name) : NodeType(tokens) +public class NodeTypeNamed(List tokens, List sections) : NodeType(tokens) { - public TokenIdent Module { get; } = module; - public TokenIdent Name { get; } = name; + public List Sections { get; } = sections; } public class NodeTypePointer(List tokens, NodeType to) : NodeType(tokens) diff --git a/compiler/TypeChecker.cs b/compiler/TypeChecker.cs index f48dc42..0062529 100644 --- a/compiler/TypeChecker.cs +++ b/compiler/TypeChecker.cs @@ -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 diagnostics) + public static TypedNodeDefinitionFunc? CheckFunction(string fileName, string currentModule, NodeDefinitionFunc function, ModuleGraph moduleGraph, out List 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(); 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> scopes = new(); diff --git a/examples/math/math.nub b/examples/math/math.nub index 59d3446..14215c9 100644 --- a/examples/math/math.nub +++ b/examples/math/math.nub @@ -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 {}