Defer type alias ScopeConflict to reference site

Type aliases that shadow imported types (e.g. `type Output = M.Output`)
no longer trigger ScopeConflict at declaration. Instead, the conflict is
recorded in `type_scope_conflicts` and only raised when the ambiguous
name is actually referenced in a type annotation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: roryc89

src/typechecker/check.rs

@@ -2190,14 +2190,12 @@ fn check_module_impl(module: &Module, registry: &ModuleRegistry, collect_span_ty
                 }
                 ctx.type_con_arities.insert(qi(name.value), count_kind_arrows(kind));
             }
-            Decl::TypeAlias { name, span, .. } => {
-                // Type synonyms re-defining an explicitly imported type name are a ScopeConflict.
-                // Data/newtype declarations are allowed to shadow imports.
+            Decl::TypeAlias { name, .. } => {
+                // Local type aliases shadow imported types, just like data/newtype declarations.
+                // A ScopeConflict is only raised if the ambiguous name is actually referenced
+                // (not merely declared or exported). Record the conflict for deferred checking.
                 if explicitly_imported_types.contains(&name.value) {
-                    errors.push(TypeError::ScopeConflict {
-                        span: *span,
-                        name: name.value,
-                    });
+                    ctx.type_scope_conflicts.insert(name.value);
                 }
             }
             _ => {}
@@ -3252,6 +3250,13 @@ fn check_module_impl(module: &Module, registry: &ModuleRegistry, collect_span_ty
                 collect_type_expr_vars(ty, &HashSet::new(), &mut errors);
                 // Validate constraint class names in the type signature
                 check_constraint_class_names(ty, &known_classes, &class_param_counts, &mut errors);
+                // Check for type-level scope conflicts (ambiguous type names)
+                if let Some((conflict_span, conflict_name)) = crate::typechecker::convert::find_type_scope_conflict(ty, &ctx.type_scope_conflicts) {
+                    errors.push(TypeError::ScopeConflict {
+                        span: conflict_span,
+                        name: conflict_name,
+                    });
+                }
                 match convert_type_expr(ty, &type_ops) {
                     Ok(converted) => {
                         // Check for partially applied synonyms in type signature

src/typechecker/convert.rs

@@ -152,6 +152,70 @@ pub fn convert_type_expr(ty: &TypeExpr, type_ops: &HashMap<QualifiedIdent, Quali
     }
 }
 
+/// Check if a type expression references any names that are in scope conflict.
+/// Returns the first conflicting name found, if any.
+pub fn find_type_scope_conflict(ty: &TypeExpr, conflicts: &HashSet<Symbol>) -> Option<(crate::span::Span, Symbol)> {
+    match ty {
+        TypeExpr::Constructor { name, span, .. } => {
+            if name.module.is_none() && conflicts.contains(&name.name) {
+                return Some((*span, name.name));
+            }
+            None
+        }
+        TypeExpr::App { constructor, arg, .. } => {
+            find_type_scope_conflict(constructor, conflicts)
+                .or_else(|| find_type_scope_conflict(arg, conflicts))
+        }
+        TypeExpr::Function { from, to, .. } => {
+            find_type_scope_conflict(from, conflicts)
+                .or_else(|| find_type_scope_conflict(to, conflicts))
+        }
+        TypeExpr::Forall { ty, vars, .. } => {
+            for (_, _, kind) in vars {
+                if let Some(k) = kind {
+                    if let Some(r) = find_type_scope_conflict(k, conflicts) {
+                        return Some(r);
+                    }
+                }
+            }
+            find_type_scope_conflict(ty, conflicts)
+        }
+        TypeExpr::Constrained { constraints, ty, .. } => {
+            for c in constraints {
+                for arg in &c.args {
+                    if let Some(r) = find_type_scope_conflict(arg, conflicts) {
+                        return Some(r);
+                    }
+                }
+            }
+            find_type_scope_conflict(ty, conflicts)
+        }
+        TypeExpr::Kinded { ty, .. } => {
+            find_type_scope_conflict(ty, conflicts)
+        }
+        TypeExpr::Record { fields, .. } => {
+            for f in fields {
+                if let Some(r) = find_type_scope_conflict(&f.ty, conflicts) {
+                    return Some(r);
+                }
+            }
+            None
+        }
+        TypeExpr::Row { fields, tail, .. } => {
+            for f in fields {
+                if let Some(r) = find_type_scope_conflict(&f.ty, conflicts) {
+                    return Some(r);
+                }
+            }
+            if let Some(t) = tail {
+                return find_type_scope_conflict(t, conflicts);
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
 /// Check that kind annotations in forall vars don't forward-reference variables
 /// declared later in the same forall. E.g. `forall (a :: k) k.` is invalid because
 /// `k` is used before it's declared.

src/typechecker/infer.rs

@@ -111,6 +111,9 @@ pub struct InferCtx {
     /// Names that are ambiguous due to being imported from multiple modules.
     /// Referencing these names produces a ScopeConflict error.
     pub scope_conflicts: HashSet<Symbol>,
+    /// Type names that are ambiguous due to a local type alias shadowing an imported type.
+    /// Only checked when the type name is actually referenced in a type expression.
+    pub type_scope_conflicts: HashSet<Symbol>,
     /// Map from operator → class method target name (e.g. `<>` → `append`).
     /// Used for tracking deferred constraints on operator usage.
     pub operator_class_targets: HashMap<QualifiedIdent, QualifiedIdent>,
@@ -218,6 +221,7 @@ impl InferCtx {
             method_own_constraints: HashMap::new(),
             module_mode: false,
             scope_conflicts: HashSet::new(),
+            type_scope_conflicts: HashSet::new(),
             operator_class_targets: HashMap::new(),
             op_deferred_constraints: Vec::new(),
             class_fundeps: HashMap::new(),