...

compiler/Generator.cs

@@ -96,16 +96,7 @@ public class Generator
                             {
                                 foreach (var variant in e.Variants)
                                 {
-                                    writer.WriteLine("struct");
+                                    writer.WriteLine($"{CType(variant.Type, variant.Name)};");
-                                    writer.WriteLine("{");
-                                    using (writer.Indent())
-                                    {
-                                        foreach (var field in variant.Fields)
-                                        {
-                                            writer.WriteLine($"{CType(field.Type, field.Name)};");
-                                        }
-                                    }
-                                    writer.WriteLine($"}} {variant.Name};");
                                 }
                             }
                             writer.WriteLine("};");
@@ -407,17 +398,9 @@ public class Generator
         var enumInfo = (Module.TypeInfoEnum)info;
         var tag = enumInfo.Variants.ToList().FindIndex(x => x.Name == enumVariantType.Variant);
 
-        var initializerValues = new Dictionary<string, string>();
+        var value = EmitExpression(expression.Value);
 
-        foreach (var initializer in expression.Initializers)
+        return $"({CType(expression.Type)}){{ .tag = {tag}, .{enumVariantType.Variant} = {value} }}";
-        {
-            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}, .{enumVariantType.Variant} = {{ {string.Join(", ", initializerStrings)} }} }}";
     }
 
     private string EmitExpressionMemberAccess(TypedNodeExpressionMemberAccess expression)

compiler/ModuleGraph.cs

@@ -95,7 +95,7 @@ public class ModuleGraph
                             case Manifest.Module.TypeInfoEnum s:
                             {
                                 var info = new Module.TypeInfoEnum(Module.DefinitionKind.External);
-                                var variants = s.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Fields.Select(x => new Module.TypeInfoEnum.Variant.Field(x.Name, x.Type)).ToList())).ToList();
+                                var variants = s.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Type)).ToList();
                                 info.SetVariants(variants);
                                 module.AddType(name, info);
                                 break;
@@ -152,7 +152,7 @@ public class ModuleGraph
 
                     if (typeInfo is Module.TypeInfoEnum enumType)
                     {
-                        var variants = enumDef.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name.Ident, v.Fields.Select(f => new Module.TypeInfoEnum.Variant.Field(f.Name.Ident, ResolveType(f.Type, module.Name))).ToList())).ToList();
+                        var variants = enumDef.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name.Ident, ResolveType(v.Type, module.Name))).ToList();
                         enumType.SetVariants(variants);
                     }
                 }
@@ -421,16 +421,10 @@ public class Module(string name)
             this.variants = variants;
         }
 
-        public class Variant(string name, List<Variant.Field> fields)
+        public class Variant(string name, NubType type)
-        {
-            public string Name { get; } = name;
-            public List<Field> Fields { get; } = fields;
-
-            public class Field(string name, NubType type)
         {
             public string Name { get; } = name;
             public NubType Type { get; } = type;
         }
     }
 }
-}

compiler/NubLib.cs

@@ -99,7 +99,7 @@ public record Manifest(Dictionary<string, Manifest.Module> Modules)
             return typeInfo switch
             {
                 Compiler.Module.TypeInfoStruct s => new Module.TypeInfoStruct(s.Packed, s.Fields.Select(x => new Module.TypeInfoStruct.Field(x.Name, x.Type)).ToList()),
-                Compiler.Module.TypeInfoEnum e => new Module.TypeInfoEnum(e.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Fields.Select(x => new Module.TypeInfoEnum.Variant.Field(x.Name, x.Type)).ToList())).ToList()),
+                Compiler.Module.TypeInfoEnum e => new Module.TypeInfoEnum(e.Variants.Select(v => new Module.TypeInfoEnum.Variant(v.Name, v.Type)).ToList()),
                 _ => throw new ArgumentOutOfRangeException(nameof(typeInfo))
             };
         }
@@ -121,10 +121,7 @@ public record Manifest(Dictionary<string, Manifest.Module> Modules)
 
         public record TypeInfoEnum(IReadOnlyList<TypeInfoEnum.Variant> Variants) : TypeInfo
         {
-            public record Variant(string Name, List<Variant.Field> Fields)
+            public record Variant(string Name, NubType Type);
-            {
-                public record Field(string Name, NubType Type);
-            }
         }
     }
 }

compiler/Parser.cs

@@ -145,24 +145,9 @@ public class Parser
             {
                 var variantsStartIndex = index;
                 var variantName = ExpectIdent();
-
-                var variantFields = new List<NodeDefinitionEnum.Variant.Field>();
-
-                if (TryExpectSymbol(Symbol.OpenCurly))
-                {
-                    while (!TryExpectSymbol(Symbol.CloseCurly))
-                    {
-                        var fieldStartIndex = index;
-
-                        var fieldName = ExpectIdent();
                 ExpectSymbol(Symbol.Colon);
-                        var fieldType = ParseType();
+                var variantType = ParseType();
-
+                variants.Add(new NodeDefinitionEnum.Variant(TokensFrom(variantsStartIndex), variantName, variantType));
-                        variantFields.Add(new NodeDefinitionEnum.Variant.Field(TokensFrom(fieldStartIndex), fieldName, fieldType));
-                    }
-                }
-
-                variants.Add(new NodeDefinitionEnum.Variant(TokensFrom(variantsStartIndex), variantName, variantFields));
             }
 
             return new NodeDefinitionEnum(TokensFrom(startIndex), exported, name, variants);
@@ -361,9 +346,7 @@ public class Parser
         }
         else if (TryExpectKeyword(Keyword.Struct))
         {
-            var module = ExpectIdent();
+            var type = ParseType();
-            ExpectSymbol(Symbol.ColonColon);
-            var name = ExpectIdent();
 
             var initializers = new List<NodeExpressionStructLiteral.Initializer>();
 
@@ -377,7 +360,7 @@ public class Parser
                 initializers.Add(new NodeExpressionStructLiteral.Initializer(TokensFrom(initializerStartIndex), fieldName, fieldValue));
             }
 
-            expr = new NodeExpressionStructLiteral(TokensFrom(startIndex), module, name, initializers);
+            expr = new NodeExpressionStructLiteral(TokensFrom(startIndex), type, initializers);
         }
         else if (TryExpectKeyword(Keyword.Enum))
         {
@@ -387,19 +370,9 @@ public class Parser
             ExpectSymbol(Symbol.ColonColon);
             var variantName = ExpectIdent();
 
-            var initializers = new List<NodeExpressionEnumLiteral.Initializer>();
+            var value = ParseExpression();
 
-            ExpectSymbol(Symbol.OpenCurly);
+            expr = new NodeExpressionEnumLiteral(TokensFrom(startIndex), module, enumName, variantName, value);
-            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
         {
@@ -757,18 +730,12 @@ public class NodeDefinitionEnum(List<Token> tokens, bool exported, TokenIdent na
     public TokenIdent Name { get; } = name;
     public List<Variant> Variants { get; } = variants;
 
-    public class Variant(List<Token> tokens, TokenIdent name, List<Variant.Field> fields) : Node(tokens)
+    public class Variant(List<Token> tokens, TokenIdent name, NodeType type) : Node(tokens)
-    {
-        public TokenIdent Name { get; } = name;
-        public List<Field> Fields { get; } = fields;
-
-        public class Field(List<Token> tokens, TokenIdent name, NodeType type) : Node(tokens)
     {
         public TokenIdent Name { get; } = name;
         public NodeType Type { get; } = type;
     }
 }
-}
 
 public class NodeDefinitionGlobalVariable(List<Token> tokens, bool exported, TokenIdent name, NodeType type) : NodeDefinition(tokens)
 {
@@ -850,10 +817,9 @@ public class NodeExpressionBoolLiteral(List<Token> tokens, TokenBoolLiteral valu
     public TokenBoolLiteral Value { get; } = value;
 }
 
-public class NodeExpressionStructLiteral(List<Token> tokens, TokenIdent module, TokenIdent name, List<NodeExpressionStructLiteral.Initializer> initializers) : NodeExpression(tokens)
+public class NodeExpressionStructLiteral(List<Token> tokens, NodeType? type, List<NodeExpressionStructLiteral.Initializer> initializers) : NodeExpression(tokens)
 {
-    public TokenIdent Module { get; } = module;
+    public NodeType? Type { get; } = type;
-    public TokenIdent Name { get; } = name;
     public List<Initializer> Initializers { get; } = initializers;
 
     public class Initializer(List<Token> tokens, TokenIdent name, NodeExpression value) : Node(tokens)
@@ -863,19 +829,13 @@ public class NodeExpressionStructLiteral(List<Token> tokens, TokenIdent module,
     }
 }
 
-public class NodeExpressionEnumLiteral(List<Token> tokens, TokenIdent module, TokenIdent enumName, TokenIdent variantName, List<NodeExpressionEnumLiteral.Initializer> initializers) : NodeExpression(tokens)
+public class NodeExpressionEnumLiteral(List<Token> tokens, TokenIdent module, TokenIdent enumName, TokenIdent variantName, NodeExpression value) : NodeExpression(tokens)
 {
     public TokenIdent Module { get; } = module;
     public TokenIdent EnumName { get; } = enumName;
     public TokenIdent VariantName { get; } = variantName;
-    public List<Initializer> Initializers { get; } = initializers;
-
-    public class Initializer(List<Token> tokens, TokenIdent name, NodeExpression value) : Node(tokens)
-    {
-        public TokenIdent Name { get; } = name;
     public NodeExpression Value { get; } = value;
 }
-}
 
 public class NodeExpressionMemberAccess(List<Token> tokens, NodeExpression target, TokenIdent name) : NodeExpression(tokens)
 {

compiler/TypeChecker.cs

@@ -380,11 +380,7 @@ public class TypeChecker
                 if (variant == null)
                     throw BasicError($"Type '{target.Type}' does not have a variant named '{enumVariantType.Variant}'", expression.Target);
 
-                var field = variant.Fields.FirstOrDefault(x => x.Name == expression.Name.Ident);
+                return new TypedNodeExpressionMemberAccess(expression.Tokens, variant.Type, target, expression.Name);
-                if (field == null)
-                    throw BasicError($"Enum variant '{target.Type}' does not have a field matching the name '{expression.Name.Ident}'", target);
-
-                return new TypedNodeExpressionMemberAccess(expression.Tokens, field.Type, target, expression.Name);
             }
             default:
                 throw BasicError($"{target.Type} has no member '{expression.Name.Ident}'", target);
@@ -409,14 +405,22 @@ public class TypeChecker
 
     private TypedNodeExpressionStructLiteral CheckExpressionStructLiteral(NodeExpressionStructLiteral expression)
     {
-        var info = ResolveModuleStruct(ResolveModule(expression.Module), expression.Name);
+        var type = ResolveType(expression.Type);
+        if (type is not NubTypeStruct structType)
+            throw BasicError("Type of struct literal is not a struct", expression.Type); 
+
+        if (!moduleGraph.TryResolveType(structType.Module, structType.Name, structType.Module == currentModule, out var info))
+            throw BasicError($"Type '{structType}' struct literal not found", expression.Type);
+
+        if (info is not Module.TypeInfoStruct structInfo)
+            throw BasicError($"Type '{structType}' is not a struct", expression.Type);
 
         var initializers = new List<TypedNodeExpressionStructLiteral.Initializer>();
         foreach (var initializer in expression.Initializers)
         {
-            var field = info.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident);
+            var field = structInfo.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident);
             if (field == null)
-                throw BasicError($"Field '{initializer.Name.Ident}' does not exist on struct '{expression.Module.Ident}::{expression.Name.Ident}'", initializer.Name);
+                throw BasicError($"Field '{initializer.Name.Ident}' does not exist on struct '{structType.Module}::{structType.Name}'", initializer.Name);
 
             var value = CheckExpression(initializer.Value);
             if (!value.Type.IsAssignableTo(field.Type))
@@ -425,32 +429,13 @@ public class TypeChecker
             initializers.Add(new TypedNodeExpressionStructLiteral.Initializer(initializer.Tokens, initializer.Name, value));
         }
 
-        return new TypedNodeExpressionStructLiteral(expression.Tokens, NubTypeStruct.Get(expression.Module.Ident, expression.Name.Ident), initializers);
+        return new TypedNodeExpressionStructLiteral(expression.Tokens, NubTypeStruct.Get(structType.Module, structType.Name), initializers);
     }
 
     private TypedNodeExpressionEnumLiteral CheckExpressionEnumLiteral(NodeExpressionEnumLiteral expression)
     {
-        var info = ResolveModuleEnum(ResolveModule(expression.Module), expression.EnumName);
+        var value = CheckExpression(expression.Value);
-
+        return new TypedNodeExpressionEnumLiteral(expression.Tokens, NubTypeEnumVariant.Get(NubTypeEnum.Get(expression.Module.Ident, expression.EnumName.Ident), expression.VariantName.Ident), value);
-        var variant = info.Variants.FirstOrDefault(x => x.Name == expression.VariantName.Ident);
-        if (variant == null)
-            throw BasicError($"Enum '{expression.Module.Ident}::{expression.EnumName.Ident}' does not have a variant '{expression.VariantName.Ident}'", expression.VariantName);
-
-        var initializers = new List<TypedNodeExpressionEnumLiteral.Initializer>();
-        foreach (var initializer in expression.Initializers)
-        {
-            var field = variant.Fields.FirstOrDefault(x => x.Name == initializer.Name.Ident);
-            if (field == null)
-                throw BasicError($"Field '{initializer.Name.Ident}' does not exist on enum variant '{expression.Module.Ident}::{expression.EnumName.Ident}.{expression.VariantName.Ident}'", initializer.Name);
-
-            var value = CheckExpression(initializer.Value);
-            if (!value.Type.IsAssignableTo(field.Type))
-                throw BasicError($"Type of assignment ({value.Type}) does not match expected type of field '{field.Name}' ({field.Type})", initializer.Name);
-
-            initializers.Add(new TypedNodeExpressionEnumLiteral.Initializer(initializer.Tokens, initializer.Name, value));
-        }
-
-        return new TypedNodeExpressionEnumLiteral(expression.Tokens, NubTypeEnumVariant.Get(NubTypeEnum.Get(expression.Module.Ident, expression.EnumName.Ident), expression.VariantName.Ident), initializers);
     }
 
     private NubType ResolveType(NodeType node)
@@ -756,16 +741,10 @@ public class TypedNodeExpressionStructLiteral(List<Token> tokens, NubType type,
     }
 }
 
-public class TypedNodeExpressionEnumLiteral(List<Token> tokens, NubType type, List<TypedNodeExpressionEnumLiteral.Initializer> initializers) : TypedNodeExpression(tokens, type)
+public class TypedNodeExpressionEnumLiteral(List<Token> tokens, NubType type, TypedNodeExpression value) : TypedNodeExpression(tokens, type)
 {
-    public List<Initializer> Initializers { get; } = initializers;
-
-    public class Initializer(List<Token> tokens, TokenIdent name, TypedNodeExpression value) : Node(tokens)
-    {
-        public TokenIdent Name { get; } = name;
     public TypedNodeExpression Value { get; } = value;
 }
-}
 
 public class TypedNodeExpressionMemberAccess(List<Token> tokens, NubType type, TypedNodeExpression target, TokenIdent name) : TypedNodeExpression(tokens, type)
 {

examples/math/math.nub

@@ -1,55 +1,42 @@
 module math
 
-struct vec2 {
+export struct vec2 {
     x: i32
     y: i32
 }
 
-struct vec3 {
+export struct vec3 {
     x: i32
     y: i32
     z: i32
 }
 
-struct color {
+export struct color {
     r: i32
     g: i32
     b: i32
     a: i32
 }
 
-struct example {
+export struct example {
-    a: {
+    b: color
-        a: i32
 }
-    b: {
-        b: {
-            c: i32
-        }
-        c: {
-            d: i32
-        }
-    }
-}
-
 
 export enum message {
-    quit
+    quit: {}
-    move {
+    move: color
-        x: i32
-        y: i32
-    }
 }
 
 export func add(a: i32 b: i32): i32
 {
-    let message: message = enum math::message::move { x = 1 y = 1 }
+    let message: message = enum math::message::move struct color { r = 23 g = 46 b = 56 }
 
     match message {
         quit q {}
         move m {
-            m.x = 23
+            m.r = 23
-            m.y = 23
+            m.g = 23
+            m.b = 23
         }
     }