@samitouri / QOS-React-1 / commits / e353f3702e

[rust][wip] Codegen conversion from HermesParser (C++)

Joe Savona committed Aug 1, 2023 at 13:55 UTC e353f3702eeae21a18f508886f1983d8c19cdb58
15 files changed +4311 -187
compiler/forget/Cargo.lock
+1
@@ -528,6 +528,7 @@ version = "0.1.0"
528 dependencies = [
529 "forget_diagnostics",
530 "forget_estree",
531 + "forget_estree_codegen",
532 "hermes",
533 "juno_support",
534 ]
compiler/forget/crates/forget_build_hir/src/context.rs
+4
@@ -65,4 +65,8 @@ impl<'ast> Visitor<'ast> for ContextVisitor<'ast> {
65 _ => {}
66 }
67 }
68 +
69 + fn visit_literal(&mut self, _literal: &'ast forget_estree::Literal) {
70 + // no-op
71 + }
72 }
compiler/forget/crates/forget_estree/src/generated.rs
+424 -40
@@ -3,7 +3,7 @@
3 use std::num::NonZeroU32;
4 use serde::ser::{Serializer, SerializeMap};
5 use serde::{Serialize, Deserialize};
6 -use crate::{JsValue, Binding, SourceRange};
6 +use crate::{JsValue, Binding, SourceRange, Number};
7 #[derive(Serialize, Deserialize, Clone, Debug)]
8 #[serde(deny_unknown_fields)]
9 pub struct SourceLocation {
@@ -19,6 +19,14 @@ pub struct Position {
19 }
20 #[derive(Serialize, Deserialize, Clone, Debug)]
21 #[serde(deny_unknown_fields)]
22 +pub struct Class {
23 + pub id: Option<Identifier>,
24 + #[serde(rename = "superClass")]
25 + pub super_class: Option<Expression>,
26 + pub body: ClassBody,
27 +}
28 +#[derive(Serialize, Deserialize, Clone, Debug)]
29 +#[serde(deny_unknown_fields)]
30 pub struct Function {
31 pub id: Option<Identifier>,
32 pub params: Vec<Pattern>,
@@ -101,6 +109,88 @@ impl Serialize for Literal {
109 }
110 }
111 #[derive(Deserialize, Clone, Debug)]
112 +pub struct NumericLiteral {
113 + pub value: Number,
114 + #[serde(default)]
115 + pub loc: Option<SourceLocation>,
116 + #[serde(default)]
117 + pub range: Option<SourceRange>,
118 +}
119 +impl Serialize for NumericLiteral {
120 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
121 + where
122 + S: Serializer,
123 + {
124 + let mut state = serializer.serialize_map(None)?;
125 + state.serialize_entry("type", "NumericLiteral")?;
126 + state.serialize_entry("value", &self.value)?;
127 + state.serialize_entry("loc", &self.loc)?;
128 + state.serialize_entry("range", &self.range)?;
129 + state.end()
130 + }
131 +}
132 +#[derive(Deserialize, Clone, Debug)]
133 +pub struct BooleanLiteral {
134 + pub value: bool,
135 + #[serde(default)]
136 + pub loc: Option<SourceLocation>,
137 + #[serde(default)]
138 + pub range: Option<SourceRange>,
139 +}
140 +impl Serialize for BooleanLiteral {
141 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
142 + where
143 + S: Serializer,
144 + {
145 + let mut state = serializer.serialize_map(None)?;
146 + state.serialize_entry("type", "BooleanLiteral")?;
147 + state.serialize_entry("value", &self.value)?;
148 + state.serialize_entry("loc", &self.loc)?;
149 + state.serialize_entry("range", &self.range)?;
150 + state.end()
151 + }
152 +}
153 +#[derive(Deserialize, Clone, Debug)]
154 +pub struct NullLiteral {
155 + #[serde(default)]
156 + pub loc: Option<SourceLocation>,
157 + #[serde(default)]
158 + pub range: Option<SourceRange>,
159 +}
160 +impl Serialize for NullLiteral {
161 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
162 + where
163 + S: Serializer,
164 + {
165 + let mut state = serializer.serialize_map(None)?;
166 + state.serialize_entry("type", "NullLiteral")?;
167 + state.serialize_entry("loc", &self.loc)?;
168 + state.serialize_entry("range", &self.range)?;
169 + state.end()
170 + }
171 +}
172 +#[derive(Deserialize, Clone, Debug)]
173 +pub struct StringLiteral {
174 + pub value: String,
175 + #[serde(default)]
176 + pub loc: Option<SourceLocation>,
177 + #[serde(default)]
178 + pub range: Option<SourceRange>,
179 +}
180 +impl Serialize for StringLiteral {
181 + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
182 + where
183 + S: Serializer,
184 + {
185 + let mut state = serializer.serialize_map(None)?;
186 + state.serialize_entry("type", "StringLiteral")?;
187 + state.serialize_entry("value", &self.value)?;
188 + state.serialize_entry("loc", &self.loc)?;
189 + state.serialize_entry("range", &self.range)?;
190 + state.end()
191 + }
192 +}
193 +#[derive(Deserialize, Clone, Debug)]
194 pub struct Program {
195 pub body: Vec<ModuleItem>,
196 #[serde(rename = "sourceType")]
@@ -610,32 +700,6 @@ impl Serialize for FunctionDeclaration {
700 }
701 }
702 #[derive(Deserialize, Clone, Debug)]
613 -pub struct Class {
614 - pub id: Option<Identifier>,
615 - #[serde(rename = "superClass")]
616 - pub super_class: Option<Expression>,
617 - pub body: ClassBody,
618 - #[serde(default)]
619 - pub loc: Option<SourceLocation>,
620 - #[serde(default)]
621 - pub range: Option<SourceRange>,
622 -}
623 -impl Serialize for Class {
624 - fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
625 - where
626 - S: Serializer,
627 - {
628 - let mut state = serializer.serialize_map(None)?;
629 - state.serialize_entry("type", "Class")?;
630 - state.serialize_entry("id", &self.id)?;
631 - state.serialize_entry("superClass", &self.super_class)?;
632 - state.serialize_entry("body", &self.body)?;
633 - state.serialize_entry("loc", &self.loc)?;
634 - state.serialize_entry("range", &self.range)?;
635 - state.end()
636 - }
637 -}
638 -#[derive(Deserialize, Clone, Debug)]
703 pub struct ClassDeclaration {
704 #[serde(flatten)]
705 pub class: Class,
@@ -1062,9 +1126,6 @@ pub struct MemberExpression {
1126 pub property: Expression,
1127 #[serde(rename = "computed")]
1128 pub is_computed: bool,
1065 - #[serde(rename = "optional")]
1066 - #[serde(default)]
1067 - pub is_optional: bool,
1129 #[serde(default)]
1130 pub loc: Option<SourceLocation>,
1131 #[serde(default)]
@@ -1080,7 +1141,6 @@ impl Serialize for MemberExpression {
1141 state.serialize_entry("object", &self.object)?;
1142 state.serialize_entry("property", &self.property)?;
1143 state.serialize_entry("computed", &self.is_computed)?;
1083 - state.serialize_entry("optional", &self.is_optional)?;
1144 state.serialize_entry("loc", &self.loc)?;
1145 state.serialize_entry("range", &self.range)?;
1146 state.end()
@@ -1115,9 +1175,6 @@ impl Serialize for ConditionalExpression {
1175 pub struct CallExpression {
1176 pub callee: ExpressionOrSuper,
1177 pub arguments: Vec<ExpressionOrSpread>,
1118 - #[serde(rename = "optional")]
1119 - #[serde(default)]
1120 - pub is_optional: bool,
1178 #[serde(default)]
1179 pub loc: Option<SourceLocation>,
1180 #[serde(default)]
@@ -1132,7 +1189,6 @@ impl Serialize for CallExpression {
1189 state.serialize_entry("type", "CallExpression")?;
1190 state.serialize_entry("callee", &self.callee)?;
1191 state.serialize_entry("arguments", &self.arguments)?;
1135 - state.serialize_entry("optional", &self.is_optional)?;
1192 state.serialize_entry("loc", &self.loc)?;
1193 state.serialize_entry("range", &self.range)?;
1194 state.end()
@@ -1250,7 +1306,7 @@ impl Serialize for YieldExpression {
1306 #[derive(Deserialize, Clone, Debug)]
1307 pub struct ImportDeclaration {
1308 pub specifiers: Vec<ImportDeclarationSpecifier>,
1253 - pub source: Literal,
1309 + pub source: _Literal,
1310 #[serde(default)]
1311 pub loc: Option<SourceLocation>,
1312 #[serde(default)]
@@ -1339,7 +1395,7 @@ impl Serialize for ImportNamespaceSpecifier {
1395 pub struct ExportNamedDeclaration {
1396 pub declaration: Option<Declaration>,
1397 pub specifiers: Vec<ExportSpecifier>,
1342 - pub source: Option<Literal>,
1398 + pub source: Option<_Literal>,
1399 #[serde(default)]
1400 pub loc: Option<SourceLocation>,
1401 #[serde(default)]
@@ -1404,7 +1460,7 @@ impl Serialize for ExportDefaultDeclaration {
1460 }
1461 #[derive(Deserialize, Clone, Debug)]
1462 pub struct ExportAllDeclaration {
1407 - pub source: Literal,
1463 + pub source: _Literal,
1464 #[serde(default)]
1465 pub exported: Option<Identifier>,
1466 #[serde(default)]
@@ -1704,7 +1760,7 @@ pub struct JSXFragment {
1760 pub opening_fragment: JSXOpeningFragment,
1761 pub children: Vec<JSXChildItem>,
1762 #[serde(rename = "closingFragment")]
1707 - pub closing_fragment: Option<JSXClosingFragment>,
1763 + pub closing_fragment: JSXClosingFragment,
1764 #[serde(default)]
1765 pub loc: Option<SourceLocation>,
1766 #[serde(default)]
@@ -2013,7 +2069,7 @@ impl Serialize for ChainExpression {
2069 #[derive(Deserialize, Clone, Debug)]
2070 pub struct OptionalMemberExpression {
2071 pub object: Expression,
2016 - pub property: Identifier,
2072 + pub property: Expression,
2073 #[serde(rename = "computed")]
2074 pub is_computed: bool,
2075 #[serde(rename = "optional")]
@@ -2328,6 +2384,7 @@ pub enum Expression {
2384 AssignmentExpression(Box<AssignmentExpression>),
2385 AwaitExpression(Box<AwaitExpression>),
2386 BinaryExpression(Box<BinaryExpression>),
2387 + BooleanLiteral(Box<BooleanLiteral>),
2388 CallExpression(Box<CallExpression>),
2389 ChainExpression(Box<ChainExpression>),
2390 ClassExpression(Box<ClassExpression>),
@@ -2341,10 +2398,13 @@ pub enum Expression {
2398 MemberExpression(Box<MemberExpression>),
2399 MetaProperty(Box<MetaProperty>),
2400 NewExpression(Box<NewExpression>),
2401 + NullLiteral(Box<NullLiteral>),
2402 + NumericLiteral(Box<NumericLiteral>),
2403 ObjectExpression(Box<ObjectExpression>),
2404 OptionalCallExpression(Box<OptionalCallExpression>),
2405 OptionalMemberExpression(Box<OptionalMemberExpression>),
2406 SequenceExpression(Box<SequenceExpression>),
2407 + StringLiteral(Box<StringLiteral>),
2408 TaggedTemplateExpression(Box<TaggedTemplateExpression>),
2409 TemplateLiteral(Box<TemplateLiteral>),
2410 ThisExpression(Box<ThisExpression>),
@@ -2359,6 +2419,7 @@ enum __ExpressionTag {
2419 AssignmentExpression,
2420 AwaitExpression,
2421 BinaryExpression,
2422 + BooleanLiteral,
2423 CallExpression,
2424 ChainExpression,
2425 ClassExpression,
@@ -2372,10 +2433,13 @@ enum __ExpressionTag {
2433 MemberExpression,
2434 MetaProperty,
2435 NewExpression,
2436 + NullLiteral,
2437 + NumericLiteral,
2438 ObjectExpression,
2439 OptionalCallExpression,
2440 OptionalMemberExpression,
2441 SequenceExpression,
2442 + StringLiteral,
2443 TaggedTemplateExpression,
2444 TemplateLiteral,
2445 ThisExpression,
@@ -2435,6 +2499,14 @@ impl<'de> serde::Deserialize<'de> for Expression {
2499 )?;
2500 Ok(Expression::BinaryExpression(node))
2501 }
2502 + __ExpressionTag::BooleanLiteral => {
2503 + let node: Box<BooleanLiteral> = <Box<
2504 + BooleanLiteral,
2505 + > as Deserialize>::deserialize(
2506 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2507 + )?;
2508 + Ok(Expression::BooleanLiteral(node))
2509 + }
2510 __ExpressionTag::CallExpression => {
2511 let node: Box<CallExpression> = <Box<
2512 CallExpression,
@@ -2539,6 +2611,22 @@ impl<'de> serde::Deserialize<'de> for Expression {
2611 )?;
2612 Ok(Expression::NewExpression(node))
2613 }
2614 + __ExpressionTag::NullLiteral => {
2615 + let node: Box<NullLiteral> = <Box<
2616 + NullLiteral,
2617 + > as Deserialize>::deserialize(
2618 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2619 + )?;
2620 + Ok(Expression::NullLiteral(node))
2621 + }
2622 + __ExpressionTag::NumericLiteral => {
2623 + let node: Box<NumericLiteral> = <Box<
2624 + NumericLiteral,
2625 + > as Deserialize>::deserialize(
2626 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2627 + )?;
2628 + Ok(Expression::NumericLiteral(node))
2629 + }
2630 __ExpressionTag::ObjectExpression => {
2631 let node: Box<ObjectExpression> = <Box<
2632 ObjectExpression,
@@ -2571,6 +2659,14 @@ impl<'de> serde::Deserialize<'de> for Expression {
2659 )?;
2660 Ok(Expression::SequenceExpression(node))
2661 }
2662 + __ExpressionTag::StringLiteral => {
2663 + let node: Box<StringLiteral> = <Box<
2664 + StringLiteral,
2665 + > as Deserialize>::deserialize(
2666 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2667 + )?;
2668 + Ok(Expression::StringLiteral(node))
2669 + }
2670 __ExpressionTag::TaggedTemplateExpression => {
2671 let node: Box<TaggedTemplateExpression> = <Box<
2672 TaggedTemplateExpression,
@@ -2624,6 +2720,78 @@ impl<'de> serde::Deserialize<'de> for Expression {
2720 }
2721 #[derive(Serialize, Clone, Debug)]
2722 #[serde(untagged)]
2723 +pub enum _Literal {
2724 + BooleanLiteral(Box<BooleanLiteral>),
2725 + Literal(Box<Literal>),
2726 + NullLiteral(Box<NullLiteral>),
2727 + NumericLiteral(Box<NumericLiteral>),
2728 + StringLiteral(Box<StringLiteral>),
2729 +}
2730 +#[derive(Deserialize, Debug)]
2731 +enum ___LiteralTag {
2732 + Literal,
2733 + BooleanLiteral,
2734 + NullLiteral,
2735 + StringLiteral,
2736 + NumericLiteral,
2737 +}
2738 +impl<'de> serde::Deserialize<'de> for _Literal {
2739 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2740 + where
2741 + D: serde::Deserializer<'de>,
2742 + {
2743 + let tagged = serde::Deserializer::deserialize_any(
2744 + deserializer,
2745 + serde::__private::de::TaggedContentVisitor::<
2746 + ___LiteralTag,
2747 + >::new("type", "_Literal"),
2748 + )?;
2749 + match tagged.0 {
2750 + ___LiteralTag::Literal => {
2751 + let node: Box<Literal> = <Box<
2752 + Literal,
2753 + > as Deserialize>::deserialize(
2754 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2755 + )?;
2756 + Ok(_Literal::Literal(node))
2757 + }
2758 + ___LiteralTag::BooleanLiteral => {
2759 + let node: Box<BooleanLiteral> = <Box<
2760 + BooleanLiteral,
2761 + > as Deserialize>::deserialize(
2762 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2763 + )?;
2764 + Ok(_Literal::BooleanLiteral(node))
2765 + }
2766 + ___LiteralTag::NullLiteral => {
2767 + let node: Box<NullLiteral> = <Box<
2768 + NullLiteral,
2769 + > as Deserialize>::deserialize(
2770 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2771 + )?;
2772 + Ok(_Literal::NullLiteral(node))
2773 + }
2774 + ___LiteralTag::StringLiteral => {
2775 + let node: Box<StringLiteral> = <Box<
2776 + StringLiteral,
2777 + > as Deserialize>::deserialize(
2778 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2779 + )?;
2780 + Ok(_Literal::StringLiteral(node))
2781 + }
2782 + ___LiteralTag::NumericLiteral => {
2783 + let node: Box<NumericLiteral> = <Box<
2784 + NumericLiteral,
2785 + > as Deserialize>::deserialize(
2786 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
2787 + )?;
2788 + Ok(_Literal::NumericLiteral(node))
2789 + }
2790 + }
2791 + }
2792 +}
2793 +#[derive(Serialize, Clone, Debug)]
2794 +#[serde(untagged)]
2795 pub enum Declaration {
2796 ClassDeclaration(Box<ClassDeclaration>),
2797 FunctionDeclaration(Box<FunctionDeclaration>),
@@ -3066,6 +3234,7 @@ enum __ExpressionOrSuperTag {
3234 AssignmentExpression,
3235 AwaitExpression,
3236 BinaryExpression,
3237 + BooleanLiteral,
3238 CallExpression,
3239 ChainExpression,
3240 ClassExpression,
@@ -3079,10 +3248,13 @@ enum __ExpressionOrSuperTag {
3248 MemberExpression,
3249 MetaProperty,
3250 NewExpression,
3251 + NullLiteral,
3252 + NumericLiteral,
3253 ObjectExpression,
3254 OptionalCallExpression,
3255 OptionalMemberExpression,
3256 SequenceExpression,
3257 + StringLiteral,
3258 TaggedTemplateExpression,
3259 TemplateLiteral,
3260 ThisExpression,
@@ -3147,6 +3319,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
3319 )?;
3320 Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(node)))
3321 }
3322 + __ExpressionOrSuperTag::BooleanLiteral => {
3323 + let node: Box<BooleanLiteral> = <Box<
3324 + BooleanLiteral,
3325 + > as Deserialize>::deserialize(
3326 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3327 + )?;
3328 + Ok(ExpressionOrSuper::Expression(Expression::BooleanLiteral(node)))
3329 + }
3330 __ExpressionOrSuperTag::CallExpression => {
3331 let node: Box<CallExpression> = <Box<
3332 CallExpression,
@@ -3255,6 +3435,22 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
3435 )?;
3436 Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node)))
3437 }
3438 + __ExpressionOrSuperTag::NullLiteral => {
3439 + let node: Box<NullLiteral> = <Box<
3440 + NullLiteral,
3441 + > as Deserialize>::deserialize(
3442 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3443 + )?;
3444 + Ok(ExpressionOrSuper::Expression(Expression::NullLiteral(node)))
3445 + }
3446 + __ExpressionOrSuperTag::NumericLiteral => {
3447 + let node: Box<NumericLiteral> = <Box<
3448 + NumericLiteral,
3449 + > as Deserialize>::deserialize(
3450 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3451 + )?;
3452 + Ok(ExpressionOrSuper::Expression(Expression::NumericLiteral(node)))
3453 + }
3454 __ExpressionOrSuperTag::ObjectExpression => {
3455 let node: Box<ObjectExpression> = <Box<
3456 ObjectExpression,
@@ -3295,6 +3491,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {
3491 )?;
3492 Ok(ExpressionOrSuper::Expression(Expression::SequenceExpression(node)))
3493 }
3494 + __ExpressionOrSuperTag::StringLiteral => {
3495 + let node: Box<StringLiteral> = <Box<
3496 + StringLiteral,
3497 + > as Deserialize>::deserialize(
3498 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3499 + )?;
3500 + Ok(ExpressionOrSuper::Expression(Expression::StringLiteral(node)))
3501 + }
3502 __ExpressionOrSuperTag::TaggedTemplateExpression => {
3503 let node: Box<TaggedTemplateExpression> = <Box<
3504 TaggedTemplateExpression,
@@ -3371,6 +3575,7 @@ enum __ExpressionOrSpreadTag {
3575 AssignmentExpression,
3576 AwaitExpression,
3577 BinaryExpression,
3578 + BooleanLiteral,
3579 CallExpression,
3580 ChainExpression,
3581 ClassExpression,
@@ -3384,10 +3589,13 @@ enum __ExpressionOrSpreadTag {
3589 MemberExpression,
3590 MetaProperty,
3591 NewExpression,
3592 + NullLiteral,
3593 + NumericLiteral,
3594 ObjectExpression,
3595 OptionalCallExpression,
3596 OptionalMemberExpression,
3597 SequenceExpression,
3598 + StringLiteral,
3599 TaggedTemplateExpression,
3600 TemplateLiteral,
3601 ThisExpression,
@@ -3456,6 +3664,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
3664 )?;
3665 Ok(ExpressionOrSpread::Expression(Expression::BinaryExpression(node)))
3666 }
3667 + __ExpressionOrSpreadTag::BooleanLiteral => {
3668 + let node: Box<BooleanLiteral> = <Box<
3669 + BooleanLiteral,
3670 + > as Deserialize>::deserialize(
3671 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3672 + )?;
3673 + Ok(ExpressionOrSpread::Expression(Expression::BooleanLiteral(node)))
3674 + }
3675 __ExpressionOrSpreadTag::CallExpression => {
3676 let node: Box<CallExpression> = <Box<
3677 CallExpression,
@@ -3564,6 +3780,22 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
3780 )?;
3781 Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node)))
3782 }
3783 + __ExpressionOrSpreadTag::NullLiteral => {
3784 + let node: Box<NullLiteral> = <Box<
3785 + NullLiteral,
3786 + > as Deserialize>::deserialize(
3787 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3788 + )?;
3789 + Ok(ExpressionOrSpread::Expression(Expression::NullLiteral(node)))
3790 + }
3791 + __ExpressionOrSpreadTag::NumericLiteral => {
3792 + let node: Box<NumericLiteral> = <Box<
3793 + NumericLiteral,
3794 + > as Deserialize>::deserialize(
3795 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3796 + )?;
3797 + Ok(ExpressionOrSpread::Expression(Expression::NumericLiteral(node)))
3798 + }
3799 __ExpressionOrSpreadTag::ObjectExpression => {
3800 let node: Box<ObjectExpression> = <Box<
3801 ObjectExpression,
@@ -3604,6 +3836,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSpread {
3836 )?;
3837 Ok(ExpressionOrSpread::Expression(Expression::SequenceExpression(node)))
3838 }
3839 + __ExpressionOrSpreadTag::StringLiteral => {
3840 + let node: Box<StringLiteral> = <Box<
3841 + StringLiteral,
3842 + > as Deserialize>::deserialize(
3843 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
3844 + )?;
3845 + Ok(ExpressionOrSpread::Expression(Expression::StringLiteral(node)))
3846 + }
3847 __ExpressionOrSpreadTag::TaggedTemplateExpression => {
3848 let node: Box<TaggedTemplateExpression> = <Box<
3849 TaggedTemplateExpression,
@@ -3681,6 +3921,7 @@ enum __FunctionBodyTag {
3921 AssignmentExpression,
3922 AwaitExpression,
3923 BinaryExpression,
3924 + BooleanLiteral,
3925 CallExpression,
3926 ChainExpression,
3927 ClassExpression,
@@ -3694,10 +3935,13 @@ enum __FunctionBodyTag {
3935 MemberExpression,
3936 MetaProperty,
3937 NewExpression,
3938 + NullLiteral,
3939 + NumericLiteral,
3940 ObjectExpression,
3941 OptionalCallExpression,
3942 OptionalMemberExpression,
3943 SequenceExpression,
3944 + StringLiteral,
3945 TaggedTemplateExpression,
3946 TemplateLiteral,
3947 ThisExpression,
@@ -3765,6 +4009,14 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
4009 )?;
4010 Ok(FunctionBody::Expression(Expression::BinaryExpression(node)))
4011 }
4012 + __FunctionBodyTag::BooleanLiteral => {
4013 + let node: Box<BooleanLiteral> = <Box<
4014 + BooleanLiteral,
4015 + > as Deserialize>::deserialize(
4016 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4017 + )?;
4018 + Ok(FunctionBody::Expression(Expression::BooleanLiteral(node)))
4019 + }
4020 __FunctionBodyTag::CallExpression => {
4021 let node: Box<CallExpression> = <Box<
4022 CallExpression,
@@ -3869,6 +4121,22 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
4121 )?;
4122 Ok(FunctionBody::Expression(Expression::NewExpression(node)))
4123 }
4124 + __FunctionBodyTag::NullLiteral => {
4125 + let node: Box<NullLiteral> = <Box<
4126 + NullLiteral,
4127 + > as Deserialize>::deserialize(
4128 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4129 + )?;
4130 + Ok(FunctionBody::Expression(Expression::NullLiteral(node)))
4131 + }
4132 + __FunctionBodyTag::NumericLiteral => {
4133 + let node: Box<NumericLiteral> = <Box<
4134 + NumericLiteral,
4135 + > as Deserialize>::deserialize(
4136 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4137 + )?;
4138 + Ok(FunctionBody::Expression(Expression::NumericLiteral(node)))
4139 + }
4140 __FunctionBodyTag::ObjectExpression => {
4141 let node: Box<ObjectExpression> = <Box<
4142 ObjectExpression,
@@ -3901,6 +4169,14 @@ impl<'de> serde::Deserialize<'de> for FunctionBody {
4169 )?;
4170 Ok(FunctionBody::Expression(Expression::SequenceExpression(node)))
4171 }
4172 + __FunctionBodyTag::StringLiteral => {
4173 + let node: Box<StringLiteral> = <Box<
4174 + StringLiteral,
4175 + > as Deserialize>::deserialize(
4176 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4177 + )?;
4178 + Ok(FunctionBody::Expression(Expression::StringLiteral(node)))
4179 + }
4180 __FunctionBodyTag::TaggedTemplateExpression => {
4181 let node: Box<TaggedTemplateExpression> = <Box<
4182 TaggedTemplateExpression,
@@ -4037,6 +4313,7 @@ enum __ForInitTag {
4313 AssignmentExpression,
4314 AwaitExpression,
4315 BinaryExpression,
4316 + BooleanLiteral,
4317 CallExpression,
4318 ChainExpression,
4319 ClassExpression,
@@ -4050,10 +4327,13 @@ enum __ForInitTag {
4327 MemberExpression,
4328 MetaProperty,
4329 NewExpression,
4330 + NullLiteral,
4331 + NumericLiteral,
4332 ObjectExpression,
4333 OptionalCallExpression,
4334 OptionalMemberExpression,
4335 SequenceExpression,
4336 + StringLiteral,
4337 TaggedTemplateExpression,
4338 TemplateLiteral,
4339 ThisExpression,
@@ -4114,6 +4394,14 @@ impl<'de> serde::Deserialize<'de> for ForInit {
4394 )?;
4395 Ok(ForInit::Expression(Expression::BinaryExpression(node)))
4396 }
4397 + __ForInitTag::BooleanLiteral => {
4398 + let node: Box<BooleanLiteral> = <Box<
4399 + BooleanLiteral,
4400 + > as Deserialize>::deserialize(
4401 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4402 + )?;
4403 + Ok(ForInit::Expression(Expression::BooleanLiteral(node)))
4404 + }
4405 __ForInitTag::CallExpression => {
4406 let node: Box<CallExpression> = <Box<
4407 CallExpression,
@@ -4218,6 +4506,22 @@ impl<'de> serde::Deserialize<'de> for ForInit {
4506 )?;
4507 Ok(ForInit::Expression(Expression::NewExpression(node)))
4508 }
4509 + __ForInitTag::NullLiteral => {
4510 + let node: Box<NullLiteral> = <Box<
4511 + NullLiteral,
4512 + > as Deserialize>::deserialize(
4513 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4514 + )?;
4515 + Ok(ForInit::Expression(Expression::NullLiteral(node)))
4516 + }
4517 + __ForInitTag::NumericLiteral => {
4518 + let node: Box<NumericLiteral> = <Box<
4519 + NumericLiteral,
4520 + > as Deserialize>::deserialize(
4521 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4522 + )?;
4523 + Ok(ForInit::Expression(Expression::NumericLiteral(node)))
4524 + }
4525 __ForInitTag::ObjectExpression => {
4526 let node: Box<ObjectExpression> = <Box<
4527 ObjectExpression,
@@ -4250,6 +4554,14 @@ impl<'de> serde::Deserialize<'de> for ForInit {
4554 )?;
4555 Ok(ForInit::Expression(Expression::SequenceExpression(node)))
4556 }
4557 + __ForInitTag::StringLiteral => {
4558 + let node: Box<StringLiteral> = <Box<
4559 + StringLiteral,
4560 + > as Deserialize>::deserialize(
4561 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4562 + )?;
4563 + Ok(ForInit::Expression(Expression::StringLiteral(node)))
4564 + }
4565 __ForInitTag::TaggedTemplateExpression => {
4566 let node: Box<TaggedTemplateExpression> = <Box<
4567 TaggedTemplateExpression,
@@ -4526,6 +4838,7 @@ enum __AssignmentTargetTag {
4838 AssignmentExpression,
4839 AwaitExpression,
4840 BinaryExpression,
4841 + BooleanLiteral,
4842 CallExpression,
4843 ChainExpression,
4844 ClassExpression,
@@ -4539,10 +4852,13 @@ enum __AssignmentTargetTag {
4852 MemberExpression,
4853 MetaProperty,
4854 NewExpression,
4855 + NullLiteral,
4856 + NumericLiteral,
4857 ObjectExpression,
4858 OptionalCallExpression,
4859 OptionalMemberExpression,
4860 SequenceExpression,
4861 + StringLiteral,
4862 TaggedTemplateExpression,
4863 TemplateLiteral,
4864 ThisExpression,
@@ -4610,6 +4926,14 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
4926 )?;
4927 Ok(AssignmentTarget::Expression(Expression::BinaryExpression(node)))
4928 }
4929 + __AssignmentTargetTag::BooleanLiteral => {
4930 + let node: Box<BooleanLiteral> = <Box<
4931 + BooleanLiteral,
4932 + > as Deserialize>::deserialize(
4933 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
4934 + )?;
4935 + Ok(AssignmentTarget::Expression(Expression::BooleanLiteral(node)))
4936 + }
4937 __AssignmentTargetTag::CallExpression => {
4938 let node: Box<CallExpression> = <Box<
4939 CallExpression,
@@ -4714,6 +5038,22 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
5038 )?;
5039 Ok(AssignmentTarget::Expression(Expression::NewExpression(node)))
5040 }
5041 + __AssignmentTargetTag::NullLiteral => {
5042 + let node: Box<NullLiteral> = <Box<
5043 + NullLiteral,
5044 + > as Deserialize>::deserialize(
5045 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5046 + )?;
5047 + Ok(AssignmentTarget::Expression(Expression::NullLiteral(node)))
5048 + }
5049 + __AssignmentTargetTag::NumericLiteral => {
5050 + let node: Box<NumericLiteral> = <Box<
5051 + NumericLiteral,
5052 + > as Deserialize>::deserialize(
5053 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5054 + )?;
5055 + Ok(AssignmentTarget::Expression(Expression::NumericLiteral(node)))
5056 + }
5057 __AssignmentTargetTag::ObjectExpression => {
5058 let node: Box<ObjectExpression> = <Box<
5059 ObjectExpression,
@@ -4754,6 +5094,14 @@ impl<'de> serde::Deserialize<'de> for AssignmentTarget {
5094 )?;
5095 Ok(AssignmentTarget::Expression(Expression::SequenceExpression(node)))
5096 }
5097 + __AssignmentTargetTag::StringLiteral => {
5098 + let node: Box<StringLiteral> = <Box<
5099 + StringLiteral,
5100 + > as Deserialize>::deserialize(
5101 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5102 + )?;
5103 + Ok(AssignmentTarget::Expression(Expression::StringLiteral(node)))
5104 + }
5105 __AssignmentTargetTag::TaggedTemplateExpression => {
5106 let node: Box<TaggedTemplateExpression> = <Box<
5107 TaggedTemplateExpression,
@@ -4938,6 +5286,7 @@ enum __JSXExpressionOrEmptyTag {
5286 AssignmentExpression,
5287 AwaitExpression,
5288 BinaryExpression,
5289 + BooleanLiteral,
5290 CallExpression,
5291 ChainExpression,
5292 ClassExpression,
@@ -4951,10 +5300,13 @@ enum __JSXExpressionOrEmptyTag {
5300 MemberExpression,
5301 MetaProperty,
5302 NewExpression,
5303 + NullLiteral,
5304 + NumericLiteral,
5305 ObjectExpression,
5306 OptionalCallExpression,
5307 OptionalMemberExpression,
5308 SequenceExpression,
5309 + StringLiteral,
5310 TaggedTemplateExpression,
5311 TemplateLiteral,
5312 ThisExpression,
@@ -5023,6 +5375,14 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
5375 )?;
5376 Ok(JSXExpressionOrEmpty::Expression(Expression::BinaryExpression(node)))
5377 }
5378 + __JSXExpressionOrEmptyTag::BooleanLiteral => {
5379 + let node: Box<BooleanLiteral> = <Box<
5380 + BooleanLiteral,
5381 + > as Deserialize>::deserialize(
5382 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5383 + )?;
5384 + Ok(JSXExpressionOrEmpty::Expression(Expression::BooleanLiteral(node)))
5385 + }
5386 __JSXExpressionOrEmptyTag::CallExpression => {
5387 let node: Box<CallExpression> = <Box<
5388 CallExpression,
@@ -5135,6 +5495,22 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
5495 )?;
5496 Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(node)))
5497 }
5498 + __JSXExpressionOrEmptyTag::NullLiteral => {
5499 + let node: Box<NullLiteral> = <Box<
5500 + NullLiteral,
5501 + > as Deserialize>::deserialize(
5502 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5503 + )?;
5504 + Ok(JSXExpressionOrEmpty::Expression(Expression::NullLiteral(node)))
5505 + }
5506 + __JSXExpressionOrEmptyTag::NumericLiteral => {
5507 + let node: Box<NumericLiteral> = <Box<
5508 + NumericLiteral,
5509 + > as Deserialize>::deserialize(
5510 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5511 + )?;
5512 + Ok(JSXExpressionOrEmpty::Expression(Expression::NumericLiteral(node)))
5513 + }
5514 __JSXExpressionOrEmptyTag::ObjectExpression => {
5515 let node: Box<ObjectExpression> = <Box<
5516 ObjectExpression,
@@ -5179,6 +5555,14 @@ impl<'de> serde::Deserialize<'de> for JSXExpressionOrEmpty {
5555 ),
5556 )
5557 }
5558 + __JSXExpressionOrEmptyTag::StringLiteral => {
5559 + let node: Box<StringLiteral> = <Box<
5560 + StringLiteral,
5561 + > as Deserialize>::deserialize(
5562 + serde::__private::de::ContentDeserializer::<D::Error>::new(tagged.1),
5563 + )?;
5564 + Ok(JSXExpressionOrEmpty::Expression(Expression::StringLiteral(node)))
5565 + }
5566 __JSXExpressionOrEmptyTag::TaggedTemplateExpression => {
5567 let node: Box<TaggedTemplateExpression> = <Box<
5568 TaggedTemplateExpression,
compiler/forget/crates/forget_estree/src/lib.rs
+1 -1
@@ -7,7 +7,7 @@ mod visit;
7
8 pub use binding::{Binding, BindingId};
9 pub use generated::*;
10 -pub use js_value::JsValue;
10 +pub use js_value::{JsValue, Number};
11 pub use range::SourceRange;
12 pub use visit::*;
13
compiler/forget/crates/forget_estree/src/snapshots/forget_estree__tests__fixtures@simple.json.snap
-1
@@ -286,7 +286,6 @@ Output:
286 }
287 },
288 "computed": false,
289 - "optional": false,
289 "loc": {
290 "source": null,
291 "start": {
compiler/forget/crates/forget_estree/src/visit.rs
+12 -7
@@ -3,7 +3,7 @@ use crate::{
3 ExportDefaultDeclaration, ExportNamedDeclaration, Expression, ExpressionOrSpread,
4 ExpressionOrSuper, ForInInit, ForInit, Function, FunctionBody, Identifier, ImportDeclaration,
5 ImportDeclarationSpecifier, ImportOrExportDeclaration, Literal, MethodDefinition, ModuleItem,
6 - Pattern, Program, Statement, SwitchCase, VariableDeclarator,
6 + Pattern, Program, Statement, SwitchCase, VariableDeclarator, _Literal,
7 };
8
9 /// Trait for visiting an estree
@@ -97,7 +97,7 @@ pub trait Visitor<'ast> {
97 fn visit_import_declaration_specifier(
98 &mut self,
99 specifier: &'ast ImportDeclarationSpecifier,
100 - _source: &'ast Literal,
100 + _source: &'ast _Literal,
101 ) {
102 match specifier {
103 ImportDeclarationSpecifier::ImportSpecifier(specifier) => {
@@ -406,17 +406,22 @@ pub trait Visitor<'ast> {
406
407 fn visit_identifier(&mut self, _identifier: &'ast Identifier) {
408 // nothing to do unless overridden
409 + todo!("Implement visit_identifier()")
410 }
411
411 - fn visit_import_source(&mut self, literal: &'ast Literal) {
412 - self.visit_literal(literal);
412 + fn visit_import_source(&mut self, literal: &'ast _Literal) {
413 + self.visit_any_literal(literal);
414 }
415
415 - fn visit_export_source(&mut self, literal: &'ast Literal) {
416 - self.visit_literal(literal);
416 + fn visit_export_source(&mut self, literal: &'ast _Literal) {
417 + self.visit_any_literal(literal);
418 + }
419 +
420 + fn visit_any_literal(&mut self, _literal: &'ast _Literal) {
421 + todo!("Implement visit_any_literal()")
422 }
423
424 fn visit_literal(&mut self, _literal: &'ast Literal) {
420 - // nothing to do unless overridden
425 + todo!("Implement visit_literal()")
426 }
427 }
compiler/forget/crates/forget_estree_codegen/src/codegen.rs
+306 -1
@@ -20,6 +20,21 @@ pub fn estree() -> String {
20 )
21 }
22
23 +/// Returns prettyplease-formatted Rust source for converting HermesParser results
24 +/// into estree
25 +pub fn estree_hermes() -> String {
26 + let src = include_str!("./ecmascript.json");
27 + let grammar: Grammar = serde_json::from_str(src).unwrap();
28 + let raw = grammar.codegen_hermes().to_string();
29 +
30 + let parsed = syn::parse_file(&raw).unwrap();
31 + format!(
32 + "// {}generated\n#![cfg_attr(rustfmt, rustfmt_skip)]\n{}",
33 + '\u{0040}',
34 + prettyplease::unparse(&parsed)
35 + )
36 +}
37 +
38 #[derive(Serialize, Deserialize, Debug)]
39 #[serde(deny_unknown_fields)]
40 pub struct Grammar {
@@ -59,7 +74,7 @@ impl Grammar {
74 use std::num::NonZeroU32;
75 use serde::ser::{Serializer, SerializeMap};
76 use serde::{Serialize,Deserialize};
62 - use crate::{JsValue, Binding, SourceRange};
77 + use crate::{JsValue, Binding, SourceRange, Number};
78
79 #(#objects)*
80
@@ -70,6 +85,42 @@ impl Grammar {
85 #(#operators)*
86 }
87 }
88 +
89 + pub fn codegen_hermes(self) -> TokenStream {
90 + let nodes: Vec<_> = self
91 + .nodes
92 + .iter()
93 + .filter(|(_, node)| !node.skip_hermes_codegen)
94 + .map(|(name, node)| node.codegen_hermes(name))
95 + .collect();
96 + let enums: Vec<_> = self
97 + .enums
98 + .iter()
99 + .map(|(name, enum_)| enum_.codegen_hermes(name, &self))
100 + .collect();
101 + let operators: Vec<_> = self
102 + .operators
103 + .iter()
104 + .map(|(name, operator)| operator.codegen_hermes(name))
105 + .collect();
106 +
107 + quote! {
108 + #![allow(dead_code)]
109 + #![allow(unused_variables)]
110 +
111 + use forget_estree::*;
112 + use hermes;
113 + use hermes::parser::{NodePtr, NodeKind, NodeLabel };
114 + use hermes::utf::{utf8_with_surrogates_to_string};
115 + use crate::generated_extension::*;
116 +
117 + #(#nodes)*
118 +
119 + #(#enums)*
120 +
121 + #(#operators)*
122 + }
123 + }
124 }
125
126 #[derive(Serialize, Deserialize, Debug)]
@@ -107,6 +158,12 @@ pub struct Node {
158
159 #[serde(default)]
160 pub fields: IndexMap<String, Field>,
161 +
162 + #[serde(default)]
163 + pub skip_hermes_codegen: bool,
164 +
165 + #[serde(default)]
166 + pub skip_hermes_enum_variant: bool,
167 }
168
169 impl Node {
@@ -175,11 +232,108 @@ impl Node {
232 }
233 }
234 }
235 +
236 + pub fn codegen_hermes(&self, name: &str) -> TokenStream {
237 + let name_str = name;
238 + let name = format_ident!("{}", name);
239 + let field_names: Vec<_> = self
240 + .fields
241 + .iter()
242 + .map(|(name, _field)| format_ident!("{}", name))
243 + .collect();
244 + let fields: Vec<_> = self
245 + .fields
246 + .iter()
247 + .map(|(name, field)| {
248 + let (type_name_str, type_kind) = parse_type(&field.type_).unwrap();
249 + let camelcase_name = field.rename.as_ref().unwrap_or(name);
250 + let field_name = format_ident!("{}", name);
251 + let helper = format_ident!("hermes_get_{}_{}", name_str, camelcase_name);
252 + let type_name = format_ident!("{}", type_name_str);
253 + if field.skip || field.hermes_default {
254 + return quote! {
255 + let #field_name = Default::default();
256 + };
257 + }
258 + if let Some(convert_with) = &field.hermes_convert_with {
259 + let convert_with = format_ident!("{}", convert_with);
260 + return quote! {
261 + let #field_name = #convert_with(cx, unsafe { hermes::parser::#helper(node) } );
262 + }
263 + }
264 + match type_kind {
265 + TypeKind::Named => {
266 + match type_name_str.as_ref() {
267 + "bool" => {
268 + quote! {
269 + let #field_name = unsafe { hermes::parser::#helper(node) };
270 + }
271 + }
272 + "Number" => {
273 + quote! {
274 + let #field_name = convert_number(unsafe { hermes::parser::#helper(node) });
275 + }
276 + }
277 + "String" => {
278 + quote! {
279 + let #field_name = convert_string(cx, unsafe { hermes::parser::#helper(node) });
280 + }
281 + }
282 + _ => {
283 + quote! {
284 + let #field_name = #type_name::convert(cx, unsafe { hermes::parser::#helper(node) });
285 + }
286 + }
287 + }
288 + }
289 + TypeKind::Option => {
290 + match type_name_str.as_ref() {
291 + "String" => {
292 + quote! {
293 + let #field_name = convert_option_string(cx, unsafe { hermes::parser::#helper(node) });
294 + }
295 + }
296 + _ => {
297 + quote! {
298 + let #field_name = convert_option(unsafe { hermes::parser::#helper(node) }, |node| #type_name::convert(cx, node));
299 + }
300 + }
301 + }
302 + }
303 + TypeKind::Vec => {
304 + quote! {
305 + let #field_name = convert_vec(unsafe { hermes::parser::#helper(node) }, |node| #type_name::convert(cx, node));
306 + }
307 + }
308 + TypeKind::VecOfOption => {
309 + quote! {
310 + let #field_name = convert_vec_of_option(unsafe { hermes::parser::#helper(node) }, |node| #type_name::convert(cx, node));
311 + }
312 + }
313 + }
314 + })
315 + .collect();
316 +
317 + quote! {
318 + impl FromHermes for #name {
319 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
320 + let range = convert_range(node);
321 + #(#fields)*
322 + Self {
323 + #(#field_names,)*
324 + loc: None,
325 + range: Some(range),
326 + }
327 + }
328 + }
329 + }
330 + }
331 }
332
333 #[derive(Serialize, Deserialize, Debug)]
334 #[serde(deny_unknown_fields)]
335 pub struct Field {
336 + // TODO: deserialize with `parse_type` into a custom type
337 #[serde(rename = "type")]
338 pub type_: String,
339
@@ -198,11 +352,18 @@ pub struct Field {
352 #[serde(default)]
353 #[serde(rename = "TODO")]
354 pub todo: Option<String>,
355 +
356 + #[serde(default)]
357 + pub hermes_convert_with: Option<String>,
358 +
359 + #[serde(default)]
360 + pub hermes_default: bool,
361 }
362
363 impl Field {
364 pub fn codegen(&self, name: &str) -> TokenStream {
365 let name = format_ident!("{}", name);
366 + parse_type(&self.type_).unwrap();
367 let type_name: Type = syn::parse_str(&self.type_)
368 .unwrap_or_else(|_| panic!("Expected a type name, got `{}`", &self.type_));
369
@@ -237,6 +398,7 @@ impl Field {
398
399 pub fn codegen_node(&self, name: &str) -> TokenStream {
400 let name = format_ident!("{}", name);
401 + parse_type(&self.type_).unwrap();
402 let type_name: Type = syn::parse_str(&self.type_)
403 .unwrap_or_else(|_| panic!("Expected a type name, got `{}`", &self.type_));
404 let type_ = quote!(#type_name);
@@ -386,6 +548,86 @@ impl Enum {
548 }
549 }
550 }
551 +
552 + pub fn codegen_hermes(&self, name: &str, grammar: &Grammar) -> TokenStream {
553 + let name = format_ident!("{}", name);
554 +
555 + let mut tag_matches = Vec::new();
556 + let mut seen = HashSet::new();
557 +
558 + // Imagine a case like:
559 + // enum ModuleItem {
560 + // ImportDeclaration, // struct
561 + // Statement // another enum
562 + // }
563 + // We need to generate matches for all the possible *concrete* `type` values, which means
564 + // we have to expand nested enums such as `Statement`
565 + for variant in self.variants.iter() {
566 + if let Some(nested_enum) = grammar.enums.get(variant) {
567 + let outer_variant = format_ident!("{}", variant);
568 + for variant in nested_enum.variants.iter() {
569 + // Skip variants that appear in multiple nested enums, we deserialize
570 + // as the first listed outer variant
571 + if !seen.insert(variant.to_string()) {
572 + continue;
573 + }
574 + // Modeling ESTree only requires a single level of nested enums,
575 + // so that's all we support. Though in theory we could support arbitrary nesting,
576 + // since ultimately we're matching based on the final concrete types.
577 + assert!(!grammar.enums.contains_key(variant));
578 + let node = grammar.nodes.get(variant).unwrap();
579 + if node.skip_hermes_enum_variant {
580 + continue;
581 + }
582 +
583 + let inner_variant = format_ident!("{}", variant);
584 + let node_variant_name = node.type_.as_ref().unwrap_or(variant);
585 + let node_variant = format_ident!("{}", node_variant_name);
586 +
587 + tag_matches.push(quote! {
588 + NodeKind::#node_variant => {
589 + let node = #inner_variant::convert(cx, node);
590 + #name::#outer_variant(#outer_variant::#inner_variant(Box::new(node)))
591 + }
592 + });
593 + }
594 + } else {
595 + if !seen.insert(variant.to_string()) {
596 + panic!(
597 + "Concrete variant {} was already added by a nested enum",
598 + variant
599 + );
600 + }
601 + let variant_name = format_ident!("{}", variant);
602 + let node = grammar.nodes.get(variant).unwrap();
603 + if node.skip_hermes_enum_variant {
604 + continue;
605 + }
606 +
607 + let node_variant_name = node.type_.as_ref().unwrap_or(variant);
608 + let node_variant = format_ident!("{}", node_variant_name);
609 +
610 + tag_matches.push(quote! {
611 + NodeKind::#node_variant => {
612 + let node = #variant_name::convert(cx, node);
613 + #name::#variant_name(Box::new(node))
614 + }
615 + })
616 + }
617 + }
618 +
619 + quote! {
620 + impl FromHermes for #name {
621 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
622 + let node_ref = node.as_ref();
623 + match node_ref.kind {
624 + #(#tag_matches),*
625 + _ => panic!("Unexpected node")
626 + }
627 + }
628 + }
629 + }
630 + }
631 }
632
633 #[derive(Serialize, Deserialize, Debug)]
@@ -457,4 +699,67 @@ impl Operator {
699 }
700 }
701 }
702 +
703 + pub fn codegen_hermes(&self, name: &str) -> TokenStream {
704 + let mut sorted_variants: Vec<_> = self.variants.iter().collect();
705 + sorted_variants.sort();
706 +
707 + let name = format_ident!("{}", name);
708 +
709 + quote! {
710 + impl FromHermesLabel for #name {
711 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
712 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
713 + utf_str.parse().unwrap()
714 + }
715 + }
716 + }
717 + }
718 +}
719 +
720 +enum TypeKind {
721 + /// T
722 + Named,
723 +
724 + /// Option<T>
725 + Option,
726 +
727 + /// Vec<T>
728 + Vec,
729 +
730 + /// Vec<Option<T>>
731 + VecOfOption,
732 +}
733 +
734 +/// Parses a given type into the underlying type name plus a descriptor of the
735 +/// kind of type. Only a subset of Rust types are supported:
736 +/// - T
737 +/// - Option<T>
738 +/// - Vec<T>
739 +/// - Vec<Option<T>>
740 +fn parse_type(type_: &str) -> Result<(String, TypeKind), String> {
741 + let mut current = type_;
742 + let mut is_list = false;
743 + let mut is_option = false;
744 + if current.starts_with("Vec<") {
745 + current = &current[4..current.len() - 1];
746 + is_list = true;
747 + }
748 + if current.starts_with("Option<") {
749 + current = &current[7..current.len() - 1];
750 + is_option = true;
751 + }
752 + if current.contains("<") {
753 + Err(format!(
754 + "Unsupported type `{current}` expected named type (`Identifier`), optional type (`Option<Identifier>`), list type (`Vec<Identifier>`), or optional list (`Vec<Option<Identifier>>`)"
755 + ))
756 + } else {
757 + let kind = match (is_list, is_option) {
758 + (true, true) => TypeKind::VecOfOption,
759 + (true, false) => TypeKind::Vec,
760 + (false, true) => TypeKind::Option,
761 + (false, false) => TypeKind::Named,
762 + };
763 + Ok((current.to_string(), kind))
764 + }
765 }
compiler/forget/crates/forget_estree_codegen/src/ecmascript.json
+74 -34
@@ -23,6 +23,20 @@
23 }
24 }
25 },
26 + "Class": {
27 + "fields": {
28 + "id": {
29 + "type": "Option<Identifier>"
30 + },
31 + "super_class": {
32 + "type": "Option<Expression>",
33 + "rename": "superClass"
34 + },
35 + "body": {
36 + "type": "ClassBody"
37 + }
38 + }
39 + },
40 "Function": {
41 "fields": {
42 "id": {
@@ -89,6 +103,8 @@
103 }
104 },
105 "Literal": {
106 + "skip_hermes_codegen": true,
107 + "skip_hermes_enum_variant": true,
108 "fields": {
109 "value": {
110 "type": "JsValue"
@@ -107,6 +123,29 @@
123 }
124 }
125 },
126 + "NumericLiteral": {
127 + "fields": {
128 + "value": {
129 + "type": "Number"
130 + }
131 + }
132 + },
133 + "BooleanLiteral": {
134 + "fields": {
135 + "value": {
136 + "type": "bool"
137 + }
138 + }
139 + },
140 + "NullLiteral": {},
141 + "StringLiteral": {
142 + "fields": {
143 + "value": {
144 + "type": "String",
145 + "hermes_convert_with": "convert_string_value"
146 + }
147 + }
148 + },
149 "Program": {
150 "fields": {
151 "body": {
@@ -115,7 +154,8 @@
154 "source_type": {
155 "type": "SourceType",
156 "optional": true,
118 - "rename": "sourceType"
157 + "rename": "sourceType",
158 + "hermes_default": true
159 }
160 }
161 },
@@ -126,7 +166,8 @@
166 },
167 "directive": {
168 "type": "Option<String>",
129 - "optional": true
169 + "optional": true,
170 + "hermes_default": true
171 }
172 }
173 },
@@ -311,6 +352,7 @@
352 }
353 },
354 "FunctionDeclaration": {
355 + "skip_hermes_codegen": true,
356 "fields": {
357 "function": {
358 "type": "Function",
@@ -318,21 +360,8 @@
360 }
361 }
362 },
321 - "Class": {
322 - "fields": {
323 - "id": {
324 - "type": "Option<Identifier>"
325 - },
326 - "super_class": {
327 - "type": "Option<Expression>",
328 - "rename": "superClass"
329 - },
330 - "body": {
331 - "type": "ClassBody"
332 - }
333 - }
334 - },
363 "ClassDeclaration": {
364 + "skip_hermes_codegen": true,
365 "fields": {
366 "class": {
367 "type": "Class",
@@ -341,6 +370,7 @@
370 }
371 },
372 "ClassExpression": {
373 + "skip_hermes_codegen": true,
374 "fields": {
375 "class": {
376 "type": "Class",
@@ -400,7 +430,8 @@
430 "ArrayExpression": {
431 "fields": {
432 "elements": {
403 - "type": "Vec<Option<ExpressionOrSpread>>"
433 + "type": "Vec<Option<ExpressionOrSpread>>",
434 + "hermes_convert_with": "convert_array_expression_elements"
435 }
436 }
437 },
@@ -437,6 +468,7 @@
468 }
469 },
470 "FunctionExpression": {
471 + "skip_hermes_codegen": true,
472 "fields": {
473 "function": {
474 "type": "Function",
@@ -445,6 +477,7 @@
477 }
478 },
479 "ArrowFunctionExpression": {
480 + "skip_hermes_codegen": true,
481 "fields": {
482 "function": {
483 "type": "Function",
@@ -532,11 +565,6 @@
565 "is_computed": {
566 "type": "bool",
567 "rename": "computed"
535 - },
536 - "is_optional": {
537 - "type": "bool",
538 - "optional": true,
539 - "rename": "optional"
568 }
569 }
570 },
@@ -560,11 +588,6 @@
588 },
589 "arguments": {
590 "type": "Vec<ExpressionOrSpread>"
563 - },
564 - "is_optional": {
565 - "type": "bool",
566 - "optional": true,
567 - "rename": "optional"
591 }
592 }
593 },
@@ -611,7 +634,7 @@
634 "type": "Vec<ImportDeclarationSpecifier>"
635 },
636 "source": {
614 - "type": "Literal"
637 + "type": "_Literal"
638 }
639 }
640 },
@@ -648,7 +671,7 @@
671 "type": "Vec<ExportSpecifier>"
672 },
673 "source": {
651 - "type": "Option<Literal>"
674 + "type": "Option<_Literal>"
675 }
676 }
677 },
@@ -669,11 +692,12 @@
692 "ExportAllDeclaration": {
693 "fields": {
694 "source": {
672 - "type": "Literal"
695 + "type": "_Literal"
696 },
697 "exported": {
698 "type": "Option<Identifier>",
676 - "optional": true
699 + "optional": true,
700 + "hermes_default": true
701 }
702 }
703 },
@@ -765,7 +789,8 @@
789 "JSXText": {
790 "fields": {
791 "value": {
768 - "type": "String"
792 + "type": "String",
793 + "hermes_convert_with": "convert_string_value"
794 },
795 "raw": {
796 "type": "String"
@@ -797,7 +822,7 @@
822 "type": "Vec<JSXChildItem>"
823 },
824 "closing_fragment": {
800 - "type": "Option<JSXClosingFragment>",
825 + "type": "JSXClosingFragment",
826 "rename": "closingFragment"
827 }
828 }
@@ -819,6 +844,7 @@
844 }
845 },
846 "AssignmentProperty": {
847 + "skip_hermes_codegen": true,
848 "type": "Property",
849 "fields": {
850 "key": {
@@ -865,6 +891,7 @@
891 }
892 },
893 "TemplateElement": {
894 + "skip_hermes_codegen": true,
895 "fields": {
896 "tail": {
897 "type": "bool"
@@ -902,6 +929,8 @@
929 }
930 },
931 "ChainExpression": {
932 + "skip_hermes_codegen": true,
933 + "skip_hermes_enum_variant": true,
934 "fields": {
935 "expression": {
936 "type": "ChainElement"
@@ -914,7 +943,7 @@
943 "type": "Expression"
944 },
945 "property": {
917 - "type": "Identifier"
946 + "type": "Expression"
947 },
948 "is_computed": {
949 "type": "bool",
@@ -980,6 +1009,7 @@
1009 "AssignmentExpression",
1010 "AwaitExpression",
1011 "BinaryExpression",
1012 + "BooleanLiteral",
1013 "CallExpression",
1014 "ChainExpression",
1015 "ClassExpression",
@@ -993,10 +1023,13 @@
1023 "MemberExpression",
1024 "MetaProperty",
1025 "NewExpression",
1026 + "NullLiteral",
1027 + "NumericLiteral",
1028 "ObjectExpression",
1029 "OptionalCallExpression",
1030 "OptionalMemberExpression",
1031 "SequenceExpression",
1032 + "StringLiteral",
1033 "TaggedTemplateExpression",
1034 "TemplateLiteral",
1035 "ThisExpression",
@@ -1004,6 +1037,13 @@
1037 "UpdateExpression",
1038 "YieldExpression"
1039 ],
1040 + "_Literal": [
1041 + "Literal",
1042 + "BooleanLiteral",
1043 + "NullLiteral",
1044 + "StringLiteral",
1045 + "NumericLiteral"
1046 + ],
1047 "Declaration": [
1048 "ClassDeclaration",
1049 "FunctionDeclaration",
compiler/forget/crates/forget_estree_codegen/src/lib.rs
+1 -1
@@ -1,3 +1,3 @@
1 mod codegen;
2
3 -pub use codegen::estree;
3 +pub use codegen::{estree, estree_hermes};
compiler/forget/crates/forget_estree_swc/src/lib.rs
+25 -3
@@ -340,7 +340,6 @@ fn convert_expression(cx: &Context, expr: &Expr) -> forget_estree::Expression {
340 _ => todo!(),
341 },
342 arguments: convert_arguments(cx, &expr.args),
343 - is_optional: false,
343 loc: None,
344 range: convert_span(&expr.span),
345 }))
@@ -452,9 +451,9 @@ fn convert_expression(cx: &Context, expr: &Expr) -> forget_estree::Expression {
451 }),
452 ),
453 OptChainBase::Member(base) => {
455 - let mut member = convert_member_expression(cx, base);
454 + let mut member = convert_optional_member_expression(cx, base);
455 member.is_optional = expr.optional;
457 - forget_estree::Expression::MemberExpression(Box::new(member))
456 + forget_estree::Expression::OptionalMemberExpression(Box::new(member))
457 }
458 },
459 Expr::JSXElement(expr) => {
@@ -779,6 +778,29 @@ fn convert_member_expression(cx: &Context, expr: &MemberExpr) -> forget_estree::
778 object: forget_estree::ExpressionOrSuper::Expression(convert_expression(cx, &expr.obj)),
779 property,
780 is_computed,
781 + loc: None,
782 + range: convert_span(&expr.span),
783 + }
784 +}
785 +
786 +fn convert_optional_member_expression(
787 + cx: &Context,
788 + expr: &MemberExpr,
789 +) -> forget_estree::OptionalMemberExpression {
790 + let (is_computed, property) = match &expr.prop {
791 + MemberProp::Ident(prop) => (
792 + false,
793 + forget_estree::Expression::Identifier(Box::new(convert_identifier(cx, prop))),
794 + ),
795 + MemberProp::Computed(prop) => (true, convert_expression(cx, &prop.expr)),
796 + _ => {
797 + panic!("PrivateName member expression properties are not supported")
798 + }
799 + };
800 + forget_estree::OptionalMemberExpression {
801 + object: convert_expression(cx, &expr.obj),
802 + property,
803 + is_computed,
804 is_optional: false,
805 loc: None,
806 range: convert_span(&expr.span),
compiler/forget/crates/forget_hermes_parser/Cargo.toml
+4 -1
@@ -15,4 +15,7 @@ repository.workspace = true
15 forget_diagnostics = { workspace = true }
16 forget_estree = { workspace = true }
17 hermes = { workspace = true }
18 -juno_support = { workspace = true }
\ No newline at end of file
18 +juno_support = { workspace = true }
19 +
20 +[build-dependencies]
21 +forget_estree_codegen = { workspace = true }
\ No newline at end of file
compiler/forget/crates/forget_hermes_parser/build.rs new
+13
@@ -0,0 +1,13 @@
1 +use forget_estree_codegen::estree_hermes;
2 +
3 +// Example custom build script.
4 +fn main() {
5 + // Re-run if the codegen files change
6 + println!("cargo:rerun-if-changed=../forget_estree_codegen/src/codegen.rs");
7 + println!("cargo:rerun-if-changed=../forget_estree_codegen/src/lib.rs");
8 + println!("cargo:rerun-if-changed=../forget_estree_codegen/src/ecmascript.json");
9 + println!("cargo:rerun-if-changed=../forget_estree_codegen");
10 +
11 + let src = estree_hermes();
12 + std::fs::write("src/generated.rs", src).unwrap();
13 +}
compiler/forget/crates/forget_hermes_parser/src/generated.rs new
+3141
@@ -0,0 +1,3141 @@
1 +// @generated
2 +#![cfg_attr(rustfmt, rustfmt_skip)]
3 +#![allow(dead_code)]
4 +#![allow(unused_variables)]
5 +use forget_estree::*;
6 +use hermes;
7 +use hermes::parser::{NodePtr, NodeKind, NodeLabel};
8 +use hermes::utf::utf8_with_surrogates_to_string;
9 +use crate::generated_extension::*;
10 +impl FromHermes for Identifier {
11 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
12 + let range = convert_range(node);
13 + let name = convert_string(
14 + cx,
15 + unsafe { hermes::parser::hermes_get_Identifier_name(node) },
16 + );
17 + let binding = Default::default();
18 + Self {
19 + name,
20 + binding,
21 + loc: None,
22 + range: Some(range),
23 + }
24 + }
25 +}
26 +impl FromHermes for NumericLiteral {
27 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
28 + let range = convert_range(node);
29 + let value = convert_number(unsafe {
30 + hermes::parser::hermes_get_NumericLiteral_value(node)
31 + });
32 + Self {
33 + value,
34 + loc: None,
35 + range: Some(range),
36 + }
37 + }
38 +}
39 +impl FromHermes for BooleanLiteral {
40 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
41 + let range = convert_range(node);
42 + let value = unsafe { hermes::parser::hermes_get_BooleanLiteral_value(node) };
43 + Self {
44 + value,
45 + loc: None,
46 + range: Some(range),
47 + }
48 + }
49 +}
50 +impl FromHermes for NullLiteral {
51 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
52 + let range = convert_range(node);
53 + Self {
54 + loc: None,
55 + range: Some(range),
56 + }
57 + }
58 +}
59 +impl FromHermes for StringLiteral {
60 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
61 + let range = convert_range(node);
62 + let value = convert_string_value(
63 + cx,
64 + unsafe { hermes::parser::hermes_get_StringLiteral_value(node) },
65 + );
66 + Self {
67 + value,
68 + loc: None,
69 + range: Some(range),
70 + }
71 + }
72 +}
73 +impl FromHermes for Program {
74 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
75 + let range = convert_range(node);
76 + let body = convert_vec(
77 + unsafe { hermes::parser::hermes_get_Program_body(node) },
78 + |node| ModuleItem::convert(cx, node),
79 + );
80 + let source_type = Default::default();
81 + Self {
82 + body,
83 + source_type,
84 + loc: None,
85 + range: Some(range),
86 + }
87 + }
88 +}
89 +impl FromHermes for ExpressionStatement {
90 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
91 + let range = convert_range(node);
92 + let expression = Expression::convert(
93 + cx,
94 + unsafe { hermes::parser::hermes_get_ExpressionStatement_expression(node) },
95 + );
96 + let directive = Default::default();
97 + Self {
98 + expression,
99 + directive,
100 + loc: None,
101 + range: Some(range),
102 + }
103 + }
104 +}
105 +impl FromHermes for BlockStatement {
106 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
107 + let range = convert_range(node);
108 + let body = convert_vec(
109 + unsafe { hermes::parser::hermes_get_BlockStatement_body(node) },
110 + |node| Statement::convert(cx, node),
111 + );
112 + Self {
113 + body,
114 + loc: None,
115 + range: Some(range),
116 + }
117 + }
118 +}
119 +impl FromHermes for EmptyStatement {
120 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
121 + let range = convert_range(node);
122 + Self {
123 + loc: None,
124 + range: Some(range),
125 + }
126 + }
127 +}
128 +impl FromHermes for DebuggerStatement {
129 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
130 + let range = convert_range(node);
131 + Self {
132 + loc: None,
133 + range: Some(range),
134 + }
135 + }
136 +}
137 +impl FromHermes for WithStatement {
138 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
139 + let range = convert_range(node);
140 + let object = Expression::convert(
141 + cx,
142 + unsafe { hermes::parser::hermes_get_WithStatement_object(node) },
143 + );
144 + let body = Statement::convert(
145 + cx,
146 + unsafe { hermes::parser::hermes_get_WithStatement_body(node) },
147 + );
148 + Self {
149 + object,
150 + body,
151 + loc: None,
152 + range: Some(range),
153 + }
154 + }
155 +}
156 +impl FromHermes for ReturnStatement {
157 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
158 + let range = convert_range(node);
159 + let argument = convert_option(
160 + unsafe { hermes::parser::hermes_get_ReturnStatement_argument(node) },
161 + |node| Expression::convert(cx, node),
162 + );
163 + Self {
164 + argument,
165 + loc: None,
166 + range: Some(range),
167 + }
168 + }
169 +}
170 +impl FromHermes for LabeledStatement {
171 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
172 + let range = convert_range(node);
173 + let label = Identifier::convert(
174 + cx,
175 + unsafe { hermes::parser::hermes_get_LabeledStatement_label(node) },
176 + );
177 + let body = Statement::convert(
178 + cx,
179 + unsafe { hermes::parser::hermes_get_LabeledStatement_body(node) },
180 + );
181 + Self {
182 + label,
183 + body,
184 + loc: None,
185 + range: Some(range),
186 + }
187 + }
188 +}
189 +impl FromHermes for BreakStatement {
190 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
191 + let range = convert_range(node);
192 + let label = convert_option(
193 + unsafe { hermes::parser::hermes_get_BreakStatement_label(node) },
194 + |node| Identifier::convert(cx, node),
195 + );
196 + Self {
197 + label,
198 + loc: None,
199 + range: Some(range),
200 + }
201 + }
202 +}
203 +impl FromHermes for ContinueStatement {
204 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
205 + let range = convert_range(node);
206 + let label = convert_option(
207 + unsafe { hermes::parser::hermes_get_ContinueStatement_label(node) },
208 + |node| Identifier::convert(cx, node),
209 + );
210 + Self {
211 + label,
212 + loc: None,
213 + range: Some(range),
214 + }
215 + }
216 +}
217 +impl FromHermes for IfStatement {
218 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
219 + let range = convert_range(node);
220 + let test = Expression::convert(
221 + cx,
222 + unsafe { hermes::parser::hermes_get_IfStatement_test(node) },
223 + );
224 + let consequent = Statement::convert(
225 + cx,
226 + unsafe { hermes::parser::hermes_get_IfStatement_consequent(node) },
227 + );
228 + let alternate = convert_option(
229 + unsafe { hermes::parser::hermes_get_IfStatement_alternate(node) },
230 + |node| Statement::convert(cx, node),
231 + );
232 + Self {
233 + test,
234 + consequent,
235 + alternate,
236 + loc: None,
237 + range: Some(range),
238 + }
239 + }
240 +}
241 +impl FromHermes for SwitchStatement {
242 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
243 + let range = convert_range(node);
244 + let discriminant = Expression::convert(
245 + cx,
246 + unsafe { hermes::parser::hermes_get_SwitchStatement_discriminant(node) },
247 + );
248 + let cases = convert_vec(
249 + unsafe { hermes::parser::hermes_get_SwitchStatement_cases(node) },
250 + |node| SwitchCase::convert(cx, node),
251 + );
252 + Self {
253 + discriminant,
254 + cases,
255 + loc: None,
256 + range: Some(range),
257 + }
258 + }
259 +}
260 +impl FromHermes for SwitchCase {
261 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
262 + let range = convert_range(node);
263 + let test = convert_option(
264 + unsafe { hermes::parser::hermes_get_SwitchCase_test(node) },
265 + |node| Expression::convert(cx, node),
266 + );
267 + let consequent = convert_vec(
268 + unsafe { hermes::parser::hermes_get_SwitchCase_consequent(node) },
269 + |node| Statement::convert(cx, node),
270 + );
271 + Self {
272 + test,
273 + consequent,
274 + loc: None,
275 + range: Some(range),
276 + }
277 + }
278 +}
279 +impl FromHermes for ThrowStatement {
280 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
281 + let range = convert_range(node);
282 + let argument = Expression::convert(
283 + cx,
284 + unsafe { hermes::parser::hermes_get_ThrowStatement_argument(node) },
285 + );
286 + Self {
287 + argument,
288 + loc: None,
289 + range: Some(range),
290 + }
291 + }
292 +}
293 +impl FromHermes for TryStatement {
294 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
295 + let range = convert_range(node);
296 + let block = BlockStatement::convert(
297 + cx,
298 + unsafe { hermes::parser::hermes_get_TryStatement_block(node) },
299 + );
300 + let handler = convert_option(
301 + unsafe { hermes::parser::hermes_get_TryStatement_handler(node) },
302 + |node| CatchClause::convert(cx, node),
303 + );
304 + let finalizer = convert_option(
305 + unsafe { hermes::parser::hermes_get_TryStatement_finalizer(node) },
306 + |node| BlockStatement::convert(cx, node),
307 + );
308 + Self {
309 + block,
310 + handler,
311 + finalizer,
312 + loc: None,
313 + range: Some(range),
314 + }
315 + }
316 +}
317 +impl FromHermes for CatchClause {
318 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
319 + let range = convert_range(node);
320 + let param = convert_option(
321 + unsafe { hermes::parser::hermes_get_CatchClause_param(node) },
322 + |node| Pattern::convert(cx, node),
323 + );
324 + let body = BlockStatement::convert(
325 + cx,
326 + unsafe { hermes::parser::hermes_get_CatchClause_body(node) },
327 + );
328 + Self {
329 + param,
330 + body,
331 + loc: None,
332 + range: Some(range),
333 + }
334 + }
335 +}
336 +impl FromHermes for WhileStatement {
337 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
338 + let range = convert_range(node);
339 + let test = Expression::convert(
340 + cx,
341 + unsafe { hermes::parser::hermes_get_WhileStatement_test(node) },
342 + );
343 + let body = Statement::convert(
344 + cx,
345 + unsafe { hermes::parser::hermes_get_WhileStatement_body(node) },
346 + );
347 + Self {
348 + test,
349 + body,
350 + loc: None,
351 + range: Some(range),
352 + }
353 + }
354 +}
355 +impl FromHermes for DoWhileStatement {
356 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
357 + let range = convert_range(node);
358 + let body = Statement::convert(
359 + cx,
360 + unsafe { hermes::parser::hermes_get_DoWhileStatement_body(node) },
361 + );
362 + let test = Expression::convert(
363 + cx,
364 + unsafe { hermes::parser::hermes_get_DoWhileStatement_test(node) },
365 + );
366 + Self {
367 + body,
368 + test,
369 + loc: None,
370 + range: Some(range),
371 + }
372 + }
373 +}
374 +impl FromHermes for ForStatement {
375 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
376 + let range = convert_range(node);
377 + let init = convert_option(
378 + unsafe { hermes::parser::hermes_get_ForStatement_init(node) },
379 + |node| ForInit::convert(cx, node),
380 + );
381 + let test = convert_option(
382 + unsafe { hermes::parser::hermes_get_ForStatement_test(node) },
383 + |node| Expression::convert(cx, node),
384 + );
385 + let update = convert_option(
386 + unsafe { hermes::parser::hermes_get_ForStatement_update(node) },
387 + |node| Expression::convert(cx, node),
388 + );
389 + let body = Statement::convert(
390 + cx,
391 + unsafe { hermes::parser::hermes_get_ForStatement_body(node) },
392 + );
393 + Self {
394 + init,
395 + test,
396 + update,
397 + body,
398 + loc: None,
399 + range: Some(range),
400 + }
401 + }
402 +}
403 +impl FromHermes for ForInStatement {
404 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
405 + let range = convert_range(node);
406 + let left = ForInInit::convert(
407 + cx,
408 + unsafe { hermes::parser::hermes_get_ForInStatement_left(node) },
409 + );
410 + let right = Expression::convert(
411 + cx,
412 + unsafe { hermes::parser::hermes_get_ForInStatement_right(node) },
413 + );
414 + let body = Statement::convert(
415 + cx,
416 + unsafe { hermes::parser::hermes_get_ForInStatement_body(node) },
417 + );
418 + Self {
419 + left,
420 + right,
421 + body,
422 + loc: None,
423 + range: Some(range),
424 + }
425 + }
426 +}
427 +impl FromHermes for ForOfStatement {
428 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
429 + let range = convert_range(node);
430 + let is_await = unsafe { hermes::parser::hermes_get_ForOfStatement_await(node) };
431 + let left = ForInInit::convert(
432 + cx,
433 + unsafe { hermes::parser::hermes_get_ForOfStatement_left(node) },
434 + );
435 + let right = Expression::convert(
436 + cx,
437 + unsafe { hermes::parser::hermes_get_ForOfStatement_right(node) },
438 + );
439 + let body = Statement::convert(
440 + cx,
441 + unsafe { hermes::parser::hermes_get_ForOfStatement_body(node) },
442 + );
443 + Self {
444 + is_await,
445 + left,
446 + right,
447 + body,
448 + loc: None,
449 + range: Some(range),
450 + }
451 + }
452 +}
453 +impl FromHermes for ClassBody {
454 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
455 + let range = convert_range(node);
456 + let body = convert_vec(
457 + unsafe { hermes::parser::hermes_get_ClassBody_body(node) },
458 + |node| MethodDefinition::convert(cx, node),
459 + );
460 + Self {
461 + body,
462 + loc: None,
463 + range: Some(range),
464 + }
465 + }
466 +}
467 +impl FromHermes for MethodDefinition {
468 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
469 + let range = convert_range(node);
470 + let key = Expression::convert(
471 + cx,
472 + unsafe { hermes::parser::hermes_get_MethodDefinition_key(node) },
473 + );
474 + let value = FunctionExpression::convert(
475 + cx,
476 + unsafe { hermes::parser::hermes_get_MethodDefinition_value(node) },
477 + );
478 + let kind = MethodKind::convert(
479 + cx,
480 + unsafe { hermes::parser::hermes_get_MethodDefinition_kind(node) },
481 + );
482 + let is_computed = unsafe {
483 + hermes::parser::hermes_get_MethodDefinition_computed(node)
484 + };
485 + let is_static = unsafe {
486 + hermes::parser::hermes_get_MethodDefinition_static(node)
487 + };
488 + Self {
489 + key,
490 + value,
491 + kind,
492 + is_computed,
493 + is_static,
494 + loc: None,
495 + range: Some(range),
496 + }
497 + }
498 +}
499 +impl FromHermes for VariableDeclaration {
500 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
501 + let range = convert_range(node);
502 + let kind = VariableDeclarationKind::convert(
503 + cx,
504 + unsafe { hermes::parser::hermes_get_VariableDeclaration_kind(node) },
505 + );
506 + let declarations = convert_vec(
507 + unsafe { hermes::parser::hermes_get_VariableDeclaration_declarations(node) },
508 + |node| VariableDeclarator::convert(cx, node),
509 + );
510 + Self {
511 + kind,
512 + declarations,
513 + loc: None,
514 + range: Some(range),
515 + }
516 + }
517 +}
518 +impl FromHermes for VariableDeclarator {
519 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
520 + let range = convert_range(node);
521 + let id = Pattern::convert(
522 + cx,
523 + unsafe { hermes::parser::hermes_get_VariableDeclarator_id(node) },
524 + );
525 + let init = convert_option(
526 + unsafe { hermes::parser::hermes_get_VariableDeclarator_init(node) },
527 + |node| Expression::convert(cx, node),
528 + );
529 + Self {
530 + id,
531 + init,
532 + loc: None,
533 + range: Some(range),
534 + }
535 + }
536 +}
537 +impl FromHermes for ThisExpression {
538 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
539 + let range = convert_range(node);
540 + Self {
541 + loc: None,
542 + range: Some(range),
543 + }
544 + }
545 +}
546 +impl FromHermes for ArrayExpression {
547 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
548 + let range = convert_range(node);
549 + let elements = convert_array_expression_elements(
550 + cx,
551 + unsafe { hermes::parser::hermes_get_ArrayExpression_elements(node) },
552 + );
553 + Self {
554 + elements,
555 + loc: None,
556 + range: Some(range),
557 + }
558 + }
559 +}
560 +impl FromHermes for ObjectExpression {
561 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
562 + let range = convert_range(node);
563 + let properties = convert_vec(
564 + unsafe { hermes::parser::hermes_get_ObjectExpression_properties(node) },
565 + |node| PropertyOrSpreadElement::convert(cx, node),
566 + );
567 + Self {
568 + properties,
569 + loc: None,
570 + range: Some(range),
571 + }
572 + }
573 +}
574 +impl FromHermes for Property {
575 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
576 + let range = convert_range(node);
577 + let key = Expression::convert(
578 + cx,
579 + unsafe { hermes::parser::hermes_get_Property_key(node) },
580 + );
581 + let value = Expression::convert(
582 + cx,
583 + unsafe { hermes::parser::hermes_get_Property_value(node) },
584 + );
585 + let kind = PropertyKind::convert(
586 + cx,
587 + unsafe { hermes::parser::hermes_get_Property_kind(node) },
588 + );
589 + let is_method = unsafe { hermes::parser::hermes_get_Property_method(node) };
590 + let is_shorthand = unsafe {
591 + hermes::parser::hermes_get_Property_shorthand(node)
592 + };
593 + let is_computed = unsafe { hermes::parser::hermes_get_Property_computed(node) };
594 + Self {
595 + key,
596 + value,
597 + kind,
598 + is_method,
599 + is_shorthand,
600 + is_computed,
601 + loc: None,
602 + range: Some(range),
603 + }
604 + }
605 +}
606 +impl FromHermes for UnaryExpression {
607 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
608 + let range = convert_range(node);
609 + let operator = UnaryOperator::convert(
610 + cx,
611 + unsafe { hermes::parser::hermes_get_UnaryExpression_operator(node) },
612 + );
613 + let prefix = unsafe { hermes::parser::hermes_get_UnaryExpression_prefix(node) };
614 + let argument = Expression::convert(
615 + cx,
616 + unsafe { hermes::parser::hermes_get_UnaryExpression_argument(node) },
617 + );
618 + Self {
619 + operator,
620 + prefix,
621 + argument,
622 + loc: None,
623 + range: Some(range),
624 + }
625 + }
626 +}
627 +impl FromHermes for UpdateExpression {
628 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
629 + let range = convert_range(node);
630 + let operator = UpdateOperator::convert(
631 + cx,
632 + unsafe { hermes::parser::hermes_get_UpdateExpression_operator(node) },
633 + );
634 + let argument = Expression::convert(
635 + cx,
636 + unsafe { hermes::parser::hermes_get_UpdateExpression_argument(node) },
637 + );
638 + let prefix = unsafe { hermes::parser::hermes_get_UpdateExpression_prefix(node) };
639 + Self {
640 + operator,
641 + argument,
642 + prefix,
643 + loc: None,
644 + range: Some(range),
645 + }
646 + }
647 +}
648 +impl FromHermes for BinaryExpression {
649 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
650 + let range = convert_range(node);
651 + let left = Expression::convert(
652 + cx,
653 + unsafe { hermes::parser::hermes_get_BinaryExpression_left(node) },
654 + );
655 + let operator = BinaryOperator::convert(
656 + cx,
657 + unsafe { hermes::parser::hermes_get_BinaryExpression_operator(node) },
658 + );
659 + let right = Expression::convert(
660 + cx,
661 + unsafe { hermes::parser::hermes_get_BinaryExpression_right(node) },
662 + );
663 + Self {
664 + left,
665 + operator,
666 + right,
667 + loc: None,
668 + range: Some(range),
669 + }
670 + }
671 +}
672 +impl FromHermes for AssignmentExpression {
673 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
674 + let range = convert_range(node);
675 + let operator = AssignmentOperator::convert(
676 + cx,
677 + unsafe { hermes::parser::hermes_get_AssignmentExpression_operator(node) },
678 + );
679 + let left = AssignmentTarget::convert(
680 + cx,
681 + unsafe { hermes::parser::hermes_get_AssignmentExpression_left(node) },
682 + );
683 + let right = Expression::convert(
684 + cx,
685 + unsafe { hermes::parser::hermes_get_AssignmentExpression_right(node) },
686 + );
687 + Self {
688 + operator,
689 + left,
690 + right,
691 + loc: None,
692 + range: Some(range),
693 + }
694 + }
695 +}
696 +impl FromHermes for LogicalExpression {
697 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
698 + let range = convert_range(node);
699 + let operator = LogicalOperator::convert(
700 + cx,
701 + unsafe { hermes::parser::hermes_get_LogicalExpression_operator(node) },
702 + );
703 + let left = Expression::convert(
704 + cx,
705 + unsafe { hermes::parser::hermes_get_LogicalExpression_left(node) },
706 + );
707 + let right = Expression::convert(
708 + cx,
709 + unsafe { hermes::parser::hermes_get_LogicalExpression_right(node) },
710 + );
711 + Self {
712 + operator,
713 + left,
714 + right,
715 + loc: None,
716 + range: Some(range),
717 + }
718 + }
719 +}
720 +impl FromHermes for MemberExpression {
721 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
722 + let range = convert_range(node);
723 + let object = ExpressionOrSuper::convert(
724 + cx,
725 + unsafe { hermes::parser::hermes_get_MemberExpression_object(node) },
726 + );
727 + let property = Expression::convert(
728 + cx,
729 + unsafe { hermes::parser::hermes_get_MemberExpression_property(node) },
730 + );
731 + let is_computed = unsafe {
732 + hermes::parser::hermes_get_MemberExpression_computed(node)
733 + };
734 + Self {
735 + object,
736 + property,
737 + is_computed,
738 + loc: None,
739 + range: Some(range),
740 + }
741 + }
742 +}
743 +impl FromHermes for ConditionalExpression {
744 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
745 + let range = convert_range(node);
746 + let test = Expression::convert(
747 + cx,
748 + unsafe { hermes::parser::hermes_get_ConditionalExpression_test(node) },
749 + );
750 + let alternate = Expression::convert(
751 + cx,
752 + unsafe { hermes::parser::hermes_get_ConditionalExpression_alternate(node) },
753 + );
754 + let consequent = Expression::convert(
755 + cx,
756 + unsafe { hermes::parser::hermes_get_ConditionalExpression_consequent(node) },
757 + );
758 + Self {
759 + test,
760 + alternate,
761 + consequent,
762 + loc: None,
763 + range: Some(range),
764 + }
765 + }
766 +}
767 +impl FromHermes for CallExpression {
768 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
769 + let range = convert_range(node);
770 + let callee = ExpressionOrSuper::convert(
771 + cx,
772 + unsafe { hermes::parser::hermes_get_CallExpression_callee(node) },
773 + );
774 + let arguments = convert_vec(
775 + unsafe { hermes::parser::hermes_get_CallExpression_arguments(node) },
776 + |node| ExpressionOrSpread::convert(cx, node),
777 + );
778 + Self {
779 + callee,
780 + arguments,
781 + loc: None,
782 + range: Some(range),
783 + }
784 + }
785 +}
786 +impl FromHermes for NewExpression {
787 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
788 + let range = convert_range(node);
789 + let callee = Expression::convert(
790 + cx,
791 + unsafe { hermes::parser::hermes_get_NewExpression_callee(node) },
792 + );
793 + let arguments = convert_vec(
794 + unsafe { hermes::parser::hermes_get_NewExpression_arguments(node) },
795 + |node| ExpressionOrSpread::convert(cx, node),
796 + );
797 + Self {
798 + callee,
799 + arguments,
800 + loc: None,
801 + range: Some(range),
802 + }
803 + }
804 +}
805 +impl FromHermes for SequenceExpression {
806 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
807 + let range = convert_range(node);
808 + let expressions = convert_vec(
809 + unsafe { hermes::parser::hermes_get_SequenceExpression_expressions(node) },
810 + |node| Expression::convert(cx, node),
811 + );
812 + Self {
813 + expressions,
814 + loc: None,
815 + range: Some(range),
816 + }
817 + }
818 +}
819 +impl FromHermes for Super {
820 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
821 + let range = convert_range(node);
822 + Self {
823 + loc: None,
824 + range: Some(range),
825 + }
826 + }
827 +}
828 +impl FromHermes for SpreadElement {
829 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
830 + let range = convert_range(node);
831 + let argument = Expression::convert(
832 + cx,
833 + unsafe { hermes::parser::hermes_get_SpreadElement_argument(node) },
834 + );
835 + Self {
836 + argument,
837 + loc: None,
838 + range: Some(range),
839 + }
840 + }
841 +}
842 +impl FromHermes for YieldExpression {
843 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
844 + let range = convert_range(node);
845 + let argument = convert_option(
846 + unsafe { hermes::parser::hermes_get_YieldExpression_argument(node) },
847 + |node| Expression::convert(cx, node),
848 + );
849 + let is_delegate = unsafe {
850 + hermes::parser::hermes_get_YieldExpression_delegate(node)
851 + };
852 + Self {
853 + argument,
854 + is_delegate,
855 + loc: None,
856 + range: Some(range),
857 + }
858 + }
859 +}
860 +impl FromHermes for ImportDeclaration {
861 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
862 + let range = convert_range(node);
863 + let specifiers = convert_vec(
864 + unsafe { hermes::parser::hermes_get_ImportDeclaration_specifiers(node) },
865 + |node| ImportDeclarationSpecifier::convert(cx, node),
866 + );
867 + let source = _Literal::convert(
868 + cx,
869 + unsafe { hermes::parser::hermes_get_ImportDeclaration_source(node) },
870 + );
871 + Self {
872 + specifiers,
873 + source,
874 + loc: None,
875 + range: Some(range),
876 + }
877 + }
878 +}
879 +impl FromHermes for ImportSpecifier {
880 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
881 + let range = convert_range(node);
882 + let imported = Identifier::convert(
883 + cx,
884 + unsafe { hermes::parser::hermes_get_ImportSpecifier_imported(node) },
885 + );
886 + let local = Identifier::convert(
887 + cx,
888 + unsafe { hermes::parser::hermes_get_ImportSpecifier_local(node) },
889 + );
890 + Self {
891 + imported,
892 + local,
893 + loc: None,
894 + range: Some(range),
895 + }
896 + }
897 +}
898 +impl FromHermes for ImportDefaultSpecifier {
899 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
900 + let range = convert_range(node);
901 + let local = Identifier::convert(
902 + cx,
903 + unsafe { hermes::parser::hermes_get_ImportDefaultSpecifier_local(node) },
904 + );
905 + Self {
906 + local,
907 + loc: None,
908 + range: Some(range),
909 + }
910 + }
911 +}
912 +impl FromHermes for ImportNamespaceSpecifier {
913 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
914 + let range = convert_range(node);
915 + let local = Identifier::convert(
916 + cx,
917 + unsafe { hermes::parser::hermes_get_ImportNamespaceSpecifier_local(node) },
918 + );
919 + Self {
920 + local,
921 + loc: None,
922 + range: Some(range),
923 + }
924 + }
925 +}
926 +impl FromHermes for ExportNamedDeclaration {
927 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
928 + let range = convert_range(node);
929 + let declaration = convert_option(
930 + unsafe {
931 + hermes::parser::hermes_get_ExportNamedDeclaration_declaration(node)
932 + },
933 + |node| Declaration::convert(cx, node),
934 + );
935 + let specifiers = convert_vec(
936 + unsafe {
937 + hermes::parser::hermes_get_ExportNamedDeclaration_specifiers(node)
938 + },
939 + |node| ExportSpecifier::convert(cx, node),
940 + );
941 + let source = convert_option(
942 + unsafe { hermes::parser::hermes_get_ExportNamedDeclaration_source(node) },
943 + |node| _Literal::convert(cx, node),
944 + );
945 + Self {
946 + declaration,
947 + specifiers,
948 + source,
949 + loc: None,
950 + range: Some(range),
951 + }
952 + }
953 +}
954 +impl FromHermes for ExportSpecifier {
955 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
956 + let range = convert_range(node);
957 + let exported = Identifier::convert(
958 + cx,
959 + unsafe { hermes::parser::hermes_get_ExportSpecifier_exported(node) },
960 + );
961 + Self {
962 + exported,
963 + loc: None,
964 + range: Some(range),
965 + }
966 + }
967 +}
968 +impl FromHermes for ExportDefaultDeclaration {
969 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
970 + let range = convert_range(node);
971 + let declaration = Declaration::convert(
972 + cx,
973 + unsafe {
974 + hermes::parser::hermes_get_ExportDefaultDeclaration_declaration(node)
975 + },
976 + );
977 + Self {
978 + declaration,
979 + loc: None,
980 + range: Some(range),
981 + }
982 + }
983 +}
984 +impl FromHermes for ExportAllDeclaration {
985 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
986 + let range = convert_range(node);
987 + let source = _Literal::convert(
988 + cx,
989 + unsafe { hermes::parser::hermes_get_ExportAllDeclaration_source(node) },
990 + );
991 + let exported = Default::default();
992 + Self {
993 + source,
994 + exported,
995 + loc: None,
996 + range: Some(range),
997 + }
998 + }
999 +}
1000 +impl FromHermes for JSXIdentifier {
1001 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1002 + let range = convert_range(node);
1003 + let name = convert_string(
1004 + cx,
1005 + unsafe { hermes::parser::hermes_get_JSXIdentifier_name(node) },
1006 + );
1007 + let binding = Default::default();
1008 + Self {
1009 + name,
1010 + binding,
1011 + loc: None,
1012 + range: Some(range),
1013 + }
1014 + }
1015 +}
1016 +impl FromHermes for JSXNamespacedName {
1017 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1018 + let range = convert_range(node);
1019 + let namespace = JSXIdentifier::convert(
1020 + cx,
1021 + unsafe { hermes::parser::hermes_get_JSXNamespacedName_namespace(node) },
1022 + );
1023 + let name = JSXIdentifier::convert(
1024 + cx,
1025 + unsafe { hermes::parser::hermes_get_JSXNamespacedName_name(node) },
1026 + );
1027 + Self {
1028 + namespace,
1029 + name,
1030 + loc: None,
1031 + range: Some(range),
1032 + }
1033 + }
1034 +}
1035 +impl FromHermes for JSXMemberExpression {
1036 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1037 + let range = convert_range(node);
1038 + let object = JSXMemberExpressionOrIdentifier::convert(
1039 + cx,
1040 + unsafe { hermes::parser::hermes_get_JSXMemberExpression_object(node) },
1041 + );
1042 + let property = JSXIdentifier::convert(
1043 + cx,
1044 + unsafe { hermes::parser::hermes_get_JSXMemberExpression_property(node) },
1045 + );
1046 + Self {
1047 + object,
1048 + property,
1049 + loc: None,
1050 + range: Some(range),
1051 + }
1052 + }
1053 +}
1054 +impl FromHermes for JSXEmptyExpression {
1055 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1056 + let range = convert_range(node);
1057 + Self {
1058 + loc: None,
1059 + range: Some(range),
1060 + }
1061 + }
1062 +}
1063 +impl FromHermes for JSXExpressionContainer {
1064 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1065 + let range = convert_range(node);
1066 + let expression = JSXExpressionOrEmpty::convert(
1067 + cx,
1068 + unsafe { hermes::parser::hermes_get_JSXExpressionContainer_expression(node) },
1069 + );
1070 + Self {
1071 + expression,
1072 + loc: None,
1073 + range: Some(range),
1074 + }
1075 + }
1076 +}
1077 +impl FromHermes for JSXSpreadChild {
1078 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1079 + let range = convert_range(node);
1080 + let expression = Expression::convert(
1081 + cx,
1082 + unsafe { hermes::parser::hermes_get_JSXSpreadChild_expression(node) },
1083 + );
1084 + Self {
1085 + expression,
1086 + loc: None,
1087 + range: Some(range),
1088 + }
1089 + }
1090 +}
1091 +impl FromHermes for JSXOpeningElement {
1092 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1093 + let range = convert_range(node);
1094 + let name = JSXElementName::convert(
1095 + cx,
1096 + unsafe { hermes::parser::hermes_get_JSXOpeningElement_name(node) },
1097 + );
1098 + let attributes = convert_vec(
1099 + unsafe { hermes::parser::hermes_get_JSXOpeningElement_attributes(node) },
1100 + |node| JSXAttributeOrSpread::convert(cx, node),
1101 + );
1102 + let self_closing = unsafe {
1103 + hermes::parser::hermes_get_JSXOpeningElement_selfClosing(node)
1104 + };
1105 + Self {
1106 + name,
1107 + attributes,
1108 + self_closing,
1109 + loc: None,
1110 + range: Some(range),
1111 + }
1112 + }
1113 +}
1114 +impl FromHermes for JSXClosingElement {
1115 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1116 + let range = convert_range(node);
1117 + let name = JSXElementName::convert(
1118 + cx,
1119 + unsafe { hermes::parser::hermes_get_JSXClosingElement_name(node) },
1120 + );
1121 + Self {
1122 + name,
1123 + loc: None,
1124 + range: Some(range),
1125 + }
1126 + }
1127 +}
1128 +impl FromHermes for JSXAttribute {
1129 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1130 + let range = convert_range(node);
1131 + let name = JSXIdentifierOrNamespacedName::convert(
1132 + cx,
1133 + unsafe { hermes::parser::hermes_get_JSXAttribute_name(node) },
1134 + );
1135 + let value = convert_option(
1136 + unsafe { hermes::parser::hermes_get_JSXAttribute_value(node) },
1137 + |node| JSXAttributeValue::convert(cx, node),
1138 + );
1139 + Self {
1140 + name,
1141 + value,
1142 + loc: None,
1143 + range: Some(range),
1144 + }
1145 + }
1146 +}
1147 +impl FromHermes for JSXSpreadAttribute {
1148 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1149 + let range = convert_range(node);
1150 + let argument = Expression::convert(
1151 + cx,
1152 + unsafe { hermes::parser::hermes_get_JSXSpreadAttribute_argument(node) },
1153 + );
1154 + Self {
1155 + argument,
1156 + loc: None,
1157 + range: Some(range),
1158 + }
1159 + }
1160 +}
1161 +impl FromHermes for JSXText {
1162 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1163 + let range = convert_range(node);
1164 + let value = convert_string_value(
1165 + cx,
1166 + unsafe { hermes::parser::hermes_get_JSXText_value(node) },
1167 + );
1168 + let raw = convert_string(
1169 + cx,
1170 + unsafe { hermes::parser::hermes_get_JSXText_raw(node) },
1171 + );
1172 + Self {
1173 + value,
1174 + raw,
1175 + loc: None,
1176 + range: Some(range),
1177 + }
1178 + }
1179 +}
1180 +impl FromHermes for JSXElement {
1181 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1182 + let range = convert_range(node);
1183 + let opening_element = JSXOpeningElement::convert(
1184 + cx,
1185 + unsafe { hermes::parser::hermes_get_JSXElement_openingElement(node) },
1186 + );
1187 + let children = convert_vec(
1188 + unsafe { hermes::parser::hermes_get_JSXElement_children(node) },
1189 + |node| JSXChildItem::convert(cx, node),
1190 + );
1191 + let closing_element = convert_option(
1192 + unsafe { hermes::parser::hermes_get_JSXElement_closingElement(node) },
1193 + |node| JSXClosingElement::convert(cx, node),
1194 + );
1195 + Self {
1196 + opening_element,
1197 + children,
1198 + closing_element,
1199 + loc: None,
1200 + range: Some(range),
1201 + }
1202 + }
1203 +}
1204 +impl FromHermes for JSXFragment {
1205 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1206 + let range = convert_range(node);
1207 + let opening_fragment = JSXOpeningFragment::convert(
1208 + cx,
1209 + unsafe { hermes::parser::hermes_get_JSXFragment_openingFragment(node) },
1210 + );
1211 + let children = convert_vec(
1212 + unsafe { hermes::parser::hermes_get_JSXFragment_children(node) },
1213 + |node| JSXChildItem::convert(cx, node),
1214 + );
1215 + let closing_fragment = JSXClosingFragment::convert(
1216 + cx,
1217 + unsafe { hermes::parser::hermes_get_JSXFragment_closingFragment(node) },
1218 + );
1219 + Self {
1220 + opening_fragment,
1221 + children,
1222 + closing_fragment,
1223 + loc: None,
1224 + range: Some(range),
1225 + }
1226 + }
1227 +}
1228 +impl FromHermes for JSXOpeningFragment {
1229 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1230 + let range = convert_range(node);
1231 + Self {
1232 + loc: None,
1233 + range: Some(range),
1234 + }
1235 + }
1236 +}
1237 +impl FromHermes for JSXClosingFragment {
1238 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1239 + let range = convert_range(node);
1240 + Self {
1241 + loc: None,
1242 + range: Some(range),
1243 + }
1244 + }
1245 +}
1246 +impl FromHermes for ArrayPattern {
1247 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1248 + let range = convert_range(node);
1249 + let elements = convert_vec_of_option(
1250 + unsafe { hermes::parser::hermes_get_ArrayPattern_elements(node) },
1251 + |node| Pattern::convert(cx, node),
1252 + );
1253 + Self {
1254 + elements,
1255 + loc: None,
1256 + range: Some(range),
1257 + }
1258 + }
1259 +}
1260 +impl FromHermes for ObjectPattern {
1261 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1262 + let range = convert_range(node);
1263 + let properties = convert_vec(
1264 + unsafe { hermes::parser::hermes_get_ObjectPattern_properties(node) },
1265 + |node| AssignmentPropertyOrRestElement::convert(cx, node),
1266 + );
1267 + Self {
1268 + properties,
1269 + loc: None,
1270 + range: Some(range),
1271 + }
1272 + }
1273 +}
1274 +impl FromHermes for RestElement {
1275 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1276 + let range = convert_range(node);
1277 + let argument = Pattern::convert(
1278 + cx,
1279 + unsafe { hermes::parser::hermes_get_RestElement_argument(node) },
1280 + );
1281 + Self {
1282 + argument,
1283 + loc: None,
1284 + range: Some(range),
1285 + }
1286 + }
1287 +}
1288 +impl FromHermes for AssignmentPattern {
1289 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1290 + let range = convert_range(node);
1291 + let left = Pattern::convert(
1292 + cx,
1293 + unsafe { hermes::parser::hermes_get_AssignmentPattern_left(node) },
1294 + );
1295 + let right = Expression::convert(
1296 + cx,
1297 + unsafe { hermes::parser::hermes_get_AssignmentPattern_right(node) },
1298 + );
1299 + Self {
1300 + left,
1301 + right,
1302 + loc: None,
1303 + range: Some(range),
1304 + }
1305 + }
1306 +}
1307 +impl FromHermes for TemplateLiteral {
1308 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1309 + let range = convert_range(node);
1310 + let quasis = convert_vec(
1311 + unsafe { hermes::parser::hermes_get_TemplateLiteral_quasis(node) },
1312 + |node| TemplateElement::convert(cx, node),
1313 + );
1314 + let expressions = convert_vec(
1315 + unsafe { hermes::parser::hermes_get_TemplateLiteral_expressions(node) },
1316 + |node| Expression::convert(cx, node),
1317 + );
1318 + Self {
1319 + quasis,
1320 + expressions,
1321 + loc: None,
1322 + range: Some(range),
1323 + }
1324 + }
1325 +}
1326 +impl FromHermes for TaggedTemplateExpression {
1327 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1328 + let range = convert_range(node);
1329 + let tag = Expression::convert(
1330 + cx,
1331 + unsafe { hermes::parser::hermes_get_TaggedTemplateExpression_tag(node) },
1332 + );
1333 + let quasi = TemplateLiteral::convert(
1334 + cx,
1335 + unsafe { hermes::parser::hermes_get_TaggedTemplateExpression_quasi(node) },
1336 + );
1337 + Self {
1338 + tag,
1339 + quasi,
1340 + loc: None,
1341 + range: Some(range),
1342 + }
1343 + }
1344 +}
1345 +impl FromHermes for MetaProperty {
1346 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1347 + let range = convert_range(node);
1348 + let meta = Identifier::convert(
1349 + cx,
1350 + unsafe { hermes::parser::hermes_get_MetaProperty_meta(node) },
1351 + );
1352 + let property = Identifier::convert(
1353 + cx,
1354 + unsafe { hermes::parser::hermes_get_MetaProperty_property(node) },
1355 + );
1356 + Self {
1357 + meta,
1358 + property,
1359 + loc: None,
1360 + range: Some(range),
1361 + }
1362 + }
1363 +}
1364 +impl FromHermes for AwaitExpression {
1365 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1366 + let range = convert_range(node);
1367 + let argument = Expression::convert(
1368 + cx,
1369 + unsafe { hermes::parser::hermes_get_AwaitExpression_argument(node) },
1370 + );
1371 + Self {
1372 + argument,
1373 + loc: None,
1374 + range: Some(range),
1375 + }
1376 + }
1377 +}
1378 +impl FromHermes for OptionalMemberExpression {
1379 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1380 + let range = convert_range(node);
1381 + let object = Expression::convert(
1382 + cx,
1383 + unsafe { hermes::parser::hermes_get_OptionalMemberExpression_object(node) },
1384 + );
1385 + let property = Expression::convert(
1386 + cx,
1387 + unsafe { hermes::parser::hermes_get_OptionalMemberExpression_property(node) },
1388 + );
1389 + let is_computed = unsafe {
1390 + hermes::parser::hermes_get_OptionalMemberExpression_computed(node)
1391 + };
1392 + let is_optional = unsafe {
1393 + hermes::parser::hermes_get_OptionalMemberExpression_optional(node)
1394 + };
1395 + Self {
1396 + object,
1397 + property,
1398 + is_computed,
1399 + is_optional,
1400 + loc: None,
1401 + range: Some(range),
1402 + }
1403 + }
1404 +}
1405 +impl FromHermes for OptionalCallExpression {
1406 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1407 + let range = convert_range(node);
1408 + let callee = ExpressionOrSuper::convert(
1409 + cx,
1410 + unsafe { hermes::parser::hermes_get_OptionalCallExpression_callee(node) },
1411 + );
1412 + let arguments = convert_vec(
1413 + unsafe { hermes::parser::hermes_get_OptionalCallExpression_arguments(node) },
1414 + |node| ExpressionOrSpread::convert(cx, node),
1415 + );
1416 + let is_optional = unsafe {
1417 + hermes::parser::hermes_get_OptionalCallExpression_optional(node)
1418 + };
1419 + Self {
1420 + callee,
1421 + arguments,
1422 + is_optional,
1423 + loc: None,
1424 + range: Some(range),
1425 + }
1426 + }
1427 +}
1428 +impl FromHermes for ImportExpression {
1429 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1430 + let range = convert_range(node);
1431 + let source = Expression::convert(
1432 + cx,
1433 + unsafe { hermes::parser::hermes_get_ImportExpression_source(node) },
1434 + );
1435 + Self {
1436 + source,
1437 + loc: None,
1438 + range: Some(range),
1439 + }
1440 + }
1441 +}
1442 +impl FromHermes for Statement {
1443 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1444 + let node_ref = node.as_ref();
1445 + match node_ref.kind {
1446 + NodeKind::BlockStatement => {
1447 + let node = BlockStatement::convert(cx, node);
1448 + Statement::BlockStatement(Box::new(node))
1449 + }
1450 + NodeKind::BreakStatement => {
1451 + let node = BreakStatement::convert(cx, node);
1452 + Statement::BreakStatement(Box::new(node))
1453 + }
1454 + NodeKind::ClassDeclaration => {
1455 + let node = ClassDeclaration::convert(cx, node);
1456 + Statement::ClassDeclaration(Box::new(node))
1457 + }
1458 + NodeKind::ContinueStatement => {
1459 + let node = ContinueStatement::convert(cx, node);
1460 + Statement::ContinueStatement(Box::new(node))
1461 + }
1462 + NodeKind::DebuggerStatement => {
1463 + let node = DebuggerStatement::convert(cx, node);
1464 + Statement::DebuggerStatement(Box::new(node))
1465 + }
1466 + NodeKind::DoWhileStatement => {
1467 + let node = DoWhileStatement::convert(cx, node);
1468 + Statement::DoWhileStatement(Box::new(node))
1469 + }
1470 + NodeKind::EmptyStatement => {
1471 + let node = EmptyStatement::convert(cx, node);
1472 + Statement::EmptyStatement(Box::new(node))
1473 + }
1474 + NodeKind::ExpressionStatement => {
1475 + let node = ExpressionStatement::convert(cx, node);
1476 + Statement::ExpressionStatement(Box::new(node))
1477 + }
1478 + NodeKind::ForInStatement => {
1479 + let node = ForInStatement::convert(cx, node);
1480 + Statement::ForInStatement(Box::new(node))
1481 + }
1482 + NodeKind::ForOfStatement => {
1483 + let node = ForOfStatement::convert(cx, node);
1484 + Statement::ForOfStatement(Box::new(node))
1485 + }
1486 + NodeKind::ForStatement => {
1487 + let node = ForStatement::convert(cx, node);
1488 + Statement::ForStatement(Box::new(node))
1489 + }
1490 + NodeKind::FunctionDeclaration => {
1491 + let node = FunctionDeclaration::convert(cx, node);
1492 + Statement::FunctionDeclaration(Box::new(node))
1493 + }
1494 + NodeKind::IfStatement => {
1495 + let node = IfStatement::convert(cx, node);
1496 + Statement::IfStatement(Box::new(node))
1497 + }
1498 + NodeKind::LabeledStatement => {
1499 + let node = LabeledStatement::convert(cx, node);
1500 + Statement::LabeledStatement(Box::new(node))
1501 + }
1502 + NodeKind::ReturnStatement => {
1503 + let node = ReturnStatement::convert(cx, node);
1504 + Statement::ReturnStatement(Box::new(node))
1505 + }
1506 + NodeKind::SwitchStatement => {
1507 + let node = SwitchStatement::convert(cx, node);
1508 + Statement::SwitchStatement(Box::new(node))
1509 + }
1510 + NodeKind::ThrowStatement => {
1511 + let node = ThrowStatement::convert(cx, node);
1512 + Statement::ThrowStatement(Box::new(node))
1513 + }
1514 + NodeKind::TryStatement => {
1515 + let node = TryStatement::convert(cx, node);
1516 + Statement::TryStatement(Box::new(node))
1517 + }
1518 + NodeKind::VariableDeclaration => {
1519 + let node = VariableDeclaration::convert(cx, node);
1520 + Statement::VariableDeclaration(Box::new(node))
1521 + }
1522 + NodeKind::WhileStatement => {
1523 + let node = WhileStatement::convert(cx, node);
1524 + Statement::WhileStatement(Box::new(node))
1525 + }
1526 + NodeKind::WithStatement => {
1527 + let node = WithStatement::convert(cx, node);
1528 + Statement::WithStatement(Box::new(node))
1529 + }
1530 + _ => panic!("Unexpected node"),
1531 + }
1532 + }
1533 +}
1534 +impl FromHermes for Expression {
1535 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1536 + let node_ref = node.as_ref();
1537 + match node_ref.kind {
1538 + NodeKind::ArrayExpression => {
1539 + let node = ArrayExpression::convert(cx, node);
1540 + Expression::ArrayExpression(Box::new(node))
1541 + }
1542 + NodeKind::ArrowFunctionExpression => {
1543 + let node = ArrowFunctionExpression::convert(cx, node);
1544 + Expression::ArrowFunctionExpression(Box::new(node))
1545 + }
1546 + NodeKind::AssignmentExpression => {
1547 + let node = AssignmentExpression::convert(cx, node);
1548 + Expression::AssignmentExpression(Box::new(node))
1549 + }
1550 + NodeKind::AwaitExpression => {
1551 + let node = AwaitExpression::convert(cx, node);
1552 + Expression::AwaitExpression(Box::new(node))
1553 + }
1554 + NodeKind::BinaryExpression => {
1555 + let node = BinaryExpression::convert(cx, node);
1556 + Expression::BinaryExpression(Box::new(node))
1557 + }
1558 + NodeKind::BooleanLiteral => {
1559 + let node = BooleanLiteral::convert(cx, node);
1560 + Expression::BooleanLiteral(Box::new(node))
1561 + }
1562 + NodeKind::CallExpression => {
1563 + let node = CallExpression::convert(cx, node);
1564 + Expression::CallExpression(Box::new(node))
1565 + }
1566 + NodeKind::ClassExpression => {
1567 + let node = ClassExpression::convert(cx, node);
1568 + Expression::ClassExpression(Box::new(node))
1569 + }
1570 + NodeKind::ConditionalExpression => {
1571 + let node = ConditionalExpression::convert(cx, node);
1572 + Expression::ConditionalExpression(Box::new(node))
1573 + }
1574 + NodeKind::FunctionExpression => {
1575 + let node = FunctionExpression::convert(cx, node);
1576 + Expression::FunctionExpression(Box::new(node))
1577 + }
1578 + NodeKind::Identifier => {
1579 + let node = Identifier::convert(cx, node);
1580 + Expression::Identifier(Box::new(node))
1581 + }
1582 + NodeKind::ImportExpression => {
1583 + let node = ImportExpression::convert(cx, node);
1584 + Expression::ImportExpression(Box::new(node))
1585 + }
1586 + NodeKind::JSXElement => {
1587 + let node = JSXElement::convert(cx, node);
1588 + Expression::JSXElement(Box::new(node))
1589 + }
1590 + NodeKind::LogicalExpression => {
1591 + let node = LogicalExpression::convert(cx, node);
1592 + Expression::LogicalExpression(Box::new(node))
1593 + }
1594 + NodeKind::MemberExpression => {
1595 + let node = MemberExpression::convert(cx, node);
1596 + Expression::MemberExpression(Box::new(node))
1597 + }
1598 + NodeKind::MetaProperty => {
1599 + let node = MetaProperty::convert(cx, node);
1600 + Expression::MetaProperty(Box::new(node))
1601 + }
1602 + NodeKind::NewExpression => {
1603 + let node = NewExpression::convert(cx, node);
1604 + Expression::NewExpression(Box::new(node))
1605 + }
1606 + NodeKind::NullLiteral => {
1607 + let node = NullLiteral::convert(cx, node);
1608 + Expression::NullLiteral(Box::new(node))
1609 + }
1610 + NodeKind::NumericLiteral => {
1611 + let node = NumericLiteral::convert(cx, node);
1612 + Expression::NumericLiteral(Box::new(node))
1613 + }
1614 + NodeKind::ObjectExpression => {
1615 + let node = ObjectExpression::convert(cx, node);
1616 + Expression::ObjectExpression(Box::new(node))
1617 + }
1618 + NodeKind::OptionalCallExpression => {
1619 + let node = OptionalCallExpression::convert(cx, node);
1620 + Expression::OptionalCallExpression(Box::new(node))
1621 + }
1622 + NodeKind::OptionalMemberExpression => {
1623 + let node = OptionalMemberExpression::convert(cx, node);
1624 + Expression::OptionalMemberExpression(Box::new(node))
1625 + }
1626 + NodeKind::SequenceExpression => {
1627 + let node = SequenceExpression::convert(cx, node);
1628 + Expression::SequenceExpression(Box::new(node))
1629 + }
1630 + NodeKind::StringLiteral => {
1631 + let node = StringLiteral::convert(cx, node);
1632 + Expression::StringLiteral(Box::new(node))
1633 + }
1634 + NodeKind::TaggedTemplateExpression => {
1635 + let node = TaggedTemplateExpression::convert(cx, node);
1636 + Expression::TaggedTemplateExpression(Box::new(node))
1637 + }
1638 + NodeKind::TemplateLiteral => {
1639 + let node = TemplateLiteral::convert(cx, node);
1640 + Expression::TemplateLiteral(Box::new(node))
1641 + }
1642 + NodeKind::ThisExpression => {
1643 + let node = ThisExpression::convert(cx, node);
1644 + Expression::ThisExpression(Box::new(node))
1645 + }
1646 + NodeKind::UnaryExpression => {
1647 + let node = UnaryExpression::convert(cx, node);
1648 + Expression::UnaryExpression(Box::new(node))
1649 + }
1650 + NodeKind::UpdateExpression => {
1651 + let node = UpdateExpression::convert(cx, node);
1652 + Expression::UpdateExpression(Box::new(node))
1653 + }
1654 + NodeKind::YieldExpression => {
1655 + let node = YieldExpression::convert(cx, node);
1656 + Expression::YieldExpression(Box::new(node))
1657 + }
1658 + _ => panic!("Unexpected node"),
1659 + }
1660 + }
1661 +}
1662 +impl FromHermes for _Literal {
1663 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1664 + let node_ref = node.as_ref();
1665 + match node_ref.kind {
1666 + NodeKind::BooleanLiteral => {
1667 + let node = BooleanLiteral::convert(cx, node);
1668 + _Literal::BooleanLiteral(Box::new(node))
1669 + }
1670 + NodeKind::NullLiteral => {
1671 + let node = NullLiteral::convert(cx, node);
1672 + _Literal::NullLiteral(Box::new(node))
1673 + }
1674 + NodeKind::StringLiteral => {
1675 + let node = StringLiteral::convert(cx, node);
1676 + _Literal::StringLiteral(Box::new(node))
1677 + }
1678 + NodeKind::NumericLiteral => {
1679 + let node = NumericLiteral::convert(cx, node);
1680 + _Literal::NumericLiteral(Box::new(node))
1681 + }
1682 + _ => panic!("Unexpected node"),
1683 + }
1684 + }
1685 +}
1686 +impl FromHermes for Declaration {
1687 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1688 + let node_ref = node.as_ref();
1689 + match node_ref.kind {
1690 + NodeKind::ClassDeclaration => {
1691 + let node = ClassDeclaration::convert(cx, node);
1692 + Declaration::ClassDeclaration(Box::new(node))
1693 + }
1694 + NodeKind::FunctionDeclaration => {
1695 + let node = FunctionDeclaration::convert(cx, node);
1696 + Declaration::FunctionDeclaration(Box::new(node))
1697 + }
1698 + NodeKind::VariableDeclaration => {
1699 + let node = VariableDeclaration::convert(cx, node);
1700 + Declaration::VariableDeclaration(Box::new(node))
1701 + }
1702 + _ => panic!("Unexpected node"),
1703 + }
1704 + }
1705 +}
1706 +impl FromHermes for ImportDeclarationSpecifier {
1707 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1708 + let node_ref = node.as_ref();
1709 + match node_ref.kind {
1710 + NodeKind::ImportSpecifier => {
1711 + let node = ImportSpecifier::convert(cx, node);
1712 + ImportDeclarationSpecifier::ImportSpecifier(Box::new(node))
1713 + }
1714 + NodeKind::ImportDefaultSpecifier => {
1715 + let node = ImportDefaultSpecifier::convert(cx, node);
1716 + ImportDeclarationSpecifier::ImportDefaultSpecifier(Box::new(node))
1717 + }
1718 + NodeKind::ImportNamespaceSpecifier => {
1719 + let node = ImportNamespaceSpecifier::convert(cx, node);
1720 + ImportDeclarationSpecifier::ImportNamespaceSpecifier(Box::new(node))
1721 + }
1722 + _ => panic!("Unexpected node"),
1723 + }
1724 + }
1725 +}
1726 +impl FromHermes for ModuleItem {
1727 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1728 + let node_ref = node.as_ref();
1729 + match node_ref.kind {
1730 + NodeKind::ImportDeclaration => {
1731 + let node = ImportDeclaration::convert(cx, node);
1732 + ModuleItem::ImportOrExportDeclaration(
1733 + ImportOrExportDeclaration::ImportDeclaration(Box::new(node)),
1734 + )
1735 + }
1736 + NodeKind::ExportNamedDeclaration => {
1737 + let node = ExportNamedDeclaration::convert(cx, node);
1738 + ModuleItem::ImportOrExportDeclaration(
1739 + ImportOrExportDeclaration::ExportNamedDeclaration(Box::new(node)),
1740 + )
1741 + }
1742 + NodeKind::ExportDefaultDeclaration => {
1743 + let node = ExportDefaultDeclaration::convert(cx, node);
1744 + ModuleItem::ImportOrExportDeclaration(
1745 + ImportOrExportDeclaration::ExportDefaultDeclaration(Box::new(node)),
1746 + )
1747 + }
1748 + NodeKind::ExportAllDeclaration => {
1749 + let node = ExportAllDeclaration::convert(cx, node);
1750 + ModuleItem::ImportOrExportDeclaration(
1751 + ImportOrExportDeclaration::ExportAllDeclaration(Box::new(node)),
1752 + )
1753 + }
1754 + NodeKind::BlockStatement => {
1755 + let node = BlockStatement::convert(cx, node);
1756 + ModuleItem::Statement(Statement::BlockStatement(Box::new(node)))
1757 + }
1758 + NodeKind::BreakStatement => {
1759 + let node = BreakStatement::convert(cx, node);
1760 + ModuleItem::Statement(Statement::BreakStatement(Box::new(node)))
1761 + }
1762 + NodeKind::ClassDeclaration => {
1763 + let node = ClassDeclaration::convert(cx, node);
1764 + ModuleItem::Statement(Statement::ClassDeclaration(Box::new(node)))
1765 + }
1766 + NodeKind::ContinueStatement => {
1767 + let node = ContinueStatement::convert(cx, node);
1768 + ModuleItem::Statement(Statement::ContinueStatement(Box::new(node)))
1769 + }
1770 + NodeKind::DebuggerStatement => {
1771 + let node = DebuggerStatement::convert(cx, node);
1772 + ModuleItem::Statement(Statement::DebuggerStatement(Box::new(node)))
1773 + }
1774 + NodeKind::DoWhileStatement => {
1775 + let node = DoWhileStatement::convert(cx, node);
1776 + ModuleItem::Statement(Statement::DoWhileStatement(Box::new(node)))
1777 + }
1778 + NodeKind::EmptyStatement => {
1779 + let node = EmptyStatement::convert(cx, node);
1780 + ModuleItem::Statement(Statement::EmptyStatement(Box::new(node)))
1781 + }
1782 + NodeKind::ExpressionStatement => {
1783 + let node = ExpressionStatement::convert(cx, node);
1784 + ModuleItem::Statement(Statement::ExpressionStatement(Box::new(node)))
1785 + }
1786 + NodeKind::ForInStatement => {
1787 + let node = ForInStatement::convert(cx, node);
1788 + ModuleItem::Statement(Statement::ForInStatement(Box::new(node)))
1789 + }
1790 + NodeKind::ForOfStatement => {
1791 + let node = ForOfStatement::convert(cx, node);
1792 + ModuleItem::Statement(Statement::ForOfStatement(Box::new(node)))
1793 + }
1794 + NodeKind::ForStatement => {
1795 + let node = ForStatement::convert(cx, node);
1796 + ModuleItem::Statement(Statement::ForStatement(Box::new(node)))
1797 + }
1798 + NodeKind::FunctionDeclaration => {
1799 + let node = FunctionDeclaration::convert(cx, node);
1800 + ModuleItem::Statement(Statement::FunctionDeclaration(Box::new(node)))
1801 + }
1802 + NodeKind::IfStatement => {
1803 + let node = IfStatement::convert(cx, node);
1804 + ModuleItem::Statement(Statement::IfStatement(Box::new(node)))
1805 + }
1806 + NodeKind::LabeledStatement => {
1807 + let node = LabeledStatement::convert(cx, node);
1808 + ModuleItem::Statement(Statement::LabeledStatement(Box::new(node)))
1809 + }
1810 + NodeKind::ReturnStatement => {
1811 + let node = ReturnStatement::convert(cx, node);
1812 + ModuleItem::Statement(Statement::ReturnStatement(Box::new(node)))
1813 + }
1814 + NodeKind::SwitchStatement => {
1815 + let node = SwitchStatement::convert(cx, node);
1816 + ModuleItem::Statement(Statement::SwitchStatement(Box::new(node)))
1817 + }
1818 + NodeKind::ThrowStatement => {
1819 + let node = ThrowStatement::convert(cx, node);
1820 + ModuleItem::Statement(Statement::ThrowStatement(Box::new(node)))
1821 + }
1822 + NodeKind::TryStatement => {
1823 + let node = TryStatement::convert(cx, node);
1824 + ModuleItem::Statement(Statement::TryStatement(Box::new(node)))
1825 + }
1826 + NodeKind::VariableDeclaration => {
1827 + let node = VariableDeclaration::convert(cx, node);
1828 + ModuleItem::Statement(Statement::VariableDeclaration(Box::new(node)))
1829 + }
1830 + NodeKind::WhileStatement => {
1831 + let node = WhileStatement::convert(cx, node);
1832 + ModuleItem::Statement(Statement::WhileStatement(Box::new(node)))
1833 + }
1834 + NodeKind::WithStatement => {
1835 + let node = WithStatement::convert(cx, node);
1836 + ModuleItem::Statement(Statement::WithStatement(Box::new(node)))
1837 + }
1838 + _ => panic!("Unexpected node"),
1839 + }
1840 + }
1841 +}
1842 +impl FromHermes for ImportOrExportDeclaration {
1843 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1844 + let node_ref = node.as_ref();
1845 + match node_ref.kind {
1846 + NodeKind::ImportDeclaration => {
1847 + let node = ImportDeclaration::convert(cx, node);
1848 + ImportOrExportDeclaration::ImportDeclaration(Box::new(node))
1849 + }
1850 + NodeKind::ExportNamedDeclaration => {
1851 + let node = ExportNamedDeclaration::convert(cx, node);
1852 + ImportOrExportDeclaration::ExportNamedDeclaration(Box::new(node))
1853 + }
1854 + NodeKind::ExportDefaultDeclaration => {
1855 + let node = ExportDefaultDeclaration::convert(cx, node);
1856 + ImportOrExportDeclaration::ExportDefaultDeclaration(Box::new(node))
1857 + }
1858 + NodeKind::ExportAllDeclaration => {
1859 + let node = ExportAllDeclaration::convert(cx, node);
1860 + ImportOrExportDeclaration::ExportAllDeclaration(Box::new(node))
1861 + }
1862 + _ => panic!("Unexpected node"),
1863 + }
1864 + }
1865 +}
1866 +impl FromHermes for ExpressionOrSuper {
1867 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
1868 + let node_ref = node.as_ref();
1869 + match node_ref.kind {
1870 + NodeKind::ArrayExpression => {
1871 + let node = ArrayExpression::convert(cx, node);
1872 + ExpressionOrSuper::Expression(
1873 + Expression::ArrayExpression(Box::new(node)),
1874 + )
1875 + }
1876 + NodeKind::ArrowFunctionExpression => {
1877 + let node = ArrowFunctionExpression::convert(cx, node);
1878 + ExpressionOrSuper::Expression(
1879 + Expression::ArrowFunctionExpression(Box::new(node)),
1880 + )
1881 + }
1882 + NodeKind::AssignmentExpression => {
1883 + let node = AssignmentExpression::convert(cx, node);
1884 + ExpressionOrSuper::Expression(
1885 + Expression::AssignmentExpression(Box::new(node)),
1886 + )
1887 + }
1888 + NodeKind::AwaitExpression => {
1889 + let node = AwaitExpression::convert(cx, node);
1890 + ExpressionOrSuper::Expression(
1891 + Expression::AwaitExpression(Box::new(node)),
1892 + )
1893 + }
1894 + NodeKind::BinaryExpression => {
1895 + let node = BinaryExpression::convert(cx, node);
1896 + ExpressionOrSuper::Expression(
1897 + Expression::BinaryExpression(Box::new(node)),
1898 + )
1899 + }
1900 + NodeKind::BooleanLiteral => {
1901 + let node = BooleanLiteral::convert(cx, node);
1902 + ExpressionOrSuper::Expression(Expression::BooleanLiteral(Box::new(node)))
1903 + }
1904 + NodeKind::CallExpression => {
1905 + let node = CallExpression::convert(cx, node);
1906 + ExpressionOrSuper::Expression(Expression::CallExpression(Box::new(node)))
1907 + }
1908 + NodeKind::ClassExpression => {
1909 + let node = ClassExpression::convert(cx, node);
1910 + ExpressionOrSuper::Expression(
1911 + Expression::ClassExpression(Box::new(node)),
1912 + )
1913 + }
1914 + NodeKind::ConditionalExpression => {
1915 + let node = ConditionalExpression::convert(cx, node);
1916 + ExpressionOrSuper::Expression(
1917 + Expression::ConditionalExpression(Box::new(node)),
1918 + )
1919 + }
1920 + NodeKind::FunctionExpression => {
1921 + let node = FunctionExpression::convert(cx, node);
1922 + ExpressionOrSuper::Expression(
1923 + Expression::FunctionExpression(Box::new(node)),
1924 + )
1925 + }
1926 + NodeKind::Identifier => {
1927 + let node = Identifier::convert(cx, node);
1928 + ExpressionOrSuper::Expression(Expression::Identifier(Box::new(node)))
1929 + }
1930 + NodeKind::ImportExpression => {
1931 + let node = ImportExpression::convert(cx, node);
1932 + ExpressionOrSuper::Expression(
1933 + Expression::ImportExpression(Box::new(node)),
1934 + )
1935 + }
1936 + NodeKind::JSXElement => {
1937 + let node = JSXElement::convert(cx, node);
1938 + ExpressionOrSuper::Expression(Expression::JSXElement(Box::new(node)))
1939 + }
1940 + NodeKind::LogicalExpression => {
1941 + let node = LogicalExpression::convert(cx, node);
1942 + ExpressionOrSuper::Expression(
1943 + Expression::LogicalExpression(Box::new(node)),
1944 + )
1945 + }
1946 + NodeKind::MemberExpression => {
1947 + let node = MemberExpression::convert(cx, node);
1948 + ExpressionOrSuper::Expression(
1949 + Expression::MemberExpression(Box::new(node)),
1950 + )
1951 + }
1952 + NodeKind::MetaProperty => {
1953 + let node = MetaProperty::convert(cx, node);
1954 + ExpressionOrSuper::Expression(Expression::MetaProperty(Box::new(node)))
1955 + }
1956 + NodeKind::NewExpression => {
1957 + let node = NewExpression::convert(cx, node);
1958 + ExpressionOrSuper::Expression(Expression::NewExpression(Box::new(node)))
1959 + }
1960 + NodeKind::NullLiteral => {
1961 + let node = NullLiteral::convert(cx, node);
1962 + ExpressionOrSuper::Expression(Expression::NullLiteral(Box::new(node)))
1963 + }
1964 + NodeKind::NumericLiteral => {
1965 + let node = NumericLiteral::convert(cx, node);
1966 + ExpressionOrSuper::Expression(Expression::NumericLiteral(Box::new(node)))
1967 + }
1968 + NodeKind::ObjectExpression => {
1969 + let node = ObjectExpression::convert(cx, node);
1970 + ExpressionOrSuper::Expression(
1971 + Expression::ObjectExpression(Box::new(node)),
1972 + )
1973 + }
1974 + NodeKind::OptionalCallExpression => {
1975 + let node = OptionalCallExpression::convert(cx, node);
1976 + ExpressionOrSuper::Expression(
1977 + Expression::OptionalCallExpression(Box::new(node)),
1978 + )
1979 + }
1980 + NodeKind::OptionalMemberExpression => {
1981 + let node = OptionalMemberExpression::convert(cx, node);
1982 + ExpressionOrSuper::Expression(
1983 + Expression::OptionalMemberExpression(Box::new(node)),
1984 + )
1985 + }
1986 + NodeKind::SequenceExpression => {
1987 + let node = SequenceExpression::convert(cx, node);
1988 + ExpressionOrSuper::Expression(
1989 + Expression::SequenceExpression(Box::new(node)),
1990 + )
1991 + }
1992 + NodeKind::StringLiteral => {
1993 + let node = StringLiteral::convert(cx, node);
1994 + ExpressionOrSuper::Expression(Expression::StringLiteral(Box::new(node)))
1995 + }
1996 + NodeKind::TaggedTemplateExpression => {
1997 + let node = TaggedTemplateExpression::convert(cx, node);
1998 + ExpressionOrSuper::Expression(
1999 + Expression::TaggedTemplateExpression(Box::new(node)),
2000 + )
2001 + }
2002 + NodeKind::TemplateLiteral => {
2003 + let node = TemplateLiteral::convert(cx, node);
2004 + ExpressionOrSuper::Expression(
2005 + Expression::TemplateLiteral(Box::new(node)),
2006 + )
2007 + }
2008 + NodeKind::ThisExpression => {
2009 + let node = ThisExpression::convert(cx, node);
2010 + ExpressionOrSuper::Expression(Expression::ThisExpression(Box::new(node)))
2011 + }
2012 + NodeKind::UnaryExpression => {
2013 + let node = UnaryExpression::convert(cx, node);
2014 + ExpressionOrSuper::Expression(
2015 + Expression::UnaryExpression(Box::new(node)),
2016 + )
2017 + }
2018 + NodeKind::UpdateExpression => {
2019 + let node = UpdateExpression::convert(cx, node);
2020 + ExpressionOrSuper::Expression(
2021 + Expression::UpdateExpression(Box::new(node)),
2022 + )
2023 + }
2024 + NodeKind::YieldExpression => {
2025 + let node = YieldExpression::convert(cx, node);
2026 + ExpressionOrSuper::Expression(
2027 + Expression::YieldExpression(Box::new(node)),
2028 + )
2029 + }
2030 + NodeKind::Super => {
2031 + let node = Super::convert(cx, node);
2032 + ExpressionOrSuper::Super(Box::new(node))
2033 + }
2034 + _ => panic!("Unexpected node"),
2035 + }
2036 + }
2037 +}
2038 +impl FromHermes for ExpressionOrSpread {
2039 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2040 + let node_ref = node.as_ref();
2041 + match node_ref.kind {
2042 + NodeKind::ArrayExpression => {
2043 + let node = ArrayExpression::convert(cx, node);
2044 + ExpressionOrSpread::Expression(
2045 + Expression::ArrayExpression(Box::new(node)),
2046 + )
2047 + }
2048 + NodeKind::ArrowFunctionExpression => {
2049 + let node = ArrowFunctionExpression::convert(cx, node);
2050 + ExpressionOrSpread::Expression(
2051 + Expression::ArrowFunctionExpression(Box::new(node)),
2052 + )
2053 + }
2054 + NodeKind::AssignmentExpression => {
2055 + let node = AssignmentExpression::convert(cx, node);
2056 + ExpressionOrSpread::Expression(
2057 + Expression::AssignmentExpression(Box::new(node)),
2058 + )
2059 + }
2060 + NodeKind::AwaitExpression => {
2061 + let node = AwaitExpression::convert(cx, node);
2062 + ExpressionOrSpread::Expression(
2063 + Expression::AwaitExpression(Box::new(node)),
2064 + )
2065 + }
2066 + NodeKind::BinaryExpression => {
2067 + let node = BinaryExpression::convert(cx, node);
2068 + ExpressionOrSpread::Expression(
2069 + Expression::BinaryExpression(Box::new(node)),
2070 + )
2071 + }
2072 + NodeKind::BooleanLiteral => {
2073 + let node = BooleanLiteral::convert(cx, node);
2074 + ExpressionOrSpread::Expression(
2075 + Expression::BooleanLiteral(Box::new(node)),
2076 + )
2077 + }
2078 + NodeKind::CallExpression => {
2079 + let node = CallExpression::convert(cx, node);
2080 + ExpressionOrSpread::Expression(
2081 + Expression::CallExpression(Box::new(node)),
2082 + )
2083 + }
2084 + NodeKind::ClassExpression => {
2085 + let node = ClassExpression::convert(cx, node);
2086 + ExpressionOrSpread::Expression(
2087 + Expression::ClassExpression(Box::new(node)),
2088 + )
2089 + }
2090 + NodeKind::ConditionalExpression => {
2091 + let node = ConditionalExpression::convert(cx, node);
2092 + ExpressionOrSpread::Expression(
2093 + Expression::ConditionalExpression(Box::new(node)),
2094 + )
2095 + }
2096 + NodeKind::FunctionExpression => {
2097 + let node = FunctionExpression::convert(cx, node);
2098 + ExpressionOrSpread::Expression(
2099 + Expression::FunctionExpression(Box::new(node)),
2100 + )
2101 + }
2102 + NodeKind::Identifier => {
2103 + let node = Identifier::convert(cx, node);
2104 + ExpressionOrSpread::Expression(Expression::Identifier(Box::new(node)))
2105 + }
2106 + NodeKind::ImportExpression => {
2107 + let node = ImportExpression::convert(cx, node);
2108 + ExpressionOrSpread::Expression(
2109 + Expression::ImportExpression(Box::new(node)),
2110 + )
2111 + }
2112 + NodeKind::JSXElement => {
2113 + let node = JSXElement::convert(cx, node);
2114 + ExpressionOrSpread::Expression(Expression::JSXElement(Box::new(node)))
2115 + }
2116 + NodeKind::LogicalExpression => {
2117 + let node = LogicalExpression::convert(cx, node);
2118 + ExpressionOrSpread::Expression(
2119 + Expression::LogicalExpression(Box::new(node)),
2120 + )
2121 + }
2122 + NodeKind::MemberExpression => {
2123 + let node = MemberExpression::convert(cx, node);
2124 + ExpressionOrSpread::Expression(
2125 + Expression::MemberExpression(Box::new(node)),
2126 + )
2127 + }
2128 + NodeKind::MetaProperty => {
2129 + let node = MetaProperty::convert(cx, node);
2130 + ExpressionOrSpread::Expression(Expression::MetaProperty(Box::new(node)))
2131 + }
2132 + NodeKind::NewExpression => {
2133 + let node = NewExpression::convert(cx, node);
2134 + ExpressionOrSpread::Expression(Expression::NewExpression(Box::new(node)))
2135 + }
2136 + NodeKind::NullLiteral => {
2137 + let node = NullLiteral::convert(cx, node);
2138 + ExpressionOrSpread::Expression(Expression::NullLiteral(Box::new(node)))
2139 + }
2140 + NodeKind::NumericLiteral => {
2141 + let node = NumericLiteral::convert(cx, node);
2142 + ExpressionOrSpread::Expression(
2143 + Expression::NumericLiteral(Box::new(node)),
2144 + )
2145 + }
2146 + NodeKind::ObjectExpression => {
2147 + let node = ObjectExpression::convert(cx, node);
2148 + ExpressionOrSpread::Expression(
2149 + Expression::ObjectExpression(Box::new(node)),
2150 + )
2151 + }
2152 + NodeKind::OptionalCallExpression => {
2153 + let node = OptionalCallExpression::convert(cx, node);
2154 + ExpressionOrSpread::Expression(
2155 + Expression::OptionalCallExpression(Box::new(node)),
2156 + )
2157 + }
2158 + NodeKind::OptionalMemberExpression => {
2159 + let node = OptionalMemberExpression::convert(cx, node);
2160 + ExpressionOrSpread::Expression(
2161 + Expression::OptionalMemberExpression(Box::new(node)),
2162 + )
2163 + }
2164 + NodeKind::SequenceExpression => {
2165 + let node = SequenceExpression::convert(cx, node);
2166 + ExpressionOrSpread::Expression(
2167 + Expression::SequenceExpression(Box::new(node)),
2168 + )
2169 + }
2170 + NodeKind::StringLiteral => {
2171 + let node = StringLiteral::convert(cx, node);
2172 + ExpressionOrSpread::Expression(Expression::StringLiteral(Box::new(node)))
2173 + }
2174 + NodeKind::TaggedTemplateExpression => {
2175 + let node = TaggedTemplateExpression::convert(cx, node);
2176 + ExpressionOrSpread::Expression(
2177 + Expression::TaggedTemplateExpression(Box::new(node)),
2178 + )
2179 + }
2180 + NodeKind::TemplateLiteral => {
2181 + let node = TemplateLiteral::convert(cx, node);
2182 + ExpressionOrSpread::Expression(
2183 + Expression::TemplateLiteral(Box::new(node)),
2184 + )
2185 + }
2186 + NodeKind::ThisExpression => {
2187 + let node = ThisExpression::convert(cx, node);
2188 + ExpressionOrSpread::Expression(
2189 + Expression::ThisExpression(Box::new(node)),
2190 + )
2191 + }
2192 + NodeKind::UnaryExpression => {
2193 + let node = UnaryExpression::convert(cx, node);
2194 + ExpressionOrSpread::Expression(
2195 + Expression::UnaryExpression(Box::new(node)),
2196 + )
2197 + }
2198 + NodeKind::UpdateExpression => {
2199 + let node = UpdateExpression::convert(cx, node);
2200 + ExpressionOrSpread::Expression(
2201 + Expression::UpdateExpression(Box::new(node)),
2202 + )
2203 + }
2204 + NodeKind::YieldExpression => {
2205 + let node = YieldExpression::convert(cx, node);
2206 + ExpressionOrSpread::Expression(
2207 + Expression::YieldExpression(Box::new(node)),
2208 + )
2209 + }
2210 + NodeKind::SpreadElement => {
2211 + let node = SpreadElement::convert(cx, node);
2212 + ExpressionOrSpread::SpreadElement(Box::new(node))
2213 + }
2214 + _ => panic!("Unexpected node"),
2215 + }
2216 + }
2217 +}
2218 +impl FromHermes for FunctionBody {
2219 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2220 + let node_ref = node.as_ref();
2221 + match node_ref.kind {
2222 + NodeKind::BlockStatement => {
2223 + let node = BlockStatement::convert(cx, node);
2224 + FunctionBody::BlockStatement(Box::new(node))
2225 + }
2226 + NodeKind::ArrayExpression => {
2227 + let node = ArrayExpression::convert(cx, node);
2228 + FunctionBody::Expression(Expression::ArrayExpression(Box::new(node)))
2229 + }
2230 + NodeKind::ArrowFunctionExpression => {
2231 + let node = ArrowFunctionExpression::convert(cx, node);
2232 + FunctionBody::Expression(
2233 + Expression::ArrowFunctionExpression(Box::new(node)),
2234 + )
2235 + }
2236 + NodeKind::AssignmentExpression => {
2237 + let node = AssignmentExpression::convert(cx, node);
2238 + FunctionBody::Expression(
2239 + Expression::AssignmentExpression(Box::new(node)),
2240 + )
2241 + }
2242 + NodeKind::AwaitExpression => {
2243 + let node = AwaitExpression::convert(cx, node);
2244 + FunctionBody::Expression(Expression::AwaitExpression(Box::new(node)))
2245 + }
2246 + NodeKind::BinaryExpression => {
2247 + let node = BinaryExpression::convert(cx, node);
2248 + FunctionBody::Expression(Expression::BinaryExpression(Box::new(node)))
2249 + }
2250 + NodeKind::BooleanLiteral => {
2251 + let node = BooleanLiteral::convert(cx, node);
2252 + FunctionBody::Expression(Expression::BooleanLiteral(Box::new(node)))
2253 + }
2254 + NodeKind::CallExpression => {
2255 + let node = CallExpression::convert(cx, node);
2256 + FunctionBody::Expression(Expression::CallExpression(Box::new(node)))
2257 + }
2258 + NodeKind::ClassExpression => {
2259 + let node = ClassExpression::convert(cx, node);
2260 + FunctionBody::Expression(Expression::ClassExpression(Box::new(node)))
2261 + }
2262 + NodeKind::ConditionalExpression => {
2263 + let node = ConditionalExpression::convert(cx, node);
2264 + FunctionBody::Expression(
2265 + Expression::ConditionalExpression(Box::new(node)),
2266 + )
2267 + }
2268 + NodeKind::FunctionExpression => {
2269 + let node = FunctionExpression::convert(cx, node);
2270 + FunctionBody::Expression(Expression::FunctionExpression(Box::new(node)))
2271 + }
2272 + NodeKind::Identifier => {
2273 + let node = Identifier::convert(cx, node);
2274 + FunctionBody::Expression(Expression::Identifier(Box::new(node)))
2275 + }
2276 + NodeKind::ImportExpression => {
2277 + let node = ImportExpression::convert(cx, node);
2278 + FunctionBody::Expression(Expression::ImportExpression(Box::new(node)))
2279 + }
2280 + NodeKind::JSXElement => {
2281 + let node = JSXElement::convert(cx, node);
2282 + FunctionBody::Expression(Expression::JSXElement(Box::new(node)))
2283 + }
2284 + NodeKind::LogicalExpression => {
2285 + let node = LogicalExpression::convert(cx, node);
2286 + FunctionBody::Expression(Expression::LogicalExpression(Box::new(node)))
2287 + }
2288 + NodeKind::MemberExpression => {
2289 + let node = MemberExpression::convert(cx, node);
2290 + FunctionBody::Expression(Expression::MemberExpression(Box::new(node)))
2291 + }
2292 + NodeKind::MetaProperty => {
2293 + let node = MetaProperty::convert(cx, node);
2294 + FunctionBody::Expression(Expression::MetaProperty(Box::new(node)))
2295 + }
2296 + NodeKind::NewExpression => {
2297 + let node = NewExpression::convert(cx, node);
2298 + FunctionBody::Expression(Expression::NewExpression(Box::new(node)))
2299 + }
2300 + NodeKind::NullLiteral => {
2301 + let node = NullLiteral::convert(cx, node);
2302 + FunctionBody::Expression(Expression::NullLiteral(Box::new(node)))
2303 + }
2304 + NodeKind::NumericLiteral => {
2305 + let node = NumericLiteral::convert(cx, node);
2306 + FunctionBody::Expression(Expression::NumericLiteral(Box::new(node)))
2307 + }
2308 + NodeKind::ObjectExpression => {
2309 + let node = ObjectExpression::convert(cx, node);
2310 + FunctionBody::Expression(Expression::ObjectExpression(Box::new(node)))
2311 + }
2312 + NodeKind::OptionalCallExpression => {
2313 + let node = OptionalCallExpression::convert(cx, node);
2314 + FunctionBody::Expression(
2315 + Expression::OptionalCallExpression(Box::new(node)),
2316 + )
2317 + }
2318 + NodeKind::OptionalMemberExpression => {
2319 + let node = OptionalMemberExpression::convert(cx, node);
2320 + FunctionBody::Expression(
2321 + Expression::OptionalMemberExpression(Box::new(node)),
2322 + )
2323 + }
2324 + NodeKind::SequenceExpression => {
2325 + let node = SequenceExpression::convert(cx, node);
2326 + FunctionBody::Expression(Expression::SequenceExpression(Box::new(node)))
2327 + }
2328 + NodeKind::StringLiteral => {
2329 + let node = StringLiteral::convert(cx, node);
2330 + FunctionBody::Expression(Expression::StringLiteral(Box::new(node)))
2331 + }
2332 + NodeKind::TaggedTemplateExpression => {
2333 + let node = TaggedTemplateExpression::convert(cx, node);
2334 + FunctionBody::Expression(
2335 + Expression::TaggedTemplateExpression(Box::new(node)),
2336 + )
2337 + }
2338 + NodeKind::TemplateLiteral => {
2339 + let node = TemplateLiteral::convert(cx, node);
2340 + FunctionBody::Expression(Expression::TemplateLiteral(Box::new(node)))
2341 + }
2342 + NodeKind::ThisExpression => {
2343 + let node = ThisExpression::convert(cx, node);
2344 + FunctionBody::Expression(Expression::ThisExpression(Box::new(node)))
2345 + }
2346 + NodeKind::UnaryExpression => {
2347 + let node = UnaryExpression::convert(cx, node);
2348 + FunctionBody::Expression(Expression::UnaryExpression(Box::new(node)))
2349 + }
2350 + NodeKind::UpdateExpression => {
2351 + let node = UpdateExpression::convert(cx, node);
2352 + FunctionBody::Expression(Expression::UpdateExpression(Box::new(node)))
2353 + }
2354 + NodeKind::YieldExpression => {
2355 + let node = YieldExpression::convert(cx, node);
2356 + FunctionBody::Expression(Expression::YieldExpression(Box::new(node)))
2357 + }
2358 + _ => panic!("Unexpected node"),
2359 + }
2360 + }
2361 +}
2362 +impl FromHermes for Pattern {
2363 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2364 + let node_ref = node.as_ref();
2365 + match node_ref.kind {
2366 + NodeKind::Identifier => {
2367 + let node = Identifier::convert(cx, node);
2368 + Pattern::Identifier(Box::new(node))
2369 + }
2370 + NodeKind::ArrayPattern => {
2371 + let node = ArrayPattern::convert(cx, node);
2372 + Pattern::ArrayPattern(Box::new(node))
2373 + }
2374 + NodeKind::ObjectPattern => {
2375 + let node = ObjectPattern::convert(cx, node);
2376 + Pattern::ObjectPattern(Box::new(node))
2377 + }
2378 + NodeKind::RestElement => {
2379 + let node = RestElement::convert(cx, node);
2380 + Pattern::RestElement(Box::new(node))
2381 + }
2382 + NodeKind::AssignmentPattern => {
2383 + let node = AssignmentPattern::convert(cx, node);
2384 + Pattern::AssignmentPattern(Box::new(node))
2385 + }
2386 + _ => panic!("Unexpected node"),
2387 + }
2388 + }
2389 +}
2390 +impl FromHermes for ForInit {
2391 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2392 + let node_ref = node.as_ref();
2393 + match node_ref.kind {
2394 + NodeKind::ArrayExpression => {
2395 + let node = ArrayExpression::convert(cx, node);
2396 + ForInit::Expression(Expression::ArrayExpression(Box::new(node)))
2397 + }
2398 + NodeKind::ArrowFunctionExpression => {
2399 + let node = ArrowFunctionExpression::convert(cx, node);
2400 + ForInit::Expression(Expression::ArrowFunctionExpression(Box::new(node)))
2401 + }
2402 + NodeKind::AssignmentExpression => {
2403 + let node = AssignmentExpression::convert(cx, node);
2404 + ForInit::Expression(Expression::AssignmentExpression(Box::new(node)))
2405 + }
2406 + NodeKind::AwaitExpression => {
2407 + let node = AwaitExpression::convert(cx, node);
2408 + ForInit::Expression(Expression::AwaitExpression(Box::new(node)))
2409 + }
2410 + NodeKind::BinaryExpression => {
2411 + let node = BinaryExpression::convert(cx, node);
2412 + ForInit::Expression(Expression::BinaryExpression(Box::new(node)))
2413 + }
2414 + NodeKind::BooleanLiteral => {
2415 + let node = BooleanLiteral::convert(cx, node);
2416 + ForInit::Expression(Expression::BooleanLiteral(Box::new(node)))
2417 + }
2418 + NodeKind::CallExpression => {
2419 + let node = CallExpression::convert(cx, node);
2420 + ForInit::Expression(Expression::CallExpression(Box::new(node)))
2421 + }
2422 + NodeKind::ClassExpression => {
2423 + let node = ClassExpression::convert(cx, node);
2424 + ForInit::Expression(Expression::ClassExpression(Box::new(node)))
2425 + }
2426 + NodeKind::ConditionalExpression => {
2427 + let node = ConditionalExpression::convert(cx, node);
2428 + ForInit::Expression(Expression::ConditionalExpression(Box::new(node)))
2429 + }
2430 + NodeKind::FunctionExpression => {
2431 + let node = FunctionExpression::convert(cx, node);
2432 + ForInit::Expression(Expression::FunctionExpression(Box::new(node)))
2433 + }
2434 + NodeKind::Identifier => {
2435 + let node = Identifier::convert(cx, node);
2436 + ForInit::Expression(Expression::Identifier(Box::new(node)))
2437 + }
2438 + NodeKind::ImportExpression => {
2439 + let node = ImportExpression::convert(cx, node);
2440 + ForInit::Expression(Expression::ImportExpression(Box::new(node)))
2441 + }
2442 + NodeKind::JSXElement => {
2443 + let node = JSXElement::convert(cx, node);
2444 + ForInit::Expression(Expression::JSXElement(Box::new(node)))
2445 + }
2446 + NodeKind::LogicalExpression => {
2447 + let node = LogicalExpression::convert(cx, node);
2448 + ForInit::Expression(Expression::LogicalExpression(Box::new(node)))
2449 + }
2450 + NodeKind::MemberExpression => {
2451 + let node = MemberExpression::convert(cx, node);
2452 + ForInit::Expression(Expression::MemberExpression(Box::new(node)))
2453 + }
2454 + NodeKind::MetaProperty => {
2455 + let node = MetaProperty::convert(cx, node);
2456 + ForInit::Expression(Expression::MetaProperty(Box::new(node)))
2457 + }
2458 + NodeKind::NewExpression => {
2459 + let node = NewExpression::convert(cx, node);
2460 + ForInit::Expression(Expression::NewExpression(Box::new(node)))
2461 + }
2462 + NodeKind::NullLiteral => {
2463 + let node = NullLiteral::convert(cx, node);
2464 + ForInit::Expression(Expression::NullLiteral(Box::new(node)))
2465 + }
2466 + NodeKind::NumericLiteral => {
2467 + let node = NumericLiteral::convert(cx, node);
2468 + ForInit::Expression(Expression::NumericLiteral(Box::new(node)))
2469 + }
2470 + NodeKind::ObjectExpression => {
2471 + let node = ObjectExpression::convert(cx, node);
2472 + ForInit::Expression(Expression::ObjectExpression(Box::new(node)))
2473 + }
2474 + NodeKind::OptionalCallExpression => {
2475 + let node = OptionalCallExpression::convert(cx, node);
2476 + ForInit::Expression(Expression::OptionalCallExpression(Box::new(node)))
2477 + }
2478 + NodeKind::OptionalMemberExpression => {
2479 + let node = OptionalMemberExpression::convert(cx, node);
2480 + ForInit::Expression(Expression::OptionalMemberExpression(Box::new(node)))
2481 + }
2482 + NodeKind::SequenceExpression => {
2483 + let node = SequenceExpression::convert(cx, node);
2484 + ForInit::Expression(Expression::SequenceExpression(Box::new(node)))
2485 + }
2486 + NodeKind::StringLiteral => {
2487 + let node = StringLiteral::convert(cx, node);
2488 + ForInit::Expression(Expression::StringLiteral(Box::new(node)))
2489 + }
2490 + NodeKind::TaggedTemplateExpression => {
2491 + let node = TaggedTemplateExpression::convert(cx, node);
2492 + ForInit::Expression(Expression::TaggedTemplateExpression(Box::new(node)))
2493 + }
2494 + NodeKind::TemplateLiteral => {
2495 + let node = TemplateLiteral::convert(cx, node);
2496 + ForInit::Expression(Expression::TemplateLiteral(Box::new(node)))
2497 + }
2498 + NodeKind::ThisExpression => {
2499 + let node = ThisExpression::convert(cx, node);
2500 + ForInit::Expression(Expression::ThisExpression(Box::new(node)))
2501 + }
2502 + NodeKind::UnaryExpression => {
2503 + let node = UnaryExpression::convert(cx, node);
2504 + ForInit::Expression(Expression::UnaryExpression(Box::new(node)))
2505 + }
2506 + NodeKind::UpdateExpression => {
2507 + let node = UpdateExpression::convert(cx, node);
2508 + ForInit::Expression(Expression::UpdateExpression(Box::new(node)))
2509 + }
2510 + NodeKind::YieldExpression => {
2511 + let node = YieldExpression::convert(cx, node);
2512 + ForInit::Expression(Expression::YieldExpression(Box::new(node)))
2513 + }
2514 + NodeKind::VariableDeclaration => {
2515 + let node = VariableDeclaration::convert(cx, node);
2516 + ForInit::VariableDeclaration(Box::new(node))
2517 + }
2518 + _ => panic!("Unexpected node"),
2519 + }
2520 + }
2521 +}
2522 +impl FromHermes for ForInInit {
2523 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2524 + let node_ref = node.as_ref();
2525 + match node_ref.kind {
2526 + NodeKind::Identifier => {
2527 + let node = Identifier::convert(cx, node);
2528 + ForInInit::Pattern(Pattern::Identifier(Box::new(node)))
2529 + }
2530 + NodeKind::ArrayPattern => {
2531 + let node = ArrayPattern::convert(cx, node);
2532 + ForInInit::Pattern(Pattern::ArrayPattern(Box::new(node)))
2533 + }
2534 + NodeKind::ObjectPattern => {
2535 + let node = ObjectPattern::convert(cx, node);
2536 + ForInInit::Pattern(Pattern::ObjectPattern(Box::new(node)))
2537 + }
2538 + NodeKind::RestElement => {
2539 + let node = RestElement::convert(cx, node);
2540 + ForInInit::Pattern(Pattern::RestElement(Box::new(node)))
2541 + }
2542 + NodeKind::AssignmentPattern => {
2543 + let node = AssignmentPattern::convert(cx, node);
2544 + ForInInit::Pattern(Pattern::AssignmentPattern(Box::new(node)))
2545 + }
2546 + NodeKind::VariableDeclaration => {
2547 + let node = VariableDeclaration::convert(cx, node);
2548 + ForInInit::VariableDeclaration(Box::new(node))
2549 + }
2550 + _ => panic!("Unexpected node"),
2551 + }
2552 + }
2553 +}
2554 +impl FromHermes for PropertyOrSpreadElement {
2555 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2556 + let node_ref = node.as_ref();
2557 + match node_ref.kind {
2558 + NodeKind::Property => {
2559 + let node = Property::convert(cx, node);
2560 + PropertyOrSpreadElement::Property(Box::new(node))
2561 + }
2562 + NodeKind::SpreadElement => {
2563 + let node = SpreadElement::convert(cx, node);
2564 + PropertyOrSpreadElement::SpreadElement(Box::new(node))
2565 + }
2566 + _ => panic!("Unexpected node"),
2567 + }
2568 + }
2569 +}
2570 +impl FromHermes for AssignmentPropertyOrRestElement {
2571 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2572 + let node_ref = node.as_ref();
2573 + match node_ref.kind {
2574 + NodeKind::Property => {
2575 + let node = AssignmentProperty::convert(cx, node);
2576 + AssignmentPropertyOrRestElement::AssignmentProperty(Box::new(node))
2577 + }
2578 + NodeKind::RestElement => {
2579 + let node = RestElement::convert(cx, node);
2580 + AssignmentPropertyOrRestElement::RestElement(Box::new(node))
2581 + }
2582 + _ => panic!("Unexpected node"),
2583 + }
2584 + }
2585 +}
2586 +impl FromHermes for PropertyKey {
2587 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2588 + let node_ref = node.as_ref();
2589 + match node_ref.kind {
2590 + NodeKind::Identifier => {
2591 + let node = Identifier::convert(cx, node);
2592 + PropertyKey::Identifier(Box::new(node))
2593 + }
2594 + _ => panic!("Unexpected node"),
2595 + }
2596 + }
2597 +}
2598 +impl FromHermes for AssignmentTarget {
2599 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2600 + let node_ref = node.as_ref();
2601 + match node_ref.kind {
2602 + NodeKind::ArrayExpression => {
2603 + let node = ArrayExpression::convert(cx, node);
2604 + AssignmentTarget::Expression(Expression::ArrayExpression(Box::new(node)))
2605 + }
2606 + NodeKind::ArrowFunctionExpression => {
2607 + let node = ArrowFunctionExpression::convert(cx, node);
2608 + AssignmentTarget::Expression(
2609 + Expression::ArrowFunctionExpression(Box::new(node)),
2610 + )
2611 + }
2612 + NodeKind::AssignmentExpression => {
2613 + let node = AssignmentExpression::convert(cx, node);
2614 + AssignmentTarget::Expression(
2615 + Expression::AssignmentExpression(Box::new(node)),
2616 + )
2617 + }
2618 + NodeKind::AwaitExpression => {
2619 + let node = AwaitExpression::convert(cx, node);
2620 + AssignmentTarget::Expression(Expression::AwaitExpression(Box::new(node)))
2621 + }
2622 + NodeKind::BinaryExpression => {
2623 + let node = BinaryExpression::convert(cx, node);
2624 + AssignmentTarget::Expression(
2625 + Expression::BinaryExpression(Box::new(node)),
2626 + )
2627 + }
2628 + NodeKind::BooleanLiteral => {
2629 + let node = BooleanLiteral::convert(cx, node);
2630 + AssignmentTarget::Expression(Expression::BooleanLiteral(Box::new(node)))
2631 + }
2632 + NodeKind::CallExpression => {
2633 + let node = CallExpression::convert(cx, node);
2634 + AssignmentTarget::Expression(Expression::CallExpression(Box::new(node)))
2635 + }
2636 + NodeKind::ClassExpression => {
2637 + let node = ClassExpression::convert(cx, node);
2638 + AssignmentTarget::Expression(Expression::ClassExpression(Box::new(node)))
2639 + }
2640 + NodeKind::ConditionalExpression => {
2641 + let node = ConditionalExpression::convert(cx, node);
2642 + AssignmentTarget::Expression(
2643 + Expression::ConditionalExpression(Box::new(node)),
2644 + )
2645 + }
2646 + NodeKind::FunctionExpression => {
2647 + let node = FunctionExpression::convert(cx, node);
2648 + AssignmentTarget::Expression(
2649 + Expression::FunctionExpression(Box::new(node)),
2650 + )
2651 + }
2652 + NodeKind::Identifier => {
2653 + let node = Identifier::convert(cx, node);
2654 + AssignmentTarget::Expression(Expression::Identifier(Box::new(node)))
2655 + }
2656 + NodeKind::ImportExpression => {
2657 + let node = ImportExpression::convert(cx, node);
2658 + AssignmentTarget::Expression(
2659 + Expression::ImportExpression(Box::new(node)),
2660 + )
2661 + }
2662 + NodeKind::JSXElement => {
2663 + let node = JSXElement::convert(cx, node);
2664 + AssignmentTarget::Expression(Expression::JSXElement(Box::new(node)))
2665 + }
2666 + NodeKind::LogicalExpression => {
2667 + let node = LogicalExpression::convert(cx, node);
2668 + AssignmentTarget::Expression(
2669 + Expression::LogicalExpression(Box::new(node)),
2670 + )
2671 + }
2672 + NodeKind::MemberExpression => {
2673 + let node = MemberExpression::convert(cx, node);
2674 + AssignmentTarget::Expression(
2675 + Expression::MemberExpression(Box::new(node)),
2676 + )
2677 + }
2678 + NodeKind::MetaProperty => {
2679 + let node = MetaProperty::convert(cx, node);
2680 + AssignmentTarget::Expression(Expression::MetaProperty(Box::new(node)))
2681 + }
2682 + NodeKind::NewExpression => {
2683 + let node = NewExpression::convert(cx, node);
2684 + AssignmentTarget::Expression(Expression::NewExpression(Box::new(node)))
2685 + }
2686 + NodeKind::NullLiteral => {
2687 + let node = NullLiteral::convert(cx, node);
2688 + AssignmentTarget::Expression(Expression::NullLiteral(Box::new(node)))
2689 + }
2690 + NodeKind::NumericLiteral => {
2691 + let node = NumericLiteral::convert(cx, node);
2692 + AssignmentTarget::Expression(Expression::NumericLiteral(Box::new(node)))
2693 + }
2694 + NodeKind::ObjectExpression => {
2695 + let node = ObjectExpression::convert(cx, node);
2696 + AssignmentTarget::Expression(
2697 + Expression::ObjectExpression(Box::new(node)),
2698 + )
2699 + }
2700 + NodeKind::OptionalCallExpression => {
2701 + let node = OptionalCallExpression::convert(cx, node);
2702 + AssignmentTarget::Expression(
2703 + Expression::OptionalCallExpression(Box::new(node)),
2704 + )
2705 + }
2706 + NodeKind::OptionalMemberExpression => {
2707 + let node = OptionalMemberExpression::convert(cx, node);
2708 + AssignmentTarget::Expression(
2709 + Expression::OptionalMemberExpression(Box::new(node)),
2710 + )
2711 + }
2712 + NodeKind::SequenceExpression => {
2713 + let node = SequenceExpression::convert(cx, node);
2714 + AssignmentTarget::Expression(
2715 + Expression::SequenceExpression(Box::new(node)),
2716 + )
2717 + }
2718 + NodeKind::StringLiteral => {
2719 + let node = StringLiteral::convert(cx, node);
2720 + AssignmentTarget::Expression(Expression::StringLiteral(Box::new(node)))
2721 + }
2722 + NodeKind::TaggedTemplateExpression => {
2723 + let node = TaggedTemplateExpression::convert(cx, node);
2724 + AssignmentTarget::Expression(
2725 + Expression::TaggedTemplateExpression(Box::new(node)),
2726 + )
2727 + }
2728 + NodeKind::TemplateLiteral => {
2729 + let node = TemplateLiteral::convert(cx, node);
2730 + AssignmentTarget::Expression(Expression::TemplateLiteral(Box::new(node)))
2731 + }
2732 + NodeKind::ThisExpression => {
2733 + let node = ThisExpression::convert(cx, node);
2734 + AssignmentTarget::Expression(Expression::ThisExpression(Box::new(node)))
2735 + }
2736 + NodeKind::UnaryExpression => {
2737 + let node = UnaryExpression::convert(cx, node);
2738 + AssignmentTarget::Expression(Expression::UnaryExpression(Box::new(node)))
2739 + }
2740 + NodeKind::UpdateExpression => {
2741 + let node = UpdateExpression::convert(cx, node);
2742 + AssignmentTarget::Expression(
2743 + Expression::UpdateExpression(Box::new(node)),
2744 + )
2745 + }
2746 + NodeKind::YieldExpression => {
2747 + let node = YieldExpression::convert(cx, node);
2748 + AssignmentTarget::Expression(Expression::YieldExpression(Box::new(node)))
2749 + }
2750 + NodeKind::ArrayPattern => {
2751 + let node = ArrayPattern::convert(cx, node);
2752 + AssignmentTarget::Pattern(Pattern::ArrayPattern(Box::new(node)))
2753 + }
2754 + NodeKind::ObjectPattern => {
2755 + let node = ObjectPattern::convert(cx, node);
2756 + AssignmentTarget::Pattern(Pattern::ObjectPattern(Box::new(node)))
2757 + }
2758 + NodeKind::RestElement => {
2759 + let node = RestElement::convert(cx, node);
2760 + AssignmentTarget::Pattern(Pattern::RestElement(Box::new(node)))
2761 + }
2762 + NodeKind::AssignmentPattern => {
2763 + let node = AssignmentPattern::convert(cx, node);
2764 + AssignmentTarget::Pattern(Pattern::AssignmentPattern(Box::new(node)))
2765 + }
2766 + _ => panic!("Unexpected node"),
2767 + }
2768 + }
2769 +}
2770 +impl FromHermes for ChainElement {
2771 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2772 + let node_ref = node.as_ref();
2773 + match node_ref.kind {
2774 + NodeKind::CallExpression => {
2775 + let node = CallExpression::convert(cx, node);
2776 + ChainElement::CallExpression(Box::new(node))
2777 + }
2778 + NodeKind::MemberExpression => {
2779 + let node = MemberExpression::convert(cx, node);
2780 + ChainElement::MemberExpression(Box::new(node))
2781 + }
2782 + _ => panic!("Unexpected node"),
2783 + }
2784 + }
2785 +}
2786 +impl FromHermes for JSXMemberExpressionOrIdentifier {
2787 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2788 + let node_ref = node.as_ref();
2789 + match node_ref.kind {
2790 + NodeKind::JSXMemberExpression => {
2791 + let node = JSXMemberExpression::convert(cx, node);
2792 + JSXMemberExpressionOrIdentifier::JSXMemberExpression(Box::new(node))
2793 + }
2794 + NodeKind::JSXIdentifier => {
2795 + let node = JSXIdentifier::convert(cx, node);
2796 + JSXMemberExpressionOrIdentifier::JSXIdentifier(Box::new(node))
2797 + }
2798 + _ => panic!("Unexpected node"),
2799 + }
2800 + }
2801 +}
2802 +impl FromHermes for JSXExpressionOrEmpty {
2803 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2804 + let node_ref = node.as_ref();
2805 + match node_ref.kind {
2806 + NodeKind::ArrayExpression => {
2807 + let node = ArrayExpression::convert(cx, node);
2808 + JSXExpressionOrEmpty::Expression(
2809 + Expression::ArrayExpression(Box::new(node)),
2810 + )
2811 + }
2812 + NodeKind::ArrowFunctionExpression => {
2813 + let node = ArrowFunctionExpression::convert(cx, node);
2814 + JSXExpressionOrEmpty::Expression(
2815 + Expression::ArrowFunctionExpression(Box::new(node)),
2816 + )
2817 + }
2818 + NodeKind::AssignmentExpression => {
2819 + let node = AssignmentExpression::convert(cx, node);
2820 + JSXExpressionOrEmpty::Expression(
2821 + Expression::AssignmentExpression(Box::new(node)),
2822 + )
2823 + }
2824 + NodeKind::AwaitExpression => {
2825 + let node = AwaitExpression::convert(cx, node);
2826 + JSXExpressionOrEmpty::Expression(
2827 + Expression::AwaitExpression(Box::new(node)),
2828 + )
2829 + }
2830 + NodeKind::BinaryExpression => {
2831 + let node = BinaryExpression::convert(cx, node);
2832 + JSXExpressionOrEmpty::Expression(
2833 + Expression::BinaryExpression(Box::new(node)),
2834 + )
2835 + }
2836 + NodeKind::BooleanLiteral => {
2837 + let node = BooleanLiteral::convert(cx, node);
2838 + JSXExpressionOrEmpty::Expression(
2839 + Expression::BooleanLiteral(Box::new(node)),
2840 + )
2841 + }
2842 + NodeKind::CallExpression => {
2843 + let node = CallExpression::convert(cx, node);
2844 + JSXExpressionOrEmpty::Expression(
2845 + Expression::CallExpression(Box::new(node)),
2846 + )
2847 + }
2848 + NodeKind::ClassExpression => {
2849 + let node = ClassExpression::convert(cx, node);
2850 + JSXExpressionOrEmpty::Expression(
2851 + Expression::ClassExpression(Box::new(node)),
2852 + )
2853 + }
2854 + NodeKind::ConditionalExpression => {
2855 + let node = ConditionalExpression::convert(cx, node);
2856 + JSXExpressionOrEmpty::Expression(
2857 + Expression::ConditionalExpression(Box::new(node)),
2858 + )
2859 + }
2860 + NodeKind::FunctionExpression => {
2861 + let node = FunctionExpression::convert(cx, node);
2862 + JSXExpressionOrEmpty::Expression(
2863 + Expression::FunctionExpression(Box::new(node)),
2864 + )
2865 + }
2866 + NodeKind::Identifier => {
2867 + let node = Identifier::convert(cx, node);
2868 + JSXExpressionOrEmpty::Expression(Expression::Identifier(Box::new(node)))
2869 + }
2870 + NodeKind::ImportExpression => {
2871 + let node = ImportExpression::convert(cx, node);
2872 + JSXExpressionOrEmpty::Expression(
2873 + Expression::ImportExpression(Box::new(node)),
2874 + )
2875 + }
2876 + NodeKind::JSXElement => {
2877 + let node = JSXElement::convert(cx, node);
2878 + JSXExpressionOrEmpty::Expression(Expression::JSXElement(Box::new(node)))
2879 + }
2880 + NodeKind::LogicalExpression => {
2881 + let node = LogicalExpression::convert(cx, node);
2882 + JSXExpressionOrEmpty::Expression(
2883 + Expression::LogicalExpression(Box::new(node)),
2884 + )
2885 + }
2886 + NodeKind::MemberExpression => {
2887 + let node = MemberExpression::convert(cx, node);
2888 + JSXExpressionOrEmpty::Expression(
2889 + Expression::MemberExpression(Box::new(node)),
2890 + )
2891 + }
2892 + NodeKind::MetaProperty => {
2893 + let node = MetaProperty::convert(cx, node);
2894 + JSXExpressionOrEmpty::Expression(
2895 + Expression::MetaProperty(Box::new(node)),
2896 + )
2897 + }
2898 + NodeKind::NewExpression => {
2899 + let node = NewExpression::convert(cx, node);
2900 + JSXExpressionOrEmpty::Expression(
2901 + Expression::NewExpression(Box::new(node)),
2902 + )
2903 + }
2904 + NodeKind::NullLiteral => {
2905 + let node = NullLiteral::convert(cx, node);
2906 + JSXExpressionOrEmpty::Expression(Expression::NullLiteral(Box::new(node)))
2907 + }
2908 + NodeKind::NumericLiteral => {
2909 + let node = NumericLiteral::convert(cx, node);
2910 + JSXExpressionOrEmpty::Expression(
2911 + Expression::NumericLiteral(Box::new(node)),
2912 + )
2913 + }
2914 + NodeKind::ObjectExpression => {
2915 + let node = ObjectExpression::convert(cx, node);
2916 + JSXExpressionOrEmpty::Expression(
2917 + Expression::ObjectExpression(Box::new(node)),
2918 + )
2919 + }
2920 + NodeKind::OptionalCallExpression => {
2921 + let node = OptionalCallExpression::convert(cx, node);
2922 + JSXExpressionOrEmpty::Expression(
2923 + Expression::OptionalCallExpression(Box::new(node)),
2924 + )
2925 + }
2926 + NodeKind::OptionalMemberExpression => {
2927 + let node = OptionalMemberExpression::convert(cx, node);
2928 + JSXExpressionOrEmpty::Expression(
2929 + Expression::OptionalMemberExpression(Box::new(node)),
2930 + )
2931 + }
2932 + NodeKind::SequenceExpression => {
2933 + let node = SequenceExpression::convert(cx, node);
2934 + JSXExpressionOrEmpty::Expression(
2935 + Expression::SequenceExpression(Box::new(node)),
2936 + )
2937 + }
2938 + NodeKind::StringLiteral => {
2939 + let node = StringLiteral::convert(cx, node);
2940 + JSXExpressionOrEmpty::Expression(
2941 + Expression::StringLiteral(Box::new(node)),
2942 + )
2943 + }
2944 + NodeKind::TaggedTemplateExpression => {
2945 + let node = TaggedTemplateExpression::convert(cx, node);
2946 + JSXExpressionOrEmpty::Expression(
2947 + Expression::TaggedTemplateExpression(Box::new(node)),
2948 + )
2949 + }
2950 + NodeKind::TemplateLiteral => {
2951 + let node = TemplateLiteral::convert(cx, node);
2952 + JSXExpressionOrEmpty::Expression(
2953 + Expression::TemplateLiteral(Box::new(node)),
2954 + )
2955 + }
2956 + NodeKind::ThisExpression => {
2957 + let node = ThisExpression::convert(cx, node);
2958 + JSXExpressionOrEmpty::Expression(
2959 + Expression::ThisExpression(Box::new(node)),
2960 + )
2961 + }
2962 + NodeKind::UnaryExpression => {
2963 + let node = UnaryExpression::convert(cx, node);
2964 + JSXExpressionOrEmpty::Expression(
2965 + Expression::UnaryExpression(Box::new(node)),
2966 + )
2967 + }
2968 + NodeKind::UpdateExpression => {
2969 + let node = UpdateExpression::convert(cx, node);
2970 + JSXExpressionOrEmpty::Expression(
2971 + Expression::UpdateExpression(Box::new(node)),
2972 + )
2973 + }
2974 + NodeKind::YieldExpression => {
2975 + let node = YieldExpression::convert(cx, node);
2976 + JSXExpressionOrEmpty::Expression(
2977 + Expression::YieldExpression(Box::new(node)),
2978 + )
2979 + }
2980 + NodeKind::JSXEmptyExpression => {
2981 + let node = JSXEmptyExpression::convert(cx, node);
2982 + JSXExpressionOrEmpty::JSXEmptyExpression(Box::new(node))
2983 + }
2984 + _ => panic!("Unexpected node"),
2985 + }
2986 + }
2987 +}
2988 +impl FromHermes for JSXAttributeOrSpread {
2989 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
2990 + let node_ref = node.as_ref();
2991 + match node_ref.kind {
2992 + NodeKind::JSXAttribute => {
2993 + let node = JSXAttribute::convert(cx, node);
2994 + JSXAttributeOrSpread::JSXAttribute(Box::new(node))
2995 + }
2996 + NodeKind::JSXSpreadAttribute => {
2997 + let node = JSXSpreadAttribute::convert(cx, node);
2998 + JSXAttributeOrSpread::JSXSpreadAttribute(Box::new(node))
2999 + }
3000 + _ => panic!("Unexpected node"),
3001 + }
3002 + }
3003 +}
3004 +impl FromHermes for JSXAttributeValue {
3005 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
3006 + let node_ref = node.as_ref();
3007 + match node_ref.kind {
3008 + NodeKind::JSXExpressionContainer => {
3009 + let node = JSXExpressionContainer::convert(cx, node);
3010 + JSXAttributeValue::JSXExpressionContainer(Box::new(node))
3011 + }
3012 + NodeKind::JSXElement => {
3013 + let node = JSXElement::convert(cx, node);
3014 + JSXAttributeValue::JSXElement(Box::new(node))
3015 + }
3016 + NodeKind::JSXFragment => {
3017 + let node = JSXFragment::convert(cx, node);
3018 + JSXAttributeValue::JSXFragment(Box::new(node))
3019 + }
3020 + _ => panic!("Unexpected node"),
3021 + }
3022 + }
3023 +}
3024 +impl FromHermes for JSXElementName {
3025 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
3026 + let node_ref = node.as_ref();
3027 + match node_ref.kind {
3028 + NodeKind::JSXIdentifier => {
3029 + let node = JSXIdentifier::convert(cx, node);
3030 + JSXElementName::JSXIdentifier(Box::new(node))
3031 + }
3032 + NodeKind::JSXMemberExpression => {
3033 + let node = JSXMemberExpression::convert(cx, node);
3034 + JSXElementName::JSXMemberExpression(Box::new(node))
3035 + }
3036 + NodeKind::JSXNamespacedName => {
3037 + let node = JSXNamespacedName::convert(cx, node);
3038 + JSXElementName::JSXNamespacedName(Box::new(node))
3039 + }
3040 + _ => panic!("Unexpected node"),
3041 + }
3042 + }
3043 +}
3044 +impl FromHermes for JSXIdentifierOrNamespacedName {
3045 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
3046 + let node_ref = node.as_ref();
3047 + match node_ref.kind {
3048 + NodeKind::JSXIdentifier => {
3049 + let node = JSXIdentifier::convert(cx, node);
3050 + JSXIdentifierOrNamespacedName::JSXIdentifier(Box::new(node))
3051 + }
3052 + NodeKind::JSXNamespacedName => {
3053 + let node = JSXNamespacedName::convert(cx, node);
3054 + JSXIdentifierOrNamespacedName::JSXNamespacedName(Box::new(node))
3055 + }
3056 + _ => panic!("Unexpected node"),
3057 + }
3058 + }
3059 +}
3060 +impl FromHermes for JSXChildItem {
3061 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
3062 + let node_ref = node.as_ref();
3063 + match node_ref.kind {
3064 + NodeKind::JSXText => {
3065 + let node = JSXText::convert(cx, node);
3066 + JSXChildItem::JSXText(Box::new(node))
3067 + }
3068 + NodeKind::JSXExpressionContainer => {
3069 + let node = JSXExpressionContainer::convert(cx, node);
3070 + JSXChildItem::JSXExpressionContainer(Box::new(node))
3071 + }
3072 + NodeKind::JSXSpreadChild => {
3073 + let node = JSXSpreadChild::convert(cx, node);
3074 + JSXChildItem::JSXSpreadChild(Box::new(node))
3075 + }
3076 + NodeKind::JSXElement => {
3077 + let node = JSXElement::convert(cx, node);
3078 + JSXChildItem::JSXElement(Box::new(node))
3079 + }
3080 + NodeKind::JSXFragment => {
3081 + let node = JSXFragment::convert(cx, node);
3082 + JSXChildItem::JSXFragment(Box::new(node))
3083 + }
3084 + _ => panic!("Unexpected node"),
3085 + }
3086 + }
3087 +}
3088 +impl FromHermesLabel for VariableDeclarationKind {
3089 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3090 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3091 + utf_str.parse().unwrap()
3092 + }
3093 +}
3094 +impl FromHermesLabel for PropertyKind {
3095 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3096 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3097 + utf_str.parse().unwrap()
3098 + }
3099 +}
3100 +impl FromHermesLabel for UnaryOperator {
3101 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3102 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3103 + utf_str.parse().unwrap()
3104 + }
3105 +}
3106 +impl FromHermesLabel for UpdateOperator {
3107 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3108 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3109 + utf_str.parse().unwrap()
3110 + }
3111 +}
3112 +impl FromHermesLabel for BinaryOperator {
3113 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3114 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3115 + utf_str.parse().unwrap()
3116 + }
3117 +}
3118 +impl FromHermesLabel for AssignmentOperator {
3119 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3120 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3121 + utf_str.parse().unwrap()
3122 + }
3123 +}
3124 +impl FromHermesLabel for LogicalOperator {
3125 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3126 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3127 + utf_str.parse().unwrap()
3128 + }
3129 +}
3130 +impl FromHermesLabel for SourceType {
3131 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3132 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3133 + utf_str.parse().unwrap()
3134 + }
3135 +}
3136 +impl FromHermesLabel for MethodKind {
3137 + fn convert(cx: &mut Context, label: NodeLabel) -> Self {
3138 + let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();
3139 + utf_str.parse().unwrap()
3140 + }
3141 +}
compiler/forget/crates/forget_hermes_parser/src/generated_extension.rs new
+288
@@ -0,0 +1,288 @@
1 +use forget_estree::{
2 + ArrowFunctionExpression, AssignmentProperty, Class, ClassBody, ClassDeclaration,
3 + ClassExpression, Expression, ExpressionOrSpread, Function, FunctionBody, FunctionDeclaration,
4 + FunctionExpression, Identifier, Number, Pattern, SourceRange, TemplateElement,
5 + TemplateElementValue,
6 +};
7 +use hermes::parser::{
8 + hermes_get_ArrowFunctionExpression_async, hermes_get_ArrowFunctionExpression_body,
9 + hermes_get_ArrowFunctionExpression_expression, hermes_get_ArrowFunctionExpression_id,
10 + hermes_get_ArrowFunctionExpression_params, hermes_get_ClassDeclaration_body,
11 + hermes_get_ClassDeclaration_id, hermes_get_ClassDeclaration_superClass,
12 + hermes_get_ClassExpression_body, hermes_get_ClassExpression_id,
13 + hermes_get_ClassExpression_superClass, hermes_get_FunctionDeclaration_async,
14 + hermes_get_FunctionDeclaration_body, hermes_get_FunctionDeclaration_generator,
15 + hermes_get_FunctionDeclaration_id, hermes_get_FunctionDeclaration_params,
16 + hermes_get_FunctionExpression_async, hermes_get_FunctionExpression_body,
17 + hermes_get_FunctionExpression_generator, hermes_get_FunctionExpression_id,
18 + hermes_get_FunctionExpression_params, hermes_get_Property_key, hermes_get_Property_kind,
19 + hermes_get_Property_method, hermes_get_Property_value, NodeKind, NodeLabel, NodeLabelOpt,
20 + NodeListRef, NodePtr, NodePtrOpt, NodeString, NodeStringOpt, SMRange,
21 +};
22 +use hermes::utf::utf8_with_surrogates_to_string;
23 +
24 +pub struct Context;
25 +
26 +impl Context {
27 + pub fn new() -> Self {
28 + Self
29 + }
30 +}
31 +
32 +pub trait FromHermes {
33 + fn convert(cx: &mut Context, node: NodePtr) -> Self;
34 +}
35 +pub trait FromHermesLabel {
36 + fn convert(cx: &mut Context, label: NodeLabel) -> Self;
37 +}
38 +
39 +pub fn convert_option<F, T>(node: NodePtrOpt, mut f: F) -> Option<T>
40 +where
41 + F: FnMut(NodePtr) -> T,
42 +{
43 + node.as_node_ptr().map(|node| f(node))
44 +}
45 +
46 +pub fn convert_vec<F, T>(node: NodeListRef, mut f: F) -> Vec<T>
47 +where
48 + F: FnMut(NodePtr) -> T,
49 +{
50 + node.iter().map(|node| f(NodePtr::new(node))).collect()
51 +}
52 +
53 +pub fn convert_vec_of_option<F, T>(node: NodeListRef, mut f: F) -> Vec<Option<T>>
54 +where
55 + F: FnMut(NodePtr) -> T,
56 +{
57 + node.iter()
58 + .map(|node| {
59 + let node = NodePtr::new(node);
60 + let node_ref = node.as_ref();
61 + match node_ref.kind {
62 + NodeKind::Empty => None,
63 + _ => Some(f(node)),
64 + }
65 + })
66 + .collect()
67 +}
68 +
69 +pub fn convert_range(node: NodePtr) -> SourceRange {
70 + let _range = node.as_ref().source_range;
71 + todo!()
72 +}
73 +
74 +#[allow(dead_code)]
75 +pub fn convert_smrange(_range: SMRange) -> SourceRange {
76 + todo!()
77 +}
78 +
79 +pub fn convert_string(_cx: &mut Context, label: NodeLabel) -> String {
80 + utf8_with_surrogates_to_string(label.as_slice()).unwrap()
81 +}
82 +
83 +#[allow(dead_code)]
84 +pub fn convert_option_string(cx: &mut Context, label: NodeLabelOpt) -> Option<String> {
85 + label.as_node_label().map(|label| convert_string(cx, label))
86 +}
87 +
88 +pub fn convert_string_value(_cx: &mut Context, label: NodeString) -> String {
89 + utf8_with_surrogates_to_string(label.as_slice()).unwrap()
90 +}
91 +
92 +pub fn convert_option_string_value(_cx: &mut Context, label: NodeStringOpt) -> Option<String> {
93 + label
94 + .as_node_string()
95 + .map(|label| utf8_with_surrogates_to_string(label.as_slice()).unwrap())
96 +}
97 +
98 +pub fn convert_number(value: f64) -> Number {
99 + value.into()
100 +}
101 +
102 +pub fn convert_array_expression_elements(
103 + cx: &mut Context,
104 + node: NodeListRef,
105 +) -> Vec<Option<ExpressionOrSpread>> {
106 + convert_vec_of_option(node, |node| ExpressionOrSpread::convert(cx, node))
107 +}
108 +
109 +impl FromHermes for TemplateElement {
110 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
111 + let range = convert_range(node);
112 + let tail = unsafe { hermes::parser::hermes_get_TemplateElement_tail(node) };
113 + let value = TemplateElementValue {
114 + cooked: convert_option_string_value(cx, unsafe {
115 + hermes::parser::hermes_get_TemplateElement_cooked(node)
116 + }),
117 + raw: convert_string(cx, unsafe {
118 + hermes::parser::hermes_get_TemplateElement_raw(node)
119 + }),
120 + };
121 + Self {
122 + tail,
123 + value,
124 + loc: None,
125 + range: Some(range),
126 + }
127 + }
128 +}
129 +
130 +impl FromHermes for AssignmentProperty {
131 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
132 + let key = FromHermes::convert(cx, unsafe { hermes_get_Property_key(node) });
133 + let value = FromHermes::convert(cx, unsafe { hermes_get_Property_value(node) });
134 + let kind = FromHermesLabel::convert(cx, unsafe { hermes_get_Property_kind(node) });
135 + let method = unsafe { hermes_get_Property_method(node) };
136 + let loc = None;
137 + let range = convert_range(node);
138 + AssignmentProperty {
139 + key,
140 + value,
141 + kind,
142 + method,
143 + loc,
144 + range: Some(range),
145 + }
146 + }
147 +}
148 +
149 +impl FromHermes for FunctionDeclaration {
150 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
151 + let id = convert_option(unsafe { hermes_get_FunctionDeclaration_id(node) }, |node| {
152 + Identifier::convert(cx, node)
153 + });
154 + let params = convert_vec(
155 + unsafe { hermes_get_FunctionDeclaration_params(node) },
156 + |node| Pattern::convert(cx, node),
157 + );
158 + let body = FunctionBody::convert(cx, unsafe { hermes_get_FunctionDeclaration_body(node) });
159 + let is_generator = unsafe { hermes_get_FunctionDeclaration_generator(node) };
160 + let is_async = unsafe { hermes_get_FunctionDeclaration_async(node) };
161 + let loc = None;
162 + let range = convert_range(node);
163 + FunctionDeclaration {
164 + function: Function {
165 + id,
166 + params,
167 + body: Some(body),
168 + is_generator,
169 + is_async,
170 + loc: loc.clone(),
171 + range: Some(range),
172 + },
173 + loc,
174 + range: Some(range),
175 + }
176 + }
177 +}
178 +
179 +impl FromHermes for FunctionExpression {
180 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
181 + let id = convert_option(unsafe { hermes_get_FunctionExpression_id(node) }, |node| {
182 + Identifier::convert(cx, node)
183 + });
184 + let params = convert_vec(
185 + unsafe { hermes_get_FunctionExpression_params(node) },
186 + |node| Pattern::convert(cx, node),
187 + );
188 + let body = FunctionBody::convert(cx, unsafe { hermes_get_FunctionExpression_body(node) });
189 + let is_generator = unsafe { hermes_get_FunctionExpression_generator(node) };
190 + let is_async = unsafe { hermes_get_FunctionExpression_async(node) };
191 + let loc = None;
192 + let range = convert_range(node);
193 + FunctionExpression {
194 + function: Function {
195 + id,
196 + params,
197 + body: Some(body),
198 + is_generator,
199 + is_async,
200 + loc: loc.clone(),
201 + range: Some(range),
202 + },
203 + loc,
204 + range: Some(range),
205 + }
206 + }
207 +}
208 +
209 +impl FromHermes for ArrowFunctionExpression {
210 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
211 + let id = convert_option(
212 + unsafe { hermes_get_ArrowFunctionExpression_id(node) },
213 + |node| Identifier::convert(cx, node),
214 + );
215 + let params = convert_vec(
216 + unsafe { hermes_get_ArrowFunctionExpression_params(node) },
217 + |node| Pattern::convert(cx, node),
218 + );
219 + let body =
220 + FunctionBody::convert(cx, unsafe { hermes_get_ArrowFunctionExpression_body(node) });
221 + let is_generator = unsafe { hermes_get_FunctionExpression_generator(node) };
222 + let is_async = unsafe { hermes_get_ArrowFunctionExpression_async(node) };
223 + let is_expression = unsafe { hermes_get_ArrowFunctionExpression_expression(node) };
224 + let loc = None;
225 + let range = convert_range(node);
226 + ArrowFunctionExpression {
227 + function: Function {
228 + id,
229 + params,
230 + body: Some(body),
231 + is_generator,
232 + is_async,
233 + loc: loc.clone(),
234 + range: Some(range),
235 + },
236 + is_expression,
237 + loc,
238 + range: Some(range),
239 + }
240 + }
241 +}
242 +
243 +impl FromHermes for ClassDeclaration {
244 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
245 + let id = convert_option(unsafe { hermes_get_ClassDeclaration_id(node) }, |node| {
246 + Identifier::convert(cx, node)
247 + });
248 + let super_class = convert_option(
249 + unsafe { hermes_get_ClassDeclaration_superClass(node) },
250 + |node| Expression::convert(cx, node),
251 + );
252 + let body = ClassBody::convert(cx, unsafe { hermes_get_ClassDeclaration_body(node) });
253 + let loc = None;
254 + let range = convert_range(node);
255 + ClassDeclaration {
256 + class: Class {
257 + id,
258 + super_class,
259 + body,
260 + },
261 + loc,
262 + range: Some(range),
263 + }
264 + }
265 +}
266 +impl FromHermes for ClassExpression {
267 + fn convert(cx: &mut Context, node: NodePtr) -> Self {
268 + let id = convert_option(unsafe { hermes_get_ClassExpression_id(node) }, |node| {
269 + Identifier::convert(cx, node)
270 + });
271 + let super_class = convert_option(
272 + unsafe { hermes_get_ClassExpression_superClass(node) },
273 + |node| Expression::convert(cx, node),
274 + );
275 + let body = ClassBody::convert(cx, unsafe { hermes_get_ClassExpression_body(node) });
276 + let loc = None;
277 + let range = convert_range(node);
278 + ClassExpression {
279 + class: Class {
280 + id,
281 + super_class,
282 + body,
283 + },
284 + loc,
285 + range: Some(range),
286 + }
287 + }
288 +}
compiler/forget/crates/forget_hermes_parser/src/lib.rs
+17 -98
@@ -1,14 +1,14 @@
1 +mod generated;
2 +mod generated_extension;
3 +
4 use forget_diagnostics::Diagnostic;
2 -use hermes::parser::{
3 - hermes_get_BlockStatement_body, hermes_get_DeclareFunction_id,
4 - hermes_get_FunctionDeclaration_async, hermes_get_FunctionDeclaration_body,
5 - hermes_get_FunctionDeclaration_generator, hermes_get_Program_body, HermesParser, NodeKind,
6 - NodePtr, ParserDialect, ParserFlags,
7 -};
8 -use juno_support::source_manager::SourceRange;
5 +use forget_estree::Program;
6 +use generated_extension::{Context, FromHermes};
7 +use hermes::parser::{HermesParser, ParserDialect, ParserFlags};
8 +use hermes::utf::utf8_with_surrogates_to_string;
9 use juno_support::NullTerminatedBuf;
10
11 -pub fn parse(source: &str, file: &str) -> Result<forget_estree::Program, Vec<Diagnostic>> {
11 +pub fn parse(source: &str, _file: &str) -> Result<Program, Vec<Diagnostic>> {
12 let buf = NullTerminatedBuf::from_str_check(source);
13 let result = HermesParser::parse(
14 ParserFlags {
@@ -19,98 +19,17 @@ pub fn parse(source: &str, file: &str) -> Result<forget_estree::Program, Vec<Dia
19 },
20 &buf,
21 );
22 + let mut cx = Context::new();
23 if result.has_errors() {
24 let error_messages = result.messages();
24 - return Err(todo!("construct diagnostics"));
25 - }
26 -
27 - Ok(unsafe { convert_program(result.root().unwrap()) })
28 -}
29 -
30 -unsafe fn convert_program(node: NodePtr) -> forget_estree::Program {
31 - let node_ref = node.as_ref();
32 - let body = hermes_get_Program_body(node);
33 - let body: Vec<_> = body
34 - .iter()
35 - .map(|node| convert_module_item(NodePtr::new(node)))
36 - .collect();
37 - forget_estree::Program {
38 - body,
39 - source_type: forget_estree::SourceType::Module,
40 - loc: None,
41 - range: None,
25 + return Err(error_messages
26 + .into_iter()
27 + .map(|diag| {
28 + let message = utf8_with_surrogates_to_string(diag.message.as_slice()).unwrap();
29 + Diagnostic::invalid_syntax(message, None)
30 + })
31 + .collect());
32 }
43 -}
33
45 -unsafe fn convert_module_item(node: NodePtr) -> forget_estree::ModuleItem {
46 - let node_ref = node.as_ref();
47 - match node_ref.kind {
48 - NodeKind::FunctionDeclaration => {
49 - forget_estree::ModuleItem::Statement(forget_estree::Statement::FunctionDeclaration(
50 - Box::new(convert_function_declaration(node)),
51 - ))
52 - }
53 - _ => todo!(),
54 - }
55 -}
56 -
57 -unsafe fn convert_function_declaration(node: NodePtr) -> forget_estree::FunctionDeclaration {
58 - let id = None; //hermes_get_DeclareFunction_id(node);
59 - let params = Vec::new();
60 - let body = forget_estree::FunctionBody::BlockStatement(Box::new(convert_block_statement(
61 - hermes_get_FunctionDeclaration_body(node),
62 - )));
63 - let is_generator = hermes_get_FunctionDeclaration_generator(node);
64 - let is_async = hermes_get_FunctionDeclaration_async(node);
65 - forget_estree::FunctionDeclaration {
66 - function: forget_estree::Function {
67 - id,
68 - params,
69 - body: Some(body),
70 - is_generator,
71 - is_async,
72 - loc: None,
73 - range: None,
74 - },
75 - loc: None,
76 - range: None,
77 - }
78 -}
79 -
80 -unsafe fn convert_block_statement(node: NodePtr) -> forget_estree::BlockStatement {
81 - let body = hermes_get_BlockStatement_body(node);
82 - let body: Vec<_> = body
83 - .iter()
84 - .map(|node| convert_statement(NodePtr::new(node)))
85 - .collect();
86 - forget_estree::BlockStatement {
87 - body,
88 - loc: None,
89 - range: None,
90 - }
91 -}
92 -
93 -unsafe fn convert_statement(node: NodePtr) -> forget_estree::Statement {
94 - let node_ref = node.as_ref();
95 - match node_ref.kind {
96 - NodeKind::ReturnStatement => {
97 - forget_estree::Statement::ReturnStatement(Box::new(forget_estree::ReturnStatement {
98 - argument: None,
99 - loc: None,
100 - range: None,
101 - }))
102 - }
103 - _ => todo!(),
104 - }
105 -}
106 -
107 -#[cfg(test)]
108 -mod tests {
109 - use super::*;
110 -
111 - #[test]
112 - fn fixtures() {
113 - let res = parse("function foo() { return }", "hello.js");
114 - println!("{:#?}", res);
115 - }
34 + Ok(FromHermes::convert(&mut cx, result.root().unwrap()))
35 }