[rust] add+apply rustfmt config
Joe Savona committed
Jul 14, 2023 at 15:33 UTC
19b0a49967a02f65d20e7af70ac79ddfd7292dfd
18 files changed
+939
-1111
compiler/forget/crates/forget_build_hir/src/build.rs
+5
-6
@@ -1,6 +1,7 @@
1
use std::collections::HashSet;
2
3
-use bumpalo::{boxed::Box, collections::String};
3
+use bumpalo::boxed::Box;
4
+use bumpalo::collections::String;
5
use forget_diagnostics::{Diagnostic, DiagnosticSeverity};
6
use forget_estree::{
7
AssignmentTarget, BinaryExpression, BlockStatement, Expression, ForInit, ForStatement,
@@ -13,11 +14,9 @@ use forget_hir::{
14
PrimitiveValue, TerminalValue,
15
};
16
16
-use crate::{
17
- builder::{Binding, Builder, LoopScope},
18
- context::get_context_identifiers,
19
- error::BuildHIRError,
20
-};
17
+use crate::builder::{Binding, Builder, LoopScope};
18
+use crate::context::get_context_identifiers;
19
+use crate::error::BuildHIRError;
20
21
/// Converts a React function in ESTree format into HIR. Returns the HIR
22
/// if it was constructed sucessfully, otherwise a list of diagnostics
compiler/forget/crates/forget_build_hir/src/builder.rs
+6
-6
@@ -1,10 +1,10 @@
1
-use bumpalo::{
2
- boxed::Box,
3
- collections::{String, Vec},
4
-};
5
-use forget_diagnostics::{invariant, Diagnostic, DiagnosticSeverity};
6
-use std::{cell::RefCell, collections::HashSet, rc::Rc};
1
+use std::cell::RefCell;
2
+use std::collections::HashSet;
3
+use std::rc::Rc;
4
5
+use bumpalo::boxed::Box;
6
+use bumpalo::collections::{String, Vec};
7
+use forget_diagnostics::{invariant, Diagnostic, DiagnosticSeverity};
8
use forget_hir::{
9
BasicBlock, BlockId, BlockKind, Environment, GotoKind, Identifier, IdentifierData, InstrIx,
10
Instruction, InstructionIdGenerator, InstructionValue, Terminal, TerminalValue, Type, HIR,
compiler/forget/crates/forget_diagnostics/src/diagnostic.rs
+2
-4
@@ -1,7 +1,5 @@
1
-use std::{
2
- error::Error,
3
- fmt::{Debug, Display, Write},
4
-};
1
+use std::error::Error;
2
+use std::fmt::{Debug, Display, Write};
3
4
use forget_estree::SourceRange;
5
use miette::{ByteOffset, SourceSpan};
compiler/forget/crates/forget_diagnostics/src/lib.rs
+1
-5
@@ -8,9 +8,5 @@ pub fn invariant<F>(cond: bool, f: F) -> Result<(), Diagnostic>
8
where
9
F: Fn() -> Diagnostic,
10
{
11
- if cond {
12
- Ok(())
13
- } else {
14
- Err(f())
15
- }
11
+ if cond { Ok(()) } else { Err(f()) }
12
}
compiler/forget/crates/forget_estree/src/generated.rs
+846
-1050
@@ -1,6 +1,8 @@
1
use std::num::NonZeroU32;
2
-use serde::{Serialize, Deserialize};
3
-use crate::{JsValue, Binding, SourceRange};
2
+
3
+use serde::{Deserialize, Serialize};
4
+
5
+use crate::{Binding, JsValue, SourceRange};
6
#[derive(Serialize, Deserialize, Clone, Debug)]
7
pub struct SourceLocation {
8
pub source: Option<String>,
@@ -667,167 +669,134 @@ impl<'de> serde::Deserialize<'de> for Statement {
669
{
670
let tagged = serde::Deserializer::deserialize_any(
671
deserializer,
670
- serde::__private::de::TaggedContentVisitor::<
671
- __StatementTag,
672
- >::new("type", "Pattern"),
672
+ serde::__private::de::TaggedContentVisitor::<__StatementTag>::new("type", "Pattern"),
673
)?;
674
match tagged.0 {
675
__StatementTag::BlockStatement => {
676
- let node: Box<BlockStatement> = <Box<
677
- BlockStatement,
678
- > as Deserialize>::deserialize(
676
+ let node: Box<BlockStatement> = <Box<BlockStatement> as Deserialize>::deserialize(
677
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
678
)?;
679
Ok(Statement::BlockStatement(node))
680
}
681
__StatementTag::BreakStatement => {
684
- let node: Box<BreakStatement> = <Box<
685
- BreakStatement,
686
- > as Deserialize>::deserialize(
682
+ let node: Box<BreakStatement> = <Box<BreakStatement> as Deserialize>::deserialize(
683
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
684
)?;
685
Ok(Statement::BreakStatement(node))
686
}
687
__StatementTag::ContinueStatement => {
692
- let node: Box<ContinueStatement> = <Box<
693
- ContinueStatement,
694
- > as Deserialize>::deserialize(
695
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
696
- )?;
688
+ let node: Box<ContinueStatement> =
689
+ <Box<ContinueStatement> as Deserialize>::deserialize(
690
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
691
+ )?;
692
Ok(Statement::ContinueStatement(node))
693
}
694
__StatementTag::DebuggerStatement => {
700
- let node: Box<DebuggerStatement> = <Box<
701
- DebuggerStatement,
702
- > as Deserialize>::deserialize(
703
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
704
- )?;
695
+ let node: Box<DebuggerStatement> =
696
+ <Box<DebuggerStatement> as Deserialize>::deserialize(
697
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
698
+ )?;
699
Ok(Statement::DebuggerStatement(node))
700
}
701
__StatementTag::DoWhileStatement => {
708
- let node: Box<DoWhileStatement> = <Box<
709
- DoWhileStatement,
710
- > as Deserialize>::deserialize(
711
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
712
- )?;
702
+ let node: Box<DoWhileStatement> =
703
+ <Box<DoWhileStatement> as Deserialize>::deserialize(
704
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
705
+ )?;
706
Ok(Statement::DoWhileStatement(node))
707
}
708
__StatementTag::EmptyStatement => {
716
- let node: Box<EmptyStatement> = <Box<
717
- EmptyStatement,
718
- > as Deserialize>::deserialize(
709
+ let node: Box<EmptyStatement> = <Box<EmptyStatement> as Deserialize>::deserialize(
710
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
711
)?;
712
Ok(Statement::EmptyStatement(node))
713
}
714
__StatementTag::ExpressionStatement => {
724
- let node: Box<ExpressionStatement> = <Box<
725
- ExpressionStatement,
726
- > as Deserialize>::deserialize(
727
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
728
- )?;
715
+ let node: Box<ExpressionStatement> =
716
+ <Box<ExpressionStatement> as Deserialize>::deserialize(
717
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
718
+ )?;
719
Ok(Statement::ExpressionStatement(node))
720
}
721
__StatementTag::ForInStatement => {
732
- let node: Box<ForInStatement> = <Box<
733
- ForInStatement,
734
- > as Deserialize>::deserialize(
722
+ let node: Box<ForInStatement> = <Box<ForInStatement> as Deserialize>::deserialize(
723
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
724
)?;
725
Ok(Statement::ForInStatement(node))
726
}
727
__StatementTag::ForOfStatement => {
740
- let node: Box<ForOfStatement> = <Box<
741
- ForOfStatement,
742
- > as Deserialize>::deserialize(
728
+ let node: Box<ForOfStatement> = <Box<ForOfStatement> as Deserialize>::deserialize(
729
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
730
)?;
731
Ok(Statement::ForOfStatement(node))
732
}
733
__StatementTag::ForStatement => {
748
- let node: Box<ForStatement> = <Box<
749
- ForStatement,
750
- > as Deserialize>::deserialize(
734
+ let node: Box<ForStatement> = <Box<ForStatement> as Deserialize>::deserialize(
735
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
736
)?;
737
Ok(Statement::ForStatement(node))
738
}
739
__StatementTag::FunctionDeclaration => {
756
- let node: Box<FunctionDeclaration> = <Box<
757
- FunctionDeclaration,
758
- > as Deserialize>::deserialize(
759
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
760
- )?;
740
+ let node: Box<FunctionDeclaration> =
741
+ <Box<FunctionDeclaration> as Deserialize>::deserialize(
742
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
743
+ )?;
744
Ok(Statement::FunctionDeclaration(node))
745
}
746
__StatementTag::IfStatement => {
764
- let node: Box<IfStatement> = <Box<
765
- IfStatement,
766
- > as Deserialize>::deserialize(
747
+ let node: Box<IfStatement> = <Box<IfStatement> as Deserialize>::deserialize(
748
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
749
)?;
750
Ok(Statement::IfStatement(node))
751
}
752
__StatementTag::LabeledStatement => {
772
- let node: Box<LabeledStatement> = <Box<
773
- LabeledStatement,
774
- > as Deserialize>::deserialize(
775
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
776
- )?;
753
+ let node: Box<LabeledStatement> =
754
+ <Box<LabeledStatement> as Deserialize>::deserialize(
755
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
756
+ )?;
757
Ok(Statement::LabeledStatement(node))
758
}
759
__StatementTag::ReturnStatement => {
780
- let node: Box<ReturnStatement> = <Box<
781
- ReturnStatement,
782
- > as Deserialize>::deserialize(
783
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
784
- )?;
760
+ let node: Box<ReturnStatement> =
761
+ <Box<ReturnStatement> as Deserialize>::deserialize(
762
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
763
+ )?;
764
Ok(Statement::ReturnStatement(node))
765
}
766
__StatementTag::SwitchStatement => {
788
- let node: Box<SwitchStatement> = <Box<
789
- SwitchStatement,
790
- > as Deserialize>::deserialize(
791
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
792
- )?;
767
+ let node: Box<SwitchStatement> =
768
+ <Box<SwitchStatement> as Deserialize>::deserialize(
769
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
770
+ )?;
771
Ok(Statement::SwitchStatement(node))
772
}
773
__StatementTag::ThrowStatement => {
796
- let node: Box<ThrowStatement> = <Box<
797
- ThrowStatement,
798
- > as Deserialize>::deserialize(
774
+ let node: Box<ThrowStatement> = <Box<ThrowStatement> as Deserialize>::deserialize(
775
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
776
)?;
777
Ok(Statement::ThrowStatement(node))
778
}
779
__StatementTag::TryStatement => {
804
- let node: Box<TryStatement> = <Box<
805
- TryStatement,
806
- > as Deserialize>::deserialize(
780
+ let node: Box<TryStatement> = <Box<TryStatement> as Deserialize>::deserialize(
781
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
782
)?;
783
Ok(Statement::TryStatement(node))
784
}
785
__StatementTag::VariableDeclaration => {
812
- let node: Box<VariableDeclaration> = <Box<
813
- VariableDeclaration,
814
- > as Deserialize>::deserialize(
815
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
816
- )?;
786
+ let node: Box<VariableDeclaration> =
787
+ <Box<VariableDeclaration> as Deserialize>::deserialize(
788
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
789
+ )?;
790
Ok(Statement::VariableDeclaration(node))
791
}
792
__StatementTag::WhileStatement => {
820
- let node: Box<WhileStatement> = <Box<
821
- WhileStatement,
822
- > as Deserialize>::deserialize(
793
+ let node: Box<WhileStatement> = <Box<WhileStatement> as Deserialize>::deserialize(
794
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
795
)?;
796
Ok(Statement::WhileStatement(node))
797
}
798
__StatementTag::WithStatement => {
828
- let node: Box<WithStatement> = <Box<
829
- WithStatement,
830
- > as Deserialize>::deserialize(
799
+ let node: Box<WithStatement> = <Box<WithStatement> as Deserialize>::deserialize(
800
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
801
)?;
802
Ok(Statement::WithStatement(node))
@@ -887,159 +856,132 @@ impl<'de> serde::Deserialize<'de> for Expression {
856
{
857
let tagged = serde::Deserializer::deserialize_any(
858
deserializer,
890
- serde::__private::de::TaggedContentVisitor::<
891
- __ExpressionTag,
892
- >::new("type", "Pattern"),
859
+ serde::__private::de::TaggedContentVisitor::<__ExpressionTag>::new("type", "Pattern"),
860
)?;
861
match tagged.0 {
862
__ExpressionTag::ArrayExpression => {
896
- let node: Box<ArrayExpression> = <Box<
897
- ArrayExpression,
898
- > as Deserialize>::deserialize(
899
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
900
- )?;
863
+ let node: Box<ArrayExpression> =
864
+ <Box<ArrayExpression> as Deserialize>::deserialize(
865
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
866
+ )?;
867
Ok(Expression::ArrayExpression(node))
868
}
869
__ExpressionTag::ArrowFunctionExpression => {
904
- let node: Box<ArrowFunctionExpression> = <Box<
905
- ArrowFunctionExpression,
906
- > as Deserialize>::deserialize(
907
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
908
- )?;
870
+ let node: Box<ArrowFunctionExpression> =
871
+ <Box<ArrowFunctionExpression> as Deserialize>::deserialize(
872
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
873
+ )?;
874
Ok(Expression::ArrowFunctionExpression(node))
875
}
876
__ExpressionTag::AssignmentExpression => {
912
- let node: Box<AssignmentExpression> = <Box<
913
- AssignmentExpression,
914
- > as Deserialize>::deserialize(
915
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
916
- )?;
877
+ let node: Box<AssignmentExpression> =
878
+ <Box<AssignmentExpression> as Deserialize>::deserialize(
879
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
880
+ )?;
881
Ok(Expression::AssignmentExpression(node))
882
}
883
__ExpressionTag::BinaryExpression => {
920
- let node: Box<BinaryExpression> = <Box<
921
- BinaryExpression,
922
- > as Deserialize>::deserialize(
923
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
924
- )?;
884
+ let node: Box<BinaryExpression> =
885
+ <Box<BinaryExpression> as Deserialize>::deserialize(
886
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
887
+ )?;
888
Ok(Expression::BinaryExpression(node))
889
}
890
__ExpressionTag::CallExpression => {
928
- let node: Box<CallExpression> = <Box<
929
- CallExpression,
930
- > as Deserialize>::deserialize(
891
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
892
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
893
)?;
894
Ok(Expression::CallExpression(node))
895
}
896
__ExpressionTag::ConditionalExpression => {
936
- let node: Box<ConditionalExpression> = <Box<
937
- ConditionalExpression,
938
- > as Deserialize>::deserialize(
939
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
940
- )?;
897
+ let node: Box<ConditionalExpression> =
898
+ <Box<ConditionalExpression> as Deserialize>::deserialize(
899
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
900
+ )?;
901
Ok(Expression::ConditionalExpression(node))
902
}
903
__ExpressionTag::FunctionExpression => {
944
- let node: Box<FunctionExpression> = <Box<
945
- FunctionExpression,
946
- > as Deserialize>::deserialize(
947
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
948
- )?;
904
+ let node: Box<FunctionExpression> =
905
+ <Box<FunctionExpression> as Deserialize>::deserialize(
906
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
907
+ )?;
908
Ok(Expression::FunctionExpression(node))
909
}
910
__ExpressionTag::Identifier => {
952
- let node: Box<Identifier> = <Box<
953
- Identifier,
954
- > as Deserialize>::deserialize(
911
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
912
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
913
)?;
914
Ok(Expression::Identifier(node))
915
}
916
__ExpressionTag::Literal => {
960
- let node: Box<Literal> = <Box<
961
- Literal,
962
- > as Deserialize>::deserialize(
917
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
918
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
919
)?;
920
Ok(Expression::Literal(node))
921
}
922
__ExpressionTag::LogicalExpression => {
968
- let node: Box<LogicalExpression> = <Box<
969
- LogicalExpression,
970
- > as Deserialize>::deserialize(
971
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
972
- )?;
923
+ let node: Box<LogicalExpression> =
924
+ <Box<LogicalExpression> as Deserialize>::deserialize(
925
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
926
+ )?;
927
Ok(Expression::LogicalExpression(node))
928
}
929
__ExpressionTag::MemberExpression => {
976
- let node: Box<MemberExpression> = <Box<
977
- MemberExpression,
978
- > as Deserialize>::deserialize(
979
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
980
- )?;
930
+ let node: Box<MemberExpression> =
931
+ <Box<MemberExpression> as Deserialize>::deserialize(
932
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
933
+ )?;
934
Ok(Expression::MemberExpression(node))
935
}
936
__ExpressionTag::NewExpression => {
984
- let node: Box<NewExpression> = <Box<
985
- NewExpression,
986
- > as Deserialize>::deserialize(
937
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
938
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
939
)?;
940
Ok(Expression::NewExpression(node))
941
}
942
__ExpressionTag::ObjectExpression => {
992
- let node: Box<ObjectExpression> = <Box<
993
- ObjectExpression,
994
- > as Deserialize>::deserialize(
995
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
996
- )?;
943
+ let node: Box<ObjectExpression> =
944
+ <Box<ObjectExpression> as Deserialize>::deserialize(
945
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
946
+ )?;
947
Ok(Expression::ObjectExpression(node))
948
}
949
__ExpressionTag::SequenceExpression => {
1000
- let node: Box<SequenceExpression> = <Box<
1001
- SequenceExpression,
1002
- > as Deserialize>::deserialize(
1003
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1004
- )?;
950
+ let node: Box<SequenceExpression> =
951
+ <Box<SequenceExpression> as Deserialize>::deserialize(
952
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
953
+ )?;
954
Ok(Expression::SequenceExpression(node))
955
}
956
__ExpressionTag::ThisExpression => {
1008
- let node: Box<ThisExpression> = <Box<
1009
- ThisExpression,
1010
- > as Deserialize>::deserialize(
957
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
958
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
959
)?;
960
Ok(Expression::ThisExpression(node))
961
}
962
__ExpressionTag::UnaryExpression => {
1016
- let node: Box<UnaryExpression> = <Box<
1017
- UnaryExpression,
1018
- > as Deserialize>::deserialize(
1019
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1020
- )?;
963
+ let node: Box<UnaryExpression> =
964
+ <Box<UnaryExpression> as Deserialize>::deserialize(
965
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
966
+ )?;
967
Ok(Expression::UnaryExpression(node))
968
}
969
__ExpressionTag::UpdateExpression => {
1024
- let node: Box<UpdateExpression> = <Box<
1025
- UpdateExpression,
1026
- > as Deserialize>::deserialize(
1027
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1028
- )?;
970
+ let node: Box<UpdateExpression> =
971
+ <Box<UpdateExpression> as Deserialize>::deserialize(
972
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
973
+ )?;
974
Ok(Expression::UpdateExpression(node))
975
}
976
__ExpressionTag::YieldExpression => {
1032
- let node: Box<YieldExpression> = <Box<
1033
- YieldExpression,
1034
- > as Deserialize>::deserialize(
1035
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1036
- )?;
977
+ let node: Box<YieldExpression> =
978
+ <Box<YieldExpression> as Deserialize>::deserialize(
979
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
980
+ )?;
981
Ok(Expression::YieldExpression(node))
982
}
983
__ExpressionTag::JSXElement => {
1040
- let node: Box<JSXElement> = <Box<
1041
- JSXElement,
1042
- > as Deserialize>::deserialize(
984
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
985
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
986
)?;
987
Ok(Expression::JSXElement(node))
@@ -1067,33 +1009,30 @@ impl<'de> serde::Deserialize<'de> for ImportDeclarationSpecifier {
1009
{
1010
let tagged = serde::Deserializer::deserialize_any(
1011
deserializer,
1070
- serde::__private::de::TaggedContentVisitor::<
1071
- __ImportDeclarationSpecifierTag,
1072
- >::new("type", "Pattern"),
1012
+ serde::__private::de::TaggedContentVisitor::<__ImportDeclarationSpecifierTag>::new(
1013
+ "type", "Pattern",
1014
+ ),
1015
)?;
1016
match tagged.0 {
1017
__ImportDeclarationSpecifierTag::ImportSpecifier => {
1076
- let node: Box<ImportSpecifier> = <Box<
1077
- ImportSpecifier,
1078
- > as Deserialize>::deserialize(
1079
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1080
- )?;
1018
+ let node: Box<ImportSpecifier> =
1019
+ <Box<ImportSpecifier> as Deserialize>::deserialize(
1020
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1021
+ )?;
1022
Ok(ImportDeclarationSpecifier::ImportSpecifier(node))
1023
}
1024
__ImportDeclarationSpecifierTag::ImportDefaultSpecifier => {
1084
- let node: Box<ImportDefaultSpecifier> = <Box<
1085
- ImportDefaultSpecifier,
1086
- > as Deserialize>::deserialize(
1087
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1088
- )?;
1025
+ let node: Box<ImportDefaultSpecifier> =
1026
+ <Box<ImportDefaultSpecifier> as Deserialize>::deserialize(
1027
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1028
+ )?;
1029
Ok(ImportDeclarationSpecifier::ImportDefaultSpecifier(node))
1030
}
1031
__ImportDeclarationSpecifierTag::ImportNamespaceSpecifier => {
1092
- let node: Box<ImportNamespaceSpecifier> = <Box<
1093
- ImportNamespaceSpecifier,
1094
- > as Deserialize>::deserialize(
1095
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1096
- )?;
1032
+ let node: Box<ImportNamespaceSpecifier> =
1033
+ <Box<ImportNamespaceSpecifier> as Deserialize>::deserialize(
1034
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1035
+ )?;
1036
Ok(ImportDeclarationSpecifier::ImportNamespaceSpecifier(node))
1037
}
1038
}
@@ -1136,179 +1075,143 @@ impl<'de> serde::Deserialize<'de> for ModuleItem {
1075
{
1076
let tagged = serde::Deserializer::deserialize_any(
1077
deserializer,
1139
- serde::__private::de::TaggedContentVisitor::<
1140
- __ModuleItemTag,
1141
- >::new("type", "Pattern"),
1078
+ serde::__private::de::TaggedContentVisitor::<__ModuleItemTag>::new("type", "Pattern"),
1079
)?;
1080
match tagged.0 {
1081
__ModuleItemTag::ImportDeclaration => {
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
- )
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
+ ))
1089
}
1090
__ModuleItemTag::BlockStatement => {
1157
- let node: Box<BlockStatement> = <Box<
1158
- BlockStatement,
1159
- > as Deserialize>::deserialize(
1091
+ let node: Box<BlockStatement> = <Box<BlockStatement> as Deserialize>::deserialize(
1092
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1093
)?;
1094
Ok(ModuleItem::Statement(Statement::BlockStatement(node)))
1095
}
1096
__ModuleItemTag::BreakStatement => {
1165
- let node: Box<BreakStatement> = <Box<
1166
- BreakStatement,
1167
- > as Deserialize>::deserialize(
1097
+ let node: Box<BreakStatement> = <Box<BreakStatement> as Deserialize>::deserialize(
1098
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1099
)?;
1100
Ok(ModuleItem::Statement(Statement::BreakStatement(node)))
1101
}
1102
__ModuleItemTag::ContinueStatement => {
1173
- let node: Box<ContinueStatement> = <Box<
1174
- ContinueStatement,
1175
- > as Deserialize>::deserialize(
1176
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1177
- )?;
1103
+ let node: Box<ContinueStatement> =
1104
+ <Box<ContinueStatement> as Deserialize>::deserialize(
1105
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1106
+ )?;
1107
Ok(ModuleItem::Statement(Statement::ContinueStatement(node)))
1108
}
1109
__ModuleItemTag::DebuggerStatement => {
1181
- let node: Box<DebuggerStatement> = <Box<
1182
- DebuggerStatement,
1183
- > as Deserialize>::deserialize(
1184
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1185
- )?;
1110
+ let node: Box<DebuggerStatement> =
1111
+ <Box<DebuggerStatement> as Deserialize>::deserialize(
1112
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1113
+ )?;
1114
Ok(ModuleItem::Statement(Statement::DebuggerStatement(node)))
1115
}
1116
__ModuleItemTag::DoWhileStatement => {
1189
- let node: Box<DoWhileStatement> = <Box<
1190
- DoWhileStatement,
1191
- > as Deserialize>::deserialize(
1192
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1193
- )?;
1117
+ let node: Box<DoWhileStatement> =
1118
+ <Box<DoWhileStatement> as Deserialize>::deserialize(
1119
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1120
+ )?;
1121
Ok(ModuleItem::Statement(Statement::DoWhileStatement(node)))
1122
}
1123
__ModuleItemTag::EmptyStatement => {
1197
- let node: Box<EmptyStatement> = <Box<
1198
- EmptyStatement,
1199
- > as Deserialize>::deserialize(
1124
+ let node: Box<EmptyStatement> = <Box<EmptyStatement> as Deserialize>::deserialize(
1125
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1126
)?;
1127
Ok(ModuleItem::Statement(Statement::EmptyStatement(node)))
1128
}
1129
__ModuleItemTag::ExpressionStatement => {
1205
- let node: Box<ExpressionStatement> = <Box<
1206
- ExpressionStatement,
1207
- > as Deserialize>::deserialize(
1208
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1209
- )?;
1130
+ let node: Box<ExpressionStatement> =
1131
+ <Box<ExpressionStatement> as Deserialize>::deserialize(
1132
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1133
+ )?;
1134
Ok(ModuleItem::Statement(Statement::ExpressionStatement(node)))
1135
}
1136
__ModuleItemTag::ForInStatement => {
1213
- let node: Box<ForInStatement> = <Box<
1214
- ForInStatement,
1215
- > as Deserialize>::deserialize(
1137
+ let node: Box<ForInStatement> = <Box<ForInStatement> as Deserialize>::deserialize(
1138
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1139
)?;
1140
Ok(ModuleItem::Statement(Statement::ForInStatement(node)))
1141
}
1142
__ModuleItemTag::ForOfStatement => {
1221
- let node: Box<ForOfStatement> = <Box<
1222
- ForOfStatement,
1223
- > as Deserialize>::deserialize(
1143
+ let node: Box<ForOfStatement> = <Box<ForOfStatement> as Deserialize>::deserialize(
1144
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1145
)?;
1146
Ok(ModuleItem::Statement(Statement::ForOfStatement(node)))
1147
}
1148
__ModuleItemTag::ForStatement => {
1229
- let node: Box<ForStatement> = <Box<
1230
- ForStatement,
1231
- > as Deserialize>::deserialize(
1149
+ let node: Box<ForStatement> = <Box<ForStatement> as Deserialize>::deserialize(
1150
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1151
)?;
1152
Ok(ModuleItem::Statement(Statement::ForStatement(node)))
1153
}
1154
__ModuleItemTag::FunctionDeclaration => {
1237
- let node: Box<FunctionDeclaration> = <Box<
1238
- FunctionDeclaration,
1239
- > as Deserialize>::deserialize(
1240
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1241
- )?;
1155
+ let node: Box<FunctionDeclaration> =
1156
+ <Box<FunctionDeclaration> as Deserialize>::deserialize(
1157
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1158
+ )?;
1159
Ok(ModuleItem::Statement(Statement::FunctionDeclaration(node)))
1160
}
1161
__ModuleItemTag::IfStatement => {
1245
- let node: Box<IfStatement> = <Box<
1246
- IfStatement,
1247
- > as Deserialize>::deserialize(
1162
+ let node: Box<IfStatement> = <Box<IfStatement> as Deserialize>::deserialize(
1163
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1164
)?;
1165
Ok(ModuleItem::Statement(Statement::IfStatement(node)))
1166
}
1167
__ModuleItemTag::LabeledStatement => {
1253
- let node: Box<LabeledStatement> = <Box<
1254
- LabeledStatement,
1255
- > as Deserialize>::deserialize(
1256
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1257
- )?;
1168
+ let node: Box<LabeledStatement> =
1169
+ <Box<LabeledStatement> as Deserialize>::deserialize(
1170
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1171
+ )?;
1172
Ok(ModuleItem::Statement(Statement::LabeledStatement(node)))
1173
}
1174
__ModuleItemTag::ReturnStatement => {
1261
- let node: Box<ReturnStatement> = <Box<
1262
- ReturnStatement,
1263
- > as Deserialize>::deserialize(
1264
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1265
- )?;
1175
+ let node: Box<ReturnStatement> =
1176
+ <Box<ReturnStatement> as Deserialize>::deserialize(
1177
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1178
+ )?;
1179
Ok(ModuleItem::Statement(Statement::ReturnStatement(node)))
1180
}
1181
__ModuleItemTag::SwitchStatement => {
1269
- let node: Box<SwitchStatement> = <Box<
1270
- SwitchStatement,
1271
- > as Deserialize>::deserialize(
1272
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1273
- )?;
1182
+ let node: Box<SwitchStatement> =
1183
+ <Box<SwitchStatement> as Deserialize>::deserialize(
1184
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1185
+ )?;
1186
Ok(ModuleItem::Statement(Statement::SwitchStatement(node)))
1187
}
1188
__ModuleItemTag::ThrowStatement => {
1277
- let node: Box<ThrowStatement> = <Box<
1278
- ThrowStatement,
1279
- > as Deserialize>::deserialize(
1189
+ let node: Box<ThrowStatement> = <Box<ThrowStatement> as Deserialize>::deserialize(
1190
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1191
)?;
1192
Ok(ModuleItem::Statement(Statement::ThrowStatement(node)))
1193
}
1194
__ModuleItemTag::TryStatement => {
1285
- let node: Box<TryStatement> = <Box<
1286
- TryStatement,
1287
- > as Deserialize>::deserialize(
1195
+ let node: Box<TryStatement> = <Box<TryStatement> as Deserialize>::deserialize(
1196
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1197
)?;
1198
Ok(ModuleItem::Statement(Statement::TryStatement(node)))
1199
}
1200
__ModuleItemTag::VariableDeclaration => {
1293
- let node: Box<VariableDeclaration> = <Box<
1294
- VariableDeclaration,
1295
- > as Deserialize>::deserialize(
1296
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1297
- )?;
1201
+ let node: Box<VariableDeclaration> =
1202
+ <Box<VariableDeclaration> as Deserialize>::deserialize(
1203
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1204
+ )?;
1205
Ok(ModuleItem::Statement(Statement::VariableDeclaration(node)))
1206
}
1207
__ModuleItemTag::WhileStatement => {
1301
- let node: Box<WhileStatement> = <Box<
1302
- WhileStatement,
1303
- > as Deserialize>::deserialize(
1208
+ let node: Box<WhileStatement> = <Box<WhileStatement> as Deserialize>::deserialize(
1209
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1210
)?;
1211
Ok(ModuleItem::Statement(Statement::WhileStatement(node)))
1212
}
1213
__ModuleItemTag::WithStatement => {
1309
- let node: Box<WithStatement> = <Box<
1310
- WithStatement,
1311
- > as Deserialize>::deserialize(
1214
+ let node: Box<WithStatement> = <Box<WithStatement> as Deserialize>::deserialize(
1215
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1216
)?;
1217
Ok(ModuleItem::Statement(Statement::WithStatement(node)))
@@ -1332,17 +1235,16 @@ impl<'de> serde::Deserialize<'de> for ImportOrExportDeclaration {
1235
{
1236
let tagged = serde::Deserializer::deserialize_any(
1237
deserializer,
1335
- serde::__private::de::TaggedContentVisitor::<
1336
- __ImportOrExportDeclarationTag,
1337
- >::new("type", "Pattern"),
1238
+ serde::__private::de::TaggedContentVisitor::<__ImportOrExportDeclarationTag>::new(
1239
+ "type", "Pattern",
1240
+ ),
1241
)?;
1242
match tagged.0 {
1243
__ImportOrExportDeclarationTag::ImportDeclaration => {
1341
- let node: Box<ImportDeclaration> = <Box<
1342
- ImportDeclaration,
1343
- > as Deserialize>::deserialize(
1344
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1345
- )?;
1244
+ let node: Box<ImportDeclaration> =
1245
+ <Box<ImportDeclaration> as Deserialize>::deserialize(
1246
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1247
+ )?;
1248
Ok(ImportOrExportDeclaration::ImportDeclaration(node))
1249
}
1250
}
@@ -1384,175 +1286,172 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
1286
{
1287
let tagged = serde::Deserializer::deserialize_any(
1288
deserializer,
1387
- serde::__private::de::TaggedContentVisitor::<
1388
- __ExpressionOrSuperTag,
1389
- >::new("type", "Pattern"),
1289
+ serde::__private::de::TaggedContentVisitor::<__ExpressionOrSuperTag>::new(
1290
+ "type", "Pattern",
1291
+ ),
1292
)?;
1293
match tagged.0 {
1294
__ExpressionOrSuperTag::ArrayExpression => {
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)))
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
+ )))
1302
}
1303
__ExpressionOrSuperTag::ArrowFunctionExpression => {
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
- )
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
+ ))
1311
}
1312
__ExpressionOrSuperTag::AssignmentExpression => {
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)))
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
+ ))
1320
}
1321
__ExpressionOrSuperTag::BinaryExpression => {
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)))
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
+ )))
1329
}
1330
__ExpressionOrSuperTag::CallExpression => {
1429
- let node: Box<CallExpression> = <Box<
1430
- CallExpression,
1431
- > as Deserialize>::deserialize(
1331
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1332
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1333
)?;
1434
- Ok(ExpressionOrSuper::Expression(Expression::CallExpression(node)))
1334
+ Ok(ExpressionOrSuper::Expression(Expression::CallExpression(
1335
+ node,
1336
+ )))
1337
}
1338
__ExpressionOrSuperTag::ConditionalExpression => {
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
- )
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
+ ))
1346
}
1347
__ExpressionOrSuperTag::FunctionExpression => {
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)))
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
+ ))
1355
}
1356
__ExpressionOrSuperTag::Identifier => {
1457
- let node: Box<Identifier> = <Box<
1458
- Identifier,
1459
- > as Deserialize>::deserialize(
1357
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1358
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1359
)?;
1360
Ok(ExpressionOrSuper::Expression(Expression::Identifier(node)))
1361
}
1362
__ExpressionOrSuperTag::Literal => {
1465
- let node: Box<Literal> = <Box<
1466
- Literal,
1467
- > as Deserialize>::deserialize(
1363
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1364
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1365
)?;
1366
Ok(ExpressionOrSuper::Expression(Expression::Literal(node)))
1367
}
1368
__ExpressionOrSuperTag::LogicalExpression => {
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)))
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
+ ))
1376
}
1377
__ExpressionOrSuperTag::MemberExpression => {
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)))
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
+ )))
1385
}
1386
__ExpressionOrSuperTag::NewExpression => {
1489
- let node: Box<NewExpression> = <Box<
1490
- NewExpression,
1491
- > as Deserialize>::deserialize(
1387
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
1388
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1389
)?;
1494
- Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node)))
1390
+ Ok(ExpressionOrSuper::Expression(Expression::NewExpression(
1391
+ node,
1392
+ )))
1393
}
1394
__ExpressionOrSuperTag::ObjectExpression => {
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)))
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
+ )))
1402
}
1403
__ExpressionOrSuperTag::SequenceExpression => {
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)))
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
+ ))
1411
}
1412
__ExpressionOrSuperTag::ThisExpression => {
1513
- let node: Box<ThisExpression> = <Box<
1514
- ThisExpression,
1515
- > as Deserialize>::deserialize(
1413
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1414
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1415
)?;
1518
- Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(node)))
1416
+ Ok(ExpressionOrSuper::Expression(Expression::ThisExpression(
1417
+ node,
1418
+ )))
1419
}
1420
__ExpressionOrSuperTag::UnaryExpression => {
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)))
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
+ )))
1428
}
1429
__ExpressionOrSuperTag::UpdateExpression => {
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)))
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
+ )))
1437
}
1438
__ExpressionOrSuperTag::YieldExpression => {
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)))
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
+ )))
1446
}
1447
__ExpressionOrSuperTag::JSXElement => {
1545
- let node: Box<JSXElement> = <Box<
1546
- JSXElement,
1547
- > as Deserialize>::deserialize(
1448
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1449
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1450
)?;
1451
Ok(ExpressionOrSuper::Expression(Expression::JSXElement(node)))
1452
}
1453
__ExpressionOrSuperTag::Super => {
1553
- let node: Box<Super> = <Box<
1554
- Super,
1555
- > as Deserialize>::deserialize(
1454
+ let node: Box<Super> = <Box<Super> as Deserialize>::deserialize(
1455
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1456
)?;
1457
Ok(ExpressionOrSuper::Super(node))
@@ -1596,179 +1495,172 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
1495
{
1496
let tagged = serde::Deserializer::deserialize_any(
1497
deserializer,
1599
- serde::__private::de::TaggedContentVisitor::<
1600
- __ExpressionOrSpreadTag,
1601
- >::new("type", "Pattern"),
1498
+ serde::__private::de::TaggedContentVisitor::<__ExpressionOrSpreadTag>::new(
1499
+ "type", "Pattern",
1500
+ ),
1501
)?;
1502
match tagged.0 {
1503
__ExpressionOrSpreadTag::ArrayExpression => {
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)))
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
+ )))
1511
}
1512
__ExpressionOrSpreadTag::ArrowFunctionExpression => {
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
- )
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
+ ))
1520
}
1521
__ExpressionOrSpreadTag::AssignmentExpression => {
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
- )
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
+ ))
1529
}
1530
__ExpressionOrSpreadTag::BinaryExpression => {
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)))
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
+ ))
1538
}
1539
__ExpressionOrSpreadTag::CallExpression => {
1645
- let node: Box<CallExpression> = <Box<
1646
- CallExpression,
1647
- > as Deserialize>::deserialize(
1540
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1541
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1542
)?;
1650
- Ok(ExpressionOrSpread::Expression(Expression::CallExpression(node)))
1543
+ Ok(ExpressionOrSpread::Expression(Expression::CallExpression(
1544
+ node,
1545
+ )))
1546
}
1547
__ExpressionOrSpreadTag::ConditionalExpression => {
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
- )
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
+ ))
1555
}
1556
__ExpressionOrSpreadTag::FunctionExpression => {
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)))
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
+ ))
1564
}
1565
__ExpressionOrSpreadTag::Identifier => {
1673
- let node: Box<Identifier> = <Box<
1674
- Identifier,
1675
- > as Deserialize>::deserialize(
1566
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1567
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1568
)?;
1569
Ok(ExpressionOrSpread::Expression(Expression::Identifier(node)))
1570
}
1571
__ExpressionOrSpreadTag::Literal => {
1681
- let node: Box<Literal> = <Box<
1682
- Literal,
1683
- > as Deserialize>::deserialize(
1572
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1573
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1574
)?;
1575
Ok(ExpressionOrSpread::Expression(Expression::Literal(node)))
1576
}
1577
__ExpressionOrSpreadTag::LogicalExpression => {
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)))
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
+ ))
1585
}
1586
__ExpressionOrSpreadTag::MemberExpression => {
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)))
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
+ ))
1594
}
1595
__ExpressionOrSpreadTag::NewExpression => {
1705
- let node: Box<NewExpression> = <Box<
1706
- NewExpression,
1707
- > as Deserialize>::deserialize(
1596
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
1597
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1598
)?;
1710
- Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node)))
1599
+ Ok(ExpressionOrSpread::Expression(Expression::NewExpression(
1600
+ node,
1601
+ )))
1602
}
1603
__ExpressionOrSpreadTag::ObjectExpression => {
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)))
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
+ ))
1611
}
1612
__ExpressionOrSpreadTag::SequenceExpression => {
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)))
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
+ ))
1620
}
1621
__ExpressionOrSpreadTag::ThisExpression => {
1729
- let node: Box<ThisExpression> = <Box<
1730
- ThisExpression,
1731
- > as Deserialize>::deserialize(
1622
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1623
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1624
)?;
1734
- Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(node)))
1625
+ Ok(ExpressionOrSpread::Expression(Expression::ThisExpression(
1626
+ node,
1627
+ )))
1628
}
1629
__ExpressionOrSpreadTag::UnaryExpression => {
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)))
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
+ )))
1637
}
1638
__ExpressionOrSpreadTag::UpdateExpression => {
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)))
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
+ ))
1646
}
1647
__ExpressionOrSpreadTag::YieldExpression => {
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)))
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
+ )))
1655
}
1656
__ExpressionOrSpreadTag::JSXElement => {
1761
- let node: Box<JSXElement> = <Box<
1762
- JSXElement,
1763
- > as Deserialize>::deserialize(
1657
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1658
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1659
)?;
1660
Ok(ExpressionOrSpread::Expression(Expression::JSXElement(node)))
1661
}
1662
__ExpressionOrSpreadTag::SpreadElement => {
1769
- let node: Box<SpreadElement> = <Box<
1770
- SpreadElement,
1771
- > as Deserialize>::deserialize(
1663
+ let node: Box<SpreadElement> = <Box<SpreadElement> as Deserialize>::deserialize(
1664
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1665
)?;
1666
Ok(ExpressionOrSpread::SpreadElement(node))
@@ -1812,167 +1704,150 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
1704
{
1705
let tagged = serde::Deserializer::deserialize_any(
1706
deserializer,
1815
- serde::__private::de::TaggedContentVisitor::<
1816
- __FunctionBodyTag,
1817
- >::new("type", "Pattern"),
1707
+ serde::__private::de::TaggedContentVisitor::<__FunctionBodyTag>::new("type", "Pattern"),
1708
)?;
1709
match tagged.0 {
1710
__FunctionBodyTag::BlockStatement => {
1821
- let node: Box<BlockStatement> = <Box<
1822
- BlockStatement,
1823
- > as Deserialize>::deserialize(
1711
+ let node: Box<BlockStatement> = <Box<BlockStatement> as Deserialize>::deserialize(
1712
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1713
)?;
1714
Ok(FunctionBody::BlockStatement(node))
1715
}
1716
__FunctionBodyTag::ArrayExpression => {
1829
- let node: Box<ArrayExpression> = <Box<
1830
- ArrayExpression,
1831
- > as Deserialize>::deserialize(
1832
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1833
- )?;
1717
+ let node: Box<ArrayExpression> =
1718
+ <Box<ArrayExpression> as Deserialize>::deserialize(
1719
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1720
+ )?;
1721
Ok(FunctionBody::Expression(Expression::ArrayExpression(node)))
1722
}
1723
__FunctionBodyTag::ArrowFunctionExpression => {
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)))
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
+ ))
1731
}
1732
__FunctionBodyTag::AssignmentExpression => {
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)))
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
+ )))
1740
}
1741
__FunctionBodyTag::BinaryExpression => {
1853
- let node: Box<BinaryExpression> = <Box<
1854
- BinaryExpression,
1855
- > as Deserialize>::deserialize(
1856
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1857
- )?;
1742
+ let node: Box<BinaryExpression> =
1743
+ <Box<BinaryExpression> as Deserialize>::deserialize(
1744
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1745
+ )?;
1746
Ok(FunctionBody::Expression(Expression::BinaryExpression(node)))
1747
}
1748
__FunctionBodyTag::CallExpression => {
1861
- let node: Box<CallExpression> = <Box<
1862
- CallExpression,
1863
- > as Deserialize>::deserialize(
1749
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1750
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1751
)?;
1752
Ok(FunctionBody::Expression(Expression::CallExpression(node)))
1753
}
1754
__FunctionBodyTag::ConditionalExpression => {
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)))
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
+ )))
1762
}
1763
__FunctionBodyTag::FunctionExpression => {
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)))
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
+ )))
1771
}
1772
__FunctionBodyTag::Identifier => {
1885
- let node: Box<Identifier> = <Box<
1886
- Identifier,
1887
- > as Deserialize>::deserialize(
1773
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1774
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1775
)?;
1776
Ok(FunctionBody::Expression(Expression::Identifier(node)))
1777
}
1778
__FunctionBodyTag::Literal => {
1893
- let node: Box<Literal> = <Box<
1894
- Literal,
1895
- > as Deserialize>::deserialize(
1779
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1780
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1781
)?;
1782
Ok(FunctionBody::Expression(Expression::Literal(node)))
1783
}
1784
__FunctionBodyTag::LogicalExpression => {
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)))
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
+ )))
1792
}
1793
__FunctionBodyTag::MemberExpression => {
1909
- let node: Box<MemberExpression> = <Box<
1910
- MemberExpression,
1911
- > as Deserialize>::deserialize(
1912
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1913
- )?;
1794
+ let node: Box<MemberExpression> =
1795
+ <Box<MemberExpression> as Deserialize>::deserialize(
1796
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1797
+ )?;
1798
Ok(FunctionBody::Expression(Expression::MemberExpression(node)))
1799
}
1800
__FunctionBodyTag::NewExpression => {
1917
- let node: Box<NewExpression> = <Box<
1918
- NewExpression,
1919
- > as Deserialize>::deserialize(
1801
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
1802
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1803
)?;
1804
Ok(FunctionBody::Expression(Expression::NewExpression(node)))
1805
}
1806
__FunctionBodyTag::ObjectExpression => {
1925
- let node: Box<ObjectExpression> = <Box<
1926
- ObjectExpression,
1927
- > as Deserialize>::deserialize(
1928
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1929
- )?;
1807
+ let node: Box<ObjectExpression> =
1808
+ <Box<ObjectExpression> as Deserialize>::deserialize(
1809
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1810
+ )?;
1811
Ok(FunctionBody::Expression(Expression::ObjectExpression(node)))
1812
}
1813
__FunctionBodyTag::SequenceExpression => {
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)))
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
+ )))
1821
}
1822
__FunctionBodyTag::ThisExpression => {
1941
- let node: Box<ThisExpression> = <Box<
1942
- ThisExpression,
1943
- > as Deserialize>::deserialize(
1823
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
1824
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1825
)?;
1826
Ok(FunctionBody::Expression(Expression::ThisExpression(node)))
1827
}
1828
__FunctionBodyTag::UnaryExpression => {
1949
- let node: Box<UnaryExpression> = <Box<
1950
- UnaryExpression,
1951
- > as Deserialize>::deserialize(
1952
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1953
- )?;
1829
+ let node: Box<UnaryExpression> =
1830
+ <Box<UnaryExpression> as Deserialize>::deserialize(
1831
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1832
+ )?;
1833
Ok(FunctionBody::Expression(Expression::UnaryExpression(node)))
1834
}
1835
__FunctionBodyTag::UpdateExpression => {
1957
- let node: Box<UpdateExpression> = <Box<
1958
- UpdateExpression,
1959
- > as Deserialize>::deserialize(
1960
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1961
- )?;
1836
+ let node: Box<UpdateExpression> =
1837
+ <Box<UpdateExpression> as Deserialize>::deserialize(
1838
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1839
+ )?;
1840
Ok(FunctionBody::Expression(Expression::UpdateExpression(node)))
1841
}
1842
__FunctionBodyTag::YieldExpression => {
1965
- let node: Box<YieldExpression> = <Box<
1966
- YieldExpression,
1967
- > as Deserialize>::deserialize(
1968
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1969
- )?;
1843
+ let node: Box<YieldExpression> =
1844
+ <Box<YieldExpression> as Deserialize>::deserialize(
1845
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1846
+ )?;
1847
Ok(FunctionBody::Expression(Expression::YieldExpression(node)))
1848
}
1849
__FunctionBodyTag::JSXElement => {
1973
- let node: Box<JSXElement> = <Box<
1974
- JSXElement,
1975
- > as Deserialize>::deserialize(
1850
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
1851
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1852
)?;
1853
Ok(FunctionBody::Expression(Expression::JSXElement(node)))
@@ -1996,15 +1871,11 @@ impl<'de> serde::Deserialize<'de> for Pattern {
1871
{
1872
let tagged = serde::Deserializer::deserialize_any(
1873
deserializer,
1999
- serde::__private::de::TaggedContentVisitor::<
2000
- __PatternTag,
2001
- >::new("type", "Pattern"),
1874
+ serde::__private::de::TaggedContentVisitor::<__PatternTag>::new("type", "Pattern"),
1875
)?;
1876
match tagged.0 {
1877
__PatternTag::Identifier => {
2005
- let node: Box<Identifier> = <Box<
2006
- Identifier,
2007
- > as Deserialize>::deserialize(
1878
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1879
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1880
)?;
1881
Ok(Pattern::Identifier(node))
@@ -2048,169 +1919,143 @@ impl<'de> serde::Deserialize<'de> for ForInit {
1919
{
1920
let tagged = serde::Deserializer::deserialize_any(
1921
deserializer,
2051
- serde::__private::de::TaggedContentVisitor::<
2052
- __ForInitTag,
2053
- >::new("type", "Pattern"),
1922
+ serde::__private::de::TaggedContentVisitor::<__ForInitTag>::new("type", "Pattern"),
1923
)?;
1924
match tagged.0 {
1925
__ForInitTag::ArrayExpression => {
2057
- let node: Box<ArrayExpression> = <Box<
2058
- ArrayExpression,
2059
- > as Deserialize>::deserialize(
2060
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2061
- )?;
1926
+ let node: Box<ArrayExpression> =
1927
+ <Box<ArrayExpression> as Deserialize>::deserialize(
1928
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1929
+ )?;
1930
Ok(ForInit::Expression(Expression::ArrayExpression(node)))
1931
}
1932
__ForInitTag::ArrowFunctionExpression => {
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)))
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
+ )))
1940
}
1941
__ForInitTag::AssignmentExpression => {
2073
- let node: Box<AssignmentExpression> = <Box<
2074
- AssignmentExpression,
2075
- > as Deserialize>::deserialize(
2076
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2077
- )?;
1942
+ let node: Box<AssignmentExpression> =
1943
+ <Box<AssignmentExpression> as Deserialize>::deserialize(
1944
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1945
+ )?;
1946
Ok(ForInit::Expression(Expression::AssignmentExpression(node)))
1947
}
1948
__ForInitTag::BinaryExpression => {
2081
- let node: Box<BinaryExpression> = <Box<
2082
- BinaryExpression,
2083
- > as Deserialize>::deserialize(
2084
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2085
- )?;
1949
+ let node: Box<BinaryExpression> =
1950
+ <Box<BinaryExpression> as Deserialize>::deserialize(
1951
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1952
+ )?;
1953
Ok(ForInit::Expression(Expression::BinaryExpression(node)))
1954
}
1955
__ForInitTag::CallExpression => {
2089
- let node: Box<CallExpression> = <Box<
2090
- CallExpression,
2091
- > as Deserialize>::deserialize(
1956
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
1957
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1958
)?;
1959
Ok(ForInit::Expression(Expression::CallExpression(node)))
1960
}
1961
__ForInitTag::ConditionalExpression => {
2097
- let node: Box<ConditionalExpression> = <Box<
2098
- ConditionalExpression,
2099
- > as Deserialize>::deserialize(
2100
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2101
- )?;
1962
+ let node: Box<ConditionalExpression> =
1963
+ <Box<ConditionalExpression> as Deserialize>::deserialize(
1964
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1965
+ )?;
1966
Ok(ForInit::Expression(Expression::ConditionalExpression(node)))
1967
}
1968
__ForInitTag::FunctionExpression => {
2105
- let node: Box<FunctionExpression> = <Box<
2106
- FunctionExpression,
2107
- > as Deserialize>::deserialize(
2108
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2109
- )?;
1969
+ let node: Box<FunctionExpression> =
1970
+ <Box<FunctionExpression> as Deserialize>::deserialize(
1971
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1972
+ )?;
1973
Ok(ForInit::Expression(Expression::FunctionExpression(node)))
1974
}
1975
__ForInitTag::Identifier => {
2113
- let node: Box<Identifier> = <Box<
2114
- Identifier,
2115
- > as Deserialize>::deserialize(
1976
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
1977
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1978
)?;
1979
Ok(ForInit::Expression(Expression::Identifier(node)))
1980
}
1981
__ForInitTag::Literal => {
2121
- let node: Box<Literal> = <Box<
2122
- Literal,
2123
- > as Deserialize>::deserialize(
1982
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
1983
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1984
)?;
1985
Ok(ForInit::Expression(Expression::Literal(node)))
1986
}
1987
__ForInitTag::LogicalExpression => {
2129
- let node: Box<LogicalExpression> = <Box<
2130
- LogicalExpression,
2131
- > as Deserialize>::deserialize(
2132
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2133
- )?;
1988
+ let node: Box<LogicalExpression> =
1989
+ <Box<LogicalExpression> as Deserialize>::deserialize(
1990
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1991
+ )?;
1992
Ok(ForInit::Expression(Expression::LogicalExpression(node)))
1993
}
1994
__ForInitTag::MemberExpression => {
2137
- let node: Box<MemberExpression> = <Box<
2138
- MemberExpression,
2139
- > as Deserialize>::deserialize(
2140
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2141
- )?;
1995
+ let node: Box<MemberExpression> =
1996
+ <Box<MemberExpression> as Deserialize>::deserialize(
1997
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
1998
+ )?;
1999
Ok(ForInit::Expression(Expression::MemberExpression(node)))
2000
}
2001
__ForInitTag::NewExpression => {
2145
- let node: Box<NewExpression> = <Box<
2146
- NewExpression,
2147
- > as Deserialize>::deserialize(
2002
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
2003
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2004
)?;
2005
Ok(ForInit::Expression(Expression::NewExpression(node)))
2006
}
2007
__ForInitTag::ObjectExpression => {
2153
- let node: Box<ObjectExpression> = <Box<
2154
- ObjectExpression,
2155
- > as Deserialize>::deserialize(
2156
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2157
- )?;
2008
+ let node: Box<ObjectExpression> =
2009
+ <Box<ObjectExpression> as Deserialize>::deserialize(
2010
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2011
+ )?;
2012
Ok(ForInit::Expression(Expression::ObjectExpression(node)))
2013
}
2014
__ForInitTag::SequenceExpression => {
2161
- let node: Box<SequenceExpression> = <Box<
2162
- SequenceExpression,
2163
- > as Deserialize>::deserialize(
2164
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2165
- )?;
2015
+ let node: Box<SequenceExpression> =
2016
+ <Box<SequenceExpression> as Deserialize>::deserialize(
2017
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2018
+ )?;
2019
Ok(ForInit::Expression(Expression::SequenceExpression(node)))
2020
}
2021
__ForInitTag::ThisExpression => {
2169
- let node: Box<ThisExpression> = <Box<
2170
- ThisExpression,
2171
- > as Deserialize>::deserialize(
2022
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
2023
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2024
)?;
2025
Ok(ForInit::Expression(Expression::ThisExpression(node)))
2026
}
2027
__ForInitTag::UnaryExpression => {
2177
- let node: Box<UnaryExpression> = <Box<
2178
- UnaryExpression,
2179
- > as Deserialize>::deserialize(
2180
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2181
- )?;
2028
+ let node: Box<UnaryExpression> =
2029
+ <Box<UnaryExpression> as Deserialize>::deserialize(
2030
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2031
+ )?;
2032
Ok(ForInit::Expression(Expression::UnaryExpression(node)))
2033
}
2034
__ForInitTag::UpdateExpression => {
2185
- let node: Box<UpdateExpression> = <Box<
2186
- UpdateExpression,
2187
- > as Deserialize>::deserialize(
2188
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2189
- )?;
2035
+ let node: Box<UpdateExpression> =
2036
+ <Box<UpdateExpression> as Deserialize>::deserialize(
2037
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2038
+ )?;
2039
Ok(ForInit::Expression(Expression::UpdateExpression(node)))
2040
}
2041
__ForInitTag::YieldExpression => {
2193
- let node: Box<YieldExpression> = <Box<
2194
- YieldExpression,
2195
- > as Deserialize>::deserialize(
2196
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2197
- )?;
2042
+ let node: Box<YieldExpression> =
2043
+ <Box<YieldExpression> as Deserialize>::deserialize(
2044
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2045
+ )?;
2046
Ok(ForInit::Expression(Expression::YieldExpression(node)))
2047
}
2048
__ForInitTag::JSXElement => {
2201
- let node: Box<JSXElement> = <Box<
2202
- JSXElement,
2203
- > as Deserialize>::deserialize(
2049
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2050
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2051
)?;
2052
Ok(ForInit::Expression(Expression::JSXElement(node)))
2053
}
2054
__ForInitTag::VariableDeclaration => {
2209
- let node: Box<VariableDeclaration> = <Box<
2210
- VariableDeclaration,
2211
- > as Deserialize>::deserialize(
2212
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2213
- )?;
2055
+ let node: Box<VariableDeclaration> =
2056
+ <Box<VariableDeclaration> as Deserialize>::deserialize(
2057
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2058
+ )?;
2059
Ok(ForInit::VariableDeclaration(node))
2060
}
2061
}
@@ -2234,25 +2079,20 @@ impl<'de> serde::Deserialize<'de> for ForInInit {
2079
{
2080
let tagged = serde::Deserializer::deserialize_any(
2081
deserializer,
2237
- serde::__private::de::TaggedContentVisitor::<
2238
- __ForInInitTag,
2239
- >::new("type", "Pattern"),
2082
+ serde::__private::de::TaggedContentVisitor::<__ForInInitTag>::new("type", "Pattern"),
2083
)?;
2084
match tagged.0 {
2085
__ForInInitTag::Identifier => {
2243
- let node: Box<Identifier> = <Box<
2244
- Identifier,
2245
- > as Deserialize>::deserialize(
2086
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2087
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2088
)?;
2089
Ok(ForInInit::Pattern(Pattern::Identifier(node)))
2090
}
2091
__ForInInitTag::VariableDeclaration => {
2251
- let node: Box<VariableDeclaration> = <Box<
2252
- VariableDeclaration,
2253
- > as Deserialize>::deserialize(
2254
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2255
- )?;
2092
+ let node: Box<VariableDeclaration> =
2093
+ <Box<VariableDeclaration> as Deserialize>::deserialize(
2094
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2095
+ )?;
2096
Ok(ForInInit::VariableDeclaration(node))
2097
}
2098
}
@@ -2276,23 +2116,17 @@ impl<'de> serde::Deserialize<'de> for PropertyKey {
2116
{
2117
let tagged = serde::Deserializer::deserialize_any(
2118
deserializer,
2279
- serde::__private::de::TaggedContentVisitor::<
2280
- __PropertyKeyTag,
2281
- >::new("type", "Pattern"),
2119
+ serde::__private::de::TaggedContentVisitor::<__PropertyKeyTag>::new("type", "Pattern"),
2120
)?;
2121
match tagged.0 {
2122
__PropertyKeyTag::Identifier => {
2285
- let node: Box<Identifier> = <Box<
2286
- Identifier,
2287
- > as Deserialize>::deserialize(
2123
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2124
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2125
)?;
2126
Ok(PropertyKey::Identifier(node))
2127
}
2128
__PropertyKeyTag::Literal => {
2293
- let node: Box<Literal> = <Box<
2294
- Literal,
2295
- > as Deserialize>::deserialize(
2129
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2130
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2131
)?;
2132
Ok(PropertyKey::Literal(node))
@@ -2335,163 +2169,166 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
2169
{
2170
let tagged = serde::Deserializer::deserialize_any(
2171
deserializer,
2338
- serde::__private::de::TaggedContentVisitor::<
2339
- __AssignmentTargetTag,
2340
- >::new("type", "Pattern"),
2172
+ serde::__private::de::TaggedContentVisitor::<__AssignmentTargetTag>::new(
2173
+ "type", "Pattern",
2174
+ ),
2175
)?;
2176
match tagged.0 {
2177
__AssignmentTargetTag::ArrayExpression => {
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)))
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
+ )))
2185
}
2186
__AssignmentTargetTag::ArrowFunctionExpression => {
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
- )
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
+ ))
2194
}
2195
__AssignmentTargetTag::AssignmentExpression => {
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)))
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
+ ))
2203
}
2204
__AssignmentTargetTag::BinaryExpression => {
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)))
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
+ )))
2212
}
2213
__AssignmentTargetTag::CallExpression => {
2380
- let node: Box<CallExpression> = <Box<
2381
- CallExpression,
2382
- > as Deserialize>::deserialize(
2214
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
2215
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2216
)?;
2385
- Ok(AssignmentTarget::Expression(Expression::CallExpression(node)))
2217
+ Ok(AssignmentTarget::Expression(Expression::CallExpression(
2218
+ node,
2219
+ )))
2220
}
2221
__AssignmentTargetTag::ConditionalExpression => {
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)))
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
+ ))
2229
}
2230
__AssignmentTargetTag::FunctionExpression => {
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)))
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
+ ))
2238
}
2239
__AssignmentTargetTag::Identifier => {
2404
- let node: Box<Identifier> = <Box<
2405
- Identifier,
2406
- > as Deserialize>::deserialize(
2240
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2241
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2242
)?;
2243
Ok(AssignmentTarget::Expression(Expression::Identifier(node)))
2244
}
2245
__AssignmentTargetTag::Literal => {
2412
- let node: Box<Literal> = <Box<
2413
- Literal,
2414
- > as Deserialize>::deserialize(
2246
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2247
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2248
)?;
2249
Ok(AssignmentTarget::Expression(Expression::Literal(node)))
2250
}
2251
__AssignmentTargetTag::LogicalExpression => {
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)))
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
+ )))
2259
}
2260
__AssignmentTargetTag::MemberExpression => {
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)))
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
+ )))
2268
}
2269
__AssignmentTargetTag::NewExpression => {
2436
- let node: Box<NewExpression> = <Box<
2437
- NewExpression,
2438
- > as Deserialize>::deserialize(
2270
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
2271
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2272
)?;
2441
- Ok(AssignmentTarget::Expression(Expression::NewExpression(node)))
2273
+ Ok(AssignmentTarget::Expression(Expression::NewExpression(
2274
+ node,
2275
+ )))
2276
}
2277
__AssignmentTargetTag::ObjectExpression => {
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)))
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
+ )))
2285
}
2286
__AssignmentTargetTag::SequenceExpression => {
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)))
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
+ ))
2294
}
2295
__AssignmentTargetTag::ThisExpression => {
2460
- let node: Box<ThisExpression> = <Box<
2461
- ThisExpression,
2462
- > as Deserialize>::deserialize(
2296
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
2297
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2298
)?;
2465
- Ok(AssignmentTarget::Expression(Expression::ThisExpression(node)))
2299
+ Ok(AssignmentTarget::Expression(Expression::ThisExpression(
2300
+ node,
2301
+ )))
2302
}
2303
__AssignmentTargetTag::UnaryExpression => {
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)))
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
+ )))
2311
}
2312
__AssignmentTargetTag::UpdateExpression => {
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)))
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
+ )))
2320
}
2321
__AssignmentTargetTag::YieldExpression => {
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)))
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
+ )))
2329
}
2330
__AssignmentTargetTag::JSXElement => {
2492
- let node: Box<JSXElement> = <Box<
2493
- JSXElement,
2494
- > as Deserialize>::deserialize(
2331
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2332
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2333
)?;
2334
Ok(AssignmentTarget::Expression(Expression::JSXElement(node)))
@@ -2517,23 +2354,20 @@ impl<'de> serde::Deserialize<'de> for JSXMemberExpressionOrIdentifier {
2354
{
2355
let tagged = serde::Deserializer::deserialize_any(
2356
deserializer,
2520
- serde::__private::de::TaggedContentVisitor::<
2521
- __JSXMemberExpressionOrIdentifierTag,
2522
- >::new("type", "Pattern"),
2357
+ serde::__private::de::TaggedContentVisitor::<__JSXMemberExpressionOrIdentifierTag>::new(
2358
+ "type", "Pattern",
2359
+ ),
2360
)?;
2361
match tagged.0 {
2362
__JSXMemberExpressionOrIdentifierTag::JSXMemberExpression => {
2526
- let node: Box<JSXMemberExpression> = <Box<
2527
- JSXMemberExpression,
2528
- > as Deserialize>::deserialize(
2529
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2530
- )?;
2363
+ let node: Box<JSXMemberExpression> =
2364
+ <Box<JSXMemberExpression> as Deserialize>::deserialize(
2365
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2366
+ )?;
2367
Ok(JSXMemberExpressionOrIdentifier::JSXMemberExpression(node))
2368
}
2369
__JSXMemberExpressionOrIdentifierTag::JSXIdentifier => {
2534
- let node: Box<JSXIdentifier> = <Box<
2535
- JSXIdentifier,
2536
- > as Deserialize>::deserialize(
2370
+ let node: Box<JSXIdentifier> = <Box<JSXIdentifier> as Deserialize>::deserialize(
2371
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2372
)?;
2373
Ok(JSXMemberExpressionOrIdentifier::JSXIdentifier(node))
@@ -2577,189 +2411,179 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
2411
{
2412
let tagged = serde::Deserializer::deserialize_any(
2413
deserializer,
2580
- serde::__private::de::TaggedContentVisitor::<
2581
- __JSXExpressionOrEmptyTag,
2582
- >::new("type", "Pattern"),
2414
+ serde::__private::de::TaggedContentVisitor::<__JSXExpressionOrEmptyTag>::new(
2415
+ "type", "Pattern",
2416
+ ),
2417
)?;
2418
match tagged.0 {
2419
__JSXExpressionOrEmptyTag::ArrayExpression => {
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)))
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
+ ))
2427
}
2428
__JSXExpressionOrEmptyTag::ArrowFunctionExpression => {
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
- )
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
+ ))
2436
}
2437
__JSXExpressionOrEmptyTag::AssignmentExpression => {
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
- )
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
+ ))
2445
}
2446
__JSXExpressionOrEmptyTag::BinaryExpression => {
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)))
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
+ ))
2454
}
2455
__JSXExpressionOrEmptyTag::CallExpression => {
2626
- let node: Box<CallExpression> = <Box<
2627
- CallExpression,
2628
- > as Deserialize>::deserialize(
2456
+ let node: Box<CallExpression> = <Box<CallExpression> as Deserialize>::deserialize(
2457
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2458
)?;
2631
- Ok(JSXExpressionOrEmpty::Expression(Expression::CallExpression(node)))
2459
+ Ok(JSXExpressionOrEmpty::Expression(
2460
+ Expression::CallExpression(node),
2461
+ ))
2462
}
2463
__JSXExpressionOrEmptyTag::ConditionalExpression => {
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
- )
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
+ ))
2471
}
2472
__JSXExpressionOrEmptyTag::FunctionExpression => {
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
- )
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
+ ))
2480
}
2481
__JSXExpressionOrEmptyTag::Identifier => {
2658
- let node: Box<Identifier> = <Box<
2659
- Identifier,
2660
- > as Deserialize>::deserialize(
2482
+ let node: Box<Identifier> = <Box<Identifier> as Deserialize>::deserialize(
2483
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2484
)?;
2663
- Ok(JSXExpressionOrEmpty::Expression(Expression::Identifier(node)))
2485
+ Ok(JSXExpressionOrEmpty::Expression(Expression::Identifier(
2486
+ node,
2487
+ )))
2488
}
2489
__JSXExpressionOrEmptyTag::Literal => {
2666
- let node: Box<Literal> = <Box<
2667
- Literal,
2668
- > as Deserialize>::deserialize(
2490
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2491
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2492
)?;
2493
Ok(JSXExpressionOrEmpty::Expression(Expression::Literal(node)))
2494
}
2495
__JSXExpressionOrEmptyTag::LogicalExpression => {
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)))
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
+ ))
2503
}
2504
__JSXExpressionOrEmptyTag::MemberExpression => {
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)))
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
+ ))
2512
}
2513
__JSXExpressionOrEmptyTag::NewExpression => {
2690
- let node: Box<NewExpression> = <Box<
2691
- NewExpression,
2692
- > as Deserialize>::deserialize(
2514
+ let node: Box<NewExpression> = <Box<NewExpression> as Deserialize>::deserialize(
2515
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2516
)?;
2695
- Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(node)))
2517
+ Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(
2518
+ node,
2519
+ )))
2520
}
2521
__JSXExpressionOrEmptyTag::ObjectExpression => {
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)))
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
+ ))
2529
}
2530
__JSXExpressionOrEmptyTag::SequenceExpression => {
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
- )
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
+ ))
2538
}
2539
__JSXExpressionOrEmptyTag::ThisExpression => {
2718
- let node: Box<ThisExpression> = <Box<
2719
- ThisExpression,
2720
- > as Deserialize>::deserialize(
2540
+ let node: Box<ThisExpression> = <Box<ThisExpression> as Deserialize>::deserialize(
2541
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2542
)?;
2723
- Ok(JSXExpressionOrEmpty::Expression(Expression::ThisExpression(node)))
2543
+ Ok(JSXExpressionOrEmpty::Expression(
2544
+ Expression::ThisExpression(node),
2545
+ ))
2546
}
2547
__JSXExpressionOrEmptyTag::UnaryExpression => {
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)))
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
+ ))
2555
}
2556
__JSXExpressionOrEmptyTag::UpdateExpression => {
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)))
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
+ ))
2564
}
2565
__JSXExpressionOrEmptyTag::YieldExpression => {
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)))
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
+ ))
2573
}
2574
__JSXExpressionOrEmptyTag::JSXElement => {
2750
- let node: Box<JSXElement> = <Box<
2751
- JSXElement,
2752
- > as Deserialize>::deserialize(
2575
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2576
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2577
)?;
2755
- Ok(JSXExpressionOrEmpty::Expression(Expression::JSXElement(node)))
2578
+ Ok(JSXExpressionOrEmpty::Expression(Expression::JSXElement(
2579
+ node,
2580
+ )))
2581
}
2582
__JSXExpressionOrEmptyTag::JSXEmptyExpression => {
2758
- let node: Box<JSXEmptyExpression> = <Box<
2759
- JSXEmptyExpression,
2760
- > as Deserialize>::deserialize(
2761
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2762
- )?;
2583
+ let node: Box<JSXEmptyExpression> =
2584
+ <Box<JSXEmptyExpression> as Deserialize>::deserialize(
2585
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2586
+ )?;
2587
Ok(JSXExpressionOrEmpty::JSXEmptyExpression(node))
2588
}
2589
}
@@ -2783,25 +2607,22 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeOrSpread {
2607
{
2608
let tagged = serde::Deserializer::deserialize_any(
2609
deserializer,
2786
- serde::__private::de::TaggedContentVisitor::<
2787
- __JSXAttributeOrSpreadTag,
2788
- >::new("type", "Pattern"),
2610
+ serde::__private::de::TaggedContentVisitor::<__JSXAttributeOrSpreadTag>::new(
2611
+ "type", "Pattern",
2612
+ ),
2613
)?;
2614
match tagged.0 {
2615
__JSXAttributeOrSpreadTag::JSXAttribute => {
2792
- let node: Box<JSXAttribute> = <Box<
2793
- JSXAttribute,
2794
- > as Deserialize>::deserialize(
2616
+ let node: Box<JSXAttribute> = <Box<JSXAttribute> as Deserialize>::deserialize(
2617
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2618
)?;
2619
Ok(JSXAttributeOrSpread::JSXAttribute(node))
2620
}
2621
__JSXAttributeOrSpreadTag::JSXSpreadAttribute => {
2800
- let node: Box<JSXSpreadAttribute> = <Box<
2801
- JSXSpreadAttribute,
2802
- > as Deserialize>::deserialize(
2803
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2804
- )?;
2622
+ let node: Box<JSXSpreadAttribute> =
2623
+ <Box<JSXSpreadAttribute> as Deserialize>::deserialize(
2624
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2625
+ )?;
2626
Ok(JSXAttributeOrSpread::JSXSpreadAttribute(node))
2627
}
2628
}
@@ -2829,39 +2650,32 @@ impl<'de> serde::Deserialize<'de> for JSXAttributeValue {
2650
{
2651
let tagged = serde::Deserializer::deserialize_any(
2652
deserializer,
2832
- serde::__private::de::TaggedContentVisitor::<
2833
- __JSXAttributeValueTag,
2834
- >::new("type", "Pattern"),
2653
+ serde::__private::de::TaggedContentVisitor::<__JSXAttributeValueTag>::new(
2654
+ "type", "Pattern",
2655
+ ),
2656
)?;
2657
match tagged.0 {
2658
__JSXAttributeValueTag::Literal => {
2838
- let node: Box<Literal> = <Box<
2839
- Literal,
2840
- > as Deserialize>::deserialize(
2659
+ let node: Box<Literal> = <Box<Literal> as Deserialize>::deserialize(
2660
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2661
)?;
2662
Ok(JSXAttributeValue::Literal(node))
2663
}
2664
__JSXAttributeValueTag::JSXExpressionContainer => {
2846
- let node: Box<JSXExpressionContainer> = <Box<
2847
- JSXExpressionContainer,
2848
- > as Deserialize>::deserialize(
2849
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2850
- )?;
2665
+ let node: Box<JSXExpressionContainer> =
2666
+ <Box<JSXExpressionContainer> as Deserialize>::deserialize(
2667
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2668
+ )?;
2669
Ok(JSXAttributeValue::JSXExpressionContainer(node))
2670
}
2671
__JSXAttributeValueTag::JSXElement => {
2854
- let node: Box<JSXElement> = <Box<
2855
- JSXElement,
2856
- > as Deserialize>::deserialize(
2672
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2673
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2674
)?;
2675
Ok(JSXAttributeValue::JSXElement(node))
2676
}
2677
__JSXAttributeValueTag::JSXFragment => {
2862
- let node: Box<JSXFragment> = <Box<
2863
- JSXFragment,
2864
- > as Deserialize>::deserialize(
2678
+ let node: Box<JSXFragment> = <Box<JSXFragment> as Deserialize>::deserialize(
2679
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2680
)?;
2681
Ok(JSXAttributeValue::JSXFragment(node))
@@ -2889,33 +2703,29 @@ impl<'de> serde::Deserialize<'de> for JSXElementName {
2703
{
2704
let tagged = serde::Deserializer::deserialize_any(
2705
deserializer,
2892
- serde::__private::de::TaggedContentVisitor::<
2893
- __JSXElementNameTag,
2894
- >::new("type", "Pattern"),
2706
+ serde::__private::de::TaggedContentVisitor::<__JSXElementNameTag>::new(
2707
+ "type", "Pattern",
2708
+ ),
2709
)?;
2710
match tagged.0 {
2711
__JSXElementNameTag::JSXIdentifier => {
2898
- let node: Box<JSXIdentifier> = <Box<
2899
- JSXIdentifier,
2900
- > as Deserialize>::deserialize(
2712
+ let node: Box<JSXIdentifier> = <Box<JSXIdentifier> as Deserialize>::deserialize(
2713
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2714
)?;
2715
Ok(JSXElementName::JSXIdentifier(node))
2716
}
2717
__JSXElementNameTag::JSXMemberExpression => {
2906
- let node: Box<JSXMemberExpression> = <Box<
2907
- JSXMemberExpression,
2908
- > as Deserialize>::deserialize(
2909
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2910
- )?;
2718
+ let node: Box<JSXMemberExpression> =
2719
+ <Box<JSXMemberExpression> as Deserialize>::deserialize(
2720
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2721
+ )?;
2722
Ok(JSXElementName::JSXMemberExpression(node))
2723
}
2724
__JSXElementNameTag::JSXNamespacedName => {
2914
- let node: Box<JSXNamespacedName> = <Box<
2915
- JSXNamespacedName,
2916
- > as Deserialize>::deserialize(
2917
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2918
- )?;
2725
+ let node: Box<JSXNamespacedName> =
2726
+ <Box<JSXNamespacedName> as Deserialize>::deserialize(
2727
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2728
+ )?;
2729
Ok(JSXElementName::JSXNamespacedName(node))
2730
}
2731
}
@@ -2939,25 +2749,22 @@ impl<'de> serde::Deserialize<'de> for JSXIdentifierOrNamespacedName {
2749
{
2750
let tagged = serde::Deserializer::deserialize_any(
2751
deserializer,
2942
- serde::__private::de::TaggedContentVisitor::<
2943
- __JSXIdentifierOrNamespacedNameTag,
2944
- >::new("type", "Pattern"),
2752
+ serde::__private::de::TaggedContentVisitor::<__JSXIdentifierOrNamespacedNameTag>::new(
2753
+ "type", "Pattern",
2754
+ ),
2755
)?;
2756
match tagged.0 {
2757
__JSXIdentifierOrNamespacedNameTag::JSXIdentifier => {
2948
- let node: Box<JSXIdentifier> = <Box<
2949
- JSXIdentifier,
2950
- > as Deserialize>::deserialize(
2758
+ let node: Box<JSXIdentifier> = <Box<JSXIdentifier> as Deserialize>::deserialize(
2759
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2760
)?;
2761
Ok(JSXIdentifierOrNamespacedName::JSXIdentifier(node))
2762
}
2763
__JSXIdentifierOrNamespacedNameTag::JSXNamespacedName => {
2956
- let node: Box<JSXNamespacedName> = <Box<
2957
- JSXNamespacedName,
2958
- > as Deserialize>::deserialize(
2959
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2960
- )?;
2764
+ let node: Box<JSXNamespacedName> =
2765
+ <Box<JSXNamespacedName> as Deserialize>::deserialize(
2766
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2767
+ )?;
2768
Ok(JSXIdentifierOrNamespacedName::JSXNamespacedName(node))
2769
}
2770
}
@@ -2987,47 +2794,36 @@ impl<'de> serde::Deserialize<'de> for JSXChildItem {
2794
{
2795
let tagged = serde::Deserializer::deserialize_any(
2796
deserializer,
2990
- serde::__private::de::TaggedContentVisitor::<
2991
- __JSXChildItemTag,
2992
- >::new("type", "Pattern"),
2797
+ serde::__private::de::TaggedContentVisitor::<__JSXChildItemTag>::new("type", "Pattern"),
2798
)?;
2799
match tagged.0 {
2800
__JSXChildItemTag::JSXText => {
2996
- let node: Box<JSXText> = <Box<
2997
- JSXText,
2998
- > as Deserialize>::deserialize(
2801
+ let node: Box<JSXText> = <Box<JSXText> as Deserialize>::deserialize(
2802
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2803
)?;
2804
Ok(JSXChildItem::JSXText(node))
2805
}
2806
__JSXChildItemTag::JSXExpressionContainer => {
3004
- let node: Box<JSXExpressionContainer> = <Box<
3005
- JSXExpressionContainer,
3006
- > as Deserialize>::deserialize(
3007
- serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3008
- )?;
2807
+ let node: Box<JSXExpressionContainer> =
2808
+ <Box<JSXExpressionContainer> as Deserialize>::deserialize(
2809
+ serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2810
+ )?;
2811
Ok(JSXChildItem::JSXExpressionContainer(node))
2812
}
2813
__JSXChildItemTag::JSXSpreadChild => {
3012
- let node: Box<JSXSpreadChild> = <Box<
3013
- JSXSpreadChild,
3014
- > as Deserialize>::deserialize(
2814
+ let node: Box<JSXSpreadChild> = <Box<JSXSpreadChild> as Deserialize>::deserialize(
2815
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2816
)?;
2817
Ok(JSXChildItem::JSXSpreadChild(node))
2818
}
2819
__JSXChildItemTag::JSXElement => {
3020
- let node: Box<JSXElement> = <Box<
3021
- JSXElement,
3022
- > as Deserialize>::deserialize(
2820
+ let node: Box<JSXElement> = <Box<JSXElement> as Deserialize>::deserialize(
2821
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2822
)?;
2823
Ok(JSXChildItem::JSXElement(node))
2824
}
2825
__JSXChildItemTag::JSXFragment => {
3028
- let node: Box<JSXFragment> = <Box<
3029
- JSXFragment,
3030
- > as Deserialize>::deserialize(
2826
+ let node: Box<JSXFragment> = <Box<JSXFragment> as Deserialize>::deserialize(
2827
serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2828
)?;
2829
Ok(JSXChildItem::JSXFragment(node))
compiler/forget/crates/forget_estree/src/js_value.rs
+14
-2
@@ -1,4 +1,5 @@
1
-use serde::{de::Visitor, Deserialize, Serialize};
1
+use serde::de::Visitor;
2
+use serde::{Deserialize, Serialize};
3
4
#[derive(Serialize, Clone, Debug, PartialEq, PartialOrd, Hash)]
5
pub enum JsValue {
@@ -9,7 +10,18 @@ pub enum JsValue {
10
String(String),
11
}
12
12
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Debug)]
13
+#[derive(
14
+ Clone,
15
+ Copy,
16
+ PartialEq,
17
+ Eq,
18
+ PartialOrd,
19
+ Ord,
20
+ Hash,
21
+ Serialize,
22
+ Deserialize,
23
+ Debug
24
+)]
25
pub struct Number(u64);
26
27
impl From<u32> for Number {
compiler/forget/crates/forget_estree/src/lib.rs
+2
-1
@@ -13,10 +13,11 @@ pub use visit::*;
13
14
#[cfg(test)]
15
mod tests {
16
- use super::*;
16
use insta::{assert_snapshot, glob};
17
use serde_json;
18
19
+ use super::*;
20
+
21
#[test]
22
fn fixtures() {
23
glob!("fixtures/**.json", |path| {
compiler/forget/crates/forget_estree/src/range.rs
+10
-1
@@ -2,7 +2,16 @@ use std::num::NonZeroU32;
2
3
use serde::{Deserialize, Serialize};
4
5
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, PartialOrd, Hash)]
5
+#[derive(
6
+ Serialize,
7
+ Deserialize,
8
+ Copy,
9
+ Clone,
10
+ Debug,
11
+ PartialEq,
12
+ PartialOrd,
13
+ Hash
14
+)]
15
pub struct SourceRange {
16
pub start: u32,
17
pub end: NonZeroU32,
compiler/forget/crates/forget_estree_codegen/src/codegen.rs
+2
-1
@@ -1,7 +1,8 @@
1
use std::collections::HashSet;
2
3
use indexmap::IndexMap;
4
-use quote::{__private::TokenStream, format_ident, quote};
4
+use quote::__private::TokenStream;
5
+use quote::{format_ident, quote};
6
use serde::{Deserialize, Serialize};
7
use syn::Type;
8
compiler/forget/crates/forget_estree_swc/src/lib.rs
+18
-15
@@ -1,4 +1,6 @@
1
-use std::{io::stderr, num::NonZeroU32, sync::Arc};
1
+use std::io::stderr;
2
+use std::num::NonZeroU32;
3
+use std::sync::Arc;
4
5
use forget_estree::{Binding, BindingId};
6
use swc::Compiler;
@@ -412,21 +414,22 @@ fn convert_assignment_target(cx: &Context, target: &PatOrExpr) -> forget_estree:
414
PatOrExpr::Pat(target) => {
415
forget_estree::AssignmentTarget::Pattern(convert_pattern(cx, target))
416
}
415
- PatOrExpr::Expr(target) => {
416
- match target.as_ref() {
417
- Expr::Member(target) => forget_estree::AssignmentTarget::Expression(
418
- forget_estree::Expression::MemberExpression(Box::new(
419
- convert_member_expression(cx, target),
420
- )),
421
- ),
422
- Expr::Ident(target) => forget_estree::AssignmentTarget::Pattern(
423
- forget_estree::Pattern::Identifier(Box::new(convert_identifier(cx, target))),
424
- ),
425
- _ => {
426
- panic!("Expected assignment target to be member expression or identifier, got {:#?}", target)
427
- }
417
+ PatOrExpr::Expr(target) => match target.as_ref() {
418
+ Expr::Member(target) => forget_estree::AssignmentTarget::Expression(
419
+ forget_estree::Expression::MemberExpression(Box::new(convert_member_expression(
420
+ cx, target,
421
+ ))),
422
+ ),
423
+ Expr::Ident(target) => forget_estree::AssignmentTarget::Pattern(
424
+ forget_estree::Pattern::Identifier(Box::new(convert_identifier(cx, target))),
425
+ ),
426
+ _ => {
427
+ panic!(
428
+ "Expected assignment target to be member expression or identifier, got {:#?}",
429
+ target
430
+ )
431
}
429
- }
432
+ },
433
}
434
}
435
compiler/forget/crates/forget_fixtures/tests/fixtures_test.rs
+2
-1
@@ -1,4 +1,5 @@
1
-use std::{env, fmt::Write};
1
+use std::env;
2
+use std::fmt::Write;
3
4
use bumpalo::Bump;
5
use forget_build_hir::build;
compiler/forget/crates/forget_hir/src/basic_block.rs
+2
-1
@@ -2,7 +2,8 @@ use std::fmt::Display;
2
3
use indexmap::{IndexMap, IndexSet};
4
5
-use crate::{id_types::BlockId, Identifier, InstrIx, Terminal};
5
+use crate::id_types::BlockId;
6
+use crate::{Identifier, InstrIx, Terminal};
7
8
/// Represents a sequence of instructions that will always[1] execute
9
/// consecutively. Concretely, a block may have zero or more instructions
compiler/forget/crates/forget_hir/src/environment.rs
+6
-6
@@ -1,10 +1,10 @@
1
-use std::{
2
- cell::{Cell, RefCell},
3
- collections::HashMap,
4
- rc::Rc,
5
-};
1
+use std::cell::{Cell, RefCell};
2
+use std::collections::HashMap;
3
+use std::rc::Rc;
4
7
-use bumpalo::{boxed::Box, collections::Vec, Bump};
5
+use bumpalo::boxed::Box;
6
+use bumpalo::collections::Vec;
7
+use bumpalo::Bump;
8
use forget_estree::BindingId;
9
10
use crate::{
compiler/forget/crates/forget_hir/src/function.rs
+2
-4
@@ -1,7 +1,5 @@
1
-use bumpalo::{
2
- boxed::Box,
3
- collections::{String, Vec},
4
-};
1
+use bumpalo::boxed::Box;
2
+use bumpalo::collections::{String, Vec};
3
use indexmap::IndexMap;
4
5
use crate::{BasicBlock, BlockId, IdentifierOperand, Instruction};
compiler/forget/crates/forget_hir/src/instruction.rs
+5
-5
@@ -1,9 +1,9 @@
1
-use std::{cell::RefCell, fmt::Display, rc::Rc};
1
+use std::cell::RefCell;
2
+use std::fmt::Display;
3
+use std::rc::Rc;
4
3
-use bumpalo::{
4
- boxed::Box,
5
- collections::{String, Vec},
6
-};
5
+use bumpalo::boxed::Box;
6
+use bumpalo::collections::{String, Vec};
7
use forget_estree::BinaryOperator;
8
9
use crate::{Function, IdentifierId, InstrIx, InstructionId, ScopeId, Type};
compiler/forget/crates/forget_hir/src/terminal.rs
+2
-1
@@ -1,4 +1,5 @@
1
-use crate::{instruction::Operand, BlockId, InstructionId};
1
+use crate::instruction::Operand;
2
+use crate::{BlockId, InstructionId};
3
4
/// Terminals represent statements or expressions that affect control flow,
5
/// such as for-of, if-else, return, logical (??), ternaries (?:), etc.
compiler/forget/crates/forget_ssa/src/enter.rs
+6
-2
@@ -1,4 +1,5 @@
1
-use std::{cell::RefCell, rc::Rc};
1
+use std::cell::RefCell;
2
+use std::rc::Rc;
3
4
use bumpalo::collections::{CollectIn, Vec};
5
use forget_hir::{
@@ -145,7 +146,10 @@ impl<'a, 'e, 'f> Builder<'a, 'e, 'f> {
146
fn visit_store(&mut self, lvalue: &mut LValue<'a>) -> () {
147
let old_identifier = &lvalue.identifier.identifier;
148
// TODO: use Result (?)
148
- assert!(!self.unknown.contains(&old_identifier.id), "EnterSSA: Expected identifier to be defined before being used. Identifier {old_identifier:?} is undefined.");
149
+ assert!(
150
+ !self.unknown.contains(&old_identifier.id),
151
+ "EnterSSA: Expected identifier to be defined before being used. Identifier {old_identifier:?} is undefined."
152
+ );
153
154
if self.context.contains(&old_identifier.id) {
155
let new_identifier = self.get_id_at(self.current, old_identifier);
compiler/forget/rustfmt.toml
new
+8
@@ -0,0 +1,8 @@
1
+# Get help on options with `rustfmt --help=config`
2
+# Please keep these in alphabetical order.
3
+edition = "2021"
4
+group_imports = "StdExternalCrate"
5
+imports_granularity = "Module"
6
+merge_derives = false
7
+use_field_init_shorthand = true
8
+version = "Two"
\ No newline at end of file