From 319ff614a0e824f8f2f4d4b67179883813c40d80 Mon Sep 17 00:00:00 2001
From: Ron Buckton <rbuckton@microsoft.com>
Date: Fri, 12 Feb 2016 15:07:33 -0800
Subject: [PATCH] PR Feedback

---
 src/compiler/binder.ts    | 33 ++++++++++++++++++---------------
 src/compiler/utilities.ts |  4 ++++
 2 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index d1101ad57e..9c1e0cfe4b 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1962,16 +1962,20 @@ namespace ts {
                         transformFlags = TransformFlags.AssertTypeScript;
                     }
                 }
+
                 break;
 
             case SyntaxKind.ExpressionStatement:
-                // if (node.flags & NodeFlags.Generated) {
-                //     let expression = (<ExpressionStatement>node).expression;
-                //     if (expression.kind === SyntaxKind.CallExpression
-                //         && (<CallExpression>expression).expression.kind === SyntaxKind.SuperKeyword) {
-                //         transformFlags |= TransformFlags.AssertES6;
-                //     }
-                // }
+                if (nodeIsSynthesized(node)) {
+                    const expression = (<ExpressionStatement>node).expression;
+                    if (nodeIsSynthesized(expression)
+                        && isCallExpression(expression)
+                        && expression.expression.kind === SyntaxKind.SuperKeyword) {
+                        // A synthesized call to `super` should be transformed to a cleaner emit
+                        // when transpiling to ES5/3.
+                        transformFlags |= TransformFlags.AssertES6;
+                    }
+                }
 
                 break;
 
@@ -2082,17 +2086,16 @@ namespace ts {
 
             case SyntaxKind.VariableDeclarationList:
                 // If a VariableDeclarationList is `let` or `const`, then it is ES6 syntax.
-                if (node.flags & NodeFlags.Let
-                    || node.flags & NodeFlags.Const) {
+                if (node.flags & NodeFlags.BlockScoped) {
                     transformFlags |= TransformFlags.AssertES6;
                 }
 
                 break;
 
             case SyntaxKind.VariableStatement:
-                // If a VariableStatement is exported, then it is ES6 syntax.
+                // If a VariableStatement is exported, then it is either ES6 or TypeScript syntax.
                 if (node.flags & NodeFlags.Export) {
-                    transformFlags |= TransformFlags.AssertES6;
+                    transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
                 }
 
                 break;
@@ -2114,13 +2117,13 @@ namespace ts {
                 break;
 
             case SyntaxKind.HeritageClause:
-                // An `extends` HertiageClause is ES6 syntax.
                 if ((<HeritageClause>node).token === SyntaxKind.ExtendsKeyword) {
+                    // An `extends` HeritageClause is ES6 syntax.
                     transformFlags |= TransformFlags.AssertES6;
                 }
-
-                // An `implements` HeritageClause is TypeScript syntax.
-                else if ((<HeritageClause>node).token === SyntaxKind.ImplementsKeyword) {
+                else {
+                    // An `implements` HeritageClause is TypeScript syntax.
+                    Debug.assert((<HeritageClause>node).token === SyntaxKind.ImplementsKeyword);
                     transformFlags |= TransformFlags.AssertTypeScript;
                 }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 62f8359c82..15d2b4d671 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2640,6 +2640,10 @@ namespace ts {
         return node.kind === SyntaxKind.BinaryExpression;
     }
 
+    export function isCallExpression(node: Node): node is CallExpression {
+        return node.kind === SyntaxKind.CallExpression;
+    }
+
     export function isTemplate(node: Node): node is Template {
         const kind = node.kind;
         return kind === SyntaxKind.TemplateExpression