dart2js: Accept named holes in js-templates.

sdk/lib/_internal/compiler/implementation/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;
 
 class TemplateManager {
   Map<String, Template> expressionTemplates = new Map<String, Template>();
   Map<String, Template> statementTemplates = new Map<String, Template>();
 
@@ skipping 72 matching lines @@
     return generator.analysis.count == 0;
   }
 
   void _compile() {
     InstantiatorGeneratorVisitor generator =
         new InstantiatorGeneratorVisitor(forceCopy);
     instantiator = generator.compile(ast);
     positionalArgumentCount = generator.analysis.count;
   }
 
-  Node instantiate(List arguments) {
+  /// Instantiates the template with the given [arguments].
+  ///
+  /// This method fills in the holes with the given arguments. The [arguments]
+  /// must be either a [List] or a [Map].
+  Node instantiate(var arguments) {
     if (arguments is List) {
       if (arguments.length != positionalArgumentCount) {
         throw 'Wrong number of template arguments, given ${arguments.length}, '
             'expected $positionalArgumentCount';
       }
       return instantiator(arguments);
     }
-    // TODO(sra): Add named placeholders and a Map of arguments.
-    throw new UnimplementedError('Template arguments must be a list');
+    assert(arguments is Map);

[sra1, 2014/10/22 21:50:28]

It might be nice to collect the set of names in the template and verify that the
map provides exactly those names.

[floitsch, 2014/11/03 18:12:58]

Done.

+    return instantiator(arguments);
   }
 }
 
 /**
  * An Instantiator is a Function that generates a JS AST tree or List of
- * trees. [arguments] is a List for positional templates, or (TODO) Map for
+ * trees. [arguments] is a List for positional templates, or Map for
  * named templates.
  */
 typedef Node Instantiator(var arguments);
 
 
 /**
  * InstantiatorGeneratorVisitor compiles a template.  This class compiles a tree
  * containing [InterpolatedNode]s into a function that will create a copy of the
  * tree with the interpolated nodes substituted with provided values.
  */
@@ skipping 43 matching lines @@
   }
 
   static RegExp identiferRE = new RegExp(r'^[A-Za-z_$][A-Za-z_$0-9]*$');
 
   static Expression convertStringToVariableUse(String value) {
     assert(identiferRE.hasMatch(value));
     return new VariableUse(value);
   }
 
   Instantiator visitInterpolatedExpression(InterpolatedExpression node) {
-    int position = node.name;
+    var name = node.name;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[name];
       if (value is Expression) return value;
       if (value is String) return convertStringToVariableUse(value);;
-      error('Interpolated value #$position is not an Expression: $value');
+      error('Interpolated value #$name is not an Expression: $value');
     };
   }
 
   Instantiator visitSplayableExpression(Node node) {
     if (node is InterpolatedExpression) {
-      int position = node.name;
+      var name = node.name;
       return (arguments) {
-        var value = arguments[position];
+        var value = arguments[name];
         Expression toExpression(item) {
           if (item is Expression) return item;
           if (item is String) return convertStringToVariableUse(item);
-          return error('Interpolated value #$position is not '
+          return error('Interpolated value #$name 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) {
-    int position = node.name;
+    var name = node.name;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[name];
       if (value is Literal) return value;
-      error('Interpolated value #$position is not a Literal: $value');
+      error('Interpolated value #$name is not a Literal: $value');
     };
   }
 
   Instantiator visitInterpolatedParameter(InterpolatedParameter node) {
-    int position = node.name;
+    var name = node.name;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[name];
 
       Parameter toParameter(item) {
         if (item is Parameter) return item;
         if (item is String) return new Parameter(item);
-        return error('Interpolated value #$position is not a Parameter or '
+        return error('Interpolated value #$name is not a Parameter or '
                      'List of Parameters: $value');
       }
       if (value is Iterable) return value.map(toParameter);
       return toParameter(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`.
-    int position = node.name;
+    var name = node.name;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[name];
       if (value is Expression) return value;
       if (value is String) return new LiteralString('"$value"');
-      error('Interpolated value #$position is not a selector: $value');
+      error('Interpolated value #$name is not a selector: $value');
     };
   }
 
   Instantiator visitInterpolatedStatement(InterpolatedStatement node) {
-    int position = node.name;
+    var name = node.name;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[name];
       if (value is Node) return value.toStatement();
-      error('Interpolated value #$position is not a Statement: $value');
+      error('Interpolated value #$name is not a Statement: $value');
     };
   }
 
   Instantiator visitSplayableStatement(Node node) {
     if (node is InterpolatedStatement) {
-      int position = node.name;
+      var name = node.name;
       return (arguments) {
-        var value = arguments[position];
+        var value = arguments[name];
         Statement toStatement(item) {
           if (item is Statement) return item;
           if (item is Expression) return item.toStatement();;
-          return error('Interpolated value #$position is not '
+          return error('Interpolated value #$name is not '
                        'a Statement or List of Statements: $value');
         }
         if (value is Iterable) return value.map(toStatement);
         return toStatement(value);
       };
     }
     return visit(node);
   }
 
   Instantiator visitProgram(Program node) {
@@ skipping 50 matching lines @@
     if (node.condition is InterpolatedExpression) {
       return visitIfConditionalCompilation(node);
     } else {
       return visitIfNormal(node);
     }
   }
 
   Instantiator visitIfConditionalCompilation(If node) {
     // Special version of visitInterpolatedExpression that permits bools.
     compileCondition(InterpolatedExpression node) {
-      int position = node.name;
+      var name = node.name;
       return (arguments) {
-        var value = arguments[position];
+        var value = arguments[name];
         if (value is bool) return value;
         if (value is Expression) return value;
         if (value is String) return convertStringToVariableUse(value);;
-        error('Interpolated value #$position is not an Expression: $value');
+        error('Interpolated value #$name 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) {
         if (condition == true) {
           return makeThen(arguments);
@@ skipping 329 matching lines @@
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     interpolatedNodes.add(node);
     containsInterpolatedNode.add(node);
     ++count;
   }
 }