feat: some sort of Astro support

Author: Princesseuh

crates/oxc_ast/src/ast/astro.rs

@@ -0,0 +1,88 @@
+//! [Astro](https://astro.build) AST Definitions
+//!
+//! Astro files have a frontmatter section (TypeScript) delimited by `---` and
+//! an HTML body that can contain JSX expressions.
+
+// NB: `#[span]`, `#[scope(...)]`,`#[visit(...)]` and `#[generate_derive(...)]` do NOT do anything to the code.
+// They are purely markers for codegen used in `tasks/ast_tools` and `crates/oxc_traverse/scripts`. See docs in those crates.
+// Read [`macro@oxc_ast_macros::ast`] for more information.
+
+use oxc_allocator::{Box, CloneIn, Dummy, TakeIn, UnstableAddress, Vec};
+use oxc_ast_macros::ast;
+use oxc_estree::ESTree;
+use oxc_span::{ContentEq, GetSpan, GetSpanMut, Span};
+
+use super::js::Program;
+use super::jsx::*;
+
+/// Astro Root Node
+///
+/// The root node of an Astro file, containing optional frontmatter and an HTML body.
+///
+/// ## Example
+///
+/// ```astro
+/// ---
+/// const name = "World";
+/// ---
+/// <h1>Hello {name}!</h1>
+/// ```
+#[ast(visit)]
+#[derive(Debug)]
+#[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree, UnstableAddress)]
+pub struct AstroRoot<'a> {
+    /// Node location in source code
+    pub span: Span,
+    /// The frontmatter section between `---` delimiters, containing TypeScript code.
+    /// This is `None` if the file has no frontmatter.
+    pub frontmatter: Option<Box<'a, AstroFrontmatter<'a>>>,
+    /// The HTML body of the Astro file, which can contain JSX expressions.
+    /// Represented as JSX children since it behaves like an implicit fragment.
+    pub body: Vec<'a, JSXChild<'a>>,
+}
+
+/// Astro Frontmatter
+///
+/// The frontmatter section of an Astro file, delimited by `---`.
+/// Contains TypeScript code that runs at build time.
+///
+/// ## Example
+///
+/// ```astro
+/// ---
+/// import Component from './Component.astro';
+/// const items = ["a", "b", "c"];
+/// ---
+/// ```
+#[ast(visit)]
+#[derive(Debug)]
+#[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree, UnstableAddress)]
+pub struct AstroFrontmatter<'a> {
+    /// Node location in source code (includes the `---` delimiters)
+    pub span: Span,
+    /// The parsed TypeScript program from the frontmatter content
+    pub program: Program<'a>,
+}
+
+/// Astro Script Element
+///
+/// A `<script>` element in an Astro file containing TypeScript/JavaScript code.
+/// Unlike regular HTML script tags, Astro scripts are processed at build time.
+///
+/// ## Example
+///
+/// ```astro
+/// <script>
+///   console.log("Hello from Astro!");
+/// </script>
+/// ```
+#[ast(visit)]
+#[derive(Debug)]
+#[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree, UnstableAddress)]
+pub struct AstroScript<'a> {
+    /// Node location in source code (includes the `<script>` tags)
+    pub span: Span,
+
+    /// The parsed TypeScript/JavaScript program from the script content
+    pub program: Program<'a>,
+}

crates/oxc_ast/src/ast/jsx.rs

@@ -9,7 +9,7 @@ use oxc_ast_macros::ast;
 use oxc_estree::ESTree;
 use oxc_span::{Atom, ContentEq, GetSpan, GetSpanMut, Span};
 
-use super::{inherit_variants, js::*, literal::*, ts::*};
+use super::{astro::AstroScript, inherit_variants, js::*, literal::*, ts::*};
 
 // 1.2 JSX Elements
 
@@ -446,6 +446,9 @@ pub enum JSXChild<'a> {
     ExpressionContainer(Box<'a, JSXExpressionContainer<'a>>) = 3,
     /// `<Foo>{...spread}</Foo>`
     Spread(Box<'a, JSXSpreadChild<'a>>) = 4,
+    /// Astro `<script>` element with parsed TypeScript content
+    /// This is only used in Astro files.
+    AstroScript(Box<'a, AstroScript<'a>>) = 5,
 }
 
 /// JSX Spread Child.

crates/oxc_ast/src/ast/mod.rs

@@ -182,13 +182,15 @@ pub use oxc_syntax::{
     },
 };
 
+pub(crate) mod astro;
 pub(crate) mod comment;
 pub(crate) mod js;
 pub(crate) mod jsx;
 pub(crate) mod literal;
 pub(crate) mod macros;
 pub(crate) mod ts;
 
+pub use astro::*;
 pub use comment::*;
 pub use js::*;
 pub use jsx::*;

crates/oxc_ast/src/ast_kind_impl.rs

@@ -604,6 +604,10 @@ impl AstKind<'_> {
             }
             Self::AssignmentTargetPropertyProperty(_) => "AssignmentTargetPropertyProperty".into(),
             Self::TSImportTypeQualifiedName(_) => "TSImportTypeQualifiedName".into(),
+
+            Self::AstroRoot(_) => "AstroRoot".into(),
+            Self::AstroFrontmatter(_) => "AstroFrontmatter".into(),
+            Self::AstroScript(_) => "AstroScript".into(),
         }
     }
 }

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -9,6 +9,25 @@ use crate::ast::*;
 
 #[cfg(target_pointer_width = "64")]
 const _: () = {
+    // Padding: 0 bytes
+    assert!(size_of::<AstroRoot>() == 40);
+    assert!(align_of::<AstroRoot>() == 8);
+    assert!(offset_of!(AstroRoot, span) == 0);
+    assert!(offset_of!(AstroRoot, frontmatter) == 8);
+    assert!(offset_of!(AstroRoot, body) == 16);
+
+    // Padding: 0 bytes
+    assert!(size_of::<AstroFrontmatter>() == 136);
+    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!(align_of::<AstroScript>() == 8);
+    assert!(offset_of!(AstroScript, span) == 0);
+    assert!(offset_of!(AstroScript, program) == 8);
+
     // Padding: 1 bytes
     assert!(size_of::<Program>() == 128);
     assert!(align_of::<Program>() == 8);
@@ -1631,6 +1650,25 @@ const _: () = {
 
 #[cfg(target_pointer_width = "32")]
 const _: () = if cfg!(target_family = "wasm") || align_of::<u64>() == 8 {
+    // Padding: 0 bytes
+    assert!(size_of::<AstroRoot>() == 28);
+    assert!(align_of::<AstroRoot>() == 4);
+    assert!(offset_of!(AstroRoot, span) == 0);
+    assert!(offset_of!(AstroRoot, frontmatter) == 8);
+    assert!(offset_of!(AstroRoot, body) == 12);
+
+    // Padding: 0 bytes
+    assert!(size_of::<AstroFrontmatter>() == 96);
+    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!(align_of::<AstroScript>() == 4);
+    assert!(offset_of!(AstroScript, span) == 0);
+    assert!(offset_of!(AstroScript, program) == 8);
+
     // Padding: 1 bytes
     assert!(size_of::<Program>() == 88);
     assert!(align_of::<Program>() == 4);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -22,6 +22,81 @@ use oxc_span::{Atom, Ident};
 use crate::{AstBuilder, ast::*};
 
 impl<'a> AstBuilder<'a> {
+    /// Build an [`AstroRoot`].
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code
+    /// * `frontmatter`: The frontmatter section between `---` delimiters, containing TypeScript code.
+    /// * `body`: The HTML body of the Astro file, which can contain JSX expressions.
+    #[inline]
+    pub fn astro_root<T1>(
+        self,
+        span: Span,
+        frontmatter: T1,
+        body: Vec<'a, JSXChild<'a>>,
+    ) -> AstroRoot<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AstroFrontmatter<'a>>>>,
+    {
+        AstroRoot { span, frontmatter: frontmatter.into_in(self.allocator), body }
+    }
+
+    /// Build an [`AstroFrontmatter`].
+    ///
+    /// If you want the built node to be allocated in the memory arena,
+    /// use [`AstBuilder::alloc_astro_frontmatter`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code (includes the `---` delimiters)
+    /// * `program`: The parsed TypeScript program from the frontmatter content
+    #[inline]
+    pub fn astro_frontmatter(self, span: Span, program: Program<'a>) -> AstroFrontmatter<'a> {
+        AstroFrontmatter { span, program }
+    }
+
+    /// Build an [`AstroFrontmatter`], and store it in the memory arena.
+    ///
+    /// Returns a [`Box`] containing the newly-allocated node.
+    /// If you want a stack-allocated node, use [`AstBuilder::astro_frontmatter`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code (includes the `---` delimiters)
+    /// * `program`: The parsed TypeScript program from the frontmatter content
+    #[inline]
+    pub fn alloc_astro_frontmatter(
+        self,
+        span: Span,
+        program: Program<'a>,
+    ) -> Box<'a, AstroFrontmatter<'a>> {
+        Box::new_in(self.astro_frontmatter(span, program), self.allocator)
+    }
+
+    /// Build an [`AstroScript`].
+    ///
+    /// If you want the built node to be allocated in the memory arena,
+    /// use [`AstBuilder::alloc_astro_script`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code (includes the `<script>` tags)
+    /// * `program`: The parsed TypeScript/JavaScript program from the script content
+    #[inline]
+    pub fn astro_script(self, span: Span, program: Program<'a>) -> AstroScript<'a> {
+        AstroScript { span, program }
+    }
+
+    /// Build an [`AstroScript`], and store it in the memory arena.
+    ///
+    /// Returns a [`Box`] containing the newly-allocated node.
+    /// If you want a stack-allocated node, use [`AstBuilder::astro_script`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code (includes the `<script>` tags)
+    /// * `program`: The parsed TypeScript/JavaScript program from the script content
+    #[inline]
+    pub fn alloc_astro_script(self, span: Span, program: Program<'a>) -> Box<'a, AstroScript<'a>> {
+        Box::new_in(self.astro_script(span, program), self.allocator)
+    }
+
     /// Build a [`Program`].
     ///
     /// ## Parameters
@@ -9734,6 +9809,18 @@ impl<'a> AstBuilder<'a> {
         JSXChild::Spread(self.alloc_jsx_spread_child(span, expression))
     }
 
+    /// Build a [`JSXChild::AstroScript`].
+    ///
+    /// This node contains an [`AstroScript`] that will be stored in the memory arena.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code (includes the `<script>` tags)
+    /// * `program`: The parsed TypeScript/JavaScript program from the script content
+    #[inline]
+    pub fn jsx_child_astro_script(self, span: Span, program: Program<'a>) -> JSXChild<'a> {
+        JSXChild::AstroScript(self.alloc_astro_script(span, program))
+    }
+
     /// Build a [`JSXSpreadChild`].
     ///
     /// If you want the built node to be allocated in the memory arena,