Anon-struct type aliases are visible to inference: ICE, field typing, annotations, method results (RUE-170, RUE-164)

Sema pre-resolves let-bound comptime type aliases before HM inference
runs (precompute_comptime_type_locals in comptime_eval.rs, the same
evaluation gate as analyze_call's implicit-comptime path) and feeds the
alias map + lazily-registered anon-struct method signatures into
ConstraintGenerator. Aliases route through the same concrete paths as
named structs, fixing all four facets: the E9000 ICE on compound field
initializers, the i32-defaulted FieldGet literal, unenforced
let-annotations, and the <error> method-result decay.

Supporting fixes: anon-struct method registration is atomic (partial
inserts let the duplicate-method error be swallowed on re-evaluation),
and StructInit's unknown-type fallback visits field initializers (ICE ->
ordinary sema error even when alias resolution fails).

Residual (pre-existing, not regressed): P::f() assoc-fn calls on
alias-named types still resolve only via the named-struct table.

11 CLI cases (comptime_alias_infer.toml): 4 facets,
generic/captured-value/chained-alias shapes, duplicate-method
regression, named-struct controls. Frontend-only.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: steveklabnik

crates/rue-air/src/inference/generate.rs

@@ -185,6 +185,23 @@ pub struct ConstraintGenerator<'a> {
     /// `None` only in unit tests; production passes the map via
     /// [`Self::with_module_binding_types`].
     module_binding_types: Option<&'a HashMap<(FileId, Spur), Type>>,
+    /// Compile-time type aliases bound by `let` in the current function body
+    /// (`let P = F();` where `F` returns `type`), pre-resolved by sema before
+    /// constraint generation. Consulted after `type_subst` when resolving
+    /// struct-literal type names and `let` annotations, so anonymous-struct
+    /// aliases route through the same concrete paths as named structs
+    /// (RUE-170). Like sema's `comptime_type_vars`, the map is flat (not
+    /// scope-aware). `None` only in unit tests; production passes the map via
+    /// [`Self::with_comptime_local_types`].
+    comptime_local_types: Option<&'a HashMap<Spur, Type>>,
+    /// Method signatures registered after the shared `InferenceContext` was
+    /// built: anonymous-struct methods are registered lazily during comptime
+    /// evaluation, so they're absent from `methods`. Consulted when a method
+    /// key misses `methods`, so a call on an anonymous-struct receiver yields
+    /// its declared return type instead of `<error>` (RUE-164). `None` only
+    /// in unit tests; production passes the map via
+    /// [`Self::with_extra_method_sigs`].
+    extra_method_sigs: Option<&'a HashMap<(StructId, Spur), MethodSig>>,
     /// Type intern pool for creating pointer and array types during constraint generation.
     type_pool: &'a TypeInternPool,
 }
@@ -235,6 +252,8 @@ impl<'a> ConstraintGenerator<'a> {
             type_subst,
             const_types: None,
             module_binding_types: None,
+            comptime_local_types: None,
+            extra_method_sigs: None,
             type_pool,
         }
     }
@@ -256,6 +275,28 @@ impl<'a> ConstraintGenerator<'a> {
         self
     }
 
+    /// Provide pre-resolved comptime type aliases (local name -> concrete
+    /// type) for struct-literal and `let`-annotation resolution. See the
+    /// `comptime_local_types` field (RUE-170).
+    pub fn with_comptime_local_types(
+        mut self,
+        comptime_local_types: &'a HashMap<Spur, Type>,
+    ) -> Self {
+        self.comptime_local_types = Some(comptime_local_types);
+        self
+    }
+
+    /// Provide late-registered method signatures (anonymous-struct methods)
+    /// for method-call resolution. See the `extra_method_sigs` field
+    /// (RUE-164).
+    pub fn with_extra_method_sigs(
+        mut self,
+        extra_method_sigs: &'a HashMap<(StructId, Spur), MethodSig>,
+    ) -> Self {
+        self.extra_method_sigs = Some(extra_method_sigs);
+        self
+    }
+
     /// Get the type variables allocated for integer literals.
     pub fn int_literal_vars(&self) -> &[TypeVarId] {
         &self.int_literal_vars
@@ -288,6 +329,14 @@ impl<'a> ConstraintGenerator<'a> {
         }
     }
 
+    /// Look up a method signature, falling back to the late-registered
+    /// (anonymous-struct) signatures when the shared map misses (RUE-164).
+    fn method_sig(&self, key: &(StructId, Spur)) -> Option<&'a MethodSig> {
+        self.methods
+            .get(key)
+            .or_else(|| self.extra_method_sigs.and_then(|sigs| sigs.get(key)))
+    }
+
     /// Resolve a field's declared type on a concrete struct type.
     fn field_type_of(&self, struct_ty: Type, field: Spur) -> Option<Type> {
         let TypeKind::Struct(struct_id) = struct_ty.kind() else {
@@ -548,9 +597,18 @@ impl<'a> ConstraintGenerator<'a> {
                 let init_info = self.generate(*init, ctx);
 
                 let var_ty = if let Some(ty_sym) = type_annotation {
-                    // Explicit type annotation - use it and constrain init to match
-                    let ty_name = self.interner.resolve(ty_sym);
-                    if let Some(annotated_ty) = self.resolve_type_name(ty_name) {
+                    // Explicit type annotation - use it and constrain init to
+                    // match. Comptime type aliases (`let P = F(); let p: P =
+                    // ...`) resolve first, mirroring sema's annotation
+                    // validation order (`comptime_type_vars` before the type
+                    // tables); without this the annotation was unenforced and
+                    // any value typechecked against it (RUE-170).
+                    let annotated = self
+                        .comptime_local_types
+                        .and_then(|aliases| aliases.get(ty_sym).copied())
+                        .map(|ty| self.type_to_infer(ty))
+                        .or_else(|| self.resolve_type_name(self.interner.resolve(ty_sym)));
+                    if let Some(annotated_ty) = annotated {
                         self.add_constraint(Constraint::equal(
                             init_info.ty,
                             annotated_ty.clone(),
@@ -1111,14 +1169,22 @@ impl<'a> ConstraintGenerator<'a> {
                 fields_len,
                 ..
             } => {
-                // Check type_subst first (for Self and type parameters in method bodies)
+                // Check type_subst first (for Self and type parameters in
+                // method bodies), then comptime type aliases (`let P = F();
+                // P { ... }`, RUE-170) — mirroring sema, which consults
+                // `comptime_type_vars` before the struct table — then named
+                // structs.
                 let struct_ty = self
                     .type_subst
                     .and_then(|subst| subst.get(type_name).copied())
+                    .or_else(|| {
+                        self.comptime_local_types
+                            .and_then(|aliases| aliases.get(type_name).copied())
+                    })
                     .or_else(|| self.structs.get(type_name).copied());
 
+                let fields = self.rir.get_field_inits(*fields_start, *fields_len);
                 if let Some(struct_ty) = struct_ty {
-                    let fields = self.rir.get_field_inits(*fields_start, *fields_len);
                     // Constrain each initializer against its field's declared
                     // type, so literal initializers are range-checked at the
                     // field's width instead of silently wrapping
@@ -1133,6 +1199,14 @@ impl<'a> ConstraintGenerator<'a> {
                     }
                     InferType::Concrete(struct_ty)
                 } else {
+                    // Unknown type name — sema reports the error. Still visit
+                    // the initializers so every sub-expression gets a type;
+                    // skipping them left compound initializers (`-1`, `1+2`)
+                    // with unresolved variables, which sema then reported as
+                    // an internal compiler error (RUE-170).
+                    for (_, value_ref) in fields.iter() {
+                        self.generate(*value_ref, ctx);
+                    }
                     InferType::Concrete(Type::ERROR)
                 }
             }
@@ -1336,9 +1410,11 @@ impl<'a> ConstraintGenerator<'a> {
                     }
                     InferType::Concrete(ty) => {
                         if let Some(struct_id) = ty.as_struct() {
-                            // Use StructId directly for method lookup
+                            // Use StructId directly for method lookup (falls
+                            // back to late-registered anonymous-struct
+                            // signatures, RUE-164)
                             let method_key = (struct_id, *method);
-                            if let Some(method_sig) = self.methods.get(&method_key) {
+                            if let Some(method_sig) = self.method_sig(&method_key) {
                                 // Generate constraints for arguments
                                 for (arg, param_type) in
                                     args.iter().zip(method_sig.param_types.iter())

crates/rue-air/src/sema/analysis.rs

@@ -1679,6 +1679,44 @@ impl<'a> Sema<'a> {
         type_subst: Option<&HashMap<Spur, Type>>,
         value_subst: Option<&HashMap<Spur, ConstValue>>,
     ) -> CompileResult<HashMap<InstRef, Type>> {
+        // Pre-resolve `let`-bound comptime type aliases (`let P = F();` where
+        // `F` returns `type`) so inference can see the concrete anonymous
+        // struct types behind them. Without this, `P { ... }`, `let p: P`,
+        // and methods on `P`-typed receivers all fell through to `<error>`
+        // or unconstrained variables (RUE-170, RUE-164). This may create the
+        // anonymous structs (idempotently — analysis re-evaluates the same
+        // initializers later and structural equality dedups them).
+        let comptime_local_types =
+            self.precompute_comptime_type_locals(body, type_subst, value_subst);
+
+        // Anonymous-struct methods are registered lazily (during comptime
+        // evaluation, including the pre-pass above), after the shared
+        // `InferenceContext` was built — so collect the signatures it doesn't
+        // know about. Without these, a method call on an anonymous-struct
+        // receiver inferred to `<error>` and poisoned sibling constraints
+        // (RUE-164).
+        let extra_method_sigs: HashMap<(StructId, Spur), crate::inference::MethodSig> = self
+            .methods
+            .iter()
+            .filter(|(key, _)| !infer_ctx.method_sigs.contains_key(*key))
+            .map(|(key, info)| {
+                (
+                    *key,
+                    crate::inference::MethodSig {
+                        struct_type: info.struct_type,
+                        has_self: info.has_self,
+                        param_types: self
+                            .param_arena
+                            .types(info.params)
+                            .iter()
+                            .map(|t| self.type_to_infer_type(*t))
+                            .collect(),
+                        return_type: self.type_to_infer_type(info.return_type),
+                    },
+                )
+            })
+            .collect();
+
         // Create constraint generator using pre-computed inference context
         let mut cgen = ConstraintGenerator::with_type_subst(
             self.rir,
@@ -1691,7 +1729,9 @@ impl<'a> Sema<'a> {
             type_subst,
         )
         .with_const_types(&infer_ctx.const_types)
-        .with_module_binding_types(&infer_ctx.module_binding_types);
+        .with_module_binding_types(&infer_ctx.module_binding_types)
+        .with_comptime_local_types(&comptime_local_types)
+        .with_extra_method_sigs(&extra_method_sigs);
 
         // Build parameter map for constraint context.
         // Convert Type to InferType so arrays are represented structurally.
@@ -4650,6 +4690,14 @@ impl<'a> Sema<'a> {
         // Track method names in this registration batch to detect duplicates
         let mut seen_methods: std::collections::HashSet<Spur> = std::collections::HashSet::new();
 
+        // Stage registrations and commit only if the whole batch validates.
+        // Inserting one-by-one left earlier methods registered when a later
+        // one failed (e.g. a duplicate name), so re-evaluating the same
+        // AnonStructType — which happens since the RUE-170 inference pre-pass
+        // evaluates type aliases before analysis does — saw the methods as
+        // "already registered", skipped this check, and silently succeeded.
+        let mut staged: Vec<((StructId, Spur), MethodInfo)> = Vec::new();
+
         for method_ref in method_refs {
             let method_inst = self.rir.get(method_ref);
             if let InstData::FnDecl {
@@ -4704,7 +4752,7 @@ impl<'a> Sema<'a> {
                     .param_arena
                     .alloc_method(param_names.into_iter(), param_types.into_iter());
 
-                self.methods.insert(
+                staged.push((
                     key,
                     MethodInfo {
                         struct_type,
@@ -4714,9 +4762,10 @@ impl<'a> Sema<'a> {
                         body: *body,
                         span: method_inst.span,
                     },
-                );
+                ));
             }
         }
+        self.methods.extend(staged);
         Some(())
     }