{"patch":"diff --git a\/compiler\/forget\/Cargo.lock b\/compiler\/forget\/Cargo.lock\nindex c8a2bc9200..1f04973fe9 100644\n--- a\/compiler\/forget\/Cargo.lock\n+++ b\/compiler\/forget\/Cargo.lock\n@@ -528,6 +528,7 @@ version = \"0.1.0\"\n dependencies = [\n \"forget_diagnostics\",\n \"forget_estree\",\n+ \"forget_estree_codegen\",\n \"hermes\",\n \"juno_support\",\n ]\ndiff --git a\/compiler\/forget\/crates\/forget_build_hir\/src\/context.rs b\/compiler\/forget\/crates\/forget_build_hir\/src\/context.rs\nindex 7623cc4553..3c677b677e 100644\n--- a\/compiler\/forget\/crates\/forget_build_hir\/src\/context.rs\n+++ b\/compiler\/forget\/crates\/forget_build_hir\/src\/context.rs\n@@ -65,4 +65,8 @@ impl<'ast> Visitor<'ast> for ContextVisitor<'ast> {\n _ => {}\n }\n }\n+\n+ fn visit_literal(&mut self, _literal: &'ast forget_estree::Literal) {\n+ \/\/ no-op\n+ }\n }\ndiff --git a\/compiler\/forget\/crates\/forget_estree\/src\/generated.rs b\/compiler\/forget\/crates\/forget_estree\/src\/generated.rs\nindex 50d76141d7..fa2bf7eb9e 100644\n--- a\/compiler\/forget\/crates\/forget_estree\/src\/generated.rs\n+++ b\/compiler\/forget\/crates\/forget_estree\/src\/generated.rs\n@@ -3,7 +3,7 @@\n use std::num::NonZeroU32;\n use serde::ser::{Serializer, SerializeMap};\n use serde::{Serialize, Deserialize};\n-use crate::{JsValue, Binding, SourceRange};\n+use crate::{JsValue, Binding, SourceRange, Number};\n #[derive(Serialize, Deserialize, Clone, Debug)]\n #[serde(deny_unknown_fields)]\n pub struct SourceLocation {\n@@ -19,6 +19,14 @@ pub struct Position {\n }\n #[derive(Serialize, Deserialize, Clone, Debug)]\n #[serde(deny_unknown_fields)]\n+pub struct Class {\n+ pub id: Option,\n+ #[serde(rename = \"superClass\")]\n+ pub super_class: Option,\n+ pub body: ClassBody,\n+}\n+#[derive(Serialize, Deserialize, Clone, Debug)]\n+#[serde(deny_unknown_fields)]\n pub struct Function {\n pub id: Option,\n pub params: Vec,\n@@ -101,6 +109,88 @@ impl Serialize for Literal {\n }\n }\n #[derive(Deserialize, Clone, Debug)]\n+pub struct NumericLiteral {\n+ pub value: Number,\n+ #[serde(default)]\n+ pub loc: Option,\n+ #[serde(default)]\n+ pub range: Option,\n+}\n+impl Serialize for NumericLiteral {\n+ fn serialize(&self, serializer: S) -> Result\n+ where\n+ S: Serializer,\n+ {\n+ let mut state = serializer.serialize_map(None)?;\n+ state.serialize_entry(\"type\", \"NumericLiteral\")?;\n+ state.serialize_entry(\"value\", &self.value)?;\n+ state.serialize_entry(\"loc\", &self.loc)?;\n+ state.serialize_entry(\"range\", &self.range)?;\n+ state.end()\n+ }\n+}\n+#[derive(Deserialize, Clone, Debug)]\n+pub struct BooleanLiteral {\n+ pub value: bool,\n+ #[serde(default)]\n+ pub loc: Option,\n+ #[serde(default)]\n+ pub range: Option,\n+}\n+impl Serialize for BooleanLiteral {\n+ fn serialize(&self, serializer: S) -> Result\n+ where\n+ S: Serializer,\n+ {\n+ let mut state = serializer.serialize_map(None)?;\n+ state.serialize_entry(\"type\", \"BooleanLiteral\")?;\n+ state.serialize_entry(\"value\", &self.value)?;\n+ state.serialize_entry(\"loc\", &self.loc)?;\n+ state.serialize_entry(\"range\", &self.range)?;\n+ state.end()\n+ }\n+}\n+#[derive(Deserialize, Clone, Debug)]\n+pub struct NullLiteral {\n+ #[serde(default)]\n+ pub loc: Option,\n+ #[serde(default)]\n+ pub range: Option,\n+}\n+impl Serialize for NullLiteral {\n+ fn serialize(&self, serializer: S) -> Result\n+ where\n+ S: Serializer,\n+ {\n+ let mut state = serializer.serialize_map(None)?;\n+ state.serialize_entry(\"type\", \"NullLiteral\")?;\n+ state.serialize_entry(\"loc\", &self.loc)?;\n+ state.serialize_entry(\"range\", &self.range)?;\n+ state.end()\n+ }\n+}\n+#[derive(Deserialize, Clone, Debug)]\n+pub struct StringLiteral {\n+ pub value: String,\n+ #[serde(default)]\n+ pub loc: Option,\n+ #[serde(default)]\n+ pub range: Option,\n+}\n+impl Serialize for StringLiteral {\n+ fn serialize(&self, serializer: S) -> Result\n+ where\n+ S: Serializer,\n+ {\n+ let mut state = serializer.serialize_map(None)?;\n+ state.serialize_entry(\"type\", \"StringLiteral\")?;\n+ state.serialize_entry(\"value\", &self.value)?;\n+ state.serialize_entry(\"loc\", &self.loc)?;\n+ state.serialize_entry(\"range\", &self.range)?;\n+ state.end()\n+ }\n+}\n+#[derive(Deserialize, Clone, Debug)]\n pub struct Program {\n pub body: Vec,\n #[serde(rename = \"sourceType\")]\n@@ -610,32 +700,6 @@ impl Serialize for FunctionDeclaration {\n }\n }\n #[derive(Deserialize, Clone, Debug)]\n-pub struct Class {\n- pub id: Option,\n- #[serde(rename = \"superClass\")]\n- pub super_class: Option,\n- pub body: ClassBody,\n- #[serde(default)]\n- pub loc: Option,\n- #[serde(default)]\n- pub range: Option,\n-}\n-impl Serialize for Class {\n- fn serialize(&self, serializer: S) -> Result\n- where\n- S: Serializer,\n- {\n- let mut state = serializer.serialize_map(None)?;\n- state.serialize_entry(\"type\", \"Class\")?;\n- state.serialize_entry(\"id\", &self.id)?;\n- state.serialize_entry(\"superClass\", &self.super_class)?;\n- state.serialize_entry(\"body\", &self.body)?;\n- state.serialize_entry(\"loc\", &self.loc)?;\n- state.serialize_entry(\"range\", &self.range)?;\n- state.end()\n- }\n-}\n-#[derive(Deserialize, Clone, Debug)]\n pub struct ClassDeclaration {\n #[serde(flatten)]\n pub class: Class,\n@@ -1062,9 +1126,6 @@ pub struct MemberExpression {\n pub property: Expression,\n #[serde(rename = \"computed\")]\n pub is_computed: bool,\n- #[serde(rename = \"optional\")]\n- #[serde(default)]\n- pub is_optional: bool,\n #[serde(default)]\n pub loc: Option,\n #[serde(default)]\n@@ -1080,7 +1141,6 @@ impl Serialize for MemberExpression {\n state.serialize_entry(\"object\", &self.object)?;\n state.serialize_entry(\"property\", &self.property)?;\n state.serialize_entry(\"computed\", &self.is_computed)?;\n- state.serialize_entry(\"optional\", &self.is_optional)?;\n state.serialize_entry(\"loc\", &self.loc)?;\n state.serialize_entry(\"range\", &self.range)?;\n state.end()\n@@ -1115,9 +1175,6 @@ impl Serialize for ConditionalExpression {\n pub struct CallExpression {\n pub callee: ExpressionOrSuper,\n pub arguments: Vec,\n- #[serde(rename = \"optional\")]\n- #[serde(default)]\n- pub is_optional: bool,\n #[serde(default)]\n pub loc: Option,\n #[serde(default)]\n@@ -1132,7 +1189,6 @@ impl Serialize for CallExpression {\n state.serialize_entry(\"type\", \"CallExpression\")?;\n state.serialize_entry(\"callee\", &self.callee)?;\n state.serialize_entry(\"arguments\", &self.arguments)?;\n- state.serialize_entry(\"optional\", &self.is_optional)?;\n state.serialize_entry(\"loc\", &self.loc)?;\n state.serialize_entry(\"range\", &self.range)?;\n state.end()\n@@ -1250,7 +1306,7 @@ impl Serialize for YieldExpression {\n #[derive(Deserialize, Clone, Debug)]\n pub struct ImportDeclaration {\n pub specifiers: Vec,\n- pub source: Literal,\n+ pub source: _Literal,\n #[serde(default)]\n pub loc: Option,\n #[serde(default)]\n@@ -1339,7 +1395,7 @@ impl Serialize for ImportNamespaceSpecifier {\n pub struct ExportNamedDeclaration {\n pub declaration: Option,\n pub specifiers: Vec,\n- pub source: Option,\n+ pub source: Option<_Literal>,\n #[serde(default)]\n pub loc: Option,\n #[serde(default)]\n@@ -1404,7 +1460,7 @@ impl Serialize for ExportDefaultDeclaration {\n }\n #[derive(Deserialize, Clone, Debug)]\n pub struct ExportAllDeclaration {\n- pub source: Literal,\n+ pub source: _Literal,\n #[serde(default)]\n pub exported: Option,\n #[serde(default)]\n@@ -1704,7 +1760,7 @@ pub struct JSXFragment {\n pub opening_fragment: JSXOpeningFragment,\n pub children: Vec,\n #[serde(rename = \"closingFragment\")]\n- pub closing_fragment: Option,\n+ pub closing_fragment: JSXClosingFragment,\n #[serde(default)]\n pub loc: Option,\n #[serde(default)]\n@@ -2013,7 +2069,7 @@ impl Serialize for ChainExpression {\n #[derive(Deserialize, Clone, Debug)]\n pub struct OptionalMemberExpression {\n pub object: Expression,\n- pub property: Identifier,\n+ pub property: Expression,\n #[serde(rename = \"computed\")]\n pub is_computed: bool,\n #[serde(rename = \"optional\")]\n@@ -2328,6 +2384,7 @@ pub enum Expression {\n AssignmentExpression(Box),\n AwaitExpression(Box),\n BinaryExpression(Box),\n+ BooleanLiteral(Box),\n CallExpression(Box),\n ChainExpression(Box),\n ClassExpression(Box),\n@@ -2341,10 +2398,13 @@ pub enum Expression {\n MemberExpression(Box),\n MetaProperty(Box),\n NewExpression(Box),\n+ NullLiteral(Box),\n+ NumericLiteral(Box),\n ObjectExpression(Box),\n OptionalCallExpression(Box),\n OptionalMemberExpression(Box),\n SequenceExpression(Box),\n+ StringLiteral(Box),\n TaggedTemplateExpression(Box),\n TemplateLiteral(Box),\n ThisExpression(Box),\n@@ -2359,6 +2419,7 @@ enum __ExpressionTag {\n AssignmentExpression,\n AwaitExpression,\n BinaryExpression,\n+ BooleanLiteral,\n CallExpression,\n ChainExpression,\n ClassExpression,\n@@ -2372,10 +2433,13 @@ enum __ExpressionTag {\n MemberExpression,\n MetaProperty,\n NewExpression,\n+ NullLiteral,\n+ NumericLiteral,\n ObjectExpression,\n OptionalCallExpression,\n OptionalMemberExpression,\n SequenceExpression,\n+ StringLiteral,\n TaggedTemplateExpression,\n TemplateLiteral,\n ThisExpression,\n@@ -2435,6 +2499,14 @@ impl<'de> serde::Deserialize<'de> for Expression {\n )?;\n Ok(Expression::BinaryExpression(node))\n }\n+ __ExpressionTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(Expression::BooleanLiteral(node))\n+ }\n __ExpressionTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for Expression {\n )?;\n Ok(Expression::NewExpression(node))\n }\n+ __ExpressionTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(Expression::NullLiteral(node))\n+ }\n+ __ExpressionTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(Expression::NumericLiteral(node))\n+ }\n __ExpressionTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for Expression {\n )?;\n Ok(Expression::SequenceExpression(node))\n }\n+ __ExpressionTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(Expression::StringLiteral(node))\n+ }\n __ExpressionTag::TaggedTemplateExpression => {\n let node: Box = serde::Deserialize<'de> for Expression {\n }\n #[derive(Serialize, Clone, Debug)]\n #[serde(untagged)]\n+pub enum _Literal {\n+ BooleanLiteral(Box),\n+ Literal(Box),\n+ NullLiteral(Box),\n+ NumericLiteral(Box),\n+ StringLiteral(Box),\n+}\n+#[derive(Deserialize, Debug)]\n+enum ___LiteralTag {\n+ Literal,\n+ BooleanLiteral,\n+ NullLiteral,\n+ StringLiteral,\n+ NumericLiteral,\n+}\n+impl<'de> serde::Deserialize<'de> for _Literal {\n+ fn deserialize(deserializer: D) -> Result\n+ where\n+ D: serde::Deserializer<'de>,\n+ {\n+ let tagged = serde::Deserializer::deserialize_any(\n+ deserializer,\n+ serde::__private::de::TaggedContentVisitor::<\n+ ___LiteralTag,\n+ >::new(\"type\", \"_Literal\"),\n+ )?;\n+ match tagged.0 {\n+ ___LiteralTag::Literal => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(_Literal::Literal(node))\n+ }\n+ ___LiteralTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(_Literal::BooleanLiteral(node))\n+ }\n+ ___LiteralTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(_Literal::NullLiteral(node))\n+ }\n+ ___LiteralTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(_Literal::StringLiteral(node))\n+ }\n+ ___LiteralTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(_Literal::NumericLiteral(node))\n+ }\n+ }\n+ }\n+}\n+#[derive(Serialize, Clone, Debug)]\n+#[serde(untagged)]\n pub enum Declaration {\n ClassDeclaration(Box),\n FunctionDeclaration(Box),\n@@ -3066,6 +3234,7 @@ enum __ExpressionOrSuperTag {\n AssignmentExpression,\n AwaitExpression,\n BinaryExpression,\n+ BooleanLiteral,\n CallExpression,\n ChainExpression,\n ClassExpression,\n@@ -3079,10 +3248,13 @@ enum __ExpressionOrSuperTag {\n MemberExpression,\n MetaProperty,\n NewExpression,\n+ NullLiteral,\n+ NumericLiteral,\n ObjectExpression,\n OptionalCallExpression,\n OptionalMemberExpression,\n SequenceExpression,\n+ StringLiteral,\n TaggedTemplateExpression,\n TemplateLiteral,\n ThisExpression,\n@@ -3147,6 +3319,14 @@ impl<'de> serde::Deserialize<'de> for ExpressionOrSuper {\n )?;\n Ok(ExpressionOrSuper::Expression(Expression::BinaryExpression(node)))\n }\n+ __ExpressionOrSuperTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSuper::Expression(Expression::BooleanLiteral(node)))\n+ }\n __ExpressionOrSuperTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for ExpressionOrSuper {\n )?;\n Ok(ExpressionOrSuper::Expression(Expression::NewExpression(node)))\n }\n+ __ExpressionOrSuperTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSuper::Expression(Expression::NullLiteral(node)))\n+ }\n+ __ExpressionOrSuperTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSuper::Expression(Expression::NumericLiteral(node)))\n+ }\n __ExpressionOrSuperTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for ExpressionOrSuper {\n )?;\n Ok(ExpressionOrSuper::Expression(Expression::SequenceExpression(node)))\n }\n+ __ExpressionOrSuperTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSuper::Expression(Expression::StringLiteral(node)))\n+ }\n __ExpressionOrSuperTag::TaggedTemplateExpression => {\n let node: Box = serde::Deserialize<'de> for ExpressionOrSpread {\n )?;\n Ok(ExpressionOrSpread::Expression(Expression::BinaryExpression(node)))\n }\n+ __ExpressionOrSpreadTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSpread::Expression(Expression::BooleanLiteral(node)))\n+ }\n __ExpressionOrSpreadTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for ExpressionOrSpread {\n )?;\n Ok(ExpressionOrSpread::Expression(Expression::NewExpression(node)))\n }\n+ __ExpressionOrSpreadTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSpread::Expression(Expression::NullLiteral(node)))\n+ }\n+ __ExpressionOrSpreadTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSpread::Expression(Expression::NumericLiteral(node)))\n+ }\n __ExpressionOrSpreadTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for ExpressionOrSpread {\n )?;\n Ok(ExpressionOrSpread::Expression(Expression::SequenceExpression(node)))\n }\n+ __ExpressionOrSpreadTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ExpressionOrSpread::Expression(Expression::StringLiteral(node)))\n+ }\n __ExpressionOrSpreadTag::TaggedTemplateExpression => {\n let node: Box = serde::Deserialize<'de> for FunctionBody {\n )?;\n Ok(FunctionBody::Expression(Expression::BinaryExpression(node)))\n }\n+ __FunctionBodyTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(FunctionBody::Expression(Expression::BooleanLiteral(node)))\n+ }\n __FunctionBodyTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for FunctionBody {\n )?;\n Ok(FunctionBody::Expression(Expression::NewExpression(node)))\n }\n+ __FunctionBodyTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(FunctionBody::Expression(Expression::NullLiteral(node)))\n+ }\n+ __FunctionBodyTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(FunctionBody::Expression(Expression::NumericLiteral(node)))\n+ }\n __FunctionBodyTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for FunctionBody {\n )?;\n Ok(FunctionBody::Expression(Expression::SequenceExpression(node)))\n }\n+ __FunctionBodyTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(FunctionBody::Expression(Expression::StringLiteral(node)))\n+ }\n __FunctionBodyTag::TaggedTemplateExpression => {\n let node: Box = serde::Deserialize<'de> for ForInit {\n )?;\n Ok(ForInit::Expression(Expression::BinaryExpression(node)))\n }\n+ __ForInitTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ForInit::Expression(Expression::BooleanLiteral(node)))\n+ }\n __ForInitTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for ForInit {\n )?;\n Ok(ForInit::Expression(Expression::NewExpression(node)))\n }\n+ __ForInitTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ForInit::Expression(Expression::NullLiteral(node)))\n+ }\n+ __ForInitTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ForInit::Expression(Expression::NumericLiteral(node)))\n+ }\n __ForInitTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for ForInit {\n )?;\n Ok(ForInit::Expression(Expression::SequenceExpression(node)))\n }\n+ __ForInitTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(ForInit::Expression(Expression::StringLiteral(node)))\n+ }\n __ForInitTag::TaggedTemplateExpression => {\n let node: Box = serde::Deserialize<'de> for AssignmentTarget {\n )?;\n Ok(AssignmentTarget::Expression(Expression::BinaryExpression(node)))\n }\n+ __AssignmentTargetTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(AssignmentTarget::Expression(Expression::BooleanLiteral(node)))\n+ }\n __AssignmentTargetTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for AssignmentTarget {\n )?;\n Ok(AssignmentTarget::Expression(Expression::NewExpression(node)))\n }\n+ __AssignmentTargetTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(AssignmentTarget::Expression(Expression::NullLiteral(node)))\n+ }\n+ __AssignmentTargetTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(AssignmentTarget::Expression(Expression::NumericLiteral(node)))\n+ }\n __AssignmentTargetTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for AssignmentTarget {\n )?;\n Ok(AssignmentTarget::Expression(Expression::SequenceExpression(node)))\n }\n+ __AssignmentTargetTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(AssignmentTarget::Expression(Expression::StringLiteral(node)))\n+ }\n __AssignmentTargetTag::TaggedTemplateExpression => {\n let node: Box = serde::Deserialize<'de> for JSXExpressionOrEmpty {\n )?;\n Ok(JSXExpressionOrEmpty::Expression(Expression::BinaryExpression(node)))\n }\n+ __JSXExpressionOrEmptyTag::BooleanLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(JSXExpressionOrEmpty::Expression(Expression::BooleanLiteral(node)))\n+ }\n __JSXExpressionOrEmptyTag::CallExpression => {\n let node: Box = serde::Deserialize<'de> for JSXExpressionOrEmpty {\n )?;\n Ok(JSXExpressionOrEmpty::Expression(Expression::NewExpression(node)))\n }\n+ __JSXExpressionOrEmptyTag::NullLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(JSXExpressionOrEmpty::Expression(Expression::NullLiteral(node)))\n+ }\n+ __JSXExpressionOrEmptyTag::NumericLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(JSXExpressionOrEmpty::Expression(Expression::NumericLiteral(node)))\n+ }\n __JSXExpressionOrEmptyTag::ObjectExpression => {\n let node: Box = serde::Deserialize<'de> for JSXExpressionOrEmpty {\n ),\n )\n }\n+ __JSXExpressionOrEmptyTag::StringLiteral => {\n+ let node: Box = as Deserialize>::deserialize(\n+ serde::__private::de::ContentDeserializer::::new(tagged.1),\n+ )?;\n+ Ok(JSXExpressionOrEmpty::Expression(Expression::StringLiteral(node)))\n+ }\n __JSXExpressionOrEmptyTag::TaggedTemplateExpression => {\n let node: Box = {\n fn visit_import_declaration_specifier(\n &mut self,\n specifier: &'ast ImportDeclarationSpecifier,\n- _source: &'ast Literal,\n+ _source: &'ast _Literal,\n ) {\n match specifier {\n ImportDeclarationSpecifier::ImportSpecifier(specifier) => {\n@@ -406,17 +406,22 @@ pub trait Visitor<'ast> {\n \n fn visit_identifier(&mut self, _identifier: &'ast Identifier) {\n \/\/ nothing to do unless overridden\n+ todo!(\"Implement visit_identifier()\")\n }\n \n- fn visit_import_source(&mut self, literal: &'ast Literal) {\n- self.visit_literal(literal);\n+ fn visit_import_source(&mut self, literal: &'ast _Literal) {\n+ self.visit_any_literal(literal);\n }\n \n- fn visit_export_source(&mut self, literal: &'ast Literal) {\n- self.visit_literal(literal);\n+ fn visit_export_source(&mut self, literal: &'ast _Literal) {\n+ self.visit_any_literal(literal);\n+ }\n+\n+ fn visit_any_literal(&mut self, _literal: &'ast _Literal) {\n+ todo!(\"Implement visit_any_literal()\")\n }\n \n fn visit_literal(&mut self, _literal: &'ast Literal) {\n- \/\/ nothing to do unless overridden\n+ todo!(\"Implement visit_literal()\")\n }\n }\ndiff --git a\/compiler\/forget\/crates\/forget_estree_codegen\/src\/codegen.rs b\/compiler\/forget\/crates\/forget_estree_codegen\/src\/codegen.rs\nindex 85228cab97..217da8587d 100644\n--- a\/compiler\/forget\/crates\/forget_estree_codegen\/src\/codegen.rs\n+++ b\/compiler\/forget\/crates\/forget_estree_codegen\/src\/codegen.rs\n@@ -20,6 +20,21 @@ pub fn estree() -> String {\n )\n }\n \n+\/\/\/ Returns prettyplease-formatted Rust source for converting HermesParser results\n+\/\/\/ into estree\n+pub fn estree_hermes() -> String {\n+ let src = include_str!(\".\/ecmascript.json\");\n+ let grammar: Grammar = serde_json::from_str(src).unwrap();\n+ let raw = grammar.codegen_hermes().to_string();\n+\n+ let parsed = syn::parse_file(&raw).unwrap();\n+ format!(\n+ \"\/\/ {}generated\\n#![cfg_attr(rustfmt, rustfmt_skip)]\\n{}\",\n+ '\\u{0040}',\n+ prettyplease::unparse(&parsed)\n+ )\n+}\n+\n #[derive(Serialize, Deserialize, Debug)]\n #[serde(deny_unknown_fields)]\n pub struct Grammar {\n@@ -59,7 +74,7 @@ impl Grammar {\n use std::num::NonZeroU32;\n use serde::ser::{Serializer, SerializeMap};\n use serde::{Serialize,Deserialize};\n- use crate::{JsValue, Binding, SourceRange};\n+ use crate::{JsValue, Binding, SourceRange, Number};\n \n #(#objects)*\n \n@@ -70,6 +85,42 @@ impl Grammar {\n #(#operators)*\n }\n }\n+\n+ pub fn codegen_hermes(self) -> TokenStream {\n+ let nodes: Vec<_> = self\n+ .nodes\n+ .iter()\n+ .filter(|(_, node)| !node.skip_hermes_codegen)\n+ .map(|(name, node)| node.codegen_hermes(name))\n+ .collect();\n+ let enums: Vec<_> = self\n+ .enums\n+ .iter()\n+ .map(|(name, enum_)| enum_.codegen_hermes(name, &self))\n+ .collect();\n+ let operators: Vec<_> = self\n+ .operators\n+ .iter()\n+ .map(|(name, operator)| operator.codegen_hermes(name))\n+ .collect();\n+\n+ quote! {\n+ #![allow(dead_code)]\n+ #![allow(unused_variables)]\n+\n+ use forget_estree::*;\n+ use hermes;\n+ use hermes::parser::{NodePtr, NodeKind, NodeLabel };\n+ use hermes::utf::{utf8_with_surrogates_to_string};\n+ use crate::generated_extension::*;\n+\n+ #(#nodes)*\n+\n+ #(#enums)*\n+\n+ #(#operators)*\n+ }\n+ }\n }\n \n #[derive(Serialize, Deserialize, Debug)]\n@@ -107,6 +158,12 @@ pub struct Node {\n \n #[serde(default)]\n pub fields: IndexMap,\n+\n+ #[serde(default)]\n+ pub skip_hermes_codegen: bool,\n+\n+ #[serde(default)]\n+ pub skip_hermes_enum_variant: bool,\n }\n \n impl Node {\n@@ -175,11 +232,108 @@ impl Node {\n }\n }\n }\n+\n+ pub fn codegen_hermes(&self, name: &str) -> TokenStream {\n+ let name_str = name;\n+ let name = format_ident!(\"{}\", name);\n+ let field_names: Vec<_> = self\n+ .fields\n+ .iter()\n+ .map(|(name, _field)| format_ident!(\"{}\", name))\n+ .collect();\n+ let fields: Vec<_> = self\n+ .fields\n+ .iter()\n+ .map(|(name, field)| {\n+ let (type_name_str, type_kind) = parse_type(&field.type_).unwrap();\n+ let camelcase_name = field.rename.as_ref().unwrap_or(name);\n+ let field_name = format_ident!(\"{}\", name);\n+ let helper = format_ident!(\"hermes_get_{}_{}\", name_str, camelcase_name);\n+ let type_name = format_ident!(\"{}\", type_name_str);\n+ if field.skip || field.hermes_default {\n+ return quote! {\n+ let #field_name = Default::default();\n+ };\n+ }\n+ if let Some(convert_with) = &field.hermes_convert_with {\n+ let convert_with = format_ident!(\"{}\", convert_with);\n+ return quote! {\n+ let #field_name = #convert_with(cx, unsafe { hermes::parser::#helper(node) } );\n+ }\n+ }\n+ match type_kind {\n+ TypeKind::Named => {\n+ match type_name_str.as_ref() {\n+ \"bool\" => {\n+ quote! {\n+ let #field_name = unsafe { hermes::parser::#helper(node) };\n+ }\n+ }\n+ \"Number\" => {\n+ quote! {\n+ let #field_name = convert_number(unsafe { hermes::parser::#helper(node) });\n+ }\n+ }\n+ \"String\" => {\n+ quote! {\n+ let #field_name = convert_string(cx, unsafe { hermes::parser::#helper(node) });\n+ }\n+ }\n+ _ => {\n+ quote! {\n+ let #field_name = #type_name::convert(cx, unsafe { hermes::parser::#helper(node) });\n+ }\n+ }\n+ }\n+ }\n+ TypeKind::Option => {\n+ match type_name_str.as_ref() {\n+ \"String\" => {\n+ quote! {\n+ let #field_name = convert_option_string(cx, unsafe { hermes::parser::#helper(node) });\n+ }\n+ }\n+ _ => {\n+ quote! {\n+ let #field_name = convert_option(unsafe { hermes::parser::#helper(node) }, |node| #type_name::convert(cx, node));\n+ }\n+ }\n+ }\n+ }\n+ TypeKind::Vec => {\n+ quote! {\n+ let #field_name = convert_vec(unsafe { hermes::parser::#helper(node) }, |node| #type_name::convert(cx, node));\n+ }\n+ }\n+ TypeKind::VecOfOption => {\n+ quote! {\n+ let #field_name = convert_vec_of_option(unsafe { hermes::parser::#helper(node) }, |node| #type_name::convert(cx, node));\n+ }\n+ }\n+ }\n+ })\n+ .collect();\n+\n+ quote! {\n+ impl FromHermes for #name {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ #(#fields)*\n+ Self {\n+ #(#field_names,)*\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+ }\n+ }\n+ }\n }\n \n #[derive(Serialize, Deserialize, Debug)]\n #[serde(deny_unknown_fields)]\n pub struct Field {\n+ \/\/ TODO: deserialize with `parse_type` into a custom type\n #[serde(rename = \"type\")]\n pub type_: String,\n \n@@ -198,11 +352,18 @@ pub struct Field {\n #[serde(default)]\n #[serde(rename = \"TODO\")]\n pub todo: Option,\n+\n+ #[serde(default)]\n+ pub hermes_convert_with: Option,\n+\n+ #[serde(default)]\n+ pub hermes_default: bool,\n }\n \n impl Field {\n pub fn codegen(&self, name: &str) -> TokenStream {\n let name = format_ident!(\"{}\", name);\n+ parse_type(&self.type_).unwrap();\n let type_name: Type = syn::parse_str(&self.type_)\n .unwrap_or_else(|_| panic!(\"Expected a type name, got `{}`\", &self.type_));\n \n@@ -237,6 +398,7 @@ impl Field {\n \n pub fn codegen_node(&self, name: &str) -> TokenStream {\n let name = format_ident!(\"{}\", name);\n+ parse_type(&self.type_).unwrap();\n let type_name: Type = syn::parse_str(&self.type_)\n .unwrap_or_else(|_| panic!(\"Expected a type name, got `{}`\", &self.type_));\n let type_ = quote!(#type_name);\n@@ -386,6 +548,86 @@ impl Enum {\n }\n }\n }\n+\n+ pub fn codegen_hermes(&self, name: &str, grammar: &Grammar) -> TokenStream {\n+ let name = format_ident!(\"{}\", name);\n+\n+ let mut tag_matches = Vec::new();\n+ let mut seen = HashSet::new();\n+\n+ \/\/ Imagine a case like:\n+ \/\/ enum ModuleItem {\n+ \/\/ ImportDeclaration, \/\/ struct\n+ \/\/ Statement \/\/ another enum\n+ \/\/ }\n+ \/\/ We need to generate matches for all the possible *concrete* `type` values, which means\n+ \/\/ we have to expand nested enums such as `Statement`\n+ for variant in self.variants.iter() {\n+ if let Some(nested_enum) = grammar.enums.get(variant) {\n+ let outer_variant = format_ident!(\"{}\", variant);\n+ for variant in nested_enum.variants.iter() {\n+ \/\/ Skip variants that appear in multiple nested enums, we deserialize\n+ \/\/ as the first listed outer variant\n+ if !seen.insert(variant.to_string()) {\n+ continue;\n+ }\n+ \/\/ Modeling ESTree only requires a single level of nested enums,\n+ \/\/ so that's all we support. Though in theory we could support arbitrary nesting,\n+ \/\/ since ultimately we're matching based on the final concrete types.\n+ assert!(!grammar.enums.contains_key(variant));\n+ let node = grammar.nodes.get(variant).unwrap();\n+ if node.skip_hermes_enum_variant {\n+ continue;\n+ }\n+\n+ let inner_variant = format_ident!(\"{}\", variant);\n+ let node_variant_name = node.type_.as_ref().unwrap_or(variant);\n+ let node_variant = format_ident!(\"{}\", node_variant_name);\n+\n+ tag_matches.push(quote! {\n+ NodeKind::#node_variant => {\n+ let node = #inner_variant::convert(cx, node);\n+ #name::#outer_variant(#outer_variant::#inner_variant(Box::new(node)))\n+ }\n+ });\n+ }\n+ } else {\n+ if !seen.insert(variant.to_string()) {\n+ panic!(\n+ \"Concrete variant {} was already added by a nested enum\",\n+ variant\n+ );\n+ }\n+ let variant_name = format_ident!(\"{}\", variant);\n+ let node = grammar.nodes.get(variant).unwrap();\n+ if node.skip_hermes_enum_variant {\n+ continue;\n+ }\n+\n+ let node_variant_name = node.type_.as_ref().unwrap_or(variant);\n+ let node_variant = format_ident!(\"{}\", node_variant_name);\n+\n+ tag_matches.push(quote! {\n+ NodeKind::#node_variant => {\n+ let node = #variant_name::convert(cx, node);\n+ #name::#variant_name(Box::new(node))\n+ }\n+ })\n+ }\n+ }\n+\n+ quote! {\n+ impl FromHermes for #name {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ #(#tag_matches),*\n+ _ => panic!(\"Unexpected node\")\n+ }\n+ }\n+ }\n+ }\n+ }\n }\n \n #[derive(Serialize, Deserialize, Debug)]\n@@ -457,4 +699,67 @@ impl Operator {\n }\n }\n }\n+\n+ pub fn codegen_hermes(&self, name: &str) -> TokenStream {\n+ let mut sorted_variants: Vec<_> = self.variants.iter().collect();\n+ sorted_variants.sort();\n+\n+ let name = format_ident!(\"{}\", name);\n+\n+ quote! {\n+ impl FromHermesLabel for #name {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+ }\n+ }\n+ }\n+}\n+\n+enum TypeKind {\n+ \/\/\/ T\n+ Named,\n+\n+ \/\/\/ Option\n+ Option,\n+\n+ \/\/\/ Vec\n+ Vec,\n+\n+ \/\/\/ Vec>\n+ VecOfOption,\n+}\n+\n+\/\/\/ Parses a given type into the underlying type name plus a descriptor of the\n+\/\/\/ kind of type. Only a subset of Rust types are supported:\n+\/\/\/ - T\n+\/\/\/ - Option\n+\/\/\/ - Vec\n+\/\/\/ - Vec>\n+fn parse_type(type_: &str) -> Result<(String, TypeKind), String> {\n+ let mut current = type_;\n+ let mut is_list = false;\n+ let mut is_option = false;\n+ if current.starts_with(\"Vec<\") {\n+ current = ¤t[4..current.len() - 1];\n+ is_list = true;\n+ }\n+ if current.starts_with(\"Option<\") {\n+ current = ¤t[7..current.len() - 1];\n+ is_option = true;\n+ }\n+ if current.contains(\"<\") {\n+ Err(format!(\n+ \"Unsupported type `{current}` expected named type (`Identifier`), optional type (`Option`), list type (`Vec`), or optional list (`Vec>`)\"\n+ ))\n+ } else {\n+ let kind = match (is_list, is_option) {\n+ (true, true) => TypeKind::VecOfOption,\n+ (true, false) => TypeKind::Vec,\n+ (false, true) => TypeKind::Option,\n+ (false, false) => TypeKind::Named,\n+ };\n+ Ok((current.to_string(), kind))\n+ }\n }\ndiff --git a\/compiler\/forget\/crates\/forget_estree_codegen\/src\/ecmascript.json b\/compiler\/forget\/crates\/forget_estree_codegen\/src\/ecmascript.json\nindex 1ae57eee07..e13e6b9153 100644\n--- a\/compiler\/forget\/crates\/forget_estree_codegen\/src\/ecmascript.json\n+++ b\/compiler\/forget\/crates\/forget_estree_codegen\/src\/ecmascript.json\n@@ -23,6 +23,20 @@\n }\n }\n },\n+ \"Class\": {\n+ \"fields\": {\n+ \"id\": {\n+ \"type\": \"Option\"\n+ },\n+ \"super_class\": {\n+ \"type\": \"Option\",\n+ \"rename\": \"superClass\"\n+ },\n+ \"body\": {\n+ \"type\": \"ClassBody\"\n+ }\n+ }\n+ },\n \"Function\": {\n \"fields\": {\n \"id\": {\n@@ -89,6 +103,8 @@\n }\n },\n \"Literal\": {\n+ \"skip_hermes_codegen\": true,\n+ \"skip_hermes_enum_variant\": true,\n \"fields\": {\n \"value\": {\n \"type\": \"JsValue\"\n@@ -107,6 +123,29 @@\n }\n }\n },\n+ \"NumericLiteral\": {\n+ \"fields\": {\n+ \"value\": {\n+ \"type\": \"Number\"\n+ }\n+ }\n+ },\n+ \"BooleanLiteral\": {\n+ \"fields\": {\n+ \"value\": {\n+ \"type\": \"bool\"\n+ }\n+ }\n+ },\n+ \"NullLiteral\": {},\n+ \"StringLiteral\": {\n+ \"fields\": {\n+ \"value\": {\n+ \"type\": \"String\",\n+ \"hermes_convert_with\": \"convert_string_value\"\n+ }\n+ }\n+ },\n \"Program\": {\n \"fields\": {\n \"body\": {\n@@ -115,7 +154,8 @@\n \"source_type\": {\n \"type\": \"SourceType\",\n \"optional\": true,\n- \"rename\": \"sourceType\"\n+ \"rename\": \"sourceType\",\n+ \"hermes_default\": true\n }\n }\n },\n@@ -126,7 +166,8 @@\n },\n \"directive\": {\n \"type\": \"Option\",\n- \"optional\": true\n+ \"optional\": true,\n+ \"hermes_default\": true\n }\n }\n },\n@@ -311,6 +352,7 @@\n }\n },\n \"FunctionDeclaration\": {\n+ \"skip_hermes_codegen\": true,\n \"fields\": {\n \"function\": {\n \"type\": \"Function\",\n@@ -318,21 +360,8 @@\n }\n }\n },\n- \"Class\": {\n- \"fields\": {\n- \"id\": {\n- \"type\": \"Option\"\n- },\n- \"super_class\": {\n- \"type\": \"Option\",\n- \"rename\": \"superClass\"\n- },\n- \"body\": {\n- \"type\": \"ClassBody\"\n- }\n- }\n- },\n \"ClassDeclaration\": {\n+ \"skip_hermes_codegen\": true,\n \"fields\": {\n \"class\": {\n \"type\": \"Class\",\n@@ -341,6 +370,7 @@\n }\n },\n \"ClassExpression\": {\n+ \"skip_hermes_codegen\": true,\n \"fields\": {\n \"class\": {\n \"type\": \"Class\",\n@@ -400,7 +430,8 @@\n \"ArrayExpression\": {\n \"fields\": {\n \"elements\": {\n- \"type\": \"Vec>\"\n+ \"type\": \"Vec>\",\n+ \"hermes_convert_with\": \"convert_array_expression_elements\"\n }\n }\n },\n@@ -437,6 +468,7 @@\n }\n },\n \"FunctionExpression\": {\n+ \"skip_hermes_codegen\": true,\n \"fields\": {\n \"function\": {\n \"type\": \"Function\",\n@@ -445,6 +477,7 @@\n }\n },\n \"ArrowFunctionExpression\": {\n+ \"skip_hermes_codegen\": true,\n \"fields\": {\n \"function\": {\n \"type\": \"Function\",\n@@ -532,11 +565,6 @@\n \"is_computed\": {\n \"type\": \"bool\",\n \"rename\": \"computed\"\n- },\n- \"is_optional\": {\n- \"type\": \"bool\",\n- \"optional\": true,\n- \"rename\": \"optional\"\n }\n }\n },\n@@ -560,11 +588,6 @@\n },\n \"arguments\": {\n \"type\": \"Vec\"\n- },\n- \"is_optional\": {\n- \"type\": \"bool\",\n- \"optional\": true,\n- \"rename\": \"optional\"\n }\n }\n },\n@@ -611,7 +634,7 @@\n \"type\": \"Vec\"\n },\n \"source\": {\n- \"type\": \"Literal\"\n+ \"type\": \"_Literal\"\n }\n }\n },\n@@ -648,7 +671,7 @@\n \"type\": \"Vec\"\n },\n \"source\": {\n- \"type\": \"Option\"\n+ \"type\": \"Option<_Literal>\"\n }\n }\n },\n@@ -669,11 +692,12 @@\n \"ExportAllDeclaration\": {\n \"fields\": {\n \"source\": {\n- \"type\": \"Literal\"\n+ \"type\": \"_Literal\"\n },\n \"exported\": {\n \"type\": \"Option\",\n- \"optional\": true\n+ \"optional\": true,\n+ \"hermes_default\": true\n }\n }\n },\n@@ -765,7 +789,8 @@\n \"JSXText\": {\n \"fields\": {\n \"value\": {\n- \"type\": \"String\"\n+ \"type\": \"String\",\n+ \"hermes_convert_with\": \"convert_string_value\"\n },\n \"raw\": {\n \"type\": \"String\"\n@@ -797,7 +822,7 @@\n \"type\": \"Vec\"\n },\n \"closing_fragment\": {\n- \"type\": \"Option\",\n+ \"type\": \"JSXClosingFragment\",\n \"rename\": \"closingFragment\"\n }\n }\n@@ -819,6 +844,7 @@\n }\n },\n \"AssignmentProperty\": {\n+ \"skip_hermes_codegen\": true,\n \"type\": \"Property\",\n \"fields\": {\n \"key\": {\n@@ -865,6 +891,7 @@\n }\n },\n \"TemplateElement\": {\n+ \"skip_hermes_codegen\": true,\n \"fields\": {\n \"tail\": {\n \"type\": \"bool\"\n@@ -902,6 +929,8 @@\n }\n },\n \"ChainExpression\": {\n+ \"skip_hermes_codegen\": true,\n+ \"skip_hermes_enum_variant\": true,\n \"fields\": {\n \"expression\": {\n \"type\": \"ChainElement\"\n@@ -914,7 +943,7 @@\n \"type\": \"Expression\"\n },\n \"property\": {\n- \"type\": \"Identifier\"\n+ \"type\": \"Expression\"\n },\n \"is_computed\": {\n \"type\": \"bool\",\n@@ -980,6 +1009,7 @@\n \"AssignmentExpression\",\n \"AwaitExpression\",\n \"BinaryExpression\",\n+ \"BooleanLiteral\",\n \"CallExpression\",\n \"ChainExpression\",\n \"ClassExpression\",\n@@ -993,10 +1023,13 @@\n \"MemberExpression\",\n \"MetaProperty\",\n \"NewExpression\",\n+ \"NullLiteral\",\n+ \"NumericLiteral\",\n \"ObjectExpression\",\n \"OptionalCallExpression\",\n \"OptionalMemberExpression\",\n \"SequenceExpression\",\n+ \"StringLiteral\",\n \"TaggedTemplateExpression\",\n \"TemplateLiteral\",\n \"ThisExpression\",\n@@ -1004,6 +1037,13 @@\n \"UpdateExpression\",\n \"YieldExpression\"\n ],\n+ \"_Literal\": [\n+ \"Literal\",\n+ \"BooleanLiteral\",\n+ \"NullLiteral\",\n+ \"StringLiteral\",\n+ \"NumericLiteral\"\n+ ],\n \"Declaration\": [\n \"ClassDeclaration\",\n \"FunctionDeclaration\",\ndiff --git a\/compiler\/forget\/crates\/forget_estree_codegen\/src\/lib.rs b\/compiler\/forget\/crates\/forget_estree_codegen\/src\/lib.rs\nindex 47d0ac41ec..f1caaaa1c2 100644\n--- a\/compiler\/forget\/crates\/forget_estree_codegen\/src\/lib.rs\n+++ b\/compiler\/forget\/crates\/forget_estree_codegen\/src\/lib.rs\n@@ -1,3 +1,3 @@\n mod codegen;\n \n-pub use codegen::estree;\n+pub use codegen::{estree, estree_hermes};\ndiff --git a\/compiler\/forget\/crates\/forget_estree_swc\/src\/lib.rs b\/compiler\/forget\/crates\/forget_estree_swc\/src\/lib.rs\nindex b6e185c2cf..ab0f32e3cb 100644\n--- a\/compiler\/forget\/crates\/forget_estree_swc\/src\/lib.rs\n+++ b\/compiler\/forget\/crates\/forget_estree_swc\/src\/lib.rs\n@@ -340,7 +340,6 @@ fn convert_expression(cx: &Context, expr: &Expr) -> forget_estree::Expression {\n _ => todo!(),\n },\n arguments: convert_arguments(cx, &expr.args),\n- is_optional: false,\n loc: None,\n range: convert_span(&expr.span),\n }))\n@@ -452,9 +451,9 @@ fn convert_expression(cx: &Context, expr: &Expr) -> forget_estree::Expression {\n }),\n ),\n OptChainBase::Member(base) => {\n- let mut member = convert_member_expression(cx, base);\n+ let mut member = convert_optional_member_expression(cx, base);\n member.is_optional = expr.optional;\n- forget_estree::Expression::MemberExpression(Box::new(member))\n+ forget_estree::Expression::OptionalMemberExpression(Box::new(member))\n }\n },\n Expr::JSXElement(expr) => {\n@@ -779,6 +778,29 @@ fn convert_member_expression(cx: &Context, expr: &MemberExpr) -> forget_estree::\n object: forget_estree::ExpressionOrSuper::Expression(convert_expression(cx, &expr.obj)),\n property,\n is_computed,\n+ loc: None,\n+ range: convert_span(&expr.span),\n+ }\n+}\n+\n+fn convert_optional_member_expression(\n+ cx: &Context,\n+ expr: &MemberExpr,\n+) -> forget_estree::OptionalMemberExpression {\n+ let (is_computed, property) = match &expr.prop {\n+ MemberProp::Ident(prop) => (\n+ false,\n+ forget_estree::Expression::Identifier(Box::new(convert_identifier(cx, prop))),\n+ ),\n+ MemberProp::Computed(prop) => (true, convert_expression(cx, &prop.expr)),\n+ _ => {\n+ panic!(\"PrivateName member expression properties are not supported\")\n+ }\n+ };\n+ forget_estree::OptionalMemberExpression {\n+ object: convert_expression(cx, &expr.obj),\n+ property,\n+ is_computed,\n is_optional: false,\n loc: None,\n range: convert_span(&expr.span),\ndiff --git a\/compiler\/forget\/crates\/forget_hermes_parser\/Cargo.toml b\/compiler\/forget\/crates\/forget_hermes_parser\/Cargo.toml\nindex 6b1bc602fd..58a84ea1f4 100644\n--- a\/compiler\/forget\/crates\/forget_hermes_parser\/Cargo.toml\n+++ b\/compiler\/forget\/crates\/forget_hermes_parser\/Cargo.toml\n@@ -15,4 +15,7 @@ repository.workspace = true\n forget_diagnostics = { workspace = true }\n forget_estree = { workspace = true }\n hermes = { workspace = true } \n-juno_support = { workspace = true }\n\\ No newline at end of file\n+juno_support = { workspace = true }\n+\n+[build-dependencies]\n+forget_estree_codegen = { workspace = true }\n\\ No newline at end of file\ndiff --git a\/compiler\/forget\/crates\/forget_hermes_parser\/build.rs b\/compiler\/forget\/crates\/forget_hermes_parser\/build.rs\nnew file mode 100644\nindex 0000000000..20b6c2a5d4\n--- \/dev\/null\n+++ b\/compiler\/forget\/crates\/forget_hermes_parser\/build.rs\n@@ -0,0 +1,13 @@\n+use forget_estree_codegen::estree_hermes;\n+\n+\/\/ Example custom build script.\n+fn main() {\n+ \/\/ Re-run if the codegen files change\n+ println!(\"cargo:rerun-if-changed=..\/forget_estree_codegen\/src\/codegen.rs\");\n+ println!(\"cargo:rerun-if-changed=..\/forget_estree_codegen\/src\/lib.rs\");\n+ println!(\"cargo:rerun-if-changed=..\/forget_estree_codegen\/src\/ecmascript.json\");\n+ println!(\"cargo:rerun-if-changed=..\/forget_estree_codegen\");\n+\n+ let src = estree_hermes();\n+ std::fs::write(\"src\/generated.rs\", src).unwrap();\n+}\ndiff --git a\/compiler\/forget\/crates\/forget_hermes_parser\/src\/generated.rs b\/compiler\/forget\/crates\/forget_hermes_parser\/src\/generated.rs\nnew file mode 100644\nindex 0000000000..04abb0984d\n--- \/dev\/null\n+++ b\/compiler\/forget\/crates\/forget_hermes_parser\/src\/generated.rs\n@@ -0,0 +1,3141 @@\n+\/\/ @generated\n+#![cfg_attr(rustfmt, rustfmt_skip)]\n+#![allow(dead_code)]\n+#![allow(unused_variables)]\n+use forget_estree::*;\n+use hermes;\n+use hermes::parser::{NodePtr, NodeKind, NodeLabel};\n+use hermes::utf::utf8_with_surrogates_to_string;\n+use crate::generated_extension::*;\n+impl FromHermes for Identifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let name = convert_string(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_Identifier_name(node) },\n+ );\n+ let binding = Default::default();\n+ Self {\n+ name,\n+ binding,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for NumericLiteral {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let value = convert_number(unsafe {\n+ hermes::parser::hermes_get_NumericLiteral_value(node)\n+ });\n+ Self {\n+ value,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for BooleanLiteral {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let value = unsafe { hermes::parser::hermes_get_BooleanLiteral_value(node) };\n+ Self {\n+ value,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for NullLiteral {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for StringLiteral {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let value = convert_string_value(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_StringLiteral_value(node) },\n+ );\n+ Self {\n+ value,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for Program {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let body = convert_vec(\n+ unsafe { hermes::parser::hermes_get_Program_body(node) },\n+ |node| ModuleItem::convert(cx, node),\n+ );\n+ let source_type = Default::default();\n+ Self {\n+ body,\n+ source_type,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ExpressionStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let expression = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ExpressionStatement_expression(node) },\n+ );\n+ let directive = Default::default();\n+ Self {\n+ expression,\n+ directive,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for BlockStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let body = convert_vec(\n+ unsafe { hermes::parser::hermes_get_BlockStatement_body(node) },\n+ |node| Statement::convert(cx, node),\n+ );\n+ Self {\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for EmptyStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for DebuggerStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for WithStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let object = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_WithStatement_object(node) },\n+ );\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_WithStatement_body(node) },\n+ );\n+ Self {\n+ object,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ReturnStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = convert_option(\n+ unsafe { hermes::parser::hermes_get_ReturnStatement_argument(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ Self {\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for LabeledStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let label = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_LabeledStatement_label(node) },\n+ );\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_LabeledStatement_body(node) },\n+ );\n+ Self {\n+ label,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for BreakStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let label = convert_option(\n+ unsafe { hermes::parser::hermes_get_BreakStatement_label(node) },\n+ |node| Identifier::convert(cx, node),\n+ );\n+ Self {\n+ label,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ContinueStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let label = convert_option(\n+ unsafe { hermes::parser::hermes_get_ContinueStatement_label(node) },\n+ |node| Identifier::convert(cx, node),\n+ );\n+ Self {\n+ label,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for IfStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let test = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_IfStatement_test(node) },\n+ );\n+ let consequent = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_IfStatement_consequent(node) },\n+ );\n+ let alternate = convert_option(\n+ unsafe { hermes::parser::hermes_get_IfStatement_alternate(node) },\n+ |node| Statement::convert(cx, node),\n+ );\n+ Self {\n+ test,\n+ consequent,\n+ alternate,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for SwitchStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let discriminant = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_SwitchStatement_discriminant(node) },\n+ );\n+ let cases = convert_vec(\n+ unsafe { hermes::parser::hermes_get_SwitchStatement_cases(node) },\n+ |node| SwitchCase::convert(cx, node),\n+ );\n+ Self {\n+ discriminant,\n+ cases,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for SwitchCase {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let test = convert_option(\n+ unsafe { hermes::parser::hermes_get_SwitchCase_test(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ let consequent = convert_vec(\n+ unsafe { hermes::parser::hermes_get_SwitchCase_consequent(node) },\n+ |node| Statement::convert(cx, node),\n+ );\n+ Self {\n+ test,\n+ consequent,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ThrowStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ThrowStatement_argument(node) },\n+ );\n+ Self {\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for TryStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let block = BlockStatement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_TryStatement_block(node) },\n+ );\n+ let handler = convert_option(\n+ unsafe { hermes::parser::hermes_get_TryStatement_handler(node) },\n+ |node| CatchClause::convert(cx, node),\n+ );\n+ let finalizer = convert_option(\n+ unsafe { hermes::parser::hermes_get_TryStatement_finalizer(node) },\n+ |node| BlockStatement::convert(cx, node),\n+ );\n+ Self {\n+ block,\n+ handler,\n+ finalizer,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for CatchClause {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let param = convert_option(\n+ unsafe { hermes::parser::hermes_get_CatchClause_param(node) },\n+ |node| Pattern::convert(cx, node),\n+ );\n+ let body = BlockStatement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_CatchClause_body(node) },\n+ );\n+ Self {\n+ param,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for WhileStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let test = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_WhileStatement_test(node) },\n+ );\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_WhileStatement_body(node) },\n+ );\n+ Self {\n+ test,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for DoWhileStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_DoWhileStatement_body(node) },\n+ );\n+ let test = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_DoWhileStatement_test(node) },\n+ );\n+ Self {\n+ body,\n+ test,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ForStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let init = convert_option(\n+ unsafe { hermes::parser::hermes_get_ForStatement_init(node) },\n+ |node| ForInit::convert(cx, node),\n+ );\n+ let test = convert_option(\n+ unsafe { hermes::parser::hermes_get_ForStatement_test(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ let update = convert_option(\n+ unsafe { hermes::parser::hermes_get_ForStatement_update(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForStatement_body(node) },\n+ );\n+ Self {\n+ init,\n+ test,\n+ update,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ForInStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let left = ForInInit::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForInStatement_left(node) },\n+ );\n+ let right = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForInStatement_right(node) },\n+ );\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForInStatement_body(node) },\n+ );\n+ Self {\n+ left,\n+ right,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ForOfStatement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let is_await = unsafe { hermes::parser::hermes_get_ForOfStatement_await(node) };\n+ let left = ForInInit::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForOfStatement_left(node) },\n+ );\n+ let right = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForOfStatement_right(node) },\n+ );\n+ let body = Statement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ForOfStatement_body(node) },\n+ );\n+ Self {\n+ is_await,\n+ left,\n+ right,\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ClassBody {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let body = convert_vec(\n+ unsafe { hermes::parser::hermes_get_ClassBody_body(node) },\n+ |node| MethodDefinition::convert(cx, node),\n+ );\n+ Self {\n+ body,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for MethodDefinition {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let key = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MethodDefinition_key(node) },\n+ );\n+ let value = FunctionExpression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MethodDefinition_value(node) },\n+ );\n+ let kind = MethodKind::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MethodDefinition_kind(node) },\n+ );\n+ let is_computed = unsafe {\n+ hermes::parser::hermes_get_MethodDefinition_computed(node)\n+ };\n+ let is_static = unsafe {\n+ hermes::parser::hermes_get_MethodDefinition_static(node)\n+ };\n+ Self {\n+ key,\n+ value,\n+ kind,\n+ is_computed,\n+ is_static,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for VariableDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let kind = VariableDeclarationKind::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_VariableDeclaration_kind(node) },\n+ );\n+ let declarations = convert_vec(\n+ unsafe { hermes::parser::hermes_get_VariableDeclaration_declarations(node) },\n+ |node| VariableDeclarator::convert(cx, node),\n+ );\n+ Self {\n+ kind,\n+ declarations,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for VariableDeclarator {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let id = Pattern::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_VariableDeclarator_id(node) },\n+ );\n+ let init = convert_option(\n+ unsafe { hermes::parser::hermes_get_VariableDeclarator_init(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ Self {\n+ id,\n+ init,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ThisExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ArrayExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let elements = convert_array_expression_elements(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ArrayExpression_elements(node) },\n+ );\n+ Self {\n+ elements,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ObjectExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let properties = convert_vec(\n+ unsafe { hermes::parser::hermes_get_ObjectExpression_properties(node) },\n+ |node| PropertyOrSpreadElement::convert(cx, node),\n+ );\n+ Self {\n+ properties,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for Property {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let key = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_Property_key(node) },\n+ );\n+ let value = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_Property_value(node) },\n+ );\n+ let kind = PropertyKind::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_Property_kind(node) },\n+ );\n+ let is_method = unsafe { hermes::parser::hermes_get_Property_method(node) };\n+ let is_shorthand = unsafe {\n+ hermes::parser::hermes_get_Property_shorthand(node)\n+ };\n+ let is_computed = unsafe { hermes::parser::hermes_get_Property_computed(node) };\n+ Self {\n+ key,\n+ value,\n+ kind,\n+ is_method,\n+ is_shorthand,\n+ is_computed,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for UnaryExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let operator = UnaryOperator::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_UnaryExpression_operator(node) },\n+ );\n+ let prefix = unsafe { hermes::parser::hermes_get_UnaryExpression_prefix(node) };\n+ let argument = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_UnaryExpression_argument(node) },\n+ );\n+ Self {\n+ operator,\n+ prefix,\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for UpdateExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let operator = UpdateOperator::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_UpdateExpression_operator(node) },\n+ );\n+ let argument = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_UpdateExpression_argument(node) },\n+ );\n+ let prefix = unsafe { hermes::parser::hermes_get_UpdateExpression_prefix(node) };\n+ Self {\n+ operator,\n+ argument,\n+ prefix,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for BinaryExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let left = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_BinaryExpression_left(node) },\n+ );\n+ let operator = BinaryOperator::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_BinaryExpression_operator(node) },\n+ );\n+ let right = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_BinaryExpression_right(node) },\n+ );\n+ Self {\n+ left,\n+ operator,\n+ right,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for AssignmentExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let operator = AssignmentOperator::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_AssignmentExpression_operator(node) },\n+ );\n+ let left = AssignmentTarget::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_AssignmentExpression_left(node) },\n+ );\n+ let right = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_AssignmentExpression_right(node) },\n+ );\n+ Self {\n+ operator,\n+ left,\n+ right,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for LogicalExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let operator = LogicalOperator::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_LogicalExpression_operator(node) },\n+ );\n+ let left = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_LogicalExpression_left(node) },\n+ );\n+ let right = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_LogicalExpression_right(node) },\n+ );\n+ Self {\n+ operator,\n+ left,\n+ right,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for MemberExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let object = ExpressionOrSuper::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MemberExpression_object(node) },\n+ );\n+ let property = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MemberExpression_property(node) },\n+ );\n+ let is_computed = unsafe {\n+ hermes::parser::hermes_get_MemberExpression_computed(node)\n+ };\n+ Self {\n+ object,\n+ property,\n+ is_computed,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ConditionalExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let test = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ConditionalExpression_test(node) },\n+ );\n+ let alternate = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ConditionalExpression_alternate(node) },\n+ );\n+ let consequent = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ConditionalExpression_consequent(node) },\n+ );\n+ Self {\n+ test,\n+ alternate,\n+ consequent,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for CallExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let callee = ExpressionOrSuper::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_CallExpression_callee(node) },\n+ );\n+ let arguments = convert_vec(\n+ unsafe { hermes::parser::hermes_get_CallExpression_arguments(node) },\n+ |node| ExpressionOrSpread::convert(cx, node),\n+ );\n+ Self {\n+ callee,\n+ arguments,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for NewExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let callee = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_NewExpression_callee(node) },\n+ );\n+ let arguments = convert_vec(\n+ unsafe { hermes::parser::hermes_get_NewExpression_arguments(node) },\n+ |node| ExpressionOrSpread::convert(cx, node),\n+ );\n+ Self {\n+ callee,\n+ arguments,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for SequenceExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let expressions = convert_vec(\n+ unsafe { hermes::parser::hermes_get_SequenceExpression_expressions(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ Self {\n+ expressions,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for Super {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for SpreadElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_SpreadElement_argument(node) },\n+ );\n+ Self {\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for YieldExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = convert_option(\n+ unsafe { hermes::parser::hermes_get_YieldExpression_argument(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ let is_delegate = unsafe {\n+ hermes::parser::hermes_get_YieldExpression_delegate(node)\n+ };\n+ Self {\n+ argument,\n+ is_delegate,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ImportDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let specifiers = convert_vec(\n+ unsafe { hermes::parser::hermes_get_ImportDeclaration_specifiers(node) },\n+ |node| ImportDeclarationSpecifier::convert(cx, node),\n+ );\n+ let source = _Literal::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ImportDeclaration_source(node) },\n+ );\n+ Self {\n+ specifiers,\n+ source,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ImportSpecifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let imported = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ImportSpecifier_imported(node) },\n+ );\n+ let local = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ImportSpecifier_local(node) },\n+ );\n+ Self {\n+ imported,\n+ local,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ImportDefaultSpecifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let local = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ImportDefaultSpecifier_local(node) },\n+ );\n+ Self {\n+ local,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ImportNamespaceSpecifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let local = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ImportNamespaceSpecifier_local(node) },\n+ );\n+ Self {\n+ local,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ExportNamedDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let declaration = convert_option(\n+ unsafe {\n+ hermes::parser::hermes_get_ExportNamedDeclaration_declaration(node)\n+ },\n+ |node| Declaration::convert(cx, node),\n+ );\n+ let specifiers = convert_vec(\n+ unsafe {\n+ hermes::parser::hermes_get_ExportNamedDeclaration_specifiers(node)\n+ },\n+ |node| ExportSpecifier::convert(cx, node),\n+ );\n+ let source = convert_option(\n+ unsafe { hermes::parser::hermes_get_ExportNamedDeclaration_source(node) },\n+ |node| _Literal::convert(cx, node),\n+ );\n+ Self {\n+ declaration,\n+ specifiers,\n+ source,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ExportSpecifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let exported = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ExportSpecifier_exported(node) },\n+ );\n+ Self {\n+ exported,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ExportDefaultDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let declaration = Declaration::convert(\n+ cx,\n+ unsafe {\n+ hermes::parser::hermes_get_ExportDefaultDeclaration_declaration(node)\n+ },\n+ );\n+ Self {\n+ declaration,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ExportAllDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let source = _Literal::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ExportAllDeclaration_source(node) },\n+ );\n+ let exported = Default::default();\n+ Self {\n+ source,\n+ exported,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXIdentifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let name = convert_string(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXIdentifier_name(node) },\n+ );\n+ let binding = Default::default();\n+ Self {\n+ name,\n+ binding,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXNamespacedName {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let namespace = JSXIdentifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXNamespacedName_namespace(node) },\n+ );\n+ let name = JSXIdentifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXNamespacedName_name(node) },\n+ );\n+ Self {\n+ namespace,\n+ name,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXMemberExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let object = JSXMemberExpressionOrIdentifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXMemberExpression_object(node) },\n+ );\n+ let property = JSXIdentifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXMemberExpression_property(node) },\n+ );\n+ Self {\n+ object,\n+ property,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXEmptyExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXExpressionContainer {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let expression = JSXExpressionOrEmpty::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXExpressionContainer_expression(node) },\n+ );\n+ Self {\n+ expression,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXSpreadChild {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let expression = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXSpreadChild_expression(node) },\n+ );\n+ Self {\n+ expression,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXOpeningElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let name = JSXElementName::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXOpeningElement_name(node) },\n+ );\n+ let attributes = convert_vec(\n+ unsafe { hermes::parser::hermes_get_JSXOpeningElement_attributes(node) },\n+ |node| JSXAttributeOrSpread::convert(cx, node),\n+ );\n+ let self_closing = unsafe {\n+ hermes::parser::hermes_get_JSXOpeningElement_selfClosing(node)\n+ };\n+ Self {\n+ name,\n+ attributes,\n+ self_closing,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXClosingElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let name = JSXElementName::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXClosingElement_name(node) },\n+ );\n+ Self {\n+ name,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXAttribute {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let name = JSXIdentifierOrNamespacedName::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXAttribute_name(node) },\n+ );\n+ let value = convert_option(\n+ unsafe { hermes::parser::hermes_get_JSXAttribute_value(node) },\n+ |node| JSXAttributeValue::convert(cx, node),\n+ );\n+ Self {\n+ name,\n+ value,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXSpreadAttribute {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXSpreadAttribute_argument(node) },\n+ );\n+ Self {\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXText {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let value = convert_string_value(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXText_value(node) },\n+ );\n+ let raw = convert_string(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXText_raw(node) },\n+ );\n+ Self {\n+ value,\n+ raw,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let opening_element = JSXOpeningElement::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXElement_openingElement(node) },\n+ );\n+ let children = convert_vec(\n+ unsafe { hermes::parser::hermes_get_JSXElement_children(node) },\n+ |node| JSXChildItem::convert(cx, node),\n+ );\n+ let closing_element = convert_option(\n+ unsafe { hermes::parser::hermes_get_JSXElement_closingElement(node) },\n+ |node| JSXClosingElement::convert(cx, node),\n+ );\n+ Self {\n+ opening_element,\n+ children,\n+ closing_element,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXFragment {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let opening_fragment = JSXOpeningFragment::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXFragment_openingFragment(node) },\n+ );\n+ let children = convert_vec(\n+ unsafe { hermes::parser::hermes_get_JSXFragment_children(node) },\n+ |node| JSXChildItem::convert(cx, node),\n+ );\n+ let closing_fragment = JSXClosingFragment::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_JSXFragment_closingFragment(node) },\n+ );\n+ Self {\n+ opening_fragment,\n+ children,\n+ closing_fragment,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXOpeningFragment {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for JSXClosingFragment {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ Self {\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ArrayPattern {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let elements = convert_vec_of_option(\n+ unsafe { hermes::parser::hermes_get_ArrayPattern_elements(node) },\n+ |node| Pattern::convert(cx, node),\n+ );\n+ Self {\n+ elements,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ObjectPattern {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let properties = convert_vec(\n+ unsafe { hermes::parser::hermes_get_ObjectPattern_properties(node) },\n+ |node| AssignmentPropertyOrRestElement::convert(cx, node),\n+ );\n+ Self {\n+ properties,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for RestElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = Pattern::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_RestElement_argument(node) },\n+ );\n+ Self {\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for AssignmentPattern {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let left = Pattern::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_AssignmentPattern_left(node) },\n+ );\n+ let right = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_AssignmentPattern_right(node) },\n+ );\n+ Self {\n+ left,\n+ right,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for TemplateLiteral {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let quasis = convert_vec(\n+ unsafe { hermes::parser::hermes_get_TemplateLiteral_quasis(node) },\n+ |node| TemplateElement::convert(cx, node),\n+ );\n+ let expressions = convert_vec(\n+ unsafe { hermes::parser::hermes_get_TemplateLiteral_expressions(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ Self {\n+ quasis,\n+ expressions,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for TaggedTemplateExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let tag = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_TaggedTemplateExpression_tag(node) },\n+ );\n+ let quasi = TemplateLiteral::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_TaggedTemplateExpression_quasi(node) },\n+ );\n+ Self {\n+ tag,\n+ quasi,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for MetaProperty {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let meta = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MetaProperty_meta(node) },\n+ );\n+ let property = Identifier::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_MetaProperty_property(node) },\n+ );\n+ Self {\n+ meta,\n+ property,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for AwaitExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let argument = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_AwaitExpression_argument(node) },\n+ );\n+ Self {\n+ argument,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for OptionalMemberExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let object = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_OptionalMemberExpression_object(node) },\n+ );\n+ let property = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_OptionalMemberExpression_property(node) },\n+ );\n+ let is_computed = unsafe {\n+ hermes::parser::hermes_get_OptionalMemberExpression_computed(node)\n+ };\n+ let is_optional = unsafe {\n+ hermes::parser::hermes_get_OptionalMemberExpression_optional(node)\n+ };\n+ Self {\n+ object,\n+ property,\n+ is_computed,\n+ is_optional,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for OptionalCallExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let callee = ExpressionOrSuper::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_OptionalCallExpression_callee(node) },\n+ );\n+ let arguments = convert_vec(\n+ unsafe { hermes::parser::hermes_get_OptionalCallExpression_arguments(node) },\n+ |node| ExpressionOrSpread::convert(cx, node),\n+ );\n+ let is_optional = unsafe {\n+ hermes::parser::hermes_get_OptionalCallExpression_optional(node)\n+ };\n+ Self {\n+ callee,\n+ arguments,\n+ is_optional,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ImportExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let source = Expression::convert(\n+ cx,\n+ unsafe { hermes::parser::hermes_get_ImportExpression_source(node) },\n+ );\n+ Self {\n+ source,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for Statement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::BlockStatement => {\n+ let node = BlockStatement::convert(cx, node);\n+ Statement::BlockStatement(Box::new(node))\n+ }\n+ NodeKind::BreakStatement => {\n+ let node = BreakStatement::convert(cx, node);\n+ Statement::BreakStatement(Box::new(node))\n+ }\n+ NodeKind::ClassDeclaration => {\n+ let node = ClassDeclaration::convert(cx, node);\n+ Statement::ClassDeclaration(Box::new(node))\n+ }\n+ NodeKind::ContinueStatement => {\n+ let node = ContinueStatement::convert(cx, node);\n+ Statement::ContinueStatement(Box::new(node))\n+ }\n+ NodeKind::DebuggerStatement => {\n+ let node = DebuggerStatement::convert(cx, node);\n+ Statement::DebuggerStatement(Box::new(node))\n+ }\n+ NodeKind::DoWhileStatement => {\n+ let node = DoWhileStatement::convert(cx, node);\n+ Statement::DoWhileStatement(Box::new(node))\n+ }\n+ NodeKind::EmptyStatement => {\n+ let node = EmptyStatement::convert(cx, node);\n+ Statement::EmptyStatement(Box::new(node))\n+ }\n+ NodeKind::ExpressionStatement => {\n+ let node = ExpressionStatement::convert(cx, node);\n+ Statement::ExpressionStatement(Box::new(node))\n+ }\n+ NodeKind::ForInStatement => {\n+ let node = ForInStatement::convert(cx, node);\n+ Statement::ForInStatement(Box::new(node))\n+ }\n+ NodeKind::ForOfStatement => {\n+ let node = ForOfStatement::convert(cx, node);\n+ Statement::ForOfStatement(Box::new(node))\n+ }\n+ NodeKind::ForStatement => {\n+ let node = ForStatement::convert(cx, node);\n+ Statement::ForStatement(Box::new(node))\n+ }\n+ NodeKind::FunctionDeclaration => {\n+ let node = FunctionDeclaration::convert(cx, node);\n+ Statement::FunctionDeclaration(Box::new(node))\n+ }\n+ NodeKind::IfStatement => {\n+ let node = IfStatement::convert(cx, node);\n+ Statement::IfStatement(Box::new(node))\n+ }\n+ NodeKind::LabeledStatement => {\n+ let node = LabeledStatement::convert(cx, node);\n+ Statement::LabeledStatement(Box::new(node))\n+ }\n+ NodeKind::ReturnStatement => {\n+ let node = ReturnStatement::convert(cx, node);\n+ Statement::ReturnStatement(Box::new(node))\n+ }\n+ NodeKind::SwitchStatement => {\n+ let node = SwitchStatement::convert(cx, node);\n+ Statement::SwitchStatement(Box::new(node))\n+ }\n+ NodeKind::ThrowStatement => {\n+ let node = ThrowStatement::convert(cx, node);\n+ Statement::ThrowStatement(Box::new(node))\n+ }\n+ NodeKind::TryStatement => {\n+ let node = TryStatement::convert(cx, node);\n+ Statement::TryStatement(Box::new(node))\n+ }\n+ NodeKind::VariableDeclaration => {\n+ let node = VariableDeclaration::convert(cx, node);\n+ Statement::VariableDeclaration(Box::new(node))\n+ }\n+ NodeKind::WhileStatement => {\n+ let node = WhileStatement::convert(cx, node);\n+ Statement::WhileStatement(Box::new(node))\n+ }\n+ NodeKind::WithStatement => {\n+ let node = WithStatement::convert(cx, node);\n+ Statement::WithStatement(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for Expression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ Expression::ArrayExpression(Box::new(node))\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ Expression::ArrowFunctionExpression(Box::new(node))\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ Expression::AssignmentExpression(Box::new(node))\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ Expression::AwaitExpression(Box::new(node))\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ Expression::BinaryExpression(Box::new(node))\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ Expression::BooleanLiteral(Box::new(node))\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ Expression::CallExpression(Box::new(node))\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ Expression::ClassExpression(Box::new(node))\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ Expression::ConditionalExpression(Box::new(node))\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ Expression::FunctionExpression(Box::new(node))\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ Expression::Identifier(Box::new(node))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ Expression::ImportExpression(Box::new(node))\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ Expression::JSXElement(Box::new(node))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ Expression::LogicalExpression(Box::new(node))\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ Expression::MemberExpression(Box::new(node))\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ Expression::MetaProperty(Box::new(node))\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ Expression::NewExpression(Box::new(node))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ Expression::NullLiteral(Box::new(node))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ Expression::NumericLiteral(Box::new(node))\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ Expression::ObjectExpression(Box::new(node))\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ Expression::OptionalCallExpression(Box::new(node))\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ Expression::OptionalMemberExpression(Box::new(node))\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ Expression::SequenceExpression(Box::new(node))\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ Expression::StringLiteral(Box::new(node))\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ Expression::TaggedTemplateExpression(Box::new(node))\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ Expression::TemplateLiteral(Box::new(node))\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ Expression::ThisExpression(Box::new(node))\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ Expression::UnaryExpression(Box::new(node))\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ Expression::UpdateExpression(Box::new(node))\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ Expression::YieldExpression(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for _Literal {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ _Literal::BooleanLiteral(Box::new(node))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ _Literal::NullLiteral(Box::new(node))\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ _Literal::StringLiteral(Box::new(node))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ _Literal::NumericLiteral(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for Declaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ClassDeclaration => {\n+ let node = ClassDeclaration::convert(cx, node);\n+ Declaration::ClassDeclaration(Box::new(node))\n+ }\n+ NodeKind::FunctionDeclaration => {\n+ let node = FunctionDeclaration::convert(cx, node);\n+ Declaration::FunctionDeclaration(Box::new(node))\n+ }\n+ NodeKind::VariableDeclaration => {\n+ let node = VariableDeclaration::convert(cx, node);\n+ Declaration::VariableDeclaration(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ImportDeclarationSpecifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ImportSpecifier => {\n+ let node = ImportSpecifier::convert(cx, node);\n+ ImportDeclarationSpecifier::ImportSpecifier(Box::new(node))\n+ }\n+ NodeKind::ImportDefaultSpecifier => {\n+ let node = ImportDefaultSpecifier::convert(cx, node);\n+ ImportDeclarationSpecifier::ImportDefaultSpecifier(Box::new(node))\n+ }\n+ NodeKind::ImportNamespaceSpecifier => {\n+ let node = ImportNamespaceSpecifier::convert(cx, node);\n+ ImportDeclarationSpecifier::ImportNamespaceSpecifier(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ModuleItem {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ImportDeclaration => {\n+ let node = ImportDeclaration::convert(cx, node);\n+ ModuleItem::ImportOrExportDeclaration(\n+ ImportOrExportDeclaration::ImportDeclaration(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ExportNamedDeclaration => {\n+ let node = ExportNamedDeclaration::convert(cx, node);\n+ ModuleItem::ImportOrExportDeclaration(\n+ ImportOrExportDeclaration::ExportNamedDeclaration(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ExportDefaultDeclaration => {\n+ let node = ExportDefaultDeclaration::convert(cx, node);\n+ ModuleItem::ImportOrExportDeclaration(\n+ ImportOrExportDeclaration::ExportDefaultDeclaration(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ExportAllDeclaration => {\n+ let node = ExportAllDeclaration::convert(cx, node);\n+ ModuleItem::ImportOrExportDeclaration(\n+ ImportOrExportDeclaration::ExportAllDeclaration(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BlockStatement => {\n+ let node = BlockStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::BlockStatement(Box::new(node)))\n+ }\n+ NodeKind::BreakStatement => {\n+ let node = BreakStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::BreakStatement(Box::new(node)))\n+ }\n+ NodeKind::ClassDeclaration => {\n+ let node = ClassDeclaration::convert(cx, node);\n+ ModuleItem::Statement(Statement::ClassDeclaration(Box::new(node)))\n+ }\n+ NodeKind::ContinueStatement => {\n+ let node = ContinueStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ContinueStatement(Box::new(node)))\n+ }\n+ NodeKind::DebuggerStatement => {\n+ let node = DebuggerStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::DebuggerStatement(Box::new(node)))\n+ }\n+ NodeKind::DoWhileStatement => {\n+ let node = DoWhileStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::DoWhileStatement(Box::new(node)))\n+ }\n+ NodeKind::EmptyStatement => {\n+ let node = EmptyStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::EmptyStatement(Box::new(node)))\n+ }\n+ NodeKind::ExpressionStatement => {\n+ let node = ExpressionStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ExpressionStatement(Box::new(node)))\n+ }\n+ NodeKind::ForInStatement => {\n+ let node = ForInStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ForInStatement(Box::new(node)))\n+ }\n+ NodeKind::ForOfStatement => {\n+ let node = ForOfStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ForOfStatement(Box::new(node)))\n+ }\n+ NodeKind::ForStatement => {\n+ let node = ForStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ForStatement(Box::new(node)))\n+ }\n+ NodeKind::FunctionDeclaration => {\n+ let node = FunctionDeclaration::convert(cx, node);\n+ ModuleItem::Statement(Statement::FunctionDeclaration(Box::new(node)))\n+ }\n+ NodeKind::IfStatement => {\n+ let node = IfStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::IfStatement(Box::new(node)))\n+ }\n+ NodeKind::LabeledStatement => {\n+ let node = LabeledStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::LabeledStatement(Box::new(node)))\n+ }\n+ NodeKind::ReturnStatement => {\n+ let node = ReturnStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ReturnStatement(Box::new(node)))\n+ }\n+ NodeKind::SwitchStatement => {\n+ let node = SwitchStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::SwitchStatement(Box::new(node)))\n+ }\n+ NodeKind::ThrowStatement => {\n+ let node = ThrowStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::ThrowStatement(Box::new(node)))\n+ }\n+ NodeKind::TryStatement => {\n+ let node = TryStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::TryStatement(Box::new(node)))\n+ }\n+ NodeKind::VariableDeclaration => {\n+ let node = VariableDeclaration::convert(cx, node);\n+ ModuleItem::Statement(Statement::VariableDeclaration(Box::new(node)))\n+ }\n+ NodeKind::WhileStatement => {\n+ let node = WhileStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::WhileStatement(Box::new(node)))\n+ }\n+ NodeKind::WithStatement => {\n+ let node = WithStatement::convert(cx, node);\n+ ModuleItem::Statement(Statement::WithStatement(Box::new(node)))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ImportOrExportDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ImportDeclaration => {\n+ let node = ImportDeclaration::convert(cx, node);\n+ ImportOrExportDeclaration::ImportDeclaration(Box::new(node))\n+ }\n+ NodeKind::ExportNamedDeclaration => {\n+ let node = ExportNamedDeclaration::convert(cx, node);\n+ ImportOrExportDeclaration::ExportNamedDeclaration(Box::new(node))\n+ }\n+ NodeKind::ExportDefaultDeclaration => {\n+ let node = ExportDefaultDeclaration::convert(cx, node);\n+ ImportOrExportDeclaration::ExportDefaultDeclaration(Box::new(node))\n+ }\n+ NodeKind::ExportAllDeclaration => {\n+ let node = ExportAllDeclaration::convert(cx, node);\n+ ImportOrExportDeclaration::ExportAllDeclaration(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ExpressionOrSuper {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::ArrayExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::ArrowFunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::AssignmentExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::AwaitExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::BinaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::BooleanLiteral(Box::new(node)))\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::CallExpression(Box::new(node)))\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::ClassExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::ConditionalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::FunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::ImportExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::JSXElement(Box::new(node)))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::LogicalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::MemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::MetaProperty(Box::new(node)))\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::NewExpression(Box::new(node)))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::NullLiteral(Box::new(node)))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::NumericLiteral(Box::new(node)))\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::ObjectExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::OptionalCallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::OptionalMemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::SequenceExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::StringLiteral(Box::new(node)))\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::TaggedTemplateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::TemplateLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(Expression::ThisExpression(Box::new(node)))\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::UnaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::UpdateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ ExpressionOrSuper::Expression(\n+ Expression::YieldExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::Super => {\n+ let node = Super::convert(cx, node);\n+ ExpressionOrSuper::Super(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ExpressionOrSpread {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ArrayExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ArrowFunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::AssignmentExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::AwaitExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::BinaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::BooleanLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::CallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ClassExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ConditionalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::FunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ ExpressionOrSpread::Expression(Expression::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ImportExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ ExpressionOrSpread::Expression(Expression::JSXElement(Box::new(node)))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::LogicalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::MemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ ExpressionOrSpread::Expression(Expression::MetaProperty(Box::new(node)))\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(Expression::NewExpression(Box::new(node)))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ ExpressionOrSpread::Expression(Expression::NullLiteral(Box::new(node)))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::NumericLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ObjectExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::OptionalCallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::OptionalMemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::SequenceExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ ExpressionOrSpread::Expression(Expression::StringLiteral(Box::new(node)))\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::TaggedTemplateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::TemplateLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::ThisExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::UnaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::UpdateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ ExpressionOrSpread::Expression(\n+ Expression::YieldExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::SpreadElement => {\n+ let node = SpreadElement::convert(cx, node);\n+ ExpressionOrSpread::SpreadElement(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for FunctionBody {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::BlockStatement => {\n+ let node = BlockStatement::convert(cx, node);\n+ FunctionBody::BlockStatement(Box::new(node))\n+ }\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::ArrayExpression(Box::new(node)))\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ FunctionBody::Expression(\n+ Expression::ArrowFunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ FunctionBody::Expression(\n+ Expression::AssignmentExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::AwaitExpression(Box::new(node)))\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::BinaryExpression(Box::new(node)))\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ FunctionBody::Expression(Expression::BooleanLiteral(Box::new(node)))\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::CallExpression(Box::new(node)))\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::ClassExpression(Box::new(node)))\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ FunctionBody::Expression(\n+ Expression::ConditionalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::FunctionExpression(Box::new(node)))\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ FunctionBody::Expression(Expression::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::ImportExpression(Box::new(node)))\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ FunctionBody::Expression(Expression::JSXElement(Box::new(node)))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::LogicalExpression(Box::new(node)))\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::MemberExpression(Box::new(node)))\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ FunctionBody::Expression(Expression::MetaProperty(Box::new(node)))\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::NewExpression(Box::new(node)))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ FunctionBody::Expression(Expression::NullLiteral(Box::new(node)))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ FunctionBody::Expression(Expression::NumericLiteral(Box::new(node)))\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::ObjectExpression(Box::new(node)))\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ FunctionBody::Expression(\n+ Expression::OptionalCallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ FunctionBody::Expression(\n+ Expression::OptionalMemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::SequenceExpression(Box::new(node)))\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ FunctionBody::Expression(Expression::StringLiteral(Box::new(node)))\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ FunctionBody::Expression(\n+ Expression::TaggedTemplateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ FunctionBody::Expression(Expression::TemplateLiteral(Box::new(node)))\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::ThisExpression(Box::new(node)))\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::UnaryExpression(Box::new(node)))\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::UpdateExpression(Box::new(node)))\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ FunctionBody::Expression(Expression::YieldExpression(Box::new(node)))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for Pattern {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ Pattern::Identifier(Box::new(node))\n+ }\n+ NodeKind::ArrayPattern => {\n+ let node = ArrayPattern::convert(cx, node);\n+ Pattern::ArrayPattern(Box::new(node))\n+ }\n+ NodeKind::ObjectPattern => {\n+ let node = ObjectPattern::convert(cx, node);\n+ Pattern::ObjectPattern(Box::new(node))\n+ }\n+ NodeKind::RestElement => {\n+ let node = RestElement::convert(cx, node);\n+ Pattern::RestElement(Box::new(node))\n+ }\n+ NodeKind::AssignmentPattern => {\n+ let node = AssignmentPattern::convert(cx, node);\n+ Pattern::AssignmentPattern(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ForInit {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ArrayExpression(Box::new(node)))\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ArrowFunctionExpression(Box::new(node)))\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ ForInit::Expression(Expression::AssignmentExpression(Box::new(node)))\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ ForInit::Expression(Expression::AwaitExpression(Box::new(node)))\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ ForInit::Expression(Expression::BinaryExpression(Box::new(node)))\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ ForInit::Expression(Expression::BooleanLiteral(Box::new(node)))\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ ForInit::Expression(Expression::CallExpression(Box::new(node)))\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ClassExpression(Box::new(node)))\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ConditionalExpression(Box::new(node)))\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ ForInit::Expression(Expression::FunctionExpression(Box::new(node)))\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ ForInit::Expression(Expression::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ImportExpression(Box::new(node)))\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ ForInit::Expression(Expression::JSXElement(Box::new(node)))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ ForInit::Expression(Expression::LogicalExpression(Box::new(node)))\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ ForInit::Expression(Expression::MemberExpression(Box::new(node)))\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ ForInit::Expression(Expression::MetaProperty(Box::new(node)))\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ ForInit::Expression(Expression::NewExpression(Box::new(node)))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ ForInit::Expression(Expression::NullLiteral(Box::new(node)))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ ForInit::Expression(Expression::NumericLiteral(Box::new(node)))\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ObjectExpression(Box::new(node)))\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ ForInit::Expression(Expression::OptionalCallExpression(Box::new(node)))\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ ForInit::Expression(Expression::OptionalMemberExpression(Box::new(node)))\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ ForInit::Expression(Expression::SequenceExpression(Box::new(node)))\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ ForInit::Expression(Expression::StringLiteral(Box::new(node)))\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ ForInit::Expression(Expression::TaggedTemplateExpression(Box::new(node)))\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ ForInit::Expression(Expression::TemplateLiteral(Box::new(node)))\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ ForInit::Expression(Expression::ThisExpression(Box::new(node)))\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ ForInit::Expression(Expression::UnaryExpression(Box::new(node)))\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ ForInit::Expression(Expression::UpdateExpression(Box::new(node)))\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ ForInit::Expression(Expression::YieldExpression(Box::new(node)))\n+ }\n+ NodeKind::VariableDeclaration => {\n+ let node = VariableDeclaration::convert(cx, node);\n+ ForInit::VariableDeclaration(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ForInInit {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ ForInInit::Pattern(Pattern::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ArrayPattern => {\n+ let node = ArrayPattern::convert(cx, node);\n+ ForInInit::Pattern(Pattern::ArrayPattern(Box::new(node)))\n+ }\n+ NodeKind::ObjectPattern => {\n+ let node = ObjectPattern::convert(cx, node);\n+ ForInInit::Pattern(Pattern::ObjectPattern(Box::new(node)))\n+ }\n+ NodeKind::RestElement => {\n+ let node = RestElement::convert(cx, node);\n+ ForInInit::Pattern(Pattern::RestElement(Box::new(node)))\n+ }\n+ NodeKind::AssignmentPattern => {\n+ let node = AssignmentPattern::convert(cx, node);\n+ ForInInit::Pattern(Pattern::AssignmentPattern(Box::new(node)))\n+ }\n+ NodeKind::VariableDeclaration => {\n+ let node = VariableDeclaration::convert(cx, node);\n+ ForInInit::VariableDeclaration(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for PropertyOrSpreadElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::Property => {\n+ let node = Property::convert(cx, node);\n+ PropertyOrSpreadElement::Property(Box::new(node))\n+ }\n+ NodeKind::SpreadElement => {\n+ let node = SpreadElement::convert(cx, node);\n+ PropertyOrSpreadElement::SpreadElement(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for AssignmentPropertyOrRestElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::Property => {\n+ let node = AssignmentProperty::convert(cx, node);\n+ AssignmentPropertyOrRestElement::AssignmentProperty(Box::new(node))\n+ }\n+ NodeKind::RestElement => {\n+ let node = RestElement::convert(cx, node);\n+ AssignmentPropertyOrRestElement::RestElement(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for PropertyKey {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ PropertyKey::Identifier(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for AssignmentTarget {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::ArrayExpression(Box::new(node)))\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::ArrowFunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::AssignmentExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::AwaitExpression(Box::new(node)))\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::BinaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::BooleanLiteral(Box::new(node)))\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::CallExpression(Box::new(node)))\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::ClassExpression(Box::new(node)))\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::ConditionalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::FunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::ImportExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::JSXElement(Box::new(node)))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::LogicalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::MemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::MetaProperty(Box::new(node)))\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::NewExpression(Box::new(node)))\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::NullLiteral(Box::new(node)))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::NumericLiteral(Box::new(node)))\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::ObjectExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::OptionalCallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::OptionalMemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::SequenceExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::StringLiteral(Box::new(node)))\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::TaggedTemplateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::TemplateLiteral(Box::new(node)))\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::ThisExpression(Box::new(node)))\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::UnaryExpression(Box::new(node)))\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ AssignmentTarget::Expression(\n+ Expression::UpdateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ AssignmentTarget::Expression(Expression::YieldExpression(Box::new(node)))\n+ }\n+ NodeKind::ArrayPattern => {\n+ let node = ArrayPattern::convert(cx, node);\n+ AssignmentTarget::Pattern(Pattern::ArrayPattern(Box::new(node)))\n+ }\n+ NodeKind::ObjectPattern => {\n+ let node = ObjectPattern::convert(cx, node);\n+ AssignmentTarget::Pattern(Pattern::ObjectPattern(Box::new(node)))\n+ }\n+ NodeKind::RestElement => {\n+ let node = RestElement::convert(cx, node);\n+ AssignmentTarget::Pattern(Pattern::RestElement(Box::new(node)))\n+ }\n+ NodeKind::AssignmentPattern => {\n+ let node = AssignmentPattern::convert(cx, node);\n+ AssignmentTarget::Pattern(Pattern::AssignmentPattern(Box::new(node)))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for ChainElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ ChainElement::CallExpression(Box::new(node))\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ ChainElement::MemberExpression(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXMemberExpressionOrIdentifier {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::JSXMemberExpression => {\n+ let node = JSXMemberExpression::convert(cx, node);\n+ JSXMemberExpressionOrIdentifier::JSXMemberExpression(Box::new(node))\n+ }\n+ NodeKind::JSXIdentifier => {\n+ let node = JSXIdentifier::convert(cx, node);\n+ JSXMemberExpressionOrIdentifier::JSXIdentifier(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXExpressionOrEmpty {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::ArrayExpression => {\n+ let node = ArrayExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ArrayExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ArrowFunctionExpression => {\n+ let node = ArrowFunctionExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ArrowFunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AssignmentExpression => {\n+ let node = AssignmentExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::AssignmentExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::AwaitExpression => {\n+ let node = AwaitExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::AwaitExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BinaryExpression => {\n+ let node = BinaryExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::BinaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::BooleanLiteral => {\n+ let node = BooleanLiteral::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::BooleanLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::CallExpression => {\n+ let node = CallExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::CallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ClassExpression => {\n+ let node = ClassExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ClassExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ConditionalExpression => {\n+ let node = ConditionalExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ConditionalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::FunctionExpression => {\n+ let node = FunctionExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::FunctionExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::Identifier => {\n+ let node = Identifier::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(Expression::Identifier(Box::new(node)))\n+ }\n+ NodeKind::ImportExpression => {\n+ let node = ImportExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ImportExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(Expression::JSXElement(Box::new(node)))\n+ }\n+ NodeKind::LogicalExpression => {\n+ let node = LogicalExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::LogicalExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MemberExpression => {\n+ let node = MemberExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::MemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::MetaProperty => {\n+ let node = MetaProperty::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::MetaProperty(Box::new(node)),\n+ )\n+ }\n+ NodeKind::NewExpression => {\n+ let node = NewExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::NewExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::NullLiteral => {\n+ let node = NullLiteral::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(Expression::NullLiteral(Box::new(node)))\n+ }\n+ NodeKind::NumericLiteral => {\n+ let node = NumericLiteral::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::NumericLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ObjectExpression => {\n+ let node = ObjectExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ObjectExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalCallExpression => {\n+ let node = OptionalCallExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::OptionalCallExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::OptionalMemberExpression => {\n+ let node = OptionalMemberExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::OptionalMemberExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::SequenceExpression => {\n+ let node = SequenceExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::SequenceExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::StringLiteral => {\n+ let node = StringLiteral::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::StringLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::TaggedTemplateExpression => {\n+ let node = TaggedTemplateExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::TaggedTemplateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::TemplateLiteral => {\n+ let node = TemplateLiteral::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::TemplateLiteral(Box::new(node)),\n+ )\n+ }\n+ NodeKind::ThisExpression => {\n+ let node = ThisExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::ThisExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::UnaryExpression => {\n+ let node = UnaryExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::UnaryExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::UpdateExpression => {\n+ let node = UpdateExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::UpdateExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::YieldExpression => {\n+ let node = YieldExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::Expression(\n+ Expression::YieldExpression(Box::new(node)),\n+ )\n+ }\n+ NodeKind::JSXEmptyExpression => {\n+ let node = JSXEmptyExpression::convert(cx, node);\n+ JSXExpressionOrEmpty::JSXEmptyExpression(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXAttributeOrSpread {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::JSXAttribute => {\n+ let node = JSXAttribute::convert(cx, node);\n+ JSXAttributeOrSpread::JSXAttribute(Box::new(node))\n+ }\n+ NodeKind::JSXSpreadAttribute => {\n+ let node = JSXSpreadAttribute::convert(cx, node);\n+ JSXAttributeOrSpread::JSXSpreadAttribute(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXAttributeValue {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::JSXExpressionContainer => {\n+ let node = JSXExpressionContainer::convert(cx, node);\n+ JSXAttributeValue::JSXExpressionContainer(Box::new(node))\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ JSXAttributeValue::JSXElement(Box::new(node))\n+ }\n+ NodeKind::JSXFragment => {\n+ let node = JSXFragment::convert(cx, node);\n+ JSXAttributeValue::JSXFragment(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXElementName {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::JSXIdentifier => {\n+ let node = JSXIdentifier::convert(cx, node);\n+ JSXElementName::JSXIdentifier(Box::new(node))\n+ }\n+ NodeKind::JSXMemberExpression => {\n+ let node = JSXMemberExpression::convert(cx, node);\n+ JSXElementName::JSXMemberExpression(Box::new(node))\n+ }\n+ NodeKind::JSXNamespacedName => {\n+ let node = JSXNamespacedName::convert(cx, node);\n+ JSXElementName::JSXNamespacedName(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXIdentifierOrNamespacedName {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::JSXIdentifier => {\n+ let node = JSXIdentifier::convert(cx, node);\n+ JSXIdentifierOrNamespacedName::JSXIdentifier(Box::new(node))\n+ }\n+ NodeKind::JSXNamespacedName => {\n+ let node = JSXNamespacedName::convert(cx, node);\n+ JSXIdentifierOrNamespacedName::JSXNamespacedName(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermes for JSXChildItem {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::JSXText => {\n+ let node = JSXText::convert(cx, node);\n+ JSXChildItem::JSXText(Box::new(node))\n+ }\n+ NodeKind::JSXExpressionContainer => {\n+ let node = JSXExpressionContainer::convert(cx, node);\n+ JSXChildItem::JSXExpressionContainer(Box::new(node))\n+ }\n+ NodeKind::JSXSpreadChild => {\n+ let node = JSXSpreadChild::convert(cx, node);\n+ JSXChildItem::JSXSpreadChild(Box::new(node))\n+ }\n+ NodeKind::JSXElement => {\n+ let node = JSXElement::convert(cx, node);\n+ JSXChildItem::JSXElement(Box::new(node))\n+ }\n+ NodeKind::JSXFragment => {\n+ let node = JSXFragment::convert(cx, node);\n+ JSXChildItem::JSXFragment(Box::new(node))\n+ }\n+ _ => panic!(\"Unexpected node\"),\n+ }\n+ }\n+}\n+impl FromHermesLabel for VariableDeclarationKind {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for PropertyKind {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for UnaryOperator {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for UpdateOperator {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for BinaryOperator {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for AssignmentOperator {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for LogicalOperator {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for SourceType {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\n+impl FromHermesLabel for MethodKind {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self {\n+ let utf_str = utf8_with_surrogates_to_string(label.as_slice()).unwrap();\n+ utf_str.parse().unwrap()\n+ }\n+}\ndiff --git a\/compiler\/forget\/crates\/forget_hermes_parser\/src\/generated_extension.rs b\/compiler\/forget\/crates\/forget_hermes_parser\/src\/generated_extension.rs\nnew file mode 100644\nindex 0000000000..6b30d456d5\n--- \/dev\/null\n+++ b\/compiler\/forget\/crates\/forget_hermes_parser\/src\/generated_extension.rs\n@@ -0,0 +1,288 @@\n+use forget_estree::{\n+ ArrowFunctionExpression, AssignmentProperty, Class, ClassBody, ClassDeclaration,\n+ ClassExpression, Expression, ExpressionOrSpread, Function, FunctionBody, FunctionDeclaration,\n+ FunctionExpression, Identifier, Number, Pattern, SourceRange, TemplateElement,\n+ TemplateElementValue,\n+};\n+use hermes::parser::{\n+ hermes_get_ArrowFunctionExpression_async, hermes_get_ArrowFunctionExpression_body,\n+ hermes_get_ArrowFunctionExpression_expression, hermes_get_ArrowFunctionExpression_id,\n+ hermes_get_ArrowFunctionExpression_params, hermes_get_ClassDeclaration_body,\n+ hermes_get_ClassDeclaration_id, hermes_get_ClassDeclaration_superClass,\n+ hermes_get_ClassExpression_body, hermes_get_ClassExpression_id,\n+ hermes_get_ClassExpression_superClass, hermes_get_FunctionDeclaration_async,\n+ hermes_get_FunctionDeclaration_body, hermes_get_FunctionDeclaration_generator,\n+ hermes_get_FunctionDeclaration_id, hermes_get_FunctionDeclaration_params,\n+ hermes_get_FunctionExpression_async, hermes_get_FunctionExpression_body,\n+ hermes_get_FunctionExpression_generator, hermes_get_FunctionExpression_id,\n+ hermes_get_FunctionExpression_params, hermes_get_Property_key, hermes_get_Property_kind,\n+ hermes_get_Property_method, hermes_get_Property_value, NodeKind, NodeLabel, NodeLabelOpt,\n+ NodeListRef, NodePtr, NodePtrOpt, NodeString, NodeStringOpt, SMRange,\n+};\n+use hermes::utf::utf8_with_surrogates_to_string;\n+\n+pub struct Context;\n+\n+impl Context {\n+ pub fn new() -> Self {\n+ Self\n+ }\n+}\n+\n+pub trait FromHermes {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self;\n+}\n+pub trait FromHermesLabel {\n+ fn convert(cx: &mut Context, label: NodeLabel) -> Self;\n+}\n+\n+pub fn convert_option(node: NodePtrOpt, mut f: F) -> Option\n+where\n+ F: FnMut(NodePtr) -> T,\n+{\n+ node.as_node_ptr().map(|node| f(node))\n+}\n+\n+pub fn convert_vec(node: NodeListRef, mut f: F) -> Vec\n+where\n+ F: FnMut(NodePtr) -> T,\n+{\n+ node.iter().map(|node| f(NodePtr::new(node))).collect()\n+}\n+\n+pub fn convert_vec_of_option(node: NodeListRef, mut f: F) -> Vec>\n+where\n+ F: FnMut(NodePtr) -> T,\n+{\n+ node.iter()\n+ .map(|node| {\n+ let node = NodePtr::new(node);\n+ let node_ref = node.as_ref();\n+ match node_ref.kind {\n+ NodeKind::Empty => None,\n+ _ => Some(f(node)),\n+ }\n+ })\n+ .collect()\n+}\n+\n+pub fn convert_range(node: NodePtr) -> SourceRange {\n+ let _range = node.as_ref().source_range;\n+ todo!()\n+}\n+\n+#[allow(dead_code)]\n+pub fn convert_smrange(_range: SMRange) -> SourceRange {\n+ todo!()\n+}\n+\n+pub fn convert_string(_cx: &mut Context, label: NodeLabel) -> String {\n+ utf8_with_surrogates_to_string(label.as_slice()).unwrap()\n+}\n+\n+#[allow(dead_code)]\n+pub fn convert_option_string(cx: &mut Context, label: NodeLabelOpt) -> Option {\n+ label.as_node_label().map(|label| convert_string(cx, label))\n+}\n+\n+pub fn convert_string_value(_cx: &mut Context, label: NodeString) -> String {\n+ utf8_with_surrogates_to_string(label.as_slice()).unwrap()\n+}\n+\n+pub fn convert_option_string_value(_cx: &mut Context, label: NodeStringOpt) -> Option {\n+ label\n+ .as_node_string()\n+ .map(|label| utf8_with_surrogates_to_string(label.as_slice()).unwrap())\n+}\n+\n+pub fn convert_number(value: f64) -> Number {\n+ value.into()\n+}\n+\n+pub fn convert_array_expression_elements(\n+ cx: &mut Context,\n+ node: NodeListRef,\n+) -> Vec> {\n+ convert_vec_of_option(node, |node| ExpressionOrSpread::convert(cx, node))\n+}\n+\n+impl FromHermes for TemplateElement {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let range = convert_range(node);\n+ let tail = unsafe { hermes::parser::hermes_get_TemplateElement_tail(node) };\n+ let value = TemplateElementValue {\n+ cooked: convert_option_string_value(cx, unsafe {\n+ hermes::parser::hermes_get_TemplateElement_cooked(node)\n+ }),\n+ raw: convert_string(cx, unsafe {\n+ hermes::parser::hermes_get_TemplateElement_raw(node)\n+ }),\n+ };\n+ Self {\n+ tail,\n+ value,\n+ loc: None,\n+ range: Some(range),\n+ }\n+ }\n+}\n+\n+impl FromHermes for AssignmentProperty {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let key = FromHermes::convert(cx, unsafe { hermes_get_Property_key(node) });\n+ let value = FromHermes::convert(cx, unsafe { hermes_get_Property_value(node) });\n+ let kind = FromHermesLabel::convert(cx, unsafe { hermes_get_Property_kind(node) });\n+ let method = unsafe { hermes_get_Property_method(node) };\n+ let loc = None;\n+ let range = convert_range(node);\n+ AssignmentProperty {\n+ key,\n+ value,\n+ kind,\n+ method,\n+ loc,\n+ range: Some(range),\n+ }\n+ }\n+}\n+\n+impl FromHermes for FunctionDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let id = convert_option(unsafe { hermes_get_FunctionDeclaration_id(node) }, |node| {\n+ Identifier::convert(cx, node)\n+ });\n+ let params = convert_vec(\n+ unsafe { hermes_get_FunctionDeclaration_params(node) },\n+ |node| Pattern::convert(cx, node),\n+ );\n+ let body = FunctionBody::convert(cx, unsafe { hermes_get_FunctionDeclaration_body(node) });\n+ let is_generator = unsafe { hermes_get_FunctionDeclaration_generator(node) };\n+ let is_async = unsafe { hermes_get_FunctionDeclaration_async(node) };\n+ let loc = None;\n+ let range = convert_range(node);\n+ FunctionDeclaration {\n+ function: Function {\n+ id,\n+ params,\n+ body: Some(body),\n+ is_generator,\n+ is_async,\n+ loc: loc.clone(),\n+ range: Some(range),\n+ },\n+ loc,\n+ range: Some(range),\n+ }\n+ }\n+}\n+\n+impl FromHermes for FunctionExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let id = convert_option(unsafe { hermes_get_FunctionExpression_id(node) }, |node| {\n+ Identifier::convert(cx, node)\n+ });\n+ let params = convert_vec(\n+ unsafe { hermes_get_FunctionExpression_params(node) },\n+ |node| Pattern::convert(cx, node),\n+ );\n+ let body = FunctionBody::convert(cx, unsafe { hermes_get_FunctionExpression_body(node) });\n+ let is_generator = unsafe { hermes_get_FunctionExpression_generator(node) };\n+ let is_async = unsafe { hermes_get_FunctionExpression_async(node) };\n+ let loc = None;\n+ let range = convert_range(node);\n+ FunctionExpression {\n+ function: Function {\n+ id,\n+ params,\n+ body: Some(body),\n+ is_generator,\n+ is_async,\n+ loc: loc.clone(),\n+ range: Some(range),\n+ },\n+ loc,\n+ range: Some(range),\n+ }\n+ }\n+}\n+\n+impl FromHermes for ArrowFunctionExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let id = convert_option(\n+ unsafe { hermes_get_ArrowFunctionExpression_id(node) },\n+ |node| Identifier::convert(cx, node),\n+ );\n+ let params = convert_vec(\n+ unsafe { hermes_get_ArrowFunctionExpression_params(node) },\n+ |node| Pattern::convert(cx, node),\n+ );\n+ let body =\n+ FunctionBody::convert(cx, unsafe { hermes_get_ArrowFunctionExpression_body(node) });\n+ let is_generator = unsafe { hermes_get_FunctionExpression_generator(node) };\n+ let is_async = unsafe { hermes_get_ArrowFunctionExpression_async(node) };\n+ let is_expression = unsafe { hermes_get_ArrowFunctionExpression_expression(node) };\n+ let loc = None;\n+ let range = convert_range(node);\n+ ArrowFunctionExpression {\n+ function: Function {\n+ id,\n+ params,\n+ body: Some(body),\n+ is_generator,\n+ is_async,\n+ loc: loc.clone(),\n+ range: Some(range),\n+ },\n+ is_expression,\n+ loc,\n+ range: Some(range),\n+ }\n+ }\n+}\n+\n+impl FromHermes for ClassDeclaration {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let id = convert_option(unsafe { hermes_get_ClassDeclaration_id(node) }, |node| {\n+ Identifier::convert(cx, node)\n+ });\n+ let super_class = convert_option(\n+ unsafe { hermes_get_ClassDeclaration_superClass(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ let body = ClassBody::convert(cx, unsafe { hermes_get_ClassDeclaration_body(node) });\n+ let loc = None;\n+ let range = convert_range(node);\n+ ClassDeclaration {\n+ class: Class {\n+ id,\n+ super_class,\n+ body,\n+ },\n+ loc,\n+ range: Some(range),\n+ }\n+ }\n+}\n+impl FromHermes for ClassExpression {\n+ fn convert(cx: &mut Context, node: NodePtr) -> Self {\n+ let id = convert_option(unsafe { hermes_get_ClassExpression_id(node) }, |node| {\n+ Identifier::convert(cx, node)\n+ });\n+ let super_class = convert_option(\n+ unsafe { hermes_get_ClassExpression_superClass(node) },\n+ |node| Expression::convert(cx, node),\n+ );\n+ let body = ClassBody::convert(cx, unsafe { hermes_get_ClassExpression_body(node) });\n+ let loc = None;\n+ let range = convert_range(node);\n+ ClassExpression {\n+ class: Class {\n+ id,\n+ super_class,\n+ body,\n+ },\n+ loc,\n+ range: Some(range),\n+ }\n+ }\n+}\ndiff --git a\/compiler\/forget\/crates\/forget_hermes_parser\/src\/lib.rs b\/compiler\/forget\/crates\/forget_hermes_parser\/src\/lib.rs\nindex 650699e53c..e43d5143a0 100644\n--- a\/compiler\/forget\/crates\/forget_hermes_parser\/src\/lib.rs\n+++ b\/compiler\/forget\/crates\/forget_hermes_parser\/src\/lib.rs\n@@ -1,14 +1,14 @@\n+mod generated;\n+mod generated_extension;\n+\n use forget_diagnostics::Diagnostic;\n-use hermes::parser::{\n- hermes_get_BlockStatement_body, hermes_get_DeclareFunction_id,\n- hermes_get_FunctionDeclaration_async, hermes_get_FunctionDeclaration_body,\n- hermes_get_FunctionDeclaration_generator, hermes_get_Program_body, HermesParser, NodeKind,\n- NodePtr, ParserDialect, ParserFlags,\n-};\n-use juno_support::source_manager::SourceRange;\n+use forget_estree::Program;\n+use generated_extension::{Context, FromHermes};\n+use hermes::parser::{HermesParser, ParserDialect, ParserFlags};\n+use hermes::utf::utf8_with_surrogates_to_string;\n use juno_support::NullTerminatedBuf;\n \n-pub fn parse(source: &str, file: &str) -> Result> {\n+pub fn parse(source: &str, _file: &str) -> Result> {\n let buf = NullTerminatedBuf::from_str_check(source);\n let result = HermesParser::parse(\n ParserFlags {\n@@ -19,98 +19,17 @@ pub fn parse(source: &str, file: &str) -> Result forget_estree::Program {\n- let node_ref = node.as_ref();\n- let body = hermes_get_Program_body(node);\n- let body: Vec<_> = body\n- .iter()\n- .map(|node| convert_module_item(NodePtr::new(node)))\n- .collect();\n- forget_estree::Program {\n- body,\n- source_type: forget_estree::SourceType::Module,\n- loc: None,\n- range: None,\n+ return Err(error_messages\n+ .into_iter()\n+ .map(|diag| {\n+ let message = utf8_with_surrogates_to_string(diag.message.as_slice()).unwrap();\n+ Diagnostic::invalid_syntax(message, None)\n+ })\n+ .collect());\n }\n-}\n \n-unsafe fn convert_module_item(node: NodePtr) -> forget_estree::ModuleItem {\n- let node_ref = node.as_ref();\n- match node_ref.kind {\n- NodeKind::FunctionDeclaration => {\n- forget_estree::ModuleItem::Statement(forget_estree::Statement::FunctionDeclaration(\n- Box::new(convert_function_declaration(node)),\n- ))\n- }\n- _ => todo!(),\n- }\n-}\n-\n-unsafe fn convert_function_declaration(node: NodePtr) -> forget_estree::FunctionDeclaration {\n- let id = None; \/\/hermes_get_DeclareFunction_id(node);\n- let params = Vec::new();\n- let body = forget_estree::FunctionBody::BlockStatement(Box::new(convert_block_statement(\n- hermes_get_FunctionDeclaration_body(node),\n- )));\n- let is_generator = hermes_get_FunctionDeclaration_generator(node);\n- let is_async = hermes_get_FunctionDeclaration_async(node);\n- forget_estree::FunctionDeclaration {\n- function: forget_estree::Function {\n- id,\n- params,\n- body: Some(body),\n- is_generator,\n- is_async,\n- loc: None,\n- range: None,\n- },\n- loc: None,\n- range: None,\n- }\n-}\n-\n-unsafe fn convert_block_statement(node: NodePtr) -> forget_estree::BlockStatement {\n- let body = hermes_get_BlockStatement_body(node);\n- let body: Vec<_> = body\n- .iter()\n- .map(|node| convert_statement(NodePtr::new(node)))\n- .collect();\n- forget_estree::BlockStatement {\n- body,\n- loc: None,\n- range: None,\n- }\n-}\n-\n-unsafe fn convert_statement(node: NodePtr) -> forget_estree::Statement {\n- let node_ref = node.as_ref();\n- match node_ref.kind {\n- NodeKind::ReturnStatement => {\n- forget_estree::Statement::ReturnStatement(Box::new(forget_estree::ReturnStatement {\n- argument: None,\n- loc: None,\n- range: None,\n- }))\n- }\n- _ => todo!(),\n- }\n-}\n-\n-#[cfg(test)]\n-mod tests {\n- use super::*;\n-\n- #[test]\n- fn fixtures() {\n- let res = parse(\"function foo() { return }\", \"hello.js\");\n- println!(\"{:#?}\", res);\n- }\n+ Ok(FromHermes::convert(&mut cx, result.root().unwrap()))\n }\n","commit":{"revision":"e353f3702eeae21a18f508886f1983d8c19cdb58","shortRevision":"e353f3702e","authorName":"Joe Savona","authorEmail":"joesavona@fb.com","authoredAt":"2023-08-01T13:55:13-07:00","subject":"[rust][wip] Codegen conversion from HermesParser (C++)"},"body":"","parents":["ce2725eda5858a642f21390d0fe5ae3d40ba4060"],"files":[{"status":"M","path":"compiler\/forget\/Cargo.lock"},{"status":"M","path":"compiler\/forget\/crates\/forget_build_hir\/src\/context.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree\/src\/generated.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree\/src\/lib.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree\/src\/snapshots\/forget_estree__tests__fixtures@simple.json.snap"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree\/src\/visit.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree_codegen\/src\/codegen.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree_codegen\/src\/ecmascript.json"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree_codegen\/src\/lib.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_estree_swc\/src\/lib.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_hermes_parser\/Cargo.toml"},{"status":"A","path":"compiler\/forget\/crates\/forget_hermes_parser\/build.rs"},{"status":"A","path":"compiler\/forget\/crates\/forget_hermes_parser\/src\/generated.rs"},{"status":"A","path":"compiler\/forget\/crates\/forget_hermes_parser\/src\/generated_extension.rs"},{"status":"M","path":"compiler\/forget\/crates\/forget_hermes_parser\/src\/lib.rs"}]}

dillon1000/react

Files changed