Get rid of is_ne again

Author: rtfeldman

docs/DEBUG_STORE_TRACKING.md

@@ -1,6 +1,6 @@
 # Minimal test file - original benchmark temporarily disabled
 # See bench_repeated_check_ORIGINAL.roc for the full version
-# TODO: Re-enable once `is_ne` is supported for all numeric types
+# TODO: Re-enable once `!=` (which desugars to is_eq().not()) is fully working
 
 app [main] { pf: platform "../../test/str/platform/main.roc" }
 

src/PROFILING/bench_repeated_check.roc

@@ -10580,7 +10580,7 @@ fn exposeAssociatedItems(self: *Self, parent_name: Ident.Idx, type_decl: std.met
                 .type_anno => |type_anno| {
                     // Get the annotation name (for annotation-only definitions like compiler intrinsics)
                     if (self.parse_ir.tokens.resolveIdentifier(type_anno.name)) |anno_ident| {
-                        // Build qualified name (e.g., "Bool.is_ne")
+                        // Build qualified name (e.g., "Bool.not")
                         const parent_text = self.env.getIdent(parent_name);
                         const anno_text = self.env.getIdent(anno_ident);
                         const qualified_idx = try self.env.insertQualifiedIdent(parent_text, anno_text);

src/canonicalize/Can.zig

@@ -112,7 +112,6 @@ pub const CommonIdents = extern struct {
     is_gt: Ident.Idx,
     is_gte: Ident.Idx,
     is_eq: Ident.Idx,
-    is_ne: Ident.Idx,
 
     // Type/module names
     @"try": Ident.Idx,
@@ -175,7 +174,6 @@ pub const CommonIdents = extern struct {
             .is_gt = try common.insertIdent(gpa, Ident.for_text("is_gt")),
             .is_gte = try common.insertIdent(gpa, Ident.for_text("is_gte")),
             .is_eq = try common.insertIdent(gpa, Ident.for_text("is_eq")),
-            .is_ne = try common.insertIdent(gpa, Ident.for_text("is_ne")),
             .@"try" = try common.insertIdent(gpa, Ident.for_text("Try")),
             .out_of_range = try common.insertIdent(gpa, Ident.for_text("OutOfRange")),
             .builtin_module = try common.insertIdent(gpa, Ident.for_text("Builtin")),
@@ -235,7 +233,6 @@ pub const CommonIdents = extern struct {
             .is_gt = common.findIdent("is_gt") orelse unreachable,
             .is_gte = common.findIdent("is_gte") orelse unreachable,
             .is_eq = common.findIdent("is_eq") orelse unreachable,
-            .is_ne = common.findIdent("is_ne") orelse unreachable,
             .@"try" = common.findIdent("Try") orelse unreachable,
             .out_of_range = common.findIdent("OutOfRange") orelse unreachable,
             .builtin_module = common.findIdent("Builtin") orelse unreachable,

src/canonicalize/ModuleEnv.zig

@@ -113,14 +113,14 @@ 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 19 well-known identifiers: from_int_digits, 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 18 well-known identifiers: from_int_digits, 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
     // Plus 18 type identifiers: Builtin.Try, Builtin.Num.Numeral, Builtin.Str, List, Box, Builtin.Num.{U8, I8, U16, I16, U32, I32, U64, I64, U128, I128, F32, F64, Dec}
     // Plus 3 field/tag identifiers: before_dot, after_dot, ProvidedByCompiler
     // Plus 7 more identifiers: tag, payload, is_negative, digits_before_pt, digits_after_pt, box, unbox
     // Plus 2 Try tag identifiers: Ok, Err
     // Plus 1 method identifier: from_numeral
     // Plus 2 Bool tag identifiers: True, False
-    try testing.expectEqual(@as(u32, 54), original.common.idents.interner.entry_count);
+    try testing.expectEqual(@as(u32, 53), original.common.idents.interner.entry_count);
     try testing.expectEqualStrings("hello", original.getIdent(hello_idx));
     try testing.expectEqualStrings("world", original.getIdent(world_idx));
 
@@ -129,9 +129,9 @@ 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 54 identifiers as original: hello, world, TestModule + 19 well-known identifiers + 17 type identifiers + 3 field/tag identifiers + 7 more identifiers + 2 Try tag identifiers + 1 method identifier + 2 Bool tag identifiers from ModuleEnv.init()
+    // Should have same 53 identifiers as original: hello, world, TestModule + 18 well-known identifiers + 17 type identifiers + 3 field/tag identifiers + 7 more identifiers + 2 Try tag identifiers + 1 method identifier + 2 Bool tag identifiers from ModuleEnv.init()
     // (Note: "Try" is now shared with well-known identifiers, reducing total by 1)
-    try testing.expectEqual(@as(u32, 54), env.common.idents.interner.entry_count);
+    try testing.expectEqual(@as(u32, 53), 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/compile/test/module_env_test.zig

@@ -6038,7 +6038,7 @@ pub const Interpreter = struct {
                         .ident = nom.ident.ident_idx,
                     },
                     .record, .tuple, .tag_union, .empty_record, .empty_tag_union => blk: {
-                        // Anonymous structural types have implicit is_eq and is_ne
+                        // Anonymous structural types have implicit is_eq
                         // Use root_env.idents for consistency with method dispatch
                         if (method_ident == self.root_env.idents.is_eq) {
                             const result = self.valuesStructurallyEqual(lhs, lhs_rt_var, rhs, rhs_rt_var) catch |err| {
@@ -6051,17 +6051,6 @@ pub const Interpreter = struct {
                             };
                             return try self.makeBoolValue(result);
                         }
-                        if (method_ident == self.root_env.idents.is_ne) {
-                            const result = self.valuesStructurallyEqual(lhs, lhs_rt_var, rhs, rhs_rt_var) catch |err| {
-                                // If structural equality is not implemented for this type, return false
-                                if (err == error.NotImplemented) {
-                                    self.triggerCrash("DEBUG: dispatchBinaryOpMethod NotImplemented", false, roc_ops);
-                                    return error.Crash;
-                                }
-                                return err;
-                            };
-                            return try self.makeBoolValue(!result);
-                        }
                         break :blk null;
                     },
                     else => null,