Merge pull request #4124 from ShyykoSerhiy/fix-3991

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

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

tests/cases/compiler/superCallInsideObjectLiteralExpression.ts

@@ -0,0 +1,12 @@
+class A {
+    foo() {
+    }
+}
+
+class B extends A {
+    constructor() {
+        var x = {
+            x: super()
+        }
+    }
+}