Added more tests.

tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt

@@ -0,0 +1,19 @@
+tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(8,17): error TS2314: Generic type 'A<T1, T2>' requires 2 type argument(s).
+tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(9,21): error TS2335: 'super' can only be referenced in a derived class.
+
+
+==== tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts (2 errors) ====
+    
+    class A<T1, T2> {
+        constructor(private map: (value: T1) => T2) {
+    
+        }
+    }
+    
+    class B extends A<number> {
+                    ~~~~~~~~~
+!!! error TS2314: Generic type 'A<T1, T2>' requires 2 type argument(s).
+        constructor() { super(value => String(value)); }
+                        ~~~~~
+!!! error TS2335: 'super' can only be referenced in a derived class.
+    }

tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js

@@ -0,0 +1,32 @@
+//// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts]
+
+class A<T1, T2> {
+    constructor(private map: (value: T1) => T2) {
+
+    }
+}
+
+class B extends A<number> {
+    constructor() { super(value => String(value)); }
+}
+
+//// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js]
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A(map) {
+        this.map = map;
+    }
+    return A;
+})();
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.call(this, function (value) { return String(value); });
+    }
+    return B;
+})(A);

tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt

@@ -0,0 +1,19 @@
+tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(8,17): error TS2314: Generic type 'A<T1, T2>' requires 2 type argument(s).
+tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(9,21): error TS2335: 'super' can only be referenced in a derived class.
+
+
+==== tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts (2 errors) ====
+    
+    class A<T1, T2> {
+        constructor(private map: (value: T1) => T2) {
+    
+        }
+    }
+    
+    class B extends A {
+                    ~
+!!! error TS2314: Generic type 'A<T1, T2>' requires 2 type argument(s).
+        constructor() { super(value => String(value)); }
+                        ~~~~~
+!!! error TS2335: 'super' can only be referenced in a derived class.
+    }

tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js

@@ -0,0 +1,32 @@
+//// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts]
+
+class A<T1, T2> {
+    constructor(private map: (value: T1) => T2) {
+
+    }
+}
+
+class B extends A {
+    constructor() { super(value => String(value)); }
+}
+
+//// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js]
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A(map) {
+        this.map = map;
+    }
+    return A;
+})();
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.call(this, function (value) { return String(value); });
+    }
+    return B;
+})(A);

tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt

@@ -0,0 +1,19 @@
+tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(8,17): error TS2315: Type 'A' is not generic.
+tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts(9,21): error TS2335: 'super' can only be referenced in a derived class.
+
+
+==== tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts (2 errors) ====
+    
+    class A {
+        constructor(private map: (value: number) => string) {
+    
+        }
+    }
+    
+    class B extends A<number, string> {
+                    ~~~~~~~~~~~~~~~~~
+!!! error TS2315: Type 'A' is not generic.
+        constructor() { super(value => String(value)); }
+                        ~~~~~
+!!! error TS2335: 'super' can only be referenced in a derived class.
+    }

tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js

@@ -0,0 +1,32 @@
+//// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts]
+
+class A {
+    constructor(private map: (value: number) => string) {
+
+    }
+}
+
+class B extends A<number, string> {
+    constructor() { super(value => String(value)); }
+}
+
+//// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js]
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A(map) {
+        this.map = map;
+    }
+    return A;
+})();
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.call(this, function (value) { return String(value); });
+    }
+    return B;
+})(A);

tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt

@@ -0,0 +1,16 @@
+tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts(9,21): error TS2335: 'super' can only be referenced in a derived class.
+
+
+==== tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts (1 errors) ====
+    
+    class A {
+        constructor(private map: (value: number) => string) {
+    
+        }
+    }
+    
+    class B {
+        constructor() { super(value => String(value)); }
+                        ~~~~~
+!!! error TS2335: 'super' can only be referenced in a derived class.
+    }

tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js

@@ -0,0 +1,25 @@
+//// [superCallFromClassThatHasNoBaseType1.ts]
+
+class A {
+    constructor(private map: (value: number) => string) {
+
+    }
+}
+
+class B {
+    constructor() { super(value => String(value)); }
+}
+
+//// [superCallFromClassThatHasNoBaseType1.js]
+var A = (function () {
+    function A(map) {
+        this.map = map;
+    }
+    return A;
+})();
+var B = (function () {
+    function B() {
+        _super.call(this, function (value) { return String(value); });
+    }
+    return B;
+})();

tests/baselines/reference/superCallFromFunction1.errors.txt

@@ -0,0 +1,10 @@
+tests/cases/compiler/superCallFromFunction1.ts(3,5): error TS2335: 'super' can only be referenced in a derived class.
+
+
+==== tests/cases/compiler/superCallFromFunction1.ts (1 errors) ====
+    
+    function foo() {
+        super(value => String(value));
+        ~~~~~
+!!! error TS2335: 'super' can only be referenced in a derived class.
+    }

tests/baselines/reference/superCallFromFunction1.js

@@ -0,0 +1,10 @@
+//// [superCallFromFunction1.ts]
+
+function foo() {
+    super(value => String(value));
+}
+
+//// [superCallFromFunction1.js]
+function foo() {
+    _super.call(this, function (value) { return String(value); });
+}

tests/baselines/reference/superNewCall1.errors.txt

@@ -0,0 +1,23 @@
+tests/cases/compiler/superNewCall1.ts(9,5): error TS2377: Constructors for derived classes must contain a 'super' call.
+tests/cases/compiler/superNewCall1.ts(10,9): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+
+
+==== tests/cases/compiler/superNewCall1.ts (2 errors) ====
+    
+    class A<T1, T2> {
+        constructor(private map: (value: T1) => T2) {
+    
+        }
+    }
+    
+    class B extends A<number, string> {
+        constructor() {
+        ~~~~~~~~~~~~~~~
+            new super(value => String(value));
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+        }
+    ~~~~~
+!!! error TS2377: Constructors for derived classes must contain a 'super' call.
+    }

tests/baselines/reference/superNewCall1.js

@@ -0,0 +1,34 @@
+//// [superNewCall1.ts]
+
+class A<T1, T2> {
+    constructor(private map: (value: T1) => T2) {
+
+    }
+}
+
+class B extends A<number, string> {
+    constructor() {
+        new super(value => String(value));
+    }
+}
+
+//// [superNewCall1.js]
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A(map) {
+        this.map = map;
+    }
+    return A;
+})();
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        new _super.prototype(function (value) { return String(value); });
+    }
+    return B;
+})(A);

tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts

@@ -0,0 +1,10 @@
+
+class A<T1, T2> {
+    constructor(private map: (value: T1) => T2) {
+
+    }
+}
+
+class B extends A<number> {
+    constructor() { super(value => String(value)); }
+}

tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts

@@ -0,0 +1,10 @@
+
+class A<T1, T2> {
+    constructor(private map: (value: T1) => T2) {
+
+    }
+}
+
+class B extends A {
+    constructor() { super(value => String(value)); }
+}

tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts

@@ -0,0 +1,10 @@
+
+class A {
+    constructor(private map: (value: number) => string) {
+
+    }
+}
+
+class B extends A<number, string> {
+    constructor() { super(value => String(value)); }
+}

tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts

@@ -0,0 +1,10 @@
+
+class A {
+    constructor(private map: (value: number) => string) {
+
+    }
+}
+
+class B {
+    constructor() { super(value => String(value)); }
+}

tests/cases/compiler/superCallFromFunction1.ts

@@ -0,0 +1,4 @@
+
+function foo() {
+    super(value => String(value));
+}

tests/cases/compiler/superNewCall1.ts

@@ -0,0 +1,12 @@
+
+class A<T1, T2> {
+    constructor(private map: (value: T1) => T2) {
+
+    }
+}
+
+class B extends A<number, string> {
+    constructor() {
+        new super(value => String(value));
+    }
+}