js_ast: implement rest/spread parsing

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 432 matching lines @@
   static const RPAREN = 7;
   static const LBRACE = 8;
   static const RBRACE = 9;
   static const LSQUARE = 10;
   static const RSQUARE = 11;
   static const COMMA = 12;
   static const QUERY = 13;
   static const COLON = 14;
   static const SEMICOLON = 15;
   static const ARROW = 16;
-  static const HASH = 17;
-  static const WHITESPACE = 18;
-  static const OTHER = 19;
+  static const ELLIPSIS = 17;
+  static const HASH = 18;
+  static const WHITESPACE = 19;
+  static const OTHER = 20;
 
   // Make sure that ]] is two symbols.
-  bool singleCharCategory(int category) => category >= DOT;
+  // TODO(jmesserly): => and ... are not single char tokens, should we change
+  // their numbers? It shouldn't matter because this is only called on values
+  // from the [CATEGORIES] table.
+  bool singleCharCategory(int category) => category > DOT;
 
   static String categoryToString(int cat) {
     switch (cat) {
       case NONE: return "NONE";
       case ALPHA: return "ALPHA";
       case NUMERIC: return "NUMERIC";
       case SYMBOL: return "SYMBOL";
       case ASSIGNMENT: return "ASSIGNMENT";
       case DOT: return "DOT";
       case LPAREN: return "LPAREN";
       case RPAREN: return "RPAREN";
       case LBRACE: return "LBRACE";
       case RBRACE: return "RBRACE";
       case LSQUARE: return "LSQUARE";
       case RSQUARE: return "RSQUARE";
       case STRING: return "STRING";
       case COMMA: return "COMMA";
       case QUERY: return "QUERY";
       case COLON: return "COLON";
       case SEMICOLON: return "SEMICOLON";
       case ARROW: return "ARROW";
+      case ELLIPSIS: return "ELLIPSIS";
       case HASH: return "HASH";
       case WHITESPACE: return "WHITESPACE";
       case OTHER: return "OTHER";
     }
     return "Unknown: $cat";
   }
 
   static const CATEGORIES = const <int>[
       OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER, OTHER,       // 0-7
       OTHER, WHITESPACE, WHITESPACE, OTHER, OTHER, WHITESPACE,      // 8-13
@@ skipping 31 matching lines @@
       '<': 8, '<=': 8, '>=': 8, '>': 8, 'in': 8, 'instanceof': 8,
       '<<': 7, '>>': 7, '>>>': 7,
       '+': 6, '-': 6,
       '*': 5, '/': 5, '%': 5
   };
   static final UNARY_OPERATORS =
       ['++', '--', '+', '-', '~', '!', 'typeof', 'void', 'delete', 'await']
         .toSet();
 
   static final ARROW_TOKEN = '=>';
+  static final ELLIPSIS_TOKEN = '...';
 
   static final OPERATORS_THAT_LOOK_LIKE_IDENTIFIERS =
       ['typeof', 'void', 'delete', 'in', 'instanceof', 'await'].toSet();
 
   static int category(int code) {
     if (code >= CATEGORIES.length) return OTHER;
     return CATEGORIES[code];
   }
 
   String getDelimited(int startPosition) {
@@ skipping 94 matching lines @@
       } while (!singleCharCategory(cat) &&
                (cat == newCat ||
                 (cat == ALPHA && newCat == NUMERIC) ||    // eg. level42.
                 (cat == NUMERIC && newCat == DOT)));      // eg. 3.1415
       lastCategory = cat;
       lastToken = src.substring(lastPosition, position);
       if (cat == NUMERIC) {
         double.parse(lastToken, (_) {
           error("Unparseable number");
         });
+      } else if (cat == DOT && lastToken.length > 1) {
+        if (lastToken == ELLIPSIS_TOKEN) {
+          lastCategory = ELLIPSIS;
+        } else {
+          error("Unknown operator");
+        }
       } else if (cat == SYMBOL) {
         if (lastToken == ARROW_TOKEN) {
           lastCategory = ARROW;
         } else {
           int binaryPrecendence = BINARY_PRECEDENCE[lastToken];
           if (binaryPrecendence == null && !UNARY_OPERATORS.contains(lastToken)) {
             error("Unknown operator");
           }
           if (isAssignment(lastToken)) lastCategory = ASSIGNMENT;
         }
@@ skipping 130 matching lines @@
   /**
    * CoverParenthesizedExpressionAndArrowParameterList[Yield] :
    *     ( Expression )
    *     ( )
    *     ( ... BindingIdentifier )
    *     ( Expression , ... BindingIdentifier )
    */
   Expression parseExpressionOrArrowFunction() {
     if (acceptCategory(RPAREN)) {
       expectCategory(ARROW);
-      return parseArrowFunctionBody(<Identifier>[]);
+      return parseArrowFunctionBody(<Parameter>[]);
     }
-    Expression expression = parseExpression();
+    if (acceptCategory(ELLIPSIS)) {
+      var params = <Parameter>[new RestParameter(parseParameter())];
+      expectCategory(RPAREN);
+      expectCategory(ARROW);
+      return parseArrowFunctionBody(params);
+    }
+    Expression expression = parseAssignment();
+    while (acceptCategory(COMMA)) {
+      if (acceptCategory(ELLIPSIS)) {
+        var params = <Parameter>[];
+        _expressionToParameterList(expression, params);
+        params.add(new RestParameter(parseParameter()));
+        expectCategory(RPAREN);
+        expectCategory(ARROW);
+        return parseArrowFunctionBody(params);
+      }
+      Expression right = parseAssignment();
+      expression = new Binary(',', expression, right);
+    }
     expectCategory(RPAREN);
     if (acceptCategory(ARROW)) {
-      var params = <Identifier>[];
+      var params = <Parameter>[];
       _expressionToParameterList(expression, params);
       return parseArrowFunctionBody(params);
     }
     return expression;
-
   }
 
   /**
    * Converts a parenthesized expression into a list of parameters, issuing an
    * error if the conversion fails.
    */
-  void _expressionToParameterList(Expression node, List<Identifier> params) {
+  void _expressionToParameterList(Expression node, List<Parameter> params) {
     if (node is Identifier) {
-      // TODO(jmesserly): support default/rest parameters
       params.add(node);
     } else if (node is Binary && node.op == ',') {
       // TODO(jmesserly): this will allow illegal parens, such as
       // `((a, b), (c, d))`. Fixing it on the left side needs an explicit
       // ParenthesizedExpression node, so we can distinguish
       // `((a, b), c)` from `(a, b, c)`.
       _expressionToParameterList(node.left, params);
       _expressionToParameterList(node.right, params);
     } else if (node is InterpolatedExpression) {
       params.add(new InterpolatedParameter(node.nameOrPosition));
     } else {
       error("Expected arrow function parameter list");
     }
   }
 
-  Expression parseArrowFunctionBody(List<Identifier> params) {
+  Expression parseArrowFunctionBody(List<Parameter> params) {
     Node body;
     if (acceptCategory(LBRACE)) {
       body = parseBlock();
     } else {
       body = parseAssignment();
     }
     return new ArrowFun(params, body);
   }
 
   Expression parseFunctionExpression() {
     String last = lastToken;
     if (acceptCategory(ALPHA)) {
       String functionName = last;
       return new NamedFunction(new Identifier(functionName),
           parseFun());
     }
     return parseFun();
   }
 
   Expression parseFun() {
-    List<Identifier> params = <Identifier>[];
+    List<Parameter> params = <Parameter>[];
 
     expectCategory(LPAREN);
     if (!acceptCategory(RPAREN)) {
       for (;;) {
-        if (acceptCategory(HASH)) {
-          var nameOrPosition = parseHash();
-          InterpolatedParameter parameter =
-              new InterpolatedParameter(nameOrPosition);
-          interpolatedValues.add(parameter);
-          params.add(parameter);
-        } else {
-          String argumentName = lastToken;
-          expectCategory(ALPHA);
-          params.add(new Identifier(argumentName));
+        if (acceptCategory(ELLIPSIS)) {
+          params.add(new RestParameter(parseParameter()));
+          expectCategory(RPAREN);
+          break;
         }
-        if (acceptCategory(COMMA)) continue;
-        expectCategory(RPAREN);
-        break;
+
+        params.add(parseParameter());
+        if (!acceptCategory(COMMA)) {
+          expectCategory(RPAREN);
+          break;
+        }
       }
     }
     AsyncModifier asyncModifier;
     if (acceptString('async')) {
       if (acceptString('*')) {
         asyncModifier = const AsyncModifier.asyncStar();
       } else {
         asyncModifier = const AsyncModifier.async();
       }
     } else if (acceptString('sync')) {
       if (!acceptString('*')) error("Only sync* is valid - sync is implied");
       asyncModifier = const AsyncModifier.syncStar();
     } else {
       asyncModifier = const AsyncModifier.sync();
     }
     expectCategory(LBRACE);
     Block block = parseBlock();
     return new Fun(params, block, asyncModifier: asyncModifier);
   }
 
+  /** Parse parameter name or interpolated parameter. */
+  Identifier parseParameter() {
+    if (acceptCategory(HASH)) {
+      var nameOrPosition = parseHash();
+      var parameter = new InterpolatedParameter(nameOrPosition);
+      interpolatedValues.add(parameter);
+      return parameter;
+    } else {
+      // TODO(jmesserly): validate this is not a keyword
+      String argumentName = lastToken;
+      expectCategory(ALPHA);
+      return new Identifier(argumentName);
+    }
+  }
+
   Expression parseObjectInitializer() {
     List<Property> properties = <Property>[];
     for (;;) {
       if (acceptCategory(RBRACE)) break;
       // Limited subset of ES6 object initializers.
       //
       // PropertyDefinition :
       //     PropertyName : AssignmentExpression
       //     MethodDefinition
       properties.add(parseMethodOrProperty());
@@ skipping 21 matching lines @@
   }
 
   Expression parseCall() {
     bool constructor = acceptString("new");
     Expression receiver = parseMember();
     while (true) {
       if (acceptCategory(LPAREN)) {
         final arguments = <Expression>[];
         if (!acceptCategory(RPAREN)) {
           while (true) {
-            Expression argument = parseAssignment();
-            arguments.add(argument);
+            if (acceptCategory(ELLIPSIS)) {
+              arguments.add(new Spread(parseAssignment()));
+              expectCategory(RPAREN);
+              break;
+            }
+            arguments.add(parseAssignment());
             if (acceptCategory(RPAREN)) break;
             expectCategory(COMMA);
           }
         }
         receiver = constructor ?
                new New(receiver, arguments) :
                new Call(receiver, arguments);
         constructor = false;
       } else if (!constructor && acceptCategory(LSQUARE)) {
         Expression inBraces = parseExpression();
@@ skipping 579 matching lines @@
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
       return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
 }