fix(isolated-declarations): incorrect type of object property accessor

Author: Dunqing

crates/oxc_isolated_declarations/src/types.rs

@@ -3,11 +3,11 @@ use oxc_ast::{
     NONE,
     ast::{
         ArrayExpression, ArrayExpressionElement, ArrowFunctionExpression, Expression, Function,
-        ObjectExpression, ObjectPropertyKind, TSLiteral, TSMethodSignatureKind, TSTupleElement,
-        TSType, TSTypeOperatorOperator,
+        ObjectExpression, ObjectPropertyKind, PropertyKey, PropertyKind, TSLiteral,
+        TSMethodSignatureKind, TSTupleElement, TSType, TSTypeOperatorOperator,
     },
 };
-use oxc_span::{GetSpan, SPAN, Span};
+use oxc_span::{ContentEq, GetSpan, SPAN, Span};
 
 use crate::{
     IsolatedDeclarations,
@@ -81,6 +81,12 @@ impl<'a> IsolatedDeclarations<'a> {
         expr: &ObjectExpression<'a>,
         is_const: bool,
     ) -> TSType<'a> {
+        // The span of accessors that cannot infer the type.
+        let mut accessor_spans = Vec::new();
+        // One of setter or getter is inferred, then the PropertyKey will be added to it.
+        // Use `Vec` rather than `HashSet` is because the `PropertyKey` is not satisfied with `Hash` trait,
+        let mut accessor_inferred: Vec<PropertyKey<'a>> = Vec::new();
+
         let members =
             self.ast.vec_from_iter(expr.properties.iter().filter_map(|property| match property {
                 ObjectPropertyKind::ObjectProperty(object) => {
@@ -111,26 +117,76 @@ impl<'a> IsolatedDeclarations<'a> {
                         }
                     }
 
-                    let type_annotation = if is_const {
-                        self.transform_expression_to_ts_type(&object.value)
-                    } else {
-                        self.infer_type_from_expression(&object.value)
-                    };
+                    let key = object.key.clone_in(self.ast.allocator);
 
-                    if type_annotation.is_none() {
-                        self.error(inferred_type_of_expression(object.value.span()));
-                        return None;
-                    }
+                    let type_annotation = match object.kind {
+                        PropertyKind::Get => {
+                            if accessor_inferred.iter().any(|k| k.content_eq(&key)) {
+                                return None;
+                            }
+
+                            let Expression::FunctionExpression(function) = &object.value else {
+                                unreachable!(
+                                    "`object.kind` being `Get` guarantees that it is a function"
+                                );
+                            };
+
+                            let annotation = self.infer_function_return_type(function);
+                            if annotation.is_none() {
+                                accessor_spans.push((key.clone_in(self.ast.allocator), key.span()));
+                                return None;
+                            }
+
+                            accessor_inferred.push(key.clone_in(self.ast.allocator));
+                            annotation
+                        }
+                        PropertyKind::Set => {
+                            if accessor_inferred.iter().any(|k| k.content_eq(&key)) {
+                                return None;
+                            }
+
+                            let Expression::FunctionExpression(function) = &object.value else {
+                                unreachable!(
+                                    "`object.kind` being `Set` guarantees that it is a function"
+                                );
+                            };
+                            let annotation = function.params.items.first().and_then(|param| {
+                                param.pattern.type_annotation.clone_in(self.ast.allocator)
+                            });
+                            if annotation.is_none() {
+                                accessor_spans
+                                    .push((key.clone_in(self.ast.allocator), function.params.span));
+                                return None;
+                            }
+
+                            accessor_inferred.push(key.clone_in(self.ast.allocator));
+                            annotation
+                        }
+                        PropertyKind::Init => {
+                            let type_annotation = if is_const {
+                                self.transform_expression_to_ts_type(&object.value)
+                            } else {
+                                self.infer_type_from_expression(&object.value)
+                            };
+
+                            if type_annotation.is_none() {
+                                self.error(inferred_type_of_expression(object.value.span()));
+                                return None;
+                            }
+
+                            type_annotation.map(|type_annotation| {
+                                self.ast.alloc_ts_type_annotation(SPAN, type_annotation)
+                            })
+                        }
+                    };
 
                     let property_signature = self.ast.ts_signature_property_signature(
                         object.span,
                         false,
                         false,
                         is_const,
-                        object.key.clone_in(self.ast.allocator),
-                        type_annotation.map(|type_annotation| {
-                            self.ast.ts_type_annotation(SPAN, type_annotation)
-                        }),
+                        key,
+                        type_annotation,
                     );
                     Some(property_signature)
                 }
@@ -139,6 +195,13 @@ impl<'a> IsolatedDeclarations<'a> {
                     None
                 }
             }));
+
+        for (key, span) in accessor_spans {
+            if !accessor_inferred.iter().any(|k| k.content_eq(&key)) {
+                self.error(inferred_type_of_expression(span));
+            }
+        }
+
         self.ast.ts_type_type_literal(SPAN, members)
     }
 

crates/oxc_isolated_declarations/tests/fixtures/object.ts

@@ -0,0 +1,38 @@
+const A = {
+	get state(): number {
+		return 0;
+	},
+};
+
+const B = {
+	set state(v: string) {
+		// do something
+	},
+};
+
+const C = {
+	get state(): number {
+		return 0;
+	},
+	set state(v: number) {
+		// do something
+	},
+};
+
+const D = {
+	get state(): number {
+		return 0;
+	},
+	set state(v: string) {
+		// do something
+	},
+};
+
+const E = {
+	get state() {
+		return A;
+	},
+	set state(v) {
+		// do something
+	},
+};

crates/oxc_isolated_declarations/tests/snapshots/object.snap

@@ -0,0 +1,42 @@
+---
+source: crates/oxc_isolated_declarations/tests/mod.rs
+input_file: crates/oxc_isolated_declarations/tests/fixtures/object.ts
+---
+```
+==================== .D.TS ====================
+
+declare const A: {
+	state: number
+};
+declare const B: {
+	state: string
+};
+declare const C: {
+	state: number
+};
+declare const D: {
+	state: number
+};
+declare const E: {};
+
+
+==================== Errors ====================
+
+  x TS9013: Expression type can't be inferred with --isolatedDeclarations.
+    ,-[32:6]
+ 31 | const E = {
+ 32 |     get state() {
+    :         ^^^^^
+ 33 |         return A;
+    `----
+
+  x TS9013: Expression type can't be inferred with --isolatedDeclarations.
+    ,-[35:11]
+ 34 |     },
+ 35 |     set state(v) {
+    :              ^^^
+ 36 |         // do something
+    `----
+
+
+```