Added more tests.

Author: DanielRosenwasser

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); });
+}