@samitouri / QOS-React-2 / commits / 17ed6cc9a9

[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.

Joe Savona committed Jul 8, 2023 at 23:00 UTC 17ed6cc9a9de2bc6993c58d8e66c3de3e23ea16d
2 files changed +1821 -23
compiler/forget/crates/estree-codegen/src/codegen.rs
+88 -10
@@ -33,11 +33,6 @@ impl Grammar {
33 operators,
34 } = self;
35
36 - let enum_names: HashSet<String> = enums.keys().cloned().collect();
37 -
38 - let mut node_names: Vec<_> = nodes.keys().cloned().collect();
39 - node_names.sort();
40 -
36 let objects: Vec<_> = objects
37 .iter()
38 .map(|(name, object)| object.codegen(name))
@@ -48,7 +43,7 @@ impl Grammar {
43 .collect();
44 let enums: Vec<_> = enums
45 .iter()
51 - .map(|(name, enum_)| enum_.codegen(name, &enum_names))
46 + .map(|(name, enum_)| enum_.codegen(name, &enums))
47 .collect();
48 let operators: Vec<_> = operators
49 .iter()
@@ -223,7 +218,7 @@ pub struct Enum {
218 }
219
220 impl Enum {
226 - pub fn codegen(&self, name: &str, enums: &HashSet<String>) -> TokenStream {
221 + pub fn codegen(&self, name: &str, enums: &IndexMap<String, Enum>) -> TokenStream {
222 let mut sorted_variants: Vec<_> = self.variants.iter().collect();
223 sorted_variants.sort();
224
@@ -232,7 +227,7 @@ impl Enum {
227 .iter()
228 .map(|name| {
229 let variant = format_ident!("{}", name);
235 - if enums.contains(*name) {
230 + if enums.contains_key(*name) {
231 quote!(#variant(#variant))
232 } else {
233 quote!(#variant(Box<#variant>))
@@ -245,7 +240,7 @@ impl Enum {
240 #(#variants),*
241 }
242 };
248 - let enum_ = if sorted_variants.iter().any(|name| enums.contains(*name)) {
243 + let enum_ = if sorted_variants.iter().any(|name| enums.contains_key(*name)) {
244 // contains recursive enum, use untagged serialization
245 quote! {
246 #[serde(untagged)]
@@ -258,9 +253,92 @@ impl Enum {
253 }
254 };
255
256 + let enum_tag = format_ident!("__{}Tag", name);
257 + let mut seen = HashSet::new();
258 +
259 + // tag_variants is used to generate an enum of all the possible type tags (`type` values)
260 + // that can appear in this enum. we emit this enum and derive a deserializer for it so that
261 + // our enum deserializer can first decode the tag in order to know how to decode the data
262 + let mut tag_variants = Vec::new();
263 +
264 + // once the tag is decoded, we need to match against it and deserialize according the tag (`type`)
265 + // tag_matches are the match arms for each type.
266 + let mut tag_matches = Vec::new();
267 +
268 + // Imagine a case like:
269 + // enum ModuleItem {
270 + // ImportDeclaration, // struct
271 + // Statement // another enum
272 + // }
273 + // We need to generate matches for all the possible *concrete* `type` values, which means
274 + // we have to expand nested enums such as `Statement`
275 + for variant in self.variants.iter() {
276 + if let Some(nested_enum) = enums.get(variant) {
277 + let outer_variant = format_ident!("{}", variant);
278 + for variant in nested_enum.variants.iter() {
279 + // Skip variants that appear in multiple nested enums, we deserialize
280 + // as the first listed outer variant
281 + if !seen.insert(variant.to_string()) {
282 + continue;
283 + }
284 + // Modeling ESTree only requires a single level of nested enums,
285 + // so that's all we support. Though in theory we could support arbitrary nesting,
286 + // since ultimately we're matching based on the final concrete types.
287 + assert!(!enums.contains_key(variant));
288 +
289 + let inner_variant = format_ident!("{}", variant);
290 + tag_variants.push(quote!(#inner_variant));
291 +
292 + tag_matches.push(quote! {
293 + #enum_tag::#inner_variant => {
294 + let node: Box<#inner_variant> = <Box<#inner_variant> as Deserialize>::deserialize(
295 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
296 + )?;
297 + Ok(#name::#outer_variant(#outer_variant::#inner_variant(node)))
298 + }
299 + });
300 + }
301 + } else {
302 + if !seen.insert(variant.to_string()) {
303 + panic!(
304 + "Concrete variant {} was already added by a nested enum",
305 + variant
306 + );
307 + }
308 + let variant_name = format_ident!("{}", variant);
309 + tag_variants.push(quote!(#variant_name));
310 +
311 + tag_matches.push(quote! {
312 + #enum_tag::#variant_name => {
313 + let node: Box<#variant_name> = <Box<#variant_name> as Deserialize>::deserialize(
314 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
315 + )?;
316 + Ok(#name::#variant_name(node))
317 + }
318 + })
319 + }
320 + }
321 quote! {
262 - #[derive(Serialize, Deserialize, Clone, Debug)]
322 + #[derive(Serialize, Clone, Debug)]
323 #enum_
324 +
325 + #[derive(Deserialize, Debug)]
326 + enum #enum_tag {
327 + #(#tag_variants),*
328 + }
329 +
330 + impl <'de> serde::Deserialize<'de> for #name {
331 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
332 + where D: serde::Deserializer<'de> {
333 + let tagged = serde::Deserializer::deserialize_any(
334 + deserializer,
335 + serde::__private::de::TaggedContentVisitor::<#enum_tag>::new("type", "Pattern")
336 + )?;
337 + match tagged.0 {
338 + #(#tag_matches),*
339 + }
340 + }
341 + }
342 }
343 }
344 }
compiler/forget/crates/estree/src/generated.rs
+1733 -13
@@ -476,7 +476,7 @@ pub struct ImportNamespaceSpecifier {
476 #[serde(default)]
477 pub range: Option<SourceRange>,
478 }
479 -#[derive(Serialize, Deserialize, Clone, Debug)]
479 +#[derive(Serialize, Clone, Debug)]
480 #[serde(tag = "type")]
481 pub enum Statement {
482 BlockStatement(Box<BlockStatement>),
@@ -500,7 +500,205 @@ pub enum Statement {
500 WhileStatement(Box<WhileStatement>),
501 WithStatement(Box<WithStatement>),
502 }
503 -#[derive(Serialize, Deserialize, Clone, Debug)]
503 +#[derive(Deserialize, Debug)]
504 +enum __StatementTag {
505 + BlockStatement,
506 + BreakStatement,
507 + ContinueStatement,
508 + DebuggerStatement,
509 + DoWhileStatement,
510 + EmptyStatement,
511 + ExpressionStatement,
512 + ForInStatement,
513 + ForOfStatement,
514 + ForStatement,
515 + FunctionDeclaration,
516 + IfStatement,
517 + LabeledStatement,
518 + ReturnStatement,
519 + SwitchStatement,
520 + ThrowStatement,
521 + TryStatement,
522 + VariableDeclaration,
523 + WhileStatement,
524 + WithStatement,
525 +}
526 +impl<'de> serde::Deserialize<'de> for Statement {
527 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
528 + where
529 + D: serde::Deserializer<'de>,
530 + {
531 + let tagged = serde::Deserializer::deserialize_any(
532 + deserializer,
533 + serde::__private::de::TaggedContentVisitor::<
534 + __StatementTag,
535 + >::new("type", "Pattern"),
536 + )?;
537 + match tagged.0 {
538 + __StatementTag::BlockStatement => {
539 + let node: Box<BlockStatement> = <Box<
540 + BlockStatement,
541 + > as Deserialize>::deserialize(
542 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
543 + )?;
544 + Ok(Statement::BlockStatement(node))
545 + }
546 + __StatementTag::BreakStatement => {
547 + let node: Box<BreakStatement> = <Box<
548 + BreakStatement,
549 + > as Deserialize>::deserialize(
550 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
551 + )?;
552 + Ok(Statement::BreakStatement(node))
553 + }
554 + __StatementTag::ContinueStatement => {
555 + let node: Box<ContinueStatement> = <Box<
556 + ContinueStatement,
557 + > as Deserialize>::deserialize(
558 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
559 + )?;
560 + Ok(Statement::ContinueStatement(node))
561 + }
562 + __StatementTag::DebuggerStatement => {
563 + let node: Box<DebuggerStatement> = <Box<
564 + DebuggerStatement,
565 + > as Deserialize>::deserialize(
566 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
567 + )?;
568 + Ok(Statement::DebuggerStatement(node))
569 + }
570 + __StatementTag::DoWhileStatement => {
571 + let node: Box<DoWhileStatement> = <Box<
572 + DoWhileStatement,
573 + > as Deserialize>::deserialize(
574 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
575 + )?;
576 + Ok(Statement::DoWhileStatement(node))
577 + }
578 + __StatementTag::EmptyStatement => {
579 + let node: Box<EmptyStatement> = <Box<
580 + EmptyStatement,
581 + > as Deserialize>::deserialize(
582 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
583 + )?;
584 + Ok(Statement::EmptyStatement(node))
585 + }
586 + __StatementTag::ExpressionStatement => {
587 + let node: Box<ExpressionStatement> = <Box<
588 + ExpressionStatement,
589 + > as Deserialize>::deserialize(
590 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
591 + )?;
592 + Ok(Statement::ExpressionStatement(node))
593 + }
594 + __StatementTag::ForInStatement => {
595 + let node: Box<ForInStatement> = <Box<
596 + ForInStatement,
597 + > as Deserialize>::deserialize(
598 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
599 + )?;
600 + Ok(Statement::ForInStatement(node))
601 + }
602 + __StatementTag::ForOfStatement => {
603 + let node: Box<ForOfStatement> = <Box<
604 + ForOfStatement,
605 + > as Deserialize>::deserialize(
606 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
607 + )?;
608 + Ok(Statement::ForOfStatement(node))
609 + }
610 + __StatementTag::ForStatement => {
611 + let node: Box<ForStatement> = <Box<
612 + ForStatement,
613 + > as Deserialize>::deserialize(
614 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
615 + )?;
616 + Ok(Statement::ForStatement(node))
617 + }
618 + __StatementTag::FunctionDeclaration => {
619 + let node: Box<FunctionDeclaration> = <Box<
620 + FunctionDeclaration,
621 + > as Deserialize>::deserialize(
622 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
623 + )?;
624 + Ok(Statement::FunctionDeclaration(node))
625 + }
626 + __StatementTag::IfStatement => {
627 + let node: Box<IfStatement> = <Box<
628 + IfStatement,
629 + > as Deserialize>::deserialize(
630 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
631 + )?;
632 + Ok(Statement::IfStatement(node))
633 + }
634 + __StatementTag::LabeledStatement => {
635 + let node: Box<LabeledStatement> = <Box<
636 + LabeledStatement,
637 + > as Deserialize>::deserialize(
638 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
639 + )?;
640 + Ok(Statement::LabeledStatement(node))
641 + }
642 + __StatementTag::ReturnStatement => {
643 + let node: Box<ReturnStatement> = <Box<
644 + ReturnStatement,
645 + > as Deserialize>::deserialize(
646 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
647 + )?;
648 + Ok(Statement::ReturnStatement(node))
649 + }
650 + __StatementTag::SwitchStatement => {
651 + let node: Box<SwitchStatement> = <Box<
652 + SwitchStatement,
653 + > as Deserialize>::deserialize(
654 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
655 + )?;
656 + Ok(Statement::SwitchStatement(node))
657 + }
658 + __StatementTag::ThrowStatement => {
659 + let node: Box<ThrowStatement> = <Box<
660 + ThrowStatement,
661 + > as Deserialize>::deserialize(
662 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
663 + )?;
664 + Ok(Statement::ThrowStatement(node))
665 + }
666 + __StatementTag::TryStatement => {
667 + let node: Box<TryStatement> = <Box<
668 + TryStatement,
669 + > as Deserialize>::deserialize(
670 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
671 + )?;
672 + Ok(Statement::TryStatement(node))
673 + }
674 + __StatementTag::VariableDeclaration => {
675 + let node: Box<VariableDeclaration> = <Box<
676 + VariableDeclaration,
677 + > as Deserialize>::deserialize(
678 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
679 + )?;
680 + Ok(Statement::VariableDeclaration(node))
681 + }
682 + __StatementTag::WhileStatement => {
683 + let node: Box<WhileStatement> = <Box<
684 + WhileStatement,
685 + > as Deserialize>::deserialize(
686 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
687 + )?;
688 + Ok(Statement::WhileStatement(node))
689 + }
690 + __StatementTag::WithStatement => {
691 + let node: Box<WithStatement> = <Box<
692 + WithStatement,
693 + > as Deserialize>::deserialize(
694 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
695 + )?;
696 + Ok(Statement::WithStatement(node))
697 + }
698 + }
699 + }
700 +}
701 +#[derive(Serialize, Clone, Debug)]
702 #[serde(tag = "type")]
703 pub enum Expression {
704 ArrayExpression(Box<ArrayExpression>),
@@ -522,71 +720,1593 @@ pub enum Expression {
720 UpdateExpression(Box<UpdateExpression>),
721 YieldExpression(Box<YieldExpression>),
722 }
525 -#[derive(Serialize, Deserialize, Clone, Debug)]
723 +#[derive(Deserialize, Debug)]
724 +enum __ExpressionTag {
725 + ArrayExpression,
726 + ArrowFunctionExpression,
727 + AssignmentExpression,
728 + BinaryExpression,
729 + CallExpression,
730 + ConditionalExpression,
731 + FunctionExpression,
732 + Identifier,
733 + Literal,
734 + LogicalExpression,
735 + MemberExpression,
736 + NewExpression,
737 + ObjectExpression,
738 + SequenceExpression,
739 + ThisExpression,
740 + UnaryExpression,
741 + UpdateExpression,
742 + YieldExpression,
743 +}
744 +impl<'de> serde::Deserialize<'de> for Expression {
745 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
746 + where
747 + D: serde::Deserializer<'de>,
748 + {
749 + let tagged = serde::Deserializer::deserialize_any(
750 + deserializer,
751 + serde::__private::de::TaggedContentVisitor::<
752 + __ExpressionTag,
753 + >::new("type", "Pattern"),
754 + )?;
755 + match tagged.0 {
756 + __ExpressionTag::ArrayExpression => {
757 + let node: Box<ArrayExpression> = <Box<
758 + ArrayExpression,
759 + > as Deserialize>::deserialize(
760 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
761 + )?;
762 + Ok(Expression::ArrayExpression(node))
763 + }
764 + __ExpressionTag::ArrowFunctionExpression => {
765 + let node: Box<ArrowFunctionExpression> = <Box<
766 + ArrowFunctionExpression,
767 + > as Deserialize>::deserialize(
768 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
769 + )?;
770 + Ok(Expression::ArrowFunctionExpression(node))
771 + }
772 + __ExpressionTag::AssignmentExpression => {
773 + let node: Box<AssignmentExpression> = <Box<
774 + AssignmentExpression,
775 + > as Deserialize>::deserialize(
776 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
777 + )?;
778 + Ok(Expression::AssignmentExpression(node))
779 + }
780 + __ExpressionTag::BinaryExpression => {
781 + let node: Box<BinaryExpression> = <Box<
782 + BinaryExpression,
783 + > as Deserialize>::deserialize(
784 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
785 + )?;
786 + Ok(Expression::BinaryExpression(node))
787 + }
788 + __ExpressionTag::CallExpression => {
789 + let node: Box<CallExpression> = <Box<
790 + CallExpression,
791 + > as Deserialize>::deserialize(
792 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
793 + )?;
794 + Ok(Expression::CallExpression(node))
795 + }
796 + __ExpressionTag::ConditionalExpression => {
797 + let node: Box<ConditionalExpression> = <Box<
798 + ConditionalExpression,
799 + > as Deserialize>::deserialize(
800 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
801 + )?;
802 + Ok(Expression::ConditionalExpression(node))
803 + }
804 + __ExpressionTag::FunctionExpression => {
805 + let node: Box<FunctionExpression> = <Box<
806 + FunctionExpression,
807 + > as Deserialize>::deserialize(
808 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
809 + )?;
810 + Ok(Expression::FunctionExpression(node))
811 + }
812 + __ExpressionTag::Identifier => {
813 + let node: Box<Identifier> = <Box<
814 + Identifier,
815 + > as Deserialize>::deserialize(
816 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
817 + )?;
818 + Ok(Expression::Identifier(node))
819 + }
820 + __ExpressionTag::Literal => {
821 + let node: Box<Literal> = <Box<
822 + Literal,
823 + > as Deserialize>::deserialize(
824 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
825 + )?;
826 + Ok(Expression::Literal(node))
827 + }
828 + __ExpressionTag::LogicalExpression => {
829 + let node: Box<LogicalExpression> = <Box<
830 + LogicalExpression,
831 + > as Deserialize>::deserialize(
832 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
833 + )?;
834 + Ok(Expression::LogicalExpression(node))
835 + }
836 + __ExpressionTag::MemberExpression => {
837 + let node: Box<MemberExpression> = <Box<
838 + MemberExpression,
839 + > as Deserialize>::deserialize(
840 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
841 + )?;
842 + Ok(Expression::MemberExpression(node))
843 + }
844 + __ExpressionTag::NewExpression => {
845 + let node: Box<NewExpression> = <Box<
846 + NewExpression,
847 + > as Deserialize>::deserialize(
848 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
849 + )?;
850 + Ok(Expression::NewExpression(node))
851 + }
852 + __ExpressionTag::ObjectExpression => {
853 + let node: Box<ObjectExpression> = <Box<
854 + ObjectExpression,
855 + > as Deserialize>::deserialize(
856 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
857 + )?;
858 + Ok(Expression::ObjectExpression(node))
859 + }
860 + __ExpressionTag::SequenceExpression => {
861 + let node: Box<SequenceExpression> = <Box<
862 + SequenceExpression,
863 + > as Deserialize>::deserialize(
864 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
865 + )?;
866 + Ok(Expression::SequenceExpression(node))
867 + }
868 + __ExpressionTag::ThisExpression => {
869 + let node: Box<ThisExpression> = <Box<
870 + ThisExpression,
871 + > as Deserialize>::deserialize(
872 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
873 + )?;
874 + Ok(Expression::ThisExpression(node))
875 + }
876 + __ExpressionTag::UnaryExpression => {
877 + let node: Box<UnaryExpression> = <Box<
878 + UnaryExpression,
879 + > as Deserialize>::deserialize(
880 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
881 + )?;
882 + Ok(Expression::UnaryExpression(node))
883 + }
884 + __ExpressionTag::UpdateExpression => {
885 + let node: Box<UpdateExpression> = <Box<
886 + UpdateExpression,
887 + > as Deserialize>::deserialize(
888 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
889 + )?;
890 + Ok(Expression::UpdateExpression(node))
891 + }
892 + __ExpressionTag::YieldExpression => {
893 + let node: Box<YieldExpression> = <Box<
894 + YieldExpression,
895 + > as Deserialize>::deserialize(
896 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
897 + )?;
898 + Ok(Expression::YieldExpression(node))
899 + }
900 + }
901 + }
902 +}
903 +#[derive(Serialize, Clone, Debug)]
904 #[serde(tag = "type")]
905 pub enum ImportDeclarationSpecifier {
906 ImportDefaultSpecifier(Box<ImportDefaultSpecifier>),
907 ImportNamespaceSpecifier(Box<ImportNamespaceSpecifier>),
908 ImportSpecifier(Box<ImportSpecifier>),
909 }
532 -#[derive(Serialize, Deserialize, Clone, Debug)]
910 +#[derive(Deserialize, Debug)]
911 +enum __ImportDeclarationSpecifierTag {
912 + ImportSpecifier,
913 + ImportDefaultSpecifier,
914 + ImportNamespaceSpecifier,
915 +}
916 +impl<'de> serde::Deserialize<'de> for ImportDeclarationSpecifier {
917 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
918 + where
919 + D: serde::Deserializer<'de>,
920 + {
921 + let tagged = serde::Deserializer::deserialize_any(
922 + deserializer,
923 + serde::__private::de::TaggedContentVisitor::<
924 + __ImportDeclarationSpecifierTag,
925 + >::new("type", "Pattern"),
926 + )?;
927 + match tagged.0 {
928 + __ImportDeclarationSpecifierTag::ImportSpecifier => {
929 + let node: Box<ImportSpecifier> = <Box<
930 + ImportSpecifier,
931 + > as Deserialize>::deserialize(
932 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
933 + )?;
934 + Ok(ImportDeclarationSpecifier::ImportSpecifier(node))
935 + }
936 + __ImportDeclarationSpecifierTag::ImportDefaultSpecifier => {
937 + let node: Box<ImportDefaultSpecifier> = <Box<
938 + ImportDefaultSpecifier,
939 + > as Deserialize>::deserialize(
940 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
941 + )?;
942 + Ok(ImportDeclarationSpecifier::ImportDefaultSpecifier(node))
943 + }
944 + __ImportDeclarationSpecifierTag::ImportNamespaceSpecifier => {
945 + let node: Box<ImportNamespaceSpecifier> = <Box<
946 + ImportNamespaceSpecifier,
947 + > as Deserialize>::deserialize(
948 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
949 + )?;
950 + Ok(ImportDeclarationSpecifier::ImportNamespaceSpecifier(node))
951 + }
952 + }
953 + }
954 +}
955 +#[derive(Serialize, Clone, Debug)]
956 #[serde(untagged)]
957 pub enum ModuleItem {
958 ImportOrExportDeclaration(ImportOrExportDeclaration),
959 Statement(Statement),
960 }
538 -#[derive(Serialize, Deserialize, Clone, Debug)]
961 +#[derive(Deserialize, Debug)]
962 +enum __ModuleItemTag {
963 + ImportDeclaration,
964 + BlockStatement,
965 + BreakStatement,
966 + ContinueStatement,
967 + DebuggerStatement,
968 + DoWhileStatement,
969 + EmptyStatement,
970 + ExpressionStatement,
971 + ForInStatement,
972 + ForOfStatement,
973 + ForStatement,
974 + FunctionDeclaration,
975 + IfStatement,
976 + LabeledStatement,
977 + ReturnStatement,
978 + SwitchStatement,
979 + ThrowStatement,
980 + TryStatement,
981 + VariableDeclaration,
982 + WhileStatement,
983 + WithStatement,
984 +}
985 +impl<'de> serde::Deserialize<'de> for ModuleItem {
986 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
987 + where
988 + D: serde::Deserializer<'de>,
989 + {
990 + let tagged = serde::Deserializer::deserialize_any(
991 + deserializer,
992 + serde::__private::de::TaggedContentVisitor::<
993 + __ModuleItemTag,
994 + >::new("type", "Pattern"),
995 + )?;
996 + match tagged.0 {
997 + __ModuleItemTag::ImportDeclaration => {
998 + let node: Box<ImportDeclaration> = <Box<
999 + ImportDeclaration,
1000 + > as Deserialize>::deserialize(
1001 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1002 + )?;
1003 + Ok(
1004 + ModuleItem::ImportOrExportDeclaration(
1005 + ImportOrExportDeclaration::ImportDeclaration(node),
1006 + ),
1007 + )
1008 + }
1009 + __ModuleItemTag::BlockStatement => {
1010 + let node: Box<BlockStatement> = <Box<
1011 + BlockStatement,
1012 + > as Deserialize>::deserialize(
1013 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1014 + )?;
1015 + Ok(ModuleItem::Statement(Statement::BlockStatement(node)))
1016 + }
1017 + __ModuleItemTag::BreakStatement => {
1018 + let node: Box<BreakStatement> = <Box<
1019 + BreakStatement,
1020 + > as Deserialize>::deserialize(
1021 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1022 + )?;
1023 + Ok(ModuleItem::Statement(Statement::BreakStatement(node)))
1024 + }
1025 + __ModuleItemTag::ContinueStatement => {
1026 + let node: Box<ContinueStatement> = <Box<
1027 + ContinueStatement,
1028 + > as Deserialize>::deserialize(
1029 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1030 + )?;
1031 + Ok(ModuleItem::Statement(Statement::ContinueStatement(node)))
1032 + }
1033 + __ModuleItemTag::DebuggerStatement => {
1034 + let node: Box<DebuggerStatement> = <Box<
1035 + DebuggerStatement,
1036 + > as Deserialize>::deserialize(
1037 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1038 + )?;
1039 + Ok(ModuleItem::Statement(Statement::DebuggerStatement(node)))
1040 + }
1041 + __ModuleItemTag::DoWhileStatement => {
1042 + let node: Box<DoWhileStatement> = <Box<
1043 + DoWhileStatement,
1044 + > as Deserialize>::deserialize(
1045 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1046 + )?;
1047 + Ok(ModuleItem::Statement(Statement::DoWhileStatement(node)))
1048 + }
1049 + __ModuleItemTag::EmptyStatement => {
1050 + let node: Box<EmptyStatement> = <Box<
1051 + EmptyStatement,
1052 + > as Deserialize>::deserialize(
1053 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1054 + )?;
1055 + Ok(ModuleItem::Statement(Statement::EmptyStatement(node)))
1056 + }
1057 + __ModuleItemTag::ExpressionStatement => {
1058 + let node: Box<ExpressionStatement> = <Box<
1059 + ExpressionStatement,
1060 + > as Deserialize>::deserialize(
1061 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1062 + )?;
1063 + Ok(ModuleItem::Statement(Statement::ExpressionStatement(node)))
1064 + }
1065 + __ModuleItemTag::ForInStatement => {
1066 + let node: Box<ForInStatement> = <Box<
1067 + ForInStatement,
1068 + > as Deserialize>::deserialize(
1069 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1070 + )?;
1071 + Ok(ModuleItem::Statement(Statement::ForInStatement(node)))
1072 + }
1073 + __ModuleItemTag::ForOfStatement => {
1074 + let node: Box<ForOfStatement> = <Box<
1075 + ForOfStatement,
1076 + > as Deserialize>::deserialize(
1077 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1078 + )?;
1079 + Ok(ModuleItem::Statement(Statement::ForOfStatement(node)))
1080 + }
1081 + __ModuleItemTag::ForStatement => {
1082 + let node: Box<ForStatement> = <Box<
1083 + ForStatement,
1084 + > as Deserialize>::deserialize(
1085 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1086 + )?;
1087 + Ok(ModuleItem::Statement(Statement::ForStatement(node)))
1088 + }
1089 + __ModuleItemTag::FunctionDeclaration => {
1090 + let node: Box<FunctionDeclaration> = <Box<
1091 + FunctionDeclaration,
1092 + > as Deserialize>::deserialize(
1093 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1094 + )?;
1095 + Ok(ModuleItem::Statement(Statement::FunctionDeclaration(node)))
1096 + }
1097 + __ModuleItemTag::IfStatement => {
1098 + let node: Box<IfStatement> = <Box<
1099 + IfStatement,
1100 + > as Deserialize>::deserialize(
1101 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1102 + )?;
1103 + Ok(ModuleItem::Statement(Statement::IfStatement(node)))
1104 + }
1105 + __ModuleItemTag::LabeledStatement => {
1106 + let node: Box<LabeledStatement> = <Box<
1107 + LabeledStatement,
1108 + > as Deserialize>::deserialize(
1109 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1110 + )?;
1111 + Ok(ModuleItem::Statement(Statement::LabeledStatement(node)))
1112 + }
1113 + __ModuleItemTag::ReturnStatement => {
1114 + let node: Box<ReturnStatement> = <Box<
1115 + ReturnStatement,
1116 + > as Deserialize>::deserialize(
1117 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1118 + )?;
1119 + Ok(ModuleItem::Statement(Statement::ReturnStatement(node)))
1120 + }
1121 + __ModuleItemTag::SwitchStatement => {
1122 + let node: Box<SwitchStatement> = <Box<
1123 + SwitchStatement,
1124 + > as Deserialize>::deserialize(
1125 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1126 + )?;
1127 + Ok(ModuleItem::Statement(Statement::SwitchStatement(node)))
1128 + }
1129 + __ModuleItemTag::ThrowStatement => {
1130 + let node: Box<ThrowStatement> = <Box<
1131 + ThrowStatement,
1132 + > as Deserialize>::deserialize(
1133 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1134 + )?;
1135 + Ok(ModuleItem::Statement(Statement::ThrowStatement(node)))
1136 + }
1137 + __ModuleItemTag::TryStatement => {
1138 + let node: Box<TryStatement> = <Box<
1139 + TryStatement,
1140 + > as Deserialize>::deserialize(
1141 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1142 + )?;
1143 + Ok(ModuleItem::Statement(Statement::TryStatement(node)))
1144 + }
1145 + __ModuleItemTag::VariableDeclaration => {
1146 + let node: Box<VariableDeclaration> = <Box<
1147 + VariableDeclaration,
1148 + > as Deserialize>::deserialize(
1149 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1150 + )?;
1151 + Ok(ModuleItem::Statement(Statement::VariableDeclaration(node)))
1152 + }
1153 + __ModuleItemTag::WhileStatement => {
1154 + let node: Box<WhileStatement> = <Box<
1155 + WhileStatement,
1156 + > as Deserialize>::deserialize(
1157 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1158 + )?;
1159 + Ok(ModuleItem::Statement(Statement::WhileStatement(node)))
1160 + }
1161 + __ModuleItemTag::WithStatement => {
1162 + let node: Box<WithStatement> = <Box<
1163 + WithStatement,
1164 + > as Deserialize>::deserialize(
1165 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1166 + )?;
1167 + Ok(ModuleItem::Statement(Statement::WithStatement(node)))
1168 + }
1169 + }
1170 + }
1171 +}
1172 +#[derive(Serialize, Clone, Debug)]
1173 #[serde(tag = "type")]
1174 pub enum ImportOrExportDeclaration {
1175 ImportDeclaration(Box<ImportDeclaration>),
1176 }
543 -#[derive(Serialize, Deserialize, Clone, Debug)]
1177 +#[derive(Deserialize, Debug)]
1178 +enum __ImportOrExportDeclarationTag {
1179 + ImportDeclaration,
1180 +}
1181 +impl<'de> serde::Deserialize<'de> for ImportOrExportDeclaration {
1182 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1183 + where
1184 + D: serde::Deserializer<'de>,
1185 + {
1186 + let tagged = serde::Deserializer::deserialize_any(
1187 + deserializer,
1188 + serde::__private::de::TaggedContentVisitor::<
1189 + __ImportOrExportDeclarationTag,
1190 + >::new("type", "Pattern"),
1191 + )?;
1192 + match tagged.0 {
1193 + __ImportOrExportDeclarationTag::ImportDeclaration => {
1194 + let node: Box<ImportDeclaration> = <Box<
1195 + ImportDeclaration,
1196 + > as Deserialize>::deserialize(
1197 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1198 + )?;
1199 + Ok(ImportOrExportDeclaration::ImportDeclaration(node))
1200 + }
1201 + }
1202 + }
1203 +}
1204 +#[derive(Serialize, Clone, Debug)]
1205 #[serde(untagged)]
1206 pub enum ExpressionOrSuper {
1207 Expression(Expression),
1208 Super(Box<Super>),
1209 }
549 -#[derive(Serialize, Deserialize, Clone, Debug)]
1210 +#[derive(Deserialize, Debug)]
1211 +enum __ExpressionOrSuperTag {
1212 + ArrayExpression,
1213 + ArrowFunctionExpression,
1214 + AssignmentExpression,
1215 + BinaryExpression,
1216 + CallExpression,
1217 + ConditionalExpression,
1218 + FunctionExpression,
1219 + Identifier,
1220 + Literal,
1221 + LogicalExpression,
1222 + MemberExpression,
1223 + NewExpression,
1224 + ObjectExpression,
1225 + SequenceExpression,
1226 + ThisExpression,
1227 + UnaryExpression,
1228 + UpdateExpression,
1229 + YieldExpression,
1230 + Super,
1231 +}
1232 +impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
1233 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1234 + where
1235 + D: serde::Deserializer<'de>,
1236 + {
1237 + let tagged = serde::Deserializer::deserialize_any(
1238 + deserializer,
1239 + serde::__private::de::TaggedContentVisitor::<
1240 + __ExpressionOrSuperTag,
1241 + >::new("type", "Pattern"),
1242 + )?;
1243 + match tagged.0 {
1244 + __ExpressionOrSuperTag::ArrayExpression => {
1245 + let node: Box<ArrayExpression> = <Box<
1246 + ArrayExpression,
1247 + > as Deserialize>::deserialize(
1248 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1249 + )?;
1250 + Ok(ExpressionOrSuper::Expression(Expression::ArrayExpression(node)))
1251 + }
1252 + __ExpressionOrSuperTag::ArrowFunctionExpression => {
1253 + let node: Box<ArrowFunctionExpression> = <Box<
1254 + ArrowFunctionExpression,
1255 + > as Deserialize>::deserialize(
1256 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1257 + )?;
1258 + Ok(
1259 + ExpressionOrSuper::Expression(
1260 + Expression::ArrowFunctionExpression(node),
1261 + ),
1262 + )
1263 + }
1264 + __ExpressionOrSuperTag::AssignmentExpression => {
1265 + let node: Box<AssignmentExpression> = <Box<
1266 + AssignmentExpression,
1267 + > as Deserialize>::deserialize(
1268 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1269 + )?;
1270 + Ok(ExpressionOrSuper::Expression(Expression::AssignmentExpression(node)))
1271 + }
1272 + __ExpressionOrSuperTag::BinaryExpression => {
1273 + let node: Box<BinaryExpression> = <Box<
1274 + BinaryExpression,
1275 + > as Deserialize>::deserialize(
1276 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1277 + )?;
1278 + Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(node)))
1279 + }
1280 + __ExpressionOrSuperTag::CallExpression => {
1281 + let node: Box<CallExpression> = <Box<
1282 + CallExpression,
1283 + > as Deserialize>::deserialize(
1284 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1285 + )?;
1286 + Ok(ExpressionOrSuper::Expression(Expression::CallExpression(node)))
1287 + }
1288 + __ExpressionOrSuperTag::ConditionalExpression => {
1289 + let node: Box<ConditionalExpression> = <Box<
1290 + ConditionalExpression,
1291 + > as Deserialize>::deserialize(
1292 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1293 + )?;
1294 + Ok(
1295 + ExpressionOrSuper::Expression(
1296 + Expression::ConditionalExpression(node),
1297 + ),
1298 + )
1299 + }
1300 + __ExpressionOrSuperTag::FunctionExpression => {
1301 + let node: Box<FunctionExpression> = <Box<
1302 + FunctionExpression,
1303 + > as Deserialize>::deserialize(
1304 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1305 + )?;
1306 + Ok(ExpressionOrSuper::Expression(Expression::FunctionExpression(node)))
1307 + }
1308 + __ExpressionOrSuperTag::Identifier => {
1309 + let node: Box<Identifier> = <Box<
1310 + Identifier,
1311 + > as Deserialize>::deserialize(
1312 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1313 + )?;
1314 + Ok(ExpressionOrSuper::Expression(Expression::Identifier(node)))
1315 + }
1316 + __ExpressionOrSuperTag::Literal => {
1317 + let node: Box<Literal> = <Box<
1318 + Literal,
1319 + > as Deserialize>::deserialize(
1320 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1321 + )?;
1322 + Ok(ExpressionOrSuper::Expression(Expression::Literal(node)))
1323 + }
1324 + __ExpressionOrSuperTag::LogicalExpression => {
1325 + let node: Box<LogicalExpression> = <Box<
1326 + LogicalExpression,
1327 + > as Deserialize>::deserialize(
1328 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1329 + )?;
1330 + Ok(ExpressionOrSuper::Expression(Expression::LogicalExpression(node)))
1331 + }
1332 + __ExpressionOrSuperTag::MemberExpression => {
1333 + let node: Box<MemberExpression> = <Box<
1334 + MemberExpression,
1335 + > as Deserialize>::deserialize(
1336 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1337 + )?;
1338 + Ok(ExpressionOrSuper::Expression(Expression::MemberExpression(node)))
1339 + }
1340 + __ExpressionOrSuperTag::NewExpression => {
1341 + let node: Box<NewExpression> = <Box<
1342 + NewExpression,
1343 + > as Deserialize>::deserialize(
1344 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1345 + )?;
1346 + Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node)))
1347 + }
1348 + __ExpressionOrSuperTag::ObjectExpression => {
1349 + let node: Box<ObjectExpression> = <Box<
1350 + ObjectExpression,
1351 + > as Deserialize>::deserialize(
1352 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1353 + )?;
1354 + Ok(ExpressionOrSuper::Expression(Expression::ObjectExpression(node)))
1355 + }
1356 + __ExpressionOrSuperTag::SequenceExpression => {
1357 + let node: Box<SequenceExpression> = <Box<
1358 + SequenceExpression,
1359 + > as Deserialize>::deserialize(
1360 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1361 + )?;
1362 + Ok(ExpressionOrSuper::Expression(Expression::SequenceExpression(node)))
1363 + }
1364 + __ExpressionOrSuperTag::ThisExpression => {
1365 + let node: Box<ThisExpression> = <Box<
1366 + ThisExpression,
1367 + > as Deserialize>::deserialize(
1368 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1369 + )?;
1370 + Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(node)))
1371 + }
1372 + __ExpressionOrSuperTag::UnaryExpression => {
1373 + let node: Box<UnaryExpression> = <Box<
1374 + UnaryExpression,
1375 + > as Deserialize>::deserialize(
1376 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1377 + )?;
1378 + Ok(ExpressionOrSuper::Expression(Expression::UnaryExpression(node)))
1379 + }
1380 + __ExpressionOrSuperTag::UpdateExpression => {
1381 + let node: Box<UpdateExpression> = <Box<
1382 + UpdateExpression,
1383 + > as Deserialize>::deserialize(
1384 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1385 + )?;
1386 + Ok(ExpressionOrSuper::Expression(Expression::UpdateExpression(node)))
1387 + }
1388 + __ExpressionOrSuperTag::YieldExpression => {
1389 + let node: Box<YieldExpression> = <Box<
1390 + YieldExpression,
1391 + > as Deserialize>::deserialize(
1392 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1393 + )?;
1394 + Ok(ExpressionOrSuper::Expression(Expression::YieldExpression(node)))
1395 + }
1396 + __ExpressionOrSuperTag::Super => {
1397 + let node: Box<Super> = <Box<
1398 + Super,
1399 + > as Deserialize>::deserialize(
1400 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1401 + )?;
1402 + Ok(ExpressionOrSuper::Super(node))
1403 + }
1404 + }
1405 + }
1406 +}
1407 +#[derive(Serialize, Clone, Debug)]
1408 #[serde(untagged)]
1409 pub enum ExpressionOrSpread {
1410 Expression(Expression),
1411 SpreadElement(Box<SpreadElement>),
1412 }
555 -#[derive(Serialize, Deserialize, Clone, Debug)]
1413 +#[derive(Deserialize, Debug)]
1414 +enum __ExpressionOrSpreadTag {
1415 + ArrayExpression,
1416 + ArrowFunctionExpression,
1417 + AssignmentExpression,
1418 + BinaryExpression,
1419 + CallExpression,
1420 + ConditionalExpression,
1421 + FunctionExpression,
1422 + Identifier,
1423 + Literal,
1424 + LogicalExpression,
1425 + MemberExpression,
1426 + NewExpression,
1427 + ObjectExpression,
1428 + SequenceExpression,
1429 + ThisExpression,
1430 + UnaryExpression,
1431 + UpdateExpression,
1432 + YieldExpression,
1433 + SpreadElement,
1434 +}
1435 +impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
1436 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1437 + where
1438 + D: serde::Deserializer<'de>,
1439 + {
1440 + let tagged = serde::Deserializer::deserialize_any(
1441 + deserializer,
1442 + serde::__private::de::TaggedContentVisitor::<
1443 + __ExpressionOrSpreadTag,
1444 + >::new("type", "Pattern"),
1445 + )?;
1446 + match tagged.0 {
1447 + __ExpressionOrSpreadTag::ArrayExpression => {
1448 + let node: Box<ArrayExpression> = <Box<
1449 + ArrayExpression,
1450 + > as Deserialize>::deserialize(
1451 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1452 + )?;
1453 + Ok(ExpressionOrSpread::Expression(Expression::ArrayExpression(node)))
1454 + }
1455 + __ExpressionOrSpreadTag::ArrowFunctionExpression => {
1456 + let node: Box<ArrowFunctionExpression> = <Box<
1457 + ArrowFunctionExpression,
1458 + > as Deserialize>::deserialize(
1459 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1460 + )?;
1461 + Ok(
1462 + ExpressionOrSpread::Expression(
1463 + Expression::ArrowFunctionExpression(node),
1464 + ),
1465 + )
1466 + }
1467 + __ExpressionOrSpreadTag::AssignmentExpression => {
1468 + let node: Box<AssignmentExpression> = <Box<
1469 + AssignmentExpression,
1470 + > as Deserialize>::deserialize(
1471 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1472 + )?;
1473 + Ok(
1474 + ExpressionOrSpread::Expression(
1475 + Expression::AssignmentExpression(node),
1476 + ),
1477 + )
1478 + }
1479 + __ExpressionOrSpreadTag::BinaryExpression => {
1480 + let node: Box<BinaryExpression> = <Box<
1481 + BinaryExpression,
1482 + > as Deserialize>::deserialize(
1483 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1484 + )?;
1485 + Ok(ExpressionOrSpread::Expression(Expression::BinaryExpression(node)))
1486 + }
1487 + __ExpressionOrSpreadTag::CallExpression => {
1488 + let node: Box<CallExpression> = <Box<
1489 + CallExpression,
1490 + > as Deserialize>::deserialize(
1491 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1492 + )?;
1493 + Ok(ExpressionOrSpread::Expression(Expression::CallExpression(node)))
1494 + }
1495 + __ExpressionOrSpreadTag::ConditionalExpression => {
1496 + let node: Box<ConditionalExpression> = <Box<
1497 + ConditionalExpression,
1498 + > as Deserialize>::deserialize(
1499 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1500 + )?;
1501 + Ok(
1502 + ExpressionOrSpread::Expression(
1503 + Expression::ConditionalExpression(node),
1504 + ),
1505 + )
1506 + }
1507 + __ExpressionOrSpreadTag::FunctionExpression => {
1508 + let node: Box<FunctionExpression> = <Box<
1509 + FunctionExpression,
1510 + > as Deserialize>::deserialize(
1511 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1512 + )?;
1513 + Ok(ExpressionOrSpread::Expression(Expression::FunctionExpression(node)))
1514 + }
1515 + __ExpressionOrSpreadTag::Identifier => {
1516 + let node: Box<Identifier> = <Box<
1517 + Identifier,
1518 + > as Deserialize>::deserialize(
1519 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1520 + )?;
1521 + Ok(ExpressionOrSpread::Expression(Expression::Identifier(node)))
1522 + }
1523 + __ExpressionOrSpreadTag::Literal => {
1524 + let node: Box<Literal> = <Box<
1525 + Literal,
1526 + > as Deserialize>::deserialize(
1527 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1528 + )?;
1529 + Ok(ExpressionOrSpread::Expression(Expression::Literal(node)))
1530 + }
1531 + __ExpressionOrSpreadTag::LogicalExpression => {
1532 + let node: Box<LogicalExpression> = <Box<
1533 + LogicalExpression,
1534 + > as Deserialize>::deserialize(
1535 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1536 + )?;
1537 + Ok(ExpressionOrSpread::Expression(Expression::LogicalExpression(node)))
1538 + }
1539 + __ExpressionOrSpreadTag::MemberExpression => {
1540 + let node: Box<MemberExpression> = <Box<
1541 + MemberExpression,
1542 + > as Deserialize>::deserialize(
1543 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1544 + )?;
1545 + Ok(ExpressionOrSpread::Expression(Expression::MemberExpression(node)))
1546 + }
1547 + __ExpressionOrSpreadTag::NewExpression => {
1548 + let node: Box<NewExpression> = <Box<
1549 + NewExpression,
1550 + > as Deserialize>::deserialize(
1551 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1552 + )?;
1553 + Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node)))
1554 + }
1555 + __ExpressionOrSpreadTag::ObjectExpression => {
1556 + let node: Box<ObjectExpression> = <Box<
1557 + ObjectExpression,
1558 + > as Deserialize>::deserialize(
1559 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1560 + )?;
1561 + Ok(ExpressionOrSpread::Expression(Expression::ObjectExpression(node)))
1562 + }
1563 + __ExpressionOrSpreadTag::SequenceExpression => {
1564 + let node: Box<SequenceExpression> = <Box<
1565 + SequenceExpression,
1566 + > as Deserialize>::deserialize(
1567 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1568 + )?;
1569 + Ok(ExpressionOrSpread::Expression(Expression::SequenceExpression(node)))
1570 + }
1571 + __ExpressionOrSpreadTag::ThisExpression => {
1572 + let node: Box<ThisExpression> = <Box<
1573 + ThisExpression,
1574 + > as Deserialize>::deserialize(
1575 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1576 + )?;
1577 + Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(node)))
1578 + }
1579 + __ExpressionOrSpreadTag::UnaryExpression => {
1580 + let node: Box<UnaryExpression> = <Box<
1581 + UnaryExpression,
1582 + > as Deserialize>::deserialize(
1583 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1584 + )?;
1585 + Ok(ExpressionOrSpread::Expression(Expression::UnaryExpression(node)))
1586 + }
1587 + __ExpressionOrSpreadTag::UpdateExpression => {
1588 + let node: Box<UpdateExpression> = <Box<
1589 + UpdateExpression,
1590 + > as Deserialize>::deserialize(
1591 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1592 + )?;
1593 + Ok(ExpressionOrSpread::Expression(Expression::UpdateExpression(node)))
1594 + }
1595 + __ExpressionOrSpreadTag::YieldExpression => {
1596 + let node: Box<YieldExpression> = <Box<
1597 + YieldExpression,
1598 + > as Deserialize>::deserialize(
1599 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1600 + )?;
1601 + Ok(ExpressionOrSpread::Expression(Expression::YieldExpression(node)))
1602 + }
1603 + __ExpressionOrSpreadTag::SpreadElement => {
1604 + let node: Box<SpreadElement> = <Box<
1605 + SpreadElement,
1606 + > as Deserialize>::deserialize(
1607 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1608 + )?;
1609 + Ok(ExpressionOrSpread::SpreadElement(node))
1610 + }
1611 + }
1612 + }
1613 +}
1614 +#[derive(Serialize, Clone, Debug)]
1615 #[serde(untagged)]
1616 pub enum FunctionBody {
1617 BlockStatement(Box<BlockStatement>),
1618 Expression(Expression),
1619 }
561 -#[derive(Serialize, Deserialize, Clone, Debug)]
1620 +#[derive(Deserialize, Debug)]
1621 +enum __FunctionBodyTag {
1622 + BlockStatement,
1623 + ArrayExpression,
1624 + ArrowFunctionExpression,
1625 + AssignmentExpression,
1626 + BinaryExpression,
1627 + CallExpression,
1628 + ConditionalExpression,
1629 + FunctionExpression,
1630 + Identifier,
1631 + Literal,
1632 + LogicalExpression,
1633 + MemberExpression,
1634 + NewExpression,
1635 + ObjectExpression,
1636 + SequenceExpression,
1637 + ThisExpression,
1638 + UnaryExpression,
1639 + UpdateExpression,
1640 + YieldExpression,
1641 +}
1642 +impl<'de> serde::Deserialize<'de> for FunctionBody {
1643 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1644 + where
1645 + D: serde::Deserializer<'de>,
1646 + {
1647 + let tagged = serde::Deserializer::deserialize_any(
1648 + deserializer,
1649 + serde::__private::de::TaggedContentVisitor::<
1650 + __FunctionBodyTag,
1651 + >::new("type", "Pattern"),
1652 + )?;
1653 + match tagged.0 {
1654 + __FunctionBodyTag::BlockStatement => {
1655 + let node: Box<BlockStatement> = <Box<
1656 + BlockStatement,
1657 + > as Deserialize>::deserialize(
1658 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1659 + )?;
1660 + Ok(FunctionBody::BlockStatement(node))
1661 + }
1662 + __FunctionBodyTag::ArrayExpression => {
1663 + let node: Box<ArrayExpression> = <Box<
1664 + ArrayExpression,
1665 + > as Deserialize>::deserialize(
1666 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1667 + )?;
1668 + Ok(FunctionBody::Expression(Expression::ArrayExpression(node)))
1669 + }
1670 + __FunctionBodyTag::ArrowFunctionExpression => {
1671 + let node: Box<ArrowFunctionExpression> = <Box<
1672 + ArrowFunctionExpression,
1673 + > as Deserialize>::deserialize(
1674 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1675 + )?;
1676 + Ok(FunctionBody::Expression(Expression::ArrowFunctionExpression(node)))
1677 + }
1678 + __FunctionBodyTag::AssignmentExpression => {
1679 + let node: Box<AssignmentExpression> = <Box<
1680 + AssignmentExpression,
1681 + > as Deserialize>::deserialize(
1682 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1683 + )?;
1684 + Ok(FunctionBody::Expression(Expression::AssignmentExpression(node)))
1685 + }
1686 + __FunctionBodyTag::BinaryExpression => {
1687 + let node: Box<BinaryExpression> = <Box<
1688 + BinaryExpression,
1689 + > as Deserialize>::deserialize(
1690 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1691 + )?;
1692 + Ok(FunctionBody::Expression(Expression::BinaryExpression(node)))
1693 + }
1694 + __FunctionBodyTag::CallExpression => {
1695 + let node: Box<CallExpression> = <Box<
1696 + CallExpression,
1697 + > as Deserialize>::deserialize(
1698 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1699 + )?;
1700 + Ok(FunctionBody::Expression(Expression::CallExpression(node)))
1701 + }
1702 + __FunctionBodyTag::ConditionalExpression => {
1703 + let node: Box<ConditionalExpression> = <Box<
1704 + ConditionalExpression,
1705 + > as Deserialize>::deserialize(
1706 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1707 + )?;
1708 + Ok(FunctionBody::Expression(Expression::ConditionalExpression(node)))
1709 + }
1710 + __FunctionBodyTag::FunctionExpression => {
1711 + let node: Box<FunctionExpression> = <Box<
1712 + FunctionExpression,
1713 + > as Deserialize>::deserialize(
1714 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1715 + )?;
1716 + Ok(FunctionBody::Expression(Expression::FunctionExpression(node)))
1717 + }
1718 + __FunctionBodyTag::Identifier => {
1719 + let node: Box<Identifier> = <Box<
1720 + Identifier,
1721 + > as Deserialize>::deserialize(
1722 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1723 + )?;
1724 + Ok(FunctionBody::Expression(Expression::Identifier(node)))
1725 + }
1726 + __FunctionBodyTag::Literal => {
1727 + let node: Box<Literal> = <Box<
1728 + Literal,
1729 + > as Deserialize>::deserialize(
1730 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1731 + )?;
1732 + Ok(FunctionBody::Expression(Expression::Literal(node)))
1733 + }
1734 + __FunctionBodyTag::LogicalExpression => {
1735 + let node: Box<LogicalExpression> = <Box<
1736 + LogicalExpression,
1737 + > as Deserialize>::deserialize(
1738 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1739 + )?;
1740 + Ok(FunctionBody::Expression(Expression::LogicalExpression(node)))
1741 + }
1742 + __FunctionBodyTag::MemberExpression => {
1743 + let node: Box<MemberExpression> = <Box<
1744 + MemberExpression,
1745 + > as Deserialize>::deserialize(
1746 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1747 + )?;
1748 + Ok(FunctionBody::Expression(Expression::MemberExpression(node)))
1749 + }
1750 + __FunctionBodyTag::NewExpression => {
1751 + let node: Box<NewExpression> = <Box<
1752 + NewExpression,
1753 + > as Deserialize>::deserialize(
1754 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1755 + )?;
1756 + Ok(FunctionBody::Expression(Expression::NewExpression(node)))
1757 + }
1758 + __FunctionBodyTag::ObjectExpression => {
1759 + let node: Box<ObjectExpression> = <Box<
1760 + ObjectExpression,
1761 + > as Deserialize>::deserialize(
1762 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1763 + )?;
1764 + Ok(FunctionBody::Expression(Expression::ObjectExpression(node)))
1765 + }
1766 + __FunctionBodyTag::SequenceExpression => {
1767 + let node: Box<SequenceExpression> = <Box<
1768 + SequenceExpression,
1769 + > as Deserialize>::deserialize(
1770 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1771 + )?;
1772 + Ok(FunctionBody::Expression(Expression::SequenceExpression(node)))
1773 + }
1774 + __FunctionBodyTag::ThisExpression => {
1775 + let node: Box<ThisExpression> = <Box<
1776 + ThisExpression,
1777 + > as Deserialize>::deserialize(
1778 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1779 + )?;
1780 + Ok(FunctionBody::Expression(Expression::ThisExpression(node)))
1781 + }
1782 + __FunctionBodyTag::UnaryExpression => {
1783 + let node: Box<UnaryExpression> = <Box<
1784 + UnaryExpression,
1785 + > as Deserialize>::deserialize(
1786 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1787 + )?;
1788 + Ok(FunctionBody::Expression(Expression::UnaryExpression(node)))
1789 + }
1790 + __FunctionBodyTag::UpdateExpression => {
1791 + let node: Box<UpdateExpression> = <Box<
1792 + UpdateExpression,
1793 + > as Deserialize>::deserialize(
1794 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1795 + )?;
1796 + Ok(FunctionBody::Expression(Expression::UpdateExpression(node)))
1797 + }
1798 + __FunctionBodyTag::YieldExpression => {
1799 + let node: Box<YieldExpression> = <Box<
1800 + YieldExpression,
1801 + > as Deserialize>::deserialize(
1802 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1803 + )?;
1804 + Ok(FunctionBody::Expression(Expression::YieldExpression(node)))
1805 + }
1806 + }
1807 + }
1808 +}
1809 +#[derive(Serialize, Clone, Debug)]
1810 #[serde(tag = "type")]
1811 pub enum Pattern {
1812 Identifier(Box<Identifier>),
1813 }
566 -#[derive(Serialize, Deserialize, Clone, Debug)]
1814 +#[derive(Deserialize, Debug)]
1815 +enum __PatternTag {
1816 + Identifier,
1817 +}
1818 +impl<'de> serde::Deserialize<'de> for Pattern {
1819 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1820 + where
1821 + D: serde::Deserializer<'de>,
1822 + {
1823 + let tagged = serde::Deserializer::deserialize_any(
1824 + deserializer,
1825 + serde::__private::de::TaggedContentVisitor::<
1826 + __PatternTag,
1827 + >::new("type", "Pattern"),
1828 + )?;
1829 + match tagged.0 {
1830 + __PatternTag::Identifier => {
1831 + let node: Box<Identifier> = <Box<
1832 + Identifier,
1833 + > as Deserialize>::deserialize(
1834 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1835 + )?;
1836 + Ok(Pattern::Identifier(node))
1837 + }
1838 + }
1839 + }
1840 +}
1841 +#[derive(Serialize, Clone, Debug)]
1842 #[serde(untagged)]
1843 pub enum ForInit {
1844 Expression(Expression),
1845 VariableDeclaration(Box<VariableDeclaration>),
1846 }
572 -#[derive(Serialize, Deserialize, Clone, Debug)]
1847 +#[derive(Deserialize, Debug)]
1848 +enum __ForInitTag {
1849 + ArrayExpression,
1850 + ArrowFunctionExpression,
1851 + AssignmentExpression,
1852 + BinaryExpression,
1853 + CallExpression,
1854 + ConditionalExpression,
1855 + FunctionExpression,
1856 + Identifier,
1857 + Literal,
1858 + LogicalExpression,
1859 + MemberExpression,
1860 + NewExpression,
1861 + ObjectExpression,
1862 + SequenceExpression,
1863 + ThisExpression,
1864 + UnaryExpression,
1865 + UpdateExpression,
1866 + YieldExpression,
1867 + VariableDeclaration,
1868 +}
1869 +impl<'de> serde::Deserialize<'de> for ForInit {
1870 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1871 + where
1872 + D: serde::Deserializer<'de>,
1873 + {
1874 + let tagged = serde::Deserializer::deserialize_any(
1875 + deserializer,
1876 + serde::__private::de::TaggedContentVisitor::<
1877 + __ForInitTag,
1878 + >::new("type", "Pattern"),
1879 + )?;
1880 + match tagged.0 {
1881 + __ForInitTag::ArrayExpression => {
1882 + let node: Box<ArrayExpression> = <Box<
1883 + ArrayExpression,
1884 + > as Deserialize>::deserialize(
1885 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1886 + )?;
1887 + Ok(ForInit::Expression(Expression::ArrayExpression(node)))
1888 + }
1889 + __ForInitTag::ArrowFunctionExpression => {
1890 + let node: Box<ArrowFunctionExpression> = <Box<
1891 + ArrowFunctionExpression,
1892 + > as Deserialize>::deserialize(
1893 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1894 + )?;
1895 + Ok(ForInit::Expression(Expression::ArrowFunctionExpression(node)))
1896 + }
1897 + __ForInitTag::AssignmentExpression => {
1898 + let node: Box<AssignmentExpression> = <Box<
1899 + AssignmentExpression,
1900 + > as Deserialize>::deserialize(
1901 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1902 + )?;
1903 + Ok(ForInit::Expression(Expression::AssignmentExpression(node)))
1904 + }
1905 + __ForInitTag::BinaryExpression => {
1906 + let node: Box<BinaryExpression> = <Box<
1907 + BinaryExpression,
1908 + > as Deserialize>::deserialize(
1909 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1910 + )?;
1911 + Ok(ForInit::Expression(Expression::BinaryExpression(node)))
1912 + }
1913 + __ForInitTag::CallExpression => {
1914 + let node: Box<CallExpression> = <Box<
1915 + CallExpression,
1916 + > as Deserialize>::deserialize(
1917 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1918 + )?;
1919 + Ok(ForInit::Expression(Expression::CallExpression(node)))
1920 + }
1921 + __ForInitTag::ConditionalExpression => {
1922 + let node: Box<ConditionalExpression> = <Box<
1923 + ConditionalExpression,
1924 + > as Deserialize>::deserialize(
1925 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1926 + )?;
1927 + Ok(ForInit::Expression(Expression::ConditionalExpression(node)))
1928 + }
1929 + __ForInitTag::FunctionExpression => {
1930 + let node: Box<FunctionExpression> = <Box<
1931 + FunctionExpression,
1932 + > as Deserialize>::deserialize(
1933 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1934 + )?;
1935 + Ok(ForInit::Expression(Expression::FunctionExpression(node)))
1936 + }
1937 + __ForInitTag::Identifier => {
1938 + let node: Box<Identifier> = <Box<
1939 + Identifier,
1940 + > as Deserialize>::deserialize(
1941 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1942 + )?;
1943 + Ok(ForInit::Expression(Expression::Identifier(node)))
1944 + }
1945 + __ForInitTag::Literal => {
1946 + let node: Box<Literal> = <Box<
1947 + Literal,
1948 + > as Deserialize>::deserialize(
1949 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1950 + )?;
1951 + Ok(ForInit::Expression(Expression::Literal(node)))
1952 + }
1953 + __ForInitTag::LogicalExpression => {
1954 + let node: Box<LogicalExpression> = <Box<
1955 + LogicalExpression,
1956 + > as Deserialize>::deserialize(
1957 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1958 + )?;
1959 + Ok(ForInit::Expression(Expression::LogicalExpression(node)))
1960 + }
1961 + __ForInitTag::MemberExpression => {
1962 + let node: Box<MemberExpression> = <Box<
1963 + MemberExpression,
1964 + > as Deserialize>::deserialize(
1965 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1966 + )?;
1967 + Ok(ForInit::Expression(Expression::MemberExpression(node)))
1968 + }
1969 + __ForInitTag::NewExpression => {
1970 + let node: Box<NewExpression> = <Box<
1971 + NewExpression,
1972 + > as Deserialize>::deserialize(
1973 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1974 + )?;
1975 + Ok(ForInit::Expression(Expression::NewExpression(node)))
1976 + }
1977 + __ForInitTag::ObjectExpression => {
1978 + let node: Box<ObjectExpression> = <Box<
1979 + ObjectExpression,
1980 + > as Deserialize>::deserialize(
1981 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1982 + )?;
1983 + Ok(ForInit::Expression(Expression::ObjectExpression(node)))
1984 + }
1985 + __ForInitTag::SequenceExpression => {
1986 + let node: Box<SequenceExpression> = <Box<
1987 + SequenceExpression,
1988 + > as Deserialize>::deserialize(
1989 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1990 + )?;
1991 + Ok(ForInit::Expression(Expression::SequenceExpression(node)))
1992 + }
1993 + __ForInitTag::ThisExpression => {
1994 + let node: Box<ThisExpression> = <Box<
1995 + ThisExpression,
1996 + > as Deserialize>::deserialize(
1997 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1998 + )?;
1999 + Ok(ForInit::Expression(Expression::ThisExpression(node)))
2000 + }
2001 + __ForInitTag::UnaryExpression => {
2002 + let node: Box<UnaryExpression> = <Box<
2003 + UnaryExpression,
2004 + > as Deserialize>::deserialize(
2005 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2006 + )?;
2007 + Ok(ForInit::Expression(Expression::UnaryExpression(node)))
2008 + }
2009 + __ForInitTag::UpdateExpression => {
2010 + let node: Box<UpdateExpression> = <Box<
2011 + UpdateExpression,
2012 + > as Deserialize>::deserialize(
2013 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2014 + )?;
2015 + Ok(ForInit::Expression(Expression::UpdateExpression(node)))
2016 + }
2017 + __ForInitTag::YieldExpression => {
2018 + let node: Box<YieldExpression> = <Box<
2019 + YieldExpression,
2020 + > as Deserialize>::deserialize(
2021 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2022 + )?;
2023 + Ok(ForInit::Expression(Expression::YieldExpression(node)))
2024 + }
2025 + __ForInitTag::VariableDeclaration => {
2026 + let node: Box<VariableDeclaration> = <Box<
2027 + VariableDeclaration,
2028 + > as Deserialize>::deserialize(
2029 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2030 + )?;
2031 + Ok(ForInit::VariableDeclaration(node))
2032 + }
2033 + }
2034 + }
2035 +}
2036 +#[derive(Serialize, Clone, Debug)]
2037 #[serde(untagged)]
2038 pub enum ForInInit {
2039 Pattern(Pattern),
2040 VariableDeclaration(Box<VariableDeclaration>),
2041 }
578 -#[derive(Serialize, Deserialize, Clone, Debug)]
2042 +#[derive(Deserialize, Debug)]
2043 +enum __ForInInitTag {
2044 + Identifier,
2045 + VariableDeclaration,
2046 +}
2047 +impl<'de> serde::Deserialize<'de> for ForInInit {
2048 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2049 + where
2050 + D: serde::Deserializer<'de>,
2051 + {
2052 + let tagged = serde::Deserializer::deserialize_any(
2053 + deserializer,
2054 + serde::__private::de::TaggedContentVisitor::<
2055 + __ForInInitTag,
2056 + >::new("type", "Pattern"),
2057 + )?;
2058 + match tagged.0 {
2059 + __ForInInitTag::Identifier => {
2060 + let node: Box<Identifier> = <Box<
2061 + Identifier,
2062 + > as Deserialize>::deserialize(
2063 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2064 + )?;
2065 + Ok(ForInInit::Pattern(Pattern::Identifier(node)))
2066 + }
2067 + __ForInInitTag::VariableDeclaration => {
2068 + let node: Box<VariableDeclaration> = <Box<
2069 + VariableDeclaration,
2070 + > as Deserialize>::deserialize(
2071 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2072 + )?;
2073 + Ok(ForInInit::VariableDeclaration(node))
2074 + }
2075 + }
2076 + }
2077 +}
2078 +#[derive(Serialize, Clone, Debug)]
2079 #[serde(tag = "type")]
2080 pub enum PropertyKey {
2081 Identifier(Box<Identifier>),
2082 Literal(Box<Literal>),
2083 }
584 -#[derive(Serialize, Deserialize, Clone, Debug)]
2084 +#[derive(Deserialize, Debug)]
2085 +enum __PropertyKeyTag {
2086 + Identifier,
2087 + Literal,
2088 +}
2089 +impl<'de> serde::Deserialize<'de> for PropertyKey {
2090 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2091 + where
2092 + D: serde::Deserializer<'de>,
2093 + {
2094 + let tagged = serde::Deserializer::deserialize_any(
2095 + deserializer,
2096 + serde::__private::de::TaggedContentVisitor::<
2097 + __PropertyKeyTag,
2098 + >::new("type", "Pattern"),
2099 + )?;
2100 + match tagged.0 {
2101 + __PropertyKeyTag::Identifier => {
2102 + let node: Box<Identifier> = <Box<
2103 + Identifier,
2104 + > as Deserialize>::deserialize(
2105 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2106 + )?;
2107 + Ok(PropertyKey::Identifier(node))
2108 + }
2109 + __PropertyKeyTag::Literal => {
2110 + let node: Box<Literal> = <Box<
2111 + Literal,
2112 + > as Deserialize>::deserialize(
2113 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2114 + )?;
2115 + Ok(PropertyKey::Literal(node))
2116 + }
2117 + }
2118 + }
2119 +}
2120 +#[derive(Serialize, Clone, Debug)]
2121 #[serde(untagged)]
2122 pub enum AssignmentTarget {
2123 Expression(Expression),
2124 Pattern(Pattern),
2125 }
2126 +#[derive(Deserialize, Debug)]
2127 +enum __AssignmentTargetTag {
2128 + ArrayExpression,
2129 + ArrowFunctionExpression,
2130 + AssignmentExpression,
2131 + BinaryExpression,
2132 + CallExpression,
2133 + ConditionalExpression,
2134 + FunctionExpression,
2135 + Identifier,
2136 + Literal,
2137 + LogicalExpression,
2138 + MemberExpression,
2139 + NewExpression,
2140 + ObjectExpression,
2141 + SequenceExpression,
2142 + ThisExpression,
2143 + UnaryExpression,
2144 + UpdateExpression,
2145 + YieldExpression,
2146 +}
2147 +impl<'de> serde::Deserialize<'de> for AssignmentTarget {
2148 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2149 + where
2150 + D: serde::Deserializer<'de>,
2151 + {
2152 + let tagged = serde::Deserializer::deserialize_any(
2153 + deserializer,
2154 + serde::__private::de::TaggedContentVisitor::<
2155 + __AssignmentTargetTag,
2156 + >::new("type", "Pattern"),
2157 + )?;
2158 + match tagged.0 {
2159 + __AssignmentTargetTag::ArrayExpression => {
2160 + let node: Box<ArrayExpression> = <Box<
2161 + ArrayExpression,
2162 + > as Deserialize>::deserialize(
2163 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2164 + )?;
2165 + Ok(AssignmentTarget::Expression(Expression::ArrayExpression(node)))
2166 + }
2167 + __AssignmentTargetTag::ArrowFunctionExpression => {
2168 + let node: Box<ArrowFunctionExpression> = <Box<
2169 + ArrowFunctionExpression,
2170 + > as Deserialize>::deserialize(
2171 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2172 + )?;
2173 + Ok(
2174 + AssignmentTarget::Expression(
2175 + Expression::ArrowFunctionExpression(node),
2176 + ),
2177 + )
2178 + }
2179 + __AssignmentTargetTag::AssignmentExpression => {
2180 + let node: Box<AssignmentExpression> = <Box<
2181 + AssignmentExpression,
2182 + > as Deserialize>::deserialize(
2183 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2184 + )?;
2185 + Ok(AssignmentTarget::Expression(Expression::AssignmentExpression(node)))
2186 + }
2187 + __AssignmentTargetTag::BinaryExpression => {
2188 + let node: Box<BinaryExpression> = <Box<
2189 + BinaryExpression,
2190 + > as Deserialize>::deserialize(
2191 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2192 + )?;
2193 + Ok(AssignmentTarget::Expression(Expression::BinaryExpression(node)))
2194 + }
2195 + __AssignmentTargetTag::CallExpression => {
2196 + let node: Box<CallExpression> = <Box<
2197 + CallExpression,
2198 + > as Deserialize>::deserialize(
2199 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2200 + )?;
2201 + Ok(AssignmentTarget::Expression(Expression::CallExpression(node)))
2202 + }
2203 + __AssignmentTargetTag::ConditionalExpression => {
2204 + let node: Box<ConditionalExpression> = <Box<
2205 + ConditionalExpression,
2206 + > as Deserialize>::deserialize(
2207 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2208 + )?;
2209 + Ok(AssignmentTarget::Expression(Expression::ConditionalExpression(node)))
2210 + }
2211 + __AssignmentTargetTag::FunctionExpression => {
2212 + let node: Box<FunctionExpression> = <Box<
2213 + FunctionExpression,
2214 + > as Deserialize>::deserialize(
2215 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2216 + )?;
2217 + Ok(AssignmentTarget::Expression(Expression::FunctionExpression(node)))
2218 + }
2219 + __AssignmentTargetTag::Identifier => {
2220 + let node: Box<Identifier> = <Box<
2221 + Identifier,
2222 + > as Deserialize>::deserialize(
2223 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2224 + )?;
2225 + Ok(AssignmentTarget::Expression(Expression::Identifier(node)))
2226 + }
2227 + __AssignmentTargetTag::Literal => {
2228 + let node: Box<Literal> = <Box<
2229 + Literal,
2230 + > as Deserialize>::deserialize(
2231 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2232 + )?;
2233 + Ok(AssignmentTarget::Expression(Expression::Literal(node)))
2234 + }
2235 + __AssignmentTargetTag::LogicalExpression => {
2236 + let node: Box<LogicalExpression> = <Box<
2237 + LogicalExpression,
2238 + > as Deserialize>::deserialize(
2239 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2240 + )?;
2241 + Ok(AssignmentTarget::Expression(Expression::LogicalExpression(node)))
2242 + }
2243 + __AssignmentTargetTag::MemberExpression => {
2244 + let node: Box<MemberExpression> = <Box<
2245 + MemberExpression,
2246 + > as Deserialize>::deserialize(
2247 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2248 + )?;
2249 + Ok(AssignmentTarget::Expression(Expression::MemberExpression(node)))
2250 + }
2251 + __AssignmentTargetTag::NewExpression => {
2252 + let node: Box<NewExpression> = <Box<
2253 + NewExpression,
2254 + > as Deserialize>::deserialize(
2255 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2256 + )?;
2257 + Ok(AssignmentTarget::Expression(Expression::NewExpression(node)))
2258 + }
2259 + __AssignmentTargetTag::ObjectExpression => {
2260 + let node: Box<ObjectExpression> = <Box<
2261 + ObjectExpression,
2262 + > as Deserialize>::deserialize(
2263 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2264 + )?;
2265 + Ok(AssignmentTarget::Expression(Expression::ObjectExpression(node)))
2266 + }
2267 + __AssignmentTargetTag::SequenceExpression => {
2268 + let node: Box<SequenceExpression> = <Box<
2269 + SequenceExpression,
2270 + > as Deserialize>::deserialize(
2271 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2272 + )?;
2273 + Ok(AssignmentTarget::Expression(Expression::SequenceExpression(node)))
2274 + }
2275 + __AssignmentTargetTag::ThisExpression => {
2276 + let node: Box<ThisExpression> = <Box<
2277 + ThisExpression,
2278 + > as Deserialize>::deserialize(
2279 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2280 + )?;
2281 + Ok(AssignmentTarget::Expression(Expression::ThisExpression(node)))
2282 + }
2283 + __AssignmentTargetTag::UnaryExpression => {
2284 + let node: Box<UnaryExpression> = <Box<
2285 + UnaryExpression,
2286 + > as Deserialize>::deserialize(
2287 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2288 + )?;
2289 + Ok(AssignmentTarget::Expression(Expression::UnaryExpression(node)))
2290 + }
2291 + __AssignmentTargetTag::UpdateExpression => {
2292 + let node: Box<UpdateExpression> = <Box<
2293 + UpdateExpression,
2294 + > as Deserialize>::deserialize(
2295 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2296 + )?;
2297 + Ok(AssignmentTarget::Expression(Expression::UpdateExpression(node)))
2298 + }
2299 + __AssignmentTargetTag::YieldExpression => {
2300 + let node: Box<YieldExpression> = <Box<
2301 + YieldExpression,
2302 + > as Deserialize>::deserialize(
2303 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2304 + )?;
2305 + Ok(AssignmentTarget::Expression(Expression::YieldExpression(node)))
2306 + }
2307 + }
2308 + }
2309 +}
2310 #[derive(
2311 Serialize,
2312 Deserialize,