Skip outter expressions when checking for super keyword in binder

Author: weswigham

src/compiler/binder.ts

@@ -2742,14 +2742,13 @@ namespace ts {
     function computeCallExpression(node: CallExpression, subtreeFlags: TransformFlags) {
         let transformFlags = subtreeFlags;
         const expression = node.expression;
-        const expressionKind = expression.kind;
 
         if (node.typeArguments) {
             transformFlags |= TransformFlags.AssertTypeScript;
         }
 
         if (subtreeFlags & TransformFlags.ContainsSpread
-            || isSuperOrSuperProperty(expression, expressionKind)) {
+            || isSuperOrSuperProperty(expression)) {
             // If the this node contains a SpreadExpression, or is a super call, then it is an ES6
             // node.
             transformFlags |= TransformFlags.AssertES2015;
@@ -2769,8 +2768,9 @@ namespace ts {
         return transformFlags & ~TransformFlags.ArrayLiteralOrCallOrNewExcludes;
     }
 
-    function isSuperOrSuperProperty(node: Node, kind: SyntaxKind) {
-        switch (kind) {
+    function isSuperOrSuperProperty(node: Node) {
+        node = skipOuterExpressions(node);
+        switch (node.kind) {
             case SyntaxKind.SuperKeyword:
                 return true;
 

tests/baselines/reference/superAccessCastedCall.js

@@ -0,0 +1,54 @@
+//// [superAccessCastedCall.ts]
+class Foo {
+    bar(): void {}
+}
+
+class Bar extends Foo {
+    x: Number;
+
+    constructor() {
+        super();
+        this.x = 2;
+    }
+
+    bar() {
+        super.bar();
+        (super.bar as any)();
+    }
+} 
+
+let b = new Bar();
+b.bar()
+
+//// [superAccessCastedCall.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var Foo = /** @class */ (function () {
+    function Foo() {
+    }
+    Foo.prototype.bar = function () { };
+    return Foo;
+}());
+var Bar = /** @class */ (function (_super) {
+    __extends(Bar, _super);
+    function Bar() {
+        var _this = _super.call(this) || this;
+        _this.x = 2;
+        return _this;
+    }
+    Bar.prototype.bar = function () {
+        _super.prototype.bar.call(this);
+        _super.prototype.bar.call(this);
+    };
+    return Bar;
+}(Foo));
+var b = new Bar();
+b.bar();

tests/baselines/reference/superAccessCastedCall.symbols

@@ -0,0 +1,50 @@
+=== tests/cases/compiler/superAccessCastedCall.ts ===
+class Foo {
+>Foo : Symbol(Foo, Decl(superAccessCastedCall.ts, 0, 0))
+
+    bar(): void {}
+>bar : Symbol(Foo.bar, Decl(superAccessCastedCall.ts, 0, 11))
+}
+
+class Bar extends Foo {
+>Bar : Symbol(Bar, Decl(superAccessCastedCall.ts, 2, 1))
+>Foo : Symbol(Foo, Decl(superAccessCastedCall.ts, 0, 0))
+
+    x: Number;
+>x : Symbol(Bar.x, Decl(superAccessCastedCall.ts, 4, 23))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    constructor() {
+        super();
+>super : Symbol(Foo, Decl(superAccessCastedCall.ts, 0, 0))
+
+        this.x = 2;
+>this.x : Symbol(Bar.x, Decl(superAccessCastedCall.ts, 4, 23))
+>this : Symbol(Bar, Decl(superAccessCastedCall.ts, 2, 1))
+>x : Symbol(Bar.x, Decl(superAccessCastedCall.ts, 4, 23))
+    }
+
+    bar() {
+>bar : Symbol(Bar.bar, Decl(superAccessCastedCall.ts, 10, 5))
+
+        super.bar();
+>super.bar : Symbol(Foo.bar, Decl(superAccessCastedCall.ts, 0, 11))
+>super : Symbol(Foo, Decl(superAccessCastedCall.ts, 0, 0))
+>bar : Symbol(Foo.bar, Decl(superAccessCastedCall.ts, 0, 11))
+
+        (super.bar as any)();
+>super.bar : Symbol(Foo.bar, Decl(superAccessCastedCall.ts, 0, 11))
+>super : Symbol(Foo, Decl(superAccessCastedCall.ts, 0, 0))
+>bar : Symbol(Foo.bar, Decl(superAccessCastedCall.ts, 0, 11))
+    }
+} 
+
+let b = new Bar();
+>b : Symbol(b, Decl(superAccessCastedCall.ts, 18, 3))
+>Bar : Symbol(Bar, Decl(superAccessCastedCall.ts, 2, 1))
+
+b.bar()
+>b.bar : Symbol(Bar.bar, Decl(superAccessCastedCall.ts, 10, 5))
+>b : Symbol(b, Decl(superAccessCastedCall.ts, 18, 3))
+>bar : Symbol(Bar.bar, Decl(superAccessCastedCall.ts, 10, 5))
+

tests/baselines/reference/superAccessCastedCall.types

@@ -0,0 +1,59 @@
+=== tests/cases/compiler/superAccessCastedCall.ts ===
+class Foo {
+>Foo : Foo
+
+    bar(): void {}
+>bar : () => void
+}
+
+class Bar extends Foo {
+>Bar : Bar
+>Foo : Foo
+
+    x: Number;
+>x : Number
+>Number : Number
+
+    constructor() {
+        super();
+>super() : void
+>super : typeof Foo
+
+        this.x = 2;
+>this.x = 2 : 2
+>this.x : Number
+>this : this
+>x : Number
+>2 : 2
+    }
+
+    bar() {
+>bar : () => void
+
+        super.bar();
+>super.bar() : void
+>super.bar : () => void
+>super : Foo
+>bar : () => void
+
+        (super.bar as any)();
+>(super.bar as any)() : any
+>(super.bar as any) : any
+>super.bar as any : any
+>super.bar : () => void
+>super : Foo
+>bar : () => void
+    }
+} 
+
+let b = new Bar();
+>b : Bar
+>new Bar() : Bar
+>Bar : typeof Bar
+
+b.bar()
+>b.bar() : void
+>b.bar : () => void
+>b : Bar
+>bar : () => void
+

tests/cases/compiler/superAccessCastedCall.ts

@@ -0,0 +1,20 @@
+class Foo {
+    bar(): void {}
+}
+
+class Bar extends Foo {
+    x: Number;
+
+    constructor() {
+        super();
+        this.x = 2;
+    }
+
+    bar() {
+        super.bar();
+        (super.bar as any)();
+    }
+} 
+
+let b = new Bar();
+b.bar()