js_ast: implement rest/spread parsing

lib/src/js/printer.dart

 // Copyright (c) 2012, 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.
 
 part of js_ast;
 
 
 class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
   final bool minifyLocalVariables;
@@ skipping 605 matching lines @@
                           newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitNew(New node) {
     out("new ");
     inNewTarget = true;
     visitNestedExpression(node.target, ACCESS,
                           newInForInit: inForInit, newAtStatementBegin: false);
     inNewTarget = false;
     out("(");
-    visitCommaSeparated(node.arguments, ASSIGNMENT,
+    visitCommaSeparated(node.arguments, SPREAD,
                         newInForInit: false, newAtStatementBegin: false);
     out(")");
   }
 
   visitCall(Call call) {
     visitNestedExpression(call.target, LEFT_HAND_SIDE,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     out("(");
-    visitCommaSeparated(call.arguments, ASSIGNMENT,
+    visitCommaSeparated(call.arguments, SPREAD,
                         newInForInit: false, newAtStatementBegin: false);
     out(")");
   }
 
   visitBinary(Binary binary) {
     Expression left = binary.left;
     Expression right = binary.right;
     String op = binary.op;
     int leftPrecedenceRequirement;
     int rightPrecedenceRequirement;
@@ skipping 110 matching lines @@
         out(op);
         break;
       case "-":
       case "--":
         if (lastCharCode == charCodes.$MINUS) out(" ");
         out(op);
         break;
       default:
         out(op);
     }
-    visitNestedExpression(unary.argument, UNARY,
+    visitNestedExpression(unary.argument, unary.precedenceLevel,
                           newInForInit: inForInit, newAtStatementBegin: false);
   }
 
+  visitSpread(Spread unary) => visitPrefix(unary);
+
   visitPostfix(Postfix postfix) {
     visitNestedExpression(postfix.argument, LEFT_HAND_SIDE,
                           newInForInit: inForInit,
                           newAtStatementBegin: atStatementBegin);
     out(postfix.op);
   }
 
   visitThis(This node) {
     out("this");
   }
 
   visitSuper(Super node) {
     out("super");
   }
 
   visitIdentifier(Identifier node) {
     out(localNamer.getName(node));
   }
 
+  visitRestParameter(RestParameter node) {
+    out('...');
+    visitIdentifier(node.parameter);
+  }
+
   bool isDigit(int charCode) {
     return charCodes.$0 <= charCode && charCode <= charCodes.$9;
   }
 
   bool isValidJavaScriptId(String field) {
     if (field.length < 3) return false;
     // Ignore the leading and trailing string-delimiter.
     for (int i = 1; i < field.length - 1; i++) {
       // TODO(floitsch): allow more characters.
       int charCode = field.codeUnitAt(i);
@@ skipping 39 matching lines @@
     functionOut(namedFunction.function, namedFunction.name);
   }
 
   visitFun(Fun fun) {
     functionOut(fun, null);
   }
 
   visitArrowFun(ArrowFun fun) {
     localNamer.enterScope(fun);
     if (fun.params.length == 1) {
-      visitNestedExpression(fun.params.single, PRIMARY,
+      visitNestedExpression(fun.params.single, SPREAD,
           newInForInit: false, newAtStatementBegin: false);
     } else {
       out("(");
-      visitCommaSeparated(fun.params, PRIMARY,
+      visitCommaSeparated(fun.params, SPREAD,
           newInForInit: false, newAtStatementBegin: false);
       out(")");
     }
     spaceOut();
     out("=>");
     if (fun.body is Expression) {
       spaceOut();
       // Object initializers require parenthesis to disambiguate
       // AssignmentExpression from FunctionBody. See:
       // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-arrow-function-definitions
@@ skipping 161 matching lines @@
       out('get ');
     } else if (node.isSetter) {
       out('set ');
     }
     propertyNameOut(node.name, inMethod: true);
 
     var fun = node.function;
     localNamer.enterScope(fun);
     out("(");
     if (fun.params != null) {
-      visitCommaSeparated(fun.params, PRIMARY,
+      visitCommaSeparated(fun.params, SPREAD,
           newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
     // TODO(jmesserly): async modifiers
     if (fun.body.statements.isEmpty) {
       spaceOut();
       out("{}");
     } else {
       blockBody(fun.body, needsSeparation: false, needsNewline: false);
     }
@@ skipping 366 matching lines @@
     return newName;
   }
 }
 
 /// Like [BaseVisitor], but calls [declare] for [Identifier] declarations, and
 /// [visitIdentifier] otherwise.
 abstract class VariableDeclarationVisitor<T> extends BaseVisitor<T> {
   declare(Identifier node);
 
   visitFunctionExpression(FunctionExpression node) {
-    for (Identifier param in node.params) declare(param);
+    for (var p in node.params) {
+      declare(p is RestParameter ? p.parameter : p);
+    }
     node.body.accept(this);
   }
 
   visitVariableInitialization(VariableInitialization node) {
     declare(node.declaration);
     if (node.value != null) node.value.accept(this);
   }
 
   visitCatch(Catch node) {
     declare(node.declaration);
     node.body.accept(this);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     declare(node.name);
     node.function.accept(this);
   }
 
   visitNamedFunction(NamedFunction node) {
     declare(node.name);
     node.function.accept(this);
   }
 
   visitClassExpression(ClassExpression node) {
     declare(node.name);
     if (node.heritage != null) node.heritage.accept(this);
     for (Method element in node.methods) element.accept(this);
   }
 }