feat(ast,parser): parse TSTypeAnnotations on AccessorProperty

crates/oxc_ast/src/ast/js.rs

@@ -2277,8 +2277,14 @@ pub struct AccessorProperty<'a> {
     pub key: PropertyKey<'a>,
     /// Initialized value in the declaration, if present.
     pub value: Option<Expression<'a>>,
+    /// Property was declared with a computed key
     pub computed: bool,
+    /// Property was declared with a `static` modifier
     pub r#static: bool,
+    /// Type annotation on the property.
+    ///
+    /// Will only ever be [`Some`] for TypeScript files.
+    pub type_annotation: Option<Box<'a, TSTypeAnnotation<'a>>>,
 }
 
 #[ast(visit)]

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -687,7 +687,7 @@ const _: () = {
     assert!(size_of::<AccessorPropertyType>() == 1usize);
     assert!(align_of::<AccessorPropertyType>() == 1usize);
 
-    assert!(size_of::<AccessorProperty>() == 88usize);
+    assert!(size_of::<AccessorProperty>() == 96usize);
     assert!(align_of::<AccessorProperty>() == 8usize);
     assert!(offset_of!(AccessorProperty, r#type) == 0usize);
     assert!(offset_of!(AccessorProperty, span) == 4usize);
@@ -696,6 +696,7 @@ const _: () = {
     assert!(offset_of!(AccessorProperty, value) == 64usize);
     assert!(offset_of!(AccessorProperty, computed) == 80usize);
     assert!(offset_of!(AccessorProperty, r#static) == 81usize);
+    assert!(offset_of!(AccessorProperty, type_annotation) == 88usize);
 
     assert!(size_of::<ImportExpression>() == 56usize);
     assert!(align_of::<ImportExpression>() == 8usize);
@@ -2091,7 +2092,7 @@ const _: () = {
     assert!(size_of::<AccessorPropertyType>() == 1usize);
     assert!(align_of::<AccessorPropertyType>() == 1usize);
 
-    assert!(size_of::<AccessorProperty>() == 48usize);
+    assert!(size_of::<AccessorProperty>() == 52usize);
     assert!(align_of::<AccessorProperty>() == 4usize);
     assert!(offset_of!(AccessorProperty, r#type) == 0usize);
     assert!(offset_of!(AccessorProperty, span) == 4usize);
@@ -2100,6 +2101,7 @@ const _: () = {
     assert!(offset_of!(AccessorProperty, value) == 36usize);
     assert!(offset_of!(AccessorProperty, computed) == 44usize);
     assert!(offset_of!(AccessorProperty, r#static) == 45usize);
+    assert!(offset_of!(AccessorProperty, type_annotation) == 48usize);
 
     assert!(size_of::<ImportExpression>() == 32usize);
     assert!(align_of::<ImportExpression>() == 4usize);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -6494,10 +6494,11 @@ impl<'a> AstBuilder<'a> {
     /// - decorators: Decorators applied to the accessor property.
     /// - key: The expression used to declare the property.
     /// - value: Initialized value in the declaration, if present.
-    /// - computed
-    /// - r#static
+    /// - computed: Property was declared with a computed key
+    /// - r#static: Property was declared with a `static` modifier
+    /// - type_annotation: Type annotation on the property.
     #[inline]
-    pub fn class_element_accessor_property(
+    pub fn class_element_accessor_property<T1>(
         self,
         r#type: AccessorPropertyType,
         span: Span,
@@ -6506,10 +6507,21 @@ impl<'a> AstBuilder<'a> {
         value: Option<Expression<'a>>,
         computed: bool,
         r#static: bool,
-    ) -> ClassElement<'a> {
-        ClassElement::AccessorProperty(self.alloc(
-            self.accessor_property(r#type, span, decorators, key, value, computed, r#static),
-        ))
+        type_annotation: T1,
+    ) -> ClassElement<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
+    {
+        ClassElement::AccessorProperty(self.alloc(self.accessor_property(
+            r#type,
+            span,
+            decorators,
+            key,
+            value,
+            computed,
+            r#static,
+            type_annotation,
+        )))
     }
 
     /// Convert a [`AccessorProperty`] into a [`ClassElement::AccessorProperty`]
@@ -7057,10 +7069,11 @@ impl<'a> AstBuilder<'a> {
     /// - decorators: Decorators applied to the accessor property.
     /// - key: The expression used to declare the property.
     /// - value: Initialized value in the declaration, if present.
-    /// - computed
-    /// - r#static
+    /// - computed: Property was declared with a computed key
+    /// - r#static: Property was declared with a `static` modifier
+    /// - type_annotation: Type annotation on the property.
     #[inline]
-    pub fn accessor_property(
+    pub fn accessor_property<T1>(
         self,
         r#type: AccessorPropertyType,
         span: Span,
@@ -7069,8 +7082,21 @@ impl<'a> AstBuilder<'a> {
         value: Option<Expression<'a>>,
         computed: bool,
         r#static: bool,
-    ) -> AccessorProperty<'a> {
-        AccessorProperty { r#type, span, decorators, key, value, computed, r#static }
+        type_annotation: T1,
+    ) -> AccessorProperty<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
+    {
+        AccessorProperty {
+            r#type,
+            span,
+            decorators,
+            key,
+            value,
+            computed,
+            r#static,
+            type_annotation: type_annotation.into_in(self.allocator),
+        }
     }
 
     /// Builds a [`AccessorProperty`] and stores it in the memory arena.
@@ -7083,10 +7109,11 @@ impl<'a> AstBuilder<'a> {
     /// - decorators: Decorators applied to the accessor property.
     /// - key: The expression used to declare the property.
     /// - value: Initialized value in the declaration, if present.
-    /// - computed
-    /// - r#static
+    /// - computed: Property was declared with a computed key
+    /// - r#static: Property was declared with a `static` modifier
+    /// - type_annotation: Type annotation on the property.
     #[inline]
-    pub fn alloc_accessor_property(
+    pub fn alloc_accessor_property<T1>(
         self,
         r#type: AccessorPropertyType,
         span: Span,
@@ -7095,9 +7122,22 @@ impl<'a> AstBuilder<'a> {
         value: Option<Expression<'a>>,
         computed: bool,
         r#static: bool,
-    ) -> Box<'a, AccessorProperty<'a>> {
+        type_annotation: T1,
+    ) -> Box<'a, AccessorProperty<'a>>
+    where
+        T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,
+    {
         Box::new_in(
-            self.accessor_property(r#type, span, decorators, key, value, computed, r#static),
+            self.accessor_property(
+                r#type,
+                span,
+                decorators,
+                key,
+                value,
+                computed,
+                r#static,
+                type_annotation,
+            ),
             self.allocator,
         )
     }

crates/oxc_ast/src/generated/derive_clone_in.rs

@@ -1954,6 +1954,7 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for AccessorProperty<'old_alloc
             value: self.value.clone_in(allocator),
             computed: self.computed.clone_in(allocator),
             r#static: self.r#static.clone_in(allocator),
+            type_annotation: self.type_annotation.clone_in(allocator),
         }
     }
 }

crates/oxc_ast/src/generated/visit.rs

@@ -3110,6 +3110,9 @@ pub mod walk {
         if let Some(value) = &it.value {
             visitor.visit_expression(value);
         }
+        if let Some(type_annotation) = &it.type_annotation {
+            visitor.visit_ts_type_annotation(type_annotation);
+        }
     }
 
     #[inline]

crates/oxc_ast/src/generated/visit_mut.rs

@@ -3253,6 +3253,9 @@ pub mod walk_mut {
         if let Some(value) = &mut it.value {
             visitor.visit_expression(value);
         }
+        if let Some(type_annotation) = &mut it.type_annotation {
+            visitor.visit_ts_type_annotation(type_annotation);
+        }
     }
 
     #[inline]

crates/oxc_isolated_declarations/src/class.rs

@@ -469,6 +469,8 @@ impl<'a> IsolatedDeclarations<'a> {
                         None,
                         property.computed,
                         property.r#static,
+                        // SAFETY: `ast.copy` is unsound! We need to fix.
+                        unsafe { self.ast.copy(&property.type_annotation) },
                     );
                     elements.push(new_element);
                 }

crates/oxc_parser/src/js/class.rs

@@ -281,7 +281,6 @@ impl<'a> ParserImpl<'a> {
         }
 
         if accessor {
-            self.parse_ts_type_annotation()?;
             self.parse_class_accessor_property(span, key, computed, r#static, r#abstract).map(Some)
         } else if self.at(Kind::LParen) || self.at(Kind::LAngle) || r#async || generator {
             // LAngle for start of type parameters `foo<T>`
@@ -479,6 +478,8 @@ impl<'a> ParserImpl<'a> {
         r#static: bool,
         r#abstract: bool,
     ) -> Result<ClassElement<'a>> {
+        let type_annotation =
+            if self.ts_enabled() { self.parse_ts_type_annotation()? } else { None };
         let value =
             self.eat(Kind::Eq).then(|| self.parse_assignment_expression_or_higher()).transpose()?;
         let r#type = if r#abstract {
@@ -496,6 +497,7 @@ impl<'a> ParserImpl<'a> {
             value,
             computed,
             r#static,
+            type_annotation,
         ))
     }
 }

crates/oxc_semantic/tests/integration/symbols.rs

@@ -230,6 +230,23 @@ fn test_class_with_type_parameter() {
     tester.has_symbol("B").has_number_of_references(0).test();
 }
 
+#[test]
+fn test_class_with_accessor() {
+    SemanticTester::ts(
+        "
+    type T = 1;
+
+    abstract class Foo {
+        accessor prop: T;
+    }
+    ",
+    )
+    .has_some_symbol("T")
+    .has_number_of_references(1)
+    .has_number_of_references_where(1, Reference::is_type)
+    .test();
+}
+
 #[test]
 fn test_ts_mapped_type() {
     let tester = SemanticTester::ts(