Class emit for ES6

src/compiler/parser.ts

@@ -613,7 +613,7 @@ module ts {
         // change the token touching it, we actually need to look back *at least* one token so
         // that the prior token sees that change.
         let maxLookahead = 1;
-
+
         let start = changeRange.span.start;
 
         // the first iteration aligns us with the change start. subsequent iteration move us to
@@ -831,7 +831,7 @@ module ts {
         // will immediately bail out of walking any subtrees when we can see that their parents
         // are already correct.
         let result = parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true)
-
+
         return result;
     }
 
@@ -1986,7 +1986,7 @@ module ts {
             //
             //      let v = new List < A, B >()
             //
-            // then we have a problem.  "v = new List<A" doesn't intersect the change range, so we
+            // then we have a problem.  "v = new List<A" doesn't intersect the change range, so we
             // start reparsing at "B" and we completely fail to handle this properly.
             //
             // In order to prevent this, we do not allow a variable declarator to be reused if it
@@ -3008,9 +3008,9 @@ module ts {
             Debug.assert(token === SyntaxKind.EqualsGreaterThanToken, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
 
             let node = <ArrowFunction>createNode(SyntaxKind.ArrowFunction, identifier.pos);
-
+
             let parameter = <ParameterDeclaration>createNode(SyntaxKind.Parameter, identifier.pos);
-            parameter.name = identifier;
+            parameter.name = identifier;
             finishNode(parameter);
 
             node.parameters = <NodeArray<ParameterDeclaration>>[parameter];
@@ -3140,8 +3140,8 @@ module ts {
 
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction {
             let node = <ArrowFunction>createNode(SyntaxKind.ArrowFunction);
-            // Arrow functions are never generators.
-            //
+            // Arrow functions are never generators.
+            //
             // If we're speculatively parsing a signature for a parenthesized arrow function, then
             // we have to have a complete parameter list.  Otherwise we might see something like
             // a => (b => c)
@@ -3206,7 +3206,7 @@ module ts {
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             let node = <ConditionalExpression>createNode(SyntaxKind.ConditionalExpression, leftOperand.pos);
-            node.condition = leftOperand;
+            node.condition = leftOperand;
             node.questionToken = questionToken;
             node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher);
             node.colonToken = parseExpectedToken(SyntaxKind.ColonToken, /*reportAtCurrentPosition:*/ false,
@@ -4526,7 +4526,13 @@ module ts {
         }
 
         function parseClassDeclaration(fullStart: number, modifiers: ModifiersArray): ClassDeclaration {
-            let node = <ClassDeclaration>createNode(SyntaxKind.ClassDeclaration, fullStart);
+            // In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code
+            let savedStrictModeContext = inStrictModeContext();
+            if (languageVersion >= ScriptTarget.ES6) {
+                setStrictModeContext(true);
+            }
+
+            var node = <ClassDeclaration>createNode(SyntaxKind.ClassDeclaration, fullStart);
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ClassKeyword);
             node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier();
@@ -4546,7 +4552,10 @@ module ts {
             else {
                 node.members = createMissingList<ClassElement>();
             }
-            return finishNode(node);
+
+            var finishedNode = finishNode(node);
+            setStrictModeContext(savedStrictModeContext);
+            return finishedNode;
         }
 
         function parseHeritageClauses(isClassHeritageClause: boolean): NodeArray<HeritageClause> {
@@ -4774,7 +4783,7 @@ module ts {
             // walker.
             let result = parseExpression();
             // Ensure the string being required is in our 'identifier' table.  This will ensure
-            // that features like 'find refs' will look inside this file when search for its name.
+            // that features like 'find refs' will look inside this file when search for its name.
             if (result.kind === SyntaxKind.StringLiteral) {
                 internIdentifier((<LiteralExpression>result).text);
             }

tests/baselines/reference/callWithSpreadES6.js

@@ -55,12 +55,6 @@ var c = new C(1, 2, ...a);
 
 
 //// [callWithSpreadES6.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 __();
-};
 function foo(x, y, ...z) {
 }
 var a;
@@ -84,26 +78,23 @@ xa[1].foo(...[
     2,
     "abc"
 ]);
-var C = (function () {
-    function C(x, y, ...z) {
+class C {
+    constructor(x, y, ...z) {
         this.foo(x, y);
         this.foo(x, y, ...z);
     }
-    C.prototype.foo = function (x, y, ...z) {
-    };
-    return C;
-})();
-var D = (function (_super) {
-    __extends(D, _super);
-    function D() {
-        _super.call(this, 1, 2);
-        _super.call(this, 1, 2, ...a);
+    foo(x, y, ...z) {
     }
-    D.prototype.foo = function () {
-        _super.prototype.foo.call(this, 1, 2);
-        _super.prototype.foo.call(this, 1, 2, ...a);
-    };
-    return D;
-})(C);
+}
+class D extends C {
+    constructor() {
+        super(1, 2);
+        super(1, 2, ...a);
+    }
+    foo() {
+        super.foo(1, 2);
+        super.foo(1, 2, ...a);
+    }
+}
 // Only supported in when target is ES6
 var c = new C(1, 2, ...a);

tests/baselines/reference/computedPropertyNames12_ES6.js

@@ -20,12 +20,11 @@ class C {
 var s;
 var n;
 var a;
-var C = (function () {
-    function C() {
+class C {
+    constructor() {
         this[n] = n;
         this[s + n] = 2;
         this[`hello bye`] = 0;
     }
-    C[`hello ${a} bye`] = 0;
-    return C;
-})();
+}
+C[`hello ${a} bye`] = 0;

tests/baselines/reference/computedPropertyNames13_ES6.js

@@ -20,30 +20,27 @@ class C {
 var s;
 var n;
 var a;
-var C = (function () {
-    function C() {
-    }
-    C.prototype[s] = function () {
-    };
-    C.prototype[n] = function () {
-    };
-    C[s + s] = function () {
-    };
-    C.prototype[s + n] = function () {
-    };
-    C.prototype[+s] = function () {
-    };
-    C[""] = function () {
-    };
-    C.prototype[0] = function () {
-    };
-    C.prototype[a] = function () {
-    };
-    C[true] = function () {
-    };
-    C.prototype[`hello bye`] = function () {
-    };
-    C[`hello ${a} bye`] = function () {
-    };
-    return C;
-})();
+class C {
+    [s]() {
+    }
+    [n]() {
+    }
+    static [s + s]() {
+    }
+    [s + n]() {
+    }
+    [+s]() {
+    }
+    static [""]() {
+    }
+    [0]() {
+    }
+    [a]() {
+    }
+    static [true]() {
+    }
+    [`hello bye`]() {
+    }
+    static [`hello ${a} bye`]() {
+    }
+}

tests/baselines/reference/computedPropertyNames14_ES6.js

@@ -11,20 +11,17 @@ class C {
 
 //// [computedPropertyNames14_ES6.js]
 var b;
-var C = (function () {
-    function C() {
+class C {
+    [b]() {
     }
-    C.prototype[b] = function () {
-    };
-    C[true] = function () {
-    };
-    C.prototype[[]] = function () {
-    };
-    C[{}] = function () {
-    };
-    C.prototype[undefined] = function () {
-    };
-    C[null] = function () {
-    };
-    return C;
-})();
+    static [true]() {
+    }
+    [[]]() {
+    }
+    static [{}]() {
+    }
+    [undefined]() {
+    }
+    static [null]() {
+    }
+}

tests/baselines/reference/computedPropertyNames15_ES6.js

@@ -12,14 +12,11 @@ class C {
 var p1;
 var p2;
 var p3;
-var C = (function () {
-    function C() {
+class C {
+    [p1]() {
     }
-    C.prototype[p1] = function () {
-    };
-    C.prototype[p2] = function () {
-    };
-    C.prototype[p3] = function () {
-    };
-    return C;
-})();
+    [p2]() {
+    }
+    [p3]() {
+    }
+}

tests/baselines/reference/computedPropertyNames16_ES6.js

@@ -20,80 +20,33 @@ class C {
 var s;
 var n;
 var a;
-var C = (function () {
-    function C() {
+class C {
+    get [s]() {
+        return 0;
     }
-    Object.defineProperty(C.prototype, s, {
-        get: function () {
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, n, {
-        set: function (v) {
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C, s + s, {
-        get: function () {
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, s + n, {
-        set: function (v) {
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, +s, {
-        get: function () {
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C, "", {
-        set: function (v) {
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, 0, {
-        get: function () {
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, a, {
-        set: function (v) {
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C, true, {
-        get: function () {
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, `hello bye`, {
-        set: function (v) {
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(C.prototype, `hello ${a} bye`, {
-        get: function () {
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return C;
-})();
+    set [n](v) {
+    }
+    static get [s + s]() {
+        return 0;
+    }
+    set [s + n](v) {
+    }
+    get [+s]() {
+        return 0;
+    }
+    static set [""](v) {
+    }
+    get [0]() {
+        return 0;
+    }
+    set [a](v) {
+    }
+    static get [true]() {
+        return 0;
+    }
+    set [`hello bye`](v) {
+    }
+    get [`hello ${a} bye`]() {
+        return 0;
+    }
+}