fix: update for Astro changes

Author: Princesseuh

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -1825,13 +1825,13 @@ const _: () = {
     assert!(offset_of!(AstroRoot, body) == 16);
 
     // Padding: 0 bytes
-    assert!(size_of::<AstroFrontmatter>() == 136);
+    assert!(size_of::<AstroFrontmatter>() == 152);
     assert!(align_of::<AstroFrontmatter>() == 8);
     assert!(offset_of!(AstroFrontmatter, span) == 0);
     assert!(offset_of!(AstroFrontmatter, program) == 8);
 
     // Padding: 0 bytes
-    assert!(size_of::<AstroScript>() == 136);
+    assert!(size_of::<AstroScript>() == 152);
     assert!(align_of::<AstroScript>() == 8);
     assert!(offset_of!(AstroScript, span) == 0);
     assert!(offset_of!(AstroScript, program) == 8);
@@ -3667,13 +3667,13 @@ const _: () = if cfg!(target_family = "wasm") || align_of::<u64>() == 8 {
     assert!(offset_of!(AstroRoot, body) == 12);
 
     // Padding: 0 bytes
-    assert!(size_of::<AstroFrontmatter>() == 96);
+    assert!(size_of::<AstroFrontmatter>() == 104);
     assert!(align_of::<AstroFrontmatter>() == 4);
     assert!(offset_of!(AstroFrontmatter, span) == 0);
     assert!(offset_of!(AstroFrontmatter, program) == 8);
 
     // Padding: 0 bytes
-    assert!(size_of::<AstroScript>() == 96);
+    assert!(size_of::<AstroScript>() == 104);
     assert!(align_of::<AstroScript>() == 4);
     assert!(offset_of!(AstroScript, span) == 0);
     assert!(offset_of!(AstroScript, program) == 8);

crates/oxc_ast/src/generated/ast_kind.rs

@@ -630,6 +630,11 @@ impl AstKind<'_> {
             Self::JSDocNullableType(it) => it.node_id(),
             Self::JSDocNonNullableType(it) => it.node_id(),
             Self::JSDocUnknownType(it) => it.node_id(),
+            Self::AstroRoot(_) => NodeId::DUMMY,
+            Self::AstroFrontmatter(_) => NodeId::DUMMY,
+            Self::AstroScript(_) => NodeId::DUMMY,
+            Self::AstroDoctype(_) => NodeId::DUMMY,
+            Self::AstroComment(_) => NodeId::DUMMY,
         }
     }
 
@@ -829,6 +834,11 @@ impl AstKind<'_> {
             Self::JSDocNullableType(it) => it.set_node_id(node_id),
             Self::JSDocNonNullableType(it) => it.set_node_id(node_id),
             Self::JSDocUnknownType(it) => it.set_node_id(node_id),
+            Self::AstroRoot(_) => {}
+            Self::AstroFrontmatter(_) => {}
+            Self::AstroScript(_) => {}
+            Self::AstroDoctype(_) => {}
+            Self::AstroComment(_) => {}
         }
     }
 }

crates/oxc_ast/src/generated/derive_dummy.rs

@@ -2047,7 +2047,7 @@ impl<'a> Dummy<'a> for JSXIdentifier<'a> {
 impl<'a> Dummy<'a> for JSXChild<'a> {
     /// Create a dummy [`JSXChild`].
     ///
-    /// Has cost of making 1 allocation (40 bytes).
+    /// Has cost of making 1 allocation (24 bytes).
     fn dummy(allocator: &'a Allocator) -> Self {
         Self::AstroDoctype(Dummy::dummy(allocator))
     }

crates/oxc_minifier/src/generated/ancestor.rs

@@ -323,6 +323,10 @@ pub(crate) enum AncestorType {
     TSInstantiationExpressionTypeArguments = 299,
     JSDocNullableTypeTypeAnnotation = 300,
     JSDocNonNullableTypeTypeAnnotation = 301,
+    AstroRootFrontmatter = 302,
+    AstroRootBody = 303,
+    AstroFrontmatterProgram = 304,
+    AstroScriptProgram = 305,
 }
 
 /// Ancestor type used in AST traversal.
@@ -907,6 +911,12 @@ pub enum Ancestor<'a, 't> {
         AncestorType::JSDocNullableTypeTypeAnnotation as u16,
     JSDocNonNullableTypeTypeAnnotation(JSDocNonNullableTypeWithoutTypeAnnotation<'a, 't>) =
         AncestorType::JSDocNonNullableTypeTypeAnnotation as u16,
+    AstroRootFrontmatter(AstroRootWithoutFrontmatter<'a, 't>) =
+        AncestorType::AstroRootFrontmatter as u16,
+    AstroRootBody(AstroRootWithoutBody<'a, 't>) = AncestorType::AstroRootBody as u16,
+    AstroFrontmatterProgram(AstroFrontmatterWithoutProgram<'a, 't>) =
+        AncestorType::AstroFrontmatterProgram as u16,
+    AstroScriptProgram(AstroScriptWithoutProgram<'a, 't>) = AncestorType::AstroScriptProgram as u16,
 }
 
 impl<'a, 't> Ancestor<'a, 't> {
@@ -1905,6 +1915,21 @@ impl<'a, 't> Ancestor<'a, 't> {
         matches!(self, Self::JSDocNonNullableTypeTypeAnnotation(_))
     }
 
+    #[inline]
+    pub fn is_astro_root(self) -> bool {
+        matches!(self, Self::AstroRootFrontmatter(_) | Self::AstroRootBody(_))
+    }
+
+    #[inline]
+    pub fn is_astro_frontmatter(self) -> bool {
+        matches!(self, Self::AstroFrontmatterProgram(_))
+    }
+
+    #[inline]
+    pub fn is_astro_script(self) -> bool {
+        matches!(self, Self::AstroScriptProgram(_))
+    }
+
     #[inline]
     pub fn is_parent_of_statement(self) -> bool {
         matches!(
@@ -2123,7 +2148,10 @@ impl<'a, 't> Ancestor<'a, 't> {
 
     #[inline]
     pub fn is_parent_of_jsx_child(self) -> bool {
-        matches!(self, Self::JSXElementChildren(_) | Self::JSXFragmentChildren(_))
+        matches!(
+            self,
+            Self::JSXElementChildren(_) | Self::JSXFragmentChildren(_) | Self::AstroRootBody(_)
+        )
     }
 
     #[inline]
@@ -2559,6 +2587,10 @@ impl<'a, 't> GetAddress for Ancestor<'a, 't> {
             Self::TSInstantiationExpressionTypeArguments(a) => a.address(),
             Self::JSDocNullableTypeTypeAnnotation(a) => a.address(),
             Self::JSDocNonNullableTypeTypeAnnotation(a) => a.address(),
+            Self::AstroRootFrontmatter(a) => a.address(),
+            Self::AstroRootBody(a) => a.address(),
+            Self::AstroFrontmatterProgram(a) => a.address(),
+            Self::AstroScriptProgram(a) => a.address(),
         }
     }
 }
@@ -18569,3 +18601,112 @@ impl<'a, 't> GetAddress for JSDocNonNullableTypeWithoutTypeAnnotation<'a, 't> {
         unsafe { Address::from_ptr(self.0) }
     }
 }
+
+pub(crate) const OFFSET_ASTRO_ROOT_SPAN: usize = offset_of!(AstroRoot, span);
+pub(crate) const OFFSET_ASTRO_ROOT_FRONTMATTER: usize = offset_of!(AstroRoot, frontmatter);
+pub(crate) const OFFSET_ASTRO_ROOT_BODY: usize = offset_of!(AstroRoot, body);
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug)]
+pub struct AstroRootWithoutFrontmatter<'a, 't>(
+    pub(crate) *const AstroRoot<'a>,
+    pub(crate) PhantomData<&'t ()>,
+);
+
+impl<'a, 't> AstroRootWithoutFrontmatter<'a, 't> {
+    #[inline]
+    pub fn span(self) -> &'t Span {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_ASTRO_ROOT_SPAN) as *const Span) }
+    }
+
+    #[inline]
+    pub fn body(self) -> &'t Vec<'a, JSXChild<'a>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_ASTRO_ROOT_BODY) as *const Vec<'a, JSXChild<'a>>)
+        }
+    }
+}
+
+impl<'a, 't> GetAddress for AstroRootWithoutFrontmatter<'a, 't> {
+    #[inline]
+    fn address(&self) -> Address {
+        unsafe { Address::from_ptr(self.0) }
+    }
+}
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug)]
+pub struct AstroRootWithoutBody<'a, 't>(
+    pub(crate) *const AstroRoot<'a>,
+    pub(crate) PhantomData<&'t ()>,
+);
+
+impl<'a, 't> AstroRootWithoutBody<'a, 't> {
+    #[inline]
+    pub fn span(self) -> &'t Span {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_ASTRO_ROOT_SPAN) as *const Span) }
+    }
+
+    #[inline]
+    pub fn frontmatter(self) -> &'t Option<Box<'a, AstroFrontmatter<'a>>> {
+        unsafe {
+            &*((self.0 as *const u8).add(OFFSET_ASTRO_ROOT_FRONTMATTER)
+                as *const Option<Box<'a, AstroFrontmatter<'a>>>)
+        }
+    }
+}
+
+impl<'a, 't> GetAddress for AstroRootWithoutBody<'a, 't> {
+    #[inline]
+    fn address(&self) -> Address {
+        unsafe { Address::from_ptr(self.0) }
+    }
+}
+
+pub(crate) const OFFSET_ASTRO_FRONTMATTER_SPAN: usize = offset_of!(AstroFrontmatter, span);
+pub(crate) const OFFSET_ASTRO_FRONTMATTER_PROGRAM: usize = offset_of!(AstroFrontmatter, program);
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug)]
+pub struct AstroFrontmatterWithoutProgram<'a, 't>(
+    pub(crate) *const AstroFrontmatter<'a>,
+    pub(crate) PhantomData<&'t ()>,
+);
+
+impl<'a, 't> AstroFrontmatterWithoutProgram<'a, 't> {
+    #[inline]
+    pub fn span(self) -> &'t Span {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_ASTRO_FRONTMATTER_SPAN) as *const Span) }
+    }
+}
+
+impl<'a, 't> GetAddress for AstroFrontmatterWithoutProgram<'a, 't> {
+    #[inline]
+    fn address(&self) -> Address {
+        unsafe { Address::from_ptr(self.0) }
+    }
+}
+
+pub(crate) const OFFSET_ASTRO_SCRIPT_SPAN: usize = offset_of!(AstroScript, span);
+pub(crate) const OFFSET_ASTRO_SCRIPT_PROGRAM: usize = offset_of!(AstroScript, program);
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug)]
+pub struct AstroScriptWithoutProgram<'a, 't>(
+    pub(crate) *const AstroScript<'a>,
+    pub(crate) PhantomData<&'t ()>,
+);
+
+impl<'a, 't> AstroScriptWithoutProgram<'a, 't> {
+    #[inline]
+    pub fn span(self) -> &'t Span {
+        unsafe { &*((self.0 as *const u8).add(OFFSET_ASTRO_SCRIPT_SPAN) as *const Span) }
+    }
+}
+
+impl<'a, 't> GetAddress for AstroScriptWithoutProgram<'a, 't> {
+    #[inline]
+    fn address(&self) -> Address {
+        unsafe { Address::from_ptr(self.0) }
+    }
+}

crates/oxc_minifier/src/generated/traverse.rs

@@ -2481,6 +2481,41 @@ pub trait Traverse<'a> {
     fn exit_js_doc_unknown_type(&mut self, node: &mut JSDocUnknownType, ctx: &mut TraverseCtx<'a>) {
     }
 
+    #[inline]
+    fn enter_astro_root(&mut self, node: &mut AstroRoot<'a>, ctx: &mut TraverseCtx<'a>) {}
+    #[inline]
+    fn exit_astro_root(&mut self, node: &mut AstroRoot<'a>, ctx: &mut TraverseCtx<'a>) {}
+
+    #[inline]
+    fn enter_astro_frontmatter(
+        &mut self,
+        node: &mut AstroFrontmatter<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+    }
+    #[inline]
+    fn exit_astro_frontmatter(
+        &mut self,
+        node: &mut AstroFrontmatter<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+    }
+
+    #[inline]
+    fn enter_astro_script(&mut self, node: &mut AstroScript<'a>, ctx: &mut TraverseCtx<'a>) {}
+    #[inline]
+    fn exit_astro_script(&mut self, node: &mut AstroScript<'a>, ctx: &mut TraverseCtx<'a>) {}
+
+    #[inline]
+    fn enter_astro_doctype(&mut self, node: &mut AstroDoctype<'a>, ctx: &mut TraverseCtx<'a>) {}
+    #[inline]
+    fn exit_astro_doctype(&mut self, node: &mut AstroDoctype<'a>, ctx: &mut TraverseCtx<'a>) {}
+
+    #[inline]
+    fn enter_astro_comment(&mut self, node: &mut AstroComment<'a>, ctx: &mut TraverseCtx<'a>) {}
+    #[inline]
+    fn exit_astro_comment(&mut self, node: &mut AstroComment<'a>, ctx: &mut TraverseCtx<'a>) {}
+
     #[inline]
     fn enter_statements(&mut self, node: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {}
     #[inline]

crates/oxc_minifier/src/generated/walk.rs

@@ -3699,6 +3699,9 @@ unsafe fn walk_jsx_child<'a, Tr: Traverse<'a>>(
             walk_jsx_expression_container(traverser, (&mut **node) as *mut _, ctx)
         }
         JSXChild::Spread(node) => walk_jsx_spread_child(traverser, (&mut **node) as *mut _, ctx),
+        JSXChild::AstroScript(node) => walk_astro_script(traverser, (&mut **node) as *mut _, ctx),
+        JSXChild::AstroDoctype(node) => walk_astro_doctype(traverser, (&mut **node) as *mut _, ctx),
+        JSXChild::AstroComment(node) => walk_astro_comment(traverser, (&mut **node) as *mut _, ctx),
     }
     traverser.exit_jsx_child(&mut *node, ctx);
 }
@@ -5728,6 +5731,84 @@ unsafe fn walk_js_doc_unknown_type<'a, Tr: Traverse<'a>>(
     traverser.exit_js_doc_unknown_type(&mut *node, ctx);
 }
 
+unsafe fn walk_astro_root<'a, Tr: Traverse<'a>>(
+    traverser: &mut Tr,
+    node: *mut AstroRoot<'a>,
+    ctx: &mut TraverseCtx<'a>,
+) {
+    traverser.enter_astro_root(&mut *node, ctx);
+    let pop_token = ctx.push_stack(Ancestor::AstroRootFrontmatter(
+        ancestor::AstroRootWithoutFrontmatter(node, PhantomData),
+    ));
+    if let Some(field) = &mut *((node as *mut u8).add(ancestor::OFFSET_ASTRO_ROOT_FRONTMATTER)
+        as *mut Option<Box<AstroFrontmatter>>)
+    {
+        walk_astro_frontmatter(traverser, (&mut **field) as *mut _, ctx);
+    }
+    ctx.retag_stack(AncestorType::AstroRootBody);
+    for item in
+        &mut *((node as *mut u8).add(ancestor::OFFSET_ASTRO_ROOT_BODY) as *mut Vec<JSXChild>)
+    {
+        walk_jsx_child(traverser, item as *mut _, ctx);
+    }
+    ctx.pop_stack(pop_token);
+    traverser.exit_astro_root(&mut *node, ctx);
+}
+
+unsafe fn walk_astro_frontmatter<'a, Tr: Traverse<'a>>(
+    traverser: &mut Tr,
+    node: *mut AstroFrontmatter<'a>,
+    ctx: &mut TraverseCtx<'a>,
+) {
+    traverser.enter_astro_frontmatter(&mut *node, ctx);
+    let pop_token = ctx.push_stack(Ancestor::AstroFrontmatterProgram(
+        ancestor::AstroFrontmatterWithoutProgram(node, PhantomData),
+    ));
+    walk_program(
+        traverser,
+        (node as *mut u8).add(ancestor::OFFSET_ASTRO_FRONTMATTER_PROGRAM) as *mut Program,
+        ctx,
+    );
+    ctx.pop_stack(pop_token);
+    traverser.exit_astro_frontmatter(&mut *node, ctx);
+}
+
+unsafe fn walk_astro_script<'a, Tr: Traverse<'a>>(
+    traverser: &mut Tr,
+    node: *mut AstroScript<'a>,
+    ctx: &mut TraverseCtx<'a>,
+) {
+    traverser.enter_astro_script(&mut *node, ctx);
+    let pop_token = ctx.push_stack(Ancestor::AstroScriptProgram(
+        ancestor::AstroScriptWithoutProgram(node, PhantomData),
+    ));
+    walk_program(
+        traverser,
+        (node as *mut u8).add(ancestor::OFFSET_ASTRO_SCRIPT_PROGRAM) as *mut Program,
+        ctx,
+    );
+    ctx.pop_stack(pop_token);
+    traverser.exit_astro_script(&mut *node, ctx);
+}
+
+unsafe fn walk_astro_doctype<'a, Tr: Traverse<'a>>(
+    traverser: &mut Tr,
+    node: *mut AstroDoctype<'a>,
+    ctx: &mut TraverseCtx<'a>,
+) {
+    traverser.enter_astro_doctype(&mut *node, ctx);
+    traverser.exit_astro_doctype(&mut *node, ctx);
+}
+
+unsafe fn walk_astro_comment<'a, Tr: Traverse<'a>>(
+    traverser: &mut Tr,
+    node: *mut AstroComment<'a>,
+    ctx: &mut TraverseCtx<'a>,
+) {
+    traverser.enter_astro_comment(&mut *node, ctx);
+    traverser.exit_astro_comment(&mut *node, ctx);
+}
+
 unsafe fn walk_statements<'a, Tr: Traverse<'a>>(
     traverser: &mut Tr,
     stmts: *mut Vec<'a, Statement<'a>>,