From dd37866fdb09a32a21da1ce1ec55643f80db80f0 Mon Sep 17 00:00:00 2001 From: Ingvar Stepanyan Date: Fri, 25 Jul 2014 16:38:34 +0300 Subject: [PATCH] Added backward-compatible test that object properties have type of "Property". (Better fix for Constellation/estraverse#4, Constellation/escodegen#80 and similar bugs) --- index.html | 574 ++++++++++++++++++++++++++++++++++++-------------- test/tests.js | 26 +++ 2 files changed, 441 insertions(+), 159 deletions(-) diff --git a/index.html b/index.html index aed3cb67cd..ff59372d05 100644 --- a/index.html +++ b/index.html @@ -142,7 +142,8 @@ entered.

end position.

  var lastStart, lastEnd, lastEndLoc;

This is the parser's state. inFunction is used to reject return statements outside of functions, labels to verify that break and continue have somewhere to jump to, and strict -indicates whether strict mode is on.

  var inFunction, labels, strict;

This function is used to raise exceptions on parse errors. It +indicates whether strict mode is on.

  var inFunction, labels, strict;

This counter is used for checking that arrow expressions did +not contain nested parentheses in argument list.

  var metParenL;

This function is used to raise exceptions on parse errors. It takes an offset integer (into the current input) to indicate the location of the error, attaches the position to the end of the error message, and then raises a SyntaxError with that @@ -152,12 +153,12 @@ message.

var err = new SyntaxError(message); err.pos = pos; err.loc = loc; err.raisedAt = tokPos; throw err; - }

Reused empty array added for node fields that are always empty.

  var empty = [];

Token types

                                                                                   
                                
               
The assignment of fine-grained, information-carrying type objects
+  }
                                                                                   
                                
               
Reused empty array added for node fields that are always empty.
                                         
  var empty = [];
                                                                                   
                                
               
Token types
                                         
                                                                                   
                                
               
The assignment of fine-grained, information-carrying type objects
 allows the tokenizer to store the information it has about a
-token in a way that is very cheap for the parser to look up.
                                         
                                                                                   
                                
               
All token type variables start with an underscore, to make them
-easy to recognize.
                                         
                                                                                   
                                
               
These are the general types. The type property is only used to
+token in a way that is very cheap for the parser to look up.
                                         
                                                                                   
                                
               
All token type variables start with an underscore, to make them
+easy to recognize.
                                         
                                                                                   
                                
               
These are the general types. The type property is only used to
 make them recognizeable when debugging.
                                         
  var _num = {type: "num"}, _regexp = {type: "regexp"}, _string = {type: "string"};
-  var _name = {type: "name"}, _eof = {type: "eof"};
                                                                                   
                                
               
Keyword tokens. The keyword property (also used in keyword-like
+  var _name = {type: "name"}, _eof = {type: "eof"};                                                                                   
                                
               
Keyword tokens. The keyword property (also used in keyword-like
 operators) indicates that the token originated from an
 identifier-like word, which is used when parsing property names.

 
@@ -176,10 +177,12 @@ continue jumps to that label.
                          var _throw = {keyword: "throw", beforeExpr: true}, _try = {keyword: "try"}, _var = {keyword: "var"};
   var _let = {keyword: "let"}, _const = {keyword: "const"};
   var _while = {keyword: "while", isLoop: true}, _with = {keyword: "with"}, _new = {keyword: "new", beforeExpr: true};
-  var _this = {keyword: "this"};                                                                                   
                                
               
The keywords that denote values.
                                         
  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
-  var _false = {keyword: "false", atomValue: false};
                                                                                   
                                
               
Some keywords are treated as regular operators. in sometimes
+  var _this = {keyword: "this"};
+  var _class = {keyword: "class"}, _extends = {keyword: "extends", beforeExpr: true}, _static = {keyword: "static"};                                                                                   
                                
               
The keywords that denote values.
                                         
  var _null = {keyword: "null", atomValue: null}, _true = {keyword: "true", atomValue: true};
+  var _false = {keyword: "false", atomValue: false};
                                                                                   
                                
               
Some keywords are treated as regular operators. in sometimes
 (when parsing for) needs to be tested against specifically, so
-we assign a variable name to it for quick comparing.
                                         
  var _in = {keyword: "in", binop: 7, beforeExpr: true};
                                                                                   
                                
               
Map keyword names to token types.
                                         
  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
+we assign a variable name to it for quick comparing.
                                         
  var _in = {keyword: "in", binop: 7, beforeExpr: true};
+  var _of = {keyword: "of", beforeExpr: true};
                                                                                   
                                
               
Map keyword names to token types.
                                         
  var keywordTypes = {"break": _break, "case": _case, "catch": _catch,
                       "continue": _continue, "debugger": _debugger, "default": _default,
                       "do": _do, "else": _else, "finally": _finally, "for": _for,
                       "function": _function, "if": _if, "return": _return, "switch": _switch,
@@ -189,10 +192,12 @@ we assign a variable name to it for quick comparing.
             
                       "instanceof": {keyword: "instanceof", binop: 7, beforeExpr: true}, "this": _this,
                       "typeof": {keyword: "typeof", prefix: true, beforeExpr: true},
                       "void": {keyword: "void", prefix: true, beforeExpr: true},
-                      "delete": {keyword: "delete", prefix: true, beforeExpr: true}};
                                                                                   
                                
               
Punctuation token types. Again, the type property is purely for debugging.
                                         
  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
+                      "delete": {keyword: "delete", prefix: true, beforeExpr: true},
+                      "class": _class, "extends": _extends, "static": _static, "of": _of};
                                                                                   
                                
               
Punctuation token types. Again, the type property is purely for debugging.
                                         
  var _bracketL = {type: "[", beforeExpr: true}, _bracketR = {type: "]"}, _braceL = {type: "{", beforeExpr: true};
   var _braceR = {type: "}"}, _parenL = {type: "(", beforeExpr: true}, _parenR = {type: ")"};
   var _comma = {type: ",", beforeExpr: true}, _semi = {type: ";", beforeExpr: true};
-  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _ellipsis = {type: "..."}, _question = {type: "?", beforeExpr: true};
                                                                                   
                                
               
Operators. These carry several kinds of properties to help the
+  var _colon = {type: ":", beforeExpr: true}, _dot = {type: "."}, _ellipsis = {type: "..."}, _question = {type: "?", beforeExpr: true};
+  var _arrow = {type: "=>", beforeExpr: true};
                                                                                   
                                
               
Operators. These carry several kinds of properties to help the
 parser use them properly (the presence of these properties is
 what categorizes them as operators).

 
@@ -218,12 +223,12 @@ in AssignmentExpression nodes.
                          var _relational = {binop: 7, beforeExpr: true};
   var _bitShift = {binop: 8, beforeExpr: true};
   var _plusMin = {binop: 9, prefix: true, beforeExpr: true};
-  var _multiplyModulo = {binop: 10, beforeExpr: true};                                                                                   
                                
               
Provide access to the token types for external users of the
+  var _multiplyModulo = {binop: 10, beforeExpr: true};                                                                                   
                                
               
Provide access to the token types for external users of the
 tokenizer.
                                         
  exports.tokTypes = {bracketL: _bracketL, bracketR: _bracketR, braceL: _braceL, braceR: _braceR,
                       parenL: _parenL, parenR: _parenR, comma: _comma, semi: _semi, colon: _colon,
                       dot: _dot, ellipsis: _ellipsis, question: _question, slash: _slash, eq: _eq,
                       name: _name, eof: _eof, num: _num, regexp: _regexp, string: _string};
-  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];
                                                                                   
                                
               
This is a trick taken from Esprima. It turns out that, on
+  for (var kw in keywordTypes) exports.tokTypes["_" + kw] = keywordTypes[kw];                                                                                   
                                
               
This is a trick taken from Esprima. It turns out that, on
 non-Chrome browsers, to check whether a string is in a set, a
 predicate containing a big ugly switch statement is faster than
 a regular expression, and on Chrome the two are about on par.
@@ -246,7 +251,7 @@ predicate from a space-separated string of words.

       f += "switch(str){";
       for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
       f += "return true}return false;";
-    }                                                                                   
                                
               
When there are more than three length categories, an outer
+    }                                                                                   
                                
               
When there are more than three length categories, an outer
 switch first dispatches on the lengths, to save on comparisons.
                                         
    if (cats.length > 3) {
       cats.sort(function(a, b) {return b.length - a.length;});
       f += "switch(str.length){";
@@ -255,17 +260,17 @@ switch first dispatches on the lengths, to save on comparisons.

         f += "case " + cat[0].length + ":";
         compareTo(cat);
       }
-      f += "}";
                                                                                   
                                
               
Otherwise, simply generate a flat switch statement.
                                         
    } else {
+      f += "}";
                                                                                   
                                
               
Otherwise, simply generate a flat switch statement.
                                         
    } else {
       compareTo(words);
     }
     return new Function("str", f);
-  }
                                                                                   
                                
               
The ECMAScript 3 reserved word list.
                                         
  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
                                                                                   
                                
               
ECMAScript 5 reserved words.
                                         
  var isReservedWord5 = makePredicate("class enum extends super const export import");
                                                                                   
                                
               
The additional reserved words in strict mode.
                                         
  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
                                                                                   
                                
               
The forbidden variable names in strict mode.
                                         
  var isStrictBadIdWord = makePredicate("eval arguments");
                                                                                   
                                
               
And the keywords.
                                         
  var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
+  }
                                                                                   
                                
               
The ECMAScript 3 reserved word list.
                                         
  var isReservedWord3 = makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile");
                                                                                   
                                
               
ECMAScript 5 reserved words.
                                         
  var isReservedWord5 = makePredicate("class enum extends super const export import");
                                                                                   
                                
               
The additional reserved words in strict mode.
                                         
  var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
                                                                                   
                                
               
The forbidden variable names in strict mode.
                                         
  var isStrictBadIdWord = makePredicate("eval arguments");
                                                                                   
                                
               
And the keywords.
                                         
  var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
 
   var isEcma5AndLessKeyword = makePredicate(ecma5AndLessKeywords);
 
-  var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const");
+  var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const class extends static of");
 
-  var isKeyword = isEcma5AndLessKeyword;
                                                                                   
                                
               
Character categories
                                         
                                                                                   
                                
               
Big ugly regular expressions that match characters in the
+  var isKeyword = isEcma5AndLessKeyword;                                                                                   
                                
               
Character categories
                                         
                                                                                   
                                
               
Big ugly regular expressions that match characters in the
 whitespace, identifier, and identifier-start categories. These
 are only applied when a character is found to actually have a
 code point above 128.
@@ -273,14 +278,14 @@ Generated by tools/generate-identifier-regex.js.
             var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
   var nonASCIIidentifierChars = "\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19B0-\u19C0\u19C8\u19C9\u19D0-\u19D9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F1\uA900-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
   var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");                                                                                   
                                
               
Whether a single character denotes a newline.
                                         
  var newline = /[\n\r\u2028\u2029]/;
                                                                                   
                                
               
Matches a whole line break (where CRLF is considered a single
-line break). Used to count lines.
                                         
  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
                                                                                   
                                
               
Test whether a given character code starts an identifier.
                                         
  var isIdentifierStart = exports.isIdentifierStart = function(code) {
+  var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
                                                                                   
                                
               
Whether a single character denotes a newline.
                                         
  var newline = /[\n\r\u2028\u2029]/;
                                                                                   
                                
               
Matches a whole line break (where CRLF is considered a single
+line break). Used to count lines.
                                         
  var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
                                                                                   
                                
               
Test whether a given character code starts an identifier.
                                         
  var isIdentifierStart = exports.isIdentifierStart = function(code) {
     if (code < 65) return code === 36;
     if (code < 91) return true;
     if (code < 97) return code === 95;
     if (code < 123)return true;
     return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
-  };
                                                                                   
                                
               
Test whether a given character is part of an identifier.
                                         
  var isIdentifierChar = exports.isIdentifierChar = function(code) {
+  };
                                                                                   
                                
               
Test whether a given character is part of an identifier.
                                         
  var isIdentifierChar = exports.isIdentifierChar = function(code) {
     if (code < 48) return code === 36;
     if (code < 58) return true;
     if (code < 65) return false;
@@ -288,16 +293,17 @@ line break). Used to count lines.
                          if (code < 97) return code === 95;
     if (code < 123)return true;
     return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  };
                                                                                   
                                
               
Tokenizer
                                         
                                                                                   
                                
               
These are used when options.locations is on, for the
+  };                                                                                   
                                
               
Tokenizer
                                         
                                                                                   
                                
               
These are used when options.locations is on, for the
 tokStartLoc and tokEndLoc properties.
                                         
  function Position() {
     this.line = tokCurLine;
     this.column = tokPos - tokLineStart;
-  }
                                                                                   
                                
               
Reset the token state. Used at the start of a parse.
                                         
  function initTokenState() {
+  }
                                                                                   
                                
               
Reset the token state. Used at the start of a parse.
                                         
  function initTokenState() {
     tokCurLine = 1;
     tokPos = tokLineStart = 0;
     tokRegexpAllowed = true;
+    metParenL = 0;
     skipSpace();
-  }
                                                                                   
                                
               
Called at the end of every token. Sets tokEnd, tokVal, and
+  }                                                                                   
                                
               
Called at the end of every token. Sets tokEnd, tokVal, and
 tokRegexpAllowed, and skips the space after the token, so that
 the next one's tokStart will point at the right position.
                                         
  function finishToken(type, val) {
     tokEnd = tokPos;
@@ -337,7 +343,7 @@ the next one's tokStart will point at the right position.

     if (options.onComment)
       options.onComment(false, input.slice(start + 2, tokPos), start, tokPos,
                         startLoc, options.locations && new Position);
-  }
                                                                                   
                                
               
Called at the start of the parse and after every token. Skips
+  }                                                                                   
                                
               
Called at the start of the parse and after every token. Skips
 whitespace and comments, and.
                                         
  function skipSpace() {
     while (tokPos < inputLen) {
       var ch = input.charCodeAt(tokPos);
@@ -376,7 +382,7 @@ whitespace and comments, and.
                          break;
       }
     }
-  }
                                                                                   
                                
               
Token reading
                                         
                                                                                   
                                
               
This is the function that is called to fetch the next token. It
+  }                                                                                   
                                
               
Token reading
                                         
                                                                                   
                                
               
This is the function that is called to fetch the next token. It
 is somewhat obscure, because it works in character codes rather
 than characters, and because operator parsing has been inlined
 into it.

@@ -427,7 +433,7 @@ into it.

     var next = input.charCodeAt(tokPos + 1);
     if (next === code) {
       if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-          newline.test(input.slice(lastEnd, tokPos))) {                                                                                   
                                
               
A --> line comment
                                         
        tokPos += 3;
+          newline.test(input.slice(lastEnd, tokPos))) {
                                                                                   
                                
               
A --> line comment
                                         
        tokPos += 3;
         skipLineComment();
         skipSpace();
         return readToken();
@@ -447,7 +453,7 @@ into it.

       return finishOp(_bitShift, size);
     }
     if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-        input.charCodeAt(tokPos + 3) == 45) {
                                                                                   
                                
               
<!--, an XML-style comment that should be interpreted as a line comment
                                         
      tokPos += 4;
+        input.charCodeAt(tokPos + 3) == 45) {
                                                                                   
                                
               
<!--, an XML-style comment that should be interpreted as a line comment
                                         
      tokPos += 4;
       skipLineComment();
       skipSpace();
       return readToken();
@@ -457,16 +463,20 @@ into it.

     return finishOp(_relational, size);
   }
 
-  function readToken_eq_excl(code) { // '=!'
+  function readToken_eq_excl(code) { // '=!', '=>'
     var next = input.charCodeAt(tokPos + 1);
     if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+    if (code === 61 && next === 62 && options.ecmaVersion >= 6) { // '=>'
+      tokPos += 2;
+      return finishToken(_arrow);
+    }
     return finishOp(code === 61 ? _eq : _prefix, 1);
   }
 
   function getTokenFromCode(code) {
-    switch(code) {
                                                                                   
                                
               
The interpretation of a dot depends on whether it is followed
+    switch(code) {                                                                                   
                                
               
The interpretation of a dot depends on whether it is followed
 by a digit or another two dots.
                                         
    case 46: // '.'
-      return readToken_dot();
                                                                                   
                                
               
Punctuation tokens.
                                         
    case 40: ++tokPos; return finishToken(_parenL);
+      return readToken_dot();
                                                                                   
                                
               
Punctuation tokens.
                                         
    case 40: ++tokPos; return finishToken(_parenL);
     case 41: ++tokPos; return finishToken(_parenR);
     case 59: ++tokPos; return finishToken(_semi);
     case 44: ++tokPos; return finishToken(_comma);
@@ -475,9 +485,15 @@ by a digit or another two dots.
                          case 123: ++tokPos; return finishToken(_braceL);
     case 125: ++tokPos; return finishToken(_braceR);
     case 58: ++tokPos; return finishToken(_colon);
-    case 63: ++tokPos; return finishToken(_question);
                                                                                   
                                
               
'0x' is a hexadecimal number.
                                         
    case 48: // '0'
+    case 63: ++tokPos; return finishToken(_question);
+
+    case 48: // '0'
       var next = input.charCodeAt(tokPos + 1);
-      if (next === 120 || next === 88) return readHexNumber();
                                                                                   
                                
               
Anything else beginning with a digit is an integer, octal
+      if (next === 120 || next === 88) return readRadixNumber(16); // '0x', '0X' - hex number
+      if (options.ecmaVersion >= 6) {
+        if (next === 111 || next === 79) return readRadixNumber(8); // '0o', '0O' - octal number
+        if (next === 98 || next === 66) return readRadixNumber(2); // '0b', '0B' - binary number
+      }                                                                                   
                                
               
Anything else beginning with a digit is an integer, octal
 number, or float.
                                         
    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
       return readNumber(false);
                                                                                   
                                
               
Quotes produce strings.
                                         
    case 34: case 39: // '"', "'"
       return readString(code);
                                                                                   
                                
               
Operators are parsed inline in tiny state machines. '=' (61) is
@@ -580,10 +596,10 @@ will return null unless the integer has exactly len di
     return total;
   }
 
-  function readHexNumber() {
+  function readRadixNumber(radix) {
     tokPos += 2; // 0x
-    var val = readInt(16);
-    if (val == null) raise(tokStart + 2, "Expected hexadecimal number");
+    var val = readInt(radix);
+    if (val == null) raise(tokStart + 2, "Expected number in radix " + radix);
     if (isIdentifierStart(input.charCodeAt(tokPos))) raise(tokPos, "Identifier directly after number");
     return finishToken(_num, val);
   }                                                                                   
                                
               
Read an integer, octal integer, or floating-point number.
                                         
  function readNumber(startsWithDot) {
@@ -609,7 +625,26 @@ will return null unless the integer has exactly len di
     else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
     else val = parseInt(str, 8);
     return finishToken(_num, val);
-  }
                                                                                   
                                
               
Read a string value, interpreting backslash-escapes.
                                         
  function readString(quote) {
+  }
                                                                                   
                                
               
Read a string value, interpreting backslash-escapes.
                                         
  function readCodePoint() {
+    var ch = input.charCodeAt(tokPos), code;
+    
+    if (ch === 123) {
+      if (options.ecmaVersion < 6) unexpected();
+      ++tokPos;
+      code = readHexChar(input.indexOf('}', tokPos) - tokPos);
+      ++tokPos;
+      if (code > 0x10FFFF) unexpected();
+    } else {
+      code = readHexChar(4);
+    }
                                                                                   
                                
               
UTF-16 Encoding
                                         
    if (code <= 0xFFFF) {
+      return String.fromCharCode(code);
+    }
+    var cu1 = ((code - 0x10000) >> 10) + 0xD800;
+    var cu2 = ((code - 0x10000) & 1023) + 0xDC00;
+    return String.fromCharCode(cu1, cu2);
+  }
+
+  function readString(quote) {
     tokPos++;
     var out = "";
     for (;;) {
@@ -635,7 +670,7 @@ will return null unless the integer has exactly len di
           case 110: out += "\n"; break; // 'n' -> '\n'
           case 114: out += "\r"; break; // 'r' -> '\r'
           case 120: out += String.fromCharCode(readHexChar(2)); break; // 'x'
-          case 117: out += String.fromCharCode(readHexChar(4)); break; // 'u'
+          case 117: out += readCodePoint(); break; // 'u'
           case 85: out += String.fromCharCode(readHexChar(8)); break; // 'U'
           case 116: out += "\t"; break; // 't' -> '\t'
           case 98: out += "\b"; break; // 'b' -> '\b'
@@ -655,13 +690,13 @@ will return null unless the integer has exactly len di
         ++tokPos;
       }
     }
-  }
                                                                                   
                                
               
Used to read character escape sequences ('\x', '\u', '\U').
                                         
  function readHexChar(len) {
+  }
                                                                                   
                                
               
Used to read character escape sequences ('\x', '\u', '\U').
                                         
  function readHexChar(len) {
     var n = readInt(16, len);
     if (n === null) raise(tokStart, "Bad character escape sequence");
     return n;
-  }
                                                                                   
                                
               
Used to signal to callers of readWord1 whether the word
+  }                                                                                   
                                
               
Used to signal to callers of readWord1 whether the word
 contained any escape sequences. This is needed because words with
-escape sequences must not be interpreted as keywords.
                                         
  var containsEsc;
                                                                                   
                                
               
Read an identifier, and return it as a string. Sets containsEsc
+escape sequences must not be interpreted as keywords.
                                         
  var containsEsc;
                                                                                   
                                
               
Read an identifier, and return it as a string. Sets containsEsc
 to whether the word contained a '\u' escape.

 
 
Only builds up the word character-by-character when it actually
@@ -691,14 +726,14 @@ containeds an escape, as a micro-optimization.
             
       first = false;
     }
     return containsEsc ? word : input.slice(start, tokPos);
-  }                                                                                   
                                
               
Read an identifier or keyword token. Will check for reserved
+  }                                                                                   
                                
               
Read an identifier or keyword token. Will check for reserved
 words when necessary.
                                         
  function readWord() {
     var word = readWord1();
     var type = _name;
     if (!containsEsc && isKeyword(word))
       type = keywordTypes[word];
     return finishToken(type, word);
-  }
                                                                                   
                                
               
Parser
                                         
                                                                                   
                                
               
A recursive descent parser operates by defining functions for all
+  }                                                                                   
                                
               
Parser
                                         
                                                                                   
                                
               
A recursive descent parser operates by defining functions for all
 syntactic elements, and recursively calling those, each function
 advancing the input stream and returning an AST node. Precedence
 of constructs (for example, the fact that !x[1] means !(x[1])
@@ -712,12 +747,12 @@ way, it'll receive the node for x[1] already parsed, and wraps
 operator precedence, because it is much more compact than using
 the technique outlined above, which uses different, nesting
 functions to specify precedence, for all of the ten binary
-precedence levels that JavaScript defines.
                                         
                                                                                   
                                
               
Parser utilities
                                         
                                                                                   
                                
               
Continue to the next token.
                                         
  function next() {
+precedence levels that JavaScript defines.
                                         
                                                                                   
                                
               
Parser utilities
                                         
                                                                                   
                                
               
Continue to the next token.
                                         
  function next() {
     lastStart = tokStart;
     lastEnd = tokEnd;
     lastEndLoc = tokEndLoc;
     readToken();
-  }
                                                                                   
                                
               
Enter strict mode. Re-reads the next token to please pedantic
+  }
                                                                                   
                                
               
Enter strict mode. Re-reads the next token to please pedantic
 tests ("use strict"; 010; -- should fail).
                                         
  function setStrict(strct) {
     strict = strct;
     tokPos = tokStart;
@@ -729,7 +764,7 @@ tests ("use strict"; 010; -- should fail).
                          }
     skipSpace();
     readToken();
-  }
                                                                                   
                                
               
Start an AST node, attaching a start offset.
                                         
  function Node() {
+  }
                                                                                   
                                
               
Start an AST node, attaching a start offset.
                                         
  function Node() {
     this.type = null;
     this.start = tokStart;
     this.end = null;
@@ -752,7 +787,7 @@ tests ("use strict"; 010; -- should fail).
                          if (options.ranges)
       node.range = [tokStart, 0];
     return node;
-  }
                                                                                   
                                
               
Start a node whose start offset information should be based on
+  }                                                                                   
                                
               
Start a node whose start offset information should be based on
 the start of another node. For example, a binary operator node is
 only started after its left-hand side has already been parsed.
                                         
  function startNodeFrom(other) {
     var node = new Node();
@@ -765,7 +800,7 @@ only started after its left-hand side has already been parsed.
             <
       node.range = [other.range[0], 0];
 
     return node;
-  }
                                                                                   
                                
               
Finish an AST node, adding type and end properties.
                                         
  function finishNode(node, type) {
+  }
                                                                                   
                                
               
Finish an AST node, adding type and end properties.
                                         
  function finishNode(node, type) {
     node.type = type;
     node.end = lastEnd;
     if (options.locations)
@@ -773,34 +808,58 @@ only started after its left-hand side has already been parsed.
             <
     if (options.ranges)
       node.range[1] = lastEnd;
     return node;
-  }
                                                                                   
                                
               
Test whether a statement node is the string literal "use strict".
                                         
  function isUseStrict(stmt) {
+  }
                                                                                   
                                
               
Test whether a statement node is the string literal "use strict".
                                         
  function isUseStrict(stmt) {
     return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
       stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
                                                                                   
                                
               
Predicate that tests whether the next token is of the given
+  }                                                                                   
                                
               
Predicate that tests whether the next token is of the given
 type, and if yes, consumes it as a side effect.
                                         
  function eat(type) {
     if (tokType === type) {
       next();
       return true;
     }
-  }
                                                                                   
                                
               
Test whether a semicolon can be inserted at the current position.
                                         
  function canInsertSemicolon() {
+  }
                                                                                   
                                
               
Test whether a semicolon can be inserted at the current position.
                                         
  function canInsertSemicolon() {
     return !options.strictSemicolons &&
       (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
                                                                                   
                                
               
Consume a semicolon, or, failing that, see if we are allowed to
+  }                                                                                   
                                
               
Consume a semicolon, or, failing that, see if we are allowed to
 pretend that there is a semicolon at this position.
                                         
  function semicolon() {
     if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
                                                                                   
                                
               
Expect a token of a given type. If found, consume it, otherwise,
+  }                                                                                   
                                
               
Expect a token of a given type. If found, consume it, otherwise,
 raise an unexpected token error.
                                         
  function expect(type) {
     if (tokType === type) next();
     else unexpected();
-  }
                                                                                   
                                
               
Raise an unexpected token error.
                                         
  function unexpected() {
-    raise(tokStart, "Unexpected token");
-  }
                                                                                   
                                
               
Verify that a node is an lval — something that can be assigned
-to.
                                         
  function checkLVal(expr) {
-    if (expr.type !== "Identifier" && expr.type !== "MemberExpression")
-      raise(expr.start, "Assigning to rvalue");
-    if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name))
-      raise(expr.start, "Assigning to " + expr.name + " in strict mode");
-  }
                                                                                   
                                
               
Statement parsing
                                         
                                                                                   
                                
               
Parse a program. Initializes the parser, reads any number of
+  }                                                                                   
                                
               
Raise an unexpected token error.
                                         
  function unexpected(pos) {
+    raise(pos != null ? pos : tokStart, "Unexpected token");
+  }
                                                                                   
                                
               
Verify that a node is an lval — something that can be assigned
+to.
                                         
  function checkLVal(expr, isBinding) {
+    switch (expr.type) {
+      case "Identifier":
+        if (strict && isStrictBadIdWord(expr.name))
+          raise(expr.start, isBinding
+            ? "Binding " + expr.name + " in strict mode"
+            : "Assigning to " + expr.name + " in strict mode"
+          );
+        break;
+      
+      case "MemberExpression":
+        if (!isBinding) break;
+
+      case "ObjectPattern":
+        for (var i = 0; i < expr.properties.length; i++)
+          checkLVal(expr.properties[i].value, isBinding);
+        break;
+
+      case "ArrayPattern":
+        for (var i = 0; i < expr.elements.length; i++)
+          checkLVal(expr.elements[i], isBinding);
+        break;
+
+      case "SpreadElement":
+        break;
+
+      default:
+        raise(expr.start, "Assigning to rvalue");
+    }
+  }
                                                                                   
                                
               
Statement parsing
                                         
                                                                                   
                                
               
Parse a program. Initializes the parser, reads any number of
 statements, and wraps them in a Program node.  Optionally takes a
 program argument.  If present, the statements will be appended
 to its body instead of creating a new node.
                                         
  function parseTopLevel(program) {
@@ -821,7 +880,7 @@ to its body instead of creating a new node.
                          return finishNode(node, "Program");
   }
 
-  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
                                                                                   
                                
               
Parse a single statement.

+  var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};                                                                                   
                                
               
Parse a single statement.

 
 
If expecting a statement and finding a slash operator, parse a
 regular expression literal. This is to handle cases like
@@ -830,7 +889,7 @@ does not help.
                          
     if (tokType === _slash || tokType === _assign && tokVal == "/=")
       readToken(true);
 
-    var starttype = tokType, node = startNode();                                                                                   
                                
               
Most types of statements are recognized by the keyword they
+    var starttype = tokType, node = startNode();                                                                                   
                                
               
Most types of statements are recognized by the keyword they
 start with. Many are trivial to parse, some require a bit of
 complexity.
                                         
    switch (starttype) {
     case _break: case _continue: return parseBreakContinueStatement(node, starttype.keyword);
@@ -838,6 +897,7 @@ complexity.
                                         case _do: return parseDoStatement(node);
     case _for: return parseForStatement(node);
     case _function: return parseFunctionStatement(node);
+    case _class: return parseClass(node, true);
     case _if: return parseIfStatement(node);
     case _return: return parseReturnStatement(node);
     case _switch: return parseSwitchStatement(node);
@@ -847,7 +907,7 @@ complexity.
                                         case _while: return parseWhileStatement(node);
     case _with: return parseWithStatement(node);
     case _braceL: return parseBlock(); // no point creating a function for this
-    case _semi: return parseEmptyStatement(node);
                                                                                   
                                
               
If the statement does not start with a statement keyword or a
+    case _semi: return parseEmptyStatement(node);                                                                                   
                                
               
If the statement does not start with a statement keyword or a
 brace, it's an ExpressionStatement or LabeledStatement. We
 simply start parsing an expression, and afterwards, if the
 next token is a colon and the expression was a simple
@@ -867,7 +927,7 @@ Identifier node, we switch to interpreting it as a label.
             
     else {
       node.label = parseIdent();
       semicolon();
-    }                                                                                   
                                
               
Verify that there is an actual destination to break or
+    }                                                                                   
                                
               
Verify that there is an actual destination to break or
 continue to.
                                         
    for (var i = 0; i < labels.length; ++i) {
       var lab = labels[i];
       if (node.label == null || lab.name === node.label.name) {
@@ -895,29 +955,33 @@ continue to.
                                         <
     semicolon();
     return finishNode(node, "DoWhileStatement");
   }
-  
                                                                                   
                                
               
Disambiguating between a for and a for/in loop is
-non-trivial. Basically, we have to parse the init var
+                                                                                     
                                
               
Disambiguating between a for and a for/in or for/of
+loop is non-trivial. Basically, we have to parse the init var
 statement or expression, disallowing the in operator (see
 the second parameter to parseExpression), and then check
-whether the next token is in. When there is no init part
-(semicolon immediately after the opening parenthesis), it is
-a regular for loop.
                                         
  
+whether the next token is in or of. When there is no init
+part (semicolon immediately after the opening parenthesis), it
+is a regular for loop.
                                         
  
   function parseForStatement(node) {
     next();
     labels.push(loopLabel);
     expect(_parenL);
     if (tokType === _semi) return parseFor(node, null);
     if (tokType === _var || tokType === _let) {
-      var init = startNode(), varKind = tokType.keyword;
+      var init = startNode(), varKind = tokType.keyword, isLet = tokType === _let;
       next();
       parseVar(init, true, varKind);
       finishNode(init, "VariableDeclaration");
-      if (init.declarations.length === 1 && eat(_in))
+      if ((tokType === _in || tokType === _of) && init.declarations.length === 1 &&
+          !(isLet && init.declarations[0].init))
         return parseForIn(node, init);
       return parseFor(node, init);
     }
     var init = parseExpression(false, true);
-    if (eat(_in)) {checkLVal(init); return parseForIn(node, init);}
+    if (tokType === _in || tokType === _of) {
+      checkLVal(init);
+      return parseForIn(node, init);
+    }
     return parseFor(node, init);
   }
   
@@ -937,7 +1001,7 @@ a regular for loop.
                          function parseReturnStatement(node) {
     if (!inFunction && !options.allowReturnOutsideFunction)
       raise(tokStart, "'return' outside of function");
-    next();
                                                                                   
                                
               
In return (and break/continue), the keywords with
+    next();
                                                                                   
                                
               
In return (and break/continue), the keywords with
 optional arguments, we eagerly look for a semicolon or the
 possibility to insert one.
                                         
    if (eat(_semi) || canInsertSemicolon()) node.argument = null;
     else { node.argument = parseExpression(); semicolon(); }
@@ -949,7 +1013,7 @@ possibility to insert one.
                          
     node.discriminant = parseParenExpression();
     node.cases = [];
     expect(_braceL);
-    labels.push(switchLabel);
                                                                                   
                                
               
Statements under must be grouped (by label) in SwitchCase
+    labels.push(switchLabel);                                                                                   
                                
               
Statements under must be grouped (by label) in SwitchCase
 nodes. cur is used to keep the node that we are currently
 adding statements to.
                                         
    for (var cur, sawDefault; tokType != _braceR;) {
       if (tokType === _case || tokType === _default) {
@@ -1051,13 +1115,13 @@ adding statements to.
                          
     node.expression = expr;
     semicolon();
     return finishNode(node, "ExpressionStatement");
-  }
                                                                                   
                                
               
Used for constructs like switch and if that insist on
+  }                                                                                   
                                
               
Used for constructs like switch and if that insist on
 parentheses around their expression.
                                         
  function parseParenExpression() {
     expect(_parenL);
     var val = parseExpression();
     expect(_parenR);
     return val;
-  }
                                                                                   
                                
               
Parse a semicolon-enclosed block of statements, handling "use
+  }                                                                                   
                                
               
Parse a semicolon-enclosed block of statements, handling "use
 strict" declarations when allowStrict is true (used for
 function bodies).
                                         
  function parseBlock(allowStrict) {
     var node = startNode(), first = true, strict = false, oldStrict;
@@ -1074,7 +1138,7 @@ function bodies).
                          
     }
     if (strict && !oldStrict) setStrict(false);
     return finishNode(node, "BlockStatement");
-  }
                                                                                   
                                
               
Parse a regular for loop. The disambiguation code in
+  }                                                                                   
                                
               
Parse a regular for loop. The disambiguation code in
 parseStatement will already have parsed the init statement or
 expression.
                                         
  function parseFor(node, init) {
     node.init = init;
@@ -1086,31 +1150,33 @@ expression.
                                         node.body = parseStatement();
     labels.pop();
     return finishNode(node, "ForStatement");
-  }
                                                                                   
                                
               
Parse a for/in loop.
                                         
  function parseForIn(node, init) {
+  }
                                                                                   
                                
               
Parse a for/in and for/of loop, which are almost
+same from parser's perspective.
                                         
  function parseForIn(node, init) {
+    var type = tokType === _in ? "ForInStatement" : "ForOfStatement";
+    next();
     node.left = init;
     node.right = parseExpression();
     expect(_parenR);
     node.body = parseStatement();
     labels.pop();
-    return finishNode(node, "ForInStatement");
-  }
                                                                                   
                                
               
Parse a list of variable declarations.
                                         
  function parseVar(node, noIn, kind) {
+    return finishNode(node, type);
+  }
                                                                                   
                                
               
Parse a list of variable declarations.
                                         
  function parseVar(node, noIn, kind) {
     node.declarations = [];
     node.kind = kind;
     for (;;) {
       var decl = startNode();
-      decl.id = parseIdent();
-      if (strict && isStrictBadIdWord(decl.id.name))
-        raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+      decl.id = options.ecmaVersion >= 6 ? toAssignable(parseExprAtom()) : parseIdent();
+      checkLVal(decl.id, true);
       decl.init = eat(_eq) ? parseExpression(true, noIn) : (kind === _const.keyword ? unexpected() : null);
       node.declarations.push(finishNode(decl, "VariableDeclarator"));
       if (!eat(_comma)) break;
     }
     return node;
-  }
                                                                                   
                                
               
Expression parsing
                                         
                                                                                   
                                
               
These nest, from the most general expression type at the top to
+  }                                                                                   
                                
               
Expression parsing
                                         
                                                                                   
                                
               
These nest, from the most general expression type at the top to
 'atomic', nondivisible expression types at the bottom. Most of
 the functions will simply let the function(s) below them parse,
 and, if the syntactic construct they handle is present, wrap
-the AST node that the inner parser gave them in another node.
                                         
                                                                                   
                                
               
Parse a full expression. The arguments are used to forbid comma
+the AST node that the inner parser gave them in another node.
                                         
                                                                                   
                                
               
Parse a full expression. The arguments are used to forbid comma
 sequences (in argument lists, array literals, or object literals)
 or the in operator (in for loops initalization expressions).
                                         
  function parseExpression(noComma, noIn) {
     var expr = parseMaybeAssign(noIn);
@@ -1121,20 +1187,20 @@ or the in operator (in for loops initalization expressions).

       return finishNode(node, "SequenceExpression");
     }
     return expr;
-  }
                                                                                   
                                
               
Parse an assignment expression. This includes applications of
+  }                                                                                   
                                
               
Parse an assignment expression. This includes applications of
 operators like +=.
                                         
  function parseMaybeAssign(noIn) {
     var left = parseMaybeConditional(noIn);
     if (tokType.isAssign) {
       var node = startNodeFrom(left);
       node.operator = tokVal;
-      node.left = left;
+      node.left = tokVal === '=' ? toAssignable(left) : left;
+      checkLVal(left);
       next();
       node.right = parseMaybeAssign(noIn);
-      checkLVal(left);
       return finishNode(node, "AssignmentExpression");
     }
     return left;
-  }
                                                                                   
                                
               
Parse a ternary conditional (?:) operator.
                                         
  function parseMaybeConditional(noIn) {
+  }
                                                                                   
                                
               
Parse a ternary conditional (?:) operator.
                                         
  function parseMaybeConditional(noIn) {
     var expr = parseExprOps(noIn);
     if (eat(_question)) {
       var node = startNodeFrom(expr);
@@ -1145,9 +1211,9 @@ operators like +=.
                          return finishNode(node, "ConditionalExpression");
     }
     return expr;
-  }
                                                                                   
                                
               
Start the precedence parser.
                                         
  function parseExprOps(noIn) {
+  }
                                                                                   
                                
               
Start the precedence parser.
                                         
  function parseExprOps(noIn) {
     return parseExprOp(parseMaybeUnary(), -1, noIn);
-  }
                                                                                   
                                
               
Parse binary operators with the operator precedence parsing
+  }                                                                                   
                                
               
Parse binary operators with the operator precedence parsing
 algorithm. left is the left-hand side of the operator.
 minPrec provides context that allows the function to stop and
 defer further parser to one of its callers when it encounters an
@@ -1166,7 +1232,7 @@ operator that has a lower precedence than the set it is parsing.

       }
     }
     return left;
-  }                                                                                   
                                
               
Parse unary operators, both prefix and postfix.
                                         
  function parseMaybeUnary() {
+  }
                                                                                   
                                
               
Parse unary operators, both prefix and postfix.
                                         
  function parseMaybeUnary() {
     if (tokType.prefix) {
       var node = startNode(), update = tokType.isUpdate;
       node.operator = tokVal;
@@ -1191,7 +1257,7 @@ operator that has a lower precedence than the set it is parsing.

       expr = finishNode(node, "UpdateExpression");
     }
     return expr;
-  }
                                                                                   
                                
               
Parse call, dot, and []-subscript expressions.
                                         
  function parseExprSubscripts() {
+  }
                                                                                   
                                
               
Parse call, dot, and []-subscript expressions.
                                         
  function parseExprSubscripts() {
     return parseSubscripts(parseExprAtom());
   }
 
@@ -1215,7 +1281,7 @@ operator that has a lower precedence than the set it is parsing.

       node.arguments = parseExprList(_parenR, false);
       return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
     } else return base;
-  }
                                                                                   
                                
               
Parse an atomic expression — either a single token that is an
+  }                                                                                   
                                
               
Parse an atomic expression — either a single token that is an
 expression, an expression started by a keyword like function or
 new, or an expression wrapped in punctuation like (), [],
 or {}.
                                         
  function parseExprAtom() {
@@ -1224,8 +1290,14 @@ or {}.
                          
       var node = startNode();
       next();
       return finishNode(node, "ThisExpression");
+    
     case _name:
-      return parseIdent();
+      var id = parseIdent();
+      if (eat(_arrow)) {
+        return parseArrowExpression(startNodeFrom(id), [id]);
+      }
+      return id;
+      
     case _num: case _string: case _regexp:
       var node = startNode();
       node.value = tokVal;
@@ -1241,18 +1313,26 @@ or {}.
                          
       return finishNode(node, "Literal");
 
     case _parenL:
-      var tokStartLoc1 = tokStartLoc, tokStart1 = tokStart;
+      var node = startNode(), tokStartLoc1 = tokStartLoc, tokStart1 = tokStart, val;
       next();
-      var val = parseExpression();
+      var oldParenL = ++metParenL;
+      if (tokType !== _parenR) {
+        val = parseExpression();
+      }
+      expect(_parenR);
+      if (metParenL === oldParenL && eat(_arrow)) {
+        val = parseArrowExpression(node, !val ? [] : val.type === "SequenceExpression" ? val.expressions : [val]);
+      } else {
                                                                                   
                                
               
disallow '()' before everything but error
                                         
        if (!val) unexpected(lastStart);
+      }
       val.start = tokStart1;
-      val.end = tokEnd;
+      val.end = lastEnd;
       if (options.locations) {
         val.loc.start = tokStartLoc1;
-        val.loc.end = tokEndLoc;
+        val.loc.end = lastEndLoc;
+      }
+      if (options.ranges) {
+        val.range = [tokStart1, lastEnd];
       }
-      if (options.ranges)
-        val.range = [tokStart1, tokEnd];
-      expect(_parenR);
       return val;
 
     case _bracketL:
@@ -1269,13 +1349,19 @@ or {}.
                          
       next();
       return parseFunction(node, false);
 
+    case _class:
+      return parseClass(startNode(), false);
+
     case _new:
       return parseNew();
 
+    case _ellipsis:
+      return parseSpread();
+
     default:
       unexpected();
     }
-  }
                                                                                   
                                
               
New's precedence is slightly tricky. It must allow its argument
+  }                                                                                   
                                
               
New's precedence is slightly tricky. It must allow its argument
 to be a [] or dot subscript expression, but not a call — at
 least, not without wrapping it in parentheses. Thus, it uses the
                                         
  function parseNew() {
     var node = startNode();
@@ -1284,7 +1370,12 @@ least, not without wrapping it in parentheses. Thus, it uses the

     if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
     else node.arguments = empty;
     return finishNode(node, "NewExpression");
-  }
                                                                                   
                                
               
Parse an object literal.
                                         
  function parseObj() {
+  }
                                                                                   
                                
               
Parse spread element '...expr'
                                         
  function parseSpread() {
+    var node = startNode();
+    next();
+    node.argument = parseExpression(true);
+    return finishNode(node, "SpreadElement");
+  }
                                                                                   
                                
               
Parse an object literal.
                                         
  function parseObj() {
     var node = startNode(), first = true, sawGetSet = false;
     node.properties = [];
     next();
@@ -1294,85 +1385,211 @@ least, not without wrapping it in parentheses. Thus, it uses the

         if (options.allowTrailingCommas && eat(_braceR)) break;
       } else first = false;
 
-      var prop = {key: parsePropertyName()}, isGetSet = false, kind;
+      var prop = startNode(), kind;
+      if (options.ecmaVersion >= 6) {
+        prop.method = false;
+        prop.shorthand = false;
+      }
+      parsePropertyName(prop);
       if (eat(_colon)) {
         prop.value = parseExpression(true);
         kind = prop.kind = "init";
-      } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
+      } else if (options.ecmaVersion >= 6 && tokType === _parenL) {
+        var func = parseFunction(startNode(), false, true);
+        kind = prop.kind = "init";
+        prop.method = true;
+        prop.value = func;
+      } else if (options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
                  (prop.key.name === "get" || prop.key.name === "set")) {
-        isGetSet = sawGetSet = true;
+        sawGetSet = true;
         kind = prop.kind = prop.key.name;
-        prop.key = parsePropertyName();
+        parsePropertyName(prop);
         if (tokType !== _parenL) unexpected();
-        prop.value = parseFunction(startNode(), false);
-      } else unexpected();
                                                                                   
                                
               
getters and setters are not allowed to clash — either with
-each other or with an init property — and in strict mode,
-init properties are also not allowed to be repeated.
                                         
      if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
-        for (var i = 0; i < node.properties.length; ++i) {
-          var other = node.properties[i];
-          if (other.key.name === prop.key.name) {
-            var conflict = kind == other.kind || isGetSet && other.kind === "init" ||
-              kind === "init" && (other.kind === "get" || other.kind === "set");
-            if (conflict && !strict && kind === "init" && other.kind === "init") conflict = false;
-            if (conflict) raise(prop.key.start, "Redefinition of property");
-          }
-        }
-      }
-      node.properties.push(prop);
+        var func = parseFunction(startNode(), false, options.ecmaVersion >= 6);
+        prop.value = func;
+      } else if (options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+        kind = prop.kind = "init";
+        prop.value = prop.key;
+        prop.shorthand = true;
+      } else unexpected();
+
+      addProperty(node.properties, finishNode(prop, "Property"), sawGetSet, "init");
     }
     return finishNode(node, "ObjectExpression");
+  }
                                                                                   
                                
               
Add property to list with keeping in mind and checking that
+object/class getters and setters are not allowed to clash —
+either with each other or with an init property — and in
+strict mode, init properties are also not allowed to be repeated.
                                         
  function addProperty(props, current, sawGetSet, defaultKind) {
+    if (current.key.type === "Identifier" && (strict || sawGetSet)) {
+      var kind = current.kind, isGetSet = kind !== defaultKind;
+      for (var i = 0; i < props.length; ++i) {
+        var other = props[i];
+        if (other.key.name === current.key.name && other.static === current.static) {
+          var conflict = kind == other.kind || isGetSet && other.kind === defaultKind ||
+            kind === defaultKind && (other.kind !== defaultKind);
+          if (conflict && !strict && kind === defaultKind && other.kind === defaultKind) conflict = false;
+          if (conflict) raise(current.key.start, "Redefinition of property");
+        }
+      }
+    }
+    props.push(current);
   }
 
-  function parsePropertyName() {
-    if (tokType === _num || tokType === _string) return parseExprAtom();
-    return parseIdent(true);
-  }
                                                                                   
                                
               
Parse a function declaration or literal (depending on the
-isStatement parameter).
                                         
  function parseFunction(node, isStatement) {
-    if (tokType === _name) node.id = parseIdent();
-    else if (isStatement) unexpected();
-    else node.id = null;
+  function parsePropertyName(prop) {
+    if (options.ecmaVersion >= 6) {
+      if (eat(_bracketL)) {
+        prop.computed = true;
+        prop.key = parseExpression();
+        expect(_bracketR);
+        return;
+      } else {
+        prop.computed = false;
+      }
+    }
+    prop.key = (tokType === _num || tokType === _string) ? parseExprAtom() : parseIdent(true);
+  }
                                                                                   
                                
               
Initialize empty function node.
                                         
  function initFunction(node) {
+    node.id = null;
     node.params = [];
-    node.rest = null;
+    if (options.ecmaVersion >= 6) {
+      node.defaults = [];
+      node.rest = null;
+      node.generator = false;
+    }
+  }
                                                                                   
                                
               
Parse a function declaration or literal (depending on the
+isStatement parameter).
                                         
  function parseFunction(node, isStatement, allowExpressionBody) {
+    initFunction(node);
+    if (isStatement || tokType === _name) {
+      node.id = parseIdent();
+    }
+    parseFunctionParams(node);
+    parseFunctionBody(node, allowExpressionBody);
+    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  }
                                                                                   
                                
               
Parse arrow function expression with given parameters.
                                         
  function parseArrowExpression(node, params) {
+    initFunction(node);
+
+    var defaults = node.defaults, hasDefaults = false;
+    
+    for (var i = 0, lastI = params.length - 1; i <= lastI; i++) {
+      var param = params[i];
+
+      if (param.type === "AssignmentExpression" && param.operator === "=") {
+        hasDefaults = true;
+        params[i] = param.left;
+        defaults.push(param.right);
+      } else {
+        toAssignable(param, i === lastI);
+        defaults.push(null);
+        if (param.type === "SpreadElement") {
+          params.length--;
+          node.rest = param.argument;
+          break;
+        }
+      }
+    }
+
+    node.params = params;
+    if (!hasDefaults) node.defaults = [];
+
+    parseFunctionBody(node, true);
+    return finishNode(node, "ArrowFunctionExpression");
+  }
                                                                                   
                                
               
Parse function parameters.
                                         
  function parseFunctionParams(node) {
+    var defaults = [], hasDefaults = false;
+    
     expect(_parenL);
     for (;;) {
       if (eat(_parenR)) {
         break;
       } else if (options.ecmaVersion >= 6 && eat(_ellipsis)) {
-        node.rest = parseIdent();
+        node.rest = toAssignable(parseExprAtom());
+        checkSpreadAssign(node.rest);
         expect(_parenR);
         break;
       } else {
-        node.params.push(parseIdent());
+        node.params.push(options.ecmaVersion >= 6 ? toAssignable(parseExprAtom()) : parseIdent());
+        if (options.ecmaVersion >= 6 && tokVal === '=') {
+          next();
+          hasDefaults = true;
+          defaults.push(parseExpression(true));
+        }
         if (!eat(_comma)) {
           expect(_parenR);
           break;
         }
       }
-    }
                                                                                   
                                
               
Start a new scope with regard to labels and the inFunction
-flag (restore them to their old value afterwards).
                                         
    var oldInFunc = inFunction, oldLabels = labels;
-    inFunction = true; labels = [];
-    node.body = parseBlock(true);
-    inFunction = oldInFunc; labels = oldLabels;
                                                                                   
                                
               
If this is a strict mode function, verify that argument names
-are not repeated, and it does not try to bind the words eval
-or arguments.
                                         
    if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
                                                                                   
                                
               
Negative indices are used to reuse loop body for node.rest and node.id
                                         
      for (var i = -2, id; i < node.params.length; ++i) {
-        if (i >= 0) {
-          id = node.params[i];
-        } else if (i == -2) {
-          if (node.rest) id = node.rest;
-          else continue;
-        } else {
-          if (node.id) id = node.id;
-          else continue;
-        }
-        if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))
-          raise(id.start, "Defining '" + id.name + "' in strict mode");
-        if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)
-          raise(id.start, "Argument name clash in strict mode");
-      }
     }
 
-    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
                                                                                   
                                
               
Parses a comma-separated list of expressions, and returns them as
+    if (hasDefaults) node.defaults = defaults;
+  }                                                                                   
                                
               
Parse function body and check parameters.
                                         
  function parseFunctionBody(node, allowExpression) {
+    var isExpression = allowExpression && tokType !== _braceL;
+    
+    if (isExpression) {
+      node.body = parseExpression(true);
+      node.expression = true;
+    } else {
                                                                                   
                                
               
Start a new scope with regard to labels and the inFunction
+flag (restore them to their old value afterwards).
                                         
      var oldInFunc = inFunction, oldLabels = labels;
+      inFunction = true; labels = [];
+      node.body = parseBlock(true);
+      node.expression = false;
+      inFunction = oldInFunc; labels = oldLabels;
+    }
                                                                                   
                                
               
If this is a strict mode function, verify that argument names
+are not repeated, and it does not try to bind the words eval
+or arguments.
                                         
    if (strict || !isExpression && node.body.body.length && isUseStrict(node.body.body[0])) {
+      var nameHash = {};
+      if (node.id)
+        checkFunctionParam(node.id, nameHash);
+      for (var i = 0; i < node.params.length; i++)
+        checkFunctionParam(node.params[i], nameHash);
+      if (node.rest)
+        checkFunctionParam(node.rest, nameHash);
+    }
+  }
                                                                                   
                                
               
Verify that argument names are not repeated, and it does not
+try to bind the words eval or arguments.
                                         
  function checkFunctionParam(param, nameHash) {
+    switch (param.type) {
+      case "Identifier":
+        if (isStrictReservedWord(param.name) || isStrictBadIdWord(param.name))
+          raise(param.start, "Defining '" + param.name + "' in strict mode");
+        if (param.name in nameHash)
+          raise(param.start, "Argument name clash in strict mode");
+        nameHash[param.name] = true;
+        break;
+
+      case "ObjectPattern":
+        for (var i = 0; i < param.properties.length; i++)
+          checkFunctionParam(param.properties[i].value, nameHash);
+        break;
+
+      case "ArrayPattern":
+        for (var i = 0; i < param.elements.length; i++)
+          checkFunctionParam(param.elements[i], nameHash);
+        break;
+    }
+  }
                                                                                   
                                
               
Parse a class declaration or literal (depending on the
+isStatement parameter).
                                         
  
+  function parseClass(node, isStatement) {
+    next();
+    node.id = tokType === _name ? parseIdent() : isStatement ? unexpected() : null;
+    node.superClass = eat(_extends) ? parseExpression() : null;
+    var classBody = startNode(), sawGetSet = false;
+    classBody.body = [];
+    expect(_braceL);
+    while (!eat(_braceR)) {
+      var method = startNode();
+      method.static = !!eat(_static);
+      method.key = parseIdent(true);
+      if (method.key.type === "Identifier" && (method.key.name === "get" || method.key.name === "set") && tokType === _name) {
+        method.kind = method.key.name;
+        method.key = parseIdent(true);
+        sawGetSet = true;
+      } else {
+        method.kind = "";
+      }
+      method.value = parseFunction(startNode());
+      addProperty(classBody.body, finishNode(method, "MethodDefinition"), sawGetSet, "");
+      eat(_semi);
+    }
+    node.body = finishNode(classBody, "ClassBody");
+    return finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+  }
                                                                                   
                                
               
Parses a comma-separated list of expressions, and returns them as
 an array. close is the token type that ends the list, and
 allowEmpty can be turned on to allow subsequent commas with
 nothing in between them to be parsed as null (which is needed
@@ -1388,7 +1605,7 @@ for array literals).
                          
       else elts.push(parseExpression(true));
     }
     return elts;
-  }                                                                                   
                                
               
Parse the next token as an identifier. If liberal is true (used
+  }                                                                                   
                                
               
Parse the next token as an identifier. If liberal is true (used
 when parsing properties), it will also convert keywords into
 identifiers.
                                         
  function parseIdent(liberal) {
     var node = startNode();
@@ -1409,6 +1626,45 @@ identifiers.
                                         <
     tokRegexpAllowed = false;
     next();
     return finishNode(node, "Identifier");
+  }
                                                                                   
                                
               
Convert existing expression atom to assignable pattern
+if possible.
                                         
  function toAssignable(node, allowSpread) {
+    if (options.ecmaVersion >= 6 && node) {
+      switch (node.type) {
+        case "Identifier":
+        case "MemberExpression":
+          break;          
+
+        case "ObjectExpression":
+          node.type = "ObjectPattern";
+          for (var i = 0; i < node.properties.length; i++) {
+            var prop = node.properties[i];
+            if (prop.kind !== "init") unexpected(prop.key.start);
+            toAssignable(prop.value);
+          }
+          break;
+
+        case "ArrayExpression":
+          node.type = "ArrayPattern";
+          for (var i = 0, lastI = node.elements.length - 1; i <= lastI; i++) {
+            toAssignable(node.elements[i], i === lastI);
+          }
+          break;
+
+        case "SpreadElement":
+          if (allowSpread) {
+            toAssignable(node.argument);
+            checkSpreadAssign(node.argument);
+            break;
+          }
+
+        default:
+          unexpected(node.start);
+      }
+    }
+    return node;
+  }
                                                                                   
                                
               
Checks if node can be assignable spread argument.
                                         
  function checkSpreadAssign(node) {
+    if (node.type !== "Identifier" && node.type !== "ArrayPattern")
+      unexpected(node.start);
   }
 
 });
diff --git a/test/tests.js b/test/tests.js
index f7d9e0432a..2a0cda4b4c 100644
--- a/test/tests.js
+++ b/test/tests.js
@@ -1459,6 +1459,7 @@ test("x = { answer: 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "answer",
@@ -1562,6 +1563,7 @@ test("x = { if: 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "if",
@@ -1665,6 +1667,7 @@ test("x = { true: 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "true",
@@ -1768,6 +1771,7 @@ test("x = { false: 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "false",
@@ -1871,6 +1875,7 @@ test("x = { null: 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "null",
@@ -1974,6 +1979,7 @@ test("x = { \"answer\": 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Literal",
                 value: "answer",
@@ -2077,6 +2083,7 @@ test("x = { x: 1, x: 2 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "x",
@@ -2108,6 +2115,7 @@ test("x = { x: 1, x: 2 }", {
               kind: "init"
             },
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "x",
@@ -2211,6 +2219,7 @@ test("x = { get width() { return m_width } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "width",
@@ -2357,6 +2366,7 @@ test("x = { get undef() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "undef",
@@ -2475,6 +2485,7 @@ test("x = { get if() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "if",
@@ -2593,6 +2604,7 @@ test("x = { get true() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "true",
@@ -2711,6 +2723,7 @@ test("x = { get false() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "false",
@@ -2829,6 +2842,7 @@ test("x = { get null() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "null",
@@ -2947,6 +2961,7 @@ test("x = { get \"undef\"() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Literal",
                 value: "undef",
@@ -3065,6 +3080,7 @@ test("x = { get 10() {} }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Literal",
                 value: 10,
@@ -3183,6 +3199,7 @@ test("x = { set width(w) { m_width = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "width",
@@ -3372,6 +3389,7 @@ test("x = { set if(w) { m_if = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "if",
@@ -3561,6 +3579,7 @@ test("x = { set true(w) { m_true = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "true",
@@ -3750,6 +3769,7 @@ test("x = { set false(w) { m_false = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "false",
@@ -3939,6 +3959,7 @@ test("x = { set null(w) { m_null = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "null",
@@ -4128,6 +4149,7 @@ test("x = { set \"null\"(w) { m_null = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Literal",
                 value: "null",
@@ -4317,6 +4339,7 @@ test("x = { set 10(w) { m_null = w } }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Literal",
                 value: 10,
@@ -4506,6 +4529,7 @@ test("x = { get: 42 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "get",
@@ -4609,6 +4633,7 @@ test("x = { set: 43 }", {
           type: "ObjectExpression",
           properties: [
             {
+              type: "Property",
               key: {
                 type: "Identifier",
                 name: "set",
@@ -21734,6 +21759,7 @@ test("throw { message: \"Error\" }", {
         type: "ObjectExpression",
         properties: [
           {
+            type: "Property",
             key: {
               type: "Identifier",
               name: "message",