MiniJsParser: fix a regression + support computed props + add tests

lib/src/js/builder.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Utilities for building JS ASTs at runtime.  Contains a builder class
 // and a parser that parses part of the language.
 
 part of js_ast;
 
 
@@ skipping 1134 matching lines @@
   Expression parseExpression() {
     Expression expression = parseAssignment();
     while (acceptCategory(COMMA)) {
       Expression right = parseAssignment();
       expression = new Binary(',', expression, right);
     }
     return expression;
   }
 
   /** Parse a variable declaration list, with `var` or `let` [keyword] */
-  VariableDeclarationList parseVariableDeclarationList(String keyword)  {
+  VariableDeclarationList parseVariableDeclarationList(
+      String keyword, [String firstIdentifier])  {
     var initialization = [];
 
     do {
-      var declarator = parseVariableBinding();
+      var declarator;
+      if (firstIdentifier != null) {
+        declarator = new Identifier(firstIdentifier);
+        firstIdentifier = null;
+      } else {
+        declarator = parseVariableBinding();
+      }
+
       var initializer = acceptString("=") ? parseAssignment() : null;
       initialization.add(new VariableInitialization(declarator, initializer));
     } while (acceptCategory(COMMA));
 
     return new VariableDeclarationList(keyword, initialization);
   }
 
   VariableBinding parseVariableBinding() {
     switch (lastCategory) {
       case ALPHA:
@@ skipping 279 matching lines @@
             body);
       } else if (acceptString('of')) {
         Expression iterableExpression = parseAssignment();
         expectCategory(RPAREN);
         Statement body = parseStatement();
         return new ForOf(
             _createVariableDeclarationList(keyword, identifier),
             iterableExpression,
             body);
       }
-      var declarations = parseVariableDeclarationList(keyword);
+      var declarations = parseVariableDeclarationList(keyword, identifier);
       expectCategory(SEMICOLON);
       return finishFor(declarations);
     }
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
     return finishFor(init);
   }
 
   static VariableDeclarationList _createVariableDeclarationList(
@@ skipping 111 matching lines @@
    * are supported:
    *
    * - getter/setter names: `get #() { ... }`
    * - method names: `#() { ... }`
    * - property names: `#: ...`
    * - entire methods: `#`
    */
   Property parseMethodOrProperty({bool onlyMethods: false}) {
     bool isStatic = acceptString('static');
 
-    bool isGetter = false;
-    bool isSetter = false;
+    bool isGetter = lastToken == 'get';
+    bool isSetter = lastToken == 'set';
     Expression name = null;
-    bool propertyNameIsIdentifier = lastCategory == ALPHA;
+    if (isGetter || isSetter) {
+      var token = lastToken;
+      getToken();
+      if (lastCategory == COLON) {
+        // That wasn't a accessor but the 'get' or 'set' property: retropedal.
+        isGetter = isSetter = false;
+        name = new LiteralString('"$token"');
+      }
+    }
     if (acceptCategory(HASH)) {
       if (lastCategory != LPAREN && (onlyMethods || lastCategory != COLON)) {
         // Interpolated method
         var member = new InterpolatedMethod(parseHash());
         interpolatedValues.add(member);
         return member;
       }
       name = parseInterpolatedExpression();
     } else {
-      name = parsePropertyName();
-    }
-
-    // Allow get or set to be followed by another property name.
-    if (propertyNameIsIdentifier &&
-        (lastCategory == ALPHA || lastCategory == HASH)) {
-      LiteralString p = name;
-      isGetter = p.value == '"get"';
-      isSetter = p.value == '"set"';
-      if (isGetter || isSetter) {
-        name = parsePropertyName();
-      }
+      name ??= parsePropertyName();
     }
 
     if (!onlyMethods && acceptCategory(COLON)) {
       Expression value = parseAssignment();
       return new Property(name, value);
     } else {
       var fun = parseFun();
       return new Method(name, fun,
           isGetter: isGetter, isSetter: isSetter, isStatic: isStatic);
     }
@@ skipping 11 matching lines @@
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
       return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
 }