Split Parameter and TypeParameter out of Identifier

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 822 matching lines @@
    *     ( )
    *     ( ... BindingIdentifier )
    *     ( Expression , ... BindingIdentifier )
    */
   Expression parseExpressionOrArrowFunction() {
     if (acceptCategory(RPAREN)) {
       expectCategory(ARROW);
       return parseArrowFunctionBody(<Parameter>[]);
     }
     if (acceptCategory(ELLIPSIS)) {
-      var params = <Parameter>[new RestParameter(parseParameter())];
+      var params = <Parameter>[parseParameter(isRest: true)];
       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()));
+        params.add(parseParameter(isRest: true));
         expectCategory(RPAREN);
         expectCategory(ARROW);
         return parseArrowFunctionBody(params);
       }
       Expression right = parseAssignment();
       expression = new Binary(',', expression, right);
     }
     expectCategory(RPAREN);
     if (acceptCategory(ARROW)) {
       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<Parameter> params) {
     if (node is Identifier) {
-      params.add(node);
+      params.add(new Parameter(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 {
@@ skipping 21 matching lines @@
     return parseFun();
   }
 
   Expression parseFun() {
     List<Parameter> params = <Parameter>[];
 
     expectCategory(LPAREN);
     if (!acceptCategory(RPAREN)) {
       for (;;) {
         if (acceptCategory(ELLIPSIS)) {
-          params.add(new RestParameter(parseParameter()));
+          params.add(parseParameter(isRest: true));
           expectCategory(RPAREN);
           break;
         }
 
         params.add(parseParameter());
         if (!acceptCategory(COMMA)) {
           expectCategory(RPAREN);
           break;
         }
       }
@@ skipping 10 matching lines @@
       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() {
+  Parameter parseParameter({bool isRest: false}) {
     if (acceptCategory(HASH)) {
       var nameOrPosition = parseHash();
-      var parameter = new InterpolatedParameter(nameOrPosition);
+      var parameter = new InterpolatedParameter(nameOrPosition, isRest: isRest);
       interpolatedValues.add(parameter);
       return parameter;
     } else {
       // TODO(jmesserly): validate this is not a keyword
       String argumentName = lastToken;
       expectCategory(ALPHA);
-      return new Identifier(argumentName);
+      return new Parameter(new Identifier(argumentName), isRest: isRest);
     }
   }
 
   Expression parseObjectInitializer() {
     List<Property> properties = <Property>[];
     for (;;) {
       if (acceptCategory(RBRACE)) break;
       // Limited subset of ES6 object initializers.
       //
       // PropertyDefinition :
@@ skipping 672 matching lines @@
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
       return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
 }