From 17ed6cc9a9de2bc6993c58d8e66c3de3e23ea16d Mon Sep 17 00:00:00 2001 From: Joe Savona Date: Sat, 8 Jul 2023 23:00:01 +0900 Subject: [PATCH] [rust] Custom deserialization for more precise errors The overall goal of this workstream is to have a Rust representation of ESTree that we can use as the input and output of the compiler. In Rust environments we can convert between the native AST of SWC or OXC and ESTree, and when invoked from JavaScript we can serialize to/from ESTree-compliant JSON. Given that our first target is to plug into a JS-based compilation toolchain, we need to have a working serialization to/from ESTree JSON. The point of the codegen-based `estree` crate is to allow us to model estree as ergonomic, idiomatic Rust (to make consuming it in code easier) while also allowing us to serialize to/from spec-compliant ESTree. This PR flushes out one remaining piece. Updates our estree codegen to generate a custom `Deserialize` implementation instead of using the derived one from serde. ESTree has some enums whose variants are themselves enums, for example we have ```rust enum ModuleItem { ImportExportDeclaration(ImportExportDeclaration), Statement(Statement), } enum ImportExportDeclaration { ... } enum Statement { ... } ``` This sort of works with serde's derive implementation: you have to use the "tag" representation for the inner enums, and an "untagged" representation for the outer one (ModuleItem). The problem is that with an untagged representation, serde doesn't know what type of data it's expecting. All it can do is go one by one and try to parse the data as the first variant (eg ImportExportDeclaration) then the next one (Statement) and fail when it gets to the end of the list. If the data isn't valid for any reason, deserialization will fail with a "not a valid ModuleItem" error. That's true but not helpful, especially if you're developing estree, are confident that the input json is valid, and need to figure out where you messed up the definition. It's also not helpful as an end-user if you're not sure your input json is valid. So this PR updates our codegen to emit a custom derive implementation that is identical for both regular enums (like Statement) and recursive ones (like ModuleItem). We first extract the tag to know what type the value is, then deserialize exactly as that type. So in the above case, rather than have to first try parsing every ModuleItem as an ImportExportDeclaration and then fall through to statement, we just decode the tag (`type` in our case, for example say it's an "ForStatement"), then deserialize directly as that type (eg, as ForStatement), then wrap it in the enum variant (ModuleItem::Statement(...)). For recursive enums like ModuleItem we add an extra wrapper as necessary. The end result is that we get much more precise errors and deserialization is more efficient: we always decode just the tag, then as exactly that type. Note that our serialization is also not perfect right now, because we don't always emit the `type` key. Serde only emits it when a value appears in an enum. We can similarly generate custom serializers for all our types to always emit the tag. That will be straightforward when it's necessary. The current PR was more of a blocker, because it was really hard to figure out mistakes in the estree definition given the ambiguous errors. Thanks to this PR we now get precise errors along the lines of "unknown type `JSXElement`" which are easy to resolve. --- .../crates/estree-codegen/src/codegen.rs | 98 +- .../forget/crates/estree/src/generated.rs | 1746 ++++++++++++++++- 2 files changed, 1821 insertions(+), 23 deletions(-) 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 = 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) -> TokenStream { + pub fn codegen(&self, name: &str, enums: &IndexMap) -> 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> = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::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> = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::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(deserializer: D) -> Result + 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, } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Serialize, Clone, Debug)] #[serde(tag = "type")] pub enum Statement { BlockStatement(Box), @@ -500,7 +500,205 @@ pub enum Statement { WhileStatement(Box), WithStatement(Box), } -#[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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::BlockStatement(node)) + } + __StatementTag::BreakStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::BreakStatement(node)) + } + __StatementTag::ContinueStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ContinueStatement(node)) + } + __StatementTag::DebuggerStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::DebuggerStatement(node)) + } + __StatementTag::DoWhileStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::DoWhileStatement(node)) + } + __StatementTag::EmptyStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::EmptyStatement(node)) + } + __StatementTag::ExpressionStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ExpressionStatement(node)) + } + __StatementTag::ForInStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ForInStatement(node)) + } + __StatementTag::ForOfStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ForOfStatement(node)) + } + __StatementTag::ForStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ForStatement(node)) + } + __StatementTag::FunctionDeclaration => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::FunctionDeclaration(node)) + } + __StatementTag::IfStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::IfStatement(node)) + } + __StatementTag::LabeledStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::LabeledStatement(node)) + } + __StatementTag::ReturnStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ReturnStatement(node)) + } + __StatementTag::SwitchStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::SwitchStatement(node)) + } + __StatementTag::ThrowStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::ThrowStatement(node)) + } + __StatementTag::TryStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::TryStatement(node)) + } + __StatementTag::VariableDeclaration => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::VariableDeclaration(node)) + } + __StatementTag::WhileStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::WhileStatement(node)) + } + __StatementTag::WithStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Statement::WithStatement(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(tag = "type")] pub enum Expression { ArrayExpression(Box), @@ -522,71 +720,1593 @@ pub enum Expression { UpdateExpression(Box), YieldExpression(Box), } -#[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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::ArrayExpression(node)) + } + __ExpressionTag::ArrowFunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::ArrowFunctionExpression(node)) + } + __ExpressionTag::AssignmentExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::AssignmentExpression(node)) + } + __ExpressionTag::BinaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::BinaryExpression(node)) + } + __ExpressionTag::CallExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::CallExpression(node)) + } + __ExpressionTag::ConditionalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::ConditionalExpression(node)) + } + __ExpressionTag::FunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::FunctionExpression(node)) + } + __ExpressionTag::Identifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::Identifier(node)) + } + __ExpressionTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::Literal(node)) + } + __ExpressionTag::LogicalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::LogicalExpression(node)) + } + __ExpressionTag::MemberExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::MemberExpression(node)) + } + __ExpressionTag::NewExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::NewExpression(node)) + } + __ExpressionTag::ObjectExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::ObjectExpression(node)) + } + __ExpressionTag::SequenceExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::SequenceExpression(node)) + } + __ExpressionTag::ThisExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::ThisExpression(node)) + } + __ExpressionTag::UnaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::UnaryExpression(node)) + } + __ExpressionTag::UpdateExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::UpdateExpression(node)) + } + __ExpressionTag::YieldExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Expression::YieldExpression(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(tag = "type")] pub enum ImportDeclarationSpecifier { ImportDefaultSpecifier(Box), ImportNamespaceSpecifier(Box), ImportSpecifier(Box), } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Debug)] +enum __ImportDeclarationSpecifierTag { + ImportSpecifier, + ImportDefaultSpecifier, + ImportNamespaceSpecifier, +} +impl<'de> serde::Deserialize<'de> for ImportDeclarationSpecifier { + fn deserialize(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ImportDeclarationSpecifier::ImportSpecifier(node)) + } + __ImportDeclarationSpecifierTag::ImportDefaultSpecifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ImportDeclarationSpecifier::ImportDefaultSpecifier(node)) + } + __ImportDeclarationSpecifierTag::ImportNamespaceSpecifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + ModuleItem::ImportOrExportDeclaration( + ImportOrExportDeclaration::ImportDeclaration(node), + ), + ) + } + __ModuleItemTag::BlockStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::BlockStatement(node))) + } + __ModuleItemTag::BreakStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::BreakStatement(node))) + } + __ModuleItemTag::ContinueStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ContinueStatement(node))) + } + __ModuleItemTag::DebuggerStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::DebuggerStatement(node))) + } + __ModuleItemTag::DoWhileStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::DoWhileStatement(node))) + } + __ModuleItemTag::EmptyStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::EmptyStatement(node))) + } + __ModuleItemTag::ExpressionStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ExpressionStatement(node))) + } + __ModuleItemTag::ForInStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ForInStatement(node))) + } + __ModuleItemTag::ForOfStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ForOfStatement(node))) + } + __ModuleItemTag::ForStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ForStatement(node))) + } + __ModuleItemTag::FunctionDeclaration => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::FunctionDeclaration(node))) + } + __ModuleItemTag::IfStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::IfStatement(node))) + } + __ModuleItemTag::LabeledStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::LabeledStatement(node))) + } + __ModuleItemTag::ReturnStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ReturnStatement(node))) + } + __ModuleItemTag::SwitchStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::SwitchStatement(node))) + } + __ModuleItemTag::ThrowStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::ThrowStatement(node))) + } + __ModuleItemTag::TryStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::TryStatement(node))) + } + __ModuleItemTag::VariableDeclaration => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::VariableDeclaration(node))) + } + __ModuleItemTag::WhileStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::WhileStatement(node))) + } + __ModuleItemTag::WithStatement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ModuleItem::Statement(Statement::WithStatement(node))) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(tag = "type")] pub enum ImportOrExportDeclaration { ImportDeclaration(Box), } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Debug)] +enum __ImportOrExportDeclarationTag { + ImportDeclaration, +} +impl<'de> serde::Deserialize<'de> for ImportOrExportDeclaration { + fn deserialize(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ImportOrExportDeclaration::ImportDeclaration(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(untagged)] pub enum ExpressionOrSuper { Expression(Expression), Super(Box), } -#[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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::ArrayExpression(node))) + } + __ExpressionOrSuperTag::ArrowFunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + ExpressionOrSuper::Expression( + Expression::ArrowFunctionExpression(node), + ), + ) + } + __ExpressionOrSuperTag::AssignmentExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::AssignmentExpression(node))) + } + __ExpressionOrSuperTag::BinaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(node))) + } + __ExpressionOrSuperTag::CallExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::CallExpression(node))) + } + __ExpressionOrSuperTag::ConditionalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + ExpressionOrSuper::Expression( + Expression::ConditionalExpression(node), + ), + ) + } + __ExpressionOrSuperTag::FunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::FunctionExpression(node))) + } + __ExpressionOrSuperTag::Identifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::Identifier(node))) + } + __ExpressionOrSuperTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::Literal(node))) + } + __ExpressionOrSuperTag::LogicalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::LogicalExpression(node))) + } + __ExpressionOrSuperTag::MemberExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::MemberExpression(node))) + } + __ExpressionOrSuperTag::NewExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node))) + } + __ExpressionOrSuperTag::ObjectExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::ObjectExpression(node))) + } + __ExpressionOrSuperTag::SequenceExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::SequenceExpression(node))) + } + __ExpressionOrSuperTag::ThisExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(node))) + } + __ExpressionOrSuperTag::UnaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::UnaryExpression(node))) + } + __ExpressionOrSuperTag::UpdateExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::UpdateExpression(node))) + } + __ExpressionOrSuperTag::YieldExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Expression(Expression::YieldExpression(node))) + } + __ExpressionOrSuperTag::Super => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSuper::Super(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(untagged)] pub enum ExpressionOrSpread { Expression(Expression), SpreadElement(Box), } -#[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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::ArrayExpression(node))) + } + __ExpressionOrSpreadTag::ArrowFunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + ExpressionOrSpread::Expression( + Expression::ArrowFunctionExpression(node), + ), + ) + } + __ExpressionOrSpreadTag::AssignmentExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + ExpressionOrSpread::Expression( + Expression::AssignmentExpression(node), + ), + ) + } + __ExpressionOrSpreadTag::BinaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::BinaryExpression(node))) + } + __ExpressionOrSpreadTag::CallExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::CallExpression(node))) + } + __ExpressionOrSpreadTag::ConditionalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + ExpressionOrSpread::Expression( + Expression::ConditionalExpression(node), + ), + ) + } + __ExpressionOrSpreadTag::FunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::FunctionExpression(node))) + } + __ExpressionOrSpreadTag::Identifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::Identifier(node))) + } + __ExpressionOrSpreadTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::Literal(node))) + } + __ExpressionOrSpreadTag::LogicalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::LogicalExpression(node))) + } + __ExpressionOrSpreadTag::MemberExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::MemberExpression(node))) + } + __ExpressionOrSpreadTag::NewExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node))) + } + __ExpressionOrSpreadTag::ObjectExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::ObjectExpression(node))) + } + __ExpressionOrSpreadTag::SequenceExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::SequenceExpression(node))) + } + __ExpressionOrSpreadTag::ThisExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(node))) + } + __ExpressionOrSpreadTag::UnaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::UnaryExpression(node))) + } + __ExpressionOrSpreadTag::UpdateExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::UpdateExpression(node))) + } + __ExpressionOrSpreadTag::YieldExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::Expression(Expression::YieldExpression(node))) + } + __ExpressionOrSpreadTag::SpreadElement => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ExpressionOrSpread::SpreadElement(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(untagged)] pub enum FunctionBody { BlockStatement(Box), 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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::BlockStatement(node)) + } + __FunctionBodyTag::ArrayExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::ArrayExpression(node))) + } + __FunctionBodyTag::ArrowFunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::ArrowFunctionExpression(node))) + } + __FunctionBodyTag::AssignmentExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::AssignmentExpression(node))) + } + __FunctionBodyTag::BinaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::BinaryExpression(node))) + } + __FunctionBodyTag::CallExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::CallExpression(node))) + } + __FunctionBodyTag::ConditionalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::ConditionalExpression(node))) + } + __FunctionBodyTag::FunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::FunctionExpression(node))) + } + __FunctionBodyTag::Identifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::Identifier(node))) + } + __FunctionBodyTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::Literal(node))) + } + __FunctionBodyTag::LogicalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::LogicalExpression(node))) + } + __FunctionBodyTag::MemberExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::MemberExpression(node))) + } + __FunctionBodyTag::NewExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::NewExpression(node))) + } + __FunctionBodyTag::ObjectExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::ObjectExpression(node))) + } + __FunctionBodyTag::SequenceExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::SequenceExpression(node))) + } + __FunctionBodyTag::ThisExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::ThisExpression(node))) + } + __FunctionBodyTag::UnaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::UnaryExpression(node))) + } + __FunctionBodyTag::UpdateExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::UpdateExpression(node))) + } + __FunctionBodyTag::YieldExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(FunctionBody::Expression(Expression::YieldExpression(node))) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(tag = "type")] pub enum Pattern { Identifier(Box), } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Debug)] +enum __PatternTag { + Identifier, +} +impl<'de> serde::Deserialize<'de> for Pattern { + fn deserialize(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(Pattern::Identifier(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(untagged)] pub enum ForInit { Expression(Expression), VariableDeclaration(Box), } -#[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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::ArrayExpression(node))) + } + __ForInitTag::ArrowFunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::ArrowFunctionExpression(node))) + } + __ForInitTag::AssignmentExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::AssignmentExpression(node))) + } + __ForInitTag::BinaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::BinaryExpression(node))) + } + __ForInitTag::CallExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::CallExpression(node))) + } + __ForInitTag::ConditionalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::ConditionalExpression(node))) + } + __ForInitTag::FunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::FunctionExpression(node))) + } + __ForInitTag::Identifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::Identifier(node))) + } + __ForInitTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::Literal(node))) + } + __ForInitTag::LogicalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::LogicalExpression(node))) + } + __ForInitTag::MemberExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::MemberExpression(node))) + } + __ForInitTag::NewExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::NewExpression(node))) + } + __ForInitTag::ObjectExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::ObjectExpression(node))) + } + __ForInitTag::SequenceExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::SequenceExpression(node))) + } + __ForInitTag::ThisExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::ThisExpression(node))) + } + __ForInitTag::UnaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::UnaryExpression(node))) + } + __ForInitTag::UpdateExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::UpdateExpression(node))) + } + __ForInitTag::YieldExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::Expression(Expression::YieldExpression(node))) + } + __ForInitTag::VariableDeclaration => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInit::VariableDeclaration(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(untagged)] pub enum ForInInit { Pattern(Pattern), VariableDeclaration(Box), } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Debug)] +enum __ForInInitTag { + Identifier, + VariableDeclaration, +} +impl<'de> serde::Deserialize<'de> for ForInInit { + fn deserialize(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInInit::Pattern(Pattern::Identifier(node))) + } + __ForInInitTag::VariableDeclaration => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(ForInInit::VariableDeclaration(node)) + } + } + } +} +#[derive(Serialize, Clone, Debug)] #[serde(tag = "type")] pub enum PropertyKey { Identifier(Box), Literal(Box), } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Debug)] +enum __PropertyKeyTag { + Identifier, + Literal, +} +impl<'de> serde::Deserialize<'de> for PropertyKey { + fn deserialize(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(PropertyKey::Identifier(node)) + } + __PropertyKeyTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::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(deserializer: D) -> Result + 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 = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::ArrayExpression(node))) + } + __AssignmentTargetTag::ArrowFunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok( + AssignmentTarget::Expression( + Expression::ArrowFunctionExpression(node), + ), + ) + } + __AssignmentTargetTag::AssignmentExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::AssignmentExpression(node))) + } + __AssignmentTargetTag::BinaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::BinaryExpression(node))) + } + __AssignmentTargetTag::CallExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::CallExpression(node))) + } + __AssignmentTargetTag::ConditionalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::ConditionalExpression(node))) + } + __AssignmentTargetTag::FunctionExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::FunctionExpression(node))) + } + __AssignmentTargetTag::Identifier => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::Identifier(node))) + } + __AssignmentTargetTag::Literal => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::Literal(node))) + } + __AssignmentTargetTag::LogicalExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::LogicalExpression(node))) + } + __AssignmentTargetTag::MemberExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::MemberExpression(node))) + } + __AssignmentTargetTag::NewExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::NewExpression(node))) + } + __AssignmentTargetTag::ObjectExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::ObjectExpression(node))) + } + __AssignmentTargetTag::SequenceExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::SequenceExpression(node))) + } + __AssignmentTargetTag::ThisExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::ThisExpression(node))) + } + __AssignmentTargetTag::UnaryExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::UnaryExpression(node))) + } + __AssignmentTargetTag::UpdateExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::UpdateExpression(node))) + } + __AssignmentTargetTag::YieldExpression => { + let node: Box = as Deserialize>::deserialize( + serde::__private::de::ContentDeserializer::::new(tagged.1), + )?; + Ok(AssignmentTarget::Expression(Expression::YieldExpression(node))) + } + } + } +} #[derive( Serialize, Deserialize,