[rust] Extract HIR initialization passes to hir crate
Joe Savona committed
Jul 14, 2023 at 15:46 UTC
0a79974d0e87d9e12abc4bd43ec01ad5fef4df8d
10 files changed
+1241
-1022
compiler/forget/Cargo.lock
+2
@@ -521,10 +521,12 @@ name = "forget_hir"
521
version = "0.1.0"
522
dependencies = [
523
"bumpalo",
524
+ "forget_diagnostics",
525
"forget_estree",
526
"forget_utils",
527
"indexmap 2.0.0",
528
"serde",
529
+ "thiserror",
530
]
531
532
[[package]]
compiler/forget/crates/forget_build_hir/src/build.rs
+1
-1
@@ -2,7 +2,7 @@ use std::collections::HashSet;
2
3
use bumpalo::boxed::Box;
4
use bumpalo::collections::String;
5
-use forget_diagnostics::{Diagnostic, DiagnosticSeverity};
5
+use forget_diagnostics::Diagnostic;
6
use forget_estree::{
7
AssignmentTarget, BinaryExpression, BlockStatement, Expression, ForInit, ForStatement,
8
Function, FunctionExpression, IfStatement, JsValue, Literal, Pattern, Statement,
compiler/forget/crates/forget_build_hir/src/builder.rs
+4
-162
@@ -1,13 +1,13 @@
1
use std::cell::RefCell;
2
-use std::collections::HashSet;
2
use std::rc::Rc;
3
4
use bumpalo::boxed::Box;
5
use bumpalo::collections::{String, Vec};
7
-use forget_diagnostics::{invariant, Diagnostic, DiagnosticSeverity};
6
+use forget_diagnostics::Diagnostic;
7
use forget_hir::{
9
- BasicBlock, BlockId, BlockKind, Environment, GotoKind, Identifier, IdentifierData, InstrIx,
10
- Instruction, InstructionIdGenerator, InstructionValue, Terminal, TerminalValue, Type, HIR,
8
+ initialize_hir, BasicBlock, BlockId, BlockKind, Environment, GotoKind, Identifier,
9
+ IdentifierData, InstrIx, Instruction, InstructionIdGenerator, InstructionValue, Terminal,
10
+ TerminalValue, Type, HIR,
11
};
12
use indexmap::IndexMap;
13
@@ -346,161 +346,3 @@ impl<'a> Builder<'a> {
346
}
347
}
348
}
349
-
350
-pub fn initialize_hir<'a>(hir: &mut HIR<'a>) -> Result<(), Diagnostic> {
351
- reverse_postorder_blocks(hir);
352
- remove_unreachable_for_updates(hir);
353
- remove_unreachable_fallthroughs(hir);
354
- remove_unreachable_do_while_statements(hir);
355
- mark_instruction_ids(hir)?;
356
- mark_predecessors(hir);
357
- Ok(())
358
-}
359
-
360
-/// Modifies the HIR to put the blocks in reverse postorder, with predecessors before
361
-/// successors (except for the case of loops)
362
-pub fn reverse_postorder_blocks<'a>(hir: &mut HIR<'a>) {
363
- let mut visited = HashSet::<BlockId>::with_capacity(hir.blocks.len());
364
- let mut postorder = std::vec::Vec::<BlockId>::with_capacity(hir.blocks.len());
365
- fn visit<'a>(
366
- block_id: BlockId,
367
- hir: &HIR<'a>,
368
- visited: &mut HashSet<BlockId>,
369
- postorder: &mut std::vec::Vec<BlockId>,
370
- ) {
371
- if !visited.insert(block_id) {
372
- // already visited
373
- return;
374
- }
375
- let block = hir.block(block_id);
376
- let terminal = &block.terminal;
377
- match &terminal.value {
378
- TerminalValue::Branch(terminal) => {
379
- visit(terminal.alternate, hir, visited, postorder);
380
- visit(terminal.consequent, hir, visited, postorder);
381
- }
382
- TerminalValue::If(terminal) => {
383
- visit(terminal.alternate, hir, visited, postorder);
384
- visit(terminal.consequent, hir, visited, postorder);
385
- }
386
- TerminalValue::For(terminal) => {
387
- visit(terminal.init, hir, visited, postorder);
388
- }
389
- TerminalValue::DoWhile(terminal) => {
390
- visit(terminal.body, hir, visited, postorder);
391
- }
392
- TerminalValue::Goto(terminal) => {
393
- visit(terminal.block, hir, visited, postorder);
394
- }
395
- TerminalValue::Return(..) => { /* no-op */ }
396
- TerminalValue::Unsupported(..) => {
397
- panic!("Unexpected unsupported terminal")
398
- }
399
- }
400
- postorder.push(block_id);
401
- }
402
- visit(hir.entry, &hir, &mut visited, &mut postorder);
403
-
404
- // NOTE: could consider sorting the blocks in-place by key
405
- let mut blocks = IndexMap::with_capacity(hir.blocks.len());
406
- for id in postorder.iter().rev().cloned() {
407
- blocks.insert(id, hir.blocks.remove(&id).unwrap());
408
- }
409
-
410
- hir.blocks = blocks;
411
-}
412
-
413
-/// Prunes ForTerminal.update values (sets to None) if they are unreachable
414
-pub fn remove_unreachable_for_updates<'a>(hir: &mut HIR<'a>) {
415
- let block_ids: HashSet<BlockId> = hir.blocks.keys().cloned().collect();
416
-
417
- for block in hir.blocks.values_mut() {
418
- if let TerminalValue::For(terminal) = &mut block.terminal.value {
419
- if let Some(update) = terminal.update {
420
- if !block_ids.contains(&update) {
421
- terminal.update = None;
422
- }
423
- }
424
- }
425
- }
426
-}
427
-
428
-/// Prunes unreachable fallthrough values, setting them to None if the referenced
429
-/// block was not otherwise reachable.
430
-pub fn remove_unreachable_fallthroughs<'a>(hir: &mut HIR<'a>) {
431
- let block_ids: HashSet<BlockId> = hir.blocks.keys().cloned().collect();
432
-
433
- for block in hir.blocks.values_mut() {
434
- block
435
- .terminal
436
- .value
437
- .map_optional_fallthroughs(|fallthrough| {
438
- if block_ids.contains(&fallthrough) {
439
- Some(fallthrough)
440
- } else {
441
- None
442
- }
443
- })
444
- }
445
-}
446
-
447
-/// Rewrites DoWhile statements into Gotos if the test block is not reachable
448
-pub fn remove_unreachable_do_while_statements<'a>(hir: &mut HIR<'a>) {
449
- let block_ids: HashSet<BlockId> = hir.blocks.keys().cloned().collect();
450
-
451
- for block in hir.blocks.values_mut() {
452
- if let TerminalValue::DoWhile(terminal) = &mut block.terminal.value {
453
- if !block_ids.contains(&terminal.test) {
454
- block.terminal.value = TerminalValue::Goto(forget_hir::GotoTerminal {
455
- block: terminal.body,
456
- kind: GotoKind::Break,
457
- });
458
- }
459
- }
460
- }
461
-}
462
-
463
-/// Updates the instruction ids for all instructions and blocks
464
-/// Relies on the blocks being in reverse postorder to ensure that id ordering is correct
465
-pub fn mark_instruction_ids<'a>(hir: &mut HIR<'a>) -> Result<(), Diagnostic> {
466
- let mut id_gen = InstructionIdGenerator::new();
467
- let mut visited = HashSet::<(usize, usize)>::new();
468
- for (ii, block) in hir.blocks.values_mut().enumerate() {
469
- let block_id = block.id;
470
- for (jj, instr_ix) in block.instructions.iter_mut().enumerate() {
471
- invariant(visited.insert((ii, jj)), || {
472
- Diagnostic::invariant(BuildHIRError::BlockVisitedTwice { block: block_id }, None)
473
- })?;
474
- let instr = &mut hir.instructions[usize::from(*instr_ix)];
475
- instr.id = id_gen.next();
476
- }
477
- block.terminal.id = id_gen.next();
478
- }
479
- Ok(())
480
-}
481
-
482
-/// Updates the predecessors of each block
483
-pub fn mark_predecessors<'a>(hir: &mut HIR<'a>) {
484
- for block in hir.blocks.values_mut() {
485
- block.predecessors.clear();
486
- }
487
- let mut visited = HashSet::<BlockId>::with_capacity(hir.blocks.len());
488
- fn visit<'a>(
489
- block_id: BlockId,
490
- prev_id: Option<BlockId>,
491
- hir: &mut HIR<'a>,
492
- visited: &mut HashSet<BlockId>,
493
- ) {
494
- let block = hir.block_mut(block_id);
495
- if let Some(prev_id) = prev_id {
496
- block.predecessors.insert(prev_id);
497
- }
498
- if !visited.insert(block_id) {
499
- return;
500
- }
501
- for successor in block.terminal.value.successors() {
502
- visit(successor, Some(block_id), hir, visited)
503
- }
504
- }
505
- visit(hir.entry, None, hir, &mut visited);
506
-}
compiler/forget/crates/forget_build_hir/src/error.rs
-5
@@ -1,4 +1,3 @@
1
-use forget_hir::BlockId;
1
use thiserror::Error;
2
3
/// Errors which can occur during HIR construction
@@ -32,10 +31,6 @@ pub enum BuildHIRError {
31
#[error("React functions may not reassign variables defined outside of the component or hook")]
32
ReassignedGlobal,
33
35
- /// ErrorSeverity::Invariant
36
- #[error("Invariant: Expected block {block} not to have been visited yet")]
37
- BlockVisitedTwice { block: BlockId },
38
-
34
/// ErrorSeverity::InvalidSyntax
35
#[error("Could not resolve a target for `break` statement")]
36
UnresolvedBreakTarget,
compiler/forget/crates/forget_build_hir/src/lib.rs
-5
@@ -4,9 +4,4 @@ mod context;
4
mod error;
5
6
pub use build::build;
7
-pub use builder::{
8
- initialize_hir, mark_instruction_ids, mark_predecessors,
9
- remove_unreachable_do_while_statements, remove_unreachable_fallthroughs,
10
- remove_unreachable_for_updates, reverse_postorder_blocks,
11
-};
7
pub use error::*;
compiler/forget/crates/forget_estree/src/generated.rs
+1050
-846
@@ -1,8 +1,6 @@
1
use std::num::NonZeroU32;
2
-
3
-use serde::{Deserialize, Serialize};
4
-
5
-use crate::{Binding, JsValue, SourceRange};
2
+use serde::{Serialize, Deserialize};
3
+use crate::{JsValue, Binding, SourceRange};
4
#[derive(Serialize, Deserialize, Clone, Debug)]
5
pub struct SourceLocation {
6
pub source: Option<String>,
@@ -669,134 +667,167 @@ impl<'de> serde::Deserialize<'de> for Statement {
667
{
668
let tagged = serde::Deserializer::deserialize_any(
669
deserializer,
672
- serde::__private::de::TaggedContentVisitor::<__StatementTag>::new("type", "Pattern"),
670
+ serde::__private::de::TaggedContentVisitor::<
671
+ __StatementTag,
672
+ >::new("type", "Pattern"),
673
)?;
674
match tagged.0 {
675
__StatementTag::BlockStatement => {
676
- let node: Box<BlockStatement> = <Box<BlockStatement> as Deserialize>::deserialize(
676
+ let node: Box<BlockStatement> = <Box<
677
+ BlockStatement,
678
+ > as Deserialize>::deserialize(
679
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
680
)?;
681
Ok(Statement::BlockStatement(node))
682
}
683
__StatementTag::BreakStatement => {
682
- let node: Box<BreakStatement> = <Box<BreakStatement> as Deserialize>::deserialize(
684
+ let node: Box<BreakStatement> = <Box<
685
+ BreakStatement,
686
+ > as Deserialize>::deserialize(
687
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
688
)?;
689
Ok(Statement::BreakStatement(node))
690
}
691
__StatementTag::ContinueStatement => {
688
- let node: Box<ContinueStatement> =
689
- <Box<ContinueStatement> as Deserialize>::deserialize(
690
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
691
- )?;
692
+ let node: Box<ContinueStatement> = <Box<
693
+ ContinueStatement,
694
+ > as Deserialize>::deserialize(
695
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
696
+ )?;
697
Ok(Statement::ContinueStatement(node))
698
}
699
__StatementTag::DebuggerStatement => {
695
- let node: Box<DebuggerStatement> =
696
- <Box<DebuggerStatement> as Deserialize>::deserialize(
697
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
698
- )?;
700
+ let node: Box<DebuggerStatement> = <Box<
701
+ DebuggerStatement,
702
+ > as Deserialize>::deserialize(
703
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
704
+ )?;
705
Ok(Statement::DebuggerStatement(node))
706
}
707
__StatementTag::DoWhileStatement => {
702
- let node: Box<DoWhileStatement> =
703
- <Box<DoWhileStatement> as Deserialize>::deserialize(
704
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
705
- )?;
708
+ let node: Box<DoWhileStatement> = <Box<
709
+ DoWhileStatement,
710
+ > as Deserialize>::deserialize(
711
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
712
+ )?;
713
Ok(Statement::DoWhileStatement(node))
714
}
715
__StatementTag::EmptyStatement => {
709
- let node: Box<EmptyStatement> = <Box<EmptyStatement> as Deserialize>::deserialize(
716
+ let node: Box<EmptyStatement> = <Box<
717
+ EmptyStatement,
718
+ > as Deserialize>::deserialize(
719
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
720
)?;
721
Ok(Statement::EmptyStatement(node))
722
}
723
__StatementTag::ExpressionStatement => {
715
- let node: Box<ExpressionStatement> =
716
- <Box<ExpressionStatement> as Deserialize>::deserialize(
717
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
718
- )?;
724
+ let node: Box<ExpressionStatement> = <Box<
725
+ ExpressionStatement,
726
+ > as Deserialize>::deserialize(
727
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
728
+ )?;
729
Ok(Statement::ExpressionStatement(node))
730
}
731
__StatementTag::ForInStatement => {
722
- let node: Box<ForInStatement> = <Box<ForInStatement> as Deserialize>::deserialize(
732
+ let node: Box<ForInStatement> = <Box<
733
+ ForInStatement,
734
+ > as Deserialize>::deserialize(
735
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
736
)?;
737
Ok(Statement::ForInStatement(node))
738
}
739
__StatementTag::ForOfStatement => {
728
- let node: Box<ForOfStatement> = <Box<ForOfStatement> as Deserialize>::deserialize(
740
+ let node: Box<ForOfStatement> = <Box<
741
+ ForOfStatement,
742
+ > as Deserialize>::deserialize(
743
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
744
)?;
745
Ok(Statement::ForOfStatement(node))
746
}
747
__StatementTag::ForStatement => {
734
- let node: Box<ForStatement> = <Box<ForStatement> as Deserialize>::deserialize(
748
+ let node: Box<ForStatement> = <Box<
749
+ ForStatement,
750
+ > as Deserialize>::deserialize(
751
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
752
)?;
753
Ok(Statement::ForStatement(node))
754
}
755
__StatementTag::FunctionDeclaration => {
740
- let node: Box<FunctionDeclaration> =
741
- <Box<FunctionDeclaration> as Deserialize>::deserialize(
742
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
743
- )?;
756
+ let node: Box<FunctionDeclaration> = <Box<
757
+ FunctionDeclaration,
758
+ > as Deserialize>::deserialize(
759
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
760
+ )?;
761
Ok(Statement::FunctionDeclaration(node))
762
}
763
__StatementTag::IfStatement => {
747
- let node: Box<IfStatement> = <Box<IfStatement> as Deserialize>::deserialize(
764
+ let node: Box<IfStatement> = <Box<
765
+ IfStatement,
766
+ > as Deserialize>::deserialize(
767
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
768
)?;
769
Ok(Statement::IfStatement(node))
770
}
771
__StatementTag::LabeledStatement => {
753
- let node: Box<LabeledStatement> =
754
- <Box<LabeledStatement> as Deserialize>::deserialize(
755
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
756
- )?;
772
+ let node: Box<LabeledStatement> = <Box<
773
+ LabeledStatement,
774
+ > as Deserialize>::deserialize(
775
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
776
+ )?;
777
Ok(Statement::LabeledStatement(node))
778
}
779
__StatementTag::ReturnStatement => {
760
- let node: Box<ReturnStatement> =
761
- <Box<ReturnStatement> as Deserialize>::deserialize(
762
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
763
- )?;
780
+ let node: Box<ReturnStatement> = <Box<
781
+ ReturnStatement,
782
+ > as Deserialize>::deserialize(
783
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
784
+ )?;
785
Ok(Statement::ReturnStatement(node))
786
}
787
__StatementTag::SwitchStatement => {
767
- let node: Box<SwitchStatement> =
768
- <Box<SwitchStatement> as Deserialize>::deserialize(
769
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
770
- )?;
788
+ let node: Box<SwitchStatement> = <Box<
789
+ SwitchStatement,
790
+ > as Deserialize>::deserialize(
791
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
792
+ )?;
793
Ok(Statement::SwitchStatement(node))
794
}
795
__StatementTag::ThrowStatement => {
774
- let node: Box<ThrowStatement> = <Box<ThrowStatement> as Deserialize>::deserialize(
796
+ let node: Box<ThrowStatement> = <Box<
797
+ ThrowStatement,
798
+ > as Deserialize>::deserialize(
799
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
800
)?;
801
Ok(Statement::ThrowStatement(node))
802
}
803
__StatementTag::TryStatement => {
780
- let node: Box<TryStatement> = <Box<TryStatement> as Deserialize>::deserialize(
804
+ let node: Box<TryStatement> = <Box<
805
+ TryStatement,
806
+ > as Deserialize>::deserialize(
807
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
808
)?;
809
Ok(Statement::TryStatement(node))
810
}
811
__StatementTag::VariableDeclaration => {
786
- let node: Box<VariableDeclaration> =
787
- <Box<VariableDeclaration> as Deserialize>::deserialize(
788
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
789
- )?;
812
+ let node: Box<VariableDeclaration> = <Box<
813
+ VariableDeclaration,
814
+ > as Deserialize>::deserialize(
815
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
816
+ )?;
817
Ok(Statement::VariableDeclaration(node))
818
}
819
__StatementTag::WhileStatement => {
793
- let node: Box<WhileStatement> = <Box<WhileStatement> as Deserialize>::deserialize(
820
+ let node: Box<WhileStatement> = <Box<
821
+ WhileStatement,
822
+ > as Deserialize>::deserialize(
823
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
824
)?;
825
Ok(Statement::WhileStatement(node))
826
}
827
__StatementTag::WithStatement => {
799
- let node: Box<WithStatement> = <Box<WithStatement> as Deserialize>::deserialize(
828
+ let node: Box<WithStatement> = <Box<
829
+ WithStatement,
830
+ > as Deserialize>::deserialize(
831
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
832
)?;
833
Ok(Statement::WithStatement(node))
@@ -856,132 +887,159 @@ impl<'de> serde::Deserialize<'de> for Expression {
887
{
888
let tagged = serde::Deserializer::deserialize_any(
889
deserializer,
859
- serde::__private::de::TaggedContentVisitor::<__ExpressionTag>::new("type", "Pattern"),
890
+ serde::__private::de::TaggedContentVisitor::<
891
+ __ExpressionTag,
892
+ >::new("type", "Pattern"),
893
)?;
894
match tagged.0 {
895
__ExpressionTag::ArrayExpression => {
863
- let node: Box<ArrayExpression> =
864
- <Box<ArrayExpression> as Deserialize>::deserialize(
865
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
866
- )?;
896
+ let node: Box<ArrayExpression> = <Box<
897
+ ArrayExpression,
898
+ > as Deserialize>::deserialize(
899
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
900
+ )?;
901
Ok(Expression::ArrayExpression(node))
902
}
903
__ExpressionTag::ArrowFunctionExpression => {
870
- let node: Box<ArrowFunctionExpression> =
871
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
872
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
873
- )?;
904
+ let node: Box<ArrowFunctionExpression> = <Box<
905
+ ArrowFunctionExpression,
906
+ > as Deserialize>::deserialize(
907
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
908
+ )?;
909
Ok(Expression::ArrowFunctionExpression(node))
910
}
911
__ExpressionTag::AssignmentExpression => {
877
- let node: Box<AssignmentExpression> =
878
- <Box<AssignmentExpression> as Deserialize>::deserialize(
879
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
880
- )?;
912
+ let node: Box<AssignmentExpression> = <Box<
913
+ AssignmentExpression,
914
+ > as Deserialize>::deserialize(
915
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
916
+ )?;
917
Ok(Expression::AssignmentExpression(node))
918
}
919
__ExpressionTag::BinaryExpression => {
884
- let node: Box<BinaryExpression> =
885
- <Box<BinaryExpression> as Deserialize>::deserialize(
886
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
887
- )?;
920
+ let node: Box<BinaryExpression> = <Box<
921
+ BinaryExpression,
922
+ > as Deserialize>::deserialize(
923
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
924
+ )?;
925
Ok(Expression::BinaryExpression(node))
926
}
927
__ExpressionTag::CallExpression => {
891
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
928
+ let node: Box<CallExpression> = <Box<
929
+ CallExpression,
930
+ > as Deserialize>::deserialize(
931
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
932
)?;
933
Ok(Expression::CallExpression(node))
934
}
935
__ExpressionTag::ConditionalExpression => {
897
- let node: Box<ConditionalExpression> =
898
- <Box<ConditionalExpression> as Deserialize>::deserialize(
899
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
900
- )?;
936
+ let node: Box<ConditionalExpression> = <Box<
937
+ ConditionalExpression,
938
+ > as Deserialize>::deserialize(
939
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
940
+ )?;
941
Ok(Expression::ConditionalExpression(node))
942
}
943
__ExpressionTag::FunctionExpression => {
904
- let node: Box<FunctionExpression> =
905
- <Box<FunctionExpression> as Deserialize>::deserialize(
906
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
907
- )?;
944
+ let node: Box<FunctionExpression> = <Box<
945
+ FunctionExpression,
946
+ > as Deserialize>::deserialize(
947
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
948
+ )?;
949
Ok(Expression::FunctionExpression(node))
950
}
951
__ExpressionTag::Identifier => {
911
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
952
+ let node: Box<Identifier> = <Box<
953
+ Identifier,
954
+ > as Deserialize>::deserialize(
955
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
956
)?;
957
Ok(Expression::Identifier(node))
958
}
959
__ExpressionTag::Literal => {
917
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
960
+ let node: Box<Literal> = <Box<
961
+ Literal,
962
+ > as Deserialize>::deserialize(
963
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
964
)?;
965
Ok(Expression::Literal(node))
966
}
967
__ExpressionTag::LogicalExpression => {
923
- let node: Box<LogicalExpression> =
924
- <Box<LogicalExpression> as Deserialize>::deserialize(
925
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
926
- )?;
968
+ let node: Box<LogicalExpression> = <Box<
969
+ LogicalExpression,
970
+ > as Deserialize>::deserialize(
971
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
972
+ )?;
973
Ok(Expression::LogicalExpression(node))
974
}
975
__ExpressionTag::MemberExpression => {
930
- let node: Box<MemberExpression> =
931
- <Box<MemberExpression> as Deserialize>::deserialize(
932
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
933
- )?;
976
+ let node: Box<MemberExpression> = <Box<
977
+ MemberExpression,
978
+ > as Deserialize>::deserialize(
979
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
980
+ )?;
981
Ok(Expression::MemberExpression(node))
982
}
983
__ExpressionTag::NewExpression => {
937
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
984
+ let node: Box<NewExpression> = <Box<
985
+ NewExpression,
986
+ > as Deserialize>::deserialize(
987
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
988
)?;
989
Ok(Expression::NewExpression(node))
990
}
991
__ExpressionTag::ObjectExpression => {
943
- let node: Box<ObjectExpression> =
944
- <Box<ObjectExpression> as Deserialize>::deserialize(
945
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
946
- )?;
992
+ let node: Box<ObjectExpression> = <Box<
993
+ ObjectExpression,
994
+ > as Deserialize>::deserialize(
995
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
996
+ )?;
997
Ok(Expression::ObjectExpression(node))
998
}
999
__ExpressionTag::SequenceExpression => {
950
- let node: Box<SequenceExpression> =
951
- <Box<SequenceExpression> as Deserialize>::deserialize(
952
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
953
- )?;
1000
+ let node: Box<SequenceExpression> = <Box<
1001
+ SequenceExpression,
1002
+ > as Deserialize>::deserialize(
1003
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1004
+ )?;
1005
Ok(Expression::SequenceExpression(node))
1006
}
1007
__ExpressionTag::ThisExpression => {
957
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1008
+ let node: Box<ThisExpression> = <Box<
1009
+ ThisExpression,
1010
+ > as Deserialize>::deserialize(
1011
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1012
)?;
1013
Ok(Expression::ThisExpression(node))
1014
}
1015
__ExpressionTag::UnaryExpression => {
963
- let node: Box<UnaryExpression> =
964
- <Box<UnaryExpression> as Deserialize>::deserialize(
965
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
966
- )?;
1016
+ let node: Box<UnaryExpression> = <Box<
1017
+ UnaryExpression,
1018
+ > as Deserialize>::deserialize(
1019
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1020
+ )?;
1021
Ok(Expression::UnaryExpression(node))
1022
}
1023
__ExpressionTag::UpdateExpression => {
970
- let node: Box<UpdateExpression> =
971
- <Box<UpdateExpression> as Deserialize>::deserialize(
972
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
973
- )?;
1024
+ let node: Box<UpdateExpression> = <Box<
1025
+ UpdateExpression,
1026
+ > as Deserialize>::deserialize(
1027
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1028
+ )?;
1029
Ok(Expression::UpdateExpression(node))
1030
}
1031
__ExpressionTag::YieldExpression => {
977
- let node: Box<YieldExpression> =
978
- <Box<YieldExpression> as Deserialize>::deserialize(
979
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
980
- )?;
1032
+ let node: Box<YieldExpression> = <Box<
1033
+ YieldExpression,
1034
+ > as Deserialize>::deserialize(
1035
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1036
+ )?;
1037
Ok(Expression::YieldExpression(node))
1038
}
1039
__ExpressionTag::JSXElement => {
984
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1040
+ let node: Box<JSXElement> = <Box<
1041
+ JSXElement,
1042
+ > as Deserialize>::deserialize(
1043
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1044
)?;
1045
Ok(Expression::JSXElement(node))
@@ -1009,30 +1067,33 @@ impl<'de> serde::Deserialize<'de> for ImportDeclarationSpecifier {
1067
{
1068
let tagged = serde::Deserializer::deserialize_any(
1069
deserializer,
1012
- serde::__private::de::TaggedContentVisitor::<__ImportDeclarationSpecifierTag>::new(
1013
- "type", "Pattern",
1014
- ),
1070
+ serde::__private::de::TaggedContentVisitor::<
1071
+ __ImportDeclarationSpecifierTag,
1072
+ >::new("type", "Pattern"),
1073
)?;
1074
match tagged.0 {
1075
__ImportDeclarationSpecifierTag::ImportSpecifier => {
1018
- let node: Box<ImportSpecifier> =
1019
- <Box<ImportSpecifier> as Deserialize>::deserialize(
1020
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1021
- )?;
1076
+ let node: Box<ImportSpecifier> = <Box<
1077
+ ImportSpecifier,
1078
+ > as Deserialize>::deserialize(
1079
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1080
+ )?;
1081
Ok(ImportDeclarationSpecifier::ImportSpecifier(node))
1082
}
1083
__ImportDeclarationSpecifierTag::ImportDefaultSpecifier => {
1025
- let node: Box<ImportDefaultSpecifier> =
1026
- <Box<ImportDefaultSpecifier> as Deserialize>::deserialize(
1027
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1028
- )?;
1084
+ let node: Box<ImportDefaultSpecifier> = <Box<
1085
+ ImportDefaultSpecifier,
1086
+ > as Deserialize>::deserialize(
1087
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1088
+ )?;
1089
Ok(ImportDeclarationSpecifier::ImportDefaultSpecifier(node))
1090
}
1091
__ImportDeclarationSpecifierTag::ImportNamespaceSpecifier => {
1032
- let node: Box<ImportNamespaceSpecifier> =
1033
- <Box<ImportNamespaceSpecifier> as Deserialize>::deserialize(
1034
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1035
- )?;
1092
+ let node: Box<ImportNamespaceSpecifier> = <Box<
1093
+ ImportNamespaceSpecifier,
1094
+ > as Deserialize>::deserialize(
1095
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1096
+ )?;
1097
Ok(ImportDeclarationSpecifier::ImportNamespaceSpecifier(node))
1098
}
1099
}
@@ -1075,143 +1136,179 @@ impl<'de> serde::Deserialize<'de> for ModuleItem {
1136
{
1137
let tagged = serde::Deserializer::deserialize_any(
1138
deserializer,
1078
- serde::__private::de::TaggedContentVisitor::<__ModuleItemTag>::new("type", "Pattern"),
1139
+ serde::__private::de::TaggedContentVisitor::<
1140
+ __ModuleItemTag,
1141
+ >::new("type", "Pattern"),
1142
)?;
1143
match tagged.0 {
1144
__ModuleItemTag::ImportDeclaration => {
1082
- let node: Box<ImportDeclaration> =
1083
- <Box<ImportDeclaration> as Deserialize>::deserialize(
1084
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1085
- )?;
1086
- Ok(ModuleItem::ImportOrExportDeclaration(
1087
- ImportOrExportDeclaration::ImportDeclaration(node),
1088
- ))
1145
+ let node: Box<ImportDeclaration> = <Box<
1146
+ ImportDeclaration,
1147
+ > as Deserialize>::deserialize(
1148
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1149
+ )?;
1150
+ Ok(
1151
+ ModuleItem::ImportOrExportDeclaration(
1152
+ ImportOrExportDeclaration::ImportDeclaration(node),
1153
+ ),
1154
+ )
1155
}
1156
__ModuleItemTag::BlockStatement => {
1091
- let node: Box<BlockStatement> = <Box<BlockStatement> as Deserialize>::deserialize(
1157
+ let node: Box<BlockStatement> = <Box<
1158
+ BlockStatement,
1159
+ > as Deserialize>::deserialize(
1160
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1161
)?;
1162
Ok(ModuleItem::Statement(Statement::BlockStatement(node)))
1163
}
1164
__ModuleItemTag::BreakStatement => {
1097
- let node: Box<BreakStatement> = <Box<BreakStatement> as Deserialize>::deserialize(
1165
+ let node: Box<BreakStatement> = <Box<
1166
+ BreakStatement,
1167
+ > as Deserialize>::deserialize(
1168
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1169
)?;
1170
Ok(ModuleItem::Statement(Statement::BreakStatement(node)))
1171
}
1172
__ModuleItemTag::ContinueStatement => {
1103
- let node: Box<ContinueStatement> =
1104
- <Box<ContinueStatement> as Deserialize>::deserialize(
1105
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1106
- )?;
1173
+ let node: Box<ContinueStatement> = <Box<
1174
+ ContinueStatement,
1175
+ > as Deserialize>::deserialize(
1176
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1177
+ )?;
1178
Ok(ModuleItem::Statement(Statement::ContinueStatement(node)))
1179
}
1180
__ModuleItemTag::DebuggerStatement => {
1110
- let node: Box<DebuggerStatement> =
1111
- <Box<DebuggerStatement> as Deserialize>::deserialize(
1112
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1113
- )?;
1181
+ let node: Box<DebuggerStatement> = <Box<
1182
+ DebuggerStatement,
1183
+ > as Deserialize>::deserialize(
1184
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1185
+ )?;
1186
Ok(ModuleItem::Statement(Statement::DebuggerStatement(node)))
1187
}
1188
__ModuleItemTag::DoWhileStatement => {
1117
- let node: Box<DoWhileStatement> =
1118
- <Box<DoWhileStatement> as Deserialize>::deserialize(
1119
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1120
- )?;
1189
+ let node: Box<DoWhileStatement> = <Box<
1190
+ DoWhileStatement,
1191
+ > as Deserialize>::deserialize(
1192
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1193
+ )?;
1194
Ok(ModuleItem::Statement(Statement::DoWhileStatement(node)))
1195
}
1196
__ModuleItemTag::EmptyStatement => {
1124
- let node: Box<EmptyStatement> = <Box<EmptyStatement> as Deserialize>::deserialize(
1197
+ let node: Box<EmptyStatement> = <Box<
1198
+ EmptyStatement,
1199
+ > as Deserialize>::deserialize(
1200
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1201
)?;
1202
Ok(ModuleItem::Statement(Statement::EmptyStatement(node)))
1203
}
1204
__ModuleItemTag::ExpressionStatement => {
1130
- let node: Box<ExpressionStatement> =
1131
- <Box<ExpressionStatement> as Deserialize>::deserialize(
1132
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1133
- )?;
1205
+ let node: Box<ExpressionStatement> = <Box<
1206
+ ExpressionStatement,
1207
+ > as Deserialize>::deserialize(
1208
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1209
+ )?;
1210
Ok(ModuleItem::Statement(Statement::ExpressionStatement(node)))
1211
}
1212
__ModuleItemTag::ForInStatement => {
1137
- let node: Box<ForInStatement> = <Box<ForInStatement> as Deserialize>::deserialize(
1213
+ let node: Box<ForInStatement> = <Box<
1214
+ ForInStatement,
1215
+ > as Deserialize>::deserialize(
1216
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1217
)?;
1218
Ok(ModuleItem::Statement(Statement::ForInStatement(node)))
1219
}
1220
__ModuleItemTag::ForOfStatement => {
1143
- let node: Box<ForOfStatement> = <Box<ForOfStatement> as Deserialize>::deserialize(
1221
+ let node: Box<ForOfStatement> = <Box<
1222
+ ForOfStatement,
1223
+ > as Deserialize>::deserialize(
1224
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1225
)?;
1226
Ok(ModuleItem::Statement(Statement::ForOfStatement(node)))
1227
}
1228
__ModuleItemTag::ForStatement => {
1149
- let node: Box<ForStatement> = <Box<ForStatement> as Deserialize>::deserialize(
1229
+ let node: Box<ForStatement> = <Box<
1230
+ ForStatement,
1231
+ > as Deserialize>::deserialize(
1232
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1233
)?;
1234
Ok(ModuleItem::Statement(Statement::ForStatement(node)))
1235
}
1236
__ModuleItemTag::FunctionDeclaration => {
1155
- let node: Box<FunctionDeclaration> =
1156
- <Box<FunctionDeclaration> as Deserialize>::deserialize(
1157
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1158
- )?;
1237
+ let node: Box<FunctionDeclaration> = <Box<
1238
+ FunctionDeclaration,
1239
+ > as Deserialize>::deserialize(
1240
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1241
+ )?;
1242
Ok(ModuleItem::Statement(Statement::FunctionDeclaration(node)))
1243
}
1244
__ModuleItemTag::IfStatement => {
1162
- let node: Box<IfStatement> = <Box<IfStatement> as Deserialize>::deserialize(
1245
+ let node: Box<IfStatement> = <Box<
1246
+ IfStatement,
1247
+ > as Deserialize>::deserialize(
1248
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1249
)?;
1250
Ok(ModuleItem::Statement(Statement::IfStatement(node)))
1251
}
1252
__ModuleItemTag::LabeledStatement => {
1168
- let node: Box<LabeledStatement> =
1169
- <Box<LabeledStatement> as Deserialize>::deserialize(
1170
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1171
- )?;
1253
+ let node: Box<LabeledStatement> = <Box<
1254
+ LabeledStatement,
1255
+ > as Deserialize>::deserialize(
1256
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1257
+ )?;
1258
Ok(ModuleItem::Statement(Statement::LabeledStatement(node)))
1259
}
1260
__ModuleItemTag::ReturnStatement => {
1175
- let node: Box<ReturnStatement> =
1176
- <Box<ReturnStatement> as Deserialize>::deserialize(
1177
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1178
- )?;
1261
+ let node: Box<ReturnStatement> = <Box<
1262
+ ReturnStatement,
1263
+ > as Deserialize>::deserialize(
1264
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1265
+ )?;
1266
Ok(ModuleItem::Statement(Statement::ReturnStatement(node)))
1267
}
1268
__ModuleItemTag::SwitchStatement => {
1182
- let node: Box<SwitchStatement> =
1183
- <Box<SwitchStatement> as Deserialize>::deserialize(
1184
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1185
- )?;
1269
+ let node: Box<SwitchStatement> = <Box<
1270
+ SwitchStatement,
1271
+ > as Deserialize>::deserialize(
1272
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1273
+ )?;
1274
Ok(ModuleItem::Statement(Statement::SwitchStatement(node)))
1275
}
1276
__ModuleItemTag::ThrowStatement => {
1189
- let node: Box<ThrowStatement> = <Box<ThrowStatement> as Deserialize>::deserialize(
1277
+ let node: Box<ThrowStatement> = <Box<
1278
+ ThrowStatement,
1279
+ > as Deserialize>::deserialize(
1280
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1281
)?;
1282
Ok(ModuleItem::Statement(Statement::ThrowStatement(node)))
1283
}
1284
__ModuleItemTag::TryStatement => {
1195
- let node: Box<TryStatement> = <Box<TryStatement> as Deserialize>::deserialize(
1285
+ let node: Box<TryStatement> = <Box<
1286
+ TryStatement,
1287
+ > as Deserialize>::deserialize(
1288
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1289
)?;
1290
Ok(ModuleItem::Statement(Statement::TryStatement(node)))
1291
}
1292
__ModuleItemTag::VariableDeclaration => {
1201
- let node: Box<VariableDeclaration> =
1202
- <Box<VariableDeclaration> as Deserialize>::deserialize(
1203
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1204
- )?;
1293
+ let node: Box<VariableDeclaration> = <Box<
1294
+ VariableDeclaration,
1295
+ > as Deserialize>::deserialize(
1296
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1297
+ )?;
1298
Ok(ModuleItem::Statement(Statement::VariableDeclaration(node)))
1299
}
1300
__ModuleItemTag::WhileStatement => {
1208
- let node: Box<WhileStatement> = <Box<WhileStatement> as Deserialize>::deserialize(
1301
+ let node: Box<WhileStatement> = <Box<
1302
+ WhileStatement,
1303
+ > as Deserialize>::deserialize(
1304
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1305
)?;
1306
Ok(ModuleItem::Statement(Statement::WhileStatement(node)))
1307
}
1308
__ModuleItemTag::WithStatement => {
1214
- let node: Box<WithStatement> = <Box<WithStatement> as Deserialize>::deserialize(
1309
+ let node: Box<WithStatement> = <Box<
1310
+ WithStatement,
1311
+ > as Deserialize>::deserialize(
1312
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1313
)?;
1314
Ok(ModuleItem::Statement(Statement::WithStatement(node)))
@@ -1235,16 +1332,17 @@ impl<'de> serde::Deserialize<'de> for ImportOrExportDeclaration {
1332
{
1333
let tagged = serde::Deserializer::deserialize_any(
1334
deserializer,
1238
- serde::__private::de::TaggedContentVisitor::<__ImportOrExportDeclarationTag>::new(
1239
- "type", "Pattern",
1240
- ),
1335
+ serde::__private::de::TaggedContentVisitor::<
1336
+ __ImportOrExportDeclarationTag,
1337
+ >::new("type", "Pattern"),
1338
)?;
1339
match tagged.0 {
1340
__ImportOrExportDeclarationTag::ImportDeclaration => {
1244
- let node: Box<ImportDeclaration> =
1245
- <Box<ImportDeclaration> as Deserialize>::deserialize(
1246
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1247
- )?;
1341
+ let node: Box<ImportDeclaration> = <Box<
1342
+ ImportDeclaration,
1343
+ > as Deserialize>::deserialize(
1344
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1345
+ )?;
1346
Ok(ImportOrExportDeclaration::ImportDeclaration(node))
1347
}
1348
}
@@ -1286,172 +1384,175 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
1384
{
1385
let tagged = serde::Deserializer::deserialize_any(
1386
deserializer,
1289
- serde::__private::de::TaggedContentVisitor::<__ExpressionOrSuperTag>::new(
1290
- "type", "Pattern",
1291
- ),
1387
+ serde::__private::de::TaggedContentVisitor::<
1388
+ __ExpressionOrSuperTag,
1389
+ >::new("type", "Pattern"),
1390
)?;
1391
match tagged.0 {
1392
__ExpressionOrSuperTag::ArrayExpression => {
1295
- let node: Box<ArrayExpression> =
1296
- <Box<ArrayExpression> as Deserialize>::deserialize(
1297
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1298
- )?;
1299
- Ok(ExpressionOrSuper::Expression(Expression::ArrayExpression(
1300
- node,
1301
- )))
1393
+ let node: Box<ArrayExpression> = <Box<
1394
+ ArrayExpression,
1395
+ > as Deserialize>::deserialize(
1396
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1397
+ )?;
1398
+ Ok(ExpressionOrSuper::Expression(Expression::ArrayExpression(node)))
1399
}
1400
__ExpressionOrSuperTag::ArrowFunctionExpression => {
1304
- let node: Box<ArrowFunctionExpression> =
1305
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
1306
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1307
- )?;
1308
- Ok(ExpressionOrSuper::Expression(
1309
- Expression::ArrowFunctionExpression(node),
1310
- ))
1401
+ let node: Box<ArrowFunctionExpression> = <Box<
1402
+ ArrowFunctionExpression,
1403
+ > as Deserialize>::deserialize(
1404
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1405
+ )?;
1406
+ Ok(
1407
+ ExpressionOrSuper::Expression(
1408
+ Expression::ArrowFunctionExpression(node),
1409
+ ),
1410
+ )
1411
}
1412
__ExpressionOrSuperTag::AssignmentExpression => {
1313
- let node: Box<AssignmentExpression> =
1314
- <Box<AssignmentExpression> as Deserialize>::deserialize(
1315
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1316
- )?;
1317
- Ok(ExpressionOrSuper::Expression(
1318
- Expression::AssignmentExpression(node),
1319
- ))
1413
+ let node: Box<AssignmentExpression> = <Box<
1414
+ AssignmentExpression,
1415
+ > as Deserialize>::deserialize(
1416
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1417
+ )?;
1418
+ Ok(ExpressionOrSuper::Expression(Expression::AssignmentExpression(node)))
1419
}
1420
__ExpressionOrSuperTag::BinaryExpression => {
1322
- let node: Box<BinaryExpression> =
1323
- <Box<BinaryExpression> as Deserialize>::deserialize(
1324
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1325
- )?;
1326
- Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(
1327
- node,
1328
- )))
1421
+ let node: Box<BinaryExpression> = <Box<
1422
+ BinaryExpression,
1423
+ > as Deserialize>::deserialize(
1424
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1425
+ )?;
1426
+ Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(node)))
1427
}
1428
__ExpressionOrSuperTag::CallExpression => {
1331
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1429
+ let node: Box<CallExpression> = <Box<
1430
+ CallExpression,
1431
+ > as Deserialize>::deserialize(
1432
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1433
)?;
1334
- Ok(ExpressionOrSuper::Expression(Expression::CallExpression(
1335
- node,
1336
- )))
1434
+ Ok(ExpressionOrSuper::Expression(Expression::CallExpression(node)))
1435
}
1436
__ExpressionOrSuperTag::ConditionalExpression => {
1339
- let node: Box<ConditionalExpression> =
1340
- <Box<ConditionalExpression> as Deserialize>::deserialize(
1341
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1342
- )?;
1343
- Ok(ExpressionOrSuper::Expression(
1344
- Expression::ConditionalExpression(node),
1345
- ))
1437
+ let node: Box<ConditionalExpression> = <Box<
1438
+ ConditionalExpression,
1439
+ > as Deserialize>::deserialize(
1440
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1441
+ )?;
1442
+ Ok(
1443
+ ExpressionOrSuper::Expression(
1444
+ Expression::ConditionalExpression(node),
1445
+ ),
1446
+ )
1447
}
1448
__ExpressionOrSuperTag::FunctionExpression => {
1348
- let node: Box<FunctionExpression> =
1349
- <Box<FunctionExpression> as Deserialize>::deserialize(
1350
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1351
- )?;
1352
- Ok(ExpressionOrSuper::Expression(
1353
- Expression::FunctionExpression(node),
1354
- ))
1449
+ let node: Box<FunctionExpression> = <Box<
1450
+ FunctionExpression,
1451
+ > as Deserialize>::deserialize(
1452
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1453
+ )?;
1454
+ Ok(ExpressionOrSuper::Expression(Expression::FunctionExpression(node)))
1455
}
1456
__ExpressionOrSuperTag::Identifier => {
1357
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1457
+ let node: Box<Identifier> = <Box<
1458
+ Identifier,
1459
+ > as Deserialize>::deserialize(
1460
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1461
)?;
1462
Ok(ExpressionOrSuper::Expression(Expression::Identifier(node)))
1463
}
1464
__ExpressionOrSuperTag::Literal => {
1363
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1465
+ let node: Box<Literal> = <Box<
1466
+ Literal,
1467
+ > as Deserialize>::deserialize(
1468
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1469
)?;
1470
Ok(ExpressionOrSuper::Expression(Expression::Literal(node)))
1471
}
1472
__ExpressionOrSuperTag::LogicalExpression => {
1369
- let node: Box<LogicalExpression> =
1370
- <Box<LogicalExpression> as Deserialize>::deserialize(
1371
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1372
- )?;
1373
- Ok(ExpressionOrSuper::Expression(
1374
- Expression::LogicalExpression(node),
1375
- ))
1473
+ let node: Box<LogicalExpression> = <Box<
1474
+ LogicalExpression,
1475
+ > as Deserialize>::deserialize(
1476
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1477
+ )?;
1478
+ Ok(ExpressionOrSuper::Expression(Expression::LogicalExpression(node)))
1479
}
1480
__ExpressionOrSuperTag::MemberExpression => {
1378
- let node: Box<MemberExpression> =
1379
- <Box<MemberExpression> as Deserialize>::deserialize(
1380
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1381
- )?;
1382
- Ok(ExpressionOrSuper::Expression(Expression::MemberExpression(
1383
- node,
1384
- )))
1481
+ let node: Box<MemberExpression> = <Box<
1482
+ MemberExpression,
1483
+ > as Deserialize>::deserialize(
1484
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1485
+ )?;
1486
+ Ok(ExpressionOrSuper::Expression(Expression::MemberExpression(node)))
1487
}
1488
__ExpressionOrSuperTag::NewExpression => {
1387
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
1489
+ let node: Box<NewExpression> = <Box<
1490
+ NewExpression,
1491
+ > as Deserialize>::deserialize(
1492
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1493
)?;
1390
- Ok(ExpressionOrSuper::Expression(Expression::NewExpression(
1391
- node,
1392
- )))
1494
+ Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node)))
1495
}
1496
__ExpressionOrSuperTag::ObjectExpression => {
1395
- let node: Box<ObjectExpression> =
1396
- <Box<ObjectExpression> as Deserialize>::deserialize(
1397
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1398
- )?;
1399
- Ok(ExpressionOrSuper::Expression(Expression::ObjectExpression(
1400
- node,
1401
- )))
1497
+ let node: Box<ObjectExpression> = <Box<
1498
+ ObjectExpression,
1499
+ > as Deserialize>::deserialize(
1500
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1501
+ )?;
1502
+ Ok(ExpressionOrSuper::Expression(Expression::ObjectExpression(node)))
1503
}
1504
__ExpressionOrSuperTag::SequenceExpression => {
1404
- let node: Box<SequenceExpression> =
1405
- <Box<SequenceExpression> as Deserialize>::deserialize(
1406
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1407
- )?;
1408
- Ok(ExpressionOrSuper::Expression(
1409
- Expression::SequenceExpression(node),
1410
- ))
1505
+ let node: Box<SequenceExpression> = <Box<
1506
+ SequenceExpression,
1507
+ > as Deserialize>::deserialize(
1508
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1509
+ )?;
1510
+ Ok(ExpressionOrSuper::Expression(Expression::SequenceExpression(node)))
1511
}
1512
__ExpressionOrSuperTag::ThisExpression => {
1413
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1513
+ let node: Box<ThisExpression> = <Box<
1514
+ ThisExpression,
1515
+ > as Deserialize>::deserialize(
1516
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1517
)?;
1416
- Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(
1417
- node,
1418
- )))
1518
+ Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(node)))
1519
}
1520
__ExpressionOrSuperTag::UnaryExpression => {
1421
- let node: Box<UnaryExpression> =
1422
- <Box<UnaryExpression> as Deserialize>::deserialize(
1423
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1424
- )?;
1425
- Ok(ExpressionOrSuper::Expression(Expression::UnaryExpression(
1426
- node,
1427
- )))
1521
+ let node: Box<UnaryExpression> = <Box<
1522
+ UnaryExpression,
1523
+ > as Deserialize>::deserialize(
1524
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1525
+ )?;
1526
+ Ok(ExpressionOrSuper::Expression(Expression::UnaryExpression(node)))
1527
}
1528
__ExpressionOrSuperTag::UpdateExpression => {
1430
- let node: Box<UpdateExpression> =
1431
- <Box<UpdateExpression> as Deserialize>::deserialize(
1432
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1433
- )?;
1434
- Ok(ExpressionOrSuper::Expression(Expression::UpdateExpression(
1435
- node,
1436
- )))
1529
+ let node: Box<UpdateExpression> = <Box<
1530
+ UpdateExpression,
1531
+ > as Deserialize>::deserialize(
1532
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1533
+ )?;
1534
+ Ok(ExpressionOrSuper::Expression(Expression::UpdateExpression(node)))
1535
}
1536
__ExpressionOrSuperTag::YieldExpression => {
1439
- let node: Box<YieldExpression> =
1440
- <Box<YieldExpression> as Deserialize>::deserialize(
1441
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1442
- )?;
1443
- Ok(ExpressionOrSuper::Expression(Expression::YieldExpression(
1444
- node,
1445
- )))
1537
+ let node: Box<YieldExpression> = <Box<
1538
+ YieldExpression,
1539
+ > as Deserialize>::deserialize(
1540
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1541
+ )?;
1542
+ Ok(ExpressionOrSuper::Expression(Expression::YieldExpression(node)))
1543
}
1544
__ExpressionOrSuperTag::JSXElement => {
1448
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1545
+ let node: Box<JSXElement> = <Box<
1546
+ JSXElement,
1547
+ > as Deserialize>::deserialize(
1548
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1549
)?;
1550
Ok(ExpressionOrSuper::Expression(Expression::JSXElement(node)))
1551
}
1552
__ExpressionOrSuperTag::Super => {
1454
- let node: Box<Super> = <Box<Super> as Deserialize>::deserialize(
1553
+ let node: Box<Super> = <Box<
1554
+ Super,
1555
+ > as Deserialize>::deserialize(
1556
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1557
)?;
1558
Ok(ExpressionOrSuper::Super(node))
@@ -1495,172 +1596,179 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
1596
{
1597
let tagged = serde::Deserializer::deserialize_any(
1598
deserializer,
1498
- serde::__private::de::TaggedContentVisitor::<__ExpressionOrSpreadTag>::new(
1499
- "type", "Pattern",
1500
- ),
1599
+ serde::__private::de::TaggedContentVisitor::<
1600
+ __ExpressionOrSpreadTag,
1601
+ >::new("type", "Pattern"),
1602
)?;
1603
match tagged.0 {
1604
__ExpressionOrSpreadTag::ArrayExpression => {
1504
- let node: Box<ArrayExpression> =
1505
- <Box<ArrayExpression> as Deserialize>::deserialize(
1506
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1507
- )?;
1508
- Ok(ExpressionOrSpread::Expression(Expression::ArrayExpression(
1509
- node,
1510
- )))
1605
+ let node: Box<ArrayExpression> = <Box<
1606
+ ArrayExpression,
1607
+ > as Deserialize>::deserialize(
1608
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1609
+ )?;
1610
+ Ok(ExpressionOrSpread::Expression(Expression::ArrayExpression(node)))
1611
}
1612
__ExpressionOrSpreadTag::ArrowFunctionExpression => {
1513
- let node: Box<ArrowFunctionExpression> =
1514
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
1515
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1516
- )?;
1517
- Ok(ExpressionOrSpread::Expression(
1518
- Expression::ArrowFunctionExpression(node),
1519
- ))
1613
+ let node: Box<ArrowFunctionExpression> = <Box<
1614
+ ArrowFunctionExpression,
1615
+ > as Deserialize>::deserialize(
1616
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1617
+ )?;
1618
+ Ok(
1619
+ ExpressionOrSpread::Expression(
1620
+ Expression::ArrowFunctionExpression(node),
1621
+ ),
1622
+ )
1623
}
1624
__ExpressionOrSpreadTag::AssignmentExpression => {
1522
- let node: Box<AssignmentExpression> =
1523
- <Box<AssignmentExpression> as Deserialize>::deserialize(
1524
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1525
- )?;
1526
- Ok(ExpressionOrSpread::Expression(
1527
- Expression::AssignmentExpression(node),
1528
- ))
1625
+ let node: Box<AssignmentExpression> = <Box<
1626
+ AssignmentExpression,
1627
+ > as Deserialize>::deserialize(
1628
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1629
+ )?;
1630
+ Ok(
1631
+ ExpressionOrSpread::Expression(
1632
+ Expression::AssignmentExpression(node),
1633
+ ),
1634
+ )
1635
}
1636
__ExpressionOrSpreadTag::BinaryExpression => {
1531
- let node: Box<BinaryExpression> =
1532
- <Box<BinaryExpression> as Deserialize>::deserialize(
1533
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1534
- )?;
1535
- Ok(ExpressionOrSpread::Expression(
1536
- Expression::BinaryExpression(node),
1537
- ))
1637
+ let node: Box<BinaryExpression> = <Box<
1638
+ BinaryExpression,
1639
+ > as Deserialize>::deserialize(
1640
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1641
+ )?;
1642
+ Ok(ExpressionOrSpread::Expression(Expression::BinaryExpression(node)))
1643
}
1644
__ExpressionOrSpreadTag::CallExpression => {
1540
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1645
+ let node: Box<CallExpression> = <Box<
1646
+ CallExpression,
1647
+ > as Deserialize>::deserialize(
1648
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1649
)?;
1543
- Ok(ExpressionOrSpread::Expression(Expression::CallExpression(
1544
- node,
1545
- )))
1650
+ Ok(ExpressionOrSpread::Expression(Expression::CallExpression(node)))
1651
}
1652
__ExpressionOrSpreadTag::ConditionalExpression => {
1548
- let node: Box<ConditionalExpression> =
1549
- <Box<ConditionalExpression> as Deserialize>::deserialize(
1550
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1551
- )?;
1552
- Ok(ExpressionOrSpread::Expression(
1553
- Expression::ConditionalExpression(node),
1554
- ))
1653
+ let node: Box<ConditionalExpression> = <Box<
1654
+ ConditionalExpression,
1655
+ > as Deserialize>::deserialize(
1656
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1657
+ )?;
1658
+ Ok(
1659
+ ExpressionOrSpread::Expression(
1660
+ Expression::ConditionalExpression(node),
1661
+ ),
1662
+ )
1663
}
1664
__ExpressionOrSpreadTag::FunctionExpression => {
1557
- let node: Box<FunctionExpression> =
1558
- <Box<FunctionExpression> as Deserialize>::deserialize(
1559
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1560
- )?;
1561
- Ok(ExpressionOrSpread::Expression(
1562
- Expression::FunctionExpression(node),
1563
- ))
1665
+ let node: Box<FunctionExpression> = <Box<
1666
+ FunctionExpression,
1667
+ > as Deserialize>::deserialize(
1668
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1669
+ )?;
1670
+ Ok(ExpressionOrSpread::Expression(Expression::FunctionExpression(node)))
1671
}
1672
__ExpressionOrSpreadTag::Identifier => {
1566
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1673
+ let node: Box<Identifier> = <Box<
1674
+ Identifier,
1675
+ > as Deserialize>::deserialize(
1676
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1677
)?;
1678
Ok(ExpressionOrSpread::Expression(Expression::Identifier(node)))
1679
}
1680
__ExpressionOrSpreadTag::Literal => {
1572
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1681
+ let node: Box<Literal> = <Box<
1682
+ Literal,
1683
+ > as Deserialize>::deserialize(
1684
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1685
)?;
1686
Ok(ExpressionOrSpread::Expression(Expression::Literal(node)))
1687
}
1688
__ExpressionOrSpreadTag::LogicalExpression => {
1578
- let node: Box<LogicalExpression> =
1579
- <Box<LogicalExpression> as Deserialize>::deserialize(
1580
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1581
- )?;
1582
- Ok(ExpressionOrSpread::Expression(
1583
- Expression::LogicalExpression(node),
1584
- ))
1689
+ let node: Box<LogicalExpression> = <Box<
1690
+ LogicalExpression,
1691
+ > as Deserialize>::deserialize(
1692
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1693
+ )?;
1694
+ Ok(ExpressionOrSpread::Expression(Expression::LogicalExpression(node)))
1695
}
1696
__ExpressionOrSpreadTag::MemberExpression => {
1587
- let node: Box<MemberExpression> =
1588
- <Box<MemberExpression> as Deserialize>::deserialize(
1589
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1590
- )?;
1591
- Ok(ExpressionOrSpread::Expression(
1592
- Expression::MemberExpression(node),
1593
- ))
1697
+ let node: Box<MemberExpression> = <Box<
1698
+ MemberExpression,
1699
+ > as Deserialize>::deserialize(
1700
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1701
+ )?;
1702
+ Ok(ExpressionOrSpread::Expression(Expression::MemberExpression(node)))
1703
}
1704
__ExpressionOrSpreadTag::NewExpression => {
1596
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
1705
+ let node: Box<NewExpression> = <Box<
1706
+ NewExpression,
1707
+ > as Deserialize>::deserialize(
1708
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1709
)?;
1599
- Ok(ExpressionOrSpread::Expression(Expression::NewExpression(
1600
- node,
1601
- )))
1710
+ Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node)))
1711
}
1712
__ExpressionOrSpreadTag::ObjectExpression => {
1604
- let node: Box<ObjectExpression> =
1605
- <Box<ObjectExpression> as Deserialize>::deserialize(
1606
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1607
- )?;
1608
- Ok(ExpressionOrSpread::Expression(
1609
- Expression::ObjectExpression(node),
1610
- ))
1713
+ let node: Box<ObjectExpression> = <Box<
1714
+ ObjectExpression,
1715
+ > as Deserialize>::deserialize(
1716
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1717
+ )?;
1718
+ Ok(ExpressionOrSpread::Expression(Expression::ObjectExpression(node)))
1719
}
1720
__ExpressionOrSpreadTag::SequenceExpression => {
1613
- let node: Box<SequenceExpression> =
1614
- <Box<SequenceExpression> as Deserialize>::deserialize(
1615
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1616
- )?;
1617
- Ok(ExpressionOrSpread::Expression(
1618
- Expression::SequenceExpression(node),
1619
- ))
1721
+ let node: Box<SequenceExpression> = <Box<
1722
+ SequenceExpression,
1723
+ > as Deserialize>::deserialize(
1724
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1725
+ )?;
1726
+ Ok(ExpressionOrSpread::Expression(Expression::SequenceExpression(node)))
1727
}
1728
__ExpressionOrSpreadTag::ThisExpression => {
1622
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1729
+ let node: Box<ThisExpression> = <Box<
1730
+ ThisExpression,
1731
+ > as Deserialize>::deserialize(
1732
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1733
)?;
1625
- Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(
1626
- node,
1627
- )))
1734
+ Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(node)))
1735
}
1736
__ExpressionOrSpreadTag::UnaryExpression => {
1630
- let node: Box<UnaryExpression> =
1631
- <Box<UnaryExpression> as Deserialize>::deserialize(
1632
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1633
- )?;
1634
- Ok(ExpressionOrSpread::Expression(Expression::UnaryExpression(
1635
- node,
1636
- )))
1737
+ let node: Box<UnaryExpression> = <Box<
1738
+ UnaryExpression,
1739
+ > as Deserialize>::deserialize(
1740
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1741
+ )?;
1742
+ Ok(ExpressionOrSpread::Expression(Expression::UnaryExpression(node)))
1743
}
1744
__ExpressionOrSpreadTag::UpdateExpression => {
1639
- let node: Box<UpdateExpression> =
1640
- <Box<UpdateExpression> as Deserialize>::deserialize(
1641
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1642
- )?;
1643
- Ok(ExpressionOrSpread::Expression(
1644
- Expression::UpdateExpression(node),
1645
- ))
1745
+ let node: Box<UpdateExpression> = <Box<
1746
+ UpdateExpression,
1747
+ > as Deserialize>::deserialize(
1748
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1749
+ )?;
1750
+ Ok(ExpressionOrSpread::Expression(Expression::UpdateExpression(node)))
1751
}
1752
__ExpressionOrSpreadTag::YieldExpression => {
1648
- let node: Box<YieldExpression> =
1649
- <Box<YieldExpression> as Deserialize>::deserialize(
1650
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1651
- )?;
1652
- Ok(ExpressionOrSpread::Expression(Expression::YieldExpression(
1653
- node,
1654
- )))
1753
+ let node: Box<YieldExpression> = <Box<
1754
+ YieldExpression,
1755
+ > as Deserialize>::deserialize(
1756
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1757
+ )?;
1758
+ Ok(ExpressionOrSpread::Expression(Expression::YieldExpression(node)))
1759
}
1760
__ExpressionOrSpreadTag::JSXElement => {
1657
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1761
+ let node: Box<JSXElement> = <Box<
1762
+ JSXElement,
1763
+ > as Deserialize>::deserialize(
1764
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1765
)?;
1766
Ok(ExpressionOrSpread::Expression(Expression::JSXElement(node)))
1767
}
1768
__ExpressionOrSpreadTag::SpreadElement => {
1663
- let node: Box<SpreadElement> = <Box<SpreadElement> as Deserialize>::deserialize(
1769
+ let node: Box<SpreadElement> = <Box<
1770
+ SpreadElement,
1771
+ > as Deserialize>::deserialize(
1772
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1773
)?;
1774
Ok(ExpressionOrSpread::SpreadElement(node))
@@ -1704,150 +1812,167 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
1812
{
1813
let tagged = serde::Deserializer::deserialize_any(
1814
deserializer,
1707
- serde::__private::de::TaggedContentVisitor::<__FunctionBodyTag>::new("type", "Pattern"),
1815
+ serde::__private::de::TaggedContentVisitor::<
1816
+ __FunctionBodyTag,
1817
+ >::new("type", "Pattern"),
1818
)?;
1819
match tagged.0 {
1820
__FunctionBodyTag::BlockStatement => {
1711
- let node: Box<BlockStatement> = <Box<BlockStatement> as Deserialize>::deserialize(
1821
+ let node: Box<BlockStatement> = <Box<
1822
+ BlockStatement,
1823
+ > as Deserialize>::deserialize(
1824
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1825
)?;
1826
Ok(FunctionBody::BlockStatement(node))
1827
}
1828
__FunctionBodyTag::ArrayExpression => {
1717
- let node: Box<ArrayExpression> =
1718
- <Box<ArrayExpression> as Deserialize>::deserialize(
1719
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1720
- )?;
1829
+ let node: Box<ArrayExpression> = <Box<
1830
+ ArrayExpression,
1831
+ > as Deserialize>::deserialize(
1832
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1833
+ )?;
1834
Ok(FunctionBody::Expression(Expression::ArrayExpression(node)))
1835
}
1836
__FunctionBodyTag::ArrowFunctionExpression => {
1724
- let node: Box<ArrowFunctionExpression> =
1725
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
1726
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1727
- )?;
1728
- Ok(FunctionBody::Expression(
1729
- Expression::ArrowFunctionExpression(node),
1730
- ))
1837
+ let node: Box<ArrowFunctionExpression> = <Box<
1838
+ ArrowFunctionExpression,
1839
+ > as Deserialize>::deserialize(
1840
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1841
+ )?;
1842
+ Ok(FunctionBody::Expression(Expression::ArrowFunctionExpression(node)))
1843
}
1844
__FunctionBodyTag::AssignmentExpression => {
1733
- let node: Box<AssignmentExpression> =
1734
- <Box<AssignmentExpression> as Deserialize>::deserialize(
1735
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1736
- )?;
1737
- Ok(FunctionBody::Expression(Expression::AssignmentExpression(
1738
- node,
1739
- )))
1845
+ let node: Box<AssignmentExpression> = <Box<
1846
+ AssignmentExpression,
1847
+ > as Deserialize>::deserialize(
1848
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1849
+ )?;
1850
+ Ok(FunctionBody::Expression(Expression::AssignmentExpression(node)))
1851
}
1852
__FunctionBodyTag::BinaryExpression => {
1742
- let node: Box<BinaryExpression> =
1743
- <Box<BinaryExpression> as Deserialize>::deserialize(
1744
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1745
- )?;
1853
+ let node: Box<BinaryExpression> = <Box<
1854
+ BinaryExpression,
1855
+ > as Deserialize>::deserialize(
1856
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1857
+ )?;
1858
Ok(FunctionBody::Expression(Expression::BinaryExpression(node)))
1859
}
1860
__FunctionBodyTag::CallExpression => {
1749
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1861
+ let node: Box<CallExpression> = <Box<
1862
+ CallExpression,
1863
+ > as Deserialize>::deserialize(
1864
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1865
)?;
1866
Ok(FunctionBody::Expression(Expression::CallExpression(node)))
1867
}
1868
__FunctionBodyTag::ConditionalExpression => {
1755
- let node: Box<ConditionalExpression> =
1756
- <Box<ConditionalExpression> as Deserialize>::deserialize(
1757
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1758
- )?;
1759
- Ok(FunctionBody::Expression(Expression::ConditionalExpression(
1760
- node,
1761
- )))
1869
+ let node: Box<ConditionalExpression> = <Box<
1870
+ ConditionalExpression,
1871
+ > as Deserialize>::deserialize(
1872
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1873
+ )?;
1874
+ Ok(FunctionBody::Expression(Expression::ConditionalExpression(node)))
1875
}
1876
__FunctionBodyTag::FunctionExpression => {
1764
- let node: Box<FunctionExpression> =
1765
- <Box<FunctionExpression> as Deserialize>::deserialize(
1766
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1767
- )?;
1768
- Ok(FunctionBody::Expression(Expression::FunctionExpression(
1769
- node,
1770
- )))
1877
+ let node: Box<FunctionExpression> = <Box<
1878
+ FunctionExpression,
1879
+ > as Deserialize>::deserialize(
1880
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1881
+ )?;
1882
+ Ok(FunctionBody::Expression(Expression::FunctionExpression(node)))
1883
}
1884
__FunctionBodyTag::Identifier => {
1773
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1885
+ let node: Box<Identifier> = <Box<
1886
+ Identifier,
1887
+ > as Deserialize>::deserialize(
1888
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1889
)?;
1890
Ok(FunctionBody::Expression(Expression::Identifier(node)))
1891
}
1892
__FunctionBodyTag::Literal => {
1779
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1893
+ let node: Box<Literal> = <Box<
1894
+ Literal,
1895
+ > as Deserialize>::deserialize(
1896
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1897
)?;
1898
Ok(FunctionBody::Expression(Expression::Literal(node)))
1899
}
1900
__FunctionBodyTag::LogicalExpression => {
1785
- let node: Box<LogicalExpression> =
1786
- <Box<LogicalExpression> as Deserialize>::deserialize(
1787
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1788
- )?;
1789
- Ok(FunctionBody::Expression(Expression::LogicalExpression(
1790
- node,
1791
- )))
1901
+ let node: Box<LogicalExpression> = <Box<
1902
+ LogicalExpression,
1903
+ > as Deserialize>::deserialize(
1904
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1905
+ )?;
1906
+ Ok(FunctionBody::Expression(Expression::LogicalExpression(node)))
1907
}
1908
__FunctionBodyTag::MemberExpression => {
1794
- let node: Box<MemberExpression> =
1795
- <Box<MemberExpression> as Deserialize>::deserialize(
1796
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1797
- )?;
1909
+ let node: Box<MemberExpression> = <Box<
1910
+ MemberExpression,
1911
+ > as Deserialize>::deserialize(
1912
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1913
+ )?;
1914
Ok(FunctionBody::Expression(Expression::MemberExpression(node)))
1915
}
1916
__FunctionBodyTag::NewExpression => {
1801
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
1917
+ let node: Box<NewExpression> = <Box<
1918
+ NewExpression,
1919
+ > as Deserialize>::deserialize(
1920
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1921
)?;
1922
Ok(FunctionBody::Expression(Expression::NewExpression(node)))
1923
}
1924
__FunctionBodyTag::ObjectExpression => {
1807
- let node: Box<ObjectExpression> =
1808
- <Box<ObjectExpression> as Deserialize>::deserialize(
1809
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1810
- )?;
1925
+ let node: Box<ObjectExpression> = <Box<
1926
+ ObjectExpression,
1927
+ > as Deserialize>::deserialize(
1928
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1929
+ )?;
1930
Ok(FunctionBody::Expression(Expression::ObjectExpression(node)))
1931
}
1932
__FunctionBodyTag::SequenceExpression => {
1814
- let node: Box<SequenceExpression> =
1815
- <Box<SequenceExpression> as Deserialize>::deserialize(
1816
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1817
- )?;
1818
- Ok(FunctionBody::Expression(Expression::SequenceExpression(
1819
- node,
1820
- )))
1933
+ let node: Box<SequenceExpression> = <Box<
1934
+ SequenceExpression,
1935
+ > as Deserialize>::deserialize(
1936
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1937
+ )?;
1938
+ Ok(FunctionBody::Expression(Expression::SequenceExpression(node)))
1939
}
1940
__FunctionBodyTag::ThisExpression => {
1823
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1941
+ let node: Box<ThisExpression> = <Box<
1942
+ ThisExpression,
1943
+ > as Deserialize>::deserialize(
1944
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1945
)?;
1946
Ok(FunctionBody::Expression(Expression::ThisExpression(node)))
1947
}
1948
__FunctionBodyTag::UnaryExpression => {
1829
- let node: Box<UnaryExpression> =
1830
- <Box<UnaryExpression> as Deserialize>::deserialize(
1831
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1832
- )?;
1949
+ let node: Box<UnaryExpression> = <Box<
1950
+ UnaryExpression,
1951
+ > as Deserialize>::deserialize(
1952
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1953
+ )?;
1954
Ok(FunctionBody::Expression(Expression::UnaryExpression(node)))
1955
}
1956
__FunctionBodyTag::UpdateExpression => {
1836
- let node: Box<UpdateExpression> =
1837
- <Box<UpdateExpression> as Deserialize>::deserialize(
1838
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1839
- )?;
1957
+ let node: Box<UpdateExpression> = <Box<
1958
+ UpdateExpression,
1959
+ > as Deserialize>::deserialize(
1960
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1961
+ )?;
1962
Ok(FunctionBody::Expression(Expression::UpdateExpression(node)))
1963
}
1964
__FunctionBodyTag::YieldExpression => {
1843
- let node: Box<YieldExpression> =
1844
- <Box<YieldExpression> as Deserialize>::deserialize(
1845
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1846
- )?;
1965
+ let node: Box<YieldExpression> = <Box<
1966
+ YieldExpression,
1967
+ > as Deserialize>::deserialize(
1968
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1969
+ )?;
1970
Ok(FunctionBody::Expression(Expression::YieldExpression(node)))
1971
}
1972
__FunctionBodyTag::JSXElement => {
1850
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1973
+ let node: Box<JSXElement> = <Box<
1974
+ JSXElement,
1975
+ > as Deserialize>::deserialize(
1976
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1977
)?;
1978
Ok(FunctionBody::Expression(Expression::JSXElement(node)))
@@ -1871,11 +1996,15 @@ impl<'de> serde::Deserialize<'de> for Pattern {
1996
{
1997
let tagged = serde::Deserializer::deserialize_any(
1998
deserializer,
1874
- serde::__private::de::TaggedContentVisitor::<__PatternTag>::new("type", "Pattern"),
1999
+ serde::__private::de::TaggedContentVisitor::<
2000
+ __PatternTag,
2001
+ >::new("type", "Pattern"),
2002
)?;
2003
match tagged.0 {
2004
__PatternTag::Identifier => {
1878
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2005
+ let node: Box<Identifier> = <Box<
2006
+ Identifier,
2007
+ > as Deserialize>::deserialize(
2008
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2009
)?;
2010
Ok(Pattern::Identifier(node))
@@ -1919,143 +2048,169 @@ impl<'de> serde::Deserialize<'de> for ForInit {
2048
{
2049
let tagged = serde::Deserializer::deserialize_any(
2050
deserializer,
1922
- serde::__private::de::TaggedContentVisitor::<__ForInitTag>::new("type", "Pattern"),
2051
+ serde::__private::de::TaggedContentVisitor::<
2052
+ __ForInitTag,
2053
+ >::new("type", "Pattern"),
2054
)?;
2055
match tagged.0 {
2056
__ForInitTag::ArrayExpression => {
1926
- let node: Box<ArrayExpression> =
1927
- <Box<ArrayExpression> as Deserialize>::deserialize(
1928
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1929
- )?;
2057
+ let node: Box<ArrayExpression> = <Box<
2058
+ ArrayExpression,
2059
+ > as Deserialize>::deserialize(
2060
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2061
+ )?;
2062
Ok(ForInit::Expression(Expression::ArrayExpression(node)))
2063
}
2064
__ForInitTag::ArrowFunctionExpression => {
1933
- let node: Box<ArrowFunctionExpression> =
1934
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
1935
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1936
- )?;
1937
- Ok(ForInit::Expression(Expression::ArrowFunctionExpression(
1938
- node,
1939
- )))
2065
+ let node: Box<ArrowFunctionExpression> = <Box<
2066
+ ArrowFunctionExpression,
2067
+ > as Deserialize>::deserialize(
2068
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2069
+ )?;
2070
+ Ok(ForInit::Expression(Expression::ArrowFunctionExpression(node)))
2071
}
2072
__ForInitTag::AssignmentExpression => {
1942
- let node: Box<AssignmentExpression> =
1943
- <Box<AssignmentExpression> as Deserialize>::deserialize(
1944
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1945
- )?;
2073
+ let node: Box<AssignmentExpression> = <Box<
2074
+ AssignmentExpression,
2075
+ > as Deserialize>::deserialize(
2076
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2077
+ )?;
2078
Ok(ForInit::Expression(Expression::AssignmentExpression(node)))
2079
}
2080
__ForInitTag::BinaryExpression => {
1949
- let node: Box<BinaryExpression> =
1950
- <Box<BinaryExpression> as Deserialize>::deserialize(
1951
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1952
- )?;
2081
+ let node: Box<BinaryExpression> = <Box<
2082
+ BinaryExpression,
2083
+ > as Deserialize>::deserialize(
2084
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2085
+ )?;
2086
Ok(ForInit::Expression(Expression::BinaryExpression(node)))
2087
}
2088
__ForInitTag::CallExpression => {
1956
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
2089
+ let node: Box<CallExpression> = <Box<
2090
+ CallExpression,
2091
+ > as Deserialize>::deserialize(
2092
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2093
)?;
2094
Ok(ForInit::Expression(Expression::CallExpression(node)))
2095
}
2096
__ForInitTag::ConditionalExpression => {
1962
- let node: Box<ConditionalExpression> =
1963
- <Box<ConditionalExpression> as Deserialize>::deserialize(
1964
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1965
- )?;
2097
+ let node: Box<ConditionalExpression> = <Box<
2098
+ ConditionalExpression,
2099
+ > as Deserialize>::deserialize(
2100
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2101
+ )?;
2102
Ok(ForInit::Expression(Expression::ConditionalExpression(node)))
2103
}
2104
__ForInitTag::FunctionExpression => {
1969
- let node: Box<FunctionExpression> =
1970
- <Box<FunctionExpression> as Deserialize>::deserialize(
1971
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1972
- )?;
2105
+ let node: Box<FunctionExpression> = <Box<
2106
+ FunctionExpression,
2107
+ > as Deserialize>::deserialize(
2108
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2109
+ )?;
2110
Ok(ForInit::Expression(Expression::FunctionExpression(node)))
2111
}
2112
__ForInitTag::Identifier => {
1976
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2113
+ let node: Box<Identifier> = <Box<
2114
+ Identifier,
2115
+ > as Deserialize>::deserialize(
2116
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2117
)?;
2118
Ok(ForInit::Expression(Expression::Identifier(node)))
2119
}
2120
__ForInitTag::Literal => {
1982
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2121
+ let node: Box<Literal> = <Box<
2122
+ Literal,
2123
+ > as Deserialize>::deserialize(
2124
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2125
)?;
2126
Ok(ForInit::Expression(Expression::Literal(node)))
2127
}
2128
__ForInitTag::LogicalExpression => {
1988
- let node: Box<LogicalExpression> =
1989
- <Box<LogicalExpression> as Deserialize>::deserialize(
1990
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1991
- )?;
2129
+ let node: Box<LogicalExpression> = <Box<
2130
+ LogicalExpression,
2131
+ > as Deserialize>::deserialize(
2132
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2133
+ )?;
2134
Ok(ForInit::Expression(Expression::LogicalExpression(node)))
2135
}
2136
__ForInitTag::MemberExpression => {
1995
- let node: Box<MemberExpression> =
1996
- <Box<MemberExpression> as Deserialize>::deserialize(
1997
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1998
- )?;
2137
+ let node: Box<MemberExpression> = <Box<
2138
+ MemberExpression,
2139
+ > as Deserialize>::deserialize(
2140
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2141
+ )?;
2142
Ok(ForInit::Expression(Expression::MemberExpression(node)))
2143
}
2144
__ForInitTag::NewExpression => {
2002
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
2145
+ let node: Box<NewExpression> = <Box<
2146
+ NewExpression,
2147
+ > as Deserialize>::deserialize(
2148
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2149
)?;
2150
Ok(ForInit::Expression(Expression::NewExpression(node)))
2151
}
2152
__ForInitTag::ObjectExpression => {
2008
- let node: Box<ObjectExpression> =
2009
- <Box<ObjectExpression> as Deserialize>::deserialize(
2010
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2011
- )?;
2153
+ let node: Box<ObjectExpression> = <Box<
2154
+ ObjectExpression,
2155
+ > as Deserialize>::deserialize(
2156
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2157
+ )?;
2158
Ok(ForInit::Expression(Expression::ObjectExpression(node)))
2159
}
2160
__ForInitTag::SequenceExpression => {
2015
- let node: Box<SequenceExpression> =
2016
- <Box<SequenceExpression> as Deserialize>::deserialize(
2017
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2018
- )?;
2161
+ let node: Box<SequenceExpression> = <Box<
2162
+ SequenceExpression,
2163
+ > as Deserialize>::deserialize(
2164
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2165
+ )?;
2166
Ok(ForInit::Expression(Expression::SequenceExpression(node)))
2167
}
2168
__ForInitTag::ThisExpression => {
2022
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
2169
+ let node: Box<ThisExpression> = <Box<
2170
+ ThisExpression,
2171
+ > as Deserialize>::deserialize(
2172
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2173
)?;
2174
Ok(ForInit::Expression(Expression::ThisExpression(node)))
2175
}
2176
__ForInitTag::UnaryExpression => {
2028
- let node: Box<UnaryExpression> =
2029
- <Box<UnaryExpression> as Deserialize>::deserialize(
2030
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2031
- )?;
2177
+ let node: Box<UnaryExpression> = <Box<
2178
+ UnaryExpression,
2179
+ > as Deserialize>::deserialize(
2180
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2181
+ )?;
2182
Ok(ForInit::Expression(Expression::UnaryExpression(node)))
2183
}
2184
__ForInitTag::UpdateExpression => {
2035
- let node: Box<UpdateExpression> =
2036
- <Box<UpdateExpression> as Deserialize>::deserialize(
2037
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2038
- )?;
2185
+ let node: Box<UpdateExpression> = <Box<
2186
+ UpdateExpression,
2187
+ > as Deserialize>::deserialize(
2188
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2189
+ )?;
2190
Ok(ForInit::Expression(Expression::UpdateExpression(node)))
2191
}
2192
__ForInitTag::YieldExpression => {
2042
- let node: Box<YieldExpression> =
2043
- <Box<YieldExpression> as Deserialize>::deserialize(
2044
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2045
- )?;
2193
+ let node: Box<YieldExpression> = <Box<
2194
+ YieldExpression,
2195
+ > as Deserialize>::deserialize(
2196
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2197
+ )?;
2198
Ok(ForInit::Expression(Expression::YieldExpression(node)))
2199
}
2200
__ForInitTag::JSXElement => {
2049
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2201
+ let node: Box<JSXElement> = <Box<
2202
+ JSXElement,
2203
+ > as Deserialize>::deserialize(
2204
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2205
)?;
2206
Ok(ForInit::Expression(Expression::JSXElement(node)))
2207
}
2208
__ForInitTag::VariableDeclaration => {
2055
- let node: Box<VariableDeclaration> =
2056
- <Box<VariableDeclaration> as Deserialize>::deserialize(
2057
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2058
- )?;
2209
+ let node: Box<VariableDeclaration> = <Box<
2210
+ VariableDeclaration,
2211
+ > as Deserialize>::deserialize(
2212
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2213
+ )?;
2214
Ok(ForInit::VariableDeclaration(node))
2215
}
2216
}
@@ -2079,20 +2234,25 @@ impl<'de> serde::Deserialize<'de> for ForInInit {
2234
{
2235
let tagged = serde::Deserializer::deserialize_any(
2236
deserializer,
2082
- serde::__private::de::TaggedContentVisitor::<__ForInInitTag>::new("type", "Pattern"),
2237
+ serde::__private::de::TaggedContentVisitor::<
2238
+ __ForInInitTag,
2239
+ >::new("type", "Pattern"),
2240
)?;
2241
match tagged.0 {
2242
__ForInInitTag::Identifier => {
2086
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2243
+ let node: Box<Identifier> = <Box<
2244
+ Identifier,
2245
+ > as Deserialize>::deserialize(
2246
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2247
)?;
2248
Ok(ForInInit::Pattern(Pattern::Identifier(node)))
2249
}
2250
__ForInInitTag::VariableDeclaration => {
2092
- let node: Box<VariableDeclaration> =
2093
- <Box<VariableDeclaration> as Deserialize>::deserialize(
2094
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2095
- )?;
2251
+ let node: Box<VariableDeclaration> = <Box<
2252
+ VariableDeclaration,
2253
+ > as Deserialize>::deserialize(
2254
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2255
+ )?;
2256
Ok(ForInInit::VariableDeclaration(node))
2257
}
2258
}
@@ -2116,17 +2276,23 @@ impl<'de> serde::Deserialize<'de> for PropertyKey {
2276
{
2277
let tagged = serde::Deserializer::deserialize_any(
2278
deserializer,
2119
- serde::__private::de::TaggedContentVisitor::<__PropertyKeyTag>::new("type", "Pattern"),
2279
+ serde::__private::de::TaggedContentVisitor::<
2280
+ __PropertyKeyTag,
2281
+ >::new("type", "Pattern"),
2282
)?;
2283
match tagged.0 {
2284
__PropertyKeyTag::Identifier => {
2123
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2285
+ let node: Box<Identifier> = <Box<
2286
+ Identifier,
2287
+ > as Deserialize>::deserialize(
2288
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2289
)?;
2290
Ok(PropertyKey::Identifier(node))
2291
}
2292
__PropertyKeyTag::Literal => {
2129
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2293
+ let node: Box<Literal> = <Box<
2294
+ Literal,
2295
+ > as Deserialize>::deserialize(
2296
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2297
)?;
2298
Ok(PropertyKey::Literal(node))
@@ -2169,166 +2335,163 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
2335
{
2336
let tagged = serde::Deserializer::deserialize_any(
2337
deserializer,
2172
- serde::__private::de::TaggedContentVisitor::<__AssignmentTargetTag>::new(
2173
- "type", "Pattern",
2174
- ),
2338
+ serde::__private::de::TaggedContentVisitor::<
2339
+ __AssignmentTargetTag,
2340
+ >::new("type", "Pattern"),
2341
)?;
2342
match tagged.0 {
2343
__AssignmentTargetTag::ArrayExpression => {
2178
- let node: Box<ArrayExpression> =
2179
- <Box<ArrayExpression> as Deserialize>::deserialize(
2180
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2181
- )?;
2182
- Ok(AssignmentTarget::Expression(Expression::ArrayExpression(
2183
- node,
2184
- )))
2344
+ let node: Box<ArrayExpression> = <Box<
2345
+ ArrayExpression,
2346
+ > as Deserialize>::deserialize(
2347
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2348
+ )?;
2349
+ Ok(AssignmentTarget::Expression(Expression::ArrayExpression(node)))
2350
}
2351
__AssignmentTargetTag::ArrowFunctionExpression => {
2187
- let node: Box<ArrowFunctionExpression> =
2188
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
2189
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2190
- )?;
2191
- Ok(AssignmentTarget::Expression(
2192
- Expression::ArrowFunctionExpression(node),
2193
- ))
2352
+ let node: Box<ArrowFunctionExpression> = <Box<
2353
+ ArrowFunctionExpression,
2354
+ > as Deserialize>::deserialize(
2355
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2356
+ )?;
2357
+ Ok(
2358
+ AssignmentTarget::Expression(
2359
+ Expression::ArrowFunctionExpression(node),
2360
+ ),
2361
+ )
2362
}
2363
__AssignmentTargetTag::AssignmentExpression => {
2196
- let node: Box<AssignmentExpression> =
2197
- <Box<AssignmentExpression> as Deserialize>::deserialize(
2198
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2199
- )?;
2200
- Ok(AssignmentTarget::Expression(
2201
- Expression::AssignmentExpression(node),
2202
- ))
2364
+ let node: Box<AssignmentExpression> = <Box<
2365
+ AssignmentExpression,
2366
+ > as Deserialize>::deserialize(
2367
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2368
+ )?;
2369
+ Ok(AssignmentTarget::Expression(Expression::AssignmentExpression(node)))
2370
}
2371
__AssignmentTargetTag::BinaryExpression => {
2205
- let node: Box<BinaryExpression> =
2206
- <Box<BinaryExpression> as Deserialize>::deserialize(
2207
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2208
- )?;
2209
- Ok(AssignmentTarget::Expression(Expression::BinaryExpression(
2210
- node,
2211
- )))
2372
+ let node: Box<BinaryExpression> = <Box<
2373
+ BinaryExpression,
2374
+ > as Deserialize>::deserialize(
2375
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2376
+ )?;
2377
+ Ok(AssignmentTarget::Expression(Expression::BinaryExpression(node)))
2378
}
2379
__AssignmentTargetTag::CallExpression => {
2214
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
2380
+ let node: Box<CallExpression> = <Box<
2381
+ CallExpression,
2382
+ > as Deserialize>::deserialize(
2383
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2384
)?;
2217
- Ok(AssignmentTarget::Expression(Expression::CallExpression(
2218
- node,
2219
- )))
2385
+ Ok(AssignmentTarget::Expression(Expression::CallExpression(node)))
2386
}
2387
__AssignmentTargetTag::ConditionalExpression => {
2222
- let node: Box<ConditionalExpression> =
2223
- <Box<ConditionalExpression> as Deserialize>::deserialize(
2224
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2225
- )?;
2226
- Ok(AssignmentTarget::Expression(
2227
- Expression::ConditionalExpression(node),
2228
- ))
2388
+ let node: Box<ConditionalExpression> = <Box<
2389
+ ConditionalExpression,
2390
+ > as Deserialize>::deserialize(
2391
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2392
+ )?;
2393
+ Ok(AssignmentTarget::Expression(Expression::ConditionalExpression(node)))
2394
}
2395
__AssignmentTargetTag::FunctionExpression => {
2231
- let node: Box<FunctionExpression> =
2232
- <Box<FunctionExpression> as Deserialize>::deserialize(
2233
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2234
- )?;
2235
- Ok(AssignmentTarget::Expression(
2236
- Expression::FunctionExpression(node),
2237
- ))
2396
+ let node: Box<FunctionExpression> = <Box<
2397
+ FunctionExpression,
2398
+ > as Deserialize>::deserialize(
2399
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2400
+ )?;
2401
+ Ok(AssignmentTarget::Expression(Expression::FunctionExpression(node)))
2402
}
2403
__AssignmentTargetTag::Identifier => {
2240
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2404
+ let node: Box<Identifier> = <Box<
2405
+ Identifier,
2406
+ > as Deserialize>::deserialize(
2407
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2408
)?;
2409
Ok(AssignmentTarget::Expression(Expression::Identifier(node)))
2410
}
2411
__AssignmentTargetTag::Literal => {
2246
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2412
+ let node: Box<Literal> = <Box<
2413
+ Literal,
2414
+ > as Deserialize>::deserialize(
2415
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2416
)?;
2417
Ok(AssignmentTarget::Expression(Expression::Literal(node)))
2418
}
2419
__AssignmentTargetTag::LogicalExpression => {
2252
- let node: Box<LogicalExpression> =
2253
- <Box<LogicalExpression> as Deserialize>::deserialize(
2254
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2255
- )?;
2256
- Ok(AssignmentTarget::Expression(Expression::LogicalExpression(
2257
- node,
2258
- )))
2420
+ let node: Box<LogicalExpression> = <Box<
2421
+ LogicalExpression,
2422
+ > as Deserialize>::deserialize(
2423
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2424
+ )?;
2425
+ Ok(AssignmentTarget::Expression(Expression::LogicalExpression(node)))
2426
}
2427
__AssignmentTargetTag::MemberExpression => {
2261
- let node: Box<MemberExpression> =
2262
- <Box<MemberExpression> as Deserialize>::deserialize(
2263
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2264
- )?;
2265
- Ok(AssignmentTarget::Expression(Expression::MemberExpression(
2266
- node,
2267
- )))
2428
+ let node: Box<MemberExpression> = <Box<
2429
+ MemberExpression,
2430
+ > as Deserialize>::deserialize(
2431
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2432
+ )?;
2433
+ Ok(AssignmentTarget::Expression(Expression::MemberExpression(node)))
2434
}
2435
__AssignmentTargetTag::NewExpression => {
2270
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
2436
+ let node: Box<NewExpression> = <Box<
2437
+ NewExpression,
2438
+ > as Deserialize>::deserialize(
2439
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2440
)?;
2273
- Ok(AssignmentTarget::Expression(Expression::NewExpression(
2274
- node,
2275
- )))
2441
+ Ok(AssignmentTarget::Expression(Expression::NewExpression(node)))
2442
}
2443
__AssignmentTargetTag::ObjectExpression => {
2278
- let node: Box<ObjectExpression> =
2279
- <Box<ObjectExpression> as Deserialize>::deserialize(
2280
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2281
- )?;
2282
- Ok(AssignmentTarget::Expression(Expression::ObjectExpression(
2283
- node,
2284
- )))
2444
+ let node: Box<ObjectExpression> = <Box<
2445
+ ObjectExpression,
2446
+ > as Deserialize>::deserialize(
2447
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2448
+ )?;
2449
+ Ok(AssignmentTarget::Expression(Expression::ObjectExpression(node)))
2450
}
2451
__AssignmentTargetTag::SequenceExpression => {
2287
- let node: Box<SequenceExpression> =
2288
- <Box<SequenceExpression> as Deserialize>::deserialize(
2289
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2290
- )?;
2291
- Ok(AssignmentTarget::Expression(
2292
- Expression::SequenceExpression(node),
2293
- ))
2452
+ let node: Box<SequenceExpression> = <Box<
2453
+ SequenceExpression,
2454
+ > as Deserialize>::deserialize(
2455
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2456
+ )?;
2457
+ Ok(AssignmentTarget::Expression(Expression::SequenceExpression(node)))
2458
}
2459
__AssignmentTargetTag::ThisExpression => {
2296
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
2460
+ let node: Box<ThisExpression> = <Box<
2461
+ ThisExpression,
2462
+ > as Deserialize>::deserialize(
2463
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2464
)?;
2299
- Ok(AssignmentTarget::Expression(Expression::ThisExpression(
2300
- node,
2301
- )))
2465
+ Ok(AssignmentTarget::Expression(Expression::ThisExpression(node)))
2466
}
2467
__AssignmentTargetTag::UnaryExpression => {
2304
- let node: Box<UnaryExpression> =
2305
- <Box<UnaryExpression> as Deserialize>::deserialize(
2306
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2307
- )?;
2308
- Ok(AssignmentTarget::Expression(Expression::UnaryExpression(
2309
- node,
2310
- )))
2468
+ let node: Box<UnaryExpression> = <Box<
2469
+ UnaryExpression,
2470
+ > as Deserialize>::deserialize(
2471
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2472
+ )?;
2473
+ Ok(AssignmentTarget::Expression(Expression::UnaryExpression(node)))
2474
}
2475
__AssignmentTargetTag::UpdateExpression => {
2313
- let node: Box<UpdateExpression> =
2314
- <Box<UpdateExpression> as Deserialize>::deserialize(
2315
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2316
- )?;
2317
- Ok(AssignmentTarget::Expression(Expression::UpdateExpression(
2318
- node,
2319
- )))
2476
+ let node: Box<UpdateExpression> = <Box<
2477
+ UpdateExpression,
2478
+ > as Deserialize>::deserialize(
2479
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2480
+ )?;
2481
+ Ok(AssignmentTarget::Expression(Expression::UpdateExpression(node)))
2482
}
2483
__AssignmentTargetTag::YieldExpression => {
2322
- let node: Box<YieldExpression> =
2323
- <Box<YieldExpression> as Deserialize>::deserialize(
2324
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2325
- )?;
2326
- Ok(AssignmentTarget::Expression(Expression::YieldExpression(
2327
- node,
2328
- )))
2484
+ let node: Box<YieldExpression> = <Box<
2485
+ YieldExpression,
2486
+ > as Deserialize>::deserialize(
2487
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2488
+ )?;
2489
+ Ok(AssignmentTarget::Expression(Expression::YieldExpression(node)))
2490
}
2491
__AssignmentTargetTag::JSXElement => {
2331
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2492
+ let node: Box<JSXElement> = <Box<
2493
+ JSXElement,
2494
+ > as Deserialize>::deserialize(
2495
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2496
)?;
2497
Ok(AssignmentTarget::Expression(Expression::JSXElement(node)))
@@ -2354,20 +2517,23 @@ impl<'de> serde::Deserialize<'de> for JSXMemberExpressionOrIdentifier {
2517
{
2518
let tagged = serde::Deserializer::deserialize_any(
2519
deserializer,
2357
- serde::__private::de::TaggedContentVisitor::<__JSXMemberExpressionOrIdentifierTag>::new(
2358
- "type", "Pattern",
2359
- ),
2520
+ serde::__private::de::TaggedContentVisitor::<
2521
+ __JSXMemberExpressionOrIdentifierTag,
2522
+ >::new("type", "Pattern"),
2523
)?;
2524
match tagged.0 {
2525
__JSXMemberExpressionOrIdentifierTag::JSXMemberExpression => {
2363
- let node: Box<JSXMemberExpression> =
2364
- <Box<JSXMemberExpression> as Deserialize>::deserialize(
2365
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2366
- )?;
2526
+ let node: Box<JSXMemberExpression> = <Box<
2527
+ JSXMemberExpression,
2528
+ > as Deserialize>::deserialize(
2529
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2530
+ )?;
2531
Ok(JSXMemberExpressionOrIdentifier::JSXMemberExpression(node))
2532
}
2533
__JSXMemberExpressionOrIdentifierTag::JSXIdentifier => {
2370
- let node: Box<JSXIdentifier> = <Box<JSXIdentifier> as Deserialize>::deserialize(
2534
+ let node: Box<JSXIdentifier> = <Box<
2535
+ JSXIdentifier,
2536
+ > as Deserialize>::deserialize(
2537
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2538
)?;
2539
Ok(JSXMemberExpressionOrIdentifier::JSXIdentifier(node))
@@ -2411,179 +2577,189 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
2577
{
2578
let tagged = serde::Deserializer::deserialize_any(
2579
deserializer,
2414
- serde::__private::de::TaggedContentVisitor::<__JSXExpressionOrEmptyTag>::new(
2415
- "type", "Pattern",
2416
- ),
2580
+ serde::__private::de::TaggedContentVisitor::<
2581
+ __JSXExpressionOrEmptyTag,
2582
+ >::new("type", "Pattern"),
2583
)?;
2584
match tagged.0 {
2585
__JSXExpressionOrEmptyTag::ArrayExpression => {
2420
- let node: Box<ArrayExpression> =
2421
- <Box<ArrayExpression> as Deserialize>::deserialize(
2422
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2423
- )?;
2424
- Ok(JSXExpressionOrEmpty::Expression(
2425
- Expression::ArrayExpression(node),
2426
- ))
2586
+ let node: Box<ArrayExpression> = <Box<
2587
+ ArrayExpression,
2588
+ > as Deserialize>::deserialize(
2589
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2590
+ )?;
2591
+ Ok(JSXExpressionOrEmpty::Expression(Expression::ArrayExpression(node)))
2592
}
2593
__JSXExpressionOrEmptyTag::ArrowFunctionExpression => {
2429
- let node: Box<ArrowFunctionExpression> =
2430
- <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
2431
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2432
- )?;
2433
- Ok(JSXExpressionOrEmpty::Expression(
2434
- Expression::ArrowFunctionExpression(node),
2435
- ))
2594
+ let node: Box<ArrowFunctionExpression> = <Box<
2595
+ ArrowFunctionExpression,
2596
+ > as Deserialize>::deserialize(
2597
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2598
+ )?;
2599
+ Ok(
2600
+ JSXExpressionOrEmpty::Expression(
2601
+ Expression::ArrowFunctionExpression(node),
2602
+ ),
2603
+ )
2604
}
2605
__JSXExpressionOrEmptyTag::AssignmentExpression => {
2438
- let node: Box<AssignmentExpression> =
2439
- <Box<AssignmentExpression> as Deserialize>::deserialize(
2440
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2441
- )?;
2442
- Ok(JSXExpressionOrEmpty::Expression(
2443
- Expression::AssignmentExpression(node),
2444
- ))
2606
+ let node: Box<AssignmentExpression> = <Box<
2607
+ AssignmentExpression,
2608
+ > as Deserialize>::deserialize(
2609
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2610
+ )?;
2611
+ Ok(
2612
+ JSXExpressionOrEmpty::Expression(
2613
+ Expression::AssignmentExpression(node),
2614
+ ),
2615
+ )
2616
}
2617
__JSXExpressionOrEmptyTag::BinaryExpression => {
2447
- let node: Box<BinaryExpression> =
2448
- <Box<BinaryExpression> as Deserialize>::deserialize(
2449
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2450
- )?;
2451
- Ok(JSXExpressionOrEmpty::Expression(
2452
- Expression::BinaryExpression(node),
2453
- ))
2618
+ let node: Box<BinaryExpression> = <Box<
2619
+ BinaryExpression,
2620
+ > as Deserialize>::deserialize(
2621
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2622
+ )?;
2623
+ Ok(JSXExpressionOrEmpty::Expression(Expression::BinaryExpression(node)))
2624
}
2625
__JSXExpressionOrEmptyTag::CallExpression => {
2456
- let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
2626
+ let node: Box<CallExpression> = <Box<
2627
+ CallExpression,
2628
+ > as Deserialize>::deserialize(
2629
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2630
)?;
2459
- Ok(JSXExpressionOrEmpty::Expression(
2460
- Expression::CallExpression(node),
2461
- ))
2631
+ Ok(JSXExpressionOrEmpty::Expression(Expression::CallExpression(node)))
2632
}
2633
__JSXExpressionOrEmptyTag::ConditionalExpression => {
2464
- let node: Box<ConditionalExpression> =
2465
- <Box<ConditionalExpression> as Deserialize>::deserialize(
2466
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2467
- )?;
2468
- Ok(JSXExpressionOrEmpty::Expression(
2469
- Expression::ConditionalExpression(node),
2470
- ))
2634
+ let node: Box<ConditionalExpression> = <Box<
2635
+ ConditionalExpression,
2636
+ > as Deserialize>::deserialize(
2637
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2638
+ )?;
2639
+ Ok(
2640
+ JSXExpressionOrEmpty::Expression(
2641
+ Expression::ConditionalExpression(node),
2642
+ ),
2643
+ )
2644
}
2645
__JSXExpressionOrEmptyTag::FunctionExpression => {
2473
- let node: Box<FunctionExpression> =
2474
- <Box<FunctionExpression> as Deserialize>::deserialize(
2475
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2476
- )?;
2477
- Ok(JSXExpressionOrEmpty::Expression(
2478
- Expression::FunctionExpression(node),
2479
- ))
2646
+ let node: Box<FunctionExpression> = <Box<
2647
+ FunctionExpression,
2648
+ > as Deserialize>::deserialize(
2649
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2650
+ )?;
2651
+ Ok(
2652
+ JSXExpressionOrEmpty::Expression(
2653
+ Expression::FunctionExpression(node),
2654
+ ),
2655
+ )
2656
}
2657
__JSXExpressionOrEmptyTag::Identifier => {
2482
- let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2658
+ let node: Box<Identifier> = <Box<
2659
+ Identifier,
2660
+ > as Deserialize>::deserialize(
2661
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2662
)?;
2485
- Ok(JSXExpressionOrEmpty::Expression(Expression::Identifier(
2486
- node,
2487
- )))
2663
+ Ok(JSXExpressionOrEmpty::Expression(Expression::Identifier(node)))
2664
}
2665
__JSXExpressionOrEmptyTag::Literal => {
2490
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2666
+ let node: Box<Literal> = <Box<
2667
+ Literal,
2668
+ > as Deserialize>::deserialize(
2669
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2670
)?;
2671
Ok(JSXExpressionOrEmpty::Expression(Expression::Literal(node)))
2672
}
2673
__JSXExpressionOrEmptyTag::LogicalExpression => {
2496
- let node: Box<LogicalExpression> =
2497
- <Box<LogicalExpression> as Deserialize>::deserialize(
2498
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2499
- )?;
2500
- Ok(JSXExpressionOrEmpty::Expression(
2501
- Expression::LogicalExpression(node),
2502
- ))
2674
+ let node: Box<LogicalExpression> = <Box<
2675
+ LogicalExpression,
2676
+ > as Deserialize>::deserialize(
2677
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2678
+ )?;
2679
+ Ok(JSXExpressionOrEmpty::Expression(Expression::LogicalExpression(node)))
2680
}
2681
__JSXExpressionOrEmptyTag::MemberExpression => {
2505
- let node: Box<MemberExpression> =
2506
- <Box<MemberExpression> as Deserialize>::deserialize(
2507
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2508
- )?;
2509
- Ok(JSXExpressionOrEmpty::Expression(
2510
- Expression::MemberExpression(node),
2511
- ))
2682
+ let node: Box<MemberExpression> = <Box<
2683
+ MemberExpression,
2684
+ > as Deserialize>::deserialize(
2685
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2686
+ )?;
2687
+ Ok(JSXExpressionOrEmpty::Expression(Expression::MemberExpression(node)))
2688
}
2689
__JSXExpressionOrEmptyTag::NewExpression => {
2514
- let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
2690
+ let node: Box<NewExpression> = <Box<
2691
+ NewExpression,
2692
+ > as Deserialize>::deserialize(
2693
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2694
)?;
2517
- Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(
2518
- node,
2519
- )))
2695
+ Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(node)))
2696
}
2697
__JSXExpressionOrEmptyTag::ObjectExpression => {
2522
- let node: Box<ObjectExpression> =
2523
- <Box<ObjectExpression> as Deserialize>::deserialize(
2524
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2525
- )?;
2526
- Ok(JSXExpressionOrEmpty::Expression(
2527
- Expression::ObjectExpression(node),
2528
- ))
2698
+ let node: Box<ObjectExpression> = <Box<
2699
+ ObjectExpression,
2700
+ > as Deserialize>::deserialize(
2701
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2702
+ )?;
2703
+ Ok(JSXExpressionOrEmpty::Expression(Expression::ObjectExpression(node)))
2704
}
2705
__JSXExpressionOrEmptyTag::SequenceExpression => {
2531
- let node: Box<SequenceExpression> =
2532
- <Box<SequenceExpression> as Deserialize>::deserialize(
2533
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2534
- )?;
2535
- Ok(JSXExpressionOrEmpty::Expression(
2536
- Expression::SequenceExpression(node),
2537
- ))
2706
+ let node: Box<SequenceExpression> = <Box<
2707
+ SequenceExpression,
2708
+ > as Deserialize>::deserialize(
2709
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2710
+ )?;
2711
+ Ok(
2712
+ JSXExpressionOrEmpty::Expression(
2713
+ Expression::SequenceExpression(node),
2714
+ ),
2715
+ )
2716
}
2717
__JSXExpressionOrEmptyTag::ThisExpression => {
2540
- let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
2718
+ let node: Box<ThisExpression> = <Box<
2719
+ ThisExpression,
2720
+ > as Deserialize>::deserialize(
2721
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2722
)?;
2543
- Ok(JSXExpressionOrEmpty::Expression(
2544
- Expression::ThisExpression(node),
2545
- ))
2723
+ Ok(JSXExpressionOrEmpty::Expression(Expression::ThisExpression(node)))
2724
}
2725
__JSXExpressionOrEmptyTag::UnaryExpression => {
2548
- let node: Box<UnaryExpression> =
2549
- <Box<UnaryExpression> as Deserialize>::deserialize(
2550
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2551
- )?;
2552
- Ok(JSXExpressionOrEmpty::Expression(
2553
- Expression::UnaryExpression(node),
2554
- ))
2726
+ let node: Box<UnaryExpression> = <Box<
2727
+ UnaryExpression,
2728
+ > as Deserialize>::deserialize(
2729
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2730
+ )?;
2731
+ Ok(JSXExpressionOrEmpty::Expression(Expression::UnaryExpression(node)))
2732
}
2733
__JSXExpressionOrEmptyTag::UpdateExpression => {
2557
- let node: Box<UpdateExpression> =
2558
- <Box<UpdateExpression> as Deserialize>::deserialize(
2559
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2560
- )?;
2561
- Ok(JSXExpressionOrEmpty::Expression(
2562
- Expression::UpdateExpression(node),
2563
- ))
2734
+ let node: Box<UpdateExpression> = <Box<
2735
+ UpdateExpression,
2736
+ > as Deserialize>::deserialize(
2737
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2738
+ )?;
2739
+ Ok(JSXExpressionOrEmpty::Expression(Expression::UpdateExpression(node)))
2740
}
2741
__JSXExpressionOrEmptyTag::YieldExpression => {
2566
- let node: Box<YieldExpression> =
2567
- <Box<YieldExpression> as Deserialize>::deserialize(
2568
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2569
- )?;
2570
- Ok(JSXExpressionOrEmpty::Expression(
2571
- Expression::YieldExpression(node),
2572
- ))
2742
+ let node: Box<YieldExpression> = <Box<
2743
+ YieldExpression,
2744
+ > as Deserialize>::deserialize(
2745
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2746
+ )?;
2747
+ Ok(JSXExpressionOrEmpty::Expression(Expression::YieldExpression(node)))
2748
}
2749
__JSXExpressionOrEmptyTag::JSXElement => {
2575
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2750
+ let node: Box<JSXElement> = <Box<
2751
+ JSXElement,
2752
+ > as Deserialize>::deserialize(
2753
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2754
)?;
2578
- Ok(JSXExpressionOrEmpty::Expression(Expression::JSXElement(
2579
- node,
2580
- )))
2755
+ Ok(JSXExpressionOrEmpty::Expression(Expression::JSXElement(node)))
2756
}
2757
__JSXExpressionOrEmptyTag::JSXEmptyExpression => {
2583
- let node: Box<JSXEmptyExpression> =
2584
- <Box<JSXEmptyExpression> as Deserialize>::deserialize(
2585
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2586
- )?;
2758
+ let node: Box<JSXEmptyExpression> = <Box<
2759
+ JSXEmptyExpression,
2760
+ > as Deserialize>::deserialize(
2761
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2762
+ )?;
2763
Ok(JSXExpressionOrEmpty::JSXEmptyExpression(node))
2764
}
2765
}
@@ -2607,22 +2783,25 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeOrSpread {
2783
{
2784
let tagged = serde::Deserializer::deserialize_any(
2785
deserializer,
2610
- serde::__private::de::TaggedContentVisitor::<__JSXAttributeOrSpreadTag>::new(
2611
- "type", "Pattern",
2612
- ),
2786
+ serde::__private::de::TaggedContentVisitor::<
2787
+ __JSXAttributeOrSpreadTag,
2788
+ >::new("type", "Pattern"),
2789
)?;
2790
match tagged.0 {
2791
__JSXAttributeOrSpreadTag::JSXAttribute => {
2616
- let node: Box<JSXAttribute> = <Box<JSXAttribute> as Deserialize>::deserialize(
2792
+ let node: Box<JSXAttribute> = <Box<
2793
+ JSXAttribute,
2794
+ > as Deserialize>::deserialize(
2795
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2796
)?;
2797
Ok(JSXAttributeOrSpread::JSXAttribute(node))
2798
}
2799
__JSXAttributeOrSpreadTag::JSXSpreadAttribute => {
2622
- let node: Box<JSXSpreadAttribute> =
2623
- <Box<JSXSpreadAttribute> as Deserialize>::deserialize(
2624
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2625
- )?;
2800
+ let node: Box<JSXSpreadAttribute> = <Box<
2801
+ JSXSpreadAttribute,
2802
+ > as Deserialize>::deserialize(
2803
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2804
+ )?;
2805
Ok(JSXAttributeOrSpread::JSXSpreadAttribute(node))
2806
}
2807
}
@@ -2650,32 +2829,39 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeValue {
2829
{
2830
let tagged = serde::Deserializer::deserialize_any(
2831
deserializer,
2653
- serde::__private::de::TaggedContentVisitor::<__JSXAttributeValueTag>::new(
2654
- "type", "Pattern",
2655
- ),
2832
+ serde::__private::de::TaggedContentVisitor::<
2833
+ __JSXAttributeValueTag,
2834
+ >::new("type", "Pattern"),
2835
)?;
2836
match tagged.0 {
2837
__JSXAttributeValueTag::Literal => {
2659
- let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2838
+ let node: Box<Literal> = <Box<
2839
+ Literal,
2840
+ > as Deserialize>::deserialize(
2841
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2842
)?;
2843
Ok(JSXAttributeValue::Literal(node))
2844
}
2845
__JSXAttributeValueTag::JSXExpressionContainer => {
2665
- let node: Box<JSXExpressionContainer> =
2666
- <Box<JSXExpressionContainer> as Deserialize>::deserialize(
2667
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2668
- )?;
2846
+ let node: Box<JSXExpressionContainer> = <Box<
2847
+ JSXExpressionContainer,
2848
+ > as Deserialize>::deserialize(
2849
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2850
+ )?;
2851
Ok(JSXAttributeValue::JSXExpressionContainer(node))
2852
}
2853
__JSXAttributeValueTag::JSXElement => {
2672
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2854
+ let node: Box<JSXElement> = <Box<
2855
+ JSXElement,
2856
+ > as Deserialize>::deserialize(
2857
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2858
)?;
2859
Ok(JSXAttributeValue::JSXElement(node))
2860
}
2861
__JSXAttributeValueTag::JSXFragment => {
2678
- let node: Box<JSXFragment> = <Box<JSXFragment> as Deserialize>::deserialize(
2862
+ let node: Box<JSXFragment> = <Box<
2863
+ JSXFragment,
2864
+ > as Deserialize>::deserialize(
2865
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2866
)?;
2867
Ok(JSXAttributeValue::JSXFragment(node))
@@ -2703,29 +2889,33 @@ impl<'de> serde::Deserialize<'de> for JSXElementName {
2889
{
2890
let tagged = serde::Deserializer::deserialize_any(
2891
deserializer,
2706
- serde::__private::de::TaggedContentVisitor::<__JSXElementNameTag>::new(
2707
- "type", "Pattern",
2708
- ),
2892
+ serde::__private::de::TaggedContentVisitor::<
2893
+ __JSXElementNameTag,
2894
+ >::new("type", "Pattern"),
2895
)?;
2896
match tagged.0 {
2897
__JSXElementNameTag::JSXIdentifier => {
2712
- let node: Box<JSXIdentifier> = <Box<JSXIdentifier> as Deserialize>::deserialize(
2898
+ let node: Box<JSXIdentifier> = <Box<
2899
+ JSXIdentifier,
2900
+ > as Deserialize>::deserialize(
2901
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2902
)?;
2903
Ok(JSXElementName::JSXIdentifier(node))
2904
}
2905
__JSXElementNameTag::JSXMemberExpression => {
2718
- let node: Box<JSXMemberExpression> =
2719
- <Box<JSXMemberExpression> as Deserialize>::deserialize(
2720
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2721
- )?;
2906
+ let node: Box<JSXMemberExpression> = <Box<
2907
+ JSXMemberExpression,
2908
+ > as Deserialize>::deserialize(
2909
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2910
+ )?;
2911
Ok(JSXElementName::JSXMemberExpression(node))
2912
}
2913
__JSXElementNameTag::JSXNamespacedName => {
2725
- let node: Box<JSXNamespacedName> =
2726
- <Box<JSXNamespacedName> as Deserialize>::deserialize(
2727
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2728
- )?;
2914
+ let node: Box<JSXNamespacedName> = <Box<
2915
+ JSXNamespacedName,
2916
+ > as Deserialize>::deserialize(
2917
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2918
+ )?;
2919
Ok(JSXElementName::JSXNamespacedName(node))
2920
}
2921
}
@@ -2749,22 +2939,25 @@ impl<'de> serde::Deserialize<'de> for JSXIdentifierOrNamespacedName {
2939
{
2940
let tagged = serde::Deserializer::deserialize_any(
2941
deserializer,
2752
- serde::__private::de::TaggedContentVisitor::<__JSXIdentifierOrNamespacedNameTag>::new(
2753
- "type", "Pattern",
2754
- ),
2942
+ serde::__private::de::TaggedContentVisitor::<
2943
+ __JSXIdentifierOrNamespacedNameTag,
2944
+ >::new("type", "Pattern"),
2945
)?;
2946
match tagged.0 {
2947
__JSXIdentifierOrNamespacedNameTag::JSXIdentifier => {
2758
- let node: Box<JSXIdentifier> = <Box<JSXIdentifier> as Deserialize>::deserialize(
2948
+ let node: Box<JSXIdentifier> = <Box<
2949
+ JSXIdentifier,
2950
+ > as Deserialize>::deserialize(
2951
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2952
)?;
2953
Ok(JSXIdentifierOrNamespacedName::JSXIdentifier(node))
2954
}
2955
__JSXIdentifierOrNamespacedNameTag::JSXNamespacedName => {
2764
- let node: Box<JSXNamespacedName> =
2765
- <Box<JSXNamespacedName> as Deserialize>::deserialize(
2766
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2767
- )?;
2956
+ let node: Box<JSXNamespacedName> = <Box<
2957
+ JSXNamespacedName,
2958
+ > as Deserialize>::deserialize(
2959
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2960
+ )?;
2961
Ok(JSXIdentifierOrNamespacedName::JSXNamespacedName(node))
2962
}
2963
}
@@ -2794,36 +2987,47 @@ impl<'de> serde::Deserialize<'de> for JSXChildItem {
2987
{
2988
let tagged = serde::Deserializer::deserialize_any(
2989
deserializer,
2797
- serde::__private::de::TaggedContentVisitor::<__JSXChildItemTag>::new("type", "Pattern"),
2990
+ serde::__private::de::TaggedContentVisitor::<
2991
+ __JSXChildItemTag,
2992
+ >::new("type", "Pattern"),
2993
)?;
2994
match tagged.0 {
2995
__JSXChildItemTag::JSXText => {
2801
- let node: Box<JSXText> = <Box<JSXText> as Deserialize>::deserialize(
2996
+ let node: Box<JSXText> = <Box<
2997
+ JSXText,
2998
+ > as Deserialize>::deserialize(
2999
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3000
)?;
3001
Ok(JSXChildItem::JSXText(node))
3002
}
3003
__JSXChildItemTag::JSXExpressionContainer => {
2807
- let node: Box<JSXExpressionContainer> =
2808
- <Box<JSXExpressionContainer> as Deserialize>::deserialize(
2809
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2810
- )?;
3004
+ let node: Box<JSXExpressionContainer> = <Box<
3005
+ JSXExpressionContainer,
3006
+ > as Deserialize>::deserialize(
3007
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3008
+ )?;
3009
Ok(JSXChildItem::JSXExpressionContainer(node))
3010
}
3011
__JSXChildItemTag::JSXSpreadChild => {
2814
- let node: Box<JSXSpreadChild> = <Box<JSXSpreadChild> as Deserialize>::deserialize(
3012
+ let node: Box<JSXSpreadChild> = <Box<
3013
+ JSXSpreadChild,
3014
+ > as Deserialize>::deserialize(
3015
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3016
)?;
3017
Ok(JSXChildItem::JSXSpreadChild(node))
3018
}
3019
__JSXChildItemTag::JSXElement => {
2820
- let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
3020
+ let node: Box<JSXElement> = <Box<
3021
+ JSXElement,
3022
+ > as Deserialize>::deserialize(
3023
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3024
)?;
3025
Ok(JSXChildItem::JSXElement(node))
3026
}
3027
__JSXChildItemTag::JSXFragment => {
2826
- let node: Box<JSXFragment> = <Box<JSXFragment> as Deserialize>::deserialize(
3028
+ let node: Box<JSXFragment> = <Box<
3029
+ JSXFragment,
3030
+ > as Deserialize>::deserialize(
3031
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3032
)?;
3033
Ok(JSXChildItem::JSXFragment(node))
compiler/forget/crates/forget_hir/Cargo.toml
+2
@@ -18,3 +18,5 @@ forget_estree = { workspace = true }
18
indexmap = { workspace = true }
19
serde = { workspace = true }
20
forget_utils = { workspace = true }
21
+forget_diagnostics = { workspace = true }
22
+thiserror = { workspace = true }
compiler/forget/crates/forget_hir/src/initialize.rs
new
+174
@@ -0,0 +1,174 @@
1
+use std::collections::HashSet;
2
+
3
+use forget_diagnostics::{invariant, Diagnostic};
4
+use indexmap::IndexMap;
5
+use thiserror::Error;
6
+
7
+use crate::{BlockId, GotoKind, GotoTerminal, InstructionIdGenerator, TerminalValue, HIR};
8
+
9
+/// Runs a variety of passes to put the HIR in canonical form. This should be called
10
+/// after initial HIR construction and after any transformations that change the
11
+/// shape of the control-flow graph.
12
+pub fn initialize_hir<'a>(hir: &mut HIR<'a>) -> Result<(), Diagnostic> {
13
+ reverse_postorder_blocks(hir);
14
+ remove_unreachable_for_updates(hir);
15
+ remove_unreachable_fallthroughs(hir);
16
+ remove_unreachable_do_while_statements(hir);
17
+ mark_instruction_ids(hir)?;
18
+ mark_predecessors(hir);
19
+ Ok(())
20
+}
21
+
22
+/// Modifies the HIR to put the blocks in reverse postorder, with predecessors before
23
+/// successors (except for the case of loops)
24
+pub fn reverse_postorder_blocks<'a>(hir: &mut HIR<'a>) {
25
+ let mut visited = HashSet::<BlockId>::with_capacity(hir.blocks.len());
26
+ let mut postorder = std::vec::Vec::<BlockId>::with_capacity(hir.blocks.len());
27
+ fn visit<'a>(
28
+ block_id: BlockId,
29
+ hir: &HIR<'a>,
30
+ visited: &mut HashSet<BlockId>,
31
+ postorder: &mut std::vec::Vec<BlockId>,
32
+ ) {
33
+ if !visited.insert(block_id) {
34
+ // already visited
35
+ return;
36
+ }
37
+ let block = hir.block(block_id);
38
+ let terminal = &block.terminal;
39
+ match &terminal.value {
40
+ TerminalValue::Branch(terminal) => {
41
+ visit(terminal.alternate, hir, visited, postorder);
42
+ visit(terminal.consequent, hir, visited, postorder);
43
+ }
44
+ TerminalValue::If(terminal) => {
45
+ visit(terminal.alternate, hir, visited, postorder);
46
+ visit(terminal.consequent, hir, visited, postorder);
47
+ }
48
+ TerminalValue::For(terminal) => {
49
+ visit(terminal.init, hir, visited, postorder);
50
+ }
51
+ TerminalValue::DoWhile(terminal) => {
52
+ visit(terminal.body, hir, visited, postorder);
53
+ }
54
+ TerminalValue::Goto(terminal) => {
55
+ visit(terminal.block, hir, visited, postorder);
56
+ }
57
+ TerminalValue::Return(..) => { /* no-op */ }
58
+ TerminalValue::Unsupported(..) => {
59
+ panic!("Unexpected unsupported terminal")
60
+ }
61
+ }
62
+ postorder.push(block_id);
63
+ }
64
+ visit(hir.entry, &hir, &mut visited, &mut postorder);
65
+
66
+ // NOTE: could consider sorting the blocks in-place by key
67
+ let mut blocks = IndexMap::with_capacity(hir.blocks.len());
68
+ for id in postorder.iter().rev().cloned() {
69
+ blocks.insert(id, hir.blocks.remove(&id).unwrap());
70
+ }
71
+
72
+ hir.blocks = blocks;
73
+}
74
+
75
+/// Prunes ForTerminal.update values (sets to None) if they are unreachable
76
+pub fn remove_unreachable_for_updates<'a>(hir: &mut HIR<'a>) {
77
+ let block_ids: HashSet<BlockId> = hir.blocks.keys().cloned().collect();
78
+
79
+ for block in hir.blocks.values_mut() {
80
+ if let TerminalValue::For(terminal) = &mut block.terminal.value {
81
+ if let Some(update) = terminal.update {
82
+ if !block_ids.contains(&update) {
83
+ terminal.update = None;
84
+ }
85
+ }
86
+ }
87
+ }
88
+}
89
+
90
+/// Prunes unreachable fallthrough values, setting them to None if the referenced
91
+/// block was not otherwise reachable.
92
+pub fn remove_unreachable_fallthroughs<'a>(hir: &mut HIR<'a>) {
93
+ let block_ids: HashSet<BlockId> = hir.blocks.keys().cloned().collect();
94
+
95
+ for block in hir.blocks.values_mut() {
96
+ block
97
+ .terminal
98
+ .value
99
+ .map_optional_fallthroughs(|fallthrough| {
100
+ if block_ids.contains(&fallthrough) {
101
+ Some(fallthrough)
102
+ } else {
103
+ None
104
+ }
105
+ })
106
+ }
107
+}
108
+
109
+/// Rewrites DoWhile statements into Gotos if the test block is not reachable
110
+pub fn remove_unreachable_do_while_statements<'a>(hir: &mut HIR<'a>) {
111
+ let block_ids: HashSet<BlockId> = hir.blocks.keys().cloned().collect();
112
+
113
+ for block in hir.blocks.values_mut() {
114
+ if let TerminalValue::DoWhile(terminal) = &mut block.terminal.value {
115
+ if !block_ids.contains(&terminal.test) {
116
+ block.terminal.value = TerminalValue::Goto(GotoTerminal {
117
+ block: terminal.body,
118
+ kind: GotoKind::Break,
119
+ });
120
+ }
121
+ }
122
+ }
123
+}
124
+
125
+/// Updates the instruction ids for all instructions and blocks
126
+/// Relies on the blocks being in reverse postorder to ensure that id ordering is correct
127
+pub fn mark_instruction_ids<'a>(hir: &mut HIR<'a>) -> Result<(), Diagnostic> {
128
+ let mut id_gen = InstructionIdGenerator::new();
129
+ let mut visited = HashSet::<(usize, usize)>::new();
130
+ for (ii, block) in hir.blocks.values_mut().enumerate() {
131
+ let block_id = block.id;
132
+ for (jj, instr_ix) in block.instructions.iter_mut().enumerate() {
133
+ invariant(visited.insert((ii, jj)), || {
134
+ Diagnostic::invariant(BlockVisitedTwice { block: block_id }, None)
135
+ })?;
136
+ let instr = &mut hir.instructions[usize::from(*instr_ix)];
137
+ instr.id = id_gen.next();
138
+ }
139
+ block.terminal.id = id_gen.next();
140
+ }
141
+ Ok(())
142
+}
143
+
144
+#[derive(Error, Debug)]
145
+#[error("Invariant: Expected block {block} not to have been visited yet")]
146
+pub struct BlockVisitedTwice {
147
+ block: BlockId,
148
+}
149
+
150
+/// Updates the predecessors of each block
151
+pub fn mark_predecessors<'a>(hir: &mut HIR<'a>) {
152
+ for block in hir.blocks.values_mut() {
153
+ block.predecessors.clear();
154
+ }
155
+ let mut visited = HashSet::<BlockId>::with_capacity(hir.blocks.len());
156
+ fn visit<'a>(
157
+ block_id: BlockId,
158
+ prev_id: Option<BlockId>,
159
+ hir: &mut HIR<'a>,
160
+ visited: &mut HashSet<BlockId>,
161
+ ) {
162
+ let block = hir.block_mut(block_id);
163
+ if let Some(prev_id) = prev_id {
164
+ block.predecessors.insert(prev_id);
165
+ }
166
+ if !visited.insert(block_id) {
167
+ return;
168
+ }
169
+ for successor in block.terminal.value.successors() {
170
+ visit(successor, Some(block_id), hir, visited)
171
+ }
172
+ }
173
+ visit(hir.entry, None, hir, &mut visited);
174
+}
compiler/forget/crates/forget_hir/src/lib.rs
+6
@@ -3,6 +3,7 @@ mod environment;
3
mod features;
4
mod function;
5
mod id_types;
6
+mod initialize;
7
mod instruction;
8
mod print;
9
mod registry;
@@ -14,6 +15,11 @@ pub use environment::*;
15
pub use features::*;
16
pub use function::*;
17
pub use id_types::*;
18
+pub use initialize::{
19
+ initialize_hir, mark_instruction_ids, mark_predecessors,
20
+ remove_unreachable_do_while_statements, remove_unreachable_fallthroughs,
21
+ remove_unreachable_for_updates, reverse_postorder_blocks,
22
+};
23
pub use instruction::*;
24
pub use print::Print;
25
pub use registry::Registry;
compiler/forget/crates/forget_optimization/src/constant_propagation.rs
+2
-3
@@ -1,10 +1,9 @@
1
use std::collections::HashMap;
2
3
-use forget_build_hir::initialize_hir;
3
use forget_estree::BinaryOperator;
4
use forget_hir::{
6
- BlockKind, Environment, Function, GotoKind, GotoTerminal, IdentifierId, Instruction,
7
- InstructionValue, LoadGlobal, Operand, Primitive, PrimitiveValue, TerminalValue,
5
+ initialize_hir, BlockKind, Environment, Function, GotoKind, GotoTerminal, IdentifierId,
6
+ Instruction, InstructionValue, LoadGlobal, Operand, Primitive, PrimitiveValue, TerminalValue,
7
};
8
use forget_ssa::eliminate_redundant_phis;
9