Remove from_dec_literal too

Author: rtfeldman

src/base/Ident.zig

@@ -16,8 +16,6 @@ const CompactWriter = collections.CompactWriter;
 
 const Ident = @This();
 
-/// Method name for parsing decimals from digit lists - used by numeric literal type checking
-pub const FROM_DEC_DIGITS_METHOD_NAME = "from_dec_digits";
 /// Method name for addition - used by + operator desugaring
 pub const PLUS_METHOD_NAME = "plus";
 /// Method name for negation - used by unary - operator desugaring

src/build/builtin_compiler/main.zig

@@ -196,18 +196,6 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
         }
     }
 
-    // from_dec_digits (Dec, F32, F64 only)
-    const dec_types = [_][]const u8{ "Dec", "F32", "F64" };
-    for (dec_types) |num_type| {
-        var buf: [256]u8 = undefined;
-
-        // from_dec_digits
-        const from_dec_digits = try std.fmt.bufPrint(&buf, "Builtin.Num.{s}.from_dec_digits", .{num_type});
-        if (env.common.findIdent(from_dec_digits)) |ident| {
-            try low_level_map.put(ident, .num_from_dec_digits);
-        }
-    }
-
     // from_numeral (all numeric types)
     for (numeric_types) |num_type| {
         var buf: [256]u8 = undefined;

src/build/roc/Builtin.roc

@@ -352,7 +352,6 @@ Builtin :: [].{
 			div_trunc_by : Dec, Dec -> Dec
 			rem_by : Dec, Dec -> Dec
 
-			from_dec_digits : (List(U8), List(U8)) -> Try(Dec, [OutOfRange])
 			from_numeral : Numeral -> Try(Dec, [InvalidNumeral(Str)])
 		}
 
@@ -373,7 +372,6 @@ Builtin :: [].{
 			div_trunc_by : F32, F32 -> F32
 			rem_by : F32, F32 -> F32
 
-			from_dec_digits : (List(U8), List(U8)) -> Try(F32, [OutOfRange])
 			from_numeral : Numeral -> Try(F32, [InvalidNumeral(Str)])
 		}
 
@@ -394,7 +392,6 @@ Builtin :: [].{
 			div_trunc_by : F64, F64 -> F64
 			rem_by : F64, F64 -> F64
 
-			from_dec_digits : (List(U8), List(U8)) -> Try(F64, [OutOfRange])
 			from_numeral : Numeral -> Try(F64, [InvalidNumeral(Str)])
 		}
 	}

src/canonicalize/Expression.zig

@@ -438,7 +438,6 @@ pub const Expr = union(enum) {
         num_rem_by, // All numeric types
 
         // Numeric parsing operations
-        num_from_dec_digits, // Parse (List(U8), List(U8)) -> Try(num, [OutOfRange])
         num_from_numeral, // Parse Numeral -> Try(num, [InvalidNumeral(Str)])
     };
 

src/canonicalize/ModuleEnv.zig

@@ -132,8 +132,9 @@ evaluation_order: ?*DependencyGraph.EvaluationOrder,
 // Cached well-known identifiers for type checking
 // (These are interned once during init to avoid repeated string comparisons during type checking)
 
-/// Interned identifier for "from_dec_digits" - used for decimal literal type checking
-from_dec_digits_ident: Ident.Idx,
+/// Padding for removed from_dec_digits_ident field (maintains struct layout for serialization)
+_padding_removed_from_dec_digits: u32 = 0,
+
 /// Interned identifier for "Try" - used for numeric literal type checking
 try_ident: Ident.Idx,
 /// Interned identifier for "OutOfRange" - used for numeric literal type checking
@@ -231,7 +232,6 @@ pub fn init(gpa: std.mem.Allocator, source: []const u8) std.mem.Allocator.Error!
     var common = try CommonEnv.init(gpa, source);
 
     // Intern well-known identifiers once during initialization for fast type checking
-    const from_dec_digits_ident = try common.insertIdent(gpa, Ident.for_text(Ident.FROM_DEC_DIGITS_METHOD_NAME));
     const try_ident = try common.insertIdent(gpa, Ident.for_text("Try"));
     const out_of_range_ident = try common.insertIdent(gpa, Ident.for_text("OutOfRange"));
     const builtin_module_ident = try common.insertIdent(gpa, Ident.for_text("Builtin"));
@@ -281,7 +281,6 @@ pub fn init(gpa: std.mem.Allocator, source: []const u8) std.mem.Allocator.Error!
         .diagnostics = CIR.Diagnostic.Span{ .span = base.DataSpan{ .start = 0, .len = 0 } },
         .store = try NodeStore.initCapacity(gpa, 10_000), // Default node store capacity
         .evaluation_order = null, // Will be set after canonicalization completes
-        .from_dec_digits_ident = from_dec_digits_ident,
         .try_ident = try_ident,
         .out_of_range_ident = out_of_range_ident,
         .builtin_module_ident = builtin_module_ident,
@@ -1718,7 +1717,7 @@ pub const Serialized = extern struct {
     store: NodeStore.Serialized,
     module_kind: ModuleKind.Serialized,
     evaluation_order_reserved: u64, // Reserved space for evaluation_order field (required for in-place deserialization cast)
-    from_dec_digits_ident_reserved: u32, // Reserved space for from_dec_digits_ident field (interned during deserialization)
+    _padding_removed_from_dec_digits: u32 = 0, // Padding for removed from_dec_digits_ident field (maintains struct layout)
     try_ident_reserved: u32, // Reserved space for try_ident field (interned during deserialization)
     out_of_range_ident_reserved: u32, // Reserved space for out_of_range_ident field (interned during deserialization)
     builtin_module_ident_reserved: u32, // Reserved space for builtin_module_ident field (interned during deserialization)
@@ -1772,7 +1771,6 @@ pub const Serialized = extern struct {
         self.module_name = .{ 0, 0 };
         self.module_name_idx_reserved = 0;
         self.evaluation_order_reserved = 0;
-        self.from_dec_digits_ident_reserved = 0;
         self.try_ident_reserved = 0;
         self.out_of_range_ident_reserved = 0;
         self.builtin_module_ident_reserved = 0;
@@ -1828,7 +1826,6 @@ pub const Serialized = extern struct {
             .store = self.store.deserialize(offset, gpa).*,
             .evaluation_order = null, // Not serialized, will be recomputed if needed
             // Well-known identifiers for type checking - look them up in the deserialized common env
-            .from_dec_digits_ident = common.findIdent(Ident.FROM_DEC_DIGITS_METHOD_NAME) orelse unreachable,
             .try_ident = common.findIdent("Try") orelse unreachable,
             .out_of_range_ident = common.findIdent("OutOfRange") orelse unreachable,
             .builtin_module_ident = common.findIdent("Builtin") orelse unreachable,

src/check/test/TestEnv.zig

@@ -85,7 +85,6 @@ fn loadCompiledModule(gpa: std.mem.Allocator, bin_data: []const u8, module_name:
         .diagnostics = serialized_ptr.diagnostics,
         .store = serialized_ptr.store.deserialize(@as(i64, @intCast(base_ptr)), gpa).*,
         .evaluation_order = null,
-        .from_dec_digits_ident = common.findIdent(base.Ident.FROM_DEC_DIGITS_METHOD_NAME) orelse unreachable,
         .try_ident = common.findIdent("Try") orelse unreachable,
         .out_of_range_ident = common.findIdent("OutOfRange") orelse unreachable,
         .builtin_module_ident = common.findIdent("Builtin") orelse unreachable,

src/check/unify.zig

@@ -1116,85 +1116,6 @@ const Unifier = struct {
         self.merge(vars, vars.b.desc.content);
     }
 
-    /// Check if a nominal type has a from_dec_digits method by unifying its signature
-    /// with the expected type: (List(U8), List(U8)) -> Try(Self, [OutOfRange])
-    /// Returns true if unification succeeds, false otherwise.
-    fn nominalTypeHasFromDecDigits(
-        self: *Self,
-        nominal_type: NominalType,
-    ) Error!bool {
-        const method_var = try self.getNominalMethodVar(nominal_type, self.module_env.from_dec_digits_ident) orelse return false;
-        const resolved = self.types_store.resolveVar(method_var);
-
-        const func = switch (resolved.desc.content) {
-            .structure => |structure| switch (structure) {
-                .fn_pure => structure.fn_pure,
-                .fn_effectful => structure.fn_effectful,
-                .fn_unbound => structure.fn_unbound,
-                else => return false,
-            },
-            else => return false,
-        };
-
-        const ret_desc = self.types_store.resolveVar(func.ret);
-        const ret_nominal = switch (ret_desc.desc.content) {
-            .structure => |structure| switch (structure) {
-                .nominal_type => structure.nominal_type,
-                else => return false,
-            },
-            else => return false,
-        };
-        if (!self.isBuiltinTryNominal(ret_nominal)) return false;
-        const ret_args = self.types_store.sliceVars(ret_nominal.vars.nonempty);
-        if (ret_args.len < 3) return false;
-
-        const args_slice = self.types_store.sliceVars(func.args);
-        if (args_slice.len != 1) return false;
-
-        const before_ident = self.module_env.common.findIdent("before_dot") orelse return false;
-        const after_ident = self.module_env.common.findIdent("after_dot") orelse return false;
-
-        const record_desc = self.types_store.resolveVar(args_slice[0]);
-        const record = switch (record_desc.desc.content) {
-            .structure => |structure| switch (structure) {
-                .record => structure.record,
-                else => return false,
-            },
-            else => return false,
-        };
-
-        if (record.fields.len() != 2) return false;
-        const fields_slice = self.types_store.getRecordFieldsSlice(record.fields);
-        const names = fields_slice.items(.name);
-        const vars = fields_slice.items(.var_);
-
-        var before_idx: ?usize = null;
-        var after_idx: ?usize = null;
-        for (names, 0..) |name, idx| {
-            if (name == before_ident) {
-                before_idx = idx;
-            } else if (name == after_ident) {
-                after_idx = idx;
-            }
-        }
-
-        if (before_idx == null or after_idx == null) return false;
-
-        const list_u8_first = try self.createListU8Var();
-        const list_u8_second = try self.createListU8Var();
-
-        self.unifyGuarded(vars[before_idx.?], list_u8_first) catch return false;
-        self.unifyGuarded(vars[after_idx.?], list_u8_second) catch return false;
-
-        const self_ret_var = try self.createNominalInstanceVar(nominal_type);
-        self.unifyGuarded(ret_args[1], self_ret_var) catch return false;
-
-        const try_error_var = try self.createOutOfRangeTagUnion();
-        self.unifyGuarded(ret_args[2], try_error_var) catch return false;
-
-        return true;
-    }
-
     fn getNominalMethodVar(
         self: *Self,
         nominal_type: NominalType,

src/compile/test/module_env_test.zig

@@ -102,7 +102,6 @@ test "ModuleEnv.Serialized roundtrip" {
         .diagnostics = deserialized_ptr.diagnostics,
         .store = deserialized_ptr.store.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), deser_alloc).*,
         .evaluation_order = null,
-        .from_dec_digits_ident = common.findIdent(Ident.FROM_DEC_DIGITS_METHOD_NAME) orelse unreachable,
         .try_ident = common.findIdent("Try") orelse unreachable,
         .out_of_range_ident = common.findIdent("OutOfRange") orelse unreachable,
         .builtin_module_ident = common.findIdent("Builtin") orelse unreachable,
@@ -128,9 +127,9 @@ test "ModuleEnv.Serialized roundtrip" {
 
     // Verify original data before serialization was correct
     // initCIRFields inserts the module name ("TestModule") into the interner, so we have 3 total: hello, world, TestModule
-    // ModuleEnv.init() also interns 18 well-known identifiers: from_dec_digits, Try, OutOfRange, Builtin, plus, minus, times, div_by, div_trunc_by, rem_by, negate, not, is_lt, is_lte, is_gt, is_gte, is_eq, is_ne
+    // ModuleEnv.init() also interns 17 well-known identifiers: Try, OutOfRange, Builtin, plus, minus, times, div_by, div_trunc_by, rem_by, negate, not, is_lt, is_lte, is_gt, is_gte, is_eq, is_ne
     // Plus 13 numeric type identifiers: Num.U8, Num.I8, Num.U16, Num.I16, Num.U32, Num.I32, Num.U64, Num.I64, Num.U128, Num.I128, Num.F32, Num.F64, Num.Dec
-    try testing.expectEqual(@as(u32, 34), original.common.idents.interner.entry_count);
+    try testing.expectEqual(@as(u32, 33), original.common.idents.interner.entry_count);
     try testing.expectEqualStrings("hello", original.getIdent(hello_idx));
     try testing.expectEqualStrings("world", original.getIdent(world_idx));
 
@@ -139,8 +138,8 @@ test "ModuleEnv.Serialized roundtrip" {
     try testing.expectEqual(@as(usize, 2), original.imports.imports.len()); // Should have 2 unique imports
 
     // First verify that the CommonEnv data was preserved after deserialization
-    // Should have same 34 identifiers as original: hello, world, TestModule + 18 well-known identifiers + 13 numeric type identifiers from ModuleEnv.init()
-    try testing.expectEqual(@as(u32, 34), env.common.idents.interner.entry_count);
+    // Should have same 33 identifiers as original: hello, world, TestModule + 17 well-known identifiers + 13 numeric type identifiers from ModuleEnv.init()
+    try testing.expectEqual(@as(u32, 33), env.common.idents.interner.entry_count);
 
     try testing.expectEqual(@as(usize, 1), env.common.exposed_items.count());
     try testing.expectEqual(@as(?u16, 42), env.common.exposed_items.getNodeIndexById(gpa, @as(u32, @bitCast(hello_idx))));

src/eval/builtin_loading.zig

@@ -79,7 +79,6 @@ pub fn loadCompiledModule(gpa: std.mem.Allocator, bin_data: []const u8, module_n
         .evaluation_order = null,
         // Well-known identifiers for type checking - look them up in the deserialized common env
         // These must exist in the Builtin module which defines them
-        .from_dec_digits_ident = common.findIdent(Ident.FROM_DEC_DIGITS_METHOD_NAME) orelse unreachable,
         .try_ident = common.findIdent("Try") orelse unreachable,
         .out_of_range_ident = common.findIdent("OutOfRange") orelse unreachable,
         .builtin_module_ident = common.findIdent("Builtin") orelse unreachable,

src/eval/interpreter.zig

@@ -3191,11 +3191,6 @@ pub const Interpreter = struct {
                 out.is_initialized = true;
                 return out;
             },
-            .num_from_dec_digits => {
-                // num.from_dec_digits : (List(U8), List(U8)) -> Try(num, [OutOfRange])
-                self.triggerCrash("num_from_dec_digits not yet implemented", false, roc_ops);
-                return error.Crash;
-            },
             .num_from_numeral => {
                 // num.from_numeral : Numeral -> Try(num, [InvalidNumeral(Str)])
                 // Numeral is { is_negative: Bool, digits_before_pt: List(U8), digits_after_pt: List(U8) }