From 3c1e0db53fe791c79a4e53a864788ef36fe099e7 Mon Sep 17 00:00:00 2001 From: overlookmotel Date: Mon, 11 Mar 2024 05:38:24 +0000 Subject: [PATCH] refactor: reduce `cfg_attr` boilerplate with `SerAttrs` derive (#2669) Closes #2641. Also added `tsify` attribute to the `SerAttrs` derive macro, so `#[cfg_attr(feature = "wasm", tsify(...))]` can also be reduced to `#[tsify(...)]`. --- Cargo.lock | 4 + crates/oxc_ast/Cargo.toml | 1 + crates/oxc_ast/src/ast/js.rs | 804 +++++++++++++++------------ crates/oxc_ast/src/ast/jsx.rs | 141 +++-- crates/oxc_ast/src/ast/literal.rs | 47 +- crates/oxc_ast/src/ast/ts.rs | 599 +++++++++++--------- crates/oxc_macros/src/lib.rs | 9 + crates/oxc_semantic/Cargo.toml | 1 + crates/oxc_semantic/src/reference.rs | 6 +- crates/oxc_semantic/src/symbol.rs | 6 +- crates/oxc_span/Cargo.toml | 2 + crates/oxc_span/src/source_type.rs | 24 +- crates/oxc_syntax/Cargo.toml | 5 +- crates/oxc_syntax/src/assumptions.rs | 8 +- crates/oxc_syntax/src/operator.rs | 112 ++-- 15 files changed, 1010 insertions(+), 759 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 227354b5e..2e135b0a9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1356,6 +1356,7 @@ dependencies = [ "num-bigint", "oxc_allocator", "oxc_index", + "oxc_macros", "oxc_span", "oxc_syntax", "ryu-js", @@ -1699,6 +1700,7 @@ dependencies = [ "oxc_ast", "oxc_diagnostics", "oxc_index", + "oxc_macros", "oxc_parser", "oxc_span", "oxc_syntax", @@ -1717,6 +1719,7 @@ version = "0.9.0" dependencies = [ "compact_str", "miette", + "oxc_macros", "serde", "tsify", "wasm-bindgen", @@ -1730,6 +1733,7 @@ dependencies = [ "dashmap", "indexmap", "oxc_index", + "oxc_macros", "oxc_span", "phf", "rustc-hash", diff --git a/crates/oxc_ast/Cargo.toml b/crates/oxc_ast/Cargo.toml index 2960124ef..8869d6664 100644 --- a/crates/oxc_ast/Cargo.toml +++ b/crates/oxc_ast/Cargo.toml @@ -22,6 +22,7 @@ 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 } diff --git a/crates/oxc_ast/src/ast/js.rs b/crates/oxc_ast/src/ast/js.rs index 75f1303bd..077ad4933 100644 --- a/crates/oxc_ast/src/ast/js.rs +++ b/crates/oxc_ast/src/ast/js.rs @@ -1,6 +1,7 @@ use std::{cell::Cell, fmt, hash::Hash}; use oxc_allocator::{Box, Vec}; +use oxc_macros::SerAttrs; use oxc_span::{Atom, CompactStr, SourceType, Span}; use oxc_syntax::{ operator::{ @@ -33,11 +34,12 @@ export interface FormalParameterRest extends Span { } "#; -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct Program<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub source_type: SourceType, pub directives: Vec<'a, Directive<'a>>, @@ -58,9 +60,10 @@ impl<'a> Program<'a> { } /// Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum Expression<'a> { BooleanLiteral(Box<'a, BooleanLiteral>), NullLiteral(Box<'a, NullLiteral>), @@ -316,10 +319,11 @@ impl<'a> Expression<'a> { } /// Identifier Name -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename = "Identifier"))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "Identifier")] pub struct IdentifierName<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, } @@ -331,15 +335,16 @@ impl<'a> IdentifierName<'a> { } /// Identifier Reference -#[derive(Debug, Clone)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename = "Identifier"))] +#[derive(Debug, Clone, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "Identifier")] pub struct IdentifierReference<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, - #[cfg_attr(feature = "serde", serde(skip))] + #[serde(skip)] pub reference_id: Cell>, - #[cfg_attr(feature = "serde", serde(skip))] + #[serde(skip)] pub reference_flag: ReferenceFlag, } @@ -357,13 +362,14 @@ impl<'a> IdentifierReference<'a> { } /// Binding Identifier -#[derive(Debug, Clone)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename = "Identifier"))] +#[derive(Debug, Clone, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "Identifier")] pub struct BindingIdentifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, - #[cfg_attr(feature = "serde", serde(skip))] + #[serde(skip)] pub symbol_id: Cell>, } @@ -381,29 +387,32 @@ impl<'a> BindingIdentifier<'a> { } /// Label Identifier -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename = "Identifier"))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "Identifier")] pub struct LabelIdentifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, } /// This Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ThisExpression { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ArrayExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub elements: Vec<'a, ArrayExpressionElement<'a>>, /// Array trailing comma @@ -412,9 +421,10 @@ pub struct ArrayExpression<'a> { } /// Array Expression Element -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ArrayExpressionElement<'a> { SpreadElement(Box<'a, SpreadElement<'a>>), Expression(Expression<'a>), @@ -430,11 +440,12 @@ impl<'a> ArrayExpressionElement<'a> { } /// Object Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ObjectExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub properties: Vec<'a, ObjectPropertyKind<'a>>, pub trailing_comma: Option, @@ -447,19 +458,21 @@ impl<'a> ObjectExpression<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ObjectPropertyKind<'a> { ObjectProperty(Box<'a, ObjectProperty<'a>>), SpreadProperty(Box<'a, SpreadElement<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ObjectProperty<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub kind: PropertyKind, pub key: PropertyKey<'a>, @@ -470,9 +483,10 @@ pub struct ObjectProperty<'a> { pub computed: bool, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum PropertyKey<'a> { Identifier(Box<'a, IdentifierName<'a>>), PrivateIdentifier(Box<'a, PrivateIdentifier<'a>>), @@ -543,9 +557,10 @@ impl<'a> PropertyKey<'a> { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum PropertyKind { Init, Get, @@ -555,11 +570,12 @@ pub enum PropertyKind { /// Template Literal /// /// This is interpreted by interleaving the expression elements in between the quasi elements. -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TemplateLiteral<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub quasis: Vec<'a, TemplateElement<'a>>, pub expressions: Vec<'a, Expression<'a>>, @@ -576,22 +592,24 @@ impl<'a> TemplateLiteral<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TaggedTemplateExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub tag: Expression<'a>, pub quasi: TemplateLiteral<'a>, pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TemplateElement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub tail: bool, pub value: TemplateElementValue<'a>, @@ -614,9 +632,10 @@ pub struct TemplateElementValue<'a> { } /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum MemberExpression<'a> { /// `MemberExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ]` ComputedMemberExpression(ComputedMemberExpression<'a>), @@ -709,11 +728,12 @@ impl<'a> MemberExpression<'a> { } /// `MemberExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ]` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ComputedMemberExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub object: Expression<'a>, pub expression: Expression<'a>, @@ -721,11 +741,12 @@ pub struct ComputedMemberExpression<'a> { } /// `MemberExpression[?Yield, ?Await] . IdentifierName` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct StaticMemberExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub object: Expression<'a>, pub property: IdentifierName<'a>, @@ -733,11 +754,12 @@ pub struct StaticMemberExpression<'a> { } /// `MemberExpression[?Yield, ?Await] . PrivateIdentifier` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct PrivateFieldExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub object: Expression<'a>, pub field: PrivateIdentifier<'a>, @@ -745,11 +767,12 @@ pub struct PrivateFieldExpression<'a> { } /// Call Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct CallExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub callee: Expression<'a>, pub arguments: Vec<'a, Argument<'a>>, @@ -799,11 +822,12 @@ impl<'a> CallExpression<'a> { } /// New Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct NewExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub callee: Expression<'a>, pub arguments: Vec<'a, Argument<'a>>, @@ -811,30 +835,33 @@ pub struct NewExpression<'a> { } /// Meta Property `new.target` | `import.meta` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct MetaProperty<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub meta: IdentifierName<'a>, pub property: IdentifierName<'a>, } /// Spread Element -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct SpreadElement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: Expression<'a>, } /// Argument -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum Argument<'a> { SpreadElement(Box<'a, SpreadElement<'a>>), Expression(Expression<'a>), @@ -847,11 +874,12 @@ impl Argument<'_> { } /// Update Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct UpdateExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub operator: UpdateOperator, pub prefix: bool, @@ -859,22 +887,24 @@ pub struct UpdateExpression<'a> { } /// Unary Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct UnaryExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub operator: UnaryOperator, pub argument: Expression<'a>, } /// Binary Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct BinaryExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub left: Expression<'a>, pub operator: BinaryOperator, @@ -882,11 +912,12 @@ pub struct BinaryExpression<'a> { } /// Private Identifier in Shift Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct PrivateInExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub left: PrivateIdentifier<'a>, pub operator: BinaryOperator, // BinaryOperator::In @@ -894,11 +925,12 @@ pub struct PrivateInExpression<'a> { } /// Binary Logical Operators -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct LogicalExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub left: Expression<'a>, pub operator: LogicalOperator, @@ -906,11 +938,12 @@ pub struct LogicalExpression<'a> { } /// Conditional Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ConditionalExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub test: Expression<'a>, pub consequent: Expression<'a>, @@ -918,11 +951,12 @@ pub struct ConditionalExpression<'a> { } /// Assignment Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AssignmentExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub operator: AssignmentOperator, pub left: AssignmentTarget<'a>, @@ -930,9 +964,10 @@ pub struct AssignmentExpression<'a> { } /// Destructuring Assignment -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum AssignmentTarget<'a> { SimpleAssignmentTarget(SimpleAssignmentTarget<'a>), AssignmentTargetPattern(AssignmentTargetPattern<'a>), @@ -955,9 +990,10 @@ impl<'a> AssignmentTarget<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum SimpleAssignmentTarget<'a> { AssignmentTargetIdentifier(Box<'a, IdentifierReference<'a>>), MemberAssignmentTarget(Box<'a, MemberExpression<'a>>), @@ -979,26 +1015,24 @@ impl<'a> SimpleAssignmentTarget<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum AssignmentTargetPattern<'a> { ArrayAssignmentTarget(Box<'a, ArrayAssignmentTarget<'a>>), ObjectAssignmentTarget(Box<'a, ObjectAssignmentTarget<'a>>), } // See serializer in serialize.rs -#[derive(Debug, Hash)] +#[derive(Debug, Hash, SerAttrs)] #[cfg_attr(feature = "wasm", derive(Tsify))] pub struct ArrayAssignmentTarget<'a> { - #[cfg_attr(feature = "wasm", serde(flatten))] + #[serde(flatten)] pub span: Span, - #[cfg_attr( - feature = "wasm", - tsify(type = "Array") - )] + #[tsify(type = "Array")] pub elements: Vec<'a, Option>>, - #[cfg_attr(feature = "wasm", serde(skip))] + #[serde(skip)] pub rest: Option>, pub trailing_comma: Option, } @@ -1013,17 +1047,14 @@ impl<'a> ArrayAssignmentTarget<'a> { } // See serializer in serialize.rs -#[derive(Debug, Hash)] +#[derive(Debug, Hash, SerAttrs)] #[cfg_attr(feature = "wasm", derive(Tsify))] pub struct ObjectAssignmentTarget<'a> { - #[cfg_attr(feature = "wasm", serde(flatten))] + #[serde(flatten)] pub span: Span, - #[cfg_attr( - feature = "wasm", - tsify(type = "Array") - )] + #[tsify(type = "Array")] pub properties: Vec<'a, AssignmentTargetProperty<'a>>, - #[cfg_attr(feature = "wasm", serde(skip))] + #[serde(skip)] pub rest: Option>, } @@ -1044,18 +1075,20 @@ impl<'a> ObjectAssignmentTarget<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename = "RestElement"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "RestElement")] pub struct AssignmentTargetRest<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, - #[cfg_attr(feature = "serde", serde(rename = "argument"))] + #[serde(rename = "argument")] pub target: AssignmentTarget<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum AssignmentTargetMaybeDefault<'a> { AssignmentTarget(AssignmentTarget<'a>), AssignmentTargetWithDefault(Box<'a, AssignmentTargetWithDefault<'a>>), @@ -1079,105 +1112,116 @@ impl<'a> AssignmentTargetMaybeDefault<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AssignmentTargetWithDefault<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub binding: AssignmentTarget<'a>, pub init: Expression<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum AssignmentTargetProperty<'a> { AssignmentTargetPropertyIdentifier(Box<'a, AssignmentTargetPropertyIdentifier<'a>>), AssignmentTargetPropertyProperty(Box<'a, AssignmentTargetPropertyProperty<'a>>), } /// Assignment Property - Identifier Reference -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AssignmentTargetPropertyIdentifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub binding: IdentifierReference<'a>, pub init: Option>, } /// Assignment Property - Property Name -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AssignmentTargetPropertyProperty<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: PropertyKey<'a>, pub binding: AssignmentTargetMaybeDefault<'a>, } /// Sequence Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct SequenceExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expressions: Vec<'a, Expression<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct Super { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } /// Await Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AwaitExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: Expression<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ChainExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: ChainElement<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ChainElement<'a> { CallExpression(Box<'a, CallExpression<'a>>), MemberExpression(Box<'a, MemberExpression<'a>>), } /// Parenthesized Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ParenthesizedExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, } /// Statements -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum Statement<'a> { // Statements BlockStatement(Box<'a, BlockStatement<'a>>), @@ -1217,11 +1261,12 @@ impl<'a> Statement<'a> { } /// Directive Prologue -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct Directive<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: StringLiteral<'a>, /// A Use Strict Directive is an ExpressionStatement in a Directive Prologue whose StringLiteral is either of the exact code point sequences "use strict" or 'use strict'. @@ -1231,29 +1276,32 @@ pub struct Directive<'a> { } /// Hashbang -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct Hashbang<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub value: Atom<'a>, } /// Block Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct BlockStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub body: Vec<'a, Statement<'a>>, } /// Declarations and the Variable Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum Declaration<'a> { VariableDeclaration(Box<'a, VariableDeclaration<'a>>), FunctionDeclaration(Box<'a, Function<'a>>), @@ -1291,11 +1339,12 @@ impl<'a> Declaration<'a> { } /// Variable Declaration -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct VariableDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub kind: VariableDeclarationKind, pub declarations: Vec<'a, VariableDeclarator<'a>>, @@ -1309,9 +1358,10 @@ impl<'a> VariableDeclaration<'a> { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum VariableDeclarationKind { Var, Const, @@ -1347,13 +1397,14 @@ impl fmt::Display for VariableDeclarationKind { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct VariableDeclarator<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, - #[cfg_attr(feature = "serde", serde(skip))] + #[serde(skip)] pub kind: VariableDeclarationKind, pub id: BindingPattern<'a>, pub init: Option>, @@ -1362,11 +1413,12 @@ pub struct VariableDeclarator<'a> { /// Using Declaration /// * -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct UsingDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub is_await: bool, #[cfg_attr(feature = "serde-impl", serde(default))] @@ -1374,30 +1426,33 @@ pub struct UsingDeclaration<'a> { } /// Empty Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct EmptyStatement { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } /// Expression Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ExpressionStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, } /// If Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct IfStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub test: Expression<'a>, pub consequent: Statement<'a>, @@ -1405,33 +1460,36 @@ pub struct IfStatement<'a> { } /// Do-While Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct DoWhileStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub body: Statement<'a>, pub test: Expression<'a>, } /// While Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct WhileStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub test: Expression<'a>, pub body: Statement<'a>, } /// For Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ForStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub init: Option>, pub test: Option>, @@ -1439,9 +1497,10 @@ pub struct ForStatement<'a> { pub body: Statement<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ForStatementInit<'a> { VariableDeclaration(Box<'a, VariableDeclaration<'a>>), Expression(Expression<'a>), @@ -1464,11 +1523,12 @@ impl<'a> ForStatementInit<'a> { } /// For-In Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ForInStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub left: ForStatementLeft<'a>, pub right: Expression<'a>, @@ -1476,11 +1536,12 @@ pub struct ForInStatement<'a> { } /// For-Of Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ForOfStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub r#await: bool, pub left: ForStatementLeft<'a>, @@ -1488,9 +1549,10 @@ pub struct ForOfStatement<'a> { pub body: Statement<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ForStatementLeft<'a> { VariableDeclaration(Box<'a, VariableDeclaration<'a>>), AssignmentTarget(AssignmentTarget<'a>), @@ -1506,62 +1568,68 @@ impl<'a> ForStatementLeft<'a> { } /// Continue Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ContinueStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub label: Option>, } /// Break Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct BreakStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub label: Option>, } /// Return Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ReturnStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: Option>, } /// With Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct WithStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub object: Expression<'a>, pub body: Statement<'a>, } /// Switch Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct SwitchStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub discriminant: Expression<'a>, pub cases: Vec<'a, SwitchCase<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct SwitchCase<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub test: Option>, pub consequent: Vec<'a, Statement<'a>>, @@ -1574,69 +1642,72 @@ impl<'a> SwitchCase<'a> { } /// Labelled Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct LabeledStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub label: LabelIdentifier<'a>, pub body: Statement<'a>, } /// Throw Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ThrowStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: Expression<'a>, } /// Try Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TryStatement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub block: Box<'a, BlockStatement<'a>>, pub handler: Option>>, pub finalizer: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct CatchClause<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub param: Option>, pub body: Box<'a, BlockStatement<'a>>, } /// Debugger Statement -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct DebuggerStatement { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } /// Destructuring Binding Patterns /// * -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct BindingPattern<'a> { // Flatten the attributes because estree has no `BindingPattern` - #[cfg_attr(feature = "serde", serde(flatten))] - #[cfg_attr( - feature = "wasm", - tsify(type = "(BindingIdentifier | ObjectPattern | ArrayPattern | AssignmentPattern)") - )] + #[serde(flatten)] + #[tsify(type = "(BindingIdentifier | ObjectPattern | ArrayPattern | AssignmentPattern)")] pub kind: BindingPatternKind<'a>, pub type_annotation: Option>>, pub optional: bool, @@ -1648,9 +1719,10 @@ impl<'a> BindingPattern<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum BindingPatternKind<'a> { /// `const a = 1` BindingIdentifier(Box<'a, BindingIdentifier<'a>>), @@ -1679,25 +1751,26 @@ impl<'a> BindingPatternKind<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AssignmentPattern<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub left: BindingPattern<'a>, pub right: Expression<'a>, } // See serializer in serialize.rs -#[derive(Debug, Hash)] +#[derive(Debug, Hash, SerAttrs)] #[cfg_attr(feature = "wasm", derive(Tsify))] pub struct ObjectPattern<'a> { - #[cfg_attr(feature = "wasm", serde(flatten))] + #[serde(flatten)] pub span: Span, - #[cfg_attr(feature = "wasm", tsify(type = "Array"))] + #[tsify(type = "Array")] pub properties: Vec<'a, BindingProperty<'a>>, - #[cfg_attr(feature = "wasm", serde(skip))] + #[serde(skip)] pub rest: Option>>, } @@ -1711,11 +1784,12 @@ impl<'a> ObjectPattern<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct BindingProperty<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub key: PropertyKey<'a>, pub value: BindingPattern<'a>, @@ -1724,17 +1798,14 @@ pub struct BindingProperty<'a> { } // See serializer in serialize.rs -#[derive(Debug, Hash)] +#[derive(Debug, Hash, SerAttrs)] #[cfg_attr(feature = "wasm", derive(Tsify))] pub struct ArrayPattern<'a> { - #[cfg_attr(feature = "wasm", serde(flatten))] + #[serde(flatten)] pub span: Span, - #[cfg_attr( - feature = "wasm", - tsify(type = "Array") - )] + #[tsify(type = "Array")] pub elements: Vec<'a, Option>>, - #[cfg_attr(feature = "wasm", serde(skip))] + #[serde(skip)] pub rest: Option>>, } @@ -1748,21 +1819,23 @@ impl<'a> ArrayPattern<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename = "RestElement"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "RestElement")] pub struct BindingRestElement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: BindingPattern<'a>, } /// Function Definitions -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct Function<'a> { pub r#type: FunctionType, - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: Option>, pub generator: bool, @@ -1834,15 +1907,15 @@ pub enum FunctionType { /// // See serializer in serialize.rs -#[derive(Debug, Hash)] +#[derive(Debug, Hash, SerAttrs)] #[cfg_attr(feature = "wasm", derive(Tsify))] pub struct FormalParameters<'a> { - #[cfg_attr(feature = "wasm", serde(flatten))] + #[serde(flatten)] pub span: Span, pub kind: FormalParameterKind, - #[cfg_attr(feature = "wasm", tsify(type = "Array"))] + #[tsify(type = "Array")] pub items: Vec<'a, FormalParameter<'a>>, - #[cfg_attr(feature = "wasm", serde(skip))] + #[serde(skip)] pub rest: Option>>, } @@ -1852,11 +1925,12 @@ impl<'a> FormalParameters<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct FormalParameter<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub pattern: BindingPattern<'a>, pub accessibility: Option, @@ -1892,11 +1966,12 @@ impl<'a> FormalParameters<'a> { } /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct FunctionBody<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub directives: Vec<'a, Directive<'a>>, pub statements: Vec<'a, Statement<'a>>, @@ -1909,11 +1984,12 @@ impl<'a> FunctionBody<'a> { } /// Arrow Function Definitions -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ArrowFunctionExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, /// Is the function body an arrow expression? i.e. `() => expr` instead of `() => {}` pub expression: bool, @@ -1939,23 +2015,25 @@ impl<'a> ArrowFunctionExpression<'a> { } /// Generator Function Definitions -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct YieldExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub delegate: bool, pub argument: Option>, } /// Class Definitions -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct Class<'a> { pub r#type: ClassType, - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: Option>, pub super_class: Option>, @@ -1994,18 +2072,20 @@ pub enum ClassType { ClassExpression, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ClassBody<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub body: Vec<'a, ClassElement<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ClassElement<'a> { StaticBlock(Box<'a, StaticBlock<'a>>), MethodDefinition(Box<'a, MethodDefinition<'a>>), @@ -2104,12 +2184,13 @@ impl<'a> ClassElement<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct MethodDefinition<'a> { pub r#type: MethodDefinitionType, - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub key: PropertyKey<'a>, pub value: Box<'a, Function<'a>>, // FunctionExpression @@ -2130,12 +2211,13 @@ pub enum MethodDefinitionType { TSAbstractMethodDefinition, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct PropertyDefinition<'a> { pub r#type: PropertyDefinitionType, - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub key: PropertyKey<'a>, pub value: Option>, @@ -2159,9 +2241,10 @@ pub enum PropertyDefinitionType { TSAbstractPropertyDefinition, } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum MethodDefinitionKind { Constructor, Method, @@ -2181,11 +2264,12 @@ impl MethodDefinitionKind { } } -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct PrivateIdentifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, } @@ -2196,18 +2280,20 @@ impl<'a> PrivateIdentifier<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct StaticBlock<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub body: Vec<'a, Statement<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ModuleDeclaration<'a> { /// import hello from './world.js'; /// import * as t from './world.js'; @@ -2269,11 +2355,12 @@ impl<'a> ModuleDeclaration<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct AccessorProperty<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub key: PropertyKey<'a>, pub value: Option>, @@ -2282,21 +2369,23 @@ pub struct AccessorProperty<'a> { pub decorators: Vec<'a, Decorator<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ImportExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub source: Expression<'a>, pub arguments: Vec<'a, Expression<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ImportDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, /// `None` for `import 'foo'`, `Some([])` for `import {} from 'foo'` pub specifiers: Option>>, @@ -2307,9 +2396,10 @@ pub struct ImportDeclaration<'a> { pub import_kind: ImportOrExportKind, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ImportDeclarationSpecifier<'a> { /// import {imported} from "source" /// import {imported as local} from "source" @@ -2322,11 +2412,12 @@ pub enum ImportDeclarationSpecifier<'a> { // import {imported} from "source" // import {imported as local} from "source" -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ImportSpecifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub imported: ModuleExportName<'a>, pub local: BindingIdentifier<'a>, @@ -2334,48 +2425,53 @@ pub struct ImportSpecifier<'a> { } // import local from "source" -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ImportDefaultSpecifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub local: BindingIdentifier<'a>, } // import * as local from "source" -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ImportNamespaceSpecifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub local: BindingIdentifier<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct WithClause<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub attributes_keyword: IdentifierName<'a>, // `with` or `assert` pub with_entries: Vec<'a, ImportAttribute<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ImportAttribute<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub key: ImportAttributeKey<'a>, pub value: StringLiteral<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ImportAttributeKey<'a> { Identifier(IdentifierName<'a>), StringLiteral(StringLiteral<'a>), @@ -2390,11 +2486,12 @@ impl<'a> ImportAttributeKey<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ExportNamedDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub declaration: Option>, pub specifiers: Vec<'a, ExportSpecifier<'a>>, @@ -2416,11 +2513,12 @@ impl<'a> ExportNamedDeclaration<'a> { /// export default HoistableDeclaration /// export default ClassDeclaration /// export default AssignmentExpression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct ExportDefaultDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub declaration: ExportDefaultDeclarationKind<'a>, pub exported: ModuleExportName<'a>, // `default` @@ -2432,11 +2530,12 @@ impl<'a> ExportDefaultDeclaration<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ExportAllDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub exported: Option>, pub source: StringLiteral<'a>, @@ -2450,11 +2549,12 @@ impl<'a> ExportAllDeclaration<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct ExportSpecifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub local: ModuleExportName<'a>, pub exported: ModuleExportName<'a>, @@ -2467,9 +2567,10 @@ impl<'a> ExportSpecifier<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ExportDefaultDeclarationKind<'a> { Expression(Expression<'a>), FunctionDeclaration(Box<'a, Function<'a>>), @@ -2497,9 +2598,10 @@ impl<'a> ExportDefaultDeclarationKind<'a> { /// * `export {foo as "\0 any unicode"}` /// * es2022: /// * -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum ModuleExportName<'a> { Identifier(IdentifierName<'a>), StringLiteral(StringLiteral<'a>), diff --git a/crates/oxc_ast/src/ast/jsx.rs b/crates/oxc_ast/src/ast/jsx.rs index c5b6cc7dd..2f6713531 100644 --- a/crates/oxc_ast/src/ast/jsx.rs +++ b/crates/oxc_ast/src/ast/jsx.rs @@ -1,6 +1,7 @@ //! [JSX](https://facebook.github.io/jsx) use oxc_allocator::{Box, Vec}; +use oxc_macros::SerAttrs; use oxc_span::{Atom, Span}; #[cfg(feature = "serde")] use serde::Serialize; @@ -12,11 +13,12 @@ use super::{js::*, literal::*, ts::*}; // 1.2 JSX Elements /// JSX Element -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct JSXElement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub opening_element: Box<'a, JSXOpeningElement<'a>>, pub closing_element: Option>>, @@ -24,11 +26,12 @@ pub struct JSXElement<'a> { } /// JSX Opening Element -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct JSXOpeningElement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub self_closing: bool, pub name: JSXElementName<'a>, @@ -37,47 +40,52 @@ pub struct JSXOpeningElement<'a> { } /// JSX Closing Element -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXClosingElement<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: JSXElementName<'a>, } /// JSX Fragment -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct JSXFragment<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub opening_fragment: JSXOpeningFragment, pub closing_fragment: JSXClosingFragment, pub children: Vec<'a, JSXChild<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXOpeningFragment { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXClosingFragment { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } /// JSX Element Name -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXElementName<'a> { /// `` Identifier(JSXIdentifier<'a>), @@ -88,11 +96,12 @@ pub enum JSXElementName<'a> { } /// JSX Namespaced Name -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXNamespacedName<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub namespace: JSXIdentifier<'a>, pub property: JSXIdentifier<'a>, @@ -105,11 +114,12 @@ impl<'a> std::fmt::Display for JSXNamespacedName<'a> { } /// JSX Member Expression -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXMemberExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub object: JSXMemberExpressionObject<'a>, pub property: JSXIdentifier<'a>, @@ -124,56 +134,62 @@ impl<'a> JSXMemberExpression<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXMemberExpressionObject<'a> { Identifier(JSXIdentifier<'a>), MemberExpression(Box<'a, JSXMemberExpression<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXExpressionContainer<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: JSXExpression<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXExpression<'a> { Expression(Expression<'a>), EmptyExpression(JSXEmptyExpression), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXEmptyExpression { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } // 1.3 JSX Attributes /// JSX Attributes -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXAttributeItem<'a> { Attribute(Box<'a, JSXAttribute<'a>>), SpreadAttribute(Box<'a, JSXSpreadAttribute<'a>>), } /// JSX Attribute -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXAttribute<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: JSXAttributeName<'a>, pub value: Option>, @@ -186,28 +202,31 @@ impl<'a> JSXAttribute<'a> { } /// JSX Spread Attribute -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXSpreadAttribute<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: Expression<'a>, } /// JSX Attribute Name -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXAttributeName<'a> { Identifier(JSXIdentifier<'a>), NamespacedName(Box<'a, JSXNamespacedName<'a>>), } /// JSX Attribute Value -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXAttributeValue<'a> { StringLiteral(StringLiteral<'a>), ExpressionContainer(JSXExpressionContainer<'a>), @@ -215,11 +234,12 @@ pub enum JSXAttributeValue<'a> { Fragment(Box<'a, JSXFragment<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXIdentifier<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, } @@ -227,9 +247,10 @@ pub struct JSXIdentifier<'a> { // 1.4 JSX Children /// JSX Child -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum JSXChild<'a> { Text(JSXText<'a>), Element(Box<'a, JSXElement<'a>>), @@ -238,20 +259,22 @@ pub enum JSXChild<'a> { Spread(JSXSpreadChild<'a>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXSpreadChild<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct JSXText<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub value: Atom<'a>, } diff --git a/crates/oxc_ast/src/ast/literal.rs b/crates/oxc_ast/src/ast/literal.rs index 6a27e9d6b..5d2383702 100644 --- a/crates/oxc_ast/src/ast/literal.rs +++ b/crates/oxc_ast/src/ast/literal.rs @@ -6,6 +6,7 @@ use std::{ }; use bitflags::bitflags; +use oxc_macros::SerAttrs; use oxc_span::{Atom, Span}; use oxc_syntax::{BigintBase, NumberBase}; #[cfg(feature = "serde")] @@ -13,11 +14,12 @@ use serde::Serialize; #[cfg(feature = "wasm")] use tsify::Tsify; -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct BooleanLiteral { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub value: bool, } @@ -36,11 +38,12 @@ impl BooleanLiteral { } } -#[derive(Debug, Clone)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Clone, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct NullLiteral { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } @@ -56,15 +59,16 @@ impl NullLiteral { } } -#[derive(Debug, Clone)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Clone, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct NumericLiteral<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub value: f64, pub raw: &'a str, - #[cfg_attr(feature = "serde", serde(skip))] + #[serde(skip)] pub base: NumberBase, } @@ -107,14 +111,15 @@ impl<'a> Hash for NumericLiteral<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct BigIntLiteral<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub raw: Atom<'a>, - #[cfg_attr(feature = "serde", serde(skip))] + #[serde(skip)] pub base: BigintBase, } @@ -124,11 +129,12 @@ impl<'a> BigIntLiteral<'a> { } } -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct RegExpLiteral<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, // valid regex is printed as {} // invalid regex is printed as null, which we can't implement yet @@ -233,11 +239,12 @@ impl fmt::Display for RegExpFlags { #[cfg_attr(feature = "wasm", derive(Tsify))] pub struct EmptyObject; -#[derive(Debug, Clone, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Clone, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct StringLiteral<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub value: Atom<'a>, } diff --git a/crates/oxc_ast/src/ast/ts.rs b/crates/oxc_ast/src/ast/ts.rs index 67b6e4c04..404b21b70 100644 --- a/crates/oxc_ast/src/ast/ts.rs +++ b/crates/oxc_ast/src/ast/ts.rs @@ -4,6 +4,7 @@ //! [Archived TypeScript spec](https://github.com/microsoft/TypeScript/blob/3c99d50da5a579d9fa92d02664b1b66d4ff55944/doc/spec-ARCHIVED.md) use oxc_allocator::{Box, Vec}; +use oxc_macros::SerAttrs; use oxc_span::{Atom, GetSpan, Span}; #[cfg(feature = "serde")] use serde::Serialize; @@ -22,11 +23,12 @@ export interface TSIndexSignatureName extends Span { } "#; -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSThisParameter<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub this: IdentifierName<'a>, pub type_annotation: Option>>, @@ -35,11 +37,12 @@ pub struct TSThisParameter<'a> { /// Enum Declaration /// /// `const_opt` enum `BindingIdentifier` { `EnumBody_opt` } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSEnumDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: BindingIdentifier<'a>, pub members: Vec<'a, TSEnumMember<'a>>, @@ -47,19 +50,21 @@ pub struct TSEnumDeclaration<'a> { pub modifiers: Modifiers<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSEnumMember<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: TSEnumMemberName<'a>, pub initializer: Option>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum TSEnumMemberName<'a> { Identifier(IdentifierName<'a>), StringLiteral(StringLiteral<'a>), @@ -69,27 +74,30 @@ pub enum TSEnumMemberName<'a> { NumericLiteral(NumericLiteral<'a>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeAnnotation<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSLiteralType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub literal: TSLiteral<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged, rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged, rename_all = "camelCase")] pub enum TSLiteral<'a> { BooleanLiteral(Box<'a, BooleanLiteral>), NullLiteral(Box<'a, NullLiteral>), @@ -101,9 +109,10 @@ pub enum TSLiteral<'a> { UnaryExpression(Box<'a, UnaryExpression<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged, rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged, rename_all = "camelCase")] pub enum TSType<'a> { // Keyword TSAnyKeyword(Box<'a, TSAnyKeyword>), @@ -165,11 +174,12 @@ impl<'a> TSType<'a> { /// `SomeType extends OtherType ? TrueType : FalseType;` /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSConditionalType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub check_type: TSType<'a>, pub extends_type: TSType<'a>, @@ -180,11 +190,12 @@ pub struct TSConditionalType<'a> { /// string | string[] | (() => string) | { s: string } /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSUnionType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub types: Vec<'a, TSType<'a>>, } @@ -192,11 +203,12 @@ pub struct TSUnionType<'a> { /// type `ColorfulCircle` = Colorful & Circle; /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSIntersectionType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub types: Vec<'a, TSType<'a>>, } @@ -204,19 +216,21 @@ pub struct TSIntersectionType<'a> { /// keyof unique readonly /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeOperator<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub operator: TSTypeOperatorOperator, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum TSTypeOperatorOperator { Keyof, Unique, @@ -226,11 +240,12 @@ pub enum TSTypeOperatorOperator { /// `let myArray: string[] = ["hello", "world"];` /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSArrayType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub element_type: TSType<'a>, } @@ -238,11 +253,12 @@ pub struct TSArrayType<'a> { /// `type I1 = Person["age" | "name"];` /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSIndexedAccessType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub object_type: TSType<'a>, pub index_type: TSType<'a>, @@ -251,47 +267,52 @@ pub struct TSIndexedAccessType<'a> { /// type `StringNumberPair` = [string, number]; /// /// -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTupleType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub element_types: Vec<'a, TSTupleElement<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSNamedTupleMember<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub element_type: TSType<'a>, pub label: IdentifierName<'a>, pub optional: bool, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSOptionalType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSRestType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged, rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged, rename_all = "camelCase")] pub enum TSTupleElement<'a> { TSType(TSType<'a>), TSOptionalType(Box<'a, TSOptionalType<'a>>), @@ -299,118 +320,132 @@ pub enum TSTupleElement<'a> { TSNamedTupleMember(Box<'a, TSNamedTupleMember<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSAnyKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSStringKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSBooleanKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSNumberKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSNeverKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSUnknownKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSNullKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSUndefinedKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSVoidKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSSymbolKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSThisType { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSObjectKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type")] pub struct TSBigIntKeyword { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } /// type C = A; /// type D = B.a; /// type E = D.c.b.a; -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeReference<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_name: TSTypeName<'a>, pub type_parameters: Option>>, @@ -419,9 +454,10 @@ pub struct TSTypeReference<'a> { /// TypeName: /// IdentifierReference /// NamespaceName . IdentifierReference -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum TSTypeName<'a> { IdentifierReference(Box<'a, IdentifierReference<'a>>), QualifiedName(Box<'a, TSQualifiedName<'a>>), @@ -462,30 +498,33 @@ impl GetSpan for TSTypeName<'_> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSQualifiedName<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub left: TSTypeName<'a>, pub right: IdentifierName<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeParameterInstantiation<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub params: Vec<'a, TSType<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeParameter<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: BindingIdentifier<'a>, pub constraint: Option>, @@ -495,20 +534,22 @@ pub struct TSTypeParameter<'a> { pub r#const: bool, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeParameterDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub params: Vec<'a, Box<'a, TSTypeParameter<'a>>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeAliasDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: BindingIdentifier<'a>, pub type_annotation: TSType<'a>, @@ -517,20 +558,22 @@ pub struct TSTypeAliasDeclaration<'a> { pub modifiers: Modifiers<'a>, } -#[derive(Debug, Hash, Clone, PartialEq, Eq, Copy)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Hash, Clone, PartialEq, Eq, Copy, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum TSAccessibility { Private, Protected, Public, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSClassImplements<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: TSTypeName<'a>, pub type_parameters: Option>>, @@ -539,11 +582,12 @@ pub struct TSClassImplements<'a> { /// Interface Declaration /// /// interface `BindingIdentifier` `TypeParameters_opt` `InterfaceExtendsClause_opt` `ObjectType` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSInterfaceDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: BindingIdentifier<'a>, pub body: Box<'a, TSInterfaceBody<'a>>, @@ -553,20 +597,22 @@ pub struct TSInterfaceDeclaration<'a> { pub modifiers: Modifiers<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSInterfaceBody<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub body: Vec<'a, TSSignature<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSPropertySignature<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub computed: bool, pub optional: bool, @@ -575,9 +621,10 @@ pub struct TSPropertySignature<'a> { pub type_annotation: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged, rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged, rename_all = "camelCase")] pub enum TSSignature<'a> { TSIndexSignature(Box<'a, TSIndexSignature<'a>>), TSPropertySignature(Box<'a, TSPropertySignature<'a>>), @@ -586,22 +633,24 @@ pub enum TSSignature<'a> { TSMethodSignature(Box<'a, TSMethodSignature<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSIndexSignature<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub parameters: Vec<'a, Box<'a, TSIndexSignatureName<'a>>>, pub type_annotation: Box<'a, TSTypeAnnotation<'a>>, pub readonly: bool, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSCallSignatureDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub this_param: Option>, pub params: Box<'a, FormalParameters<'a>>, @@ -609,20 +658,22 @@ pub struct TSCallSignatureDeclaration<'a> { pub type_parameters: Option>>, } -#[derive(Debug, Clone, Copy, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Clone, Copy, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum TSMethodSignatureKind { Method, Get, Set, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSMethodSignature<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub key: PropertyKey<'a>, pub computed: bool, @@ -634,64 +685,66 @@ pub struct TSMethodSignature<'a> { pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSConstructSignatureDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub params: Box<'a, FormalParameters<'a>>, pub return_type: Option>>, pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr( - feature = "serde", - derive(Serialize), - serde(tag = "type", rename = "Identifier", rename_all = "camelCase") -)] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] +#[serde(tag = "type", rename = "Identifier", rename_all = "camelCase")] pub struct TSIndexSignatureName<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: Atom<'a>, pub type_annotation: Box<'a, TSTypeAnnotation<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSInterfaceHeritage<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypePredicate<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub parameter_name: TSTypePredicateName<'a>, pub asserts: bool, pub type_annotation: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged, rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged, rename_all = "camelCase")] pub enum TSTypePredicateName<'a> { Identifier(IdentifierName<'a>), This(TSThisType), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSModuleDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: TSModuleDeclarationName<'a>, pub body: TSModuleDeclarationBody<'a>, @@ -709,18 +762,20 @@ pub struct TSModuleDeclaration<'a> { pub modifiers: Modifiers<'a>, } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "lowercase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "lowercase")] pub enum TSModuleDeclarationKind { Global, Module, Namespace, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum TSModuleDeclarationName<'a> { Identifier(IdentifierName<'a>), StringLiteral(StringLiteral<'a>), @@ -735,64 +790,71 @@ impl<'a> TSModuleDeclarationName<'a> { } } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum TSModuleDeclarationBody<'a> { TSModuleDeclaration(Box<'a, TSModuleDeclaration<'a>>), TSModuleBlock(Box<'a, TSModuleBlock<'a>>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSModuleBlock<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub body: Vec<'a, Statement<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeLiteral<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub members: Vec<'a, TSSignature<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSInferType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_parameter: Box<'a, TSTypeParameter<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeQuery<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expr_name: TSTypeQueryExprName<'a>, pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum TSTypeQueryExprName<'a> { TSTypeName(TSTypeName<'a>), TSImportType(TSImportType<'a>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSImportType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub argument: TSType<'a>, pub qualifier: Option>, @@ -800,38 +862,42 @@ pub struct TSImportType<'a> { pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSImportAttributes<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub elements: Vec<'a, TSImportAttribute<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSImportAttribute<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub name: TSImportAttributeName<'a>, pub value: Expression<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged)] pub enum TSImportAttributeName<'a> { Identifier(IdentifierName<'a>), StringLiteral(StringLiteral<'a>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSFunctionType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub this_param: Option>, pub params: Box<'a, FormalParameters<'a>>, @@ -839,11 +905,12 @@ pub struct TSFunctionType<'a> { pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSConstructorType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub r#abstract: bool, pub params: Box<'a, FormalParameters<'a>>, @@ -851,11 +918,12 @@ pub struct TSConstructorType<'a> { pub type_parameters: Option>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSMappedType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_parameter: Box<'a, TSTypeParameter<'a>>, pub name_type: Option>, @@ -864,100 +932,110 @@ pub struct TSMappedType<'a> { pub readonly: TSMappedTypeModifierOperator, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub enum TSMappedTypeModifierOperator { True, - #[cfg_attr(feature = "serde", serde(rename = "+"))] + #[serde(rename = "+")] Plus, - #[cfg_attr(feature = "serde", serde(rename = "-"))] + #[serde(rename = "-")] Minus, None, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTemplateLiteralType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub quasis: Vec<'a, TemplateElement<'a>>, pub types: Vec<'a, TSType<'a>>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSAsExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSSatisfiesExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSTypeAssertion<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, pub type_annotation: TSType<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSImportEqualsDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: BindingIdentifier<'a>, pub module_reference: Box<'a, TSModuleReference<'a>>, pub import_kind: ImportOrExportKind, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(untagged, rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(untagged, rename_all = "camelCase")] pub enum TSModuleReference<'a> { TypeName(TSTypeName<'a>), ExternalModuleReference(TSExternalModuleReference<'a>), } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSExternalModuleReference<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: StringLiteral<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSNonNullExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct Decorator<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, } @@ -983,9 +1061,10 @@ impl<'a> Decorator<'a> { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub enum ModifierKind { Abstract, Accessor, @@ -1004,18 +1083,20 @@ pub enum ModifierKind { Override, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct Modifier { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub kind: ModifierKind, } -#[derive(Debug, Default, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(transparent))] +#[derive(Debug, Default, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(transparent)] pub struct Modifiers<'a>(Option>); impl<'a> Modifiers<'a> { @@ -1045,11 +1126,12 @@ impl<'a> Modifiers<'a> { /// Export Assignment in non-module files /// /// `export = foo` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSExportAssignment<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, } @@ -1057,28 +1139,31 @@ pub struct TSExportAssignment<'a> { /// Namespace Export Declaration in declaration files /// /// `export as namespace foo` -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSNamespaceExportDeclaration<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub id: IdentifierName<'a>, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct TSInstantiationExpression<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub expression: Expression<'a>, pub type_parameters: Box<'a, TSTypeParameterInstantiation<'a>>, } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub enum ImportOrExportKind { Value, Type, @@ -1096,20 +1181,22 @@ impl ImportOrExportKind { // [`JSDoc`](https://github.com/microsoft/TypeScript/blob/54a554d8af2657630307cbfa8a3e4f3946e36507/src/compiler/types.ts#L393) -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct JSDocNullableType<'a> { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, pub type_annotation: TSType<'a>, pub postfix: bool, } -#[derive(Debug, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(tag = "type", rename_all = "camelCase"))] +#[derive(Debug, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(tag = "type", rename_all = "camelCase")] pub struct JSDocUnknownType { - #[cfg_attr(feature = "serde", serde(flatten))] + #[serde(flatten)] pub span: Span, } diff --git a/crates/oxc_macros/src/lib.rs b/crates/oxc_macros/src/lib.rs index 1b1cf024d..8d4017ec5 100644 --- a/crates/oxc_macros/src/lib.rs +++ b/crates/oxc_macros/src/lib.rs @@ -58,3 +58,12 @@ 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() +} diff --git a/crates/oxc_semantic/Cargo.toml b/crates/oxc_semantic/Cargo.toml index 6f8dc0c0b..fc5f06f15 100644 --- a/crates/oxc_semantic/Cargo.toml +++ b/crates/oxc_semantic/Cargo.toml @@ -25,6 +25,7 @@ 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 } diff --git a/crates/oxc_semantic/src/reference.rs b/crates/oxc_semantic/src/reference.rs index c7fb67aba..0fef24e21 100644 --- a/crates/oxc_semantic/src/reference.rs +++ b/crates/oxc_semantic/src/reference.rs @@ -1,3 +1,4 @@ +use oxc_macros::SerAttrs; use oxc_span::{CompactStr, Span}; #[cfg(feature = "serde")] use serde::Serialize; @@ -8,9 +9,10 @@ use crate::{symbol::SymbolId, AstNodeId}; pub use oxc_syntax::reference::{ReferenceFlag, ReferenceId}; -#[derive(Debug, Clone)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct Reference { span: Span, /// The name of the identifier that was referred to diff --git a/crates/oxc_semantic/src/symbol.rs b/crates/oxc_semantic/src/symbol.rs index 7dd9e1b51..02027100c 100644 --- a/crates/oxc_semantic/src/symbol.rs +++ b/crates/oxc_semantic/src/symbol.rs @@ -1,5 +1,6 @@ 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, @@ -25,9 +26,10 @@ export type IndexVec = Array; /// Symbol Table /// /// `SoA` (Struct of Arrays) for memory efficiency. -#[derive(Debug, Default)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Default, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct SymbolTable { pub spans: IndexVec, pub names: IndexVec, diff --git a/crates/oxc_span/Cargo.toml b/crates/oxc_span/Cargo.toml index ce596e444..ee9bace93 100644 --- a/crates/oxc_span/Cargo.toml +++ b/crates/oxc_span/Cargo.toml @@ -19,6 +19,8 @@ workspace = true doctest = false [dependencies] +oxc_macros = { workspace = true } + miette = { workspace = true } compact_str = { version = "0.7.1" } diff --git a/crates/oxc_span/src/source_type.rs b/crates/oxc_span/src/source_type.rs index 1bc21b6bf..de1312fac 100644 --- a/crates/oxc_span/src/source_type.rs +++ b/crates/oxc_span/src/source_type.rs @@ -1,14 +1,17 @@ use std::path::Path; +use oxc_macros::SerAttrs; + #[cfg(feature = "serde")] use serde::Serialize; #[cfg(feature = "wasm")] use tsify::Tsify; /// Source Type for JavaScript vs TypeScript / Script vs Module / JSX -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub struct SourceType { /// JavaScript or TypeScript, default JavaScript language: Language, @@ -25,30 +28,33 @@ pub struct SourceType { } /// JavaScript or TypeScript -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub enum Language { JavaScript, - #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))] + #[serde(rename_all = "camelCase")] TypeScript { is_definition_file: bool, }, } /// Script or Module -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub enum ModuleKind { Script, Module, } /// JSX for JavaScript and TypeScript -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "serde", derive(Serialize), serde(rename_all = "camelCase"))] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] +#[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] +#[serde(rename_all = "camelCase")] pub enum LanguageVariant { Standard, Jsx, diff --git a/crates/oxc_syntax/Cargo.toml b/crates/oxc_syntax/Cargo.toml index 9df2674e1..24aec5c0b 100644 --- a/crates/oxc_syntax/Cargo.toml +++ b/crates/oxc_syntax/Cargo.toml @@ -19,8 +19,9 @@ workspace = true doctest = false [dependencies] -oxc_index = { workspace = true } -oxc_span = { workspace = true } +oxc_index = { workspace = true } +oxc_macros = { workspace = true } +oxc_span = { workspace = true } unicode-id-start = { workspace = true } serde = { workspace = true, features = ["derive"], optional = true } diff --git a/crates/oxc_syntax/src/assumptions.rs b/crates/oxc_syntax/src/assumptions.rs index 9cf584a89..d78ce2fe8 100644 --- a/crates/oxc_syntax/src/assumptions.rs +++ b/crates/oxc_syntax/src/assumptions.rs @@ -1,15 +1,17 @@ +use oxc_macros::SerAttrs; + #[cfg(feature = "serde")] use serde::Deserialize; /// Compiler assumptions /// /// See -#[derive(Debug, Default, Clone, Copy)] +#[derive(Debug, Default, Clone, Copy, SerAttrs)] #[cfg_attr(feature = "serde", derive(Deserialize))] -#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))] +#[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 . - #[cfg_attr(feature = "serde", serde(default))] + #[serde(default)] pub no_document_all: bool, } diff --git a/crates/oxc_syntax/src/operator.rs b/crates/oxc_syntax/src/operator.rs index 74a049e5d..7586c532d 100644 --- a/crates/oxc_syntax/src/operator.rs +++ b/crates/oxc_syntax/src/operator.rs @@ -1,3 +1,5 @@ +use oxc_macros::SerAttrs; + #[cfg(feature = "serde")] use serde::Serialize; #[cfg(feature = "wasm")] @@ -5,41 +7,41 @@ use tsify::Tsify; use crate::precedence::{GetPrecedence, Precedence}; -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] #[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] pub enum AssignmentOperator { - #[cfg_attr(feature = "serde", serde(rename = "="))] + #[serde(rename = "=")] Assign, - #[cfg_attr(feature = "serde", serde(rename = "+="))] + #[serde(rename = "+=")] Addition, - #[cfg_attr(feature = "serde", serde(rename = "-="))] + #[serde(rename = "-=")] Subtraction, - #[cfg_attr(feature = "serde", serde(rename = "*="))] + #[serde(rename = "*=")] Multiplication, - #[cfg_attr(feature = "serde", serde(rename = "/="))] + #[serde(rename = "/=")] Division, - #[cfg_attr(feature = "serde", serde(rename = "%="))] + #[serde(rename = "%=")] Remainder, - #[cfg_attr(feature = "serde", serde(rename = "<<="))] + #[serde(rename = "<<=")] ShiftLeft, - #[cfg_attr(feature = "serde", serde(rename = ">>="))] + #[serde(rename = ">>=")] ShiftRight, - #[cfg_attr(feature = "serde", serde(rename = ">>>="))] + #[serde(rename = ">>>=")] ShiftRightZeroFill, - #[cfg_attr(feature = "serde", serde(rename = "|="))] + #[serde(rename = "|=")] BitwiseOR, - #[cfg_attr(feature = "serde", serde(rename = "^="))] + #[serde(rename = "^=")] BitwiseXOR, - #[cfg_attr(feature = "serde", serde(rename = "&="))] + #[serde(rename = "&=")] BitwiseAnd, - #[cfg_attr(feature = "serde", serde(rename = "&&="))] + #[serde(rename = "&&=")] LogicalAnd, - #[cfg_attr(feature = "serde", serde(rename = "||="))] + #[serde(rename = "||=")] LogicalOr, - #[cfg_attr(feature = "serde", serde(rename = "??="))] + #[serde(rename = "??=")] LogicalNullish, - #[cfg_attr(feature = "serde", serde(rename = "**="))] + #[serde(rename = "**=")] Exponential, } @@ -84,53 +86,53 @@ impl AssignmentOperator { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] #[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] pub enum BinaryOperator { - #[cfg_attr(feature = "serde", serde(rename = "=="))] + #[serde(rename = "==")] Equality, - #[cfg_attr(feature = "serde", serde(rename = "!="))] + #[serde(rename = "!=")] Inequality, - #[cfg_attr(feature = "serde", serde(rename = "==="))] + #[serde(rename = "===")] StrictEquality, - #[cfg_attr(feature = "serde", serde(rename = "!=="))] + #[serde(rename = "!==")] StrictInequality, - #[cfg_attr(feature = "serde", serde(rename = "<"))] + #[serde(rename = "<")] LessThan, - #[cfg_attr(feature = "serde", serde(rename = "<="))] + #[serde(rename = "<=")] LessEqualThan, - #[cfg_attr(feature = "serde", serde(rename = ">"))] + #[serde(rename = ">")] GreaterThan, - #[cfg_attr(feature = "serde", serde(rename = ">="))] + #[serde(rename = ">=")] GreaterEqualThan, - #[cfg_attr(feature = "serde", serde(rename = "<<"))] + #[serde(rename = "<<")] ShiftLeft, - #[cfg_attr(feature = "serde", serde(rename = ">>"))] + #[serde(rename = ">>")] ShiftRight, - #[cfg_attr(feature = "serde", serde(rename = ">>>"))] + #[serde(rename = ">>>")] ShiftRightZeroFill, - #[cfg_attr(feature = "serde", serde(rename = "+"))] + #[serde(rename = "+")] Addition, - #[cfg_attr(feature = "serde", serde(rename = "-"))] + #[serde(rename = "-")] Subtraction, - #[cfg_attr(feature = "serde", serde(rename = "*"))] + #[serde(rename = "*")] Multiplication, - #[cfg_attr(feature = "serde", serde(rename = "/"))] + #[serde(rename = "/")] Division, - #[cfg_attr(feature = "serde", serde(rename = "%"))] + #[serde(rename = "%")] Remainder, - #[cfg_attr(feature = "serde", serde(rename = "|"))] + #[serde(rename = "|")] BitwiseOR, - #[cfg_attr(feature = "serde", serde(rename = "^"))] + #[serde(rename = "^")] BitwiseXOR, - #[cfg_attr(feature = "serde", serde(rename = "&"))] + #[serde(rename = "&")] BitwiseAnd, - #[cfg_attr(feature = "serde", serde(rename = "in"))] + #[serde(rename = "in")] In, - #[cfg_attr(feature = "serde", serde(rename = "instanceof"))] + #[serde(rename = "instanceof")] Instanceof, - #[cfg_attr(feature = "serde", serde(rename = "**"))] + #[serde(rename = "**")] Exponential, } @@ -271,15 +273,15 @@ impl GetPrecedence for BinaryOperator { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] #[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] pub enum LogicalOperator { - #[cfg_attr(feature = "serde", serde(rename = "||"))] + #[serde(rename = "||")] Or, - #[cfg_attr(feature = "serde", serde(rename = "&&"))] + #[serde(rename = "&&")] And, - #[cfg_attr(feature = "serde", serde(rename = "??"))] + #[serde(rename = "??")] Coalesce, } @@ -303,23 +305,23 @@ impl GetPrecedence for LogicalOperator { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] #[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] pub enum UnaryOperator { - #[cfg_attr(feature = "serde", serde(rename = "-"))] + #[serde(rename = "-")] UnaryNegation, - #[cfg_attr(feature = "serde", serde(rename = "+"))] + #[serde(rename = "+")] UnaryPlus, - #[cfg_attr(feature = "serde", serde(rename = "!"))] + #[serde(rename = "!")] LogicalNot, - #[cfg_attr(feature = "serde", serde(rename = "~"))] + #[serde(rename = "~")] BitwiseNot, - #[cfg_attr(feature = "serde", serde(rename = "typeof"))] + #[serde(rename = "typeof")] Typeof, - #[cfg_attr(feature = "serde", serde(rename = "void"))] + #[serde(rename = "void")] Void, - #[cfg_attr(feature = "serde", serde(rename = "delete"))] + #[serde(rename = "delete")] Delete, } @@ -349,13 +351,13 @@ impl UnaryOperator { } } -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SerAttrs)] #[cfg_attr(feature = "serde", derive(Serialize))] #[cfg_attr(feature = "wasm", derive(Tsify))] pub enum UpdateOperator { - #[cfg_attr(feature = "serde", serde(rename = "++"))] + #[serde(rename = "++")] Increment, - #[cfg_attr(feature = "serde", serde(rename = "--"))] + #[serde(rename = "--")] Decrement, }