Merge remote-tracking branch 'origin/main' into builtin-str2

Author: rtfeldman

src/canonicalize/Can.zig

@@ -118,6 +118,11 @@ pub const Diagnostic = union(enum) {
         type_name: Ident.Idx,
         region: Region,
     },
+    type_from_missing_module: struct {
+        module_name: Ident.Idx,
+        type_name: Ident.Idx,
+        region: Region,
+    },
     module_not_imported: struct {
         module_name: Ident.Idx,
         region: Region,
@@ -269,6 +274,7 @@ pub const Diagnostic = union(enum) {
             .module_not_found => |d| d.region,
             .value_not_exposed => |d| d.region,
             .type_not_exposed => |d| d.region,
+            .type_from_missing_module => |d| d.region,
             .module_not_imported => |d| d.region,
             .too_many_exports => |d| d.region,
             .undeclared_type => |d| d.region,
@@ -889,9 +895,19 @@ pub const Diagnostic = union(enum) {
     ) !Report {
         var report = Report.init(allocator, "UNDECLARED TYPE", .runtime_error);
         const owned_type_name = try report.addOwnedString(type_name);
-        try report.document.addReflowingText("The type ");
-        try report.document.addType(owned_type_name);
-        try report.document.addReflowingText(" is not declared in this scope.");
+
+        // Check if this looks like a qualified type (contains dots)
+        const has_dots = std.mem.indexOfScalar(u8, type_name, '.') != null;
+
+        if (has_dots) {
+            try report.document.addReflowingText("Cannot resolve qualified type ");
+            try report.document.addType(owned_type_name);
+            try report.document.addReflowingText(".");
+        } else {
+            try report.document.addReflowingText("The type ");
+            try report.document.addType(owned_type_name);
+            try report.document.addReflowingText(" is not declared in this scope.");
+        }
         try report.document.addLineBreak();
         try report.document.addLineBreak();
 
@@ -1411,13 +1427,32 @@ pub const Diagnostic = union(enum) {
 
         const owned_module = try report.addOwnedString(module_name);
         const owned_type = try report.addOwnedString(type_name);
-        try report.document.addReflowingText("The ");
-        try report.document.addModuleName(owned_module);
-        try report.document.addReflowingText(" module does not expose anything named ");
-        try report.document.addType(owned_type);
-        try report.document.addReflowingText(".");
-        try report.document.addLineBreak();
-        try report.document.addReflowingText("Make sure the module exports this type, or use a type that is exposed.");
+
+        // Check if trying to access a type with the same name as the module (e.g., Result.Result)
+        const is_same_name = std.mem.eql(u8, module_name, type_name);
+
+        if (is_same_name) {
+            // Special message for Result.Result, Color.Color, etc.
+            const qualified_name = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module_name, type_name });
+            defer allocator.free(qualified_name);
+            const owned_qualified = try report.addOwnedString(qualified_name);
+
+            try report.document.addReflowingText("There is no ");
+            try report.document.addType(owned_qualified);
+            try report.document.addReflowingText(" type.");
+            try report.document.addLineBreak();
+            try report.document.addLineBreak();
+        } else {
+            // Standard message for other cases (e.g., Color.RGB where Color is a nominal type)
+            const qualified_name = try std.fmt.allocPrint(allocator, "{s}.{s}", .{ module_name, type_name });
+            defer allocator.free(qualified_name);
+            const owned_qualified = try report.addOwnedString(qualified_name);
+
+            try report.document.addType(owned_qualified);
+            try report.document.addReflowingText(" does not exist.");
+            try report.document.addLineBreak();
+            try report.document.addLineBreak();
+        }
 
         const owned_filename = try report.addOwnedString(filename);
         try report.document.addSourceRegion(
@@ -1428,6 +1463,21 @@ pub const Diagnostic = union(enum) {
             line_starts,
         );
 
+        // Add tip at the end
+        try report.document.addLineBreak();
+        if (is_same_name) {
+            try report.document.addReflowingText("There is a ");
+            try report.document.addModuleName(owned_module);
+            try report.document.addReflowingText(" module, but it does not have a ");
+            try report.document.addType(owned_type);
+            try report.document.addReflowingText(" type nested inside it.");
+        } else {
+            try report.document.addType(owned_module);
+            try report.document.addReflowingText(" is a valid type, but it does not have an associated ");
+            try report.document.addType(owned_type);
+            try report.document.addReflowingText(".");
+        }
+
         return report;
     }
 

src/canonicalize/Diagnostic.zig

@@ -188,6 +188,7 @@ pub const Tag = enum {
     diag_module_not_found,
     diag_value_not_exposed,
     diag_type_not_exposed,
+    diag_type_from_missing_module,
     diag_module_not_imported,
     diag_too_many_exports,
     diag_nominal_type_redeclared,

src/canonicalize/Node.zig

@@ -128,7 +128,7 @@ pub fn deinit(store: *NodeStore) void {
 /// when adding/removing variants from ModuleEnv unions. Update these when modifying the unions.
 ///
 /// Count of the diagnostic nodes in the ModuleEnv
-pub const MODULEENV_DIAGNOSTIC_NODE_COUNT = 56;
+pub const MODULEENV_DIAGNOSTIC_NODE_COUNT = 57;
 /// Count of the expression nodes in the ModuleEnv
 pub const MODULEENV_EXPR_NODE_COUNT = 33;
 /// Count of the statement nodes in the ModuleEnv
@@ -2831,6 +2831,12 @@ pub fn addDiagnostic(store: *NodeStore, reason: CIR.Diagnostic) Allocator.Error!
             node.data_1 = @as(u32, @bitCast(r.module_name));
             node.data_2 = @as(u32, @bitCast(r.type_name));
         },
+        .type_from_missing_module => |r| {
+            node.tag = .diag_type_from_missing_module;
+            region = r.region;
+            node.data_1 = @as(u32, @bitCast(r.module_name));
+            node.data_2 = @as(u32, @bitCast(r.type_name));
+        },
         .module_not_imported => |r| {
             node.tag = .diag_module_not_imported;
             region = r.region;
@@ -3083,6 +3089,11 @@ pub fn getDiagnostic(store: *const NodeStore, diagnostic: CIR.Diagnostic.Idx) CI
             .type_name = @as(base.Ident.Idx, @bitCast(node.data_2)),
             .region = store.getRegionAt(node_idx),
         } },
+        .diag_type_from_missing_module => return CIR.Diagnostic{ .type_from_missing_module = .{
+            .module_name = @as(base.Ident.Idx, @bitCast(node.data_1)),
+            .type_name = @as(base.Ident.Idx, @bitCast(node.data_2)),
+            .region = store.getRegionAt(node_idx),
+        } },
         .diag_module_not_imported => return CIR.Diagnostic{ .module_not_imported = .{
             .module_name = @as(base.Ident.Idx, @bitCast(node.data_1)),
             .region = store.getRegionAt(node_idx),

src/canonicalize/NodeStore.zig

@@ -7,17 +7,37 @@ const collections = @import("collections");
 const CIR = @import("CIR.zig");
 
 const Ident = base.Ident;
+const Region = base.Region;
 
 const Scope = @This();
 
+/// Represents a type binding for a type imported from an external module.
+/// Contains all necessary information to resolve the type from the imported module.
+pub const ExternalTypeBinding = struct {
+    module_ident: Ident.Idx,
+    original_ident: Ident.Idx,
+    target_node_idx: ?u16,
+    import_idx: ?CIR.Import.Idx,
+    origin_region: Region,
+    /// True if the module was attempted to be imported but was not found.
+    /// This allows us to emit a more specific diagnostic when the type is used.
+    module_not_found: bool,
+};
+
+/// A unified type binding that can represent either a locally declared type or an externally imported type.
+/// This is the single source of truth for all type resolution in a scope.
+pub const TypeBinding = union(enum) {
+    local_nominal: CIR.Statement.Idx,
+    local_alias: CIR.Statement.Idx,
+    associated_nominal: CIR.Statement.Idx,
+    external_nominal: ExternalTypeBinding,
+};
+
 /// Maps an Ident to a Pattern in the Can IR
 idents: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx),
 aliases: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx),
-/// Maps type names to their type declaration statements
-type_decls: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx),
-/// Maps unqualified type names to their fully qualified Statement.Idx (for associated types)
-/// Example: within Foo's associated block, "Bar" -> statement for "Foo.Bar"
-type_aliases: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx),
+/// Canonical bindings for type names (local, auto-imported, and imported types)
+type_bindings: std.AutoHashMapUnmanaged(Ident.Idx, TypeBinding),
 /// Maps type variables to their type annotation indices
 type_vars: std.AutoHashMapUnmanaged(Ident.Idx, CIR.TypeAnno.Idx),
 /// Maps module alias names to their full module names
@@ -33,8 +53,7 @@ pub fn init(is_function_boundary: bool) Scope {
     return Scope{
         .idents = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx){},
         .aliases = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx){},
-        .type_decls = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx){},
-        .type_aliases = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx){},
+        .type_bindings = std.AutoHashMapUnmanaged(Ident.Idx, TypeBinding){},
         .type_vars = std.AutoHashMapUnmanaged(Ident.Idx, CIR.TypeAnno.Idx){},
         .module_aliases = std.AutoHashMapUnmanaged(Ident.Idx, Ident.Idx){},
         .exposed_items = std.AutoHashMapUnmanaged(Ident.Idx, ExposedItemInfo){},
@@ -47,8 +66,7 @@ pub fn init(is_function_boundary: bool) Scope {
 pub fn deinit(self: *Scope, gpa: std.mem.Allocator) void {
     self.idents.deinit(gpa);
     self.aliases.deinit(gpa);
-    self.type_decls.deinit(gpa);
-    self.type_aliases.deinit(gpa);
+    self.type_bindings.deinit(gpa);
     self.type_vars.deinit(gpa);
     self.module_aliases.deinit(gpa);
     self.exposed_items.deinit(gpa);
@@ -157,20 +175,18 @@ pub const ImportedModuleIntroduceResult = union(enum) {
 };
 
 /// Item kinds in a scope
-pub const ItemKind = enum { ident, alias, type_decl, type_var, module_alias, exposed_item };
+pub const ItemKind = enum { ident, alias, type_var, module_alias, exposed_item };
 
 /// Get the appropriate map for the given item kind
 pub fn items(scope: *Scope, comptime item_kind: ItemKind) switch (item_kind) {
     .ident, .alias => *std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx),
-    .type_decl => *std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx),
     .type_var => *std.AutoHashMapUnmanaged(Ident.Idx, CIR.TypeAnno.Idx),
     .module_alias => *std.AutoHashMapUnmanaged(Ident.Idx, Ident.Idx),
     .exposed_item => *std.AutoHashMapUnmanaged(Ident.Idx, ExposedItemInfo),
 } {
     return switch (item_kind) {
         .ident => &scope.idents,
         .alias => &scope.aliases,
-        .type_decl => &scope.type_decls,
         .type_var => &scope.type_vars,
         .module_alias => &scope.module_aliases,
         .exposed_item => &scope.exposed_items,
@@ -180,15 +196,13 @@ pub fn items(scope: *Scope, comptime item_kind: ItemKind) switch (item_kind) {
 /// Get the appropriate map for the given item kind (const version)
 pub fn itemsConst(scope: *const Scope, comptime item_kind: ItemKind) switch (item_kind) {
     .ident, .alias => *const std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx),
-    .type_decl => *const std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx),
     .type_var => *const std.AutoHashMapUnmanaged(Ident.Idx, CIR.TypeAnno.Idx),
     .module_alias => *const std.AutoHashMapUnmanaged(Ident.Idx, Ident.Idx),
     .exposed_item => *const std.AutoHashMapUnmanaged(Ident.Idx, ExposedItemInfo),
 } {
     return switch (item_kind) {
         .ident => &scope.idents,
         .alias => &scope.aliases,
-        .type_decl => &scope.type_decls,
         .type_var => &scope.type_vars,
         .module_alias => &scope.module_aliases,
         .exposed_item => &scope.exposed_items,
@@ -198,7 +212,6 @@ pub fn itemsConst(scope: *const Scope, comptime item_kind: ItemKind) switch (ite
 /// Put an item in the scope, panics on OOM
 pub fn put(scope: *Scope, gpa: std.mem.Allocator, comptime item_kind: ItemKind, name: Ident.Idx, value: switch (item_kind) {
     .ident, .alias => CIR.Pattern.Idx,
-    .type_decl => CIR.Statement.Idx,
     .type_var => CIR.TypeAnno.Idx,
     .module_alias => Ident.Idx,
     .exposed_item => ExposedItemInfo,
@@ -214,13 +227,14 @@ pub fn introduceTypeDecl(
     type_decl: CIR.Statement.Idx,
     parent_lookup_fn: ?fn (Ident.Idx) ?CIR.Statement.Idx,
 ) std.mem.Allocator.Error!TypeIntroduceResult {
-    // Check if already exists in current scope by comparing text content
-    var iter = scope.type_decls.iterator();
-    while (iter.next()) |entry| {
-        if (name.idx == entry.key_ptr.idx) {
-            // Type redeclaration is an error, not just a warning
-            return TypeIntroduceResult{ .redeclared_error = entry.value_ptr.* };
-        }
+    // Check if type already exists in this scope
+    if (scope.type_bindings.getPtr(name)) |existing| {
+        return switch (existing.*) {
+            .local_nominal => |stmt| TypeIntroduceResult{ .redeclared_error = stmt },
+            .local_alias => |stmt| TypeIntroduceResult{ .type_alias_redeclared = stmt },
+            .associated_nominal => |stmt| TypeIntroduceResult{ .nominal_type_redeclared = stmt },
+            .external_nominal => TypeIntroduceResult{ .nominal_type_redeclared = type_decl },
+        };
     }
 
     // Check for shadowing in parent scopes and issue warnings
@@ -229,7 +243,8 @@ pub fn introduceTypeDecl(
         shadowed_stmt = lookup_fn(name);
     }
 
-    try scope.put(gpa, .type_decl, name, type_decl);
+    // Add type binding (single source of truth)
+    try scope.type_bindings.put(gpa, name, TypeBinding{ .local_nominal = type_decl });
 
     if (shadowed_stmt) |stmt| {
         return TypeIntroduceResult{ .shadowing_warning = stmt };
@@ -238,26 +253,6 @@ pub fn introduceTypeDecl(
     return TypeIntroduceResult{ .success = {} };
 }
 
-/// Lookup a type declaration in the scope hierarchy
-/// TODO: Optimize lookup performance - currently O(n) due to text comparison
-/// TODO: Consider caching or using a more efficient data structure for type lookup
-/// TODO: Support for nominal vs structural type distinction (future := operator)
-pub fn lookupTypeDecl(scope: *const Scope, name: Ident.Idx) TypeLookupResult {
-    // Search by comparing text content, not identifier index
-    var iter = scope.type_decls.iterator();
-    while (iter.next()) |entry| {
-        if (name.idx == entry.key_ptr.idx) {
-            return TypeLookupResult{ .found = entry.value_ptr.* };
-        }
-    }
-    return TypeLookupResult{ .not_found = {} };
-}
-
-/// Look up an unqualified type alias (for associated types)
-pub fn lookupTypeAlias(scope: *const Scope, name: Ident.Idx) ?CIR.Statement.Idx {
-    return scope.type_aliases.get(name);
-}
-
 /// Introduce an unqualified type alias (for associated types)
 /// Maps an unqualified name to a fully qualified type declaration
 pub fn introduceTypeAlias(
@@ -266,7 +261,9 @@ pub fn introduceTypeAlias(
     unqualified_name: Ident.Idx,
     qualified_type_decl: CIR.Statement.Idx,
 ) !void {
-    try scope.type_aliases.put(gpa, unqualified_name, qualified_type_decl);
+    try scope.type_bindings.put(gpa, unqualified_name, TypeBinding{
+        .associated_nominal = qualified_type_decl,
+    });
 }
 
 /// Update an existing type declaration in the scope
@@ -278,17 +275,17 @@ pub fn updateTypeDecl(
     name: Ident.Idx,
     new_type_decl: CIR.Statement.Idx,
 ) std.mem.Allocator.Error!void {
-    // Find the existing entry by comparing text content
-    var iter = scope.type_decls.iterator();
-    while (iter.next()) |entry| {
-        if (name.idx == entry.key_ptr.idx) {
-            // Update the existing entry with the new statement index
-            entry.value_ptr.* = new_type_decl;
-            return;
-        }
+    if (scope.type_bindings.getPtr(name)) |binding_ptr| {
+        const current = binding_ptr.*;
+        binding_ptr.* = switch (current) {
+            .local_nominal => TypeBinding{ .local_nominal = new_type_decl },
+            .local_alias => TypeBinding{ .local_alias = new_type_decl },
+            .associated_nominal => TypeBinding{ .associated_nominal = new_type_decl },
+            .external_nominal => current,
+        };
+    } else {
+        try scope.type_bindings.put(gpa, name, TypeBinding{ .local_nominal = new_type_decl });
     }
-    // If not found, add it as a new entry
-    try scope.put(gpa, .type_decl, name, new_type_decl);
 }
 
 /// Introduce a type variable into the scope

src/canonicalize/Scope.zig

@@ -790,6 +790,14 @@ test "NodeStore round trip - Diagnostics" {
         },
     });
 
+    try diagnostics.append(gpa, CIR.Diagnostic{
+        .type_from_missing_module = .{
+            .module_name = rand_ident_idx(),
+            .type_name = rand_ident_idx(),
+            .region = rand_region(),
+        },
+    });
+
     // Test the round-trip for all diagnostics
     for (diagnostics.items) |diagnostic| {
         const idx = try store.addDiagnostic(diagnostic);

src/canonicalize/test/node_store_test.zig

@@ -822,6 +822,9 @@ pub const Statement = union(enum) {
         qualifier_tok: ?Token.Idx,
         alias_tok: ?Token.Idx,
         exposes: ExposedItem.Span,
+        /// True when importing like `import json.Parser.Config` where Config is auto-exposed
+        /// but Parser should not become an alias (unlike `import json.Parser exposing [Config]`)
+        nested_import: bool,
         region: TokenizedRegion,
     },
     type_decl: struct {

src/parse/AST.zig

@@ -1172,6 +1172,7 @@ pub fn getStatement(store: *const NodeStore, statement_idx: AST.Statement.Idx) A
                     .start = exposes_start,
                     .len = exposes_len,
                 } },
+                .nested_import = false,
                 .region = node.region,
             } };
         },