From 40796b2c6d64b1d3b304b33ece97bd6893437762 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Tue, 27 Jan 2015 14:42:39 -0800 Subject: [PATCH] Added more tests. --- ...IncorrectNumberOfTypeArguments1.errors.txt | 19 +++++++++++ ...eButWithIncorrectNumberOfTypeArguments1.js | 32 +++++++++++++++++ ...ericTypeButWithNoTypeArguments1.errors.txt | 19 +++++++++++ ...sFromGenericTypeButWithNoTypeArguments1.js | 32 +++++++++++++++++ ...enericTypeButWithTypeArguments1.errors.txt | 19 +++++++++++ ...ivesNonGenericTypeButWithTypeArguments1.js | 32 +++++++++++++++++ ...CallFromClassThatHasNoBaseType1.errors.txt | 16 +++++++++ .../superCallFromClassThatHasNoBaseType1.js | 25 ++++++++++++++ .../superCallFromFunction1.errors.txt | 10 ++++++ .../reference/superCallFromFunction1.js | 10 ++++++ .../reference/superNewCall1.errors.txt | 23 +++++++++++++ tests/baselines/reference/superNewCall1.js | 34 +++++++++++++++++++ ...eButWithIncorrectNumberOfTypeArguments1.ts | 10 ++++++ ...sFromGenericTypeButWithNoTypeArguments1.ts | 10 ++++++ ...ivesNonGenericTypeButWithTypeArguments1.ts | 10 ++++++ .../superCallFromClassThatHasNoBaseType1.ts | 10 ++++++ .../cases/compiler/superCallFromFunction1.ts | 4 +++ tests/cases/compiler/superNewCall1.ts | 12 +++++++ 18 files changed, 327 insertions(+) create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js create mode 100644 tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt create mode 100644 tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js create mode 100644 tests/baselines/reference/superCallFromFunction1.errors.txt create mode 100644 tests/baselines/reference/superCallFromFunction1.js create mode 100644 tests/baselines/reference/superNewCall1.errors.txt create mode 100644 tests/baselines/reference/superNewCall1.js create mode 100644 tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts create mode 100644 tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts create mode 100644 tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts create mode 100644 tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts create mode 100644 tests/cases/compiler/superCallFromFunction1.ts create mode 100644 tests/cases/compiler/superNewCall1.ts diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt new file mode 100644 index 00000000000..14905b224ad --- /dev/null +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.errors.txt @@ -0,0 +1,19 @@ +tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts(8,17): error TS2314: Generic type 'A' 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 { + constructor(private map: (value: T1) => T2) { + + } + } + + class B extends A { + ~~~~~~~~~ +!!! error TS2314: Generic type 'A' requires 2 type argument(s). + constructor() { super(value => String(value)); } + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + } \ No newline at end of file diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js new file mode 100644 index 00000000000..92abed0d66d --- /dev/null +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.js @@ -0,0 +1,32 @@ +//// [superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts] + +class A { + constructor(private map: (value: T1) => T2) { + + } +} + +class B extends A { + 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); diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt new file mode 100644 index 00000000000..d402272df1b --- /dev/null +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.errors.txt @@ -0,0 +1,19 @@ +tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts(8,17): error TS2314: Generic type 'A' 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 { + constructor(private map: (value: T1) => T2) { + + } + } + + class B extends A { + ~ +!!! error TS2314: Generic type 'A' requires 2 type argument(s). + constructor() { super(value => String(value)); } + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + } \ No newline at end of file diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js new file mode 100644 index 00000000000..7e3c61e6690 --- /dev/null +++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.js @@ -0,0 +1,32 @@ +//// [superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts] + +class A { + 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); diff --git a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.errors.txt new file mode 100644 index 00000000000..8bbf8b87cd3 --- /dev/null +++ b/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 { + ~~~~~~~~~~~~~~~~~ +!!! error TS2315: Type 'A' is not generic. + constructor() { super(value => String(value)); } + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + } \ No newline at end of file diff --git a/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js new file mode 100644 index 00000000000..b48d5bb7f58 --- /dev/null +++ b/tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.js @@ -0,0 +1,32 @@ +//// [superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts] + +class A { + constructor(private map: (value: number) => string) { + + } +} + +class B extends A { + 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); diff --git a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.errors.txt new file mode 100644 index 00000000000..bac5abad004 --- /dev/null +++ b/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. + } \ No newline at end of file diff --git a/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js b/tests/baselines/reference/superCallFromClassThatHasNoBaseType1.js new file mode 100644 index 00000000000..7818aed7ff8 --- /dev/null +++ b/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; +})(); diff --git a/tests/baselines/reference/superCallFromFunction1.errors.txt b/tests/baselines/reference/superCallFromFunction1.errors.txt new file mode 100644 index 00000000000..374a3aeb16c --- /dev/null +++ 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. + } \ No newline at end of file diff --git a/tests/baselines/reference/superCallFromFunction1.js b/tests/baselines/reference/superCallFromFunction1.js new file mode 100644 index 00000000000..a7fcbaaeff0 --- /dev/null +++ b/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); }); +} diff --git a/tests/baselines/reference/superNewCall1.errors.txt b/tests/baselines/reference/superNewCall1.errors.txt new file mode 100644 index 00000000000..2b104e7d647 --- /dev/null +++ b/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 { + constructor(private map: (value: T1) => T2) { + + } + } + + class B extends A { + 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. + } \ No newline at end of file diff --git a/tests/baselines/reference/superNewCall1.js b/tests/baselines/reference/superNewCall1.js new file mode 100644 index 00000000000..d9b74ac5080 --- /dev/null +++ b/tests/baselines/reference/superNewCall1.js @@ -0,0 +1,34 @@ +//// [superNewCall1.ts] + +class A { + constructor(private map: (value: T1) => T2) { + + } +} + +class B extends A { + 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); diff --git a/tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts b/tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts new file mode 100644 index 00000000000..d633ccb018f --- /dev/null +++ b/tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts @@ -0,0 +1,10 @@ + +class A { + constructor(private map: (value: T1) => T2) { + + } +} + +class B extends A { + constructor() { super(value => String(value)); } +} \ No newline at end of file diff --git a/tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts b/tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts new file mode 100644 index 00000000000..c09fb37db2d --- /dev/null +++ b/tests/cases/compiler/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts @@ -0,0 +1,10 @@ + +class A { + constructor(private map: (value: T1) => T2) { + + } +} + +class B extends A { + constructor() { super(value => String(value)); } +} \ No newline at end of file diff --git a/tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts b/tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts new file mode 100644 index 00000000000..99755d87fbf --- /dev/null +++ b/tests/cases/compiler/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.ts @@ -0,0 +1,10 @@ + +class A { + constructor(private map: (value: number) => string) { + + } +} + +class B extends A { + constructor() { super(value => String(value)); } +} \ No newline at end of file diff --git a/tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts b/tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts new file mode 100644 index 00000000000..5f030bd5562 --- /dev/null +++ b/tests/cases/compiler/superCallFromClassThatHasNoBaseType1.ts @@ -0,0 +1,10 @@ + +class A { + constructor(private map: (value: number) => string) { + + } +} + +class B { + constructor() { super(value => String(value)); } +} \ No newline at end of file diff --git a/tests/cases/compiler/superCallFromFunction1.ts b/tests/cases/compiler/superCallFromFunction1.ts new file mode 100644 index 00000000000..81874204e1a --- /dev/null +++ b/tests/cases/compiler/superCallFromFunction1.ts @@ -0,0 +1,4 @@ + +function foo() { + super(value => String(value)); +} \ No newline at end of file diff --git a/tests/cases/compiler/superNewCall1.ts b/tests/cases/compiler/superNewCall1.ts new file mode 100644 index 00000000000..b3792d55221 --- /dev/null +++ b/tests/cases/compiler/superNewCall1.ts @@ -0,0 +1,12 @@ + +class A { + constructor(private map: (value: T1) => T2) { + + } +} + +class B extends A { + constructor() { + new super(value => String(value)); + } +} \ No newline at end of file