feat: add dependency

javascript-engine/external/boa/boa_macros/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "boa_macros"
+description = "Macros for the Boa JavaScript engine."
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.23"
+syn = "1.0.107"
+proc-macro2 = "1.0"
+synstructure = "0.12"

javascript-engine/external/boa/boa_macros/src/lib.rs

@@ -0,0 +1,179 @@
+//! Macros for the Boa JavaScript engine.
+
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/boa-dev/boa/main/assets/logo.svg",
+    html_favicon_url = "https://raw.githubusercontent.com/boa-dev/boa/main/assets/logo.svg"
+)]
+#![cfg_attr(not(test), forbid(clippy::unwrap_used))]
+#![warn(missing_docs, clippy::dbg_macro)]
+#![deny(
+    // rustc lint groups https://doc.rust-lang.org/rustc/lints/groups.html
+    warnings,
+    future_incompatible,
+    let_underscore,
+    nonstandard_style,
+    rust_2018_compatibility,
+    rust_2018_idioms,
+    rust_2021_compatibility,
+    unused,
+
+    // rustc allowed-by-default lints https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html
+    macro_use_extern_crate,
+    meta_variable_misuse,
+    missing_abi,
+    missing_copy_implementations,
+    missing_debug_implementations,
+    non_ascii_idents,
+    noop_method_call,
+    single_use_lifetimes,
+    trivial_casts,
+    trivial_numeric_casts,
+    unreachable_pub,
+    unsafe_op_in_unsafe_fn,
+    unused_crate_dependencies,
+    unused_import_braces,
+    unused_lifetimes,
+    unused_qualifications,
+    unused_tuple_struct_fields,
+    variant_size_differences,
+
+    // rustdoc lints https://doc.rust-lang.org/rustdoc/lints.html
+    rustdoc::broken_intra_doc_links,
+    rustdoc::private_intra_doc_links,
+    rustdoc::missing_crate_level_docs,
+    rustdoc::private_doc_tests,
+    rustdoc::invalid_codeblock_attributes,
+    rustdoc::invalid_rust_codeblocks,
+    rustdoc::bare_urls,
+
+    // clippy categories https://doc.rust-lang.org/clippy/
+    clippy::all,
+    clippy::correctness,
+    clippy::suspicious,
+    clippy::style,
+    clippy::complexity,
+    clippy::perf,
+    clippy::pedantic,
+    clippy::nursery,
+)]
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, LitStr};
+use synstructure::{decl_derive, AddBounds, Structure};
+
+/// Construct a utf-16 array literal from a utf-8 [`str`] literal.
+#[proc_macro]
+pub fn utf16(input: TokenStream) -> TokenStream {
+    let literal = parse_macro_input!(input as LitStr);
+    let utf8 = literal.value();
+    let utf16 = utf8.encode_utf16().collect::<Vec<_>>();
+    quote! {
+        [#(#utf16),*].as_slice()
+    }
+    .into()
+}
+
+decl_derive! {
+    [Trace, attributes(unsafe_ignore_trace)] =>
+    /// Derive the Trace trait.
+    derive_trace
+}
+
+fn derive_trace(mut s: Structure<'_>) -> proc_macro2::TokenStream {
+    s.filter(|bi| {
+        !bi.ast()
+            .attrs
+            .iter()
+            .any(|attr| attr.path.is_ident("unsafe_ignore_trace"))
+    });
+    let trace_body = s.each(|bi| quote!(mark(#bi)));
+
+    s.add_bounds(AddBounds::Fields);
+    let trace_impl = s.unsafe_bound_impl(
+        quote!(::boa_gc::Trace),
+        quote! {
+            #[inline]
+            unsafe fn trace(&self) {
+                #[allow(dead_code)]
+                fn mark<T: ::boa_gc::Trace + ?Sized>(it: &T) {
+                    unsafe {
+                        ::boa_gc::Trace::trace(it);
+                    }
+                }
+                match *self { #trace_body }
+            }
+            #[inline]
+            unsafe fn weak_trace(&self) {
+                #[allow(dead_code, unreachable_code)]
+                fn mark<T: ::boa_gc::Trace + ?Sized>(it: &T) {
+                    unsafe {
+                        ::boa_gc::Trace::weak_trace(it)
+                    }
+                }
+                match *self { #trace_body }
+            }
+            #[inline]
+            unsafe fn root(&self) {
+                #[allow(dead_code)]
+                fn mark<T: ::boa_gc::Trace + ?Sized>(it: &T) {
+                    unsafe {
+                        ::boa_gc::Trace::root(it);
+                    }
+                }
+                match *self { #trace_body }
+            }
+            #[inline]
+            unsafe fn unroot(&self) {
+                #[allow(dead_code)]
+                fn mark<T: ::boa_gc::Trace + ?Sized>(it: &T) {
+                    unsafe {
+                        ::boa_gc::Trace::unroot(it);
+                    }
+                }
+                match *self { #trace_body }
+            }
+            #[inline]
+            fn run_finalizer(&self) {
+                ::boa_gc::Finalize::finalize(self);
+                #[allow(dead_code)]
+                fn mark<T: ::boa_gc::Trace + ?Sized>(it: &T) {
+                    unsafe {
+                        ::boa_gc::Trace::run_finalizer(it);
+                    }
+                }
+                match *self { #trace_body }
+            }
+        },
+    );
+
+    // We also implement drop to prevent unsafe drop implementations on this
+    // type and encourage people to use Finalize. This implementation will
+    // call `Finalize::finalize` if it is safe to do so.
+    let drop_impl = s.unbound_impl(
+        quote!(::std::ops::Drop),
+        quote! {
+            fn drop(&mut self) {
+                if ::boa_gc::finalizer_safe() {
+                    ::boa_gc::Finalize::finalize(self);
+                }
+            }
+        },
+    );
+
+    quote! {
+        #trace_impl
+        #drop_impl
+    }
+}
+
+decl_derive! {
+    [Finalize] =>
+    /// Derive the Finalize trait.
+    derive_finalize
+}
+
+#[allow(clippy::needless_pass_by_value)]
+fn derive_finalize(s: Structure<'_>) -> proc_macro2::TokenStream {
+    s.unbound_impl(quote!(::boa_gc::Finalize), quote!())
+}

javascript-engine/external/boa/boa_macros/tests/utf16.rs

@@ -0,0 +1,15 @@
+use boa_macros::utf16;
+
+#[test]
+fn literal() {
+    let utf16 = utf16!("hello!");
+    let manual = "hello!".encode_utf16().collect::<Vec<_>>();
+    assert_eq!(manual, utf16);
+}
+
+#[test]
+fn utf16() {
+    let utf16 = utf16!("hello!😁😁😁");
+    let manual = "hello!😁😁😁".encode_utf16().collect::<Vec<_>>();
+    assert_eq!(manual, utf16);
+}