diff --git a/compiler/forget/crates/estree-codegen/src/codegen.rs b/compiler/forget/crates/estree-codegen/src/codegen.rs
index e45f003b64..fbc5f64c26 100644
--- a/compiler/forget/crates/estree-codegen/src/codegen.rs
+++ b/compiler/forget/crates/estree-codegen/src/codegen.rs
@@ -33,11 +33,6 @@ impl Grammar {
             operators,
         } = self;
 
-        let enum_names: HashSet<String> = enums.keys().cloned().collect();
-
-        let mut node_names: Vec<_> = nodes.keys().cloned().collect();
-        node_names.sort();
-
         let objects: Vec<_> = objects
             .iter()
             .map(|(name, object)| object.codegen(name))
@@ -48,7 +43,7 @@ impl Grammar {
             .collect();
         let enums: Vec<_> = enums
             .iter()
-            .map(|(name, enum_)| enum_.codegen(name, &enum_names))
+            .map(|(name, enum_)| enum_.codegen(name, &enums))
             .collect();
         let operators: Vec<_> = operators
             .iter()
@@ -223,7 +218,7 @@ pub struct Enum {
 }
 
 impl Enum {
-    pub fn codegen(&self, name: &str, enums: &HashSet<String>) -> TokenStream {
+    pub fn codegen(&self, name: &str, enums: &IndexMap<String, Enum>) -> TokenStream {
         let mut sorted_variants: Vec<_> = self.variants.iter().collect();
         sorted_variants.sort();
 
@@ -232,7 +227,7 @@ impl Enum {
             .iter()
             .map(|name| {
                 let variant = format_ident!("{}", name);
-                if enums.contains(*name) {
+                if enums.contains_key(*name) {
                     quote!(#variant(#variant))
                 } else {
                     quote!(#variant(Box<#variant>))
@@ -245,7 +240,7 @@ impl Enum {
                 #(#variants),*
             }
         };
-        let enum_ = if sorted_variants.iter().any(|name| enums.contains(*name)) {
+        let enum_ = if sorted_variants.iter().any(|name| enums.contains_key(*name)) {
             // contains recursive enum, use untagged serialization
             quote! {
                 #[serde(untagged)]
@@ -258,9 +253,92 @@ impl Enum {
             }
         };
 
+        let enum_tag = format_ident!("__{}Tag", name);
+        let mut seen = HashSet::new();
+
+        // tag_variants is used to generate an enum of all the possible type tags (`type` values)
+        // that can appear in this enum. we emit this enum and derive a deserializer for it so that
+        // our enum deserializer can first decode the tag in order to know how to decode the data
+        let mut tag_variants = Vec::new();
+
+        // once the tag is decoded, we need to match against it and deserialize according the tag (`type`)
+        // tag_matches are the match arms for each type.
+        let mut tag_matches = Vec::new();
+
+        // Imagine a case like:
+        // enum ModuleItem {
+        //   ImportDeclaration, // struct
+        //   Statement // another enum
+        // }
+        // We need to generate matches for all the possible *concrete* `type` values, which means
+        // we have to expand nested enums such as `Statement`
+        for variant in self.variants.iter() {
+            if let Some(nested_enum) = enums.get(variant) {
+                let outer_variant = format_ident!("{}", variant);
+                for variant in nested_enum.variants.iter() {
+                    // Skip variants that appear in multiple nested enums, we deserialize
+                    // as the first listed outer variant
+                    if !seen.insert(variant.to_string()) {
+                        continue;
+                    }
+                    // Modeling ESTree only requires a single level of nested enums,
+                    // so that's all we support. Though in theory we could support arbitrary nesting,
+                    // since ultimately we're matching based on the final concrete types.
+                    assert!(!enums.contains_key(variant));
+
+                    let inner_variant = format_ident!("{}", variant);
+                    tag_variants.push(quote!(#inner_variant));
+
+                    tag_matches.push(quote! {
+                        #enum_tag::#inner_variant => {
+                            let node: Box<#inner_variant> = <Box<#inner_variant> as Deserialize>::deserialize(
+                                serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                            )?;
+                            Ok(#name::#outer_variant(#outer_variant::#inner_variant(node)))
+                        }
+                    });
+                }
+            } else {
+                if !seen.insert(variant.to_string()) {
+                    panic!(
+                        "Concrete variant {} was already added by a nested enum",
+                        variant
+                    );
+                }
+                let variant_name = format_ident!("{}", variant);
+                tag_variants.push(quote!(#variant_name));
+
+                tag_matches.push(quote! {
+                    #enum_tag::#variant_name => {
+                        let node: Box<#variant_name> = <Box<#variant_name> as Deserialize>::deserialize(
+                            serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                        )?;
+                        Ok(#name::#variant_name(node))
+                    }
+                })
+            }
+        }
         quote! {
-            #[derive(Serialize, Deserialize, Clone, Debug)]
+            #[derive(Serialize, Clone, Debug)]
             #enum_
+
+            #[derive(Deserialize, Debug)]
+            enum #enum_tag {
+                #(#tag_variants),*
+            }
+
+            impl <'de> serde::Deserialize<'de> for #name {
+                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                where D: serde::Deserializer<'de> {
+                    let tagged = serde::Deserializer::deserialize_any(
+                        deserializer,
+                        serde::__private::de::TaggedContentVisitor::<#enum_tag>::new("type", "Pattern")
+                    )?;
+                    match tagged.0 {
+                        #(#tag_matches),*
+                    }
+                }
+            }
         }
     }
 }
diff --git a/compiler/forget/crates/estree/src/generated.rs b/compiler/forget/crates/estree/src/generated.rs
index 41abb8efe2..eb74c114f8 100644
--- a/compiler/forget/crates/estree/src/generated.rs
+++ b/compiler/forget/crates/estree/src/generated.rs
@@ -476,7 +476,7 @@ pub struct ImportNamespaceSpecifier {
     #[serde(default)]
     pub range: Option<SourceRange>,
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum Statement {
     BlockStatement(Box<BlockStatement>),
@@ -500,7 +500,205 @@ pub enum Statement {
     WhileStatement(Box<WhileStatement>),
     WithStatement(Box<WithStatement>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __StatementTag {
+    BlockStatement,
+    BreakStatement,
+    ContinueStatement,
+    DebuggerStatement,
+    DoWhileStatement,
+    EmptyStatement,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    IfStatement,
+    LabeledStatement,
+    ReturnStatement,
+    SwitchStatement,
+    ThrowStatement,
+    TryStatement,
+    VariableDeclaration,
+    WhileStatement,
+    WithStatement,
+}
+impl<'de> serde::Deserialize<'de> for Statement {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __StatementTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __StatementTag::BlockStatement => {
+                let node: Box<BlockStatement> = <Box<
+                    BlockStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::BlockStatement(node))
+            }
+            __StatementTag::BreakStatement => {
+                let node: Box<BreakStatement> = <Box<
+                    BreakStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::BreakStatement(node))
+            }
+            __StatementTag::ContinueStatement => {
+                let node: Box<ContinueStatement> = <Box<
+                    ContinueStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ContinueStatement(node))
+            }
+            __StatementTag::DebuggerStatement => {
+                let node: Box<DebuggerStatement> = <Box<
+                    DebuggerStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::DebuggerStatement(node))
+            }
+            __StatementTag::DoWhileStatement => {
+                let node: Box<DoWhileStatement> = <Box<
+                    DoWhileStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::DoWhileStatement(node))
+            }
+            __StatementTag::EmptyStatement => {
+                let node: Box<EmptyStatement> = <Box<
+                    EmptyStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::EmptyStatement(node))
+            }
+            __StatementTag::ExpressionStatement => {
+                let node: Box<ExpressionStatement> = <Box<
+                    ExpressionStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ExpressionStatement(node))
+            }
+            __StatementTag::ForInStatement => {
+                let node: Box<ForInStatement> = <Box<
+                    ForInStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ForInStatement(node))
+            }
+            __StatementTag::ForOfStatement => {
+                let node: Box<ForOfStatement> = <Box<
+                    ForOfStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ForOfStatement(node))
+            }
+            __StatementTag::ForStatement => {
+                let node: Box<ForStatement> = <Box<
+                    ForStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ForStatement(node))
+            }
+            __StatementTag::FunctionDeclaration => {
+                let node: Box<FunctionDeclaration> = <Box<
+                    FunctionDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::FunctionDeclaration(node))
+            }
+            __StatementTag::IfStatement => {
+                let node: Box<IfStatement> = <Box<
+                    IfStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::IfStatement(node))
+            }
+            __StatementTag::LabeledStatement => {
+                let node: Box<LabeledStatement> = <Box<
+                    LabeledStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::LabeledStatement(node))
+            }
+            __StatementTag::ReturnStatement => {
+                let node: Box<ReturnStatement> = <Box<
+                    ReturnStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ReturnStatement(node))
+            }
+            __StatementTag::SwitchStatement => {
+                let node: Box<SwitchStatement> = <Box<
+                    SwitchStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::SwitchStatement(node))
+            }
+            __StatementTag::ThrowStatement => {
+                let node: Box<ThrowStatement> = <Box<
+                    ThrowStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::ThrowStatement(node))
+            }
+            __StatementTag::TryStatement => {
+                let node: Box<TryStatement> = <Box<
+                    TryStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::TryStatement(node))
+            }
+            __StatementTag::VariableDeclaration => {
+                let node: Box<VariableDeclaration> = <Box<
+                    VariableDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::VariableDeclaration(node))
+            }
+            __StatementTag::WhileStatement => {
+                let node: Box<WhileStatement> = <Box<
+                    WhileStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::WhileStatement(node))
+            }
+            __StatementTag::WithStatement => {
+                let node: Box<WithStatement> = <Box<
+                    WithStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Statement::WithStatement(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum Expression {
     ArrayExpression(Box<ArrayExpression>),
@@ -522,71 +720,1593 @@ pub enum Expression {
     UpdateExpression(Box<UpdateExpression>),
     YieldExpression(Box<YieldExpression>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ExpressionTag {
+    ArrayExpression,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    BinaryExpression,
+    CallExpression,
+    ConditionalExpression,
+    FunctionExpression,
+    Identifier,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    NewExpression,
+    ObjectExpression,
+    SequenceExpression,
+    ThisExpression,
+    UnaryExpression,
+    UpdateExpression,
+    YieldExpression,
+}
+impl<'de> serde::Deserialize<'de> for Expression {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ExpressionTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ExpressionTag::ArrayExpression => {
+                let node: Box<ArrayExpression> = <Box<
+                    ArrayExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::ArrayExpression(node))
+            }
+            __ExpressionTag::ArrowFunctionExpression => {
+                let node: Box<ArrowFunctionExpression> = <Box<
+                    ArrowFunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::ArrowFunctionExpression(node))
+            }
+            __ExpressionTag::AssignmentExpression => {
+                let node: Box<AssignmentExpression> = <Box<
+                    AssignmentExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::AssignmentExpression(node))
+            }
+            __ExpressionTag::BinaryExpression => {
+                let node: Box<BinaryExpression> = <Box<
+                    BinaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::BinaryExpression(node))
+            }
+            __ExpressionTag::CallExpression => {
+                let node: Box<CallExpression> = <Box<
+                    CallExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::CallExpression(node))
+            }
+            __ExpressionTag::ConditionalExpression => {
+                let node: Box<ConditionalExpression> = <Box<
+                    ConditionalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::ConditionalExpression(node))
+            }
+            __ExpressionTag::FunctionExpression => {
+                let node: Box<FunctionExpression> = <Box<
+                    FunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::FunctionExpression(node))
+            }
+            __ExpressionTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::Identifier(node))
+            }
+            __ExpressionTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::Literal(node))
+            }
+            __ExpressionTag::LogicalExpression => {
+                let node: Box<LogicalExpression> = <Box<
+                    LogicalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::LogicalExpression(node))
+            }
+            __ExpressionTag::MemberExpression => {
+                let node: Box<MemberExpression> = <Box<
+                    MemberExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::MemberExpression(node))
+            }
+            __ExpressionTag::NewExpression => {
+                let node: Box<NewExpression> = <Box<
+                    NewExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::NewExpression(node))
+            }
+            __ExpressionTag::ObjectExpression => {
+                let node: Box<ObjectExpression> = <Box<
+                    ObjectExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::ObjectExpression(node))
+            }
+            __ExpressionTag::SequenceExpression => {
+                let node: Box<SequenceExpression> = <Box<
+                    SequenceExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::SequenceExpression(node))
+            }
+            __ExpressionTag::ThisExpression => {
+                let node: Box<ThisExpression> = <Box<
+                    ThisExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::ThisExpression(node))
+            }
+            __ExpressionTag::UnaryExpression => {
+                let node: Box<UnaryExpression> = <Box<
+                    UnaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::UnaryExpression(node))
+            }
+            __ExpressionTag::UpdateExpression => {
+                let node: Box<UpdateExpression> = <Box<
+                    UpdateExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::UpdateExpression(node))
+            }
+            __ExpressionTag::YieldExpression => {
+                let node: Box<YieldExpression> = <Box<
+                    YieldExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Expression::YieldExpression(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum ImportDeclarationSpecifier {
     ImportDefaultSpecifier(Box<ImportDefaultSpecifier>),
     ImportNamespaceSpecifier(Box<ImportNamespaceSpecifier>),
     ImportSpecifier(Box<ImportSpecifier>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ImportDeclarationSpecifierTag {
+    ImportSpecifier,
+    ImportDefaultSpecifier,
+    ImportNamespaceSpecifier,
+}
+impl<'de> serde::Deserialize<'de> for ImportDeclarationSpecifier {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ImportDeclarationSpecifierTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ImportDeclarationSpecifierTag::ImportSpecifier => {
+                let node: Box<ImportSpecifier> = <Box<
+                    ImportSpecifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ImportDeclarationSpecifier::ImportSpecifier(node))
+            }
+            __ImportDeclarationSpecifierTag::ImportDefaultSpecifier => {
+                let node: Box<ImportDefaultSpecifier> = <Box<
+                    ImportDefaultSpecifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ImportDeclarationSpecifier::ImportDefaultSpecifier(node))
+            }
+            __ImportDeclarationSpecifierTag::ImportNamespaceSpecifier => {
+                let node: Box<ImportNamespaceSpecifier> = <Box<
+                    ImportNamespaceSpecifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ImportDeclarationSpecifier::ImportNamespaceSpecifier(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ModuleItem {
     ImportOrExportDeclaration(ImportOrExportDeclaration),
     Statement(Statement),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ModuleItemTag {
+    ImportDeclaration,
+    BlockStatement,
+    BreakStatement,
+    ContinueStatement,
+    DebuggerStatement,
+    DoWhileStatement,
+    EmptyStatement,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    IfStatement,
+    LabeledStatement,
+    ReturnStatement,
+    SwitchStatement,
+    ThrowStatement,
+    TryStatement,
+    VariableDeclaration,
+    WhileStatement,
+    WithStatement,
+}
+impl<'de> serde::Deserialize<'de> for ModuleItem {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ModuleItemTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ModuleItemTag::ImportDeclaration => {
+                let node: Box<ImportDeclaration> = <Box<
+                    ImportDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    ModuleItem::ImportOrExportDeclaration(
+                        ImportOrExportDeclaration::ImportDeclaration(node),
+                    ),
+                )
+            }
+            __ModuleItemTag::BlockStatement => {
+                let node: Box<BlockStatement> = <Box<
+                    BlockStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::BlockStatement(node)))
+            }
+            __ModuleItemTag::BreakStatement => {
+                let node: Box<BreakStatement> = <Box<
+                    BreakStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::BreakStatement(node)))
+            }
+            __ModuleItemTag::ContinueStatement => {
+                let node: Box<ContinueStatement> = <Box<
+                    ContinueStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ContinueStatement(node)))
+            }
+            __ModuleItemTag::DebuggerStatement => {
+                let node: Box<DebuggerStatement> = <Box<
+                    DebuggerStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::DebuggerStatement(node)))
+            }
+            __ModuleItemTag::DoWhileStatement => {
+                let node: Box<DoWhileStatement> = <Box<
+                    DoWhileStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::DoWhileStatement(node)))
+            }
+            __ModuleItemTag::EmptyStatement => {
+                let node: Box<EmptyStatement> = <Box<
+                    EmptyStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::EmptyStatement(node)))
+            }
+            __ModuleItemTag::ExpressionStatement => {
+                let node: Box<ExpressionStatement> = <Box<
+                    ExpressionStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ExpressionStatement(node)))
+            }
+            __ModuleItemTag::ForInStatement => {
+                let node: Box<ForInStatement> = <Box<
+                    ForInStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ForInStatement(node)))
+            }
+            __ModuleItemTag::ForOfStatement => {
+                let node: Box<ForOfStatement> = <Box<
+                    ForOfStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ForOfStatement(node)))
+            }
+            __ModuleItemTag::ForStatement => {
+                let node: Box<ForStatement> = <Box<
+                    ForStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ForStatement(node)))
+            }
+            __ModuleItemTag::FunctionDeclaration => {
+                let node: Box<FunctionDeclaration> = <Box<
+                    FunctionDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::FunctionDeclaration(node)))
+            }
+            __ModuleItemTag::IfStatement => {
+                let node: Box<IfStatement> = <Box<
+                    IfStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::IfStatement(node)))
+            }
+            __ModuleItemTag::LabeledStatement => {
+                let node: Box<LabeledStatement> = <Box<
+                    LabeledStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::LabeledStatement(node)))
+            }
+            __ModuleItemTag::ReturnStatement => {
+                let node: Box<ReturnStatement> = <Box<
+                    ReturnStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ReturnStatement(node)))
+            }
+            __ModuleItemTag::SwitchStatement => {
+                let node: Box<SwitchStatement> = <Box<
+                    SwitchStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::SwitchStatement(node)))
+            }
+            __ModuleItemTag::ThrowStatement => {
+                let node: Box<ThrowStatement> = <Box<
+                    ThrowStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::ThrowStatement(node)))
+            }
+            __ModuleItemTag::TryStatement => {
+                let node: Box<TryStatement> = <Box<
+                    TryStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::TryStatement(node)))
+            }
+            __ModuleItemTag::VariableDeclaration => {
+                let node: Box<VariableDeclaration> = <Box<
+                    VariableDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::VariableDeclaration(node)))
+            }
+            __ModuleItemTag::WhileStatement => {
+                let node: Box<WhileStatement> = <Box<
+                    WhileStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::WhileStatement(node)))
+            }
+            __ModuleItemTag::WithStatement => {
+                let node: Box<WithStatement> = <Box<
+                    WithStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ModuleItem::Statement(Statement::WithStatement(node)))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum ImportOrExportDeclaration {
     ImportDeclaration(Box<ImportDeclaration>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ImportOrExportDeclarationTag {
+    ImportDeclaration,
+}
+impl<'de> serde::Deserialize<'de> for ImportOrExportDeclaration {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ImportOrExportDeclarationTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ImportOrExportDeclarationTag::ImportDeclaration => {
+                let node: Box<ImportDeclaration> = <Box<
+                    ImportDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ImportOrExportDeclaration::ImportDeclaration(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ExpressionOrSuper {
     Expression(Expression),
     Super(Box<Super>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ExpressionOrSuperTag {
+    ArrayExpression,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    BinaryExpression,
+    CallExpression,
+    ConditionalExpression,
+    FunctionExpression,
+    Identifier,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    NewExpression,
+    ObjectExpression,
+    SequenceExpression,
+    ThisExpression,
+    UnaryExpression,
+    UpdateExpression,
+    YieldExpression,
+    Super,
+}
+impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ExpressionOrSuperTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ExpressionOrSuperTag::ArrayExpression => {
+                let node: Box<ArrayExpression> = <Box<
+                    ArrayExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::ArrayExpression(node)))
+            }
+            __ExpressionOrSuperTag::ArrowFunctionExpression => {
+                let node: Box<ArrowFunctionExpression> = <Box<
+                    ArrowFunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    ExpressionOrSuper::Expression(
+                        Expression::ArrowFunctionExpression(node),
+                    ),
+                )
+            }
+            __ExpressionOrSuperTag::AssignmentExpression => {
+                let node: Box<AssignmentExpression> = <Box<
+                    AssignmentExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::AssignmentExpression(node)))
+            }
+            __ExpressionOrSuperTag::BinaryExpression => {
+                let node: Box<BinaryExpression> = <Box<
+                    BinaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(node)))
+            }
+            __ExpressionOrSuperTag::CallExpression => {
+                let node: Box<CallExpression> = <Box<
+                    CallExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::CallExpression(node)))
+            }
+            __ExpressionOrSuperTag::ConditionalExpression => {
+                let node: Box<ConditionalExpression> = <Box<
+                    ConditionalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    ExpressionOrSuper::Expression(
+                        Expression::ConditionalExpression(node),
+                    ),
+                )
+            }
+            __ExpressionOrSuperTag::FunctionExpression => {
+                let node: Box<FunctionExpression> = <Box<
+                    FunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::FunctionExpression(node)))
+            }
+            __ExpressionOrSuperTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::Identifier(node)))
+            }
+            __ExpressionOrSuperTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::Literal(node)))
+            }
+            __ExpressionOrSuperTag::LogicalExpression => {
+                let node: Box<LogicalExpression> = <Box<
+                    LogicalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::LogicalExpression(node)))
+            }
+            __ExpressionOrSuperTag::MemberExpression => {
+                let node: Box<MemberExpression> = <Box<
+                    MemberExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::MemberExpression(node)))
+            }
+            __ExpressionOrSuperTag::NewExpression => {
+                let node: Box<NewExpression> = <Box<
+                    NewExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node)))
+            }
+            __ExpressionOrSuperTag::ObjectExpression => {
+                let node: Box<ObjectExpression> = <Box<
+                    ObjectExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::ObjectExpression(node)))
+            }
+            __ExpressionOrSuperTag::SequenceExpression => {
+                let node: Box<SequenceExpression> = <Box<
+                    SequenceExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::SequenceExpression(node)))
+            }
+            __ExpressionOrSuperTag::ThisExpression => {
+                let node: Box<ThisExpression> = <Box<
+                    ThisExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(node)))
+            }
+            __ExpressionOrSuperTag::UnaryExpression => {
+                let node: Box<UnaryExpression> = <Box<
+                    UnaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::UnaryExpression(node)))
+            }
+            __ExpressionOrSuperTag::UpdateExpression => {
+                let node: Box<UpdateExpression> = <Box<
+                    UpdateExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::UpdateExpression(node)))
+            }
+            __ExpressionOrSuperTag::YieldExpression => {
+                let node: Box<YieldExpression> = <Box<
+                    YieldExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Expression(Expression::YieldExpression(node)))
+            }
+            __ExpressionOrSuperTag::Super => {
+                let node: Box<Super> = <Box<
+                    Super,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSuper::Super(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ExpressionOrSpread {
     Expression(Expression),
     SpreadElement(Box<SpreadElement>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ExpressionOrSpreadTag {
+    ArrayExpression,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    BinaryExpression,
+    CallExpression,
+    ConditionalExpression,
+    FunctionExpression,
+    Identifier,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    NewExpression,
+    ObjectExpression,
+    SequenceExpression,
+    ThisExpression,
+    UnaryExpression,
+    UpdateExpression,
+    YieldExpression,
+    SpreadElement,
+}
+impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ExpressionOrSpreadTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ExpressionOrSpreadTag::ArrayExpression => {
+                let node: Box<ArrayExpression> = <Box<
+                    ArrayExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::ArrayExpression(node)))
+            }
+            __ExpressionOrSpreadTag::ArrowFunctionExpression => {
+                let node: Box<ArrowFunctionExpression> = <Box<
+                    ArrowFunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    ExpressionOrSpread::Expression(
+                        Expression::ArrowFunctionExpression(node),
+                    ),
+                )
+            }
+            __ExpressionOrSpreadTag::AssignmentExpression => {
+                let node: Box<AssignmentExpression> = <Box<
+                    AssignmentExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    ExpressionOrSpread::Expression(
+                        Expression::AssignmentExpression(node),
+                    ),
+                )
+            }
+            __ExpressionOrSpreadTag::BinaryExpression => {
+                let node: Box<BinaryExpression> = <Box<
+                    BinaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::BinaryExpression(node)))
+            }
+            __ExpressionOrSpreadTag::CallExpression => {
+                let node: Box<CallExpression> = <Box<
+                    CallExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::CallExpression(node)))
+            }
+            __ExpressionOrSpreadTag::ConditionalExpression => {
+                let node: Box<ConditionalExpression> = <Box<
+                    ConditionalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    ExpressionOrSpread::Expression(
+                        Expression::ConditionalExpression(node),
+                    ),
+                )
+            }
+            __ExpressionOrSpreadTag::FunctionExpression => {
+                let node: Box<FunctionExpression> = <Box<
+                    FunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::FunctionExpression(node)))
+            }
+            __ExpressionOrSpreadTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::Identifier(node)))
+            }
+            __ExpressionOrSpreadTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::Literal(node)))
+            }
+            __ExpressionOrSpreadTag::LogicalExpression => {
+                let node: Box<LogicalExpression> = <Box<
+                    LogicalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::LogicalExpression(node)))
+            }
+            __ExpressionOrSpreadTag::MemberExpression => {
+                let node: Box<MemberExpression> = <Box<
+                    MemberExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::MemberExpression(node)))
+            }
+            __ExpressionOrSpreadTag::NewExpression => {
+                let node: Box<NewExpression> = <Box<
+                    NewExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node)))
+            }
+            __ExpressionOrSpreadTag::ObjectExpression => {
+                let node: Box<ObjectExpression> = <Box<
+                    ObjectExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::ObjectExpression(node)))
+            }
+            __ExpressionOrSpreadTag::SequenceExpression => {
+                let node: Box<SequenceExpression> = <Box<
+                    SequenceExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::SequenceExpression(node)))
+            }
+            __ExpressionOrSpreadTag::ThisExpression => {
+                let node: Box<ThisExpression> = <Box<
+                    ThisExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(node)))
+            }
+            __ExpressionOrSpreadTag::UnaryExpression => {
+                let node: Box<UnaryExpression> = <Box<
+                    UnaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::UnaryExpression(node)))
+            }
+            __ExpressionOrSpreadTag::UpdateExpression => {
+                let node: Box<UpdateExpression> = <Box<
+                    UpdateExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::UpdateExpression(node)))
+            }
+            __ExpressionOrSpreadTag::YieldExpression => {
+                let node: Box<YieldExpression> = <Box<
+                    YieldExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::Expression(Expression::YieldExpression(node)))
+            }
+            __ExpressionOrSpreadTag::SpreadElement => {
+                let node: Box<SpreadElement> = <Box<
+                    SpreadElement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ExpressionOrSpread::SpreadElement(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum FunctionBody {
     BlockStatement(Box<BlockStatement>),
     Expression(Expression),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __FunctionBodyTag {
+    BlockStatement,
+    ArrayExpression,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    BinaryExpression,
+    CallExpression,
+    ConditionalExpression,
+    FunctionExpression,
+    Identifier,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    NewExpression,
+    ObjectExpression,
+    SequenceExpression,
+    ThisExpression,
+    UnaryExpression,
+    UpdateExpression,
+    YieldExpression,
+}
+impl<'de> serde::Deserialize<'de> for FunctionBody {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __FunctionBodyTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __FunctionBodyTag::BlockStatement => {
+                let node: Box<BlockStatement> = <Box<
+                    BlockStatement,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::BlockStatement(node))
+            }
+            __FunctionBodyTag::ArrayExpression => {
+                let node: Box<ArrayExpression> = <Box<
+                    ArrayExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::ArrayExpression(node)))
+            }
+            __FunctionBodyTag::ArrowFunctionExpression => {
+                let node: Box<ArrowFunctionExpression> = <Box<
+                    ArrowFunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::ArrowFunctionExpression(node)))
+            }
+            __FunctionBodyTag::AssignmentExpression => {
+                let node: Box<AssignmentExpression> = <Box<
+                    AssignmentExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::AssignmentExpression(node)))
+            }
+            __FunctionBodyTag::BinaryExpression => {
+                let node: Box<BinaryExpression> = <Box<
+                    BinaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::BinaryExpression(node)))
+            }
+            __FunctionBodyTag::CallExpression => {
+                let node: Box<CallExpression> = <Box<
+                    CallExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::CallExpression(node)))
+            }
+            __FunctionBodyTag::ConditionalExpression => {
+                let node: Box<ConditionalExpression> = <Box<
+                    ConditionalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::ConditionalExpression(node)))
+            }
+            __FunctionBodyTag::FunctionExpression => {
+                let node: Box<FunctionExpression> = <Box<
+                    FunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::FunctionExpression(node)))
+            }
+            __FunctionBodyTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::Identifier(node)))
+            }
+            __FunctionBodyTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::Literal(node)))
+            }
+            __FunctionBodyTag::LogicalExpression => {
+                let node: Box<LogicalExpression> = <Box<
+                    LogicalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::LogicalExpression(node)))
+            }
+            __FunctionBodyTag::MemberExpression => {
+                let node: Box<MemberExpression> = <Box<
+                    MemberExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::MemberExpression(node)))
+            }
+            __FunctionBodyTag::NewExpression => {
+                let node: Box<NewExpression> = <Box<
+                    NewExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::NewExpression(node)))
+            }
+            __FunctionBodyTag::ObjectExpression => {
+                let node: Box<ObjectExpression> = <Box<
+                    ObjectExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::ObjectExpression(node)))
+            }
+            __FunctionBodyTag::SequenceExpression => {
+                let node: Box<SequenceExpression> = <Box<
+                    SequenceExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::SequenceExpression(node)))
+            }
+            __FunctionBodyTag::ThisExpression => {
+                let node: Box<ThisExpression> = <Box<
+                    ThisExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::ThisExpression(node)))
+            }
+            __FunctionBodyTag::UnaryExpression => {
+                let node: Box<UnaryExpression> = <Box<
+                    UnaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::UnaryExpression(node)))
+            }
+            __FunctionBodyTag::UpdateExpression => {
+                let node: Box<UpdateExpression> = <Box<
+                    UpdateExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::UpdateExpression(node)))
+            }
+            __FunctionBodyTag::YieldExpression => {
+                let node: Box<YieldExpression> = <Box<
+                    YieldExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(FunctionBody::Expression(Expression::YieldExpression(node)))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum Pattern {
     Identifier(Box<Identifier>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __PatternTag {
+    Identifier,
+}
+impl<'de> serde::Deserialize<'de> for Pattern {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __PatternTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __PatternTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(Pattern::Identifier(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ForInit {
     Expression(Expression),
     VariableDeclaration(Box<VariableDeclaration>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ForInitTag {
+    ArrayExpression,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    BinaryExpression,
+    CallExpression,
+    ConditionalExpression,
+    FunctionExpression,
+    Identifier,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    NewExpression,
+    ObjectExpression,
+    SequenceExpression,
+    ThisExpression,
+    UnaryExpression,
+    UpdateExpression,
+    YieldExpression,
+    VariableDeclaration,
+}
+impl<'de> serde::Deserialize<'de> for ForInit {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ForInitTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ForInitTag::ArrayExpression => {
+                let node: Box<ArrayExpression> = <Box<
+                    ArrayExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::ArrayExpression(node)))
+            }
+            __ForInitTag::ArrowFunctionExpression => {
+                let node: Box<ArrowFunctionExpression> = <Box<
+                    ArrowFunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::ArrowFunctionExpression(node)))
+            }
+            __ForInitTag::AssignmentExpression => {
+                let node: Box<AssignmentExpression> = <Box<
+                    AssignmentExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::AssignmentExpression(node)))
+            }
+            __ForInitTag::BinaryExpression => {
+                let node: Box<BinaryExpression> = <Box<
+                    BinaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::BinaryExpression(node)))
+            }
+            __ForInitTag::CallExpression => {
+                let node: Box<CallExpression> = <Box<
+                    CallExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::CallExpression(node)))
+            }
+            __ForInitTag::ConditionalExpression => {
+                let node: Box<ConditionalExpression> = <Box<
+                    ConditionalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::ConditionalExpression(node)))
+            }
+            __ForInitTag::FunctionExpression => {
+                let node: Box<FunctionExpression> = <Box<
+                    FunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::FunctionExpression(node)))
+            }
+            __ForInitTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::Identifier(node)))
+            }
+            __ForInitTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::Literal(node)))
+            }
+            __ForInitTag::LogicalExpression => {
+                let node: Box<LogicalExpression> = <Box<
+                    LogicalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::LogicalExpression(node)))
+            }
+            __ForInitTag::MemberExpression => {
+                let node: Box<MemberExpression> = <Box<
+                    MemberExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::MemberExpression(node)))
+            }
+            __ForInitTag::NewExpression => {
+                let node: Box<NewExpression> = <Box<
+                    NewExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::NewExpression(node)))
+            }
+            __ForInitTag::ObjectExpression => {
+                let node: Box<ObjectExpression> = <Box<
+                    ObjectExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::ObjectExpression(node)))
+            }
+            __ForInitTag::SequenceExpression => {
+                let node: Box<SequenceExpression> = <Box<
+                    SequenceExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::SequenceExpression(node)))
+            }
+            __ForInitTag::ThisExpression => {
+                let node: Box<ThisExpression> = <Box<
+                    ThisExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::ThisExpression(node)))
+            }
+            __ForInitTag::UnaryExpression => {
+                let node: Box<UnaryExpression> = <Box<
+                    UnaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::UnaryExpression(node)))
+            }
+            __ForInitTag::UpdateExpression => {
+                let node: Box<UpdateExpression> = <Box<
+                    UpdateExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::UpdateExpression(node)))
+            }
+            __ForInitTag::YieldExpression => {
+                let node: Box<YieldExpression> = <Box<
+                    YieldExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::Expression(Expression::YieldExpression(node)))
+            }
+            __ForInitTag::VariableDeclaration => {
+                let node: Box<VariableDeclaration> = <Box<
+                    VariableDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInit::VariableDeclaration(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum ForInInit {
     Pattern(Pattern),
     VariableDeclaration(Box<VariableDeclaration>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __ForInInitTag {
+    Identifier,
+    VariableDeclaration,
+}
+impl<'de> serde::Deserialize<'de> for ForInInit {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __ForInInitTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __ForInInitTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInInit::Pattern(Pattern::Identifier(node)))
+            }
+            __ForInInitTag::VariableDeclaration => {
+                let node: Box<VariableDeclaration> = <Box<
+                    VariableDeclaration,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(ForInInit::VariableDeclaration(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum PropertyKey {
     Identifier(Box<Identifier>),
     Literal(Box<Literal>),
 }
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Deserialize, Debug)]
+enum __PropertyKeyTag {
+    Identifier,
+    Literal,
+}
+impl<'de> serde::Deserialize<'de> for PropertyKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __PropertyKeyTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __PropertyKeyTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(PropertyKey::Identifier(node))
+            }
+            __PropertyKeyTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(PropertyKey::Literal(node))
+            }
+        }
+    }
+}
+#[derive(Serialize, Clone, Debug)]
 #[serde(untagged)]
 pub enum AssignmentTarget {
     Expression(Expression),
     Pattern(Pattern),
 }
+#[derive(Deserialize, Debug)]
+enum __AssignmentTargetTag {
+    ArrayExpression,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    BinaryExpression,
+    CallExpression,
+    ConditionalExpression,
+    FunctionExpression,
+    Identifier,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    NewExpression,
+    ObjectExpression,
+    SequenceExpression,
+    ThisExpression,
+    UnaryExpression,
+    UpdateExpression,
+    YieldExpression,
+}
+impl<'de> serde::Deserialize<'de> for AssignmentTarget {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let tagged = serde::Deserializer::deserialize_any(
+            deserializer,
+            serde::__private::de::TaggedContentVisitor::<
+                __AssignmentTargetTag,
+            >::new("type", "Pattern"),
+        )?;
+        match tagged.0 {
+            __AssignmentTargetTag::ArrayExpression => {
+                let node: Box<ArrayExpression> = <Box<
+                    ArrayExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::ArrayExpression(node)))
+            }
+            __AssignmentTargetTag::ArrowFunctionExpression => {
+                let node: Box<ArrowFunctionExpression> = <Box<
+                    ArrowFunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(
+                    AssignmentTarget::Expression(
+                        Expression::ArrowFunctionExpression(node),
+                    ),
+                )
+            }
+            __AssignmentTargetTag::AssignmentExpression => {
+                let node: Box<AssignmentExpression> = <Box<
+                    AssignmentExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::AssignmentExpression(node)))
+            }
+            __AssignmentTargetTag::BinaryExpression => {
+                let node: Box<BinaryExpression> = <Box<
+                    BinaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::BinaryExpression(node)))
+            }
+            __AssignmentTargetTag::CallExpression => {
+                let node: Box<CallExpression> = <Box<
+                    CallExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::CallExpression(node)))
+            }
+            __AssignmentTargetTag::ConditionalExpression => {
+                let node: Box<ConditionalExpression> = <Box<
+                    ConditionalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::ConditionalExpression(node)))
+            }
+            __AssignmentTargetTag::FunctionExpression => {
+                let node: Box<FunctionExpression> = <Box<
+                    FunctionExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::FunctionExpression(node)))
+            }
+            __AssignmentTargetTag::Identifier => {
+                let node: Box<Identifier> = <Box<
+                    Identifier,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::Identifier(node)))
+            }
+            __AssignmentTargetTag::Literal => {
+                let node: Box<Literal> = <Box<
+                    Literal,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::Literal(node)))
+            }
+            __AssignmentTargetTag::LogicalExpression => {
+                let node: Box<LogicalExpression> = <Box<
+                    LogicalExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::LogicalExpression(node)))
+            }
+            __AssignmentTargetTag::MemberExpression => {
+                let node: Box<MemberExpression> = <Box<
+                    MemberExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::MemberExpression(node)))
+            }
+            __AssignmentTargetTag::NewExpression => {
+                let node: Box<NewExpression> = <Box<
+                    NewExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::NewExpression(node)))
+            }
+            __AssignmentTargetTag::ObjectExpression => {
+                let node: Box<ObjectExpression> = <Box<
+                    ObjectExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::ObjectExpression(node)))
+            }
+            __AssignmentTargetTag::SequenceExpression => {
+                let node: Box<SequenceExpression> = <Box<
+                    SequenceExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::SequenceExpression(node)))
+            }
+            __AssignmentTargetTag::ThisExpression => {
+                let node: Box<ThisExpression> = <Box<
+                    ThisExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::ThisExpression(node)))
+            }
+            __AssignmentTargetTag::UnaryExpression => {
+                let node: Box<UnaryExpression> = <Box<
+                    UnaryExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::UnaryExpression(node)))
+            }
+            __AssignmentTargetTag::UpdateExpression => {
+                let node: Box<UpdateExpression> = <Box<
+                    UpdateExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::UpdateExpression(node)))
+            }
+            __AssignmentTargetTag::YieldExpression => {
+                let node: Box<YieldExpression> = <Box<
+                    YieldExpression,
+                > as Deserialize>::deserialize(
+                    serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
+                )?;
+                Ok(AssignmentTarget::Expression(Expression::YieldExpression(node)))
+            }
+        }
+    }
+}
 #[derive(
     Serialize,
     Deserialize,