fix: restore class member source and localize default dates

changelog.d/9451-9468-intl-method-source.md

@@ -0,0 +1,15 @@
+### Fixed
+
+- **Class methods and accessors now retain their original source text.**
+  `String(C.prototype.method)`, direct `.toString()`, template coercion, and
+  reflected getter/setter functions return the source MethodDefinition rather
+  than a synthesized native-function body. Object-literal accessors also
+  receive their specified `get name` / `set name` function names. CommonJS
+  class expressions keep assignment-inferred names without exposing Perry's
+  internal anonymous-default registration key. Fixes #9468.
+
+- **Default `Intl.DateTimeFormat` dates now use the locale's CLDR numeric
+  pattern.** The implicit numeric year/month/day field set, its
+  `formatToParts()` output, and `Date.prototype.toLocaleDateString()` now agree
+  on locale order, separators, and padding instead of falling back to the
+  hard-coded US layout. Fixes #9451.

crates/perry-codegen/src/codegen/artifact_source_text.rs

@@ -0,0 +1,117 @@
+//! Source-text registration for raw class method and accessor symbols.
+//!
+//! Class members are not ordinary closure wrappers, so their retained source
+//! must be paired with the LLVM body symbol codegen actually emitted. Kept out
+//! of `artifacts.rs` so that file remains below the repository's 2,000-line
+//! limit.
+
+use std::collections::HashSet;
+
+use perry_hir::types::FuncId;
+use perry_hir::Module as HirModule;
+
+use crate::module::LlModule;
+
+use super::helpers::{scoped_method_name, scoped_static_method_name};
+
+pub(super) fn extend_class_method_source_text(
+    hir: &HirModule,
+    module_prefix: &str,
+    llmod: &LlModule,
+    user_fn_source: &mut Vec<(String, String)>,
+) {
+    // An HIR registry entry is not proof that this module emitted the body: a
+    // cross-module or typed-only accessor can remain present without a local
+    // definition. Referencing such a symbol from module initialization makes
+    // LLVM reject the module, so `has_function` is the final authority.
+    let mut seen: HashSet<String> = user_fn_source
+        .iter()
+        .map(|(symbol, _)| symbol.clone())
+        .collect();
+    let mut push_defined = |func_id: FuncId, symbol: String| {
+        let Some(source) = hir.closure_source_text.get(&func_id) else {
+            return;
+        };
+        if symbol.is_empty() || !llmod.has_function(&symbol) || !seen.insert(symbol.clone()) {
+            return;
+        }
+        user_fn_source.push((symbol, source.clone()));
+    };
+
+    for class in &hir.classes {
+        if class.id == 0 {
+            continue;
+        }
+        for method in &class.methods {
+            push_defined(
+                method.id,
+                scoped_method_name(module_prefix, &class.name, &method.name),
+            );
+        }
+        for member in class
+            .computed_members
+            .iter()
+            .filter(|member| !member.is_static)
+        {
+            push_defined(
+                member.function.id,
+                scoped_method_name(module_prefix, &class.name, &member.function.name),
+            );
+        }
+        for (prop, getter) in &class.getters {
+            let symbol = if class.static_accessor_fn_ids.contains(&getter.id) {
+                scoped_static_method_name(
+                    module_prefix,
+                    class.id,
+                    &class.name,
+                    &format!("__get_{prop}"),
+                )
+            } else {
+                scoped_method_name(
+                    module_prefix,
+                    &class.name,
+                    &format!("__get_{}", getter.name),
+                )
+            };
+            push_defined(getter.id, symbol);
+        }
+        for (prop, setter) in &class.setters {
+            let symbol = if class.static_accessor_fn_ids.contains(&setter.id) {
+                scoped_static_method_name(
+                    module_prefix,
+                    class.id,
+                    &class.name,
+                    &format!("__set_{prop}"),
+                )
+            } else {
+                scoped_method_name(
+                    module_prefix,
+                    &class.name,
+                    &format!("__set_{}", setter.name),
+                )
+            };
+            push_defined(setter.id, symbol);
+        }
+        for method in &class.static_methods {
+            push_defined(
+                method.id,
+                scoped_static_method_name(module_prefix, class.id, &class.name, &method.name),
+            );
+        }
+        for member in class
+            .computed_members
+            .iter()
+            .filter(|member| member.is_static)
+        {
+            push_defined(
+                member.function.id,
+                scoped_static_method_name(
+                    module_prefix,
+                    class.id,
+                    &class.name,
+                    &member.function.name,
+                ),
+            );
+        }
+    }
+}

crates/perry-codegen/src/codegen/artifacts.rs

@@ -1854,6 +1854,16 @@ pub(super) fn emit_module_artifacts(c: ModuleArtifactsCtx<'_>) -> Result<()> {
         user_fn_source.push((sym, src.clone()));
     }
 
+    // #9468: method/accessor bodies are raw symbols rather than closure
+    // wrappers. Pair retained MethodDefinition text only with symbols this
+    // module actually emitted; the helper also preserves the file-size gate.
+    super::artifact_source_text::extend_class_method_source_text(
+        hir,
+        module_prefix,
+        llmod,
+        &mut user_fn_source,
+    );
+
     // Wall 51: the standalone-ctor arity registered into CLASS_CONSTRUCTORS must
     // match the arity of the ctor function actually emitted above (which, for a
     // no-own-ctor class with heritage, is the synthesized `super(...args)`

crates/perry-codegen/src/codegen/mod.rs

@@ -179,6 +179,7 @@ mod argument_shape_clone_tests;
 pub(crate) mod arguments;
 mod artifact_context;
 mod artifact_display_names;
+mod artifact_source_text;
 mod artifacts;
 mod boxed_locals;
 #[cfg(test)]

crates/perry-hir/src/destructuring/var_decl.rs

@@ -105,7 +105,25 @@ pub(crate) fn lower_var_decl_with_destructuring(
             if let Some(init_ast) = decl.init.as_ref() {
                 result.extend(predeclare_implicit_assignment_targets(ctx, init_ast));
             }
-            let init = decl.init.as_ref().map(|e| lower_expr(ctx, e)).transpose()?;
+            // A simple binding performs NamedEvaluation for an anonymous
+            // function/class initializer (`const C = class {}`). Most class
+            // expressions take stmt.rs's direct class fast path, but a
+            // pre-existing class-registry entry can deliberately divert one
+            // through this generic path (notably the CommonJS factory's
+            // function-scope pre-registration). Preserve the binding name in
+            // that path too; the helper filters out named definitions and
+            // non-NamedEvaluation expressions before installing the context.
+            let init = decl
+                .init
+                .as_ref()
+                .map(|e| {
+                    crate::lower::expr_assign::lower_rhs_with_assignment_name(
+                        ctx,
+                        e,
+                        Some(name.clone()),
+                    )
+                })
+                .transpose()?;
             if matches!(ty, Type::Any) {
                 match &init {
                     Some(Expr::NativeMethodCall { module, method, .. }) => {

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

@@ -56,7 +56,7 @@ pub(crate) fn rhs_accepts_assignment_name(expr: &ast::Expr) -> bool {
     }
 }
 
-fn lower_rhs_with_assignment_name(
+pub(crate) fn lower_rhs_with_assignment_name(
     ctx: &mut LoweringContext,
     rhs: &ast::Expr,
     name: Option<String>,

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

@@ -501,6 +501,19 @@ fn lower_accessor_prop(
     };
 
     let func_id = ctx.fresh_func();
+    // #9468: accessor definitions run SetFunctionName with the `get`/`set`
+    // prefix. Class accessors already acquire this name when reflected from a
+    // descriptor; object-literal accessors are ordinary closure values and
+    // therefore need the same metadata recorded at lowering.
+    if let MethodKeyKind::Static(key) = &accessor_key {
+        let prefix = if setter_param.is_some() {
+            "set "
+        } else {
+            "get "
+        };
+        ctx.closure_display_names
+            .insert(func_id, format!("{prefix}{key}"));
+    }
     let outer_locals: Vec<(String, LocalId)> = ctx
         .locals
         .iter()

crates/perry-hir/src/lower_decl/class_decl.rs

@@ -226,6 +226,28 @@ pub fn lower_class_decl(
             .insert(class_id, class_decl.ident.sym.to_string());
     }
     capture_class_source(ctx, class_id, &class_decl.class);
+    // cjs_wrap rewrites a sole `module.exports = class { ... }` into a
+    // declaration under this reserved key so Perry can hoist and register the
+    // class. The key is compiler-only: the original class expression had no
+    // NamedEvaluation context, therefore its observable `.name` is empty and
+    // its retained source must not expose the injected identifier.
+    const CJS_ANONYMOUS_DEFAULT: &str = "__perry_cjs_default__";
+    if class_decl.ident.sym.as_ref() == CJS_ANONYMOUS_DEFAULT {
+        ctx.class_display_names.insert(class_id, String::new());
+        if let Some(source) = ctx.class_source_text.get_mut(&class_id) {
+            if let Some(after_class) = source.strip_prefix("class") {
+                let trimmed = after_class.trim_start();
+                if let Some(after_name) = trimmed.strip_prefix(CJS_ANONYMOUS_DEFAULT) {
+                    let name_is_complete = after_name.as_bytes().first().is_none_or(|byte| {
+                        !byte.is_ascii_alphanumeric() && *byte != b'_' && *byte != b'$'
+                    });
+                    if name_is_complete {
+                        *source = format!("class{after_name}");
+                    }
+                }
+            }
+        }
+    }
     if let Some(ast::Expr::Ident(parent)) = class_decl.class.super_class.as_deref() {
         if let Some(crate::lower::fn_ctor_env::FnCtorShape::DynCtor(kind)) =
             ctx.fn_ctor_env.entries.get(parent.sym.as_ref()).cloned()

crates/perry-hir/src/lower_decl/class_members.rs

@@ -9,6 +9,40 @@ use crate::lower_types::*;
 
 use super::*;
 
+/// #9468: retain a class member's MethodDefinition source under the FuncId of
+/// its compiled method/accessor body. Unlike ordinary functions, class members
+/// are emitted as raw `perry_method_*` / `perry_static_*` symbols, but the
+/// source registry can still use the same FuncId-to-source handoff.
+///
+/// SWC's ClassMethod span includes the class-only `static` modifier. That
+/// modifier is not part of the function object's [[SourceText]] (`String(C.m)`
+/// starts at the method definition itself), so remove it while preserving the
+/// rest byte-for-byte, including `get`/`set`, `async`, `*`, and comments.
+fn capture_class_method_source(
+    ctx: &mut LoweringContext,
+    func_id: crate::types::FuncId,
+    method: &ast::ClassMethod,
+) {
+    let Some(mut src) = crate::ir::current_module_source_slice(method.span.lo.0, method.span.hi.0)
+    else {
+        return;
+    };
+    if method.is_static {
+        let leading_ws = src.len() - src.trim_start().len();
+        let candidate = &src[leading_ws..];
+        if let Some(after_static) = candidate.strip_prefix("static") {
+            if after_static
+                .as_bytes()
+                .first()
+                .is_some_and(u8::is_ascii_whitespace)
+            {
+                src = after_static.trim_start().to_string();
+            }
+        }
+    }
+    ctx.closure_source_text.insert(func_id, src);
+}
+
 pub fn lower_constructor(
     ctx: &mut LoweringContext,
     class_name: &str,
@@ -670,6 +704,7 @@ pub fn lower_class_method_with_name(
     ctx.exit_type_param_scope();
 
     let func_id = ctx.fresh_func();
+    capture_class_method_source(ctx, func_id, method);
     // Record the param-prologue length for generator methods so the generator
     // transform runs param binding (default guards + destructuring) synchronously
     // at call time per spec FunctionDeclarationInstantiation order. Without this,
@@ -799,8 +834,11 @@ pub fn lower_getter_method_with_name(
     ctx.exit_scope(scope_mark);
     ctx.in_nonarrow_fn = saved_in_nonarrow_fn;
 
+    let func_id = ctx.fresh_func();
+    capture_class_method_source(ctx, func_id, method);
+
     Ok(Function {
-        id: ctx.fresh_func(),
+        id: func_id,
         name,
         type_params: Vec::new(),
         params: Vec::new(),
@@ -967,8 +1005,11 @@ pub fn lower_setter_method_with_name(
     ctx.exit_scope(scope_mark);
     ctx.in_nonarrow_fn = saved_in_nonarrow_fn;
 
+    let func_id = ctx.fresh_func();
+    capture_class_method_source(ctx, func_id, method);
+
     Ok(Function {
-        id: ctx.fresh_func(),
+        id: func_id,
         name,
         type_params: Vec::new(),
         params,

crates/perry-runtime/Cargo.toml

@@ -212,7 +212,7 @@ proc-ipc = []
 intl-locale = ["dep:icu_locale", "dep:icu_locale_core"]
 # CLDR-accurate Intl.DateTimeFormat / toLocaleString date-time patterns and a
 # compiled IANA database for explicit named `timeZone` options.
-intl-datetime = ["dep:icu_datetime", "dep:icu_time", "dep:icu_calendar", "dep:icu_locale_core", "dep:timezone_provider"]
+intl-datetime = ["dep:icu_datetime", "dep:icu_time", "dep:icu_calendar", "dep:icu_locale_core", "dep:timezone_provider", "dep:writeable"]
 # `full` only opt-ins the small Node-API helpers (os.hostname / os.homedir).
 # `postgres`, `redis`, `whoami` were previously listed here but were either
 # unimported (postgres, whoami) or only used by a now-deleted `redis_client.rs`
@@ -347,6 +347,8 @@ icu_locale_core = { version = "2", optional = true }
 icu_datetime = { version = "2", default-features = false, features = ["compiled_data"], optional = true }
 icu_time = { version = "2", default-features = false, features = ["compiled_data"], optional = true }
 icu_calendar = { version = "2", default-features = false, features = ["compiled_data"], optional = true }
+# ICU's semantic field annotations drive Intl.DateTimeFormat#formatToParts.
+writeable = { version = "0.6", optional = true }
 idna = { version = "1", optional = true }
 url = { version = "2", optional = true }
 # #4911: real node:dns resolve*/reverse. hickory-proto provides DNS wire-format

crates/perry-runtime/src/closure/dispatch.rs

@@ -20,7 +20,10 @@ mod errors;
 mod validate;
 mod value_call;
 
-pub(crate) use bound::{coerce_call_this, rebind_explicit_this, reify_function_method_value};
+pub(crate) use bound::{
+    bound_method_source_func_ptr, coerce_call_this, rebind_explicit_this,
+    reify_function_method_value,
+};
 pub use bound::{dispatch_bound_function, dispatch_bound_method, js_function_bind};
 
 pub(crate) use errors::reset_throw_not_callable_counter;