Merge remote-tracking branch 'origin/main' into omit-inline-debug-effects

# Conflicts:
#	src/eval/compile_time_finalization.zig
#	src/postcheck/lambda_mono/lower.zig

Author: rtfeldman

src/backend/dev/LirCodeGen.zig

@@ -5428,7 +5428,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);
@@ -5549,7 +5550,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);
@@ -14048,6 +14050,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,
@@ -997,14 +999,12 @@ pub const MonoLlvmCodeGen = struct {
         const file = try self.debugFileFor(builder, self.current_debug_file);
         const empty_expr = builder.debugExpression(&.{}) catch return error.OutOfMemory;
         const previous_debug_location = wip.debug_location;
-        if (self.enable_default_platform_diagnostics) {
-            wip.debug_location = .{ .location = .{
-                .line = proc_line,
-                .column = if (proc_line == 0) 0 else 1,
-                .scope = scope.toOptional(),
-                .inlined_at = .none,
-            } };
-        }
+        wip.debug_location = .{ .location = .{
+            .line = proc_line,
+            .column = if (proc_line == 0) 0 else 1,
+            .scope = scope.toOptional(),
+            .inlined_at = .none,
+        } };
         defer wip.debug_location = previous_debug_location;
 
         for (self.store.getLocalSpan(proc.frame_locals)) |local_id| {
@@ -1189,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);
@@ -1390,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"))
@@ -1800,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

@@ -3123,7 +3123,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| {
@@ -7284,6 +7285,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);

src/canonicalize/Can.zig

@@ -10129,6 +10129,7 @@ fn runExprKernel(
                 const if_expr_idx = try self.env.addExpr(Expr{ .e_if = .{
                     .branches = branches_span,
                     .final_else = final_else,
+                    .warn_unused_branches = false,
                 } }, state.region);
 
                 const if_free_vars = self.scratch_free_vars.spanFrom(state.free_vars_start);
@@ -10802,6 +10803,7 @@ fn runExprKernel(
                 .e_if = .{
                     .branches = branches_span,
                     .final_else = can_else.idx,
+                    .warn_unused_branches = true,
                 },
             }, state.region);
 
@@ -10868,6 +10870,7 @@ fn runExprKernel(
                 .e_if = .{
                     .branches = branches_span,
                     .final_else = empty_record_idx,
+                    .warn_unused_branches = true,
                 },
             }, state.region);
 

src/canonicalize/Expression.zig

@@ -201,6 +201,7 @@ pub const Expr = union(enum) {
     e_if: struct {
         branches: IfBranch.Span,
         final_else: Expr.Idx,
+        warn_unused_branches: bool,
     },
     /// This is *only* for calling functions, not for tag application.
     /// The Tag variant contains any applied values inside it.

src/canonicalize/Node.zig

@@ -575,7 +575,7 @@ pub const Payload = extern union {
     };
 
     pub const ExprIfThenElse = extern struct {
-        branches_else_idx: u32, // Index into span_with_node_data: (branches.start, branches.len, final_else)
+        branches_else_idx: u32, // Index into if_data
         _padding: [8]u8 = .{ 0, 0, 0, 0, 0, 0, 0, 0 },
     };