Remove NumKind.numeral from backend code

The numeral variant was a placeholder for unresolved numeric types that
should never make it to code generation. By the time code reaches the
backend, all numeric types should be resolved to concrete types (u8, i64,
dec, etc.).

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: rtfeldman

src/backend/dev/CodeGen.zig

@@ -44,7 +44,6 @@ pub const NumKind = enum {
     f32,
     f64,
     dec,
-    numeral,
 
     pub fn isFloat(self: NumKind) bool {
         return self == .f32 or self == .f64;
@@ -54,7 +53,7 @@ pub const NumKind = enum {
         return switch (self) {
             .i8, .i16, .i32, .i64, .i128 => true,
             .u8, .u16, .u32, .u64, .u128 => false,
-            .f32, .f64, .dec, .numeral => true, // floats are signed
+            .f32, .f64, .dec => true, // floats are signed
         };
     }
 
@@ -63,41 +62,12 @@ pub const NumKind = enum {
             .u8, .i8 => 1,
             .u16, .i16 => 2,
             .u32, .i32, .f32 => 4,
-            .u64, .i64, .f64, .numeral => 8,
+            .u64, .i64, .f64 => 8,
             .u128, .i128, .dec => 16,
         };
     }
 };
 
-/// Binary operation types
-pub const BinOp = enum {
-    add,
-    sub,
-    mul,
-    div,
-    rem,
-    div_trunc,
-    lt,
-    gt,
-    le,
-    ge,
-    eq,
-    ne,
-    @"and",
-    @"or",
-
-    pub fn isComparison(self: BinOp) bool {
-        return switch (self) {
-            .lt, .gt, .le, .ge, .eq, .ne => true,
-            else => false,
-        };
-    }
-
-    pub fn isLogical(self: BinOp) bool {
-        return self == .@"and" or self == .@"or";
-    }
-};
-
 /// Code generator that produces native machine code from high-level operations.
 /// This is parameterized by the target architecture's types.
 pub fn CodeGen(
@@ -251,13 +221,3 @@ test "NumKind properties" {
     try std.testing.expectEqual(@as(u8, 8), NumKind.i64.byteSize());
     try std.testing.expectEqual(@as(u8, 16), NumKind.i128.byteSize());
 }
-
-test "BinOp properties" {
-    try std.testing.expect(BinOp.lt.isComparison());
-    try std.testing.expect(BinOp.eq.isComparison());
-    try std.testing.expect(!BinOp.add.isComparison());
-
-    try std.testing.expect(BinOp.@"and".isLogical());
-    try std.testing.expect(BinOp.@"or".isLogical());
-    try std.testing.expect(!BinOp.add.isLogical());
-}

src/backend/llvm/emit.zig

@@ -32,16 +32,15 @@ pub const NumKind = enum {
     f32,
     f64,
     dec,
-    numeral,
 
     /// Compile-time validation that this enum matches the expected structure.
     pub fn validate() void {
         comptime {
             const fields = @typeInfo(NumKind).@"enum".fields;
-            if (fields.len != 14) @compileError("NumKind must have exactly 14 variants");
+            if (fields.len != 13) @compileError("NumKind must have exactly 13 variants");
             if (!std.mem.eql(u8, fields[0].name, "u8")) @compileError("NumKind[0] must be u8");
             if (!std.mem.eql(u8, fields[1].name, "i8")) @compileError("NumKind[1] must be i8");
-            if (!std.mem.eql(u8, fields[13].name, "numeral")) @compileError("NumKind[13] must be numeral");
+            if (!std.mem.eql(u8, fields[12].name, "dec")) @compileError("NumKind[12] must be dec");
         }
     }
 };
@@ -141,7 +140,6 @@ pub const LlvmEmitter = struct {
             .f32 => .float,
             .f64 => .double,
             .dec => .i128, // Dec is stored as i128
-            .numeral => .i64, // Default unspecialized numeric type
         };
     }