dart2js: Accept named holes in js-templates.

pkg/compiler/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;
 
 class TemplateManager {
   Map<String, Template> expressionTemplates = new Map<String, Template>();
   Map<String, Template> statementTemplates = new Map<String, Template>();
 
@@ skipping 29 matching lines @@
  * the original with the placeholders replaced by the arguments to
  * [instantiate].
  */
 class Template {
   final String source;
   final bool isExpression;
   final bool forceCopy;
   final Node ast;
 
   Instantiator instantiator;
+
   int positionalArgumentCount = -1;
-  // TODO(sra): Named arguments.
+
+  // Null, unless there are named holes.
+  List<String> holeNames;
+  bool get isPositional => holeNames == null;
 
   Template(this.source, this.ast,
            {this.isExpression: true, this.forceCopy: false}) {
     _compile();
   }
 
   Template.withExpressionResult(this.ast)
       : source = null, isExpression = true, forceCopy = false {
     assert(ast is Expression);
     assert(_checkNoPlaceholders());
@@ skipping 14 matching lines @@
         new InstantiatorGeneratorVisitor(false);
     generator.compile(ast);
     return generator.analysis.count == 0;
   }
 
   void _compile() {
     InstantiatorGeneratorVisitor generator =
         new InstantiatorGeneratorVisitor(forceCopy);
     instantiator = generator.compile(ast);
     positionalArgumentCount = generator.analysis.count;
+    Set<String> names = generator.analysis.holeNames;
+    holeNames = names.isEmpty ? null : names.toList(growable:false);
   }
 
-  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);
+    if (holeNames.length < arguments.length) {
+      // This search is in O(n), but we only do it in case of an error, and the
+      // number of holes should be quite limited.
+      String unusedNames =
+          arguments.keys.where((name) => !holeNames.contains(name)).join(", ");
+      throw "Template arguments has unused mappings: $unusedNames";
+    }
+    if (!holeNames.every((String name) => arguments.containsKey(name))) {
+      String notFound =
+          holeNames.where((name) => !arguments.containsKey(name)).join(", ");
+      throw "Template arguments is missing mappings for: $notFound";
+    }
+    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 nameOrPosition = node.nameOrPosition;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[nameOrPosition];
       if (value is Expression) return value;
-      if (value is String) return convertStringToVariableUse(value);;
-      error('Interpolated value #$position is not an Expression: $value');
+      if (value is String) return convertStringToVariableUse(value);
+      error('Interpolated value #$nameOrPosition is not an Expression: $value');
     };
   }
 
   Instantiator visitSplayableExpression(Node node) {
     if (node is InterpolatedExpression) {
-      int position = node.name;
+      var nameOrPosition = node.nameOrPosition;
       return (arguments) {
-        var value = arguments[position];
+        var value = arguments[nameOrPosition];
         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 #$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) {
-    int position = node.name;
+    var nameOrPosition = node.nameOrPosition;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[nameOrPosition];
       if (value is Literal) return value;
-      error('Interpolated value #$position is not a Literal: $value');
+      error('Interpolated value #$nameOrPosition is not a Literal: $value');
     };
   }
 
   Instantiator visitInterpolatedParameter(InterpolatedParameter node) {
-    int position = node.name;
+    var nameOrPosition = node.nameOrPosition;
     return (arguments) {
-      var value = arguments[position];
+      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 #$position is not a Parameter or '
-                     'List of Parameters: $value');
+        return error('Interpolated value #$nameOrPosition 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 nameOrPosition = node.nameOrPosition;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[nameOrPosition];
       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 #$nameOrPosition is not a selector: $value');
     };
   }
 
   Instantiator visitInterpolatedStatement(InterpolatedStatement node) {
-    int position = node.name;
+    var nameOrPosition = node.nameOrPosition;
     return (arguments) {
-      var value = arguments[position];
+      var value = arguments[nameOrPosition];
       if (value is Node) return value.toStatement();
-      error('Interpolated value #$position is not a Statement: $value');
+      error('Interpolated value #$nameOrPosition is not a Statement: $value');
     };
   }
 
   Instantiator visitSplayableStatement(Node node) {
     if (node is InterpolatedStatement) {
-      int position = node.name;
+      var nameOrPosition = node.nameOrPosition;
       return (arguments) {
-        var value = arguments[position];
+        var value = arguments[nameOrPosition];
         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 #$nameOrPosition 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 nameOrPosition = node.nameOrPosition;
       return (arguments) {
-        var value = arguments[position];
+        var value = arguments[nameOrPosition];
         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 #$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) {
         if (condition == true) {
           return makeThen(arguments);
@@ skipping 303 matching lines @@
   Instantiator visitRegExpLiteral(RegExpLiteral node) =>
       (arguments) => new RegExpLiteral(node.pattern);
 
   Instantiator visitComment(Comment node) => TODO('visitComment');
 }
 
 /**
  * InterpolatedNodeAnalysis extract [InterpolatedNode]s from AST.
  */
 class InterpolatedNodeAnalysis extends BaseVisitor {
-  final Set<Node> containsInterpolatedNode = new Set<Node>();
+  final Setlet<Node> containsInterpolatedNode = new Setlet<Node>();
   final List<InterpolatedNode> interpolatedNodes = <InterpolatedNode>[];
+  final Setlet<String> holeNames = new Setlet<String>();
   int count = 0;
 
   InterpolatedNodeAnalysis();
 
   bool containsInterpolatedNodes(Node node) =>
       containsInterpolatedNode.contains(node);
 
   void visit(Node node) {
     node.accept(this);
   }
 
   void visitNode(Node node) {
     int before = count;
     node.visitChildren(this);
     if (count != before) containsInterpolatedNode.add(node);
     return null;
   }
 
   visitInterpolatedNode(InterpolatedNode node) {
     interpolatedNodes.add(node);
     containsInterpolatedNode.add(node);
+    if (node.isNamed) holeNames.add(node.nameOrPosition);
     ++count;
   }
 }