Merge pull request microsoft#4124 from ShyykoSerhiy/fix-3991

Fix for "Error for missing 'super' call is misleading"

Author: DanielRosenwasser

src/compiler/checker.ts

@@ -10470,17 +10470,21 @@ namespace ts {
  return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).expression.kind === SyntaxKind.SuperKeyword;
  }
 
+ function containsSuperCallAsComputedPropertyName(n: Declaration): boolean {
+ return n.name && containsSuperCall(n.name);
+ }
+
  function containsSuperCall(n: Node): boolean {
  if (isSuperCallExpression(n)) {
  return true;
  }
- switch (n.kind) {
- case SyntaxKind.FunctionExpression:
- case SyntaxKind.FunctionDeclaration:
- case SyntaxKind.ArrowFunction:
- case SyntaxKind.ObjectLiteralExpression: return false;
- default: return forEachChild(n, containsSuperCall);
+ else if (isFunctionLike(n)) {
+ return false;
+ }
+ else if (isClassLike(n)) {
+ return forEach((<ClassLikeDeclaration>n).members, containsSuperCallAsComputedPropertyName);
  }
+ return forEachChild(n, containsSuperCall);
  }
 
  function markThisReferencesAsErrors(n: Node): void {

tests/baselines/reference/superCallInsideClassDeclaration.errors.txt

@@ -0,0 +1,29 @@
+tests/cases/compiler/superCallInsideClassDeclaration.ts(8,5): error TS2377: Constructors for derived classes must contain a 'super' call.
+
+
+==== tests/cases/compiler/superCallInsideClassDeclaration.ts (1 errors) ====
+ class A {
+ }
+ 
+ class C {
+ }
+ 
+ class B extends A {
+ constructor() {
+ ~~~~~~~~~~~~~~~
+ 
+ 
+ class D extends C {
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ constructor() {
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ super();
+ ~~~~~~~~~~~~~~~~~~~~~~~~
+ }
+ ~~~~~~~~~~~~~
+ }
+ ~~~~~~~~~
+ }
+ ~~~~~
+!!! error TS2377: Constructors for derived classes must contain a 'super' call.
+ }

tests/baselines/reference/superCallInsideClassDeclaration.js

@@ -0,0 +1,47 @@
+//// [superCallInsideClassDeclaration.ts]
+class A {
+}
+
+class C {
+}
+
+class B extends A {
+ constructor() {
+
+ class D extends C {
+ constructor() {
+ super();
+ }
+ }
+ }
+}
+
+//// [superCallInsideClassDeclaration.js]
+var __extends = (this && this.__extends) || function (d, b) {
+ for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var A = (function () {
+ function A() {
+ }
+ return A;
+})();
+var C = (function () {
+ function C() {
+ }
+ return C;
+})();
+var B = (function (_super) {
+ __extends(B, _super);
+ function B() {
+ var D = (function (_super) {
+ __extends(D, _super);
+ function D() {
+ _super.call(this);
+ }
+ return D;
+ })(C);
+ }
+ return B;
+})(A);

tests/baselines/reference/superCallInsideClassExpression.errors.txt

@@ -0,0 +1,29 @@
+tests/cases/compiler/superCallInsideClassExpression.ts(8,5): error TS2377: Constructors for derived classes must contain a 'super' call.
+
+
+==== tests/cases/compiler/superCallInsideClassExpression.ts (1 errors) ====
+ class A {
+ }
+ 
+ class C {
+ }
+ 
+ class B extends A {
+ constructor() {
+ ~~~~~~~~~~~~~~~
+ 
+ 
+ var D = class extends C {
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ constructor() {
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ super();
+ ~~~~~~~~~~~~~~~~~~~~~~~~
+ }
+ ~~~~~~~~~~~~~
+ }
+ ~~~~~~~~~
+ }
+ ~~~~~
+!!! error TS2377: Constructors for derived classes must contain a 'super' call.
+ }

tests/baselines/reference/superCallInsideClassExpression.js

@@ -0,0 +1,47 @@
+//// [superCallInsideClassExpression.ts]
+class A {
+}
+
+class C {
+}
+
+class B extends A {
+ constructor() {
+
+ var D = class extends C {
+ constructor() {
+ super();
+ }
+ }
+ }
+}
+
+//// [superCallInsideClassExpression.js]
+var __extends = (this && this.__extends) || function (d, b) {
+ for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var A = (function () {
+ function A() {
+ }
+ return A;
+})();
+var C = (function () {
+ function C() {
+ }
+ return C;
+})();
+var B = (function (_super) {
+ __extends(B, _super);
+ function B() {
+ var D = (function (_super) {
+ __extends(class_1, _super);
+ function class_1() {
+ _super.call(this);
+ }
+ return class_1;
+ })(C);
+ }
+ return B;
+})(A);

tests/baselines/reference/superCallInsideObjectLiteralExpression.js

@@ -0,0 +1,36 @@
+//// [superCallInsideObjectLiteralExpression.ts]
+class A {
+ foo() {
+ }
+}
+
+class B extends A {
+ constructor() {
+ var x = {
+ x: super()
+ }
+ }
+}
+
+//// [superCallInsideObjectLiteralExpression.js]
+var __extends = (this && this.__extends) || function (d, b) {
+ for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var A = (function () {
+ function A() {
+ }
+ A.prototype.foo = function () {
+ };
+ return A;
+})();
+var B = (function (_super) {
+ __extends(B, _super);
+ function B() {
+ var x = {
+ x: _super.call(this)
+ };
+ }
+ return B;
+})(A);

tests/baselines/reference/superCallInsideObjectLiteralExpression.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/compiler/superCallInsideObjectLiteralExpression.ts ===
+class A {
+>A : Symbol(A, Decl(superCallInsideObjectLiteralExpression.ts, 0, 0))
+
+ foo() {
+>foo : Symbol(foo, Decl(superCallInsideObjectLiteralExpression.ts, 0, 9))
+ }
+}
+
+class B extends A {
+>B : Symbol(B, Decl(superCallInsideObjectLiteralExpression.ts, 3, 1))
+>A : Symbol(A, Decl(superCallInsideObjectLiteralExpression.ts, 0, 0))
+
+ constructor() {
+ var x = {
+>x : Symbol(x, Decl(superCallInsideObjectLiteralExpression.ts, 7, 11))
+
+ x: super()
+>x : Symbol(x, Decl(superCallInsideObjectLiteralExpression.ts, 7, 17))
+>super : Symbol(A, Decl(superCallInsideObjectLiteralExpression.ts, 0, 0))
+ }
+ }
+}

tests/baselines/reference/superCallInsideObjectLiteralExpression.types

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/superCallInsideObjectLiteralExpression.ts ===
+class A {
+>A : A
+
+ foo() {
+>foo : () => void
+ }
+}
+
+class B extends A {
+>B : B
+>A : A
+
+ constructor() {
+ var x = {
+>x : { x: void; }
+>{ x: super() } : { x: void; }
+
+ x: super()
+>x : void
+>super() : void
+>super : typeof A
+ }
+ }
+}

tests/cases/compiler/superCallInsideClassDeclaration.ts

@@ -0,0 +1,16 @@
+class A {
+}
+
+class C {
+}
+
+class B extends A {
+ constructor() {
+
+ class D extends C {
+ constructor() {
+ super();
+ }
+ }
+ }
+}

tests/cases/compiler/superCallInsideClassExpression.ts

@@ -0,0 +1,16 @@
+class A {
+}
+
+class C {
+}
+
+class B extends A {
+ constructor() {
+
+ var D = class extends C {
+ constructor() {
+ super();
+ }
+ }
+ }
+}