Desugar more arithmetic operators

.rules

@@ -80,7 +80,8 @@ When writing Roc code in tests or examples, remember these syntax rules:
 
 - **Naming Convention**: Roc uses `snake_case` for identifiers, not `camelCase`
 - **Boolean Operators**: Use `and` and `or` keywords, not `&&` or `||`
-- **Lambda Syntax**: Anonymous functions use bars: `my_fn = |arg1, arg2| other_fn(arg1, arg2)`
+- **Function Syntax**: Functions in Roc are called with parentheses and commas, not whitespace: `my_fn = |arg1, arg2| other_fn(arg1, arg2)` NOT `my_fn = \arg1, arg2 -> other_fn arg1 arg2`
+- **Lambda Syntax**: Functions in Roc are written with pipes (never backslashes) and are called with parentheses and commas (never whitespace). This is valid: `my_fn = |arg1, arg2| other_fn(arg1, arg2)` and this is NOT valid: `my_fn = \arg1, arg2 -> other_fn arg1 arg2`
 - **If Expressions**: The syntax is `if condition then_branch else else_branch` with no `then` keyword
 - **Blocks**: Use curly braces to define inline variables. The last expression in the block is its return value:
   ```
@@ -92,3 +93,10 @@ When writing Roc code in tests or examples, remember these syntax rules:
       answer
   }
   ```
+
+## Development Priorities
+
+1. **No std.debug.print or std.debug.panic in production** - This code base compiles to WebAssembly. That means if you ever leave std.debug.print or std.debug.panic calls in production code (both are fine in tests), CI will fail on the WebAssembly build. It's fine to use these for debugging, but if you want a production panic, use `@panic`, and if you want to write to stderr in production, use a normal stderr writer.
+1. **No excuses** - It is always incorrect to think "this is a pre-existing test failure, so I don't need to address it." All projects in this repository begin with completely passing tests, and this is strictly enforced by CI. If there is a test failure, you have not completed your task until it has been addressed. No excuses!
+2. **Ignore pass rate** - Test pass rate is something you should ignore completely. It doesn't matter how many tests are passing or how many are failing. All that matters is the binary "are all tests passing?" If you make a change and more tests pass than before, that does NOT necessarily mean you made progress. Likewise, if you make a change and fewer tests pass than before, that does NOT necessarily mean you regressed progress. You need to look at feedback like compiler output, debug logging, and individual test failure messages to determine whether you are making progress or not; completely disregard the number of passing or failing tests as a measure of incremental progress. The only way the number of failing tests is relevant is that you know you are not done with the project until the number of failures has reached zero.
+3. **No hacks, workarounds, placeholders, or fallbacks** - This is a production code base with an emphasis on high quality. Never give up and write code like "// For now, ..." or which silently swallows errors, or which uses fallbacks like "// If that didn't work, try..."

ci/check_test_wiring.zig

@@ -12,11 +12,6 @@ const test_exclusions = [_][]const u8{
     "src/snapshot_tool",
 };
 
-const test_file_exclusions = [_][]const u8{
-    // TODO: This test got out of sync and is not straightforward to fix
-    "src/eval/test/low_level_interp_test.zig",
-};
-
 const TermColor = struct {
     pub const red = "\x1b[0;31m";
     pub const green = "\x1b[0;32m";
@@ -155,16 +150,6 @@ fn handleFile(
         return;
     }
 
-    if (shouldSkipTestPath(path)) {
-        allocator.free(path);
-        return;
-    }
-
-    if (shouldSkipTestFile(path)) {
-        allocator.free(path);
-        return;
-    }
-
     if (try fileHasTestDecl(allocator, path)) {
         try test_files.append(allocator, path);
         return;
@@ -173,20 +158,6 @@ fn handleFile(
     allocator.free(path);
 }
 
-fn shouldSkipTestPath(path: []const u8) bool {
-    for (test_exclusions) |prefix| {
-        if (hasDirPrefix(path, prefix)) return true;
-    }
-    return false;
-}
-
-fn shouldSkipTestFile(path: []const u8) bool {
-    for (test_file_exclusions) |excluded| {
-        if (std.mem.eql(u8, path, excluded)) return true;
-    }
-    return false;
-}
-
 fn hasDirPrefix(path: []const u8, prefix: []const u8) bool {
     if (!std.mem.startsWith(u8, path, prefix)) return false;
     return path.len == prefix.len or path[prefix.len] == '/';

src/base/Ident.zig

@@ -22,6 +22,16 @@ pub const FROM_INT_DIGITS_METHOD_NAME = "from_int_digits";
 pub const FROM_DEC_DIGITS_METHOD_NAME = "from_dec_digits";
 /// Method name for addition - used by + operator desugaring
 pub const PLUS_METHOD_NAME = "plus";
+/// Method name for subtraction - used by - operator desugaring
+pub const MINUS_METHOD_NAME = "minus";
+/// Method name for multiplication - used by * operator desugaring
+pub const TIMES_METHOD_NAME = "times";
+/// Method name for division - used by / operator desugaring
+pub const DIV_METHOD_NAME = "div";
+/// Method name for truncating division - used by // operator desugaring
+pub const DIV_TRUNC_METHOD_NAME = "div_trunc";
+/// Method name for remainder - used by % operator desugaring
+pub const REM_METHOD_NAME = "rem";
 
 /// The original text of the identifier.
 raw_text: []const u8,

src/build/builtin_compiler/main.zig

@@ -119,6 +119,81 @@ fn transformStrNominalToPrimitive(env: *ModuleEnv) !void {
     }
 }
 
+/// Transform all numeric nominal types (U8, I8, ..., I128, Dec, F32, F64) to their compact Num representations.
+/// This ensures that numeric types in method signatures use num_compact instead of staying as nominal types,
+/// which is necessary for proper unification and serialization.
+fn transformNumericNominalToPrimitive(env: *ModuleEnv) !void {
+    const Num = types.Num;
+
+    // Map of numeric type names to their compact representations
+    const NumericTypeMapping = struct {
+        name: []const u8,
+        num_type: Num,
+    };
+
+    const numeric_mappings = [_]NumericTypeMapping{
+        .{ .name = "U8", .num_type = .{ .num_compact = .{ .int = .u8 } } },
+        .{ .name = "I8", .num_type = .{ .num_compact = .{ .int = .i8 } } },
+        .{ .name = "U16", .num_type = .{ .num_compact = .{ .int = .u16 } } },
+        .{ .name = "I16", .num_type = .{ .num_compact = .{ .int = .i16 } } },
+        .{ .name = "U32", .num_type = .{ .num_compact = .{ .int = .u32 } } },
+        .{ .name = "I32", .num_type = .{ .num_compact = .{ .int = .i32 } } },
+        .{ .name = "U64", .num_type = .{ .num_compact = .{ .int = .u64 } } },
+        .{ .name = "I64", .num_type = .{ .num_compact = .{ .int = .i64 } } },
+        .{ .name = "U128", .num_type = .{ .num_compact = .{ .int = .u128 } } },
+        .{ .name = "I128", .num_type = .{ .num_compact = .{ .int = .i128 } } },
+        .{ .name = "Dec", .num_type = .{ .num_compact = .{ .frac = .dec } } },
+        .{ .name = "F32", .num_type = .{ .num_compact = .{ .frac = .f32 } } },
+        .{ .name = "F64", .num_type = .{ .num_compact = .{ .frac = .f64 } } },
+    };
+
+    // Build a map of identifier -> num type for fast lookup
+    var ident_to_num_map = std.AutoHashMap(base.Ident.Idx, Num).init(env.gpa);
+    defer ident_to_num_map.deinit();
+
+    for (numeric_mappings) |mapping| {
+        if (env.common.findIdent(mapping.name)) |ident| {
+            try ident_to_num_map.put(ident, mapping.num_type);
+        }
+    }
+
+    // Iterate through all slots in the type store
+    for (0..env.types.len()) |i| {
+        const var_idx = @as(Var, @enumFromInt(i));
+
+        // Skip redirects, only process roots
+        if (!env.types.resolveVar(var_idx).is_root) {
+            continue;
+        }
+
+        const resolved = env.types.resolveVar(var_idx);
+        const desc = resolved.desc;
+
+        // Check if this descriptor contains a nominal type
+        switch (desc.content) {
+            .structure => |structure| {
+                switch (structure) {
+                    .nominal_type => |nominal| {
+                        // Check if this is a numeric nominal type
+                        if (ident_to_num_map.get(nominal.ident.ident_idx)) |num_type| {
+                            // Replace with compact num type
+                            const new_content = Content{ .structure = .{ .num = num_type } };
+                            const new_desc = types.Descriptor{
+                                .content = new_content,
+                                .rank = desc.rank,
+                                .mark = desc.mark,
+                            };
+                            try env.types.setVarDesc(var_idx, new_desc);
+                        }
+                    },
+                    else => {},
+                }
+            },
+            else => {},
+        }
+    }
+}
+
 /// Replace specific e_anno_only expressions with e_low_level_lambda operations.
 /// This transforms standalone annotations into low-level builtin lambda operations
 /// that will be recognized by the compiler backend.
@@ -270,7 +345,7 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
         }
     }
 
-    // Numeric arithmetic operations (all numeric types have plus, minus, times, div_by, rem_by)
+    // Numeric arithmetic operations (all numeric types have plus, minus, times, div, rem)
     for (numeric_types) |num_type| {
         var buf: [256]u8 = undefined;
 
@@ -292,15 +367,15 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
             try low_level_map.put(ident, .num_times);
         }
 
-        // div_by
-        const div_by = try std.fmt.bufPrint(&buf, "Builtin.Num.{s}.div_by", .{num_type});
-        if (env.common.findIdent(div_by)) |ident| {
+        // div
+        const div = try std.fmt.bufPrint(&buf, "Builtin.Num.{s}.div", .{num_type});
+        if (env.common.findIdent(div)) |ident| {
             try low_level_map.put(ident, .num_div_by);
         }
 
-        // rem_by
-        const rem_by = try std.fmt.bufPrint(&buf, "Builtin.Num.{s}.rem_by", .{num_type});
-        if (env.common.findIdent(rem_by)) |ident| {
+        // rem
+        const rem = try std.fmt.bufPrint(&buf, "Builtin.Num.{s}.rem", .{num_type});
+        if (env.common.findIdent(rem)) |ident| {
             try low_level_map.put(ident, .num_rem_by);
         }
     }
@@ -316,22 +391,57 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
         }
     }
 
+    // DEBUG: Show what we're looking for
+    std.debug.print("\n=== DEBUG: Builtin Compiler Method Transformation ===\n", .{});
+    std.debug.print("Looking for {d} low-level operations to transform:\n", .{low_level_map.count()});
+    {
+        var iter = low_level_map.iterator();
+        var count: usize = 0;
+        while (iter.next()) |entry| {
+            const ident_text = env.getIdentText(entry.key_ptr.*);
+            const op_name = @tagName(entry.value_ptr.*);
+            if (count < 10 or std.mem.indexOf(u8, ident_text, "I128") != null) {
+                std.debug.print("  - {s} -> .{s}\n", .{ ident_text, op_name });
+            }
+            count += 1;
+        }
+        if (count > 10) {
+            std.debug.print("  ... and {d} more\n", .{count - 10});
+        }
+    }
+    std.debug.print("\n", .{});
+
     // Iterate through all defs and replace matching anno-only defs with low-level implementations
     const all_defs = env.store.sliceDefs(env.all_defs);
+    std.debug.print("Examining {d} total defs for .e_anno_only expressions...\n", .{all_defs.len});
+
+    var anno_only_count: usize = 0;
+    var matched_count: usize = 0;
+
     for (all_defs) |def_idx| {
         const def = env.store.getDef(def_idx);
         const expr = env.store.getExpr(def.expr);
 
         // Check if this is an anno-only def (e_anno_only expression)
         if (expr == .e_anno_only and def.annotation != null) {
+            anno_only_count += 1;
+
             // Get the identifier from the pattern
             const pattern = env.store.getPattern(def.pattern);
             if (pattern == .assign) {
                 const ident = pattern.assign.ident;
+                const ident_text = env.getIdentText(ident);
+
+                // DEBUG: Show first few anno_only defs and all I128 ones
+                if (anno_only_count <= 5 or std.mem.indexOf(u8, ident_text, "I128") != null) {
+                    std.debug.print("  Found .e_anno_only def: {s}\n", .{ident_text});
+                }
 
                 // Check if this identifier matches a low-level operation
                 if (low_level_map.fetchRemove(ident)) |entry| {
                     const low_level_op = entry.value;
+                    matched_count += 1;
+                    std.debug.print("    -> MATCHED! Transforming to .{s}\n", .{@tagName(low_level_op)});
 
                     // Create a dummy parameter pattern for the lambda
                     // Use the identifier "_arg" for the parameter
@@ -359,12 +469,28 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
                     } }, base.Region.zero());
 
                     // Now replace the e_anno_only expression with the e_low_level_lambda
-                    // We need to modify the def's expr field to point to our new expression
-                    // CIR.Def.Idx and Node.Idx have the same underlying representation
+                    // The def stores its fields in extra_data:
+                    //   extra_data[0] = pattern
+                    //   extra_data[1] = expr  <- This is what we need to modify!
+                    //   extra_data[2..3] = kind
+                    //   extra_data[4] = annotation
                     const def_node_idx = @as(@TypeOf(env.store.nodes).Idx, @enumFromInt(@intFromEnum(def_idx)));
-                    var def_node = env.store.nodes.get(def_node_idx);
-                    def_node.data_2 = @intFromEnum(expr_idx);
-                    env.store.nodes.set(def_node_idx, def_node);
+                    const def_node = env.store.nodes.get(def_node_idx);
+                    const extra_start = def_node.data_1;
+                    // Modify the expr field (at offset 1 from extra_start)
+                    env.store.extra_data.items.items[extra_start + 1] = @intFromEnum(expr_idx);
+
+                    // DEBUG STEP 1: Verify the transformation actually happened
+                    if (std.mem.indexOf(u8, ident_text, "I128.plus") != null) {
+                        const updated_def = env.store.getDef(def_idx);
+                        const updated_expr = env.store.getExpr(updated_def.expr);
+                        std.debug.print("    [STEP 1 VERIFY] After transformation, expr tag for {s}: {s}\n", .{ ident_text, @tagName(updated_expr) });
+                        if (updated_expr == .e_low_level_lambda) {
+                            std.debug.print("    [STEP 1 VERIFY] ✓ Transformation succeeded in memory!\n", .{});
+                        } else {
+                            std.debug.print("    [STEP 1 VERIFY] ✗ PROBLEM: Still {s}, transformation failed!\n", .{@tagName(updated_expr)});
+                        }
+                    }
 
                     // Track this replaced def index
                     try new_def_indices.append(gpa, def_idx);
@@ -373,6 +499,13 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
         }
     }
 
+    // DEBUG: Show summary
+    std.debug.print("\n=== Transformation Summary ===\n", .{});
+    std.debug.print("Total .e_anno_only defs found: {d}\n", .{anno_only_count});
+    std.debug.print("Successfully transformed: {d}\n", .{matched_count});
+    std.debug.print("Operations still not found: {d}\n", .{low_level_map.count()});
+    std.debug.print("==========================================\n\n", .{});
+
     // Verify all low-level operations were found in the builtins
     if (low_level_map.count() > 0) {
         std.debug.print("\n" ++ "=" ** 80 ++ "\n", .{});
@@ -581,9 +714,10 @@ pub fn main() !void {
 
     // Transform nominal types to primitive types as necessary.
     // This must happen BEFORE serialization to ensure the .bin file contains
-    // methods associated with the .str primitive, not a nominal type
+    // methods associated with primitives/compact types, not nominal types
     try transformStrNominalToPrimitive(builtin_env);
     try transformListNominalToPrimitive(builtin_env);
+    try transformNumericNominalToPrimitive(builtin_env);
 
     // Create output directory
     try std.fs.cwd().makePath("zig-out/builtins");
@@ -729,6 +863,11 @@ fn compileModule(
                     const nested = module_env.getIdentText(d.nested_name);
                     std.debug.print("  - Nested value not found: {s}.{s}\n", .{ parent, nested });
                 },
+                .malformed_type_annotation => |d| {
+                    const region = d.region;
+                    const text = source[region.start.offset..region.end.offset];
+                    std.debug.print("  - Malformed type annotation at offset {d}-{d}: '{s}'\n", .{ region.start.offset, region.end.offset, text });
+                },
                 else => {
                     std.debug.print("  - Diagnostic: {any}\n", .{diag});
                 },