diff --git a/compiler/Generator.cs b/compiler/Generator.cs index 2681bea..61b4ef9 100644 --- a/compiler/Generator.cs +++ b/compiler/Generator.cs @@ -85,7 +85,7 @@ public class Generator case Module.TypeInfoEnum e: { writer.WriteLine(); - writer.Write($"struct {NameMangler.Mangle(module.Name, name, NubTypeStruct.Get(module.Name, name))}"); + writer.Write($"struct {NameMangler.Mangle(module.Name, name, NubTypeEnum.Get(module.Name, name))}"); writer.WriteLine("{"); using (writer.Indent()) { @@ -96,7 +96,7 @@ public class Generator { foreach (var variant in e.Variants) { - writer.WriteLine($"struct {variant.Name}"); + writer.WriteLine("struct"); writer.WriteLine("{"); using (writer.Indent()) { @@ -105,7 +105,7 @@ public class Generator writer.WriteLine($"{CType(field.Type, field.Name)};"); } } - writer.WriteLine("};"); + writer.WriteLine($"}} {variant.Name};"); } } writer.WriteLine("};"); @@ -165,7 +165,7 @@ public class Generator { if (!moduleGraph.TryResolveIdentifier(function.Module, function.Name.Ident, true, out var info)) throw new UnreachableException($"Module graph does not have info about the function {function.Module}::{function.Name.Ident}. This should have been caught earlier"); - + if (info.Kind == Module.DefinitionKind.Internal) writer.Write("static "); @@ -209,6 +209,9 @@ public class Generator case TypedNodeStatementWhile statement: EmitStatementWhile(statement); break; + case TypedNodeStatementMatch statement: + EmitStatementMatch(statement); + break; default: throw new ArgumentOutOfRangeException(nameof(node), node, null); } @@ -286,7 +289,38 @@ public class Generator writer.WriteLine("{"); using (writer.Indent()) { - EmitStatement(statement.Block); + EmitStatement(statement.Body); + } + writer.WriteLine("}"); + } + + private void EmitStatementMatch(TypedNodeStatementMatch statement) + { + var target = EmitExpression(statement.Target); + var enumType = (NubTypeEnum)statement.Target.Type; + + if (!moduleGraph.TryResolveType(enumType.Module, enumType.Name, true, out var info)) + throw new UnreachableException(); + + var enumInfo = (Module.TypeInfoEnum)info; + + writer.WriteLine($"switch ({target}.tag)"); + writer.WriteLine("{"); + using (writer.Indent()) + { + foreach (var @case in statement.Cases) + { + var tag = enumInfo.Variants.ToList().FindIndex(x => x.Name == @case.Type.Ident); + + writer.WriteLine($"case {tag}:"); + writer.WriteLine("{"); + using (writer.Indent()) + { + writer.WriteLine($"auto {@case.VariableName.Ident} = {target}.{@case.Type.Ident};"); + EmitStatement(@case.Body); + } + writer.WriteLine("}"); + } } writer.WriteLine("}"); } @@ -301,6 +335,7 @@ public class Generator TypedNodeExpressionIntLiteral expression => expression.Value.Value.ToString(), TypedNodeExpressionStringLiteral expression => $"(struct nub_core_string){{ \"{expression.Value.Value}\", {expression.Value.Value.Length} }}", TypedNodeExpressionStructLiteral expression => EmitExpressionStructLiteral(expression), + TypedNodeExpressionEnumLiteral expression => EmitExpressionEnumLiteral(expression), TypedNodeExpressionMemberAccess expression => EmitExpressionMemberAccess(expression), TypedNodeExpressionLocalIdent expression => expression.Value.Ident, TypedNodeExpressionModuleIdent expression => EmitExpressionModuleIdent(expression), @@ -362,6 +397,29 @@ public class Generator return $"({CType(expression.Type)}){{ {string.Join(", ", initializerStrings)} }}"; } + private string EmitExpressionEnumLiteral(TypedNodeExpressionEnumLiteral expression) + { + var enumType = (NubTypeEnumVariant)expression.Type; + + if (!moduleGraph.TryResolveType(enumType.Module, enumType.EnumName, true, out var info)) + throw new UnreachableException(); + + var enumInfo = (Module.TypeInfoEnum)info; + var tag = enumInfo.Variants.ToList().FindIndex(x => x.Name == enumType.VariantName); + + var initializerValues = new Dictionary(); + + foreach (var initializer in expression.Initializers) + { + var values = EmitExpression(initializer.Value); + initializerValues[initializer.Name.Ident] = values; + } + + var initializerStrings = initializerValues.Select(x => $".{x.Key} = {x.Value}"); + + return $"({CType(expression.Type)}){{ .tag = {tag}, .{enumType.VariantName} = {{{string.Join(", ", initializerStrings)}}} }}"; + } + private string EmitExpressionMemberAccess(TypedNodeExpressionMemberAccess expression) { var target = EmitExpression(expression.Target); @@ -390,6 +448,7 @@ public class Generator NubTypeVoid => "void" + (varName != null ? $" {varName}" : ""), NubTypeBool => "bool" + (varName != null ? $" {varName}" : ""), NubTypeStruct type => $"struct {NameMangler.Mangle(type.Module, type.Name, type)}" + (varName != null ? $" {varName}" : ""), + NubTypeEnum type => $"struct {NameMangler.Mangle(type.Module, type.Name, type)}" + (varName != null ? $" {varName}" : ""), NubTypeSInt type => $"int{type.Width}_t" + (varName != null ? $" {varName}" : ""), NubTypeUInt type => $"uint{type.Width}_t" + (varName != null ? $" {varName}" : ""), NubTypePointer type => CType(type.To) + (varName != null ? $" *{varName}" : "*"), diff --git a/compiler/NubType.cs b/compiler/NubType.cs index 962868b..4b63b9f 100644 --- a/compiler/NubType.cs +++ b/compiler/NubType.cs @@ -135,6 +135,32 @@ public class NubTypeEnum : NubType public override string ToString() => $"enum {Module}::{Name}"; } +public class NubTypeEnumVariant : NubType +{ + private static readonly Dictionary<(string Module, string EnumName, string VariantName), NubTypeEnumVariant> Cache = new(); + + public static NubTypeEnumVariant Get(string module, string enumName, string variantName) + { + if (!Cache.TryGetValue((module, enumName, variantName), out var enumType)) + Cache[(module, enumName, variantName)] = enumType = new NubTypeEnumVariant(module, enumName, variantName); + + return enumType; + } + + private NubTypeEnumVariant(string module, string enumName, string variantName) + { + Module = module; + EnumName = enumName; + VariantName = variantName; + } + + public string Module { get; } + public string EnumName { get; } + public string VariantName { get; } + + public override string ToString() => $"enum {Module}::{EnumName}.{VariantName}"; +} + public class NubTypePointer : NubType { private static readonly Dictionary Cache = new(); diff --git a/compiler/Parser.cs b/compiler/Parser.cs index a5217ff..e46303f 100644 --- a/compiler/Parser.cs +++ b/compiler/Parser.cs @@ -243,9 +243,10 @@ public class Parser while (!TryExpectSymbol(Symbol.CloseCurly)) { var caseStartIndex = index; - var name = ExpectIdent(); + var type = ExpectIdent(); + var variableName = ExpectIdent(); var body = ParseStatement(); - cases.Add(new NodeStatementMatch.Case(TokensFrom(caseStartIndex), name, body)); + cases.Add(new NodeStatementMatch.Case(TokensFrom(caseStartIndex), type, variableName, body)); } return new NodeStatementMatch(TokensFrom(startIndex), target, cases); @@ -378,6 +379,28 @@ public class Parser expr = new NodeExpressionStructLiteral(TokensFrom(startIndex), module, name, initializers); } + else if (TryExpectKeyword(Keyword.Enum)) + { + var module = ExpectIdent(); + ExpectSymbol(Symbol.ColonColon); + var enumName = ExpectIdent(); + ExpectSymbol(Symbol.Period); + var variantName = ExpectIdent(); + + var initializers = new List(); + + ExpectSymbol(Symbol.OpenCurly); + while (!TryExpectSymbol(Symbol.CloseCurly)) + { + var initializerStartIndex = startIndex; + var fieldName = ExpectIdent(); + ExpectSymbol(Symbol.Equal); + var fieldValue = ParseExpression(); + initializers.Add(new NodeExpressionEnumLiteral.Initializer(TokensFrom(initializerStartIndex), fieldName, fieldValue)); + } + + expr = new NodeExpressionEnumLiteral(TokensFrom(startIndex), module, enumName, variantName, initializers); + } else { throw new CompileException(Diagnostic.Error("Expected start of expression").At(fileName, Peek()).Build()); @@ -766,10 +789,10 @@ public class NodeStatementIf(List tokens, NodeExpression condition, NodeS public NodeStatement? ElseBlock { get; } = elseBlock; } -public class NodeStatementWhile(List tokens, NodeExpression condition, NodeStatement block) : NodeStatement(tokens) +public class NodeStatementWhile(List tokens, NodeExpression condition, NodeStatement body) : NodeStatement(tokens) { public NodeExpression Condition { get; } = condition; - public NodeStatement Block { get; } = block; + public NodeStatement Body { get; } = body; } public class NodeStatementMatch(List tokens, NodeExpression target, List cases) : NodeStatement(tokens) @@ -777,10 +800,11 @@ public class NodeStatementMatch(List tokens, NodeExpression target, List< public NodeExpression Target { get; } = target; public List Cases { get; } = cases; - public class Case(List tokens, TokenIdent type, NodeStatement block) : Node(tokens) + public class Case(List tokens, TokenIdent type, TokenIdent variableName, NodeStatement body) : Node(tokens) { public TokenIdent Type { get; } = type; - public NodeStatement Block { get; } = block; + public TokenIdent VariableName { get; } = variableName; + public NodeStatement Body { get; } = body; } } @@ -814,6 +838,20 @@ public class NodeExpressionStructLiteral(List tokens, TokenIdent module, } } +public class NodeExpressionEnumLiteral(List tokens, TokenIdent module, TokenIdent enumName, TokenIdent variantName, List initializers) : NodeExpression(tokens) +{ + public TokenIdent Module { get; } = module; + public TokenIdent EnumName { get; } = enumName; + public TokenIdent VariantName { get; } = variantName; + public List Initializers { get; } = initializers; + + public class Initializer(List tokens, TokenIdent name, NodeExpression value) : Node(tokens) + { + public TokenIdent Name { get; } = name; + public NodeExpression Value { get; } = value; + } +} + public class NodeExpressionMemberAccess(List tokens, NodeExpression target, TokenIdent name) : NodeExpression(tokens) { public NodeExpression Target { get; } = target; diff --git a/compiler/TypeChecker.cs b/compiler/TypeChecker.cs index a2ed02a..f8d5e9f 100644 --- a/compiler/TypeChecker.cs +++ b/compiler/TypeChecker.cs @@ -87,6 +87,7 @@ public class TypeChecker NodeStatementReturn statement => CheckStatementReturn(statement), NodeStatementVariableDeclaration statement => CheckStatementVariableDeclaration(statement), NodeStatementWhile statement => CheckStatementWhile(statement), + NodeStatementMatch statement => CheckStatementMatch(statement), _ => throw new ArgumentOutOfRangeException(nameof(node)) }; } @@ -138,7 +139,26 @@ public class TypeChecker private TypedNodeStatementWhile CheckStatementWhile(NodeStatementWhile statement) { - return new TypedNodeStatementWhile(statement.Tokens, CheckExpression(statement.Condition), CheckStatement(statement.Block)); + return new TypedNodeStatementWhile(statement.Tokens, CheckExpression(statement.Condition), CheckStatement(statement.Body)); + } + + private TypedNodeStatementMatch CheckStatementMatch(NodeStatementMatch statement) + { + var cases = new List(); + var target = CheckExpression(statement.Target); + var enumType = (NubTypeEnum)target.Type; + + foreach (var @case in statement.Cases) + { + using (scope.EnterScope()) + { + scope.DeclareIdentifier(@case.VariableName.Ident, NubTypeEnumVariant.Get(enumType.Module, enumType.Name, @case.Type.Ident)); + var body = CheckStatement(@case.Body); + cases.Add(new TypedNodeStatementMatch.Case(@case.Tokens, @case.Type, @case.VariableName, body)); + } + } + + return new TypedNodeStatementMatch(statement.Tokens, target, cases); } private TypedNodeExpression CheckExpression(NodeExpression node) @@ -155,6 +175,7 @@ public class TypeChecker NodeExpressionFuncCall expression => CheckExpressionFuncCall(expression), NodeExpressionStringLiteral expression => CheckExpressionStringLiteral(expression), NodeExpressionStructLiteral expression => CheckExpressionStructLiteral(expression), + NodeExpressionEnumLiteral expression => CheckExpressionEnumLiteral(expression), _ => throw new ArgumentOutOfRangeException(nameof(node)) }; } @@ -331,6 +352,7 @@ public class TypeChecker switch (target.Type) { case NubTypeStruct structType: + { if (!moduleGraph.TryResolveModule(structType.Module, out var module)) throw new CompileException(Diagnostic.Error($"Module '{structType.Module}' not found").At(fileName, expression.Target).Build()); @@ -338,13 +360,35 @@ public class TypeChecker 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) - throw new CompileException(Diagnostic.Error($"Type '{structType.Module}::{structType.Name}' is not a struct").At(fileName, expression.Target).Build()); + throw new CompileException(Diagnostic.Error($"Type '{target.Type}' is not a struct").At(fileName, expression.Target).Build()); var field = structDef.Fields.FirstOrDefault(x => x.Name == expression.Name.Ident); if (field == null) throw new CompileException(Diagnostic.Error($"Struct '{target.Type}' does not have a field matching the name '{expression.Name.Ident}'").At(fileName, target).Build()); return new TypedNodeExpressionMemberAccess(expression.Tokens, field.Type, target, expression.Name); + } + case NubTypeEnumVariant enumVariantType: + { + if (!moduleGraph.TryResolveModule(enumVariantType.Module, out var module)) + throw new CompileException(Diagnostic.Error($"Module '{enumVariantType.Module}' not found").At(fileName, expression.Target).Build()); + + if (!module.TryResolveType(enumVariantType.EnumName, moduleName == enumVariantType.Module, out var typeDef)) + throw new CompileException(Diagnostic.Error($"Type '{enumVariantType.EnumName}' not found in module '{enumVariantType.Module}'").At(fileName, expression.Target).Build()); + + if (typeDef is not Module.TypeInfoEnum enumDef) + throw new CompileException(Diagnostic.Error($"Type '{enumVariantType.Module}::{enumVariantType.EnumName}' is not an enum").At(fileName, expression.Target).Build()); + + var variant = enumDef.Variants.FirstOrDefault(x => x.Name == enumVariantType.VariantName); + if (variant == null) + throw new CompileException(Diagnostic.Error($"Type '{target.Type}' does not have a variant '{enumVariantType.VariantName}'").At(fileName, expression.Target).Build()); + + var field = variant.Fields.FirstOrDefault(x => x.Name == expression.Name.Ident); + if (field == null) + throw new CompileException(Diagnostic.Error($"Enum variant '{target.Type}' does not have a field matching the name '{expression.Name.Ident}'").At(fileName, target).Build()); + + return new TypedNodeExpressionMemberAccess(expression.Tokens, field.Type, target, expression.Name); + } default: throw new CompileException(Diagnostic.Error($"{target.Type} has no member '{expression.Name.Ident}'").At(fileName, target).Build()); } @@ -384,7 +428,7 @@ public class TypeChecker { var field = structDef.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.Name.Ident}'").At(fileName, initializer.Name).Build()); + 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()); var value = CheckExpression(initializer.Value); if (value.Type != field.Type) @@ -396,6 +440,40 @@ public class TypeChecker return new TypedNodeExpressionStructLiteral(expression.Tokens, NubTypeStruct.Get(expression.Module.Ident, expression.Name.Ident), initializers); } + 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 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); + 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()); + + var initializers = new List(); + foreach (var initializer in expression.Initializers) + { + var field = variant.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident); + if (field == null) + throw new CompileException(Diagnostic.Error($"Field '{initializer.Name.Ident}' does not exist on enum variant '{expression.Module.Ident}::{expression.EnumName.Ident}.{expression.VariantName.Ident}'").At(fileName, initializer.Name).Build()); + + var value = CheckExpression(initializer.Value); + if (value.Type != field.Type) + throw new CompileException(Diagnostic.Error($"Type of assignment ({value.Type}) does not match expected type of field '{field.Name}' ({field.Type})").At(fileName, initializer.Name).Build()); + + initializers.Add(new TypedNodeExpressionEnumLiteral.Initializer(initializer.Tokens, initializer.Name, value)); + } + + return new TypedNodeExpressionEnumLiteral(expression.Tokens, NubTypeEnumVariant.Get(expression.Module.Ident, expression.EnumName.Ident, expression.VariantName.Ident), initializers); + } + private NubType ResolveType(NodeType node) { return node switch @@ -425,6 +503,7 @@ public class TypeChecker return customType 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)) }; } @@ -539,10 +618,23 @@ public class TypedNodeStatementIf(List tokens, TypedNodeExpression condit public TypedNodeStatement? ElseBlock { get; } = elseBlock; } -public class TypedNodeStatementWhile(List tokens, TypedNodeExpression condition, TypedNodeStatement block) : TypedNodeStatement(tokens) +public class TypedNodeStatementWhile(List tokens, TypedNodeExpression condition, TypedNodeStatement body) : TypedNodeStatement(tokens) { public TypedNodeExpression Condition { get; } = condition; - public TypedNodeStatement Block { get; } = block; + public TypedNodeStatement Body { get; } = body; +} + +public class TypedNodeStatementMatch(List tokens, TypedNodeExpression target, List cases) : TypedNodeStatement(tokens) +{ + public TypedNodeExpression Target { get; } = target; + public List Cases { get; } = cases; + + public class Case(List tokens, TokenIdent type, TokenIdent variableName, TypedNodeStatement body) : Node(tokens) + { + public TokenIdent Type { get; } = type; + public TokenIdent VariableName { get; } = variableName; + public TypedNodeStatement Body { get; } = body; + } } public abstract class TypedNodeExpression(List tokens, NubType type) : TypedNode(tokens) @@ -576,6 +668,17 @@ public class TypedNodeExpressionStructLiteral(List tokens, NubType type, } } +public class TypedNodeExpressionEnumLiteral(List tokens, NubType type, List initializers) : TypedNodeExpression(tokens, type) +{ + public List Initializers { get; } = initializers; + + public class Initializer(List tokens, TokenIdent name, TypedNodeExpression value) : Node(tokens) + { + public TokenIdent Name { get; } = name; + public TypedNodeExpression Value { get; } = value; + } +} + public class TypedNodeExpressionMemberAccess(List tokens, NubType type, TypedNodeExpression target, TokenIdent name) : TypedNodeExpression(tokens, type) { public TypedNodeExpression Target { get; } = target; diff --git a/examples/math/math.nub b/examples/math/math.nub index c655f48..59d3446 100644 --- a/examples/math/math.nub +++ b/examples/math/math.nub @@ -15,6 +15,16 @@ export enum message { export func add(a: i32 b: i32): i32 { + let message: math::message = enum math::message.move { x = 1 y = 1 } + + match message { + quit q {} + move m { + m.x = 23 + m.y = 23 + } + } + return math::add_internal(a b) }