diff --git a/crates/oxc_ast/src/ast/ts.rs b/crates/oxc_ast/src/ast/ts.rs index 28c24478e7d23..dc5eae3cdb41f 100644 --- a/crates/oxc_ast/src/ast/ts.rs +++ b/crates/oxc_ast/src/ast/ts.rs @@ -1144,10 +1144,20 @@ pub struct TSImportType<'a> { pub struct TSImportAttributes<'a> { #[serde(flatten)] pub span: Span, - pub attributes_keyword: IdentifierName<'a>, // `with` or `assert` + pub attributes_keyword: TSImportAttributesKeyword, pub elements: Vec<'a, TSImportAttribute<'a>>, } +#[ast] +#[derive(Debug, Hash)] +#[generate_derive(CloneIn)] +#[cfg_attr(feature = "serialize", derive(Serialize, Tsify))] +#[serde(untagged)] +pub enum TSImportAttributesKeyword { + With = 0, + Assert = 1, +} + #[ast(visit)] #[derive(Debug, Hash)] #[generate_derive(CloneIn, GetSpan, GetSpanMut)] diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs index 9d4160d4f971c..81a8222a8ecbb 100644 --- a/crates/oxc_ast/src/generated/assert_layouts.rs +++ b/crates/oxc_ast/src/generated/assert_layouts.rs @@ -1128,20 +1128,23 @@ const _: () = { assert!(size_of::() == 16usize); assert!(align_of::() == 8usize); - assert!(size_of::() == 120usize); + assert!(size_of::() == 104usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSImportType, span) == 0usize); assert!(offset_of!(TSImportType, is_type_of) == 8usize); assert!(offset_of!(TSImportType, parameter) == 16usize); assert!(offset_of!(TSImportType, qualifier) == 32usize); assert!(offset_of!(TSImportType, attributes) == 48usize); - assert!(offset_of!(TSImportType, type_parameters) == 112usize); + assert!(offset_of!(TSImportType, type_parameters) == 96usize); - assert!(size_of::() == 64usize); + assert!(size_of::() == 48usize); assert!(align_of::() == 8usize); assert!(offset_of!(TSImportAttributes, span) == 0usize); assert!(offset_of!(TSImportAttributes, attributes_keyword) == 8usize); - assert!(offset_of!(TSImportAttributes, elements) == 32usize); + assert!(offset_of!(TSImportAttributes, elements) == 16usize); + + assert!(size_of::() == 1usize); + assert!(align_of::() == 1usize); assert!(size_of::() == 56usize); assert!(align_of::() == 8usize); @@ -2529,20 +2532,23 @@ const _: () = { assert!(size_of::() == 8usize); assert!(align_of::() == 4usize); - assert!(size_of::() == 72usize); + assert!(size_of::() == 60usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSImportType, span) == 0usize); assert!(offset_of!(TSImportType, is_type_of) == 8usize); assert!(offset_of!(TSImportType, parameter) == 12usize); assert!(offset_of!(TSImportType, qualifier) == 20usize); assert!(offset_of!(TSImportType, attributes) == 28usize); - assert!(offset_of!(TSImportType, type_parameters) == 68usize); + assert!(offset_of!(TSImportType, type_parameters) == 56usize); - assert!(size_of::() == 40usize); + assert!(size_of::() == 28usize); assert!(align_of::() == 4usize); assert!(offset_of!(TSImportAttributes, span) == 0usize); assert!(offset_of!(TSImportAttributes, attributes_keyword) == 8usize); - assert!(offset_of!(TSImportAttributes, elements) == 24usize); + assert!(offset_of!(TSImportAttributes, elements) == 12usize); + + assert!(size_of::() == 1usize); + assert!(align_of::() == 1usize); assert!(size_of::() == 36usize); assert!(align_of::() == 4usize); diff --git a/crates/oxc_ast/src/generated/ast_builder.rs b/crates/oxc_ast/src/generated/ast_builder.rs index e4fa92b39b0a5..d8864da77f121 100644 --- a/crates/oxc_ast/src/generated/ast_builder.rs +++ b/crates/oxc_ast/src/generated/ast_builder.rs @@ -11768,7 +11768,7 @@ impl<'a> AstBuilder<'a> { pub fn ts_import_attributes( self, span: Span, - attributes_keyword: IdentifierName<'a>, + attributes_keyword: TSImportAttributesKeyword, elements: Vec<'a, TSImportAttribute<'a>>, ) -> TSImportAttributes<'a> { TSImportAttributes { span, attributes_keyword, elements } @@ -11786,7 +11786,7 @@ impl<'a> AstBuilder<'a> { pub fn alloc_ts_import_attributes( self, span: Span, - attributes_keyword: IdentifierName<'a>, + attributes_keyword: TSImportAttributesKeyword, elements: Vec<'a, TSImportAttribute<'a>>, ) -> Box<'a, TSImportAttributes<'a>> { Box::new_in(self.ts_import_attributes(span, attributes_keyword, elements), self.allocator) diff --git a/crates/oxc_ast/src/generated/derive_clone_in.rs b/crates/oxc_ast/src/generated/derive_clone_in.rs index 8b330c63d7181..1d448ad9d3ba6 100644 --- a/crates/oxc_ast/src/generated/derive_clone_in.rs +++ b/crates/oxc_ast/src/generated/derive_clone_in.rs @@ -3171,6 +3171,16 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSImportAttributes<'old_all } } +impl<'alloc> CloneIn<'alloc> for TSImportAttributesKeyword { + type Cloned = TSImportAttributesKeyword; + fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned { + match self { + Self::With => TSImportAttributesKeyword::With, + Self::Assert => TSImportAttributesKeyword::Assert, + } + } +} + impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSImportAttribute<'old_alloc> { type Cloned = TSImportAttribute<'new_alloc>; fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned { diff --git a/crates/oxc_ast/src/generated/visit.rs b/crates/oxc_ast/src/generated/visit.rs index 5b0123fc812f5..dc802ecc7c537 100644 --- a/crates/oxc_ast/src/generated/visit.rs +++ b/crates/oxc_ast/src/generated/visit.rs @@ -2154,7 +2154,6 @@ pub mod walk { it: &TSImportAttributes<'a>, ) { // NOTE: AstKind doesn't exists! - visitor.visit_identifier_name(&it.attributes_keyword); visitor.visit_ts_import_attribute_list(&it.elements); } diff --git a/crates/oxc_ast/src/generated/visit_mut.rs b/crates/oxc_ast/src/generated/visit_mut.rs index d37a81659efa2..af7907313f647 100644 --- a/crates/oxc_ast/src/generated/visit_mut.rs +++ b/crates/oxc_ast/src/generated/visit_mut.rs @@ -2227,7 +2227,6 @@ pub mod walk_mut { it: &mut TSImportAttributes<'a>, ) { // NOTE: AstType doesn't exists! - visitor.visit_identifier_name(&mut it.attributes_keyword); visitor.visit_ts_import_attribute_list(&mut it.elements); } diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs index 7d5aee94b09d6..f6f8186949211 100644 --- a/crates/oxc_codegen/src/gen.rs +++ b/crates/oxc_codegen/src/gen.rs @@ -3339,6 +3339,15 @@ impl<'a> Gen for TSImportAttributes<'a> { } } +impl Gen for TSImportAttributesKeyword { + fn gen(&self, p: &mut Codegen, _: Context) { + match self { + Self::With => p.print_str("with"), + Self::Assert => p.print_str("assert"), + } + } +} + impl<'a> Gen for TSImportAttribute<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { self.name.gen(p, ctx); diff --git a/crates/oxc_parser/src/ts/types.rs b/crates/oxc_parser/src/ts/types.rs index b40a4eba8fa62..6db3b319d21d7 100644 --- a/crates/oxc_parser/src/ts/types.rs +++ b/crates/oxc_parser/src/ts/types.rs @@ -1003,8 +1003,14 @@ impl<'a> ParserImpl<'a> { let span = self.start_span(); self.expect(Kind::LCurly)?; let attributes_keyword = match self.cur_kind() { - Kind::Assert if !self.cur_token().is_on_new_line => self.parse_identifier_name()?, - Kind::With => self.parse_identifier_name()?, + Kind::Assert if !self.cur_token().is_on_new_line => { + self.bump_any(); + TSImportAttributesKeyword::Assert + } + Kind::With => { + self.bump_any(); + TSImportAttributesKeyword::With + } _ => { return Err(self.unexpected()); } diff --git a/crates/oxc_traverse/src/generated/ancestor.rs b/crates/oxc_traverse/src/generated/ancestor.rs index 58c552af840fb..e13e35cc0f8f5 100644 --- a/crates/oxc_traverse/src/generated/ancestor.rs +++ b/crates/oxc_traverse/src/generated/ancestor.rs @@ -288,39 +288,38 @@ pub(crate) enum AncestorType { TSImportTypeQualifier = 260, TSImportTypeAttributes = 261, TSImportTypeTypeParameters = 262, - TSImportAttributesAttributesKeyword = 263, - TSImportAttributesElements = 264, - TSImportAttributeName = 265, - TSImportAttributeValue = 266, - TSFunctionTypeThisParam = 267, - TSFunctionTypeParams = 268, - TSFunctionTypeReturnType = 269, - TSFunctionTypeTypeParameters = 270, - TSConstructorTypeParams = 271, - TSConstructorTypeReturnType = 272, - TSConstructorTypeTypeParameters = 273, - TSMappedTypeTypeParameter = 274, - TSMappedTypeNameType = 275, - TSMappedTypeTypeAnnotation = 276, - TSTemplateLiteralTypeQuasis = 277, - TSTemplateLiteralTypeTypes = 278, - TSAsExpressionExpression = 279, - TSAsExpressionTypeAnnotation = 280, - TSSatisfiesExpressionExpression = 281, - TSSatisfiesExpressionTypeAnnotation = 282, - TSTypeAssertionExpression = 283, - TSTypeAssertionTypeAnnotation = 284, - TSImportEqualsDeclarationId = 285, - TSImportEqualsDeclarationModuleReference = 286, - TSExternalModuleReferenceExpression = 287, - TSNonNullExpressionExpression = 288, - DecoratorExpression = 289, - TSExportAssignmentExpression = 290, - TSNamespaceExportDeclarationId = 291, - TSInstantiationExpressionExpression = 292, - TSInstantiationExpressionTypeParameters = 293, - JSDocNullableTypeTypeAnnotation = 294, - JSDocNonNullableTypeTypeAnnotation = 295, + TSImportAttributesElements = 263, + TSImportAttributeName = 264, + TSImportAttributeValue = 265, + TSFunctionTypeThisParam = 266, + TSFunctionTypeParams = 267, + TSFunctionTypeReturnType = 268, + TSFunctionTypeTypeParameters = 269, + TSConstructorTypeParams = 270, + TSConstructorTypeReturnType = 271, + TSConstructorTypeTypeParameters = 272, + TSMappedTypeTypeParameter = 273, + TSMappedTypeNameType = 274, + TSMappedTypeTypeAnnotation = 275, + TSTemplateLiteralTypeQuasis = 276, + TSTemplateLiteralTypeTypes = 277, + TSAsExpressionExpression = 278, + TSAsExpressionTypeAnnotation = 279, + TSSatisfiesExpressionExpression = 280, + TSSatisfiesExpressionTypeAnnotation = 281, + TSTypeAssertionExpression = 282, + TSTypeAssertionTypeAnnotation = 283, + TSImportEqualsDeclarationId = 284, + TSImportEqualsDeclarationModuleReference = 285, + TSExternalModuleReferenceExpression = 286, + TSNonNullExpressionExpression = 287, + DecoratorExpression = 288, + TSExportAssignmentExpression = 289, + TSNamespaceExportDeclarationId = 290, + TSInstantiationExpressionExpression = 291, + TSInstantiationExpressionTypeParameters = 292, + JSDocNullableTypeTypeAnnotation = 293, + JSDocNonNullableTypeTypeAnnotation = 294, } /// Ancestor type used in AST traversal. @@ -827,8 +826,6 @@ pub enum Ancestor<'a, 't> { AncestorType::TSImportTypeAttributes as u16, TSImportTypeTypeParameters(TSImportTypeWithoutTypeParameters<'a, 't>) = AncestorType::TSImportTypeTypeParameters as u16, - TSImportAttributesAttributesKeyword(TSImportAttributesWithoutAttributesKeyword<'a, 't>) = - AncestorType::TSImportAttributesAttributesKeyword as u16, TSImportAttributesElements(TSImportAttributesWithoutElements<'a, 't>) = AncestorType::TSImportAttributesElements as u16, TSImportAttributeName(TSImportAttributeWithoutName<'a, 't>) = @@ -1749,10 +1746,7 @@ impl<'a, 't> Ancestor<'a, 't> { #[inline] pub fn is_ts_import_attributes(self) -> bool { - matches!( - self, - Self::TSImportAttributesAttributesKeyword(_) | Self::TSImportAttributesElements(_) - ) + matches!(self, Self::TSImportAttributesElements(_)) } #[inline] @@ -12090,28 +12084,6 @@ pub(crate) const OFFSET_TS_IMPORT_ATTRIBUTES_ATTRIBUTES_KEYWORD: usize = pub(crate) const OFFSET_TS_IMPORT_ATTRIBUTES_ELEMENTS: usize = offset_of!(TSImportAttributes, elements); -#[repr(transparent)] -#[derive(Clone, Copy, Debug)] -pub struct TSImportAttributesWithoutAttributesKeyword<'a, 't>( - pub(crate) *const TSImportAttributes<'a>, - pub(crate) PhantomData<&'t ()>, -); - -impl<'a, 't> TSImportAttributesWithoutAttributesKeyword<'a, 't> { - #[inline] - pub fn span(self) -> &'t Span { - unsafe { &*((self.0 as *const u8).add(OFFSET_TS_IMPORT_ATTRIBUTES_SPAN) as *const Span) } - } - - #[inline] - pub fn elements(self) -> &'t Vec<'a, TSImportAttribute<'a>> { - unsafe { - &*((self.0 as *const u8).add(OFFSET_TS_IMPORT_ATTRIBUTES_ELEMENTS) - as *const Vec<'a, TSImportAttribute<'a>>) - } - } -} - #[repr(transparent)] #[derive(Clone, Copy, Debug)] pub struct TSImportAttributesWithoutElements<'a, 't>( @@ -12126,10 +12098,10 @@ impl<'a, 't> TSImportAttributesWithoutElements<'a, 't> { } #[inline] - pub fn attributes_keyword(self) -> &'t IdentifierName<'a> { + pub fn attributes_keyword(self) -> &'t TSImportAttributesKeyword { unsafe { &*((self.0 as *const u8).add(OFFSET_TS_IMPORT_ATTRIBUTES_ATTRIBUTES_KEYWORD) - as *const IdentifierName<'a>) + as *const TSImportAttributesKeyword) } } } diff --git a/crates/oxc_traverse/src/generated/walk.rs b/crates/oxc_traverse/src/generated/walk.rs index 98c4f13c25487..85f71059754d0 100644 --- a/crates/oxc_traverse/src/generated/walk.rs +++ b/crates/oxc_traverse/src/generated/walk.rs @@ -5157,16 +5157,9 @@ pub(crate) unsafe fn walk_ts_import_attributes<'a, Tr: Traverse<'a>>( ctx: &mut TraverseCtx<'a>, ) { traverser.enter_ts_import_attributes(&mut *node, ctx); - let pop_token = ctx.push_stack(Ancestor::TSImportAttributesAttributesKeyword( - ancestor::TSImportAttributesWithoutAttributesKeyword(node, PhantomData), + let pop_token = ctx.push_stack(Ancestor::TSImportAttributesElements( + ancestor::TSImportAttributesWithoutElements(node, PhantomData), )); - walk_identifier_name( - traverser, - (node as *mut u8).add(ancestor::OFFSET_TS_IMPORT_ATTRIBUTES_ATTRIBUTES_KEYWORD) - as *mut IdentifierName, - ctx, - ); - ctx.retag_stack(AncestorType::TSImportAttributesElements); for item in (*((node as *mut u8).add(ancestor::OFFSET_TS_IMPORT_ATTRIBUTES_ELEMENTS) as *mut Vec)) .iter_mut()