fix(parser): correct Astro shorthand attribute spans (#7)

Author: Princesseuh

crates/oxc_parser/src/astro/jsx.rs

@@ -602,27 +602,29 @@ impl<'a, C: ParserConfig> ParserImpl<'a, C> {
     /// Try to parse Astro shorthand attribute `{prop}` -> `prop={prop}`
     fn try_parse_astro_shorthand_attribute(&mut self) -> Option<Box<'a, JSXAttribute<'a>>> {
         let checkpoint = self.checkpoint();
+        let attr_span = self.start_span();
         self.bump_any(); // bump `{`
 
         if self.at(Kind::Ident) || self.cur_kind().is_any_keyword() {
             let ident_span = self.start_span();
             let name = self.cur_src();
             self.bump_any();
+            let ident_span = self.end_span(ident_span);
 
             if self.at(Kind::RCurly) {
                 self.bump_any(); // bump `}`
-                let ident_span = self.end_span(ident_span);
+                let attr_span = self.end_span(attr_span);
                 let name = Atom::from(name);
                 let identifier = self.ast.jsx_identifier(ident_span, name);
                 let attr_name = JSXAttributeName::Identifier(self.alloc(identifier));
 
                 let ident_ref = self.ast.identifier_reference(ident_span, name);
                 let expr = Expression::Identifier(self.alloc(ident_ref));
                 let expr_container =
-                    self.ast.alloc_jsx_expression_container(ident_span, JSXExpression::from(expr));
+                    self.ast.alloc_jsx_expression_container(attr_span, JSXExpression::from(expr));
                 let value = JSXAttributeValue::ExpressionContainer(expr_container);
 
-                return Some(self.ast.alloc_jsx_attribute(ident_span, attr_name, Some(value)));
+                return Some(self.ast.alloc_jsx_attribute(attr_span, attr_name, Some(value)));
             }
         }
 

crates/oxc_parser/src/astro/mod.rs

@@ -1268,6 +1268,82 @@ const name = "World";
         }
     }
 
+    #[test]
+    fn parse_astro_attribute_shorthand_spans() {
+        use oxc_ast::ast::JSXAttributeValue;
+
+        let allocator = Allocator::default();
+        let source_type = SourceType::astro();
+        let source = r"<Component {prop} />";
+        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, got SpreadAttribute");
+        };
+        let JSXAttributeName::Identifier(name) = &attr.name else {
+            panic!("expected ident name");
+        };
+        let Some(JSXAttributeValue::ExpressionContainer(container)) = &attr.value else {
+            panic!("expected expression container value");
+        };
+
+        assert_eq!(attr.span.source_text(source), "{prop}");
+        assert_eq!(container.span.source_text(source), "{prop}");
+        assert_eq!(name.span.source_text(source), "prop");
+    }
+
+    /// Shorthand is desugared away, so this span relationship is all consumers have to detect it.
+    #[test]
+    fn parse_astro_attribute_shorthand_is_distinguishable_by_span() {
+        let shorthand =
+            ["<C {prop} />", "<C   {prop}   />", "<C {{ a: 1 }} />", "<C {obj?.prop} />"];
+        let longhand = [
+            "<C class=\"a\" />",
+            "<C    class=\"a\" />",
+            "<C\n  class=\"a\"\n/>",
+            "<C client:load />",
+            "<C a:b=\"c\" />",
+            "<C disabled />",
+            "<C x={y} />",
+            "<C x=`y` />",
+        ];
+
+        for (source, expected) in
+            shorthand.iter().map(|s| (s, true)).chain(longhand.iter().map(|s| (s, false)))
+        {
+            let allocator = Allocator::default();
+            let ret = Parser::new(&allocator, source, SourceType::astro()).parse_astro();
+            assert!(!ret.panicked, "{source:?} panicked: {:?}", ret.errors);
+            assert!(ret.errors.is_empty(), "{source:?} errors: {:?}", ret.errors);
+
+            let JSXChild::Element(element) = &ret.root.body[0] else {
+                panic!("{source:?}: expected JSXChild::Element");
+            };
+            let JSXAttributeItem::Attribute(attr) = &element.opening_element.attributes[0] else {
+                panic!("{source:?}: expected Attribute");
+            };
+            let JSXAttributeName::Identifier(name) = &attr.name else {
+                panic!("{source:?}: expected ident name");
+            };
+
+            assert_eq!(
+                attr.span.start < name.span.start,
+                expected,
+                "{source:?}: attribute span {:?} vs name span {:?}",
+                attr.span,
+                name.span
+            );
+            if expected {
+                assert_eq!(&source[attr.span.start as usize..][..1], "{", "{source:?}");
+            }
+        }
+    }
+
     // A non-identifier `{expr}` is a shorthand whose name is the expression source text.
     #[test]
     fn parse_astro_attribute_shorthand_object_expression() {