Merge pull request #9642 from roc-lang/comptime-exhaustiveness

Implement comptime exhaustiveness checking

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/MonoLlvmCodeGen.zig

@@ -1800,6 +1800,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 },
     };
 

src/canonicalize/NodeStore.zig

@@ -28,6 +28,7 @@ span2_data: collections.SafeList(Span2), // Typed storage for (start, len) span
 span_with_node_data: collections.SafeList(SpanWithNode), // Typed storage for (start, len, node) triples
 method_call_data: collections.SafeList(MethodCallData), // Typed storage for method args plus method-token source region
 match_data: collections.SafeList(MatchData), // Typed storage for match expression data
+if_data: collections.SafeList(IfData), // Typed storage for if expression data
 match_branch_data: collections.SafeList(MatchBranchData), // Typed storage for match branch data
 closure_data: collections.SafeList(ClosureData), // Typed storage for closure expressions
 zero_arg_tag_data: collections.SafeList(ZeroArgTagData), // Typed storage for zero-argument tags
@@ -73,6 +74,15 @@ pub const MatchData = extern struct {
     skip_exhaustiveness: u32,
 };
 
+/// If expression data.
+/// Stores branches span, final else, and whether to warn for untaken compile-time branches.
+pub const IfData = extern struct {
+    branches_start: u32,
+    branches_len: u32,
+    final_else: u32,
+    warn_unused_branches: u32,
+};
+
 /// Match branch data.
 /// Stores patterns span, value, guard, and redundant flag.
 pub const MatchBranchData = extern struct {
@@ -257,6 +267,8 @@ pub fn initCapacity(gpa: Allocator, capacity: usize) Allocator.Error!NodeStore {
     errdefer method_call_data.deinit(gpa);
     var match_data = try collections.SafeList(MatchData).initCapacity(gpa, capacity / 8);
     errdefer match_data.deinit(gpa);
+    var if_data = try collections.SafeList(IfData).initCapacity(gpa, capacity / 8);
+    errdefer if_data.deinit(gpa);
     var match_branch_data = try collections.SafeList(MatchBranchData).initCapacity(gpa, capacity / 8);
     errdefer match_branch_data.deinit(gpa);
     var closure_data = try collections.SafeList(ClosureData).initCapacity(gpa, capacity / 16);
@@ -285,6 +297,7 @@ pub fn initCapacity(gpa: Allocator, capacity: usize) Allocator.Error!NodeStore {
         .span_with_node_data = span_with_node_data,
         .method_call_data = method_call_data,
         .match_data = match_data,
+        .if_data = if_data,
         .match_branch_data = match_branch_data,
         .closure_data = closure_data,
         .zero_arg_tag_data = zero_arg_tag_data,
@@ -308,6 +321,7 @@ pub fn clone(self: *const NodeStore, gpa: Allocator) Allocator.Error!NodeStore {
         .span_with_node_data = try self.span_with_node_data.clone(gpa),
         .method_call_data = try self.method_call_data.clone(gpa),
         .match_data = try self.match_data.clone(gpa),
+        .if_data = try self.if_data.clone(gpa),
         .match_branch_data = try self.match_branch_data.clone(gpa),
         .closure_data = try self.closure_data.clone(gpa),
         .zero_arg_tag_data = try self.zero_arg_tag_data.clone(gpa),
@@ -331,6 +345,7 @@ pub fn deinit(store: *NodeStore) void {
     store.span_with_node_data.deinit(store.gpa);
     store.method_call_data.deinit(store.gpa);
     store.match_data.deinit(store.gpa);
+    store.if_data.deinit(store.gpa);
     store.match_branch_data.deinit(store.gpa);
     store.closure_data.deinit(store.gpa);
     store.zero_arg_tag_data.deinit(store.gpa);
@@ -354,6 +369,7 @@ pub fn relocate(store: *NodeStore, offset: isize) void {
     store.span_with_node_data.relocate(offset);
     store.method_call_data.relocate(offset);
     store.match_data.relocate(offset);
+    store.if_data.relocate(offset);
     store.match_branch_data.relocate(offset);
     store.closure_data.relocate(offset);
     store.zero_arg_tag_data.relocate(offset);
@@ -1034,12 +1050,12 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr {
         },
         .expr_if_then_else => {
             const p = payload.expr_if_then_else;
-            // Retrieve branches span and final_else from span_with_node_data
-            const branches_else = store.span_with_node_data.items.items[p.branches_else_idx];
+            const if_data = store.if_data.items.items[p.branches_else_idx];
 
             return CIR.Expr{ .e_if = .{
-                .branches = .{ .span = .{ .start = branches_else.start, .len = branches_else.len } },
-                .final_else = @enumFromInt(branches_else.node),
+                .branches = .{ .span = .{ .start = if_data.branches_start, .len = if_data.branches_len } },
+                .final_else = @enumFromInt(if_data.final_else),
+                .warn_unused_branches = if_data.warn_unused_branches != 0,
             } };
         },
         .expr_field_access => {
@@ -2454,15 +2470,16 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) Allocator
         },
         .e_if => |e| {
             node.tag = .expr_if_then_else;
-            const branches_else_idx: u32 = @intCast(store.span_with_node_data.len());
-            _ = try store.span_with_node_data.append(store.gpa, .{
-                .start = e.branches.span.start,
-                .len = e.branches.span.len,
-                .node = @intFromEnum(e.final_else),
+            const if_data_idx: u32 = @intCast(store.if_data.len());
+            _ = try store.if_data.append(store.gpa, .{
+                .branches_start = e.branches.span.start,
+                .branches_len = e.branches.span.len,
+                .final_else = @intFromEnum(e.final_else),
+                .warn_unused_branches = @intFromBool(e.warn_unused_branches),
             });
 
             node.setPayload(.{ .expr_if_then_else = .{
-                .branches_else_idx = branches_else_idx,
+                .branches_else_idx = if_data_idx,
             } });
         },
         .e_call => |e| {
@@ -4603,6 +4620,7 @@ pub const Serialized = extern struct {
     span_with_node_data: collections.SafeList(SpanWithNode).Serialized,
     method_call_data: collections.SafeList(MethodCallData).Serialized,
     match_data: collections.SafeList(MatchData).Serialized,
+    if_data: collections.SafeList(IfData).Serialized,
     match_branch_data: collections.SafeList(MatchBranchData).Serialized,
     closure_data: collections.SafeList(ClosureData).Serialized,
     zero_arg_tag_data: collections.SafeList(ZeroArgTagData).Serialized,
@@ -4634,6 +4652,8 @@ pub const Serialized = extern struct {
         try self.method_call_data.serialize(&store.method_call_data, allocator, writer);
         // Serialize match_data
         try self.match_data.serialize(&store.match_data, allocator, writer);
+        // Serialize if_data
+        try self.if_data.serialize(&store.if_data, allocator, writer);
         // Serialize match_branch_data
         try self.match_branch_data.serialize(&store.match_branch_data, allocator, writer);
         // Serialize closure_data
@@ -4666,6 +4686,7 @@ pub const Serialized = extern struct {
             .span_with_node_data = self.span_with_node_data.deserializeInto(base_addr),
             .method_call_data = self.method_call_data.deserializeInto(base_addr),
             .match_data = self.match_data.deserializeInto(base_addr),
+            .if_data = self.if_data.deserializeInto(base_addr),
             .match_branch_data = self.match_branch_data.deserializeInto(base_addr),
             .closure_data = self.closure_data.deserializeInto(base_addr),
             .zero_arg_tag_data = self.zero_arg_tag_data.deserializeInto(base_addr),
@@ -4691,6 +4712,7 @@ pub const Serialized = extern struct {
             .span_with_node_data = self.span_with_node_data.deserializeInto(base_addr),
             .method_call_data = self.method_call_data.deserializeInto(base_addr),
             .match_data = self.match_data.deserializeInto(base_addr),
+            .if_data = self.if_data.deserializeInto(base_addr),
             .match_branch_data = self.match_branch_data.deserializeInto(base_addr),
             .closure_data = self.closure_data.deserializeInto(base_addr),
             .zero_arg_tag_data = self.zero_arg_tag_data.deserializeInto(base_addr),

src/canonicalize/test/node_store_test.zig

@@ -314,6 +314,7 @@ test "NodeStore round trip - Expressions" {
         .e_if = .{
             .branches = CIR.Expr.IfBranch.Span{ .span = rand_span() },
             .final_else = rand_idx(CIR.Expr.Idx),
+            .warn_unused_branches = true,
         },
     });
     try expressions.append(gpa, CIR.Expr{

src/check/Check.zig

@@ -186,6 +186,11 @@ checking_call_arg: bool = false,
 /// treatment of a variable binding. Deliberately NOT set for mutable `var`
 /// bindings, which must never generalize.
 checking_binding_rhs: bool = false,
+/// Nonzero while checking source that constructs a compile-time value. Static
+/// exhaustiveness diagnostics under this depth are empirical candidates: the
+/// compile-time finalizer either observes them executing, reports their generated
+/// miss path, or discards them if the source was not reached.
+empirical_exhaustiveness_depth: u32 = 0,
 /// Deferred def-level unifications (def_var = ptrn_var = expr_var).
 /// These must happen AFTER generalization to avoid lowering expr_var's rank
 /// before generalization can process it, but BEFORE eql constraint resolution
@@ -3422,6 +3427,9 @@ fn checkDef(self: *Self, def_idx: CIR.Def.Idx, env: *Env) std.mem.Allocator.Erro
         }
     };
 
+    self.empirical_exhaustiveness_depth += 1;
+    defer self.empirical_exhaustiveness_depth -= 1;
+
     // Infer types for the body, checking against the instantiated annotation
     self.checking_binding_rhs = true;
     const def_does_fx = try self.checkExpr(def.expr, env, expectation);
@@ -6417,6 +6425,10 @@ fn checkExpr(self: *Self, expr_idx: CIR.Expr.Idx, env: *Env, expected: Expected)
 
             // Check the the body of the expr
             // If we have an expected function, use that as the expr's expected type
+            const saved_empirical_exhaustiveness_depth = self.empirical_exhaustiveness_depth;
+            self.empirical_exhaustiveness_depth = 0;
+            defer self.empirical_exhaustiveness_depth = saved_empirical_exhaustiveness_depth;
+
             const body_does_fx = if (mb_anno_func) |expected_func| blk: {
                 const lambda_body_does_fx = try self.checkExpr(lambda.body, env, Expected.none().withBranchResult(expected_func.ret));
                 try self.closeAbsentConstructedPayloadVars(lambda.body, body_var);
@@ -7779,6 +7791,10 @@ fn closeAbsentConstructedPayloadVars(
     }
 }
 
+fn pendingExhaustivenessMode(self: *const Self) ProblemStore.PendingStaticExhaustivenessMode {
+    return if (self.empirical_exhaustiveness_depth == 0) .static else .empirical;
+}
+
 fn checkDestructureExhaustiveness(
     self: *Self,
     pattern_idx: CIR.Pattern.Idx,
@@ -7829,7 +7845,7 @@ fn checkDestructureExhaustiveness(
             .count = self.problems.missing_patterns_backing.items.len - missing_patterns_start,
         };
 
-        _ = try self.problems.appendProblem(self.gpa, .{ .non_exhaustive_destructure = .{
+        try self.problems.appendPendingStaticExhaustiveness(self.gpa, .destructure, self.pendingExhaustivenessMode(), region, .{ .non_exhaustive_destructure = .{
             .pattern = pattern_idx,
             .value_snapshot = value_snapshot,
             .missing_patterns = missing_patterns_range,
@@ -8587,7 +8603,7 @@ fn checkMatchExpr(
                 .count = self.problems.missing_patterns_backing.items.len - missing_patterns_start,
             };
 
-            _ = try self.problems.appendProblem(self.gpa, .{ .non_exhaustive_match = .{
+            try self.problems.appendPendingStaticExhaustiveness(self.gpa, .match, self.pendingExhaustivenessMode(), match_region, .{ .non_exhaustive_match = .{
                 .match_expr = expr_idx,
                 .condition_snapshot = condition_snapshot,
                 .missing_patterns = missing_patterns_range,

src/check/checked_artifact.zig

@@ -4987,6 +4987,7 @@ pub const CheckedExprData = union(enum) {
     if_: struct {
         branches: []const CheckedIfBranch,
         final_else: CheckedExprId,
+        warn_unused_branches: bool,
     },
     call: struct {
         func: CheckedExprId,
@@ -6567,6 +6568,7 @@ const CheckedBodyPayloadCopier = struct {
             .e_if => |if_| .{ .if_ = .{
                 .branches = try self.copyIfBranches(if_.branches),
                 .final_else = self.checkedExpr(if_.final_else),
+                .warn_unused_branches = if_.warn_unused_branches,
             } },
             .e_call => |call| .{ .call = .{
                 .func = self.checkedExpr(call.func),