add type analysis of enums

src/ast.zig

@@ -280,6 +280,9 @@ pub const Struct = struct {
 
 pub const Enum = struct {
     name: Token,
+
+    // TODO allow custom values for the enum fields
+    // just like c enums can skip values
     fields: TokenList,
 };
 

src/ast_printer.zig

@@ -351,8 +351,7 @@ fn prettyType(typ: SymbolUnderlyingType) []const u8 {
 
         .OpaqueType => |ident| retWithName("opaque", ident),
         .Struct => |ident| retWithName("struct", ident),
-
-        else => unreachable,
+        .Enum => |ident| retWithName("enum", ident),
     };
 }
 
@@ -395,7 +394,21 @@ pub fn printContext(ctx: CompilationContext) void {
                 kv.key,
                 kv.value,
             ),
-            else => unreachable,
+
+            .Enum => |identmap| {
+                std.debug.warn("enum {}:", kv.key);
+
+                var mapit = identmap.iterator();
+
+                while (mapit.next()) |field_kv| {
+                    std.debug.warn("\t{} => {}\n", field_kv.key, field_kv.value);
+                }
+            },
+
+            else => {
+                std.debug.warn("TODO handle print of {}\n", kv.value);
+                unreachable;
+            },
         }
     }
 }

src/codegen.zig

@@ -270,6 +270,9 @@ pub const Codegen = struct {
                 std.debug.warn("cgen: generated function '{}'\n", name);
             },
 
+            // NOTE: enums don't have specific llvm ir code generated for them
+            .Enum => {},
+
             else => {
                 std.debug.warn("TODO handle node type {}\n", @tagName(node.*));
                 return;

src/comp_ctx.zig

@@ -59,8 +59,8 @@ pub const FunctionSymbol = struct {
 // structs are hashmaps pointing to SymbolUnderlyingType
 pub const UnderlyingTypeMap = std.hash_map.StringHashMap(SymbolUnderlyingType);
 
-// enums have lists of identifiers
-pub const IdentifierList = std.ArrayList([]const u8);
+// enums have maps from fields to u32s
+pub const IdentifierMap = std.StringHashMap(u32);
 
 // TODO const
 pub const SymbolType = enum {
@@ -73,7 +73,7 @@ pub const SymbolType = enum {
 pub const SymbolData = union(SymbolType) {
     Function: FunctionSymbol,
     Struct: UnderlyingTypeMap,
-    Enum: IdentifierList,
+    Enum: IdentifierMap,
 
     // variables (parameters and variables), for the type system
     // only have types
@@ -161,4 +161,18 @@ pub const CompilationContext = struct {
             },
         });
     }
+
+    pub fn insertEnum(self: *@This(), enu: ast.Enum) !void {
+        var ident_map = IdentifierMap.init(self.allocator);
+        errdefer ident_map.deinit();
+
+        // TODO change this when enums get support for custom values
+        for (enu.fields.toSlice()) |token, idx| {
+            _ = try ident_map.put(token.lexeme, @intCast(u32, idx));
+        }
+
+        _ = try self.symbol_table.put(enu.name.lexeme, SymbolData{
+            .Enum = ident_map,
+        });
+    }
 };

src/types.zig

@@ -143,8 +143,10 @@ pub const TypeSolver = struct {
                     try ctx.insertStruct(struc, types);
             },
 
-            // TODO enums are u32
-            //.Enum => {},
+            // TODO change enums to u32
+            .Enum => |enu| {
+                try ctx.insertEnum(enu);
+            },
 
             // TODO infer type of expr in const
             //.ConstDecl => {},