diff --git a/crates/oxc_parser/src/js/binding.rs b/crates/oxc_parser/src/js/binding.rs index 450097676c92d..6a43ab99cc652 100644 --- a/crates/oxc_parser/src/js/binding.rs +++ b/crates/oxc_parser/src/js/binding.rs @@ -124,7 +124,7 @@ impl<'a> ParserImpl<'a> { .context(Context::In, Context::empty(), |p| p.parse_initializer(init_span, pattern))?; let span = self.end_span(span); - Ok(BindingRestElement { span, argument }) + Ok(self.ast.binding_rest_element(span, argument)) } /// `BindingProperty`[Yield, Await] : diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs index befdd336db942..8ef922fc8c957 100644 --- a/crates/oxc_parser/src/js/expression.rs +++ b/crates/oxc_parser/src/js/expression.rs @@ -1,5 +1,3 @@ -use std::cell::Cell; - use oxc_allocator::Box; use oxc_ast::ast::*; use oxc_diagnostics::Result; @@ -77,7 +75,7 @@ impl<'a> ParserImpl<'a> { } let (span, name) = self.parse_identifier_kind(Kind::Ident); self.check_identifier(span, &name); - Ok(BindingIdentifier { span, name, symbol_id: Cell::default() }) + Ok(self.ast.binding_identifier(span, name)) } pub(crate) fn parse_label_identifier(&mut self) -> Result> { @@ -86,7 +84,7 @@ impl<'a> ParserImpl<'a> { } let (span, name) = self.parse_identifier_kind(Kind::Ident); self.check_identifier(span, &name); - Ok(LabelIdentifier { span, name }) + Ok(self.ast.label_identifier(span, name)) } pub(crate) fn parse_identifier_name(&mut self) -> Result> { @@ -94,13 +92,13 @@ impl<'a> ParserImpl<'a> { return Err(self.unexpected()); } let (span, name) = self.parse_identifier_kind(Kind::Ident); - Ok(IdentifierName { span, name }) + Ok(self.ast.identifier_name(span, name)) } /// Parse keyword kind as identifier pub(crate) fn parse_keyword_identifier(&mut self, kind: Kind) -> IdentifierName<'a> { let (span, name) = self.parse_identifier_kind(kind); - IdentifierName { span, name } + self.ast.identifier_name(span, name) } #[inline] @@ -130,7 +128,7 @@ impl<'a> ParserImpl<'a> { let span = self.start_span(); let name = Atom::from(self.cur_string()); self.bump_any(); - PrivateIdentifier { span: self.end_span(span), name } + self.ast.private_identifier(self.end_span(span), name) } /// Section [Primary Expression](https://tc39.es/ecma262/#sec-primary-expression) @@ -277,13 +275,13 @@ impl<'a> ParserImpl<'a> { _ => return Err(self.unexpected()), }; self.bump_any(); - Ok(BooleanLiteral { span: self.end_span(span), value }) + Ok(self.ast.boolean_literal(self.end_span(span), value)) } pub(crate) fn parse_literal_null(&mut self) -> NullLiteral { let span = self.start_span(); self.bump_any(); // bump `null` - NullLiteral { span: self.end_span(span) } + self.ast.null_literal(self.end_span(span)) } pub(crate) fn parse_literal_number(&mut self) -> Result> { @@ -360,7 +358,7 @@ impl<'a> ParserImpl<'a> { let value = self.cur_string(); let span = self.start_span(); self.bump_any(); - Ok(StringLiteral { span: self.end_span(span), value: value.into() }) + Ok(self.ast.string_literal(self.end_span(span), value)) } /// Section [Array Expression](https://tc39.es/ecma262/#prod-ArrayLiteral) @@ -400,7 +398,7 @@ impl<'a> ParserImpl<'a> { /// , /// Elision , pub(crate) fn parse_elision(&mut self) -> ArrayExpressionElement<'a> { - ArrayExpressionElement::Elision(Elision { span: self.cur_token().span() }) + self.ast.array_expression_element_elision(self.cur_token().span()) } /// Section [Template Literal](https://tc39.es/ecma262/#prod-TemplateLiteral) @@ -907,12 +905,7 @@ impl<'a> ParserImpl<'a> { let left = self.parse_private_identifier(); self.expect(Kind::In)?; let right = self.parse_unary_expression_or_higher(lhs_span)?; - Expression::PrivateInExpression(self.ast.alloc(PrivateInExpression { - span: self.end_span(lhs_span), - left, - operator: BinaryOperator::In, - right, - })) + self.ast.expression_private_in(self.end_span(lhs_span), left, BinaryOperator::In, right) } else { self.parse_unary_expression_or_higher(lhs_span)? }; diff --git a/crates/oxc_parser/src/ts/statement.rs b/crates/oxc_parser/src/ts/statement.rs index e6d7f49a4ccda..36644f25e443f 100644 --- a/crates/oxc_parser/src/ts/statement.rs +++ b/crates/oxc_parser/src/ts/statement.rs @@ -64,7 +64,7 @@ impl<'a> ParserImpl<'a> { self.error(diagnostics::invalid_assignment(span)); } - Ok(TSEnumMember { span, id, initializer }) + Ok(self.ast.ts_enum_member(span, id, initializer)) } fn parse_ts_enum_member_name(&mut self) -> Result> { @@ -475,7 +475,7 @@ impl<'a> ParserImpl<'a> { self.eat_decorators()?; let this = { let (span, name) = self.parse_identifier_kind(Kind::This); - IdentifierName { span, name } + self.ast.identifier_name(span, name) }; let type_annotation = self.parse_ts_type_annotation()?; Ok(self.ast.ts_this_parameter(self.end_span(span), this, type_annotation)) diff --git a/crates/oxc_parser/src/ts/types.rs b/crates/oxc_parser/src/ts/types.rs index 044dfb144b5b5..5e70e26a37e85 100644 --- a/crates/oxc_parser/src/ts/types.rs +++ b/crates/oxc_parser/src/ts/types.rs @@ -762,11 +762,7 @@ impl<'a> ParserImpl<'a> { let mut left = TSTypeName::IdentifierReference(self.ast.alloc(ident)); while self.eat(Kind::Dot) { let right = self.parse_identifier_name()?; - left = TSTypeName::QualifiedName(self.ast.alloc(TSQualifiedName { - span: self.end_span(span), - left, - right, - })); + left = self.ast.ts_type_name_qualified_name(self.end_span(span), left, right); } Ok(left) } @@ -883,24 +879,22 @@ impl<'a> ParserImpl<'a> { return Ok(if dotdotdot { TSTupleElement::TSRestType(self.ast.alloc(TSRestType { span, - type_annotation: TSType::TSNamedTupleMember(self.ast.alloc( - TSNamedTupleMember { - span: self.end_span(member_span), - element_type, - label, - // TODO: A tuple member cannot be both optional and rest. (TS5085) - // See typescript suite - optional, - }, - )), + type_annotation: self.ast.ts_type_named_tuple_member( + self.end_span(member_span), + element_type, + label, + // TODO: A tuple member cannot be both optional and rest. (TS5085) + // See typescript suite + optional, + ), })) } else { - TSTupleElement::TSNamedTupleMember(self.ast.alloc(TSNamedTupleMember { + TSTupleElement::from(self.ast.ts_type_named_tuple_member( span, element_type, label, optional, - })) + )) }); } self.parse_tuple_element_type() @@ -933,10 +927,7 @@ impl<'a> ParserImpl<'a> { let ty = self.parse_ts_type()?; if let TSType::JSDocNullableType(ty) = ty { if ty.span.start == ty.type_annotation.span().start { - Ok(TSTupleElement::TSOptionalType(self.ast.alloc(TSOptionalType { - span: ty.span, - type_annotation: ty.unbox().type_annotation, - }))) + Ok(self.ast.ts_tuple_element_optional_type(ty.span, ty.unbox().type_annotation)) } else { Ok(TSTupleElement::JSDocNullableType(ty)) } @@ -1023,7 +1014,7 @@ impl<'a> ParserImpl<'a> { )?; self.expect(Kind::RCurly)?; self.expect(Kind::RCurly)?; - Ok(TSImportAttributes { span, elements }) + Ok(self.ast.ts_import_attributes(span, elements)) } fn parse_ts_import_attribute(&mut self) -> Result> { @@ -1035,7 +1026,7 @@ impl<'a> ParserImpl<'a> { self.expect(Kind::Colon)?; let value = self.parse_expr()?; - Ok(TSImportAttribute { span: self.end_span(span), name, value }) + Ok(self.ast.ts_import_attribute(self.end_span(span), name, value)) } fn try_parse_constraint_of_infer_type(&mut self) -> Result>> { @@ -1316,11 +1307,7 @@ impl<'a> ParserImpl<'a> { return Err(self.unexpected()); } - Ok(TSIndexSignatureName { - span: self.end_span(span), - name, - type_annotation: type_annotation.unwrap(), - }) + Ok(self.ast.ts_index_signature_name(self.end_span(span), name, type_annotation.unwrap())) } pub(crate) fn parse_class_element_modifiers(