dart2js: Accept named holes in js-templates.

pkg/compiler/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;
 
 
@@ skipping 190 matching lines @@
    *
    * See the MiniJsParser class.
    *
    * [arguments] can be a single [Node] (e.g. an [Expression] or [Statement]) or
    * a list of [Node]s, which will be interpolated into the source at the '#'
    * signs.
    */
   Expression call(String source, [var arguments]) {
     Template template = _findExpressionTemplate(source);
     if (arguments == null) return template.instantiate([]);
-    return template.instantiate(arguments is List ? arguments : [arguments]);
+    // We allow a single argument to be given directly.
+    if (arguments is! List && arguments is! Map) arguments = [arguments];
+    return template.instantiate(arguments);
   }
 
   /**
    * Parses a JavaScript Statement, otherwise just like [call].
    */
   Statement statement(String source, [var arguments]) {
     Template template = _findStatementTemplate(source);
     if (arguments == null) return template.instantiate([]);
-    return template.instantiate(arguments is List ? arguments : [arguments]);
+    // We allow a single argument to be given directly.
+    if (arguments is! List && arguments is! Map) arguments = [arguments];
+    return template.instantiate(arguments);
   }
 
   /**
    * Parses JavaScript written in the `JS` foreign instruction.
    *
    * The [source] must be a JavaScript expression or a JavaScript throw
    * statement.
    */
   Template parseForeignJS(String source) {
     // TODO(sra): Parse with extra validation to forbid `#` interpolation in
@@ skipping 164 matching lines @@
         position = 0 {
     getToken();
   }
 
   int lastCategory = NONE;
   String lastToken = null;
   int lastPosition = 0;
   int position = 0;
   bool skippedNewline = false;  // skipped newline in last getToken?
   final String src;
+
   final List<InterpolatedNode> interpolatedValues = <InterpolatedNode>[];
+  bool get hasNamedHoles =>
+      interpolatedValues.isNotEmpty && interpolatedValues.first.isNamed;
+  bool get hasPositionalHoles =>
+      interpolatedValues.isNotEmpty && interpolatedValues.first.isPositional;
 
   static const NONE = -1;
   static const ALPHA = 0;
   static const NUMERIC = 1;
   static const STRING = 2;
   static const SYMBOL = 3;
   static const ASSIGNMENT = 4;
   static const DOT = 5;
   static const LPAREN = 6;
   static const RPAREN = 7;
@@ skipping 241 matching lines @@
       getToken();
       return true;
     }
     return false;
   }
 
   void error(message) {
     throw new MiniJsParserError(this, message);
   }
 
+  /// Returns either the name for the hole, or its integer position.
+  parseHash() {
+    String holeName = lastToken;
+    if (acceptCategory(ALPHA)) {
+      // Named hole. Example: 'function #funName() { ... }'
+      if (hasPositionalHoles) {
+        error('Holes must all be positional or named. $holeName');
+      }
+      return holeName;
+    } else {
+      if (hasNamedHoles) {
+        error('Holes must all be positional or named. $holeName');
+      }
+      int position = interpolatedValues.length;
+      return position;
+    }
+  }
+
   Expression parsePrimary() {
     String last = lastToken;
     if (acceptCategory(ALPHA)) {
       if (last == "true") {
         return new LiteralBool(true);
       } else if (last == "false") {
         return new LiteralBool(false);
       } else if (last == "null") {
         return new LiteralNull();
       } else if (last == "function") {
@@ skipping 21 matching lines @@
       }
       return new ArrayInitializer(values.length, values);
     } else if (last != null && last.startsWith("/")) {
       String regexp = getDelimited(lastPosition);
       getToken();
       String flags = lastToken;
       if (!acceptCategory(ALPHA)) flags = "";
       Expression expression = new RegExpLiteral(regexp + flags);
       return expression;
     } else if (acceptCategory(HASH)) {
+      var nameOrPosition = parseHash();
       InterpolatedExpression expression =
-          new InterpolatedExpression(interpolatedValues.length);
+          new InterpolatedExpression(nameOrPosition);
       interpolatedValues.add(expression);
       return expression;
     } else {
       error("Expected primary expression");
       return null;
     }
   }
 
   Expression parseFunctionExpression() {
     String last = lastToken;
     if (acceptCategory(ALPHA)) {
       String functionName = last;
       return new NamedFunction(new VariableDeclaration(functionName),
           parseFun());
     }
     return parseFun();
   }
 
   Expression parseFun() {
     List<Parameter> params = <Parameter>[];
 
     expectCategory(LPAREN);
     if (!acceptCategory(RPAREN)) {
       for (;;) {
         if (acceptCategory(HASH)) {
+          var nameOrPosition = parseHash();
           InterpolatedParameter parameter =
-              new InterpolatedParameter(interpolatedValues.length);
+              new InterpolatedParameter(nameOrPosition);
           interpolatedValues.add(parameter);
           params.add(parameter);
         } else {
           String argumentName = lastToken;
           expectCategory(ALPHA);
           params.add(new Parameter(argumentName));
         }
         if (acceptCategory(COMMA)) continue;
         expectCategory(RPAREN);
         break;
@@ skipping 12 matching lines @@
       // Limited subset: keys are identifiers, no 'get' or 'set' properties.
       Literal propertyName;
       String identifier = lastToken;
       if (acceptCategory(ALPHA)) {
         propertyName = new LiteralString('"$identifier"');
       } else if (acceptCategory(STRING)) {
         propertyName = new LiteralString(identifier);
       } else if (acceptCategory(SYMBOL)) {  // e.g. void
         propertyName = new LiteralString('"$identifier"');
       } else if (acceptCategory(HASH)) {
+        var nameOrPosition = parseHash();
         InterpolatedLiteral interpolatedLiteral =
-            new InterpolatedLiteral(interpolatedValues.length);
+            new InterpolatedLiteral(nameOrPosition);
         interpolatedValues.add(interpolatedLiteral);
         propertyName = interpolatedLiteral;
       } else {
         error('Expected property name');
       }
       expectCategory(COLON);
       Expression value = parseAssignment();
       properties.add(new Property(propertyName, value));
       if (acceptCategory(RBRACE)) break;
       expectCategory(COMMA);
@@ skipping 45 matching lines @@
         // JS allows new without (), but we don't.
         if (constructor) error("Parentheses are required for new");
         break;
       }
     }
     return receiver;
   }
 
   Expression getDotRhs(Expression receiver) {
     if (acceptCategory(HASH)) {
-      InterpolatedSelector property =
-          new InterpolatedSelector(interpolatedValues.length);
+      var nameOrPosition = parseHash();
+      InterpolatedSelector property = new InterpolatedSelector(nameOrPosition);
       interpolatedValues.add(property);
       return new PropertyAccess(receiver, property);
     }
     String identifier = lastToken;
     // In ES5 keywords like delete and continue are allowed as property
     // names, and the IndexedDB API uses that, so we need to allow it here.
     if (acceptCategory(SYMBOL)) {
       if (!OPERATORS_THAT_LOOK_LIKE_IDENTIFIERS.contains(identifier)) {
         error("Expected alphanumeric identifier");
       }
@@ skipping 211 matching lines @@
 
     Expression expression = parseExpression();
     expectSemicolon();
 
     if (checkForInterpolatedStatement) {
       // 'Promote' the interpolated expression `#;` to an interpolated
       // statement.
       if (expression is InterpolatedExpression) {
         assert(identical(interpolatedValues.last, expression));
         InterpolatedStatement statement =
-            new InterpolatedStatement(expression.name);
+            new InterpolatedStatement(expression.nameOrPosition);
         interpolatedValues[interpolatedValues.length - 1] = statement;
         return statement;
       }
     }
 
     return new ExpressionStatement(expression);
   }
 
   Statement parseReturn() {
     if (acceptSemicolon()) return new Return();
@@ skipping 110 matching lines @@
   Catch parseCatch() {
     expectCategory(LPAREN);
     String identifier = lastToken;
     expectCategory(ALPHA);
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     Block body = parseBlock();
     return new Catch(new VariableDeclaration(identifier), body);
   }
 }