Merge pull request #8280 from roc-lang/bool-builtin

Add initial Bool.roc and Result.roc builtin modules

Author: rtfeldman

build.zig

@@ -22,9 +22,19 @@ pub fn build(b: *std.Build) void {
     const playground_test_step = b.step("test-playground", "Build the integration test suite for the WASM playground");
 
     // general configuration
-    const target = b.standardTargetOptions(.{ .default_target = .{
-        .abi = if (builtin.target.os.tag == .linux) .musl else null,
-    } });
+    const target = blk: {
+        var default_target_query: std.Target.Query = .{
+            .abi = if (builtin.target.os.tag == .linux) .musl else null,
+        };
+
+        // Use baseline x86_64 CPU for Valgrind compatibility on CI (Valgrind 3.18.1 doesn't support AVX-512)
+        const is_ci = std.process.getEnvVarOwned(b.allocator, "CI") catch null;
+        if (is_ci != null and builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .linux) {
+            default_target_query.cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 };
+        }
+
+        break :blk b.standardTargetOptions(.{ .default_target = default_target_query });
+    };
     const optimize = b.standardOptimizeOption(.{});
     const strip = b.option(bool, "strip", "Omit debug information");
     const no_bin = b.option(bool, "no-bin", "Skip emitting binaries (important for fast incremental compilation)") orelse false;
@@ -91,7 +101,7 @@ pub fn build(b: *std.Build) void {
     //
     // We cache the builtin compiler executable to avoid ~doubling normal build times.
     // CI always rebuilds from scratch, so it's not affected by this caching.
-    //
+
     // Discover all .roc files in src/build/roc/
     const roc_files = discoverBuiltinRocFiles(b) catch |err| {
         std.debug.print("Failed to discover builtin .roc files: {}\n", .{err});

src/build/builtin_compiler/main.zig

@@ -1,7 +1,7 @@
-//! Build-time compiler for Roc builtin modules (Dict.roc and Set.roc).
+//! Build-time compiler for Roc builtin modules (Bool.roc, Result.roc, Dict.roc, and Set.roc).
 //!
 //! This executable runs during `zig build` on the host machine to:
-//! 1. Parse and type-check Dict.roc and Set.roc
+//! 1. Parse and type-check the builtin .roc modules
 //! 2. Serialize the resulting ModuleEnvs to binary files
 //! 3. Output .bin files to zig-out/builtins/ (which get embedded in the roc binary)
 
@@ -21,6 +21,9 @@ const Allocator = std.mem.Allocator;
 /// Build-time compiler that compiles builtin .roc sources into serialized ModuleEnvs.
 /// This runs during `zig build` on the host machine to generate .bin files
 /// that get embedded into the final roc executable.
+///
+/// Note: Command-line arguments are ignored. The .roc files are read from fixed paths.
+/// The build system may pass file paths as arguments for cache tracking, but we don't use them.
 pub fn main() !void {
     var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
     defer {
@@ -31,33 +34,78 @@ pub fn main() !void {
     }
     const gpa = gpa_impl.allocator();
 
+    // Ignore command-line arguments - they're only used by Zig's build system for cache tracking
+
     // Read the .roc source files at runtime
+    const bool_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Bool.roc", 1024 * 1024);
+    defer gpa.free(bool_roc_source);
+
+    const result_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Result.roc", 1024 * 1024);
+    defer gpa.free(result_roc_source);
+
     const dict_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Dict.roc", 1024 * 1024);
     defer gpa.free(dict_roc_source);
 
     const set_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Set.roc", 1024 * 1024);
     defer gpa.free(set_roc_source);
 
-    // Compile Dict.roc first (it has no dependencies)
+    // Compile Bool.roc without injecting anything (it's completely self-contained)
+    const bool_env = try compileModule(
+        gpa,
+        "Bool",
+        bool_roc_source,
+        &.{}, // No module dependencies
+        .{ .inject_bool = false, .inject_result = false },
+    );
+    defer {
+        bool_env.deinit();
+        gpa.destroy(bool_env);
+    }
+
+    // Verify that Bool's type declaration is at the expected index (2)
+    // This is critical for the compiler's hardcoded BUILTIN_BOOL constant
+    const bool_type_idx = bool_env.all_statements.span.start;
+    if (bool_type_idx != 2) {
+        const stderr = std.io.getStdErr().writer();
+        try stderr.print("WARNING: Expected Bool at index 2, but got {}!\n", .{bool_type_idx});
+        return error.UnexpectedBoolIndex;
+    }
+
+    // Compile Result.roc (injects Bool since Result might use if expressions)
+    const result_env = try compileModule(
+        gpa,
+        "Result",
+        result_roc_source,
+        &.{}, // No module dependencies
+        .{ .inject_bool = true, .inject_result = false },
+    );
+    defer {
+        result_env.deinit();
+        gpa.destroy(result_env);
+    }
+
+    // Compile Dict.roc (needs Bool injected for if expressions, and Result for error handling)
     const dict_env = try compileModule(
         gpa,
         "Dict",
         dict_roc_source,
         &.{}, // No module dependencies
+        .{}, // Inject Bool and Result (defaults)
     );
     defer {
         dict_env.deinit();
         gpa.destroy(dict_env);
     }
 
-    // Compile Set.roc (it imports Dict)
+    // Compile Set.roc (imports Dict, needs Bool and Result injected)
     const set_env = try compileModule(
         gpa,
         "Set",
         set_roc_source,
         &[_]ModuleDep{
             .{ .name = "Dict", .env = dict_env },
         },
+        .{}, // Inject Bool and Result (defaults)
     );
     defer {
         set_env.deinit();
@@ -67,10 +115,10 @@ pub fn main() !void {
     // Create output directory
     try std.fs.cwd().makePath("zig-out/builtins");
 
-    // Serialize Dict module
+    // Serialize modules
+    try serializeModuleEnv(gpa, bool_env, "zig-out/builtins/Bool.bin");
+    try serializeModuleEnv(gpa, result_env, "zig-out/builtins/Result.bin");
     try serializeModuleEnv(gpa, dict_env, "zig-out/builtins/Dict.bin");
-
-    // Serialize Set module
     try serializeModuleEnv(gpa, set_env, "zig-out/builtins/Set.bin");
 }
 
@@ -84,6 +132,7 @@ fn compileModule(
     module_name: []const u8,
     source: []const u8,
     deps: []const ModuleDep,
+    can_options: Can.InitOptions,
 ) !*ModuleEnv {
     // This follows the pattern from TestEnv.init() in src/check/test/TestEnv.zig
 
@@ -149,7 +198,7 @@ fn compileModule(
         gpa.destroy(can_result);
     }
 
-    can_result.* = try Can.init(module_env, parse_ast, &module_envs);
+    can_result.* = try Can.init(module_env, parse_ast, &module_envs, can_options);
 
     try can_result.canonicalizeFile();
     try can_result.validateForChecking();

src/build/roc/Bool.roc

@@ -0,0 +1 @@
+Bool := [True, False].{}

src/build/roc/Result.roc

@@ -0,0 +1 @@
+Result(ok, err) := [Ok(ok), Err(err)].{}

src/canonicalize/Can.zig

@@ -133,7 +133,7 @@ const RecordField = CIR.RecordField;
 const SeenRecordField = struct { ident: base.Ident.Idx, region: base.Region };
 
 /// The idx of the builtin Bool
-pub const BUILTIN_BOOL: Statement.Idx = @enumFromInt(4);
+pub const BUILTIN_BOOL: Statement.Idx = @enumFromInt(2);
 /// The idx of the builtin Result
 pub const BUILTIN_RESULT: Statement.Idx = @enumFromInt(13);
 
@@ -171,10 +171,22 @@ pub fn deinit(
     self.scratch_free_vars.deinit(gpa);
 }
 
+/// Options for initializing the canonicalizer.
+/// Controls which built-in types are injected into the module's scope.
+pub const InitOptions = struct {
+    /// Whether to inject the Bool type declaration (`Bool := [True, False]`).
+    /// Set to false when compiling Bool.roc itself to avoid duplication.
+    inject_bool: bool = true,
+    /// Whether to inject the Result type declaration (`Result(ok, err) := [Ok(ok), Err(err)]`).
+    /// Set to false when compiling Result.roc itself (if it exists).
+    inject_result: bool = true,
+};
+
 pub fn init(
     env: *ModuleEnv,
     parse_ir: *AST,
     module_envs: ?*const std.StringHashMap(*const ModuleEnv),
+    options: InitOptions,
 ) std.mem.Allocator.Error!Self {
     const gpa = env.gpa;
 
@@ -207,16 +219,28 @@ pub fn init(
 
     const scratch_statements_start = result.env.store.scratch_statements.top();
 
-    // Simulate the builtins by add type declarations
+    // Inject built-in type declarations that aren't defined in this module's source
     // TODO: These should ultimately come from the platform/builtin files rather than being hardcoded
-    try result.addBuiltinTypeBool(env);
-    try result.addBuiltinTypeResult(env);
+    if (options.inject_bool) {
+        const bool_idx = try result.addBuiltinTypeBool(env);
+        try result.env.store.addScratchStatement(bool_idx);
+    }
+    if (options.inject_result) {
+        const result_idx = try result.addBuiltinTypeResult(env);
+        try result.env.store.addScratchStatement(result_idx);
+    }
 
-    // Add builtins to builtin stmts
-    try result.env.store.addScratchStatement(BUILTIN_BOOL);
-    try result.env.store.addScratchStatement(BUILTIN_RESULT);
     result.env.builtin_statements = try result.env.store.statementSpanFrom(scratch_statements_start);
 
+    // Debug assertion: When Bool is injected, it must be the first builtin statement
+    if (std.debug.runtime_safety and options.inject_bool) {
+        const builtin_stmts = result.env.store.sliceStatements(result.env.builtin_statements);
+        std.debug.assert(builtin_stmts.len >= 1); // Must have at least Bool
+        // Verify first builtin is Bool by checking it's a nominal_decl
+        const first_stmt = result.env.store.getStatement(builtin_stmts[0]);
+        std.debug.assert(first_stmt == .s_nominal_decl);
+    }
+
     // Assert that the node store is completely empty
     env.debugAssertArraysInSync();
 
@@ -226,7 +250,8 @@ pub fn init(
 // builtins //
 
 /// Creates `Bool := [True, False]`
-fn addBuiltinTypeBool(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void {
+/// Returns the statement index where Bool was created
+fn addBuiltinTypeBool(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!Statement.Idx {
     const gpa = ir.gpa;
     const type_ident = try ir.insertIdent(base.Ident.for_text("Bool"));
     const true_ident = try ir.insertIdent(base.Ident.for_text("True"));
@@ -268,8 +293,10 @@ fn addBuiltinTypeBool(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void
         .s_nominal_decl = .{ .header = header_idx, .anno = tag_union_anno_idx },
     }, .err, Region.zero());
 
-    // Assert that this is the first stmt in the file
-    std.debug.assert(type_decl_idx == BUILTIN_BOOL);
+    // Note: When Bool.roc is compiled without injecting builtins, Bool is at absolute index 2 (BUILTIN_BOOL).
+    // This is verified at build time by the builtin_compiler.
+    // When builtins are injected into other modules, Bool is always the FIRST builtin (builtin_statements[0]),
+    // though its absolute statement index may differ from BUILTIN_BOOL.
 
     // Introduce to scope
     const current_scope = &self.scopes.items[self.scopes.items.len - 1];
@@ -279,10 +306,13 @@ fn addBuiltinTypeBool(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void
     // TODO: in the future, we should have hardcoded constants for these.
     try self.unqualified_nominal_tags.put(gpa, "True", type_decl_idx);
     try self.unqualified_nominal_tags.put(gpa, "False", type_decl_idx);
+
+    return type_decl_idx;
 }
 
 /// Creates `Result(ok, err) := [Ok(ok), Err(err)]`
-fn addBuiltinTypeResult(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void {
+/// Returns the statement index where Result was created
+fn addBuiltinTypeResult(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!Statement.Idx {
     const gpa = ir.gpa;
     const type_ident = try ir.insertIdent(base.Ident.for_text("Result"));
     const ok_tag_ident = try ir.insertIdent(base.Ident.for_text("Ok"));
@@ -357,17 +387,19 @@ fn addBuiltinTypeResult(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!voi
         Region.zero(),
     );
 
-    // Assert that this is the first stmt in the file
-    std.debug.assert(type_decl_idx == BUILTIN_RESULT);
+    // Note: When Result.roc is compiled without injecting builtins, Result ends up at index 13 (BUILTIN_RESULT)
+    // This is verified during build time.
+    // When builtins are injected into other modules (Dict, Set), Result can be at any index.
 
     // Add to scope
     const current_scope = &self.scopes.items[self.scopes.items.len - 1];
     try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx);
 
-    // Add True and False to unqualified_nominal_tags
-    // TODO: in the future, we should have hardcoded constants for these.
+    // Add Ok and Err to unqualified_nominal_tags
     try self.unqualified_nominal_tags.put(gpa, "Ok", type_decl_idx);
     try self.unqualified_nominal_tags.put(gpa, "Err", type_decl_idx);
+
+    return type_decl_idx;
 }
 
 // canonicalize //

src/canonicalize/test/TestEnv.zig

@@ -50,7 +50,7 @@ pub fn init(source: []const u8) !TestEnv {
 
     try module_env.initCIRFields(gpa, "test");
 
-    can.* = try Can.init(module_env, parse_ast, null);
+    can.* = try Can.init(module_env, parse_ast, null, .{});
 
     return TestEnv{
         .gpa = gpa,