merge: land #8661, #8656, #8666, #8662, #8660

.github/workflows/test.yml

@@ -3169,7 +3169,7 @@ jobs:
       - name: Run Effect fixture
         run: |
           cd tests/release/packages/effect-basic
-          PERRY_EFFECT_BASIC_ADVISORY=1 PERRY_BIN="$GITHUB_WORKSPACE/target/release/perry" bash fixture.sh
+          PERRY_BIN="$GITHUB_WORKSPACE/target/release/perry" bash fixture.sh
 
       - name: Upload Effect fixture logs
         if: always()

Cargo.toml

@@ -372,6 +372,7 @@ libc = "0.2"
 lazy_static = "1.5"
 chrono = "0.4"
 regex = "1.12"
+regress = "0.11.1"
 hex = "0.4"
 tempfile = "3"
 itoa = "1.0"

changelog.d/8656-collator-compare-accessor.md

@@ -0,0 +1,2 @@
+`Intl.Collator.prototype.compare` is now exposed as an accessor returning a
+bound function, matching the spec's getter shape rather than a plain method.

changelog.d/8660-regexp-repeat-matcher.md

@@ -0,0 +1 @@
+Fixed RegExp quantified capture groups to follow ECMA-262 RepeatMatcher semantics, including clearing skipped captures and discarding empty optional iterations.

changelog.d/8661-effect-advisory-cleanup.md

@@ -0,0 +1 @@
+Removed a stale Effect advisory entry from the package test expectations.

changelog.d/8662-5895-review-followups.md

@@ -0,0 +1 @@
+Addressed the #5895 review follow-ups.

changelog.d/8666-imported-static-update-share.md

@@ -0,0 +1,2 @@
+Shared the imported-static update path in codegen instead of re-emitting it per
+call site.

crates/perry-codegen/src/expr/member_update.rs

@@ -43,7 +43,7 @@ use crate::nanbox::POINTER_MASK_I64;
 use crate::rooting::{self, Repr};
 use crate::types::{DOUBLE, I32, I64, I8};
 
-use super::{lower_expr, FnCtx};
+use super::{emit_root_nanbox_store_on_block, lower_expr, FnCtx};
 
 pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
     match expr {
@@ -57,6 +57,107 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
             prefix,
             strict,
         } => {
+            // #8654: a statically-known class field has one canonical LLVM
+            // global shared by its defining module and every importer.
+            // `Class.field = value` already lowers through `StaticFieldSet`
+            // and updates that global, but `Class.field++` used the generic
+            // class-object side table instead. The two stores then diverged:
+            // direct reads kept seeing the initialized global while the
+            // update read `undefined` from (and wrote `NaN` to) the side
+            // table. Perform the RMW on the shared global and mirror the new
+            // value into the side table for genuinely dynamic reads.
+            let static_class_name = match object.as_ref() {
+                Expr::ClassRef(class_name) => Some(class_name),
+                // Imported class bindings are represented as an extern ref
+                // until codegen resolves their source-module metadata.
+                Expr::ExternFuncRef { name, .. } => Some(name),
+                _ => None,
+            };
+            if let Some(class_name) = static_class_name {
+                let key = (class_name.clone(), property.clone());
+                if let Some(global_name) = ctx.static_field_globals.get(&key).cloned() {
+                    let global_ref = format!("@{global_name}");
+                    let old = ctx.block().load(DOUBLE, &global_ref);
+                    let old_num = ctx.block().call(DOUBLE, "js_to_numeric", &[(DOUBLE, &old)]);
+
+                    // A postfix BigInt result remains live across the
+                    // allocating numeric step and the runtime-table mirror.
+                    // Keep it in a function-lifetime root: a temporary root
+                    // cannot be released before its final load escapes this
+                    // lowering, because `root_reload` may otherwise rederive
+                    // that load after the pooled slot has been reused.
+                    let postfix_result = if *prefix {
+                        None
+                    } else {
+                        let old_bits = ctx.block().bitcast_double_to_i64(&old_num);
+                        let top16 = ctx.block().lshr(I64, &old_bits, "48");
+                        let is_bigint =
+                            ctx.block()
+                                .icmp_eq(I64, &top16, crate::nanbox::BIGINT_TAG_TOP16_I64);
+                        let rooted_bits = ctx.block().select(
+                            crate::types::I1,
+                            &is_bigint,
+                            I64,
+                            &old_bits,
+                            crate::nanbox::TAG_UNDEFINED_I64,
+                        );
+                        let slot = ctx.func.alloca_entry(I64);
+                        ctx.func.entry_allocas_push_store(
+                            I64,
+                            crate::nanbox::TAG_UNDEFINED_I64,
+                            &slot,
+                        );
+                        ctx.block().store(I64, &rooted_bits, &slot);
+                        super::root_entry_alloca(ctx, &slot);
+                        Some((slot, is_bigint))
+                    };
+
+                    let step_arg = match op {
+                        BinaryOp::Sub => "0",
+                        _ => "1",
+                    };
+                    let new = ctx.block().call(
+                        DOUBLE,
+                        "js_numeric_step",
+                        &[(DOUBLE, &old_num), (I32, step_arg)],
+                    );
+                    emit_root_nanbox_store_on_block(ctx.block(), &new, &global_ref);
+
+                    if let Some(&class_id) = ctx.class_ids.get(class_name) {
+                        let field_idx = ctx.strings.intern(property);
+                        let field = ctx.strings.entry(field_idx);
+                        let bytes_ref = format!("@{}", field.bytes_global);
+                        let byte_len = field.byte_len.to_string();
+                        let class_id = class_id.to_string();
+                        // Reload from the registered root after the root
+                        // barrier: a moving collection may rewrite it.
+                        let mirrored = ctx.block().load(DOUBLE, &global_ref);
+                        ctx.block().call_void(
+                            "js_class_register_static_field",
+                            &[
+                                (I32, &class_id),
+                                (crate::types::PTR, &bytes_ref),
+                                (I64, &byte_len),
+                                (DOUBLE, &mirrored),
+                            ],
+                        );
+                    }
+
+                    return Ok(if let Some((slot, is_bigint)) = postfix_result {
+                        let rooted_bits = ctx.block().load(I64, &slot);
+                        let rooted_result = ctx.block().bitcast_i64_to_double(&rooted_bits);
+                        ctx.block().select(
+                            crate::types::I1,
+                            &is_bigint,
+                            DOUBLE,
+                            &rooted_result,
+                            &old_num,
+                        )
+                    } else {
+                        ctx.block().load(DOUBLE, &global_ref)
+                    });
+                }
+            }
             // Scalar replacement fast path: load → fadd/fsub 1.0 → store
             // on the field's alloca, no heap traffic.
             if let Expr::LocalGet(id) = object.as_ref() {

crates/perry-codegen/src/expr/this_super_call.rs

@@ -806,6 +806,7 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                             None => double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)),
                         };
                         lower_event_emitter_subclass_init(ctx, &this_box);
+                        bind_derived_this_after_super(ctx);
                         let current_class_name =
                             ctx.class_stack.last().cloned().unwrap_or_default();
                         crate::lower_call::apply_field_initializers_recursive(
@@ -1162,6 +1163,14 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                     &this_box,
                     &lowered_args,
                 );
+                // The native base initialized the provisional receiver, so a
+                // successful super() must now initialize the derived `this`
+                // binding before field initializers or the remaining
+                // constructor body can observe it. Without this, an indirect
+                // chain such as Counter -> B -> EventEmitter installed the
+                // emitter surface but the next `this.seen = ...` still threw
+                // the pre-super ReferenceError.
+                bind_derived_this_after_super(ctx);
                 // Spec: derived-class field initializers run AFTER `super()`
                 // returns. The native base is the chain root and has no TS
                 // fields, so everything after it still needs initializing —

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

@@ -1500,6 +1500,32 @@ pub(super) fn lower_new(ctx: &mut LoweringContext, new_expr: &ast::NewExpr) -> R
                 // via `js_new_function_construct` — see
                 // `perry-codegen/src/lower_call/new.rs`.
             }
+            // A named native-module export whose public name is not a class
+            // name still has a real runtime function value. Route `new` over
+            // that value through the dynamic constructor check instead of the
+            // static `Expr::New { class_name }` fallback, which would merely
+            // allocate an empty placeholder. This is where Node distinguishes
+            // constructable JavaScript wrappers (`repl.start`, `events.init`)
+            // from native non-constructors (`path.toNamespacedPath`). The
+            // runtime's explicit export metadata makes that decision. Keep
+            // capitalized class exports on the specialized paths below.
+            if let Some((module, Some(export))) = ctx.lookup_native_module(&class_name) {
+                if export
+                    .chars()
+                    .next()
+                    .is_some_and(|first| !first.is_uppercase())
+                {
+                    return Ok(Expr::NewDynamic {
+                        callee: Box::new(Expr::PropertyGet {
+                            byte_offset: 0,
+                            object: Box::new(Expr::NativeModuleRef(module.to_string())),
+                            property: export.to_string(),
+                        }),
+                        args,
+                        byte_offset: new_byte_offset,
+                    });
+                }
+            }
             // #wall: an ALIASED named import of a native built-in class
             // (`import { BlockList as Wj4 } from "net"; new Wj4()`) must
             // construct exactly like the un-aliased form. The bare-ident