Fix remaining issues

Author: rtfeldman

src/build/builtin_compiler/main.zig

@@ -901,11 +901,7 @@ fn serializeModuleEnv(
 /// For builtin_compiler, types are always in all_statements (not builtin_statements)
 /// because we're compiling Builtin.roc itself, not importing from it.
 fn findTypeDeclaration(env: *const ModuleEnv, type_name: []const u8) !CIR.Statement.Idx {
-    // Construct the qualified name (e.g., "Builtin.Bool")
-    // Types in nested declarations are stored with their full qualified names
-    var qualified_name_buf: [256]u8 = undefined;
-    const qualified_name = try std.fmt.bufPrint(&qualified_name_buf, "{s}.{s}", .{ env.module_name, type_name });
-
+    // Type headers now store the unqualified name (e.g., "Bool" not "Builtin.Bool")
     // Search in all_statements (where Builtin.roc's own types are stored)
     const all_stmts = env.store.sliceStatements(env.all_statements);
     for (all_stmts) |stmt_idx| {
@@ -915,7 +911,7 @@ fn findTypeDeclaration(env: *const ModuleEnv, type_name: []const u8) !CIR.Statem
                 const header = env.store.getTypeHeader(decl.header);
                 const ident_idx = header.name;
                 const ident_text = env.getIdentText(ident_idx);
-                if (std.mem.eql(u8, ident_text, qualified_name)) {
+                if (std.mem.eql(u8, ident_text, type_name)) {
                     return stmt_idx;
                 }
             },
@@ -927,13 +923,13 @@ fn findTypeDeclaration(env: *const ModuleEnv, type_name: []const u8) !CIR.Statem
 }
 
 /// Find a nested type declaration by parent and type name in a compiled module
-/// For example, findNestedTypeDeclaration(env, "Num", "U8") finds "Builtin.Num.U8"
+/// For example, findNestedTypeDeclaration(env, "Num", "U8") finds type with header.name = "U8"
+/// The parent_name parameter is ignored since type headers store the unqualified name
 /// Returns the statement index of the type declaration
 fn findNestedTypeDeclaration(env: *const ModuleEnv, parent_name: []const u8, type_name: []const u8) !CIR.Statement.Idx {
-    // Construct the qualified name (e.g., "Builtin.Num.U8")
-    var qualified_name_buf: [256]u8 = undefined;
-    const qualified_name = try std.fmt.bufPrint(&qualified_name_buf, "{s}.{s}.{s}", .{ env.module_name, parent_name, type_name });
+    _ = parent_name; // Type headers store unqualified names
 
+    // Type headers now store the unqualified name (e.g., "U8" not "Builtin.Num.U8")
     // Search in all_statements (where Builtin.roc's own types are stored)
     const all_stmts = env.store.sliceStatements(env.all_statements);
     for (all_stmts) |stmt_idx| {
@@ -943,7 +939,7 @@ fn findNestedTypeDeclaration(env: *const ModuleEnv, parent_name: []const u8, typ
                 const header = env.store.getTypeHeader(decl.header);
                 const ident_idx = header.name;
                 const ident_text = env.getIdentText(ident_idx);
-                if (std.mem.eql(u8, ident_text, qualified_name)) {
+                if (std.mem.eql(u8, ident_text, type_name)) {
                     return stmt_idx;
                 }
             },

src/canonicalize/Can.zig

@@ -412,14 +412,12 @@ fn processTypeDeclFirstPass(
         break :blk try self.env.insertQualifiedIdent(parent_text, type_text);
     } else type_header.name;
 
-    // Create a new header with the qualified name if needed
-    const final_header_idx = if (parent_name != null and qualified_name_idx.idx != type_header.name.idx) blk: {
-        const qualified_header = CIR.TypeHeader{
-            .name = qualified_name_idx,
-            .args = type_header.args,
-        };
-        break :blk try self.env.addTypeHeader(qualified_header, region);
-    } else header_idx;
+    // Keep the original header with its unqualified name.
+    // The qualified_name_idx is only used for scope registration, not stored in the type header.
+    // This ensures that NominalType.ident contains just the type name (e.g., "Bool"),
+    // while NominalType.origin_module contains the module name (e.g., "Builtin").
+    // Method lookup then constructs the full path: origin_module + "." + ident + "." + method
+    const final_header_idx = header_idx;
 
     // Check if this type was already introduced in Phase 1.5.8 (for forward reference support)
     // If so, reuse the existing statement index instead of creating a new one

src/check/Check.zig

@@ -672,10 +672,8 @@ fn mkNumberTypeContent(self: *Self, type_name: []const u8, env: *Env) Allocator.
     else
         self.common_idents.module_name; // We're compiling Builtin module itself
 
-    // Number types are nested in Num module, so the qualified name is "Num.U8", "Num.I32", etc.
-    const qualified_type_name = try std.fmt.allocPrint(self.gpa, "Num.{s}", .{type_name});
-    defer self.gpa.free(qualified_type_name);
-    const type_name_ident = try @constCast(self.cir).insertIdent(base.Ident.for_text(qualified_type_name));
+    // Type headers now store the unqualified name (e.g., "U8" not "Num.U8")
+    const type_name_ident = try @constCast(self.cir).insertIdent(base.Ident.for_text(type_name));
     const type_ident = types_mod.TypeIdent{
         .ident_idx = type_name_ident,
     };

src/check/test/type_checking_integration.zig

@@ -2093,7 +2093,7 @@ test "associated item can reference another associated item from same type" {
         \\
         \\x = Test.MyBool.my_eq(Test.MyBool.MyTrue, Test.MyBool.MyFalse)
     ;
-    try checkTypesModule(source, .{ .pass = .{ .def = "x" } }, "Test.MyBool");
+    try checkTypesModule(source, .{ .pass = .{ .def = "x" } }, "MyBool");
 }
 
 test "Bool.not works as builtin associated item" {

src/eval/interpreter.zig

@@ -5663,14 +5663,6 @@ pub const Interpreter = struct {
         const method_name_str = current_ident_store.getText(method_name);
         // Construct: "OriginModule.TypeName.methodName"
         // Note: TypeName may already contain dots for nested types
-        // If type_name already starts with origin_module_text (e.g., "Builtin.Bool" with origin "Builtin"),
-        // then just use "TypeName.methodName" to avoid duplication like "Builtin.Builtin.Bool.method"
-        if (std.mem.startsWith(u8, type_name, origin_module_text) and
-            type_name.len > origin_module_text.len and
-            type_name[origin_module_text.len] == '.')
-        {
-            return std.fmt.bufPrint(buf, "{s}.{s}", .{ type_name, method_name_str });
-        }
         return std.fmt.bufPrint(buf, "{s}.{s}.{s}", .{ origin_module_text, type_name, method_name_str });
     }