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

lib/src/js/template.dart

 // Copyright (c) 2014, 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 TemplateManager {
   Map<String, Template> expressionTemplates = new Map<String, Template>();
   Map<String, Template> statementTemplates = new Map<String, Template>();
 
@@ skipping 160 matching lines @@
 
   Instantiator visitSplayable(Node node) {
     // TODO(sra): Process immediate [InterpolatedNode]s, permitting splaying.
     return visit(node);
   }
 
   Instantiator visitNode(Node node) {
     throw 'Unimplemented InstantiatorGeneratorVisitor for $node';
   }
 
-  static RegExp identiferRE = new RegExp(r'^[A-Za-z_$][A-Za-z_$0-9]*$');
-
-  static Expression convertStringToVariableUse(String value) {
-    assert(identiferRE.hasMatch(value));

[Jennifer Messerly, 2015/03/25 21:29:16]

this check already happens in the constructor

-    return new VariableUse(value);
-  }
-
   Instantiator visitInterpolatedExpression(InterpolatedExpression node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
       if (value is Expression) return value;
-      if (value is String) return convertStringToVariableUse(value);
+      if (value is String) return new Identifier(value);
       error('Interpolated value #$nameOrPosition is not an Expression: $value');
     };
   }
 
   Instantiator visitSplayableExpression(Node node) {
     if (node is InterpolatedExpression) {
       var nameOrPosition = node.nameOrPosition;
       return (arguments) {
         var value = arguments[nameOrPosition];
         Expression toExpression(item) {
           if (item is Expression) return item;
-          if (item is String) return convertStringToVariableUse(item);
+          if (item is String) return new Identifier(item);
           return error('Interpolated value #$nameOrPosition is not '
               'an Expression or List of Expressions: $value');
         }
         if (value is Iterable) return value.map(toExpression);
         return toExpression(value);
       };
     }
     return visit(node);
   }
 
   Instantiator visitInterpolatedLiteral(InterpolatedLiteral node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
       if (value is Literal) return value;
       error('Interpolated value #$nameOrPosition is not a Literal: $value');
     };
   }
 
   Instantiator visitInterpolatedParameter(InterpolatedParameter node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
 
-      Parameter toParameter(item) {
-        if (item is Parameter) return item;
-        if (item is String) return new Parameter(item);
-        return error('Interpolated value #$nameOrPosition is not a Parameter or'
-                     ' List of Parameters: $value');
+      Identifier toIdentifier(item) {
+        if (item is Identifier) return item;
+        if (item is String) return new Identifier(item);
+        return error('Interpolated value #$nameOrPosition is not an Identifier'
+                     ' or List of Identifiers: $value');
       }
-      if (value is Iterable) return value.map(toParameter);
-      return toParameter(value);
+      if (value is Iterable) return value.map(toIdentifier);
+      return toIdentifier(value);
     };
   }
 
   Instantiator visitInterpolatedSelector(InterpolatedSelector node) {
     // A selector is an expression, as in `a[selector]`.
     // A String argument converted into a LiteralString, so `a.#` with argument
     // 'foo' generates `a["foo"]` which prints as `a.foo`.
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var value = arguments[nameOrPosition];
@@ skipping 19 matching lines @@
       Method toMethod(item) {
         if (item is Method) return item;
         return error('Interpolated value #$nameOrPosition is not a Method '
             'or List of Methods: $value');
       }
       if (value is Iterable) return value.map(toMethod);
       return toMethod(value);
     };
   }
 
-  Instantiator visitInterpolatedVariableDeclaration(
-        InterpolatedVariableDeclaration node) {
+  Instantiator visitInterpolatedIdentifier(InterpolatedIdentifier node) {
     var nameOrPosition = node.nameOrPosition;
     return (arguments) {
       var item = arguments[nameOrPosition];
-      if (item is VariableDeclaration) return item;
-      if (item is String) return new VariableDeclaration(item);
+      if (item is Identifier) return item;
+      if (item is String) return new Identifier(item);
       return error('Interpolated value #$nameOrPosition is not a '
-          'VariableDeclaration or String: $item');
+          'Identifier or String: $item');
     };
   }
 
   Instantiator visitSplayableStatement(Node node) {
     if (node is InterpolatedStatement) {
       var nameOrPosition = node.nameOrPosition;
       return (arguments) {
         var value = arguments[nameOrPosition];
         Statement toStatement(item) {
           if (item is Statement) return item;
@@ skipping 67 matching lines @@
   }
 
   Instantiator visitIfConditionalCompilation(If node) {
     // Special version of visitInterpolatedExpression that permits bools.
     compileCondition(InterpolatedExpression node) {
       var nameOrPosition = node.nameOrPosition;
       return (arguments) {
         var value = arguments[nameOrPosition];
         if (value is bool) return value;
         if (value is Expression) return value;
-        if (value is String) return convertStringToVariableUse(value);;
+        if (value is String) return new Identifier(value);
         error('Interpolated value #$nameOrPosition '
               'is not an Expression: $value');
       };
     }
     var makeCondition = compileCondition(node.condition);
     Instantiator makeThen = visit(node.then);
     Instantiator makeOtherwise = visit(node.otherwise);
     return (arguments) {
       var condition = makeCondition(arguments);
       if (condition is bool) {
@@ skipping 241 matching lines @@
     String op = node.op;
     return (arguments) => new Prefix(op, makeOperand(arguments));
   }
 
   Instantiator visitPostfix(Postfix node) {
     Instantiator makeOperand = visit(node.argument);
     String op = node.op;
     return (arguments) => new Postfix(op, makeOperand(arguments));
   }
 
-  Instantiator visitVariableUse(VariableUse node) =>
-      (arguments) => new VariableUse(node.name);
-
   Instantiator visitThis(This node) => (arguments) => new This();
   Instantiator visitSuper(Super node) => (arguments) => new Super();
 
-  Instantiator visitVariableDeclaration(VariableDeclaration node) =>
-      (arguments) => new VariableDeclaration(node.name);
-
-  Instantiator visitParameter(Parameter node) =>
-      (arguments) => new Parameter(node.name);
+  Instantiator visitIdentifier(Identifier node) =>
+      (arguments) => new Identifier(node.name);
 
   Instantiator visitAccess(PropertyAccess node) {
     Instantiator makeReceiver = visit(node.receiver);
     Instantiator makeSelector = visit(node.selector);
     return (arguments) =>
         new PropertyAccess(makeReceiver(arguments), makeSelector(arguments));
   }
 
   Instantiator visitNamedFunction(NamedFunction node) {
     Instantiator makeDeclaration = visit(node.name);
     Instantiator makeFunction = visit(node.function);
     return (arguments) =>
         new NamedFunction(makeDeclaration(arguments), makeFunction(arguments));
   }
 
   Instantiator visitFunctionExpression(FunctionExpression node) {
     List<Instantiator> paramMakers = node.params.map(visitSplayable).toList();
     Instantiator makeBody = visit(node.body);
     // TODO(sra): Avoid copying params if no interpolation or forced copying.
     return (arguments) {
-      List<Parameter> params = <Parameter>[];
+      List<Identifier> params = <Identifier>[];
       for (Instantiator instantiator in paramMakers) {
         var result = instantiator(arguments);
         if (result is Iterable) {
           params.addAll(result);
         } else {
           params.add(result);
         }
       }
       var body = makeBody(arguments);
       if (node is ArrowFun) {
@@ skipping 168 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }