Merge remote-tracking branch 'origin/main' into numeric-builtins

# Conflicts:
#	src/backend/dev/LirCodeGen.zig
#	src/build/roc/Builtin.roc
#	src/cli/main.zig
#	src/cli/targets/arm64musl/roc_default_platform.o
#	test/snapshots/match_expr/guards_1.md
#	test/snapshots/type_app_multiple_args.md

Author: lukewilliamboswell

.gitignore

@@ -140,6 +140,7 @@ src/snapshots/**/*.html
 
 # Local claude-code settings
 .claude/
+.claude
 
 *.bak
 kcov-output/

src/backend/dev/LirCodeGen.zig

@@ -3945,10 +3945,16 @@ pub fn LirCodeGen(comptime target: RocTarget) type {
                     return .{ .general_reg = gt_reg };
                 },
 
+                // Resolved before backend codegen: builtin `from_numeral` is
+                // folded to a constant during Monotype lowering, so the op must
+                // never reach a backend. Reaching here is an invariant failure,
+                // not a missing feature.
+                .num_from_numeral => {
+                    std.debug.panic("num_from_numeral reached the dev backend; it must be folded to a constant during Monotype lowering", .{});
+                },
                 // Unimplemented ops
                 .num_log,
                 .num_round,
-                .num_from_numeral,
                 => {
                     std.debug.panic("UNIMPLEMENTED low-level op: {s}", .{@tagName(ll.op)});
                 },
@@ -5649,7 +5655,8 @@ pub fn LirCodeGen(comptime target: RocTarget) type {
                         try locals.put(localKey(expect_stmt.condition), expect_stmt.condition);
                         try stack.append(sa, expect_stmt.next);
                     },
-                    .runtime_error => {},
+                    .comptime_branch_taken => |marker| try stack.append(sa, marker.next),
+                    .runtime_error, .comptime_exhaustiveness_failed => {},
                     .incref => |inc| {
                         try locals.put(localKey(inc.value), inc.value);
                         try stack.append(sa, inc.next);
@@ -5770,7 +5777,8 @@ pub fn LirCodeGen(comptime target: RocTarget) type {
                         try locals.put(localKey(expect_stmt.condition), expect_stmt.condition);
                         try stack.append(sa, expect_stmt.next);
                     },
-                    .runtime_error => {},
+                    .comptime_branch_taken => |marker| try stack.append(sa, marker.next),
+                    .runtime_error, .comptime_exhaustiveness_failed => {},
                     .incref => |inc| {
                         try locals.put(localKey(inc.value), inc.value);
                         try stack.append(sa, inc.next);
@@ -14488,6 +14496,15 @@ pub fn LirCodeGen(comptime target: RocTarget) type {
                             try self.emitTrap();
                         },
 
+                        .comptime_exhaustiveness_failed => {
+                            try self.emitRocCrash("compile-time exhaustiveness failure reached runtime code");
+                            try self.emitTrap();
+                        },
+
+                        .comptime_branch_taken => |marker| {
+                            try work.append(wa, .{ .node = marker.next });
+                        },
+
                         .join => |j| {
                             const jp_key = @intFromEnum(j.id);
                             try self.setupJoinPointParams(j.id, j.params);

src/backend/llvm/Builder.zig

@@ -6111,7 +6111,7 @@ pub const WipFunction = struct {
         args: []const Value,
         name: []const u8,
     ) Allocator.Error!Value {
-        return self.callInner(kind, call_conv, function_attributes, ty, callee, args, name, false);
+        return self.callInner(kind, call_conv, function_attributes, ty, callee, args, name, false, false);
     }
 
     fn callInner(
@@ -6124,6 +6124,7 @@ pub const WipFunction = struct {
         args: []const Value,
         name: []const u8,
         has_op_bundle_cold: bool,
+        force_debug_location: bool,
     ) Allocator.Error!Value {
         const ret_ty = ty.functionReturn(self.builder);
         assert(ty.isFunction(self.builder));
@@ -6132,31 +6133,35 @@ pub const WipFunction = struct {
         for (params, args[0..params.len]) |param, arg_val| assert(param == arg_val.typeOfWip(self));
 
         try self.ensureUnusedExtraCapacity(1, Instruction.Call, args.len);
-        const instruction = try self.addInst(switch (ret_ty) {
-            .void => null,
-            else => name,
-        }, .{
-            .tag = switch (kind) {
-                .normal => .call,
-                .fast => .@"call fast",
-                .musttail => .@"musttail call",
-                .musttail_fast => .@"musttail call fast",
-                .notail => .@"notail call",
-                .notail_fast => .@"notail call fast",
-                .tail => .@"tail call",
-                .tail_fast => .@"tail call fast",
-            },
-            .data = self.addExtraAssumeCapacity(Instruction.Call{
-                .info = .{
-                    .call_conv = call_conv,
-                    .has_op_bundle_cold = has_op_bundle_cold,
+        const instruction = try self.addInstInner(
+            switch (ret_ty) {
+                .void => null,
+                else => name,
+            },
+            .{
+                .tag = switch (kind) {
+                    .normal => .call,
+                    .fast => .@"call fast",
+                    .musttail => .@"musttail call",
+                    .musttail_fast => .@"musttail call fast",
+                    .notail => .@"notail call",
+                    .notail_fast => .@"notail call fast",
+                    .tail => .@"tail call",
+                    .tail_fast => .@"tail call fast",
                 },
-                .attributes = function_attributes,
-                .ty = ty,
-                .callee = callee,
-                .args_len = @intCast(args.len),
-            }),
-        });
+                .data = self.addExtraAssumeCapacity(Instruction.Call{
+                    .info = .{
+                        .call_conv = call_conv,
+                        .has_op_bundle_cold = has_op_bundle_cold,
+                    },
+                    .attributes = function_attributes,
+                    .ty = ty,
+                    .callee = callee,
+                    .args_len = @intCast(args.len),
+                }),
+            },
+            force_debug_location,
+        );
         self.extra.appendSliceAssumeCapacity(@ptrCast(args));
         return instruction.toValue();
     }
@@ -6185,14 +6190,19 @@ pub const WipFunction = struct {
         name: []const u8,
     ) Allocator.Error!Value {
         const intrinsic = try self.builder.getIntrinsic(id, overload);
-        return self.call(
+        return self.callInner(
             fast.toCallKind(),
             CallConv.default,
             function_attributes,
             intrinsic.typeOf(self.builder),
             intrinsic.toValue(self.builder),
             args,
             name,
+            false,
+            switch (id) {
+                .@"dbg.declare", .@"dbg.value" => self.debug_location != .no_location,
+                else => false,
+            },
         );
     }
 
@@ -6207,6 +6217,7 @@ pub const WipFunction = struct {
             &.{try self.builder.intValue(.i1, 1)},
             "",
             true,
+            false,
         );
     }
 
@@ -6990,6 +7001,15 @@ pub const WipFunction = struct {
         self: *WipFunction,
         name: ?[]const u8,
         instruction: Instruction,
+    ) Allocator.Error!Instruction.Index {
+        return self.addInstInner(name, instruction, false);
+    }
+
+    fn addInstInner(
+        self: *WipFunction,
+        name: ?[]const u8,
+        instruction: Instruction,
+        force_debug_location: bool,
     ) Allocator.Error!Instruction.Index {
         const block_instructions = &self.cursor.block.ptr(self).instructions;
         try self.instructions.ensureUnusedCapacity(self.builder.gpa, 1);
@@ -7007,7 +7027,8 @@ pub const WipFunction = struct {
         self.instructions.appendAssumeCapacity(instruction);
         if (!self.strip) {
             self.names.appendAssumeCapacity(final_name);
-            if (block_instructions.items.len == 0 or
+            if (force_debug_location or
+                block_instructions.items.len == 0 or
                 !std.meta.eql(self.debug_location, self.prev_debug_location))
             {
                 self.debug_locations.putAssumeCapacity(index, self.debug_location);

src/backend/llvm/MonoLlvmCodeGen.zig

@@ -171,6 +171,8 @@ pub const MonoLlvmCodeGen = struct {
     /// one subprogram per proc, and per-statement line locations from the
     /// LIR store's source-location tables.
     emit_debug_info: bool = false,
+    /// Emit local variable declarations for source-level debugger inspection.
+    emit_local_debug_info: bool = false,
     /// Build-only default-platform Linux executables link a small runtime
     /// object that owns process startup diagnostics and signal handling.
     enable_default_platform_runtime: bool = false,
@@ -1187,7 +1189,9 @@ pub const MonoLlvmCodeGen = struct {
         defer self.allocator.free(self.local_slots);
         try self.allocLocalSlots();
         try self.unpackProcArgs(proc);
-        if (!builder.strip) try self.declareFrameLocals(proc, self.store.procLoc(proc_id).line);
+        if (!builder.strip and self.emit_local_debug_info) {
+            try self.declareFrameLocals(proc, self.store.procLoc(proc_id).line);
+        }
 
         if (proc.hosted) |hosted| {
             try self.emitHostedProcBody(hosted, proc);
@@ -1388,7 +1392,7 @@ pub const MonoLlvmCodeGen = struct {
         arg_layouts: []const layout.Idx,
         ret_layout: layout.Idx,
     ) Error!void {
-        if (self.enable_default_platform_runtime and
+        if (self.enable_default_platform_hosted_calls and
             self.host_call_mode == .extern_symbols and
             self.target.os.tag == .linux and
             std.mem.eql(u8, symbol_name, "_start"))
@@ -1798,6 +1802,12 @@ pub const MonoLlvmCodeGen = struct {
             .runtime_error => {
                 try self.emitCrashBytes("hit a runtime error");
             },
+            .comptime_exhaustiveness_failed => {
+                try self.emitCrashBytes("compile-time exhaustiveness failure reached runtime code");
+            },
+            .comptime_branch_taken => |marker| {
+                try work.append(wa, .{ .node = marker.next });
+            },
             .incref => |inc| {
                 try self.emitRcForLocal(.incref, inc.value, inc.count, inc.atomicity);
                 try work.append(wa, .{ .node = inc.next });

src/backend/wasm/WasmCodeGen.zig

@@ -3184,7 +3184,8 @@ fn collectProcLocals(
                 try recordProcLocal(locals, expect_stmt.condition);
                 try work.append(wa, expect_stmt.next);
             },
-            .runtime_error => {},
+            .comptime_branch_taken => |marker| try work.append(wa, marker.next),
+            .runtime_error, .comptime_exhaustiveness_failed => {},
             .switch_stmt => |switch_stmt| {
                 try recordProcLocal(locals, switch_stmt.cond);
                 for (self.store.getCFSwitchBranches(switch_stmt.branches)) |branch| {
@@ -7371,6 +7372,13 @@ fn generateCFStmtNode(self: *Self, work: *std.ArrayList(StmtWork), wa: Allocator
             try self.emitRocStaticStringCall(wasm_roc_ops_crashed_offset, msg);
             self.currentCode().append(self.allocator, Op.@"unreachable") catch return error.OutOfMemory;
         },
+        .comptime_exhaustiveness_failed => {
+            try self.emitRocStaticStringCall(wasm_roc_ops_crashed_offset, "compile-time exhaustiveness failure reached runtime code");
+            self.currentCode().append(self.allocator, Op.@"unreachable") catch return error.OutOfMemory;
+        },
+        .comptime_branch_taken => |marker| {
+            try work.append(wa, .{ .node = .{ .stmt_id = marker.next, .stop = stop } });
+        },
         .crash => |crash| {
             const msg_bytes = self.store.getString(crash.msg);
             try self.emitRocStaticStringCall(wasm_roc_ops_crashed_offset, msg_bytes);
@@ -10535,7 +10543,7 @@ fn generateLowLevel(self: *Self, ll: anytype) Allocator.Error!void {
                 .{@tagName(self.procLocalLayoutIdx(args[0]))},
             ),
         },
-        .num_from_numeral => unreachable, // Resolved before backend codegen
+        .num_from_numeral => unreachable, // Folded to a constant during Monotype lowering
 
         // Box operations
         .box_box => {

src/base/mod.zig

@@ -82,6 +82,9 @@ pub const CalledVia = enum {
     /// Try.parallel(get("a"), get("b"), (|foo, bar | { foo, bar }))
     /// ```
     record_builder,
+    /// This call is the result of desugaring range syntax,
+    /// e.g. `1..<5` becomes `Iter.exclusive_range(1, 5)`.
+    range,
 };
 
 /// Represents a value written as-is in a Roc source file.