Add regression test for GH #21871 (#22733)

tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.js

@@ -0,0 +1,86 @@
+//// [tests/cases/compiler/amdDeclarationEmitNoExtraDeclare.ts] ////
+
+//// [Class.ts]
+import { Configurable } from "./Configurable"
+
+export class HiddenClass {}
+
+export class ActualClass extends Configurable(HiddenClass) {}
+//// [Configurable.ts]
+export type Constructor<T> = {
+    new(...args: any[]): T;
+}
+export function Configurable<T extends Constructor<{}>>(base: T): T {
+    return class extends base {
+
+        constructor(...args: any[]) {
+            super(...args);
+        }
+
+    };
+}
+
+
+//// [dist.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+define("Configurable", ["require", "exports"], function (require, exports) {
+    "use strict";
+    exports.__esModule = true;
+    function Configurable(base) {
+        return /** @class */ (function (_super) {
+            __extends(class_1, _super);
+            function class_1() {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return _super.apply(this, args) || this;
+            }
+            return class_1;
+        }(base));
+    }
+    exports.Configurable = Configurable;
+});
+define("Class", ["require", "exports", "Configurable"], function (require, exports, Configurable_1) {
+    "use strict";
+    exports.__esModule = true;
+    var HiddenClass = /** @class */ (function () {
+        function HiddenClass() {
+        }
+        return HiddenClass;
+    }());
+    exports.HiddenClass = HiddenClass;
+    var ActualClass = /** @class */ (function (_super) {
+        __extends(ActualClass, _super);
+        function ActualClass() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return ActualClass;
+    }(Configurable_1.Configurable(HiddenClass)));
+    exports.ActualClass = ActualClass;
+});
+
+
+//// [dist.d.ts]
+declare module "Configurable" {
+    export type Constructor<T> = {
+        new (...args: any[]): T;
+    };
+    export function Configurable<T extends Constructor<{}>>(base: T): T;
+}
+declare module "Class" {
+    export class HiddenClass {
+    }
+    const ActualClass_base: typeof HiddenClass;
+    export class ActualClass extends ActualClass_base {
+    }
+}

tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.symbols

@@ -0,0 +1,43 @@
+=== tests/cases/compiler/Class.ts ===
+import { Configurable } from "./Configurable"
+>Configurable : Symbol(Configurable, Decl(Class.ts, 0, 8))
+
+export class HiddenClass {}
+>HiddenClass : Symbol(HiddenClass, Decl(Class.ts, 0, 45))
+
+export class ActualClass extends Configurable(HiddenClass) {}
+>ActualClass : Symbol(ActualClass, Decl(Class.ts, 2, 27))
+>Configurable : Symbol(Configurable, Decl(Class.ts, 0, 8))
+>HiddenClass : Symbol(HiddenClass, Decl(Class.ts, 0, 45))
+
+=== tests/cases/compiler/Configurable.ts ===
+export type Constructor<T> = {
+>Constructor : Symbol(Constructor, Decl(Configurable.ts, 0, 0))
+>T : Symbol(T, Decl(Configurable.ts, 0, 24))
+
+    new(...args: any[]): T;
+>args : Symbol(args, Decl(Configurable.ts, 1, 8))
+>T : Symbol(T, Decl(Configurable.ts, 0, 24))
+}
+export function Configurable<T extends Constructor<{}>>(base: T): T {
+>Configurable : Symbol(Configurable, Decl(Configurable.ts, 2, 1))
+>T : Symbol(T, Decl(Configurable.ts, 3, 29))
+>Constructor : Symbol(Constructor, Decl(Configurable.ts, 0, 0))
+>base : Symbol(base, Decl(Configurable.ts, 3, 56))
+>T : Symbol(T, Decl(Configurable.ts, 3, 29))
+>T : Symbol(T, Decl(Configurable.ts, 3, 29))
+
+    return class extends base {
+>base : Symbol(base, Decl(Configurable.ts, 3, 56))
+
+        constructor(...args: any[]) {
+>args : Symbol(args, Decl(Configurable.ts, 6, 20))
+
+            super(...args);
+>super : Symbol(T, Decl(Configurable.ts, 3, 29))
+>args : Symbol(args, Decl(Configurable.ts, 6, 20))
+        }
+
+    };
+}
+

tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.types

@@ -0,0 +1,47 @@
+=== tests/cases/compiler/Class.ts ===
+import { Configurable } from "./Configurable"
+>Configurable : <T extends new (...args: any[]) => {}>(base: T) => T
+
+export class HiddenClass {}
+>HiddenClass : HiddenClass
+
+export class ActualClass extends Configurable(HiddenClass) {}
+>ActualClass : ActualClass
+>Configurable(HiddenClass) : HiddenClass
+>Configurable : <T extends new (...args: any[]) => {}>(base: T) => T
+>HiddenClass : typeof HiddenClass
+
+=== tests/cases/compiler/Configurable.ts ===
+export type Constructor<T> = {
+>Constructor : Constructor<T>
+>T : T
+
+    new(...args: any[]): T;
+>args : any[]
+>T : T
+}
+export function Configurable<T extends Constructor<{}>>(base: T): T {
+>Configurable : <T extends Constructor<{}>>(base: T) => T
+>T : T
+>Constructor : Constructor<T>
+>base : T
+>T : T
+>T : T
+
+    return class extends base {
+>class extends base {        constructor(...args: any[]) {            super(...args);        }    } : { new (...args: any[]): (Anonymous class); prototype: Configurable<any>.(Anonymous class); } & T
+>base : {}
+
+        constructor(...args: any[]) {
+>args : any[]
+
+            super(...args);
+>super(...args) : void
+>super : T
+>...args : any
+>args : any[]
+        }
+
+    };
+}
+

tests/cases/compiler/amdDeclarationEmitNoExtraDeclare.ts

@@ -0,0 +1,22 @@
+// @declaration: true
+// @module: amd
+// @out: dist.js
+// @filename: Class.ts
+import { Configurable } from "./Configurable"
+
+export class HiddenClass {}
+
+export class ActualClass extends Configurable(HiddenClass) {}
+// @filename: Configurable.ts
+export type Constructor<T> = {
+    new(...args: any[]): T;
+}
+export function Configurable<T extends Constructor<{}>>(base: T): T {
+    return class extends base {
+
+        constructor(...args: any[]) {
+            super(...args);
+        }
+
+    };
+}