fix(hir): compose imported methods with static literals

Author: Ralph Kuepper

crates/perry-hir/src/lower/context.rs

@@ -199,6 +199,7 @@ impl LoweringContext {
             mixin_funcs: HashMap::new(),
             anon_shape_classes: HashMap::new(),
             anon_shape_fields: HashMap::new(),
+            prefer_exported_method_shape_seed: false,
             forward_class_names: std::collections::HashSet::new(),
             forward_class_decl_depth: std::collections::HashMap::new(),
             class_renames: std::collections::HashMap::new(),

crates/perry-hir/src/lower/expr_object.rs

@@ -632,6 +632,11 @@ fn accessor_key_expr(key: MethodKeyKind) -> Expr {
 }
 
 pub(super) fn lower_object(ctx: &mut LoweringContext, obj: &ast::ObjectLit) -> Result<Expr> {
+    // A directly exported object is the producer boundary for #8775. Consume
+    // the marker here so nested literals continue through their ordinary
+    // lowering paths.
+    let prefer_exported_method_shape_seed =
+        std::mem::take(&mut ctx.prefer_exported_method_shape_seed);
     // Phase 3: closed-shape object literals lower to `new __AnonShape_N()`
     // so downstream field access hits the direct-GEP fast path. The
     // anon class is synthesized as a shape-only class with constructor
@@ -1074,7 +1079,8 @@ pub(super) fn lower_object(ctx: &mut LoweringContext, obj: &ast::ObjectLit) -> R
             collect_local_refs_expr(value, &mut refs, &mut visited_closures);
             !refs.contains(&param_id)
         };
-        let can_emit_static_object = has_method
+        let can_emit_static_object = !prefer_exported_method_shape_seed
+            && has_method
             && !has_spread
             && !has_accessor
             && !has_computed
@@ -1105,8 +1111,58 @@ pub(super) fn lower_object(ctx: &mut LoweringContext, obj: &ast::ObjectLit) -> R
             return Ok(Expr::Object(props));
         }
 
-        // Pass 2: build the IIFE wrapper. `__o` starts as an empty object
-        // and each op mutates it in source order.
+        // Imported-object capabilities need a producer-authoritative non-zero
+        // class and stable slot order. Keep directly exported, static-key
+        // method literals in the source-ordered IIFE, but seed it with a
+        // shape-only anonymous class instead of `{}`. This composes with the
+        // direct-object optimization above: non-exported literals still skip
+        // the IIFE, while exported literals retain the metadata required by a
+        // consumer's guarded direct call.
+        let static_shape_seed = if prefer_exported_method_shape_seed
+            && !has_spread
+            && !has_accessor
+            && !has_computed
+            && !has_proto_setter
+        {
+            let mut names = Vec::new();
+            let mut seen = std::collections::HashSet::new();
+            let mut eligible = true;
+            for op in &ops {
+                let name = match op {
+                    SpreadOp::Set {
+                        key: Expr::String(name),
+                        infer_name: false,
+                        ..
+                    }
+                    | SpreadOp::MethodByName { key: name, .. } => name,
+                    _ => {
+                        eligible = false;
+                        break;
+                    }
+                };
+                if seen.insert(name.clone()) {
+                    names.push(name.clone());
+                }
+            }
+            eligible.then(|| {
+                let fields: Vec<(String, Type)> =
+                    names.iter().map(|name| (name.clone(), Type::Any)).collect();
+                let class_name = ctx.synthesize_anon_shape_class(&fields);
+                Expr::New {
+                    class_name,
+                    args: names.iter().map(|_| Expr::Undefined).collect(),
+                    type_args: Vec::new(),
+                    byte_offset: 0,
+                    cap_args_appended: 0,
+                }
+            })
+        } else {
+            None
+        };
+
+        // Pass 2: build the IIFE wrapper. `__o` starts as the exported stable
+        // shape seed when eligible, otherwise as an empty object, and each op
+        // mutates it in source order.
         let extern_call = |name: &str, args: Vec<Expr>| Expr::Call {
             callee: Box::new(Expr::ExternFuncRef {
                 name: name.to_string(),
@@ -1250,7 +1306,7 @@ pub(super) fn lower_object(ctx: &mut LoweringContext, obj: &ast::ObjectLit) -> R
         };
         return Ok(Expr::Call {
             callee: Box::new(closure),
-            args: vec![Expr::Object(Vec::new())],
+            args: vec![static_shape_seed.unwrap_or_else(|| Expr::Object(Vec::new()))],
             type_args: vec![],
             byte_offset: 0,
         });

crates/perry-hir/src/lower/lowering_context.rs

@@ -767,6 +767,11 @@ pub struct LoweringContext {
     /// (e.g. recognizing a bundled mysql2 `createPool(config)` by its option
     /// names) recovers them here.
     pub(crate) anon_shape_fields: HashMap<String, Vec<String>>,
+    /// Set while lowering a directly exported binding/default expression.
+    /// Eligible method literals consume this flag and retain the seeded IIFE
+    /// representation needed to publish an exact cross-module own-method
+    /// capability. Ordinary local method literals keep the direct-object path.
+    pub(crate) prefer_exported_method_shape_seed: bool,
     /// Class DECLARATION names at the top level of the function body
     /// currently being lowered. JS resolves a method-body reference to a
     /// sibling class declared LATER in the same function at call time

crates/perry-hir/src/lower/module_decl.rs

@@ -22,6 +22,22 @@ use native_default_import::{
     node_submodule_default_export_key,
 };
 
+fn is_direct_object_literal(expr: &ast::Expr) -> bool {
+    let mut current = expr;
+    loop {
+        match current {
+            ast::Expr::TsAs(wrapper) => current = &wrapper.expr,
+            ast::Expr::TsNonNull(wrapper) => current = &wrapper.expr,
+            ast::Expr::TsSatisfies(wrapper) => current = &wrapper.expr,
+            ast::Expr::TsTypeAssertion(wrapper) => current = &wrapper.expr,
+            ast::Expr::TsConstAssertion(wrapper) => current = &wrapper.expr,
+            ast::Expr::Paren(wrapper) => current = &wrapper.expr,
+            ast::Expr::Object(_) => return true,
+            _ => return false,
+        }
+    }
+}
+
 pub(crate) fn lower_module_decl(
     ctx: &mut LoweringContext,
     module: &mut Module,
@@ -1179,7 +1195,13 @@ pub(crate) fn lower_module_decl(
                                 }
                             }
 
-                            let expr = lower_expr(ctx, init)?;
+                            let previous_shape_seed = ctx.prefer_exported_method_shape_seed;
+                            ctx.prefer_exported_method_shape_seed = var_decl.kind
+                                == ast::VarDeclKind::Const
+                                && is_direct_object_literal(init);
+                            let expr = lower_expr(ctx, init);
+                            ctx.prefer_exported_method_shape_seed = previous_shape_seed;
+                            let expr = expr?;
                             let id = if ctx.pre_registered_module_vars.remove(&name) {
                                 ctx.pre_registered_module_var_decls.remove(&name);
                                 let id = ctx.lookup_local(&name).unwrap();
@@ -1904,7 +1926,12 @@ pub(crate) fn lower_module_decl(
         }
         ast::ModuleDecl::ExportDefaultExpr(export_default_expr) => {
             // export default <expr>
-            let lowered = lower_expr(ctx, &export_default_expr.expr)?;
+            let previous_shape_seed = ctx.prefer_exported_method_shape_seed;
+            ctx.prefer_exported_method_shape_seed =
+                is_direct_object_literal(&export_default_expr.expr);
+            let lowered = lower_expr(ctx, &export_default_expr.expr);
+            ctx.prefer_exported_method_shape_seed = previous_shape_seed;
+            let lowered = lowered?;
 
             // If the expression is a FuncRef, add to exported_functions for proper wrapper generation
             if let Expr::FuncRef(func_id) = &lowered {

crates/perry-hir/src/lower/tests.rs

@@ -155,6 +155,55 @@ const computed = { [key]() { return 1; } };
     }
 }
 
+#[test]
+fn exported_static_method_literals_keep_a_stable_shape_seed() {
+    let source = r#"
+export const named = {
+  value: 1,
+  read() { return this.value; },
+};
+export default {
+  value: 2,
+  read() { return this.value; },
+};
+"#;
+    let module =
+        perry_parser::parse_typescript(source, "exported-method-object.ts").expect("source parses");
+    let hir = super::lower_module(
+        &module,
+        "exported-method-object",
+        "exported-method-object.ts",
+    )
+    .expect("source lowers");
+
+    for name in ["named", "default"] {
+        let init = hir
+            .init
+            .iter()
+            .find_map(|stmt| match stmt {
+                Stmt::Let {
+                    name: local_name,
+                    init: Some(init),
+                    ..
+                } if local_name == name => Some(init),
+                _ => None,
+            })
+            .unwrap_or_else(|| panic!("missing init for {name}"));
+        let Expr::Call { callee, args, .. } = init else {
+            panic!("exported method object must retain its seeded IIFE: {init:#?}");
+        };
+        assert!(matches!(
+            callee.as_ref(),
+            Expr::Closure { params, .. }
+                if params.first().is_some_and(|param| param.name == "__perry_obj_iife")
+        ));
+        assert!(matches!(
+            args.as_slice(),
+            [Expr::New { class_name, .. }] if class_name.starts_with("__AnonShape_")
+        ));
+    }
+}
+
 #[test]
 fn test_lower_function_registration() {
     let mut ctx = make_ctx();