From fb9dc18a777148ca8a87d9dfd9fe39b28e8c4e7c Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Wed, 17 Sep 2025 10:50:07 -0400 Subject: [PATCH] Make it compile --- src/canonicalize/test/frac_test.zig | 147 ---------------------------- src/canonicalize/test/int_test.zig | 6 -- src/check/Check.zig | 2 +- src/cli/main.zig | 2 +- src/eval/test/eval_test.zig | 2 +- src/eval/test/helpers.zig | 2 +- src/layout/store_test.zig | 6 +- src/repl/repl_test.zig | 2 +- src/types/store.zig | 12 +-- 9 files changed, 10 insertions(+), 171 deletions(-) diff --git a/src/canonicalize/test/frac_test.zig b/src/canonicalize/test/frac_test.zig index bff445686d..f34af8d268 100644 --- a/src/canonicalize/test/frac_test.zig +++ b/src/canonicalize/test/frac_test.zig @@ -8,7 +8,6 @@ const std = @import("std"); const base = @import("base"); const parse = @import("parse"); const compile = @import("compile"); -const types = @import("types"); const builtins = @import("builtins"); const Can = @import("../Can.zig"); @@ -30,58 +29,9 @@ test "fractional literal - basic decimal" { .e_dec_small => |dec| { try testing.expectEqual(dec.numerator, 314); try testing.expectEqual(dec.denominator_power_of_ten, 2); - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => { - std.debug.print("Unexpected content type: {}\n", .{resolved.desc.content}); - return error.UnexpectedContentType; - }, - } }, .e_frac_dec => |dec| { _ = dec; - // Also accept e_frac_dec for decimal literals - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => { - std.debug.print("Unexpected content type: {}\n", .{resolved.desc.content}); - return error.UnexpectedContentType; - }, - } }, else => { std.debug.print("Unexpected expr type: {}\n", .{expr}); @@ -103,88 +53,12 @@ test "fractional literal - scientific notation small" { // Very small numbers may round to zero when parsed as small decimal // This is expected behavior when the value is too small for i16 representation try testing.expectEqual(dec.numerator, 0); - - // Still check type requirements - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .frac_poly => |poly| { - try testing.expect(poly.requirements.fits_in_f32); - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - try testing.expect(requirements.fits_in_f32); - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } }, .e_frac_dec => |frac| { - // Scientific notation can also be parsed as RocDec for exact representation - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(poly.requirements.fits_in_f32); - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(requirements.fits_in_f32); - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } // RocDec stores the value in a special format _ = frac; }, .e_frac_f64 => |frac| { - // Or it might be parsed as f64 - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(poly.requirements.fits_in_f32); - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(requirements.fits_in_f32); - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } try testing.expectApproxEqAbs(frac.value, 1.23e-10, 1e-20); }, else => { @@ -204,27 +78,6 @@ test "fractional literal - scientific notation large (near f64 max)" { switch (expr) { .e_frac_f64 => |frac| { - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - try testing.expect(!poly.requirements.fits_in_dec); // Way out of Dec range - }, - .frac_unbound => |requirements| { - try testing.expect(!requirements.fits_in_dec); // Way out of Dec range - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } try testing.expectEqual(frac.value, 1e308); }, else => { diff --git a/src/canonicalize/test/int_test.zig b/src/canonicalize/test/int_test.zig index e8c4080b19..cbb58e4bae 100644 --- a/src/canonicalize/test/int_test.zig +++ b/src/canonicalize/test/int_test.zig @@ -28,12 +28,6 @@ fn getIntValue(module_env: *ModuleEnv, expr_idx: CIR.Expr.Idx) !i128 { } } -fn calculateRequirements(value: i128) types.Num.Int.Requirements { - const bits_needed = types.Num.Int.BitsNeeded.fromValue(@bitCast(value)); - - return .{ .sign_needed = value < 0, .bits_needed = bits_needed }; -} - test "canonicalize simple positive integer" { const source = "42"; var test_env = try TestEnv.init(source); diff --git a/src/check/Check.zig b/src/check/Check.zig index 660f1cf956..036a49b7bb 100644 --- a/src/check/Check.zig +++ b/src/check/Check.zig @@ -1623,7 +1623,7 @@ fn checkExpr(self: *Self, expr_idx: CIR.Expr.Idx, rank: types_mod.Rank, expected try self.updateVar(expr_var, .{ .structure = .{ .num = .{ .num_compact = .{ .int = suffix } } } }, rank); } else { const int_var = try self.freshFromContent(.{ .structure = .{ .num = .{ - .int_unbound = Num.IntRequirements.init(), + .int_unbound = num.requirements, } } }, rank, expr_region); try self.var_pool.addVarToRank(int_var, rank); diff --git a/src/cli/main.zig b/src/cli/main.zig index 7cd6a39d05..4162fc8349 100644 --- a/src/cli/main.zig +++ b/src/cli/main.zig @@ -1397,7 +1397,7 @@ pub fn setupSharedMemoryWithModuleEnv(gpa: std.mem.Allocator, roc_file_path: []c // Type check the module var checker = try Check.init(shm_allocator, &env.types, &env, &.{}, &env.store.regions, common_idents); - try checker.checkDefs(); + try checker.checkFile(); // Copy the ModuleEnv to the allocated space env_ptr.* = env; diff --git a/src/eval/test/eval_test.zig b/src/eval/test/eval_test.zig index 72217aaeb0..6ee6a5fb0b 100644 --- a/src/eval/test/eval_test.zig +++ b/src/eval/test/eval_test.zig @@ -718,7 +718,7 @@ test "ModuleEnv serialization and interpreter evaluation" { var checker = try Check.init(gpa, &original_env.types, &original_env, &.{}, &original_env.store.regions, common_idents); defer checker.deinit(); - _ = try checker.checkExpr(canonicalized_expr_idx.get_idx()); + _ = try checker.checkExprRepl(canonicalized_expr_idx.get_idx()); // Test 1: Evaluate with the original ModuleEnv { diff --git a/src/eval/test/helpers.zig b/src/eval/test/helpers.zig index 98cf9566af..7c484abb41 100644 --- a/src/eval/test/helpers.zig +++ b/src/eval/test/helpers.zig @@ -328,7 +328,7 @@ pub fn parseAndCanonicalizeExpr(allocator: std.mem.Allocator, source: []const u8 checker.* = try Check.init(allocator, &module_env.types, module_env, &.{}, &module_env.store.regions, common_idents); // Type check the expression - _ = try checker.checkExpr(canonical_expr_idx.get_idx()); + _ = try checker.checkExprRepl(canonical_expr_idx.get_idx()); // WORKAROUND: The type checker doesn't set types for binop expressions yet. // For numeric binops, manually set the type to match the operands. diff --git a/src/layout/store_test.zig b/src/layout/store_test.zig index 8131af8358..4c2132bf1e 100644 --- a/src/layout/store_test.zig +++ b/src/layout/store_test.zig @@ -85,7 +85,7 @@ test "addTypeVar - default layouts for polymorphic types" { // Flex number var (Num a) defaults to i128 const num_var = try lt.type_store.fresh(); - const flex_num_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_var, .requirements = .{ .sign_needed = false, .bits_needed = 0 } } } } }); + const flex_num_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .num_poly = num_var } } }); const num_layout_idx = try lt.layout_store.addTypeVar(flex_num_var, <.type_scope); const num_layout = lt.layout_store.getLayout(num_layout_idx); try testing.expect(num_layout.tag == .scalar); @@ -93,7 +93,7 @@ test "addTypeVar - default layouts for polymorphic types" { // Flex int var (Int a) defaults to i128 const int_var = try lt.type_store.fresh(); - const flex_int_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .int_poly = .{ .var_ = int_var, .requirements = .{ .sign_needed = false, .bits_needed = 0 } } } } }); + const flex_int_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .int_poly = int_var } } }); const int_layout_idx = try lt.layout_store.addTypeVar(flex_int_var, <.type_scope); const int_layout = lt.layout_store.getLayout(int_layout_idx); try testing.expect(int_layout.tag == .scalar); @@ -101,7 +101,7 @@ test "addTypeVar - default layouts for polymorphic types" { // Flex frac var (Frac a) defaults to dec const frac_var = try lt.type_store.fresh(); - const flex_frac_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .frac_poly = .{ .var_ = frac_var, .requirements = .{ .fits_in_f32 = false, .fits_in_dec = true } } } } }); + const flex_frac_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .frac_poly = frac_var } } }); const frac_layout_idx = try lt.layout_store.addTypeVar(flex_frac_var, <.type_scope); const frac_layout = lt.layout_store.getLayout(frac_layout_idx); try testing.expect(frac_layout.tag == .scalar); diff --git a/src/repl/repl_test.zig b/src/repl/repl_test.zig index 89314c235f..2049531159 100644 --- a/src/repl/repl_test.zig +++ b/src/repl/repl_test.zig @@ -216,7 +216,7 @@ test "Repl - minimal interpreter integration" { var checker = try Check.init(gpa, &module_env.types, cir, &.{}, &cir.store.regions, common_idents); defer checker.deinit(); - _ = try checker.checkExpr(canonical_expr_idx.get_idx()); + _ = try checker.checkExprRepl(canonical_expr_idx.get_idx()); // Step 6: Create interpreter var interpreter = try Interpreter.init(gpa, &module_env); diff --git a/src/types/store.zig b/src/types/store.zig index 88ea413757..0d5d73c935 100644 --- a/src/types/store.zig +++ b/src/types/store.zig @@ -1111,11 +1111,7 @@ test "resolveVarAndCompressPath - no-op on already root" { defer store.deinit(); const num_flex = try store.fresh(); - const requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, - }; - const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_flex, .requirements = requirements } } } }; + const num = Content{ .structure = .{ .num = .{ .num_poly = num_flex } } }; const num_var = try store.freshFromContent(num); const result = store.resolveVarAndCompressPath(num_var); @@ -1132,11 +1128,7 @@ test "resolveVarAndCompressPath - flattens redirect chain to structure" { defer store.deinit(); const num_flex = try store.fresh(); - const requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, - }; - const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_flex, .requirements = requirements } } } }; + const num = Content{ .structure = .{ .num = .{ .num_poly = num_flex } } }; const c = try store.freshFromContent(num); const b = try store.freshRedirect(c); const a = try store.freshRedirect(b);