[js_ast] adds Identifier that merges VariableDeclaration/Use and Parameter

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 46 matching lines @@
 still has one semicolon:
 
     js.statement('if (happy) #;', ret)
     -->
     if (happy)
       return 123;
 
 If the placeholder is not followed by a semicolon, it is part of an expression.
 Here the paceholder is in the position of the function in a function call:
 
-    var vFoo = new VariableUse('foo');
+    var vFoo = new Identifier('foo');
     js.statement('if (happy) #("Happy!")', vFoo)
     -->
     if (happy)
       foo("Happy!");
 
 Generally, a placeholder in an expression position requires an Expression AST as
 an argument and a placeholder in a statement position requires a Statement AST.
 An expression will be converted to a Statement if needed by creating an
-ExpessionStatement.  A String argument will be converted into a VariableUse and
+ExpessionStatement.  A String argument will be converted into a Identifier and
 requires that the string is a JavaScript identifier.
 
     js('# + 1', vFoo)       -->  foo + 1
     js('# + 1', 'foo')      -->  foo + 1
     js('# + 1', 'foo.bar')  -->  assertion failure
 
 Some placeholder positions are _splicing contexts_.  A function argument list is
 a splicing expression context.  A placeholder in a splicing expression context
-can take a single Expression (or String, converted to VariableUse) or an
+can take a single Expression (or String, converted to Identifier) or an
 Iterable of Expressions (and/or Strings).
 
     // non-splicing argument:
     js('#(#)', ['say', s])        -->  say("hello")
     // splicing arguments:
     js('#(#)', ['say', []])       -->  say()
     js('#(#)', ['say', [s]])      -->  say("hello")
     js('#(#)', ['say', [s, n]])   -->  say("hello", 123)
 
 A splicing context can be used to append 'lists' and add extra elements:
@@ skipping 634 matching lines @@
         return new LiteralNull();
       } else if (last == "function") {
         return parseFunctionExpression();
       } else if (last == "this") {
         return new This();
       } else if (last == "super") {
         return new Super();
       } else if (last == "class") {
         return parseClass();
       } else {
-        return new VariableUse(last);
+        return new Identifier(last);
       }
     } else if (acceptCategory(LPAREN)) {
       return parseExpressionOrArrowFunction();
     } else if (acceptCategory(STRING)) {
       return new LiteralString(last);
     } else if (acceptCategory(NUMERIC)) {
       return new LiteralNumber(last);
     } else if (acceptCategory(LBRACE)) {
       return parseObjectInitializer();
     } else if (acceptCategory(LSQUARE)) {
@@ skipping 34 matching lines @@
   /**
    * CoverParenthesizedExpressionAndArrowParameterList[Yield] :
    *     ( Expression )
    *     ( )
    *     ( ... BindingIdentifier )
    *     ( Expression , ... BindingIdentifier )
    */
   Expression parseExpressionOrArrowFunction() {
     if (acceptCategory(RPAREN)) {
       expectCategory(ARROW);
-      return parseArrowFunctionBody(<Parameter>[]);
+      return parseArrowFunctionBody(<Identifier>[]);
     }
     Expression expression = parseExpression();
     expectCategory(RPAREN);
     if (acceptCategory(ARROW)) {
-      var params = <Parameter>[];
+      var params = <Identifier>[];
       _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 VariableUse) {
+  void _expressionToParameterList(Expression node, List<Identifier> params) {
+    if (node is Identifier) {
       // TODO(jmesserly): support default/rest parameters
-      params.add(new Parameter(node.name));
+      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<Parameter> params) {
+  Expression parseArrowFunctionBody(List<Identifier> 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 VariableDeclaration(functionName),
+      return new NamedFunction(new Identifier(functionName),
           parseFun());
     }
     return parseFun();
   }
 
   Expression parseFun() {
-    List<Parameter> params = <Parameter>[];
+    List<Identifier> params = <Identifier>[];
 
     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 Parameter(argumentName));
+          params.add(new Identifier(argumentName));
         }
         if (acceptCategory(COMMA)) continue;
         expectCategory(RPAREN);
         break;
       }
     }
     AsyncModifier asyncModifier;
     if (acceptString('async')) {
       if (acceptString('*')) {
         asyncModifier = const AsyncModifier.asyncStar();
@@ skipping 196 matching lines @@
       expression = new Binary(',', expression, right);
     }
     return expression;
   }
 
   /** Parse a variable declaration list, with `var` or `let` [keyword] */
   VariableDeclarationList parseVariableDeclarationList(String keyword) {
     // Supports one form for interpolated variable declaration:
     //    let # = ...
     if (acceptCategory(HASH)) {
-      var name = new InterpolatedVariableDeclaration(parseHash());
+      var name = new InterpolatedIdentifier(parseHash());
       interpolatedValues.add(name);
 
       Expression initializer = acceptString("=") ? parseAssignment() : null;
       return new VariableDeclarationList(keyword,
           [new VariableInitialization(name, initializer)]);
     }
 
     String firstVariable = lastToken;
     expectCategory(ALPHA);
     return finishVariableDeclarationList(keyword, firstVariable);
   }
 
   VariableDeclarationList finishVariableDeclarationList(
       String keyword, String firstVariable) {
     var initialization = [];
 
     void declare(String variable) {
       Expression initializer = null;
       if (acceptString("=")) {
         initializer = parseAssignment();
       }
-      var declaration = new VariableDeclaration(variable);
+      var declaration = new Identifier(variable);
       initialization.add(new VariableInitialization(declaration, initializer));
     }
 
     declare(firstVariable);
     while (acceptCategory(COMMA)) {
       String variable = lastToken;
       expectCategory(ALPHA);
       declare(variable);
     }
     return new VariableDeclarationList(keyword, initialization);
@@ skipping 92 matching lines @@
       if (lastToken == 'with') {
         error('Not implemented in mini parser');
       }
 
     }
 
     bool checkForInterpolatedStatement = lastCategory == HASH;
 
     Expression expression = parseExpression();
 
-    if (expression is VariableUse && acceptCategory(COLON)) {
+    if (expression is Identifier && acceptCategory(COLON)) {
       return new LabeledStatement(expression.name, parseStatement());
     }
 
     expectSemicolon();
 
     if (checkForInterpolatedStatement) {
       // 'Promote' the interpolated expression `#;` to an interpolated
       // statement.
       if (expression is InterpolatedExpression) {
         assert(identical(interpolatedValues.last, expression));
@@ skipping 112 matching lines @@
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
     return finishFor(init);
   }
 
   static VariableDeclarationList _createVariableDeclarationList(
       String keyword, String identifier) {
     return new VariableDeclarationList(keyword, [
         new VariableInitialization(
-            new VariableDeclaration(identifier), null)]);
+            new Identifier(identifier), null)]);
   }
 
   Statement parseFunctionDeclaration() {
     String name = lastToken;
     expectCategory(ALPHA);
     Expression fun = parseFun();
-    return new FunctionDeclaration(new VariableDeclaration(name), fun);
+    return new FunctionDeclaration(new Identifier(name), fun);
   }
 
   Statement parseTry() {
     expectCategory(LBRACE);
     Block body = parseBlock();
     Catch catchPart = null;
     if (acceptString('catch')) catchPart = parseCatch();
     Block finallyPart = null;
     if (acceptString('finally')) {
       expectCategory(LBRACE);
@@ skipping 58 matching lines @@
     return new Switch(key, clauses);
   }
 
   Catch parseCatch() {
     expectCategory(LPAREN);
     String identifier = lastToken;
     expectCategory(ALPHA);
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     Block body = parseBlock();
-    return new Catch(new VariableDeclaration(identifier), body);
+    return new Catch(new Identifier(identifier), body);
   }
 
   ClassExpression parseClass() {
-    VariableDeclaration name;
+    Identifier name;
     if (acceptCategory(HASH)) {
-      var interpolatedName = new InterpolatedVariableDeclaration(parseHash());
+      var interpolatedName = new InterpolatedIdentifier(parseHash());
       interpolatedValues.add(interpolatedName);
       name = interpolatedName;
     } else {
-      name = new VariableDeclaration(lastToken);
+      name = new Identifier(lastToken);
       expectCategory(ALPHA);
     }
     Expression heritage = null;
     if (acceptString('extends')) {
       heritage = parseLeftHandSide();
     }
     expectCategory(LBRACE);
     var methods = new List<Method>();
     while (lastCategory != RBRACE) {
       methods.add(parseMethodOrProperty(onlyMethods: true));
@@ skipping 65 matching lines @@
       expectCategory(RSQUARE);
       return expr;
     } else if (acceptCategory(HASH)) {
       return parseInterpolatedExpression();
     } else {
       error('Expected property name');
       return null;
     }
   }
 }