fix(parser): correct Astro shorthand attribute spans

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,35 @@ 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");
+    }
+
     // A non-identifier `{expr}` is a shorthand whose name is the expression source text.
     #[test]
     fn parse_astro_attribute_shorthand_object_expression() {