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