chore: binding cleanup (#1551)

.github/workflows/ci.yml

@@ -202,7 +202,7 @@ jobs:
         if: startsWith(matrix.config.os, 'ubuntu')
         run: |
           sudo apt-get install -y clang-format
-          clang-format --verbose --Werror --dry-run src/*.cc src/*.hpp
+          clang-format --verbose --Werror --dry-run src/*.cc src/*.hpp src/*.h
 
       - name: Test (ASAN)
         env:

build.rs

@@ -151,9 +151,10 @@ fn build_binding() {
   let bindings = bindgen::Builder::default()
     .header("src/binding.hpp")
     .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
-    .clang_args(["-x", "c++", "-std=c++20", "-Iv8/include"])
+    .clang_args(["-x", "c++", "-std=c++20", "-Iv8/include", "-I."])
     .clang_args(args)
-    .allowlist_item("RUST_.*")
+    .allowlist_item("v8__.*")
+    .allowlist_item("cppgc__.*")
     .generate()
     .expect("Unable to generate bindings");
 

src/binding.cc

@@ -411,6 +411,10 @@ void v8__TracedReference__CONSTRUCT(
   construct_in_place<v8::TracedReference<v8::Data>>(buf);
 }
 
+void v8__TracedReference__DESTRUCT(v8::TracedReference<v8::Data>* self) {
+  self->~TracedReference();
+}
+
 void v8__TracedReference__Reset(v8::TracedReference<v8::Data>* self,
                                 v8::Isolate* isolate, const v8::Data* other) {
   self->Reset(isolate, ptr_to_local(other));
@@ -519,9 +523,6 @@ uint32_t v8__ScriptCompiler__CachedDataVersionTag() {
 size_t v8__TypedArray__Length(const v8::TypedArray* self) {
   return ptr_to_local(self)->Length();
 }
-size_t v8__TypedArray__kMaxByteLength() {
-  return v8::TypedArray::kMaxByteLength;
-}
 
 bool v8__Data__EQ(const v8::Data& self, const v8::Data& other) {
   return ptr_to_local(&self) == ptr_to_local(&other);
@@ -1009,8 +1010,6 @@ int v8__Name__GetIdentityHash(const v8::Name& self) {
   return ptr_to_local(&self)->GetIdentityHash();
 }
 
-size_t v8__String__kMaxLength() { return v8::String::kMaxLength; }
-
 const v8::String* v8__String__Empty(v8::Isolate* isolate) {
   return local_to_ptr(v8::String::Empty(isolate));
 }
@@ -2555,20 +2554,8 @@ void v8__AllowJavascriptExecutionScope__DESTRUCT(
                                     size_t byte_offset, size_t length) { \
     return local_to_ptr(                                                 \
         v8::NAME::New(ptr_to_local(&buf_ptr), byte_offset, length));     \
-  }                                                                      \
+  }
-  size_t v8__##NAME##__kMaxLength() { return v8::NAME::kMaxLength; }
+EACH_TYPED_ARRAY(V)
-
-V(Uint8Array)
-V(Uint8ClampedArray)
-V(Int8Array)
-V(Uint16Array)
-V(Int16Array)
-V(Uint32Array)
-V(Int32Array)
-V(Float32Array)
-V(Float64Array)
-V(BigUint64Array)
-V(BigInt64Array)
 #undef V
 
 const v8::Script* v8__Script__Compile(const v8::Context& context,

src/binding.hpp

@@ -1,23 +1,30 @@
 #include <v8-cppgc.h>
 #include <v8-message.h>
+#include <v8-typed-array.h>
+
+#include "support.h"
 
 /**
  * Types defined here will be compiled with bindgen
  * and made available in `crate::binding` in rust.
  */
 
-namespace {
-
 class RustObj;
 
-}
+static size_t v8__ScriptOrigin_SIZE = sizeof(v8::ScriptOrigin);
 
-static size_t RUST_v8__ScriptOrigin_SIZE = sizeof(v8::ScriptOrigin);
+static size_t cppgc__Member_SIZE = sizeof(cppgc::Member<RustObj>);
+static size_t cppgc__WeakMember_SIZE = sizeof(cppgc::WeakMember<RustObj>);
 
-static size_t RUST_cppgc__Member_SIZE = sizeof(cppgc::Member<RustObj>);
+static size_t v8__TracedReference_SIZE = sizeof(v8::TracedReference<v8::Data>);
-static size_t RUST_cppgc__WeakMember_SIZE = sizeof(cppgc::WeakMember<RustObj>);
 
-static size_t RUST_v8__TracedReference_SIZE =
+static size_t v8__String__ValueView_SIZE = sizeof(v8::String::ValueView);
-    sizeof(v8::TracedReference<v8::Data>);
 
-static size_t RUST_v8__String__ValueView_SIZE = sizeof(v8::String::ValueView);
+static int v8__String__kMaxLength = v8::String::kMaxLength;
+
+static size_t v8__TypedArray__kMaxByteLength = v8::TypedArray::kMaxByteLength;
+
+#define TYPED_ARRAY_MAX_LENGTH(name) \
+  static size_t v8__##name##__kMaxLength = v8::name::kMaxLength;
+EACH_TYPED_ARRAY(TYPED_ARRAY_MAX_LENGTH)
+#undef TYPED_ARRAY_MAX_LENGTH

src/cppgc.rs

@@ -337,7 +337,7 @@ macro_rules! member {
   ($( # $attr:tt )* $name:ident) => {
     paste::paste! {
       #[repr(transparent)]
-      struct [< $name Inner >]([u8; crate::binding:: [< RUST_cppgc__ $name _SIZE >]]);
+      struct [< $name Inner >]([u8; crate::binding:: [< cppgc__ $name _SIZE >]]);
 
       impl [< $name Inner >] {
         fn new(ptr: *mut RustObj) -> Self {

src/handle.rs

@@ -37,6 +37,7 @@ extern "C" {
   );
 
   fn v8__TracedReference__CONSTRUCT(this: *mut TracedReference<Data>);
+  fn v8__TracedReference__DESTRUCT(this: *mut TracedReference<Data>);
   fn v8__TracedReference__Reset(
     this: *mut TracedReference<Data>,
     isolate: *mut Isolate,
@@ -1037,7 +1038,7 @@ impl FinalizerMap {
 /// reclaimed. For more details see BasicTracedReference.
 #[repr(C)]
 pub struct TracedReference<T> {
-  data: [u8; crate::binding::RUST_v8__TracedReference_SIZE],
+  data: [u8; crate::binding::v8__TracedReference_SIZE],
   _phantom: PhantomData<T>,
 }
 
@@ -1089,3 +1090,13 @@ impl<T> TracedReference<T> {
     }
   }
 }
+
+impl<T> Drop for TracedReference<T> {
+  fn drop(&mut self) {
+    unsafe {
+      v8__TracedReference__DESTRUCT(
+        self as *mut Self as *mut TracedReference<Data>,
+      );
+    }
+  }
+}

src/script.rs

@@ -15,7 +15,7 @@ use crate::Value;
 #[repr(C)]
 #[derive(Debug)]
 pub struct ScriptOrigin<'s>(
-  [u8; crate::binding::RUST_v8__ScriptOrigin_SIZE],
+  [u8; crate::binding::v8__ScriptOrigin_SIZE],
   PhantomData<&'s ()>,
 );
 

src/string.rs

@@ -1,3 +1,4 @@
+use crate::binding::v8__String__kMaxLength;
 use crate::support::char;
 use crate::support::int;
 use crate::support::size_t;
@@ -16,8 +17,6 @@ use std::ptr::NonNull;
 use std::slice;
 
 extern "C" {
-  fn v8__String__kMaxLength() -> size_t;
-
   fn v8__String__Empty(isolate: *mut Isolate) -> *const String;
 
   fn v8__String__NewFromUtf8(
@@ -329,10 +328,7 @@ impl String {
   /// The maximum length (in bytes) of a buffer that a v8::String can be built
   /// from. Attempting to create a v8::String from a larger buffer will result
   /// in None being returned.
-  #[inline(always)]
+  pub const MAX_LENGTH: usize = v8__String__kMaxLength as _;
-  pub fn max_length() -> usize {
-    unsafe { v8__String__kMaxLength() }
-  }
 
   #[inline(always)]
   pub fn empty<'s>(scope: &mut HandleScope<'s, ()>) -> Local<'s, String> {
@@ -967,7 +963,7 @@ pub enum ValueViewData<'s> {
 /// V8 strings are either encoded as one-byte or two-bytes per character.
 #[repr(C)]
 pub struct ValueView<'s>(
-  [u8; crate::binding::RUST_v8__String__ValueView_SIZE],
+  [u8; crate::binding::v8__String__ValueView_SIZE],
   PhantomData<&'s ()>,
 );
 

src/support.h

@@ -176,4 +176,17 @@ struct three_pointers_t {
 
 }  // namespace support
 
+#define EACH_TYPED_ARRAY(V) \
+  V(Uint8Array)             \
+  V(Uint8ClampedArray)      \
+  V(Int8Array)              \
+  V(Uint16Array)            \
+  V(Int16Array)             \
+  V(Uint32Array)            \
+  V(Int32Array)             \
+  V(Float32Array)           \
+  V(Float64Array)           \
+  V(BigUint64Array)         \
+  V(BigInt64Array)
+
 #endif  // SUPPORT_H_

src/typed_array.rs

@@ -1,22 +1,20 @@
 // Copyright 2019-2021 the Deno authors. All rights reserved. MIT license.
+use crate::binding::v8__TypedArray__kMaxByteLength;
 use crate::support::size_t;
 use crate::ArrayBuffer;
 use crate::HandleScope;
 use crate::Local;
 use crate::TypedArray;
+use paste::paste;
 
 extern "C" {
-  fn v8__TypedArray__kMaxByteLength() -> size_t;
   fn v8__TypedArray__Length(this: *const TypedArray) -> size_t;
 }
 
 impl TypedArray {
   /// The largest supported typed array byte size. Each subclass defines a
   /// type-specific max_length for the maximum length that can be passed to new.
-  #[inline(always)]
+  pub const MAX_BYTE_LENGTH: usize = v8__TypedArray__kMaxByteLength;
-  pub fn max_byte_length() -> usize {
-    unsafe { v8__TypedArray__kMaxByteLength() }
-  }
 
   /// Number of elements in this typed array
   /// (e.g. for Int16Array, |ByteLength|/2).
@@ -27,75 +25,42 @@ impl TypedArray {
 }
 
 macro_rules! typed_array {
-  ($name:ident, $new_func:ident, $max_length_func:ident) => {
+  ($name:ident) => {
-    use crate::$name;
+    paste! {
-    impl $name {
+      use crate::$name;
-      #[inline(always)]
+      impl $name {
-      pub fn new<'s>(
+        #[inline(always)]
-        scope: &mut HandleScope<'s>,
+        pub fn new<'s>(
-        buf: Local<ArrayBuffer>,
+          scope: &mut HandleScope<'s>,
-        byte_offset: usize,
+          buf: Local<ArrayBuffer>,
-        length: usize,
+          byte_offset: usize,
-      ) -> Option<Local<'s, $name>> {
+          length: usize,
-        extern "C" {
+        ) -> Option<Local<'s, $name>> {
-          fn $new_func(
+          extern "C" {
-            buf_ptr: *const ArrayBuffer,
+            fn [< v8__ $name __New >](
-            byte_offset: usize,
+              buf_ptr: *const ArrayBuffer,
-            length: usize,
+              byte_offset: usize,
-          ) -> *const $name;
+              length: usize,
+            ) -> *const $name;
+          }
+          unsafe { scope.cast_local(|_| [< v8__ $name __New >](&*buf, byte_offset, length)) }
         }
-        unsafe { scope.cast_local(|_| $new_func(&*buf, byte_offset, length)) }
-      }
 
-      #[doc = concat!("The largest ", stringify!($name), " size that can be constructed using `new`.")]
+        #[doc = concat!("The largest ", stringify!($name), " size that can be constructed using `new`.")]
-      #[inline(always)]
+        pub const MAX_LENGTH: usize = crate::binding::[< v8__ $name __kMaxLength >];
-      pub fn max_length() -> usize {
-        extern "C" {
-          fn $max_length_func() -> usize;
-        }
-        unsafe { $max_length_func() }
       }
-
     }
   };
 }
 
-typed_array!(Uint8Array, v8__Uint8Array__New, v8__Uint8Array__kMaxLength);
+typed_array!(Uint8Array);
-typed_array!(
+typed_array!(Uint8ClampedArray);
-  Uint8ClampedArray,
+typed_array!(Int8Array);
-  v8__Uint8ClampedArray__New,
+typed_array!(Uint16Array);
-  v8__Uint8ClampedArray__kMaxLength
+typed_array!(Int16Array);
-);
+typed_array!(Uint32Array);
-typed_array!(Int8Array, v8__Int8Array__New, v8__Int8Array__kMaxLength);
+typed_array!(Int32Array);
-typed_array!(
+typed_array!(Float32Array);
-  Uint16Array,
+typed_array!(Float64Array);
-  v8__Uint16Array__New,
+typed_array!(BigUint64Array);
-  v8__Uint16Array__kMaxLength
+typed_array!(BigInt64Array);
-);
-typed_array!(Int16Array, v8__Int16Array__New, v8__Int16Array__kMaxLength);
-typed_array!(
-  Uint32Array,
-  v8__Uint32Array__New,
-  v8__Uint32Array__kMaxLength
-);
-typed_array!(Int32Array, v8__Int32Array__New, v8__Int32Array__kMaxLength);
-typed_array!(
-  Float32Array,
-  v8__Float32Array__New,
-  v8__Float32Array__kMaxLength
-);
-typed_array!(
-  Float64Array,
-  v8__Float64Array__New,
-  v8__Float64Array__kMaxLength
-);
-typed_array!(
-  BigUint64Array,
-  v8__BigUint64Array__New,
-  v8__BigUint64Array__kMaxLength
-);
-typed_array!(
-  BigInt64Array,
-  v8__BigInt64Array__New,
-  v8__BigInt64Array__kMaxLength
-);

tests/test_api.rs

@@ -320,7 +320,7 @@ fn test_string() {
   }
   {
     let scope = &mut v8::HandleScope::new(isolate);
-    let mut buffer = Vec::with_capacity(v8::String::max_length());
+    let mut buffer = Vec::with_capacity(v8::String::MAX_LENGTH);
     for _ in 0..buffer.capacity() / 4 {
       // U+10348 in UTF-8
       buffer.push(0xF0_u8);
@@ -332,13 +332,13 @@ fn test_string() {
       v8::String::new_from_utf8(scope, &buffer, v8::NewStringType::Normal)
         .unwrap();
     // U+10348 is 2 UTF-16 code units, which is the unit of v8::String.length().
-    assert_eq!(v8::String::max_length() / 2, local.length());
+    assert_eq!(v8::String::MAX_LENGTH / 2, local.length());
     assert_eq!(
       buffer.as_slice(),
       local.to_rust_string_lossy(scope).as_bytes()
     );
 
-    let mut too_long = Vec::with_capacity(v8::String::max_length() + 4);
+    let mut too_long = Vec::with_capacity(v8::String::MAX_LENGTH + 4);
     for _ in 0..too_long.capacity() / 4 {
       // U+10348 in UTF-8
       too_long.push(0xF0_u8);
@@ -5766,109 +5766,109 @@ fn typed_array_constructors() {
   assert!(t.is_uint8_array());
   assert_eq!(t.length(), 0);
 
-  // Uint8Array::max_length() ought to be 1 << 53 - 1 on 64 bits when heap
+  // Uint8Array::MAX_LENGTH ought to be 1 << 53 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 53) - 1, v8::Uint8Array::max_length());
+  assert_eq!((1 << 53) - 1, v8::Uint8Array::MAX_LENGTH);
 
   let t = v8::Uint8ClampedArray::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_uint8_clamped_array());
   assert_eq!(t.length(), 0);
 
-  // Uint8ClampedArray::max_length() ought to be 1 << 53 - 1 on 64 bits when
+  // Uint8ClampedArray::MAX_LENGTH ought to be 1 << 53 - 1 on 64 bits when
   // heap sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 53) - 1, v8::Uint8ClampedArray::max_length());
+  assert_eq!((1 << 53) - 1, v8::Uint8ClampedArray::MAX_LENGTH);
 
   let t = v8::Int8Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_int8_array());
   assert_eq!(t.length(), 0);
 
-  // Int8Array::max_length() ought to be 1 << 53 - 1 on 64 bits when heap
+  // Int8Array::MAX_LENGTH ought to be 1 << 53 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 53) - 1, v8::Int8Array::max_length());
+  assert_eq!((1 << 53) - 1, v8::Int8Array::MAX_LENGTH);
 
   let t = v8::Uint16Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_uint16_array());
   assert_eq!(t.length(), 0);
 
-  // Uint16Array::max_length() ought to be 1 << 52 - 1 on 64 bits when heap
+  // Uint16Array::MAX_LENGTH ought to be 1 << 52 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 52) - 1, v8::Uint16Array::max_length());
+  assert_eq!((1 << 52) - 1, v8::Uint16Array::MAX_LENGTH);
 
   let t = v8::Int16Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_int16_array());
   assert_eq!(t.length(), 0);
 
-  // Int16Array::max_length() ought to be 1 << 52 - 1 on 64 bits when heap
+  // Int16Array::MAX_LENGTH ought to be 1 << 52 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 52) - 1, v8::Int16Array::max_length());
+  assert_eq!((1 << 52) - 1, v8::Int16Array::MAX_LENGTH);
 
   let t = v8::Uint32Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_uint32_array());
   assert_eq!(t.length(), 0);
 
-  // Uint32Array::max_length() ought to be 1 << 51 - 1 on 64 bits when heap
+  // Uint32Array::MAX_LENGTH ought to be 1 << 51 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 51) - 1, v8::Uint32Array::max_length());
+  assert_eq!((1 << 51) - 1, v8::Uint32Array::MAX_LENGTH);
 
   let t = v8::Int32Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_int32_array());
   assert_eq!(t.length(), 0);
 
-  // Int32Array::max_length() ought to be 1 << 51 - 1 on 64 bits when heap
+  // Int32Array::MAX_LENGTH ought to be 1 << 51 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 51) - 1, v8::Int32Array::max_length());
+  assert_eq!((1 << 51) - 1, v8::Int32Array::MAX_LENGTH);
 
   let t = v8::Float32Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_float32_array());
   assert_eq!(t.length(), 0);
 
-  // Float32Array::max_length() ought to be 1 << 51 - 1 on 64 bits when heap
+  // Float32Array::MAX_LENGTH ought to be 1 << 51 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 51) - 1, v8::Float32Array::max_length());
+  assert_eq!((1 << 51) - 1, v8::Float32Array::MAX_LENGTH);
 
   let t = v8::Float64Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_float64_array());
   assert_eq!(t.length(), 0);
 
-  // Float64Array::max_length() ought to be 1 << 50 - 1 on 64 bits when heap
+  // Float64Array::MAX_LENGTH ought to be 1 << 50 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 50) - 1, v8::Float64Array::max_length());
+  assert_eq!((1 << 50) - 1, v8::Float64Array::MAX_LENGTH);
 
   let t = v8::BigUint64Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_big_uint64_array());
   assert_eq!(t.length(), 0);
 
-  // BigUint64Array::max_length() ought to be 1 << 50 - 1 on 64 bits when heap
+  // BigUint64Array::MAX_LENGTH ought to be 1 << 50 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 50) - 1, v8::BigUint64Array::max_length());
+  assert_eq!((1 << 50) - 1, v8::BigUint64Array::MAX_LENGTH);
 
   let t = v8::BigInt64Array::new(scope, ab, 0, 0).unwrap();
   assert!(t.is_big_int64_array());
   assert_eq!(t.length(), 0);
 
-  // BigInt64Array::max_length() ought to be 1 << 50 - 1 on 64 bits when heap
+  // BigInt64Array::MAX_LENGTH ought to be 1 << 50 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 50) - 1, v8::BigInt64Array::max_length());
+  assert_eq!((1 << 50) - 1, v8::BigInt64Array::MAX_LENGTH);
 
-  // TypedArray::max_byte_length() ought to be 1 << 53 - 1 on 64 bits when heap
+  // TypedArray::MAX_BYTE_LENGTH ought to be 1 << 53 - 1 on 64 bits when heap
   // sandbox is disabled.
   #[cfg(target_pointer_width = "64")]
-  assert_eq!((1 << 53) - 1, v8::TypedArray::max_byte_length());
+  assert_eq!((1 << 53) - 1, v8::TypedArray::MAX_BYTE_LENGTH);
 
-  // TypedArray::max_byte_length() ought to be >= 2^28 < 2^30 in 32 bits
+  // TypedArray::MAX_BYTE_LENGTH ought to be >= 2^28 < 2^30 in 32 bits
   #[cfg(target_pointer_width = "32")]
-  assert!(((2 << 28)..(2 << 30)).contains(&v8::TypedArray::max_byte_length()));
+  assert!(((2 << 28)..(2 << 30)).contains(&v8::TypedArray::MAX_BYTE_LENGTH));
 
   // v8::ArrayBuffer::new raises a fatal if the length is > kMaxLength, so we test this behavior
   // through the JS side of things, where a non-fatal RangeError is thrown in such cases.
@@ -5876,7 +5876,7 @@ fn typed_array_constructors() {
     let scope = &mut v8::TryCatch::new(scope);
     eval(
       scope,
-      &format!("new Uint8Array({})", v8::Uint8Array::max_length() + 1),
+      &format!("new Uint8Array({})", v8::Uint8Array::MAX_LENGTH + 1),
     );
     // Array is too big (> max_length) - expecting this threw a RangeError
     assert!(scope.has_caught());