refactor(napi/parser, allocator): raw transfer: store buffer size and align as consts (#12275)

Similar to #12268. Instead of hard-coding the size and alignment of raw transfer buffers in multiple places, codegen add these to generated files, and everywhere else import the values from those files. This is more robust.

Author: overlookmotel

.github/generated/ast_changes_watch_list.yml

@@ -3,6 +3,7 @@
 
 src:
   - '.github/generated/ast_changes_watch_list.yml'
+  - 'crates/oxc_allocator/src/generated/fixed_size_constants.rs'
   - 'crates/oxc_ast/src/ast/comment.rs'
   - 'crates/oxc_ast/src/ast/js.rs'
   - 'crates/oxc_ast/src/ast/jsx.rs'
@@ -68,6 +69,7 @@ src:
   - 'napi/parser/generated/lazy/walk.js'
   - 'napi/parser/src/generated/assert_layouts.rs'
   - 'napi/parser/src/generated/derive_estree.rs'
+  - 'napi/parser/src/generated/raw_transfer_constants.rs'
   - 'napi/parser/src/raw_transfer_types.rs'
   - 'npm/oxc-types/types.d.ts'
   - 'tasks/ast_tools/src/**'

crates/oxc_allocator/src/fixed_size.rs

@@ -5,10 +5,12 @@ use std::{
     ptr::NonNull,
 };
 
-use crate::Allocator;
+use crate::{
+    Allocator,
+    fixed_size_constants::{BUFFER_ALIGN, BUFFER_SIZE},
+};
 
 const TWO_GIB: usize = 1 << 31;
-const FOUR_GIB: usize = 1 << 32;
 
 // What we ideally want is an allocation 2 GiB in size, aligned on 4 GiB.
 // But system allocator on Mac OS refuses allocations with 4 GiB alignment.
@@ -25,10 +27,8 @@ const FOUR_GIB: usize = 1 << 32;
 // Could just use that built-in workaround, rather than implementing our own, or allocate a 6 GiB chunk
 // with alignment 16, to skip Rust's built-in workaround.
 // Note: Rust's workaround will likely commit a whole page of memory, just to store the real pointer.
-const ALLOC_SIZE: usize = FOUR_GIB;
+const ALLOC_SIZE: usize = BUFFER_SIZE + TWO_GIB;
 const ALLOC_ALIGN: usize = TWO_GIB;
-const CHUNK_SIZE: usize = TWO_GIB;
-pub const CHUNK_ALIGN: usize = FOUR_GIB;
 
 const ALLOC_LAYOUT: Layout = match Layout::from_size_align(ALLOC_SIZE, ALLOC_ALIGN) {
     Ok(layout) => layout,
@@ -71,12 +71,12 @@ impl FixedSizeAllocator {
             alloc_ptr.add(offset)
         };
 
-        debug_assert!(chunk_ptr.as_ptr() as usize % CHUNK_ALIGN == 0);
+        debug_assert!(chunk_ptr.as_ptr() as usize % BUFFER_ALIGN == 0);
 
-        // SAFETY: Memory region starting at `chunk_ptr` with `CHUNK_SIZE` bytes is within
+        // SAFETY: Memory region starting at `chunk_ptr` with `BUFFER_SIZE` bytes is within
         // the allocation we just made.
         // `chunk_ptr` has high alignment (4 GiB). `size` is large and a high power of 2 (2 GiB).
-        let allocator = unsafe { Allocator::from_raw_parts(chunk_ptr, CHUNK_SIZE) };
+        let allocator = unsafe { Allocator::from_raw_parts(chunk_ptr, BUFFER_SIZE) };
 
         // Store pointer to original allocation, so it can be used to deallocate in `drop`
         Self { allocator: ManuallyDrop::new(allocator), alloc_ptr }

crates/oxc_allocator/src/generated/fixed_size_constants.rs

@@ -0,0 +1,7 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
+
+#![expect(clippy::unreadable_literal)]
+
+pub const BUFFER_SIZE: usize = 2147483648;
+pub const BUFFER_ALIGN: usize = 4294967296;

crates/oxc_allocator/src/lib.rs

@@ -65,3 +65,20 @@ pub use pool::{AllocatorGuard, AllocatorPool};
 pub use string_builder::StringBuilder;
 pub use take_in::{Dummy, TakeIn};
 pub use vec::Vec;
+
+mod generated {
+    #[cfg(all(
+        feature = "fixed_size",
+        not(feature = "disable_fixed_size"),
+        target_pointer_width = "64",
+        target_endian = "little"
+    ))]
+    pub mod fixed_size_constants;
+}
+#[cfg(all(
+    feature = "fixed_size",
+    not(feature = "disable_fixed_size"),
+    target_pointer_width = "64",
+    target_endian = "little"
+))]
+use generated::fixed_size_constants;

crates/oxc_allocator/src/pool.rs

@@ -117,10 +117,7 @@ mod wrapper {
     target_endian = "little"
 ))]
 mod wrapper {
-    use crate::{
-        Allocator,
-        fixed_size::{CHUNK_ALIGN, FixedSizeAllocator},
-    };
+    use crate::{Allocator, fixed_size::FixedSizeAllocator, fixed_size_constants::BUFFER_ALIGN};
 
     /// Structure which wraps an [`Allocator`] with fixed size of 2 GiB, and aligned on 4 GiB.
     ///
@@ -144,12 +141,12 @@ mod wrapper {
             self.0.reset();
 
             // Set data pointer back to start.
-            // SAFETY: Fixed-size allocators have data pointer originally aligned on `CHUNK_ALIGN`,
-            // and size less than `CHUNK_ALIGN`. So we can restore original data pointer by rounding down
-            // to next multiple of `CHUNK_ALIGN`.
+            // SAFETY: Fixed-size allocators have data pointer originally aligned on `BUFFER_ALIGN`,
+            // and size less than `BUFFER_ALIGN`. So we can restore original data pointer by rounding down
+            // to next multiple of `BUFFER_ALIGN`.
             unsafe {
                 let data_ptr = self.0.data_ptr();
-                let offset = data_ptr.as_ptr() as usize % CHUNK_ALIGN;
+                let offset = data_ptr.as_ptr() as usize % BUFFER_ALIGN;
                 let data_ptr = data_ptr.sub(offset);
                 self.0.set_data_ptr(data_ptr);
             }

napi/parser/generated/constants.js

@@ -1,8 +1,16 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
 
-const DATA_POINTER_POS_32 = 536870908,
+const BUFFER_SIZE = 2147483648,
+  BUFFER_ALIGN = 4294967296,
+  DATA_POINTER_POS_32 = 536870908,
   IS_TS_FLAG_POS = 2147483636,
   PROGRAM_OFFSET = 0;
 
-module.exports = { DATA_POINTER_POS_32, IS_TS_FLAG_POS, PROGRAM_OFFSET };
+module.exports = {
+  BUFFER_SIZE,
+  BUFFER_ALIGN,
+  DATA_POINTER_POS_32,
+  IS_TS_FLAG_POS,
+  PROGRAM_OFFSET,
+};

napi/parser/raw-transfer/common.js

@@ -7,7 +7,7 @@ const {
   parseAsyncRaw: parseAsyncRawBinding,
   getBufferOffset,
 } = require('../bindings.js');
-const { IS_TS_FLAG_POS } = require('../generated/constants.js');
+const { BUFFER_SIZE, BUFFER_ALIGN, IS_TS_FLAG_POS } = require('../generated/constants.js');
 
 module.exports = {
   parseSyncRawImpl,
@@ -141,9 +141,8 @@ async function parseAsyncRawImpl(filename, sourceText, options, convert) {
   return data;
 }
 
-const ONE_GIB = 1 << 30,
-  TWO_GIB = ONE_GIB * 2,
-  SIX_GIB = ONE_GIB * 6;
+const ARRAY_BUFFER_SIZE = BUFFER_SIZE + BUFFER_ALIGN;
+const ONE_GIB = 1 << 30;
 
 // We keep a cache of buffers for raw transfer, so we can reuse them as much as possible.
 //
@@ -277,10 +276,10 @@ function clearBuffersCache() {
  * @returns {Uint8Array} - Buffer
  */
 function createBuffer() {
-  const arrayBuffer = new ArrayBuffer(SIX_GIB);
+  const arrayBuffer = new ArrayBuffer(ARRAY_BUFFER_SIZE);
   const offset = getBufferOffset(new Uint8Array(arrayBuffer));
-  const buffer = new Uint8Array(arrayBuffer, offset, TWO_GIB);
-  buffer.uint32 = new Uint32Array(arrayBuffer, offset, TWO_GIB / 4);
-  buffer.float64 = new Float64Array(arrayBuffer, offset, TWO_GIB / 8);
+  const buffer = new Uint8Array(arrayBuffer, offset, BUFFER_SIZE);
+  buffer.uint32 = new Uint32Array(arrayBuffer, offset, BUFFER_SIZE / 4);
+  buffer.float64 = new Float64Array(arrayBuffer, offset, BUFFER_SIZE / 8);
   return buffer;
 }

napi/parser/src/generated/raw_transfer_constants.rs

@@ -0,0 +1,7 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
+
+#![expect(clippy::unreadable_literal)]
+
+pub const BUFFER_SIZE: usize = 2147483648;
+pub const BUFFER_ALIGN: usize = 4294967296;

napi/parser/src/lib.rs

@@ -49,7 +49,11 @@ mod generated {
     // Note: We intentionally don't import `generated/derive_estree.rs`. It's not needed.
     #[cfg(debug_assertions)]
     pub mod assert_layouts;
+    #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+    pub mod raw_transfer_constants;
 }
+#[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+use generated::raw_transfer_constants;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum AstType {

napi/parser/src/raw_transfer.rs

@@ -19,6 +19,7 @@ use oxc_napi::get_source_type;
 
 use crate::{
     AstType, ParserOptions, get_ast_type, parse,
+    raw_transfer_constants::{BUFFER_ALIGN, BUFFER_SIZE},
     raw_transfer_types::{EcmaScriptModule, Error, RawTransferData},
 };
 
@@ -35,22 +36,19 @@ use crate::{
 // 2. JS bitwise operators work only on signed 32-bit integers, with 32nd bit as sign bit.
 //    So avoiding the 32nd bit being set enables using `>>` bitshift operator, which may be cheaper
 //    than `>>>`, without offsets being interpreted as negative.
-const TWO_GIB: usize = 1 << 31;
-const FOUR_GIB: usize = 1 << 32;
 
-const BUFFER_SIZE: usize = TWO_GIB;
-const BUFFER_ALIGN: usize = FOUR_GIB;
 const BUMP_ALIGN: usize = 16;
 
-/// Get offset within a `Uint8Array` which is aligned on 4 GiB.
+/// Get offset within a `Uint8Array` which is aligned on `BUFFER_ALIGN`.
 ///
 /// Does not check that the offset is within bounds of `buffer`.
-/// To ensure it always is, provide a `Uint8Array` of at least 4 GiB size.
+/// To ensure it always is, provide a `Uint8Array` of at least `BUFFER_SIZE` bytes.
 #[napi(skip_typescript)]
 pub fn get_buffer_offset(buffer: Uint8Array) -> u32 {
     let buffer = &*buffer;
-    let buffer_addr32 = buffer.as_ptr() as u32;
-    0u32.wrapping_sub(buffer_addr32)
+    let offset = BUFFER_ALIGN - (buffer.as_ptr() as usize % BUFFER_ALIGN);
+    #[expect(clippy::cast_possible_truncation)]
+    return offset as u32;
 }
 
 /// Parse AST into provided `Uint8Array` buffer, synchronously.