feat: merge features serde and wasm to serialize (#2716)

This PR merges the previous confusing features `serde` and `wasm` into a single `serialize` feature. We'll eventually do serialize + type information for both wasm and napi targets. `oxc_macros` is removed from `oxc_ast`'s dependency because it requires `syn` and friends, which goes against our policy ["Third-party dependencies should be minimal."](https://oxc-project.github.io/docs/contribute/rules.html#development-policy)
2026-05-19 12:19:15 +00:00 · 2024-03-14 17:13:12 +08:00 · 2024-03-14 17:13:12 +08:00 · 697b6b70c0
commit 697b6b70c0
parent 9609c34e6d
31 changed files with 1107 additions and 1358 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1371,7 +1371,6 @@ dependencies = [
 "num-bigint",
 "oxc_allocator",
 "oxc_index",
- "oxc_macros",
 "oxc_span",
 "oxc_syntax",
 "ryu-js",
@ -1715,7 +1714,6 @@ dependencies = [
 "oxc_ast",
 "oxc_diagnostics",
 "oxc_index",
- "oxc_macros",
 "oxc_parser",
 "oxc_span",
 "oxc_syntax",
@ -1734,7 +1732,6 @@ version = "0.9.0"
 dependencies = [
 "compact_str",
 "miette",
- "oxc_macros",
 "serde",
 "tsify",
 "wasm-bindgen",
@ -1748,7 +1745,6 @@ dependencies = [
 "dashmap",
 "indexmap",
 "oxc_index",
- "oxc_macros",
 "oxc_span",
 "phf",
 "rustc-hash",
--- a/crates/oxc/Cargo.toml
+++ b/crates/oxc/Cargo.toml
@ -33,9 +33,8 @@ oxc_minifier    = { workspace = true, optional = true }
 oxc_codegen     = { workspace = true, optional = true }

 [features]
-serde       = ["oxc_ast/serde", "oxc_semantic/serde"]
+serialize   = ["oxc_ast/serialize", "oxc_span/serialize", "oxc_syntax/serialize", "oxc_semantic?/serialize"]
 semantic    = ["oxc_semantic"]
 transformer = ["oxc_transformer"]
 minifier    = ["oxc_minifier"]
 codegen     = ["oxc_codegen"]
-wasm        = ["oxc_ast/wasm", "serde", "oxc_semantic?/wasm", "oxc_span/wasm", "oxc_syntax/wasm"]
--- a/crates/oxc_ast/Cargo.toml
+++ b/crates/oxc_ast/Cargo.toml
@ -22,7 +22,6 @@ oxc_allocator = { workspace = true }
 oxc_span      = { workspace = true }
 oxc_syntax    = { workspace = true }
 oxc_index     = { workspace = true }
-oxc_macros    = { workspace = true }

 bitflags   = { workspace = true }
 num-bigint = { workspace = true }
@ -36,5 +35,12 @@ wasm-bindgen = { workspace = true, optional = true }

 [features]
 default = []
-serde   = ["dep:serde", "dep:serde_json", "dep:ryu-js", "oxc_span/serde", "oxc_syntax/serde"]
-wasm    = ["serde", "dep:tsify", "dep:wasm-bindgen"]
+serialize = [
+  "dep:serde",
+  "dep:serde_json",
+  "dep:ryu-js",
+  "dep:tsify",
+  "dep:wasm-bindgen",
+  "oxc_span/serialize",
+  "oxc_syntax/serialize",
+]
--- a/crates/oxc_ast/src/ast/js.rs
+++ b/crates/oxc_ast/src/ast/js.rs
--- a/crates/oxc_ast/src/ast/jsx.rs
+++ b/crates/oxc_ast/src/ast/jsx.rs
@ -1,11 +1,10 @@
 //! [JSX](https://facebook.github.io/jsx)

 use oxc_allocator::{Box, Vec};
-use oxc_macros::SerAttrs;
 use oxc_span::{Atom, Span};
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

 use super::{js::*, literal::*, ts::*};
@ -13,12 +12,11 @@ use super::{js::*, literal::*, ts::*};
 // 1.2 JSX Elements

 /// JSX Element
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type", rename_all = "camelCase")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct JSXElement<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub opening_element: Box<'a, JSXOpeningElement<'a>>,
    pub closing_element: Option<Box<'a, JSXClosingElement<'a>>>,
@ -26,12 +24,11 @@ pub struct JSXElement<'a> {
 }

 /// JSX Opening Element
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type", rename_all = "camelCase")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct JSXOpeningElement<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub self_closing: bool,
    pub name: JSXElementName<'a>,
@ -40,52 +37,47 @@ pub struct JSXOpeningElement<'a> {
 }

 /// JSX Closing Element
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXClosingElement<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub name: JSXElementName<'a>,
 }

 /// JSX Fragment
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type", rename_all = "camelCase")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type", rename_all = "camelCase"))]
 pub struct JSXFragment<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub opening_fragment: JSXOpeningFragment,
    pub closing_fragment: JSXClosingFragment,
    pub children: Vec<'a, JSXChild<'a>>,
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXOpeningFragment {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXClosingFragment {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
 }

 /// JSX Element Name
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXElementName<'a> {
    /// `<Apple />`
    Identifier(JSXIdentifier<'a>),
@ -96,12 +88,11 @@ pub enum JSXElementName<'a> {
 }

 /// JSX Namespaced Name
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXNamespacedName<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub namespace: JSXIdentifier<'a>,
    pub property: JSXIdentifier<'a>,
@ -114,12 +105,11 @@ impl<'a> std::fmt::Display for JSXNamespacedName<'a> {
 }

 /// JSX Member Expression
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXMemberExpression<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub object: JSXMemberExpressionObject<'a>,
    pub property: JSXIdentifier<'a>,
@ -134,62 +124,56 @@ impl<'a> JSXMemberExpression<'a> {
    }
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXMemberExpressionObject<'a> {
    Identifier(JSXIdentifier<'a>),
    MemberExpression(Box<'a, JSXMemberExpression<'a>>),
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXExpressionContainer<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub expression: JSXExpression<'a>,
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXExpression<'a> {
    Expression(Expression<'a>),
    EmptyExpression(JSXEmptyExpression),
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXEmptyExpression {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
 }

 // 1.3 JSX Attributes

 /// JSX Attributes
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXAttributeItem<'a> {
    Attribute(Box<'a, JSXAttribute<'a>>),
    SpreadAttribute(Box<'a, JSXSpreadAttribute<'a>>),
 }

 /// JSX Attribute
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXAttribute<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub name: JSXAttributeName<'a>,
    pub value: Option<JSXAttributeValue<'a>>,
@ -202,31 +186,28 @@ impl<'a> JSXAttribute<'a> {
 }

 /// JSX Spread Attribute
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXSpreadAttribute<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub argument: Expression<'a>,
 }

 /// JSX Attribute Name
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXAttributeName<'a> {
    Identifier(JSXIdentifier<'a>),
    NamespacedName(Box<'a, JSXNamespacedName<'a>>),
 }

 /// JSX Attribute Value
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXAttributeValue<'a> {
    StringLiteral(StringLiteral<'a>),
    ExpressionContainer(JSXExpressionContainer<'a>),
@ -234,12 +215,11 @@ pub enum JSXAttributeValue<'a> {
    Fragment(Box<'a, JSXFragment<'a>>),
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXIdentifier<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub name: Atom<'a>,
 }
@ -247,10 +227,9 @@ pub struct JSXIdentifier<'a> {
 // 1.4 JSX Children

 /// JSX Child
-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(untagged)]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(untagged))]
 pub enum JSXChild<'a> {
    Text(JSXText<'a>),
    Element(Box<'a, JSXElement<'a>>),
@ -259,22 +238,20 @@ pub enum JSXChild<'a> {
    Spread(JSXSpreadChild<'a>),
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXSpreadChild<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub expression: Expression<'a>,
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct JSXText<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub value: Atom<'a>,
 }
--- a/crates/oxc_ast/src/ast/literal.rs
+++ b/crates/oxc_ast/src/ast/literal.rs
@ -6,20 +6,18 @@ use std::{
 };

 use bitflags::bitflags;
-use oxc_macros::SerAttrs;
 use oxc_span::{Atom, Span};
 use oxc_syntax::{BigintBase, NumberBase};
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

-#[derive(Debug, Clone, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Clone, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct BooleanLiteral {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub value: bool,
 }
@ -38,12 +36,11 @@ impl BooleanLiteral {
    }
 }

-#[derive(Debug, Clone, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct NullLiteral {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
 }

@ -59,16 +56,15 @@ impl NullLiteral {
    }
 }

-#[derive(Debug, Clone, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct NumericLiteral<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub value: f64,
    pub raw: &'a str,
-    #[serde(skip)]
+    #[cfg_attr(feature = "serialize", serde(skip))]
    pub base: NumberBase,
 }

@ -87,7 +83,7 @@ impl<'a> NumericLiteral<'a> {
            return int32_value;
        }

-        // NaN, Infinity if not included in our NumericLiteral, so we just skip step 2.
+        // NaN, Infinity if not included in our NumericLiteral, so we just serde(skip) step 2.

        // step 3
        let pos_int = num.signum() * num.abs().floor();
@ -111,15 +107,14 @@ impl<'a> Hash for NumericLiteral<'a> {
    }
 }

-#[derive(Debug, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct BigIntLiteral<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub raw: Atom<'a>,
-    #[serde(skip)]
+    #[cfg_attr(feature = "serialize", serde(skip))]
    pub base: BigintBase,
 }

@ -129,12 +124,11 @@ impl<'a> BigIntLiteral<'a> {
    }
 }

-#[derive(Debug, Clone, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Clone, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct RegExpLiteral<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    // valid regex is printed as {}
    // invalid regex is printed as null, which we can't implement yet
@ -142,9 +136,8 @@ pub struct RegExpLiteral<'a> {
    pub regex: RegExp<'a>,
 }

-#[derive(Debug, Clone, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 pub struct RegExp<'a> {
    pub pattern: Atom<'a>,
    pub flags: RegExpFlags,
@ -171,7 +164,7 @@ bitflags! {
    }
 }

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type RegExpFlags = {
@ -234,17 +227,15 @@ impl fmt::Display for RegExpFlags {
    }
 }

-#[derive(Debug, Clone, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 pub struct EmptyObject;

-#[derive(Debug, Clone, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(tag = "type")]
+#[derive(Debug, Clone, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(tag = "type"))]
 pub struct StringLiteral<'a> {
-    #[serde(flatten)]
+    #[cfg_attr(feature = "serialize", serde(flatten))]
    pub span: Span,
    pub value: Atom<'a>,
 }
--- a/crates/oxc_ast/src/ast/ts.rs
+++ b/crates/oxc_ast/src/ast/ts.rs
--- a/crates/oxc_ast/src/lib.rs
+++ b/crates/oxc_ast/src/lib.rs
@ -9,7 +9,7 @@
 //! ## Cargo Features
 //! * `"serde"` enables support for serde serialization

-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 mod serialize;

 pub mod ast;
--- a/crates/oxc_index/Cargo.toml
+++ b/crates/oxc_index/Cargo.toml
@ -23,5 +23,5 @@ index_vec         = { workspace = true }
 static_assertions = { workspace = true }

 [features]
-default = []
-serde   = ["index_vec/serde"]
+default   = []
+serialize = ["index_vec/serde"]
--- a/crates/oxc_macros/src/lib.rs
+++ b/crates/oxc_macros/src/lib.rs
@ -58,12 +58,3 @@ pub fn declare_all_lint_rules(input: proc_macro::TokenStream) -> proc_macro::Tok

    declare_all_lint_rules::declare_all_lint_rules(metadata).into()
 }
-
-/// Dummy derive macro which doesn't actually derive anything,
-/// but allows `#[serde]` and `#[tsify]` attrs on the item it's applied to,
-/// without deriving `Serialize` or `Tsify`, and without `#[cfg_attr]`.
-#[proc_macro_derive(SerAttrs, attributes(serde, tsify))]
-pub fn ser_attrs(_input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    // Return an empty token stream
-    proc_macro::TokenStream::new()
-}
--- a/crates/oxc_parser/Cargo.toml
+++ b/crates/oxc_parser/Cargo.toml
@ -34,10 +34,10 @@ seq-macro        = { workspace = true }
 memchr = "2.7.1"

 [dev-dependencies]
-oxc_ast    = { workspace = true, features = ["serde"] }
+oxc_ast    = { workspace = true }
 miette     = { workspace = true }
 serde_json = { workspace = true }
-ouroboros  = "0.18.3"                                   # for `multi-thread` example
+ouroboros  = "0.18.3"             # for `multi-thread` example

 [features]
 # Expose Lexer for benchmarks
--- a/crates/oxc_semantic/Cargo.toml
+++ b/crates/oxc_semantic/Cargo.toml
@ -25,10 +25,8 @@ oxc_syntax      = { workspace = true }
 oxc_diagnostics = { workspace = true }
 oxc_index       = { workspace = true }
 oxc_allocator   = { workspace = true }
-oxc_macros      = { workspace = true }

 indexmap   = { workspace = true }
-itertools  = { workspace = true }
 phf        = { workspace = true, features = ["macros"] }
 rustc-hash = { workspace = true }
 serde      = { workspace = true, features = ["derive"], optional = true }
@ -40,15 +38,14 @@ wasm-bindgen = { workspace = true, optional = true }
 [dev-dependencies]
 oxc_parser = { workspace = true }

+itertools         = { workspace = true }
 bitflags          = { workspace = true }
 indexmap          = { workspace = true }
 insta             = { workspace = true }
-itertools         = { workspace = true }
 phf               = { workspace = true, features = ["macros"] }
-pretty_assertions = "1.4.0"
 rustc-hash        = { workspace = true }
+pretty_assertions = "1.4.0"

 [features]
-default = []
-serde   = ["dep:serde", "oxc_span/serde", "oxc_syntax/serde"]
-wasm    = ["serde", "dep:tsify", "dep:wasm-bindgen"]
+default   = []
+serialize = ["dep:serde", "oxc_span/serialize", "oxc_syntax/serialize", "dep:tsify", "dep:wasm-bindgen"]
--- a/crates/oxc_semantic/src/reference.rs
+++ b/crates/oxc_semantic/src/reference.rs
@ -1,18 +1,16 @@
-use oxc_macros::SerAttrs;
 use oxc_span::{CompactStr, Span};
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

 use crate::{symbol::SymbolId, AstNodeId};

 pub use oxc_syntax::reference::{ReferenceFlag, ReferenceId};

-#[derive(Debug, Clone, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(rename_all = "camelCase"))]
 pub struct Reference {
    span: Span,
    /// The name of the identifier that was referred to
--- a/crates/oxc_semantic/src/symbol.rs
+++ b/crates/oxc_semantic/src/symbol.rs
@ -1,6 +1,5 @@
 use oxc_ast::ast::Expression;
 use oxc_index::IndexVec;
-use oxc_macros::SerAttrs;
 use oxc_span::{Atom, CompactStr, Span};
 pub use oxc_syntax::{
    scope::ScopeId,
@ -12,12 +11,12 @@ use crate::{
    reference::{Reference, ReferenceId},
 };

-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type IndexVec<I, T> = Array<T>;
@ -26,10 +25,8 @@ export type IndexVec<I, T> = Array<T>;
 /// Symbol Table
 ///
 /// `SoA` (Struct of Arrays) for memory efficiency.
-#[derive(Debug, Default, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Default)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify), serde(rename_all = "camelCase"))]
 pub struct SymbolTable {
    pub spans: IndexVec<SymbolId, Span>,
    pub names: IndexVec<SymbolId, CompactStr>,
--- a/crates/oxc_span/Cargo.toml
+++ b/crates/oxc_span/Cargo.toml
@ -19,17 +19,13 @@ workspace = true
 doctest = false

 [dependencies]
-oxc_macros = { workspace = true }
-
 miette      = { workspace = true }
 compact_str = { version = "0.7.1" }

 tsify        = { workspace = true, optional = true }
 wasm-bindgen = { workspace = true, optional = true }
-
-serde = { workspace = true, features = ["derive"], optional = true }
+serde        = { workspace = true, features = ["derive"], optional = true }

 [features]
-default = []
-serde   = ["dep:serde", "compact_str/serde"]
-wasm    = ["serde", "dep:tsify", "dep:wasm-bindgen"]
+default   = []
+serialize = ["dep:serde", "dep:tsify", "dep:wasm-bindgen", "compact_str/serde"]
--- a/crates/oxc_span/src/atom.rs
+++ b/crates/oxc_span/src/atom.rs
@ -1,11 +1,11 @@
 use std::{borrow::Borrow, fmt, hash, ops::Deref};

-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::{Serialize, Serializer};

 use compact_str::CompactString;

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type Atom = string;
@ -22,7 +22,7 @@ pub const MAX_INLINE_LEN: usize = 16;
 #[derive(Clone, Eq)]
 pub struct Atom<'a>(&'a str);

-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 impl<'a> Serialize for Atom<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
@ -247,7 +247,7 @@ impl fmt::Display for CompactStr {
    }
 }

-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 impl Serialize for CompactStr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
--- a/crates/oxc_span/src/source_type.rs
+++ b/crates/oxc_span/src/source_type.rs
@ -1,17 +1,14 @@
 use std::path::Path;

-use oxc_macros::SerAttrs;
-
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

 /// Source Type for JavaScript vs TypeScript / Script vs Module / JSX
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(rename_all = "camelCase"))]
 pub struct SourceType {
    /// JavaScript or TypeScript, default JavaScript
    language: Language,
@ -28,32 +25,29 @@ pub struct SourceType {
 }

 /// JavaScript or TypeScript
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(rename_all = "lowercase")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(rename_all = "lowercase"))]
 pub enum Language {
    JavaScript,
    TypeScript,
-    #[serde(rename = "typescriptDefinition")]
+    #[cfg_attr(feature = "serialize", serde(rename = "typescriptDefinition"))]
    TypeScriptDefinition,
 }

 /// Script or Module
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(rename_all = "camelCase"))]
 pub enum ModuleKind {
    Script,
    Module,
 }

 /// JSX for JavaScript and TypeScript
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
+#[cfg_attr(feature = "serialize", serde(rename_all = "camelCase"))]
 pub enum LanguageVariant {
    Standard,
    Jsx,
--- a/crates/oxc_span/src/span.rs
+++ b/crates/oxc_span/src/span.rs
@ -1,10 +1,9 @@
 use std::hash::{Hash, Hasher};

 use miette::{SourceOffset, SourceSpan};
-use oxc_macros::SerAttrs;
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

 /// An Empty span useful for creating AST nodes.
@ -15,9 +14,8 @@ pub const SPAN: Span = Span::new(0, 0);
 /// See the [`text-size`](https://docs.rs/text-size) crate for details.
 /// Utility methods can be copied from the `text-size` crate if they are needed.
 /// NOTE: `u32` is sufficient for "all" reasonable programs. Larger than u32 is a 4GB JS file.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 #[non_exhaustive] // disallow struct expression constructor `Span {}`
 pub struct Span {
    pub start: u32,
--- a/crates/oxc_syntax/Cargo.toml
+++ b/crates/oxc_syntax/Cargo.toml
@ -19,21 +19,20 @@ workspace = true
 doctest = false

 [dependencies]
-oxc_index  = { workspace = true }
-oxc_macros = { workspace = true }
-oxc_span   = { workspace = true }
+oxc_index = { workspace = true }
+oxc_span  = { workspace = true }

 unicode-id-start = { workspace = true }
-serde            = { workspace = true, features = ["derive"], optional = true }
 bitflags         = { workspace = true }
 rustc-hash       = { workspace = true }
 indexmap         = { workspace = true }
 dashmap          = { workspace = true }
 phf              = { workspace = true, features = ["macros"] }

+serde        = { workspace = true, features = ["derive"], optional = true }
 tsify        = { workspace = true, optional = true }
 wasm-bindgen = { workspace = true, optional = true }
+
 [features]
-default = []
-serde   = ["dep:serde", "bitflags/serde", "oxc_index/serde"]
-wasm    = ["serde", "dep:tsify", "dep:wasm-bindgen"]
+default   = []
+serialize = ["dep:serde", "dep:tsify", "dep:wasm-bindgen", "oxc_index/serialize", "bitflags/serde"]
--- a/crates/oxc_syntax/src/assumptions.rs
+++ b/crates/oxc_syntax/src/assumptions.rs
@ -1,17 +1,15 @@
-use oxc_macros::SerAttrs;
-
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Deserialize;

 /// Compiler assumptions
 ///
 /// See <https://babeljs.io/docs/assumptions>
-#[derive(Debug, Default, Clone, Copy, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Deserialize))]
-#[serde(rename_all = "camelCase")]
+#[derive(Debug, Default, Clone, Copy)]
+#[cfg_attr(feature = "serialize", derive(Deserialize))]
+#[cfg_attr(feature = "serialize", serde(rename_all = "camelCase"))]
 pub struct CompilerAssumptions {
    /// When using operators that check for null or undefined, assume that they are never used with the special value document.all.
    /// See <https://babeljs.io/docs/assumptions#nodocumentall>.
-    #[serde(default)]
+    #[cfg_attr(feature = "serialize", serde(default))]
    pub no_document_all: bool,
 }
--- a/crates/oxc_syntax/src/lib.rs
+++ b/crates/oxc_syntax/src/lib.rs
@ -1,7 +1,5 @@
 //! Common code for JavaScript Syntax

-use oxc_macros::SerAttrs;
-
 pub mod assumptions;
 pub mod class;
 pub mod identifier;
@ -15,7 +13,7 @@ pub mod scope;
 pub mod symbol;
 pub mod xml_entities;

-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, SerAttrs)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub enum NumberBase {
    Float,
    Decimal,
@ -30,7 +28,7 @@ impl NumberBase {
    }
 }

-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, SerAttrs)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub enum BigintBase {
    Decimal,
    Binary,
--- a/crates/oxc_syntax/src/node.rs
+++ b/crates/oxc_syntax/src/node.rs
@ -5,7 +5,7 @@ define_index_type! {
    pub struct AstNodeId = usize;
 }

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type AstNodeId = number;
--- a/crates/oxc_syntax/src/operator.rs
+++ b/crates/oxc_syntax/src/operator.rs
@ -1,47 +1,44 @@
-use oxc_macros::SerAttrs;
-
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;
-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 use tsify::Tsify;

 use crate::precedence::{GetPrecedence, Precedence};

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 pub enum AssignmentOperator {
-    #[serde(rename = "=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "="))]
    Assign,
-    #[serde(rename = "+=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "+="))]
    Addition,
-    #[serde(rename = "-=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "-="))]
    Subtraction,
-    #[serde(rename = "*=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "*="))]
    Multiplication,
-    #[serde(rename = "/=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "/="))]
    Division,
-    #[serde(rename = "%=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "%="))]
    Remainder,
-    #[serde(rename = "<<=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "<<="))]
    ShiftLeft,
-    #[serde(rename = ">>=")]
+    #[cfg_attr(feature = "serialize", serde(rename = ">>="))]
    ShiftRight,
-    #[serde(rename = ">>>=")]
+    #[cfg_attr(feature = "serialize", serde(rename = ">>>="))]
    ShiftRightZeroFill,
-    #[serde(rename = "|=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "|="))]
    BitwiseOR,
-    #[serde(rename = "^=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "^="))]
    BitwiseXOR,
-    #[serde(rename = "&=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "&="))]
    BitwiseAnd,
-    #[serde(rename = "&&=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "&&="))]
    LogicalAnd,
-    #[serde(rename = "||=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "||="))]
    LogicalOr,
-    #[serde(rename = "??=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "??="))]
    LogicalNullish,
-    #[serde(rename = "**=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "**="))]
    Exponential,
 }

@ -86,53 +83,52 @@ impl AssignmentOperator {
    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))]
 pub enum BinaryOperator {
-    #[serde(rename = "==")]
+    #[cfg_attr(feature = "serialize", serde(rename = "=="))]
    Equality,
-    #[serde(rename = "!=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "!="))]
    Inequality,
-    #[serde(rename = "===")]
+    #[cfg_attr(feature = "serialize", serde(rename = "==="))]
    StrictEquality,
-    #[serde(rename = "!==")]
+    #[cfg_attr(feature = "serialize", serde(rename = "!=="))]
    StrictInequality,
-    #[serde(rename = "<")]
+    #[cfg_attr(feature = "serialize", serde(rename = "<"))]
    LessThan,
-    #[serde(rename = "<=")]
+    #[cfg_attr(feature = "serialize", serde(rename = "<="))]
    LessEqualThan,
-    #[serde(rename = ">")]
+    #[cfg_attr(feature = "serialize", serde(rename = ">"))]
    GreaterThan,
-    #[serde(rename = ">=")]
+    #[cfg_attr(feature = "serialize", serde(rename = ">="))]
    GreaterEqualThan,
-    #[serde(rename = "<<")]
+    #[cfg_attr(feature = "serialize", serde(rename = "<<"))]
    ShiftLeft,
-    #[serde(rename = ">>")]
+    #[cfg_attr(feature = "serialize", serde(rename = ">>"))]
    ShiftRight,
-    #[serde(rename = ">>>")]
+    #[cfg_attr(feature = "serialize", serde(rename = ">>>"))]
    ShiftRightZeroFill,
-    #[serde(rename = "+")]
+    #[cfg_attr(feature = "serialize", serde(rename = "+"))]
    Addition,
-    #[serde(rename = "-")]
+    #[cfg_attr(feature = "serialize", serde(rename = "-"))]
    Subtraction,
-    #[serde(rename = "*")]
+    #[cfg_attr(feature = "serialize", serde(rename = "*"))]
    Multiplication,
-    #[serde(rename = "/")]
+    #[cfg_attr(feature = "serialize", serde(rename = "/"))]
    Division,
-    #[serde(rename = "%")]
+    #[cfg_attr(feature = "serialize", serde(rename = "%"))]
    Remainder,
-    #[serde(rename = "|")]
+    #[cfg_attr(feature = "serialize", serde(rename = "|"))]
    BitwiseOR,
-    #[serde(rename = "^")]
+    #[cfg_attr(feature = "serialize", serde(rename = "^"))]
    BitwiseXOR,
-    #[serde(rename = "&")]
+    #[cfg_attr(feature = "serialize", serde(rename = "&"))]
    BitwiseAnd,
-    #[serde(rename = "in")]
+    #[cfg_attr(feature = "serialize", serde(rename = "in"))]
    In,
-    #[serde(rename = "instanceof")]
+    #[cfg_attr(feature = "serialize", serde(rename = "instanceof"))]
    Instanceof,
-    #[serde(rename = "**")]
+    #[cfg_attr(feature = "serialize", serde(rename = "**"))]
    Exponential,
 }

@ -273,15 +269,15 @@ impl GetPrecedence for BinaryOperator {
    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize))]
+#[cfg_attr(feature = "serialize", derive(Tsify))]
 pub enum LogicalOperator {
-    #[serde(rename = "||")]
+    #[cfg_attr(feature = "serialize", serde(rename = "||"))]
    Or,
-    #[serde(rename = "&&")]
+    #[cfg_attr(feature = "serialize", serde(rename = "&&"))]
    And,
-    #[serde(rename = "??")]
+    #[cfg_attr(feature = "serialize", serde(rename = "??"))]
    Coalesce,
 }

@ -305,23 +301,23 @@ impl GetPrecedence for LogicalOperator {
    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize))]
+#[cfg_attr(feature = "serialize", derive(Tsify))]
 pub enum UnaryOperator {
-    #[serde(rename = "-")]
+    #[cfg_attr(feature = "serialize", serde(rename = "-"))]
    UnaryNegation,
-    #[serde(rename = "+")]
+    #[cfg_attr(feature = "serialize", serde(rename = "+"))]
    UnaryPlus,
-    #[serde(rename = "!")]
+    #[cfg_attr(feature = "serialize", serde(rename = "!"))]
    LogicalNot,
-    #[serde(rename = "~")]
+    #[cfg_attr(feature = "serialize", serde(rename = "~"))]
    BitwiseNot,
-    #[serde(rename = "typeof")]
+    #[cfg_attr(feature = "serialize", serde(rename = "typeof"))]
    Typeof,
-    #[serde(rename = "void")]
+    #[cfg_attr(feature = "serialize", serde(rename = "void"))]
    Void,
-    #[serde(rename = "delete")]
+    #[cfg_attr(feature = "serialize", serde(rename = "delete"))]
    Delete,
 }

@ -351,13 +347,13 @@ impl UnaryOperator {
    }
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "wasm", derive(Tsify))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(Serialize))]
+#[cfg_attr(feature = "serialize", derive(Tsify))]
 pub enum UpdateOperator {
-    #[serde(rename = "++")]
+    #[cfg_attr(feature = "serialize", serde(rename = "++"))]
    Increment,
-    #[serde(rename = "--")]
+    #[cfg_attr(feature = "serialize", serde(rename = "--"))]
    Decrement,
 }

--- a/crates/oxc_syntax/src/reference.rs
+++ b/crates/oxc_syntax/src/reference.rs
@ -1,13 +1,13 @@
 use bitflags::bitflags;
 use oxc_index::define_index_type;
-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;

 define_index_type! {
    pub struct ReferenceId = u32;
 }

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type ReferenceId = number;
@ -22,7 +22,7 @@ export type ReferenceFlag = {

 bitflags! {
    #[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
-    #[cfg_attr(feature = "serde", derive(Serialize))]
+    #[cfg_attr(feature = "serialize", derive(Serialize))]
    pub struct ReferenceFlag: u8 {
        const None = 0;
        const Read = 1 << 0;
--- a/crates/oxc_syntax/src/scope.rs
+++ b/crates/oxc_syntax/src/scope.rs
@ -5,7 +5,7 @@ define_index_type! {
    pub struct ScopeId = u32;
 }

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type ScopeId = number;
--- a/crates/oxc_syntax/src/symbol.rs
+++ b/crates/oxc_syntax/src/symbol.rs
@ -1,14 +1,14 @@
 use bitflags::bitflags;
 use oxc_index::define_index_type;

-#[cfg(feature = "serde")]
+#[cfg(feature = "serialize")]
 use serde::Serialize;

 define_index_type! {
    pub struct SymbolId = u32;
 }

-#[cfg(feature = "wasm")]
+#[cfg(feature = "serialize")]
 #[wasm_bindgen::prelude::wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type SymbolId = number;
@ -17,7 +17,7 @@ export type SymbolFlags = unknown;

 bitflags! {
    #[derive(Debug, Clone, Copy)]
-    #[cfg_attr(feature = "serde", derive(Serialize))]
+    #[cfg_attr(feature = "serialize", derive(Serialize))]
    pub struct SymbolFlags: u32 {
        const None                    = 0;
        /// Variable (var) or parameter
--- a/crates/oxc_wasm/Cargo.toml
+++ b/crates/oxc_wasm/Cargo.toml
@ -18,7 +18,7 @@ test       = false
 doctest    = false

 [dependencies]
-oxc = { workspace = true, features = ["serde", "semantic", "transformer", "minifier", "codegen", "wasm"] }
+oxc = { workspace = true, features = ["serialize", "semantic", "transformer", "minifier", "codegen"] }

 oxc_linter   = { workspace = true }
 oxc_prettier = { workspace = true }
--- a/napi/parser/Cargo.toml
+++ b/napi/parser/Cargo.toml
@ -23,7 +23,7 @@ doctest    = false
 [dependencies]
 oxc_allocator    = { workspace = true }
 oxc_parser       = { workspace = true }
-oxc_ast          = { workspace = true, features = ["serde"] }
+oxc_ast          = { workspace = true, features = ["serialize"] }
 oxc_span         = { workspace = true }
 oxc_diagnostics  = { workspace = true }
 oxc_module_lexer = { path = "../../crates/oxc_module_lexer" }
--- a/tasks/common/Cargo.toml
+++ b/tasks/common/Cargo.toml
@ -14,7 +14,7 @@ doctest = false

 [dependencies]
 console    = "0.15.8"
-oxc_syntax = { workspace = true, features = ["serde"] }
+oxc_syntax = { workspace = true, features = ["serialize"] }

 project-root = { workspace = true }
 serde        = { workspace = true, features = ["derive"] }
--- a/tasks/coverage/Cargo.toml
+++ b/tasks/coverage/Cargo.toml
@ -23,7 +23,7 @@ test = false
 [dependencies]
 oxc_allocator    = { workspace = true }
 oxc_parser       = { workspace = true }
-oxc_ast          = { workspace = true, features = ["serde"] }
+oxc_ast          = { workspace = true, features = ["serialize"] }
 oxc_codegen      = { workspace = true }
 oxc_diagnostics  = { workspace = true }
 oxc_semantic     = { workspace = true }
--- a/wasm/parser/Cargo.toml
+++ b/wasm/parser/Cargo.toml
@ -21,7 +21,7 @@ test       = false
 doctest    = false

 [dependencies]
-oxc = { workspace = true, features = ["serde", "wasm"] }
+oxc = { workspace = true, features = ["serialize"] }
 serde        = { workspace = true, features = ["derive"] }

 wasm-bindgen       = { workspace = true }