docs(array): point the #7768 placeholders at the real PR number (#7765)

Author: Ralph Küpper

…-receiver-tag-gates-collection-probes.md …-receiver-tag-gates-collection-probes.mdchangelog.d/7768-array-receiver-tag-gates-collection-probes.md renamed to changelog.d/7765-array-receiver-tag-gates-collection-probes.md changelog.d/7768-array-receiver-tag-gates-collection-probes.md renamed to changelog.d/7765-array-receiver-tag-gates-collection-probes.md

@@ -1,4 +1,4 @@
-### Array element reads stop asking whether an array is a Map (#7768)
+### Array element reads stop asking whether an array is a Map (#7765)
 
 `gc-handoff/apps/asyncpipe.ts` — an async service pipeline, and the worst gap in
 the corpus at 13x node — spent **13.5% of its run in `set::is_registered_set` +

crates/perry-runtime/src/array/collection_tag_tests.rs

@@ -1,4 +1,4 @@
-//! Receiver-tag gating of the `Map`/`Set` registry probes (#7768).
+//! Receiver-tag gating of the `Map`/`Set` registry probes (#7765).
 //!
 //! `js_array_get_f64` and `js_array_length` used to ask both collection
 //! registries "is this receiver a Set? a Map?" on every element read of an

crates/perry-runtime/src/array/indexing.rs

@@ -545,7 +545,7 @@ fn array_get_property_by_key(arr: *const ArrayHeader, key: *const crate::StringH
 /// FOR DENSE KEYS/PROPERTY ARRAYS ONLY — general JS arrays may have
 /// `length > capacity` (sparse), where this cap would be incorrect.
 pub(crate) unsafe fn keys_array_len_capped_to_capacity(arr: *const ArrayHeader) -> usize {
-    // #7768: a well-formed dense keys array answers from its own two words.
+    // #7765: a well-formed dense keys array answers from its own two words.
     // `js_array_length` re-derives the same number through a proxy probe, a
     // second header read for its lazy/object arms, and a `clean_arr_ptr`
     // forwarding walk — once per property read on the field-get funnel.
@@ -664,7 +664,7 @@ pub extern "C" fn js_array_length(arr: *const ArrayHeader) -> u32 {
     };
     if !arr.is_null() {
         let addr = arr as usize;
-        // #7768: gate both probes on the receiver's own type tag — see
+        // #7765: gate both probes on the receiver's own type tag — see
         // `js_array_get_f64` for why the tag answers, why it is ABA-proof, and
         // why a header-less buffer receiver still lands on the same result.
         // This reads the byte the `GC_TYPE_LAZY_ARRAY` / `GC_TYPE_OBJECT` block
@@ -895,7 +895,7 @@ pub extern "C" fn js_array_get_f64(arr: *const ArrayHeader, index: u32) -> f64 {
             crate::buffer::js_buffer_get(arr as *const crate::buffer::BufferHeader, index as i32);
         return byte_val as f64;
     }
-    // #7768: ONE `GcHeader` read now gates both collection probes below and
+    // #7765: ONE `GcHeader` read now gates both collection probes below and
     // supplies the descriptor flags further down, which `array_object_flags`
     // used to re-derive through a second `clean_arr_ptr` and a second header
     // read. On `gc-handoff/apps/asyncpipe_big.ts` this call site was 76% of all

crates/perry-runtime/src/map.rs

@@ -193,7 +193,7 @@ fn register_map(ptr: *mut MapHeader, entries: *mut f64, capacity: usize) {
 
 /// Every entry into [`is_registered_map`], i.e. every caller that could not
 /// rule a `Map` out more cheaply. The `js_array_get_f64` / `js_array_length`
-/// receiver-tag gates (#7768) are asserted against this: a plain-array element
+/// receiver-tag gates (#7765) are asserted against this: a plain-array element
 /// read must not move it. Remove those gates and the assertion fails, which is
 /// the point — a fast path nobody can prove ran is not a fast path.
 ///

crates/perry-runtime/src/object/field_get_set/get_field_by_name_tail.rs

@@ -461,7 +461,7 @@ pub(crate) fn get_field_by_name_object_tail(
         // been true since `js_set_alloc` moved to
         // `arena_alloc_gc(_, _, GC_TYPE_SET)`: a registered Set IS a GC
         // allocation and its `obj_type` classifies it. `js_array_get_f64` and
-        // `js_array_length` gate their probes on exactly that byte (#7768);
+        // `js_array_length` gate their probes on exactly that byte (#7765);
         // this receiver is not proven to carry a header at this point, so it
         // still asks the registry.)
         if crate::set::is_registered_set(obj as usize) {

scripts/addr_class_allowlist.txt

@@ -151,4 +151,4 @@ crates/perry-runtime/src/child_process/value_util.rs | * | pre-existing GcHeader
 crates/perry-runtime/src/closure/dispatch/ | * | pre-existing GcHeader probe predating addr_class; address validated by call-site guards (magnitude/registry/is_valid_obj_ptr) -- migrate to addr_class::try_read_gc_header in a follow-up (split of closure/dispatch.rs)
 crates/perry-runtime/src/bun_compat/string_width.rs | 0xE0000..=0xE007F | Unicode "Tags" codepoint block (U+E0000..U+E007F) tested against a char, not a handle-band address
 crates/perry-runtime/src/bun_compat/width_tables.rs | * | pure Unicode East-Asian-width codepoint-range table; every hex literal is a Unicode code point (e.g. U+F0000 / U+100000 SPUA-A/B planes), never a handle-band address
-crates/perry-runtime/src/array/collection_tag_tests.rs | * | unit tests for the #7768 receiver-tag gate: they read AND re-stamp `GcHeader.obj_type` on an address they allocated themselves, which is the whole subject under test. `try_read_gc_header` cannot serve them (it hands out a shared reference, and the recycling test must WRITE the tag to model `arena_alloc_gc` handing the bytes to the next owner).
+crates/perry-runtime/src/array/collection_tag_tests.rs | * | unit tests for the #7765 receiver-tag gate: they read AND re-stamp `GcHeader.obj_type` on an address they allocated themselves, which is the whole subject under test. `try_read_gc_header` cannot serve them (it hands out a shared reference, and the recycling test must WRITE the tag to model `arena_alloc_gc` handing the bytes to the next owner).