fix(isolated-declarations): crash when transforming a class with a parameter property in a private constructor

Author: Dunqing

crates/oxc_isolated_declarations/src/class.rs

@@ -289,23 +289,35 @@ impl<'a> IsolatedDeclarations<'a> {
     fn transform_constructor_parameter_properties(
         &self,
         function: &Function<'a>,
-        params: &FormalParameters<'a>,
+        typed_params: &FormalParameters<'a>,
     ) -> ArenaVec<'a, ClassElement<'a>> {
-        self.ast.vec_from_iter(function.params.items.iter().enumerate().filter_map(
-            |(index, param)| {
-                if !param.has_modifier() {
-                    return None;
-                }
-                let type_annotation =
-                    if param.accessibility.is_some_and(TSAccessibility::is_private) {
-                        None
-                    } else {
-                        // transformed params will definitely have type annotation
-                        params.items[index].pattern.type_annotation.clone_in(self.ast.allocator)
-                    };
-                self.transform_formal_parameter_to_class_property(param, type_annotation)
-            },
-        ))
+        self.ast.vec_from_iter(
+            function
+                .params
+                .items
+                .iter()
+                .filter(|param| {
+                    // To follow up `transform_formal_parameters`'s behavior
+                    typed_params.items.len() == function.params.items.len() || param.has_modifier()
+                })
+                .enumerate()
+                .filter_map(|(index, param)| {
+                    if !param.has_modifier() {
+                        return None;
+                    }
+                    let type_annotation =
+                        if param.accessibility.is_some_and(TSAccessibility::is_private) {
+                            None
+                        } else {
+                            // transformed params will definitely have type annotation
+                            typed_params.items[index]
+                                .pattern
+                                .type_annotation
+                                .clone_in(self.ast.allocator)
+                        };
+                    self.transform_formal_parameter_to_class_property(param, type_annotation)
+                }),
+        )
     }
 
     /// Collect return_type of getter and first parma type of setter

crates/oxc_isolated_declarations/tests/fixtures/class.ts

@@ -81,4 +81,65 @@ export class ClassParameterProperties {
 		a: number,
 		readonly b: string,
 	) {}
+}
+
+export class PrivateConstructorWithParameterProperties {
+	private constructor(
+		foo: string,
+		readonly bar: string,
+	) {}
+}
+
+export class ProtectedConstructorWithParameterProperties {
+	protected constructor(
+		public foo: string,
+		private readonly bar: number,
+		protected baz: boolean,
+		readonly qux: string,
+	) {}
+}
+
+export class PrivateConstructorMixedParameterProperties {
+	private constructor(
+		public publicProp: string,
+		private privateProp: number,
+		protected protectedProp: boolean,
+		readonly readonlyProp: string,
+		public readonly publicReadonlyProp: number,
+		private readonly privateReadonlyProp: boolean,
+		normalParam: string,
+	) {}
+}
+
+export class PrivateConstructorWithOverloads {
+	private constructor(a: number);
+	private constructor(a: string);
+	private constructor(a: number, b: string);
+	private constructor(a: any, b?: string) {}
+}
+
+export class PrivateConstructorWithOptionalParameters {
+	private constructor(
+		required: string,
+		optional?: number,
+		public publicOptional?: boolean,
+		private privateOptional?: string,
+		readonly readonlyOptional?: number,
+	) {}
+}
+
+export class PrivateConstructorWithRestParameters {
+	private constructor(
+		first: string,
+		...rest: number[]
+	) {}
+}
+
+export class PrivateConstructorWithDefaultParameters {
+	private constructor(
+		public prop1: string = "default",
+		private prop2: number = 42,
+		readonly prop3: boolean = true,
+		normalParam: string = "normal",
+	) {}
 }

crates/oxc_isolated_declarations/tests/snapshots/class.snap

@@ -68,6 +68,46 @@ export declare class ClassParameterProperties {
 	readonly b: string;
 	constructor(a: number, b: string);
 }
+export declare class PrivateConstructorWithParameterProperties {
+	readonly bar: string;
+	private constructor();
+}
+export declare class ProtectedConstructorWithParameterProperties {
+	foo: string;
+	private readonly bar;
+	protected baz: boolean;
+	readonly qux: string;
+	protected constructor(foo: string, bar: number, baz: boolean, qux: string);
+}
+export declare class PrivateConstructorMixedParameterProperties {
+	publicProp: string;
+	private privateProp;
+	protected protectedProp: boolean;
+	readonly readonlyProp: string;
+	readonly publicReadonlyProp: number;
+	private readonly privateReadonlyProp;
+	private constructor();
+}
+export declare class PrivateConstructorWithOverloads {
+	private constructor();
+	private constructor();
+	private constructor();
+}
+export declare class PrivateConstructorWithOptionalParameters {
+	publicOptional?: boolean;
+	private privateOptional?;
+	readonly readonlyOptional?: number;
+	private constructor();
+}
+export declare class PrivateConstructorWithRestParameters {
+	private constructor();
+}
+export declare class PrivateConstructorWithDefaultParameters {
+	prop1: string;
+	private prop2;
+	readonly prop3: boolean;
+	private constructor();
+}
 
 
 ==================== Errors ====================