Split Parameter and TypeParameter out of Identifier

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 188 matching lines @@
   }
 
   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 new Identifier(item);
+          if (item is Parameter) return item.binding;
           return error('Interpolated value #$nameOrPosition is not '
-              'an Expression or List of Expressions: $value');
+              'an Expression or List of Expressions: $value: ${value is Iterable ? value.map((v) => v.runtimeType) : value.runtimeType}');
         }
         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;
+    var isRest = node.isRest;
     return (arguments) {
       var value = arguments[nameOrPosition];
 
-      Parameter toIdentifier(item) {
-        if (item is Parameter) return item;
-        if (item is String) return new Identifier(item);
-        return error('Interpolated value #$nameOrPosition is not an Identifier'
-            ' or List of Identifiers: $value');
+      Parameter toParameter(item, {bool isRest: false}) {
+        if (item is Identifier) return new Parameter(item, isRest: isRest);
+        if (item is String) return new Parameter(new Identifier(item), isRest: isRest);
+        return error('Interpolated value #$nameOrPosition is not an Parameter'
+            ' or List of Parameters: $value: ${value.runtimeType}');
       }
-      if (value is Iterable) return value.map(toIdentifier);
-      return toIdentifier(value);
+      if (value is Iterable) return value.map(toParameter);
+      return toParameter(value, isRest: isRest);
     };
   }
 
   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 369 matching lines @@
 
   Instantiator visitPostfix(Postfix node) {
     Instantiator makeOperand = visit(node.argument);
     String op = node.op;
     return (arguments) => new Postfix(op, makeOperand(arguments));
   }
 
   Instantiator visitThis(This node) => (arguments) => new This();
   Instantiator visitSuper(Super node) => (arguments) => new Super();
 
+  Instantiator visitParameter(Parameter node) {
+    Instantiator makeBinding = visit(node.binding);
+    Instantiator makeType = visit(node.type);
+    var isRest = node.isRest;
+    return (arguments) => new Parameter(
+        makeBinding(arguments), type: makeType(arguments), isRest: isRest);
+  }
+
+  Instantiator visitTypeParameter(TypeParameter node) {
+    Instantiator makeName = visit(node.name);
+    Instantiator makeBound = visit(node.bound);
+    return (arguments) =>
+        new TypeParameter(makeName(arguments), bound: makeBound(arguments));
+  }
+
   Instantiator visitIdentifier(Identifier node) =>
       (arguments) => new Identifier(node.name);
 
   Instantiator visitSpread(Spread node) =>
       (args) => new Spread(visit(node.argument)(args));
 
   Instantiator visitYield(Yield node) =>
       (args) => new Yield(node.value != null ? visit(node.value)(args) : null,
           star: node.star);
 
-  Instantiator visitRestParameter(RestParameter node) =>
-      (args) => new RestParameter(visit(node.parameter)(args));
-
   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);
@@ skipping 261 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     containsInterpolatedNode.add(node);
     if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }