Hello {name}!
+/// ``` +#[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: OptionWelcome, world!
- - - "#; - - let sources = parse_astro(source_text); - assert_eq!(sources.len(), 1); - assert_eq!(sources[0].source_text.trim(), r#"console.log("Hi");"#); - assert_eq!(sources[0].start, 51); - } - - #[test] - fn test_parse_astro_with_fontmatter() { - let source_text = r#" - --- - const { message = 'Welcome, world!' } = Astro.props; - --- - -Welcome, world!
- - - "#; - - let sources = parse_astro(source_text); - assert_eq!(sources.len(), 2); - assert_eq!( - sources[0].source_text.trim(), - "const { message = 'Welcome, world!' } = Astro.props;" - ); - assert_eq!(sources[0].start, 12); - assert_eq!(sources[1].source_text.trim(), r#"console.log("Hi");"#); - assert_eq!(sources[1].start, 141); - } - - #[test] - fn test_parse_astro_with_inline_script() { - let source_text = r#" -Welcome, world!
- - - - - "#; - - let sources = parse_astro(source_text); - assert_eq!(sources.len(), 2); - assert!(sources[0].source_text.is_empty()); - assert_eq!(sources[0].start, 102); - assert_eq!(sources[1].source_text.trim(), r#"console.log("Hi");"#); - assert_eq!(sources[1].start, 129); - } - - #[test] - fn test_script_inside_code_comment() { - let source_text = r" - - - - "; - - let sources = parse_astro(source_text); - assert_eq!(sources.len(), 1); - assert_eq!(sources[0].source_text, "b"); - assert_eq!(sources[0].start, 79); - } - - #[test] - fn test_parse_astro_with_inline_script_self_closing() { - let source_text = r#" -Welcome, world!
- - - - - "#; - - let sources = parse_astro(source_text); - assert_eq!(sources.len(), 2); - assert!(sources[0].source_text.is_empty()); - assert_eq!(sources[0].start, 104); - assert_eq!(sources[1].source_text.trim(), r#"console.log("Hi");"#); - assert_eq!(sources[1].start, 122); - } -} diff --git a/crates/oxc_linter/src/loader/partial_loader/mod.rs b/crates/oxc_linter/src/loader/partial_loader/mod.rs index bb59ffef3f09a..fdbc11a500cb4 100644 --- a/crates/oxc_linter/src/loader/partial_loader/mod.rs +++ b/crates/oxc_linter/src/loader/partial_loader/mod.rs @@ -3,10 +3,8 @@ use oxc_span::VALID_EXTENSIONS; use crate::loader::JavaScriptSource; -mod astro; mod svelte; mod vue; -pub use astro::AstroPartialLoader; pub use svelte::SveltePartialLoader; pub use vue::VuePartialLoader; @@ -17,7 +15,7 @@ const COMMENT_END: &str = "-->"; /// File extensions that can contain JS/TS code in certain parts, such as in `"#, None, None, Some(PathBuf::from("src/foo/bar.vue")), ), - ( - r"--- -import Welcome from '../components/Welcome.astro'; -import Layout from '../layouts/Layout.astro'; ---- -Hello
+"#; + let ret = Parser::new(&allocator, source, source_type).parse_astro(); + assert!(!ret.panicked); + assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors); + + // Check frontmatter - now contains a parsed Program + assert!(ret.root.frontmatter.is_some()); + let frontmatter = ret.root.frontmatter.as_ref().unwrap(); + // The program should have one statement (const declaration) + assert_eq!(frontmatter.program.body.len(), 1); + assert!(matches!(frontmatter.program.body[0], Statement::VariableDeclaration(_))); + + // Check body has at least one element + assert!(!ret.root.body.is_empty()); + assert!(matches!(ret.root.body[0], JSXChild::Element(_))); + } + + #[test] + fn parse_astro_without_frontmatter() { + let allocator = Allocator::default(); + let source_type = SourceType::astro(); + let source = "Hello
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Frontmatter is always present (synthetic empty one for files without actual frontmatter)
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ // Synthetic frontmatter has 0-length span and empty body
+ assert_eq!(frontmatter.span.start, 0);
+ assert_eq!(frontmatter.span.end, 0);
+ assert!(frontmatter.program.body.is_empty());
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ assert!(matches!(ret.root.body[0], JSXChild::Element(_)));
+ }
+
+ #[test]
+ fn parse_astro_with_jsx_expression() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Simpler test case: just an expression in JSX
+ let source = r#"---
+const name = "World";
+---
+{name}
+"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Check frontmatter - now contains a parsed Program
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ assert_eq!(frontmatter.program.body.len(), 1);
+
+ // Check body
+ assert!(!ret.root.body.is_empty());
+ // First element should be the
+ assert!(matches!(ret.root.body[0], JSXChild::Element(_)));
+ }
+
+ #[test]
+ fn parse_astro_fragment() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "<>";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ let attrs = &element.opening_element.attributes;
+ assert_eq!(attrs.len(), 2);
+
+ let attr_value = |idx: usize| -> &str {
+ let JSXAttributeItem::Attribute(a) = &attrs[idx] else {
+ panic!("Expected Attribute at {idx}");
+ };
+ let Some(JSXAttributeValue::StringLiteral(lit)) = &a.value else {
+ panic!("expected string literal at {idx}");
+ };
+ lit.value.as_str()
+ };
+ assert_eq!(attr_value(0), "42");
+ assert_eq!(attr_value(1), "99");
+ }
+
+ #[test]
+ fn parse_astro_unquoted_value_has_correct_span() {
+ // The lexer rewind in the unquoted-value path must produce a span that
+ // exactly covers the value characters in the source — not the wider
+ // span the JS lexer would have produced for a partial token.
+ use oxc_ast::ast::JSXAttributeValue;
+ use oxc_span::GetSpan;
+
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#"` is malformed: `attr=` with no value. The diagnostic
+ // must point at the `/`, not silently consume it as the value — that
+ // would break self-closing and surface the error far from the cause.
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+
+ assert!(!ret.errors.is_empty(), "expected a diagnostic for empty unquoted value");
+
+ let slash_offset = source.find('/').unwrap() as u32;
+ assert!(
+ ret.errors.iter().any(|e| e
+ .labels
+ .as_ref()
+ .is_some_and(|labels| labels.iter().any(|l| l.offset() as u32 == slash_offset))),
+ "expected diagnostic at offset {slash_offset}, got {:?}",
+ ret.errors
+ );
+ }
+
+ #[test]
+ fn parse_astro_void_element_without_closing() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // HTML void elements don't need to be self-closed
+ let source = r#"
"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have 3 elements
+ assert_eq!(ret.root.body.len(), 3);
+ assert!(matches!(ret.root.body[0], JSXChild::Element(_)));
+ assert!(matches!(ret.root.body[1], JSXChild::Element(_)));
+ assert!(matches!(ret.root.body[2], JSXChild::Element(_)));
+ }
+
+ #[test]
+ fn parse_astro_void_element_self_closed() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Self-closing void elements should also work
+ let source = r#"
"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have 3 elements
+ assert_eq!(ret.root.body.len(), 3);
+ }
+
+ #[test]
+ fn parse_astro_void_elements_mixed_with_content() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#"
1
2
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one fragment
+ assert_eq!(ret.root.body.len(), 1);
+ assert!(matches!(ret.root.body[0], JSXChild::Fragment(_)));
+ }
+
+ #[test]
+ fn parse_astro_script() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "Hello
\n\nWorld
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have 5 children: div, text(\n), script, text(\n), div
+ assert_eq!(ret.root.body.len(), 5, "Expected 5 children, got {}", ret.root.body.len());
+
+ // First should be an element
+ assert!(matches!(ret.root.body[0], JSXChild::Element(_)));
+
+ // Second should be text (newline)
+ assert!(matches!(ret.root.body[1], JSXChild::Text(_)));
+
+ // Third should be a and )
+ assert!(matches!(ret.root.body[3], JSXChild::Text(_)));
+
+ // Fifth should be an element
+ assert!(matches!(ret.root.body[4], JSXChild::Element(_)));
+ }
+
+ #[test]
+ fn parse_astro_complex() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#"---
+ import CardSkeleton from "$components/card/CardSkeleton.astro"
+ import ReturnHome from "$components/controls/ReturnHome.astro"
+ import Layout from "$layouts/Layout.astro"
+
+ /**
+ * Catalogue page
+ */
+ const pageTitle = "Catalogue"
+ ---
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Images and data are fetched from IGDB for video games, BGG for board games, TMDB for movies and shows, and Spotify for albums.
+ Their licenses apply.
+
+
+
+
+
+
+
+
+"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Check frontmatter is parsed as TypeScript
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ // Should have 4 statements: 3 imports + 1 const declaration
+ assert_eq!(frontmatter.program.body.len(), 4, "Expected 4 statements in frontmatter");
+ // First 3 should be import declarations
+ assert!(matches!(frontmatter.program.body[0], Statement::ImportDeclaration(_)));
+ assert!(matches!(frontmatter.program.body[1], Statement::ImportDeclaration(_)));
+ assert!(matches!(frontmatter.program.body[2], Statement::ImportDeclaration(_)));
+ // Last should be a variable declaration
+ assert!(matches!(frontmatter.program.body[3], Statement::VariableDeclaration(_)));
+
+ // Check body has the Layout element (may have leading whitespace text)
+ assert!(!ret.root.body.is_empty());
+ // Find the first non-text element
+ let first_element =
+ ret.root.body.iter().find(|child| matches!(child, JSXChild::Element(_)));
+ assert!(first_element.is_some(), "Expected at least one JSXChild::Element in body");
+ }
+
+ #[test]
+ fn parse_astro_frontmatter_with_whitespace_before_fence() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Whitespace before opening fence is allowed per spec
+ let source = " ---\nconst x = 1;\n---\n
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ assert_eq!(
+ element.opening_element.attributes.len(),
+ 1,
+ "expected 1 attribute (class), line comment should be skipped"
+ );
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_line_comment_inline_after_attribute() {
+ // A `//` line comment at the end of an attribute line.
+ // Everything from `//` to end-of-line is skipped; the next line's
+ // attribute is still parsed normally.
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ assert_eq!(
+ element.opening_element.attributes.len(),
+ 2,
+ "expected 2 attributes (class, id); inline line comment should be skipped"
+ );
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_template_literal_attribute() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "{pageTitle}
++ Where I keep track of books, movies, songs, video games, and other media I + consume. Keep in mind that this is a personal catalogue, incomplete and + biased. +
+
+
+
+
+ test
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Should have frontmatter
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ assert_eq!(frontmatter.program.body.len(), 1);
+ assert!(matches!(frontmatter.program.body[0], Statement::VariableDeclaration(_)));
+ }
+
+ #[test]
+ fn parse_astro_frontmatter_content_before_fence() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Content before opening fence is allowed (customarily ignored)
+ let source = "ignored content\n---\nconst x = 1;\n---\ntest
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Should have frontmatter
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ assert_eq!(frontmatter.program.body.len(), 1);
+ assert!(matches!(frontmatter.program.body[0], Statement::VariableDeclaration(_)));
+ }
+
+ #[test]
+ fn parse_astro_frontmatter_code_on_opening_line() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Code on same line as opening fence
+ let source = "---const x = 1;\n---\ntest
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Should have frontmatter with 1 statement
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ assert_eq!(frontmatter.program.body.len(), 1);
+ assert!(matches!(frontmatter.program.body[0], Statement::VariableDeclaration(_)));
+ }
+
+ #[test]
+ fn parse_astro_frontmatter_code_on_closing_line() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Code on same line as closing fence
+ let source = "---\nconst x = 1;---\ntest
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Should have frontmatter with 1 statement
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ assert_eq!(frontmatter.program.body.len(), 1);
+ assert!(matches!(frontmatter.program.body[0], Statement::VariableDeclaration(_)));
+ }
+
+ #[test]
+ fn parse_astro_frontmatter_compact() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Both opening and closing on same "line" with code
+ let source = "---const x = 1;---test
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Should have frontmatter with 1 statement
+ assert!(ret.root.frontmatter.is_some());
+ let frontmatter = ret.root.frontmatter.as_ref().unwrap();
+ assert_eq!(frontmatter.program.body.len(), 1);
+ assert!(matches!(frontmatter.program.body[0], Statement::VariableDeclaration(_)));
+
+ // Body should have the div element
+ assert!(!ret.root.body.is_empty());
+ assert!(matches!(ret.root.body[0], JSXChild::Element(_)));
+ }
+
+ #[test]
+ fn parse_astro_attribute_with_at_sign() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ // Should have one attribute
+ assert_eq!(element.opening_element.attributes.len(), 1);
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_attribute_with_colon_self_closing() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ // Should have one attribute
+ assert_eq!(element.opening_element.attributes.len(), 1);
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_attribute_with_colon_not_self_closing() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ // Should have one attribute
+ assert_eq!(element.opening_element.attributes.len(), 1);
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_attribute_colon_with_space_two_attrs() {
+ // In Astro: `` is two attributes: `:` and `hello`
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r"";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ // Should have TWO attributes: `:` and `hello`
+ assert_eq!(
+ element.opening_element.attributes.len(),
+ 2,
+ "Expected 2 attributes, got {:?}",
+ element.opening_element.attributes
+ );
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_attribute_colon_no_space_one_attr() {
+ // In Astro: `
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ assert_eq!(element.opening_element.attributes.len(), 1);
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_block_comment_between_multiple_attributes() {
+ // Block comment sandwiched between real attributes — all three must survive.
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ assert_eq!(
+ element.opening_element.attributes.len(),
+ 2,
+ "expected 2 attributes (id, class), comment should be skipped"
+ );
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_line_comment_on_own_line_between_attributes() {
+ // A `//` line comment on its own line between attributes.
+ // The newline that terminates the comment acts as the separator,
+ // so the next attribute is parsed correctly.
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "` is one attribute: `:hello`
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r"";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ // Should have ONE attribute: `:hello`
+ assert_eq!(
+ element.opening_element.attributes.len(),
+ 1,
+ "Expected 1 attribute, got {:?}",
+ element.opening_element.attributes
+ );
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_attribute_with_dot() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ assert_eq!(element.opening_element.attributes.len(), 1);
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_attribute_shorthand() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r"
";
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ assert_eq!(
+ element.opening_element.attributes.len(),
+ 1,
+ "expected 1 attribute (class), comment should be skipped"
+ );
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_block_comment_between_attributes_multiline() {
+ // Multi-line block comment between attributes.
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "x
"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ let attrs = &element.opening_element.attributes;
+ assert_eq!(attrs.len(), 2);
+
+ let unquoted_value = |idx: usize| -> &str {
+ let JSXAttributeItem::Attribute(attr) = &attrs[idx] else {
+ panic!("Expected Attribute at {idx}");
+ };
+ let Some(JSXAttributeValue::StringLiteral(str_lit)) = &attr.value else {
+ panic!("Expected StringLiteral value at {idx}, got {:?}", attr.value);
+ };
+ str_lit.value.as_str()
+ };
+
+ assert_eq!(unquoted_value(0), "hello-world");
+ assert_eq!(unquoted_value(1), "#abc123");
+ }
+
+ #[test]
+ fn parse_astro_unquoted_attribute_then_self_closing() {
+ // The unquoted reader must stop at `/` so `` still self-closes.
+ use oxc_ast::ast::JSXAttributeValue;
+
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ assert!(element.closing_element.is_none(), "expected self-closing element");
+ let attrs = &element.opening_element.attributes;
+ assert_eq!(attrs.len(), 1);
+
+ let JSXAttributeItem::Attribute(attr) = &attrs[0] else {
+ panic!("Expected Attribute");
+ };
+ let Some(JSXAttributeValue::StringLiteral(str_lit)) = &attr.value else {
+ panic!("Expected StringLiteral value, got {:?}", attr.value);
+ };
+ assert_eq!(str_lit.value.as_str(), "4");
+ }
+
+ #[test]
+ fn parse_astro_quoted_and_expression_attributes_still_work() {
+ // The new unquoted-value path must not regress string or expression attributes.
+ use oxc_ast::ast::JSXAttributeValue;
+
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ let attrs = &element.opening_element.attributes;
+ assert_eq!(attrs.len(), 3);
+
+ let JSXAttributeItem::Attribute(type_attr) = &attrs[0] else {
+ panic!("Expected Attribute at 0");
+ };
+ assert!(matches!(type_attr.value, Some(JSXAttributeValue::StringLiteral(_))));
+
+ let JSXAttributeItem::Attribute(value_attr) = &attrs[1] else {
+ panic!("Expected Attribute at 1");
+ };
+ assert!(matches!(value_attr.value, Some(JSXAttributeValue::ExpressionContainer(_))));
+
+ let JSXAttributeItem::Attribute(other_attr) = &attrs[2] else {
+ panic!("Expected Attribute at 2");
+ };
+ assert!(matches!(other_attr.value, Some(JSXAttributeValue::StringLiteral(_))));
+ }
+
+ #[test]
+ fn parse_astro_unquoted_attribute_in_middle_of_list() {
+ // Sibling attributes on either side must still parse across the lexer rewind.
+ use oxc_ast::ast::JSXAttributeValue;
+
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ let attrs = &element.opening_element.attributes;
+ assert_eq!(attrs.len(), 4);
+
+ let attr = |idx: usize| -> &oxc_ast::ast::JSXAttribute<'_> {
+ let JSXAttributeItem::Attribute(a) = &attrs[idx] else {
+ panic!("Expected Attribute at {idx}");
+ };
+ a
+ };
+
+ let JSXAttributeName::Identifier(name) = &attr(0).name else {
+ panic!("expected ident name");
+ };
+ assert_eq!(name.name.as_str(), "id");
+ assert!(matches!(attr(0).value, Some(JSXAttributeValue::StringLiteral(_))));
+
+ let JSXAttributeName::Identifier(name) = &attr(1).name else {
+ panic!("expected ident name");
+ };
+ assert_eq!(name.name.as_str(), "class");
+ let Some(JSXAttributeValue::StringLiteral(class_lit)) = &attr(1).value else {
+ panic!("class should be quoted string");
+ };
+ assert_eq!(class_lit.value.as_str(), "bar");
+
+ let JSXAttributeName::Identifier(name) = &attr(2).name else {
+ panic!("expected ident name");
+ };
+ assert_eq!(name.name.as_str(), "data-x");
+ let Some(JSXAttributeValue::StringLiteral(data_lit)) = &attr(2).value else {
+ panic!("data-x should produce a string literal");
+ };
+ assert_eq!(data_lit.value.as_str(), "42");
+
+ let JSXAttributeName::Identifier(name) = &attr(3).name else {
+ panic!("expected ident name");
+ };
+ assert_eq!(name.name.as_str(), "disabled");
+ assert!(attr(3).value.is_none(), "boolean attr should have no value");
+ }
+
+ #[test]
+ fn parse_astro_unquoted_attribute_with_children() {
+ // The unquoted reader must stop at `>` so children parse, not get swallowed.
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#"hello
"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ assert!(element.closing_element.is_some(), "expected non-self-closing");
+ assert_eq!(element.opening_element.attributes.len(), 1);
+ assert_eq!(element.children.len(), 1);
+ assert!(matches!(element.children[0], JSXChild::Text(_)));
+ }
+
+ #[test]
+ fn parse_astro_unquoted_attribute_value_stops_at_newline() {
+ // An unquoted value must terminate at whitespace, including newlines.
+ // Otherwise multi-line attribute lists would silently swallow the
+ // following attribute names.
+ use oxc_ast::ast::JSXAttributeValue;
+
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = "x
"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ let JSXChild::Element(element) = &ret.root.body[0] else {
+ panic!("Expected JSXChild::Element");
+ };
+ let JSXAttributeItem::Attribute(attr) = &element.opening_element.attributes[0] else {
+ panic!("Expected Attribute");
+ };
+ let Some(JSXAttributeValue::StringLiteral(str_lit)) = &attr.value else {
+ panic!("Expected StringLiteral");
+ };
+
+ let value_start = source.find("hello-world").unwrap() as u32;
+ let value_end = value_start + "hello-world".len() as u32;
+ assert_eq!(str_lit.span().start, value_start);
+ assert_eq!(str_lit.span().end, value_end);
+ }
+
+ #[test]
+ fn parse_astro_empty_value_reports_error_at_terminator() {
+ // `"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have 3 elements
+ assert_eq!(ret.root.body.len(), 3);
+ assert!(matches!(ret.root.body[0], JSXChild::Element(_)));
+ assert!(matches!(ret.root.body[1], JSXChild::Element(_)));
+ assert!(matches!(ret.root.body[2], JSXChild::Element(_)));
+ }
+
+ #[test]
+ fn parse_astro_void_element_self_closed() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Self-closing void elements should also work
+ let source = r#""#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have 3 elements
+ assert_eq!(ret.root.body.len(), 3);
+ }
+
+ #[test]
+ fn parse_astro_void_elements_mixed_with_content() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ let source = r#"
+
+
+
+
+
"#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have 1 div element
+ assert_eq!(ret.root.body.len(), 1);
+ if let JSXChild::Element(element) = &ret.root.body[0] {
+ // The div should have children (text nodes, input, label, br, img, etc.)
+ assert!(!element.children.is_empty());
+ } else {
+ panic!("Expected JSXChild::Element");
+ }
+ }
+
+ #[test]
+ fn parse_astro_bare_script_parsed_as_typescript() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // Bare "#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one "#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one "#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one JSX Element with raw text content (not AstroScript)
+ assert_eq!(ret.root.body.len(), 1);
+ match &ret.root.body[0] {
+ JSXChild::Element(element) => {
+ if let JSXElementName::Identifier(ident) = &element.opening_element.name {
+ assert_eq!(ident.name.as_str(), "script");
+ } else {
+ panic!("Expected Identifier for script element");
+ }
+ // Should have text child (raw, unparsed content)
+ assert_eq!(element.children.len(), 1);
+ assert!(matches!(element.children[0], JSXChild::Text(_)));
+ }
+ other => panic!("Expected Element, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn parse_astro_script_defer_is_parsed() {
+ let allocator = Allocator::default();
+ let source_type = SourceType::astro();
+ // "#;
+ let ret = Parser::new(&allocator, source, source_type).parse_astro();
+ assert!(!ret.panicked, "parser panicked: {:?}", ret.errors);
+ assert!(ret.errors.is_empty(), "errors: {:?}", ret.errors);
+
+ // Body should have one
+
+
+
+
++
+