Support for interpolated declarations in the js parser.

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_ast;
 
 
@@ skipping 166 matching lines @@
 
     js('{#:1, #:2}',  [s, 'bye'])    -->  {hello: 1, bye: 2}
 
 
 What is not implemented:
 
  -  Array initializers and object initializers could support splicing.  In the
     array case, we would need some way to know if an ArrayInitializer argument
     should be splice or is intended as a single value.
 
- -  There are no placeholders in definition contexts:
-
-        function #(){}
-        var # = 1;
-
 */
 const JsBuilder js = const JsBuilder();
 
 
 class JsBuilder {
   const JsBuilder();
 
   /**
    * Parses a bit of JavaScript, and returns an expression.
    *
@@ skipping 557 matching lines @@
       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());
+    if (lastCategory == ALPHA || lastCategory == HASH) {
+      Declaration name = parseVariableDeclaration();
+      return new NamedFunction(name, parseFun());
     }
     return parseFun();
   }
 
   Expression parseFun() {
     List<Parameter> params = <Parameter>[];
 
     expectCategory(LPAREN);
     if (!acceptCategory(RPAREN)) {
       for (;;) {
@@ skipping 225 matching lines @@
   Expression parseExpression() {
     Expression expression = parseAssignment();
     while (acceptCategory(COMMA)) {
       Expression right = parseAssignment();
       expression = new Binary(',', expression, right);
     }
     return expression;
   }
 
   VariableDeclarationList parseVariableDeclarationList() {
-    String firstVariable = lastToken;
-    expectCategory(ALPHA);
+    Declaration firstVariable = parseVariableDeclaration();
     return finishVariableDeclarationList(firstVariable);
   }
 
-  VariableDeclarationList finishVariableDeclarationList(String firstVariable) {
+  VariableDeclarationList finishVariableDeclarationList(
+      Declaration firstVariable) {
     var initialization = [];
 
-    void declare(String variable) {
+    void declare(Declaration declaration) {
       Expression initializer = null;
       if (acceptString("=")) {
         initializer = parseAssignment();
       }
-      var declaration = new VariableDeclaration(variable);
       initialization.add(new VariableInitialization(declaration, initializer));
     }
 
     declare(firstVariable);
     while (acceptCategory(COMMA)) {
-      String variable = lastToken;
-      expectCategory(ALPHA);
+      Declaration variable = parseVariableDeclaration();
       declare(variable);
     }
     return new VariableDeclarationList(initialization);
   }
 
   Expression parseVarDeclarationOrExpression() {
     if (acceptString("var")) {
       return parseVariableDeclarationList();
     } else {
       return parseExpression();
@@ skipping 168 matching lines @@
       Statement body = parseStatement();
       return new For(init, condition, update, body);
     }
 
     expectCategory(LPAREN);
     if (acceptCategory(SEMICOLON)) {
       return finishFor(null);
     }
 
     if (acceptString('var')) {
-      String identifier = lastToken;
-      expectCategory(ALPHA);
+      Declaration declaration = parseVariableDeclaration();
       if (acceptString('in')) {
         Expression objectExpression = parseExpression();
         expectCategory(RPAREN);
         Statement body = parseStatement();
         return new ForIn(
             new VariableDeclarationList([
-                new VariableInitialization(
-                    new VariableDeclaration(identifier), null)]),
+                new VariableInitialization(declaration, null)]),
             objectExpression,
             body);
       }
-      Expression declarations = finishVariableDeclarationList(identifier);
+      Expression declarations = finishVariableDeclarationList(declaration);
       expectCategory(SEMICOLON);
       return finishFor(declarations);
     }
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
     return finishFor(init);
   }
 
+  Declaration parseVariableDeclaration() {
+    if (acceptCategory(HASH)) {
+      var nameOrPosition = parseHash();
+      InterpolatedDeclaration declaration =
+          new InterpolatedDeclaration(nameOrPosition);
+      interpolatedValues.add(declaration);
+      return declaration;
+    } else {
+      String token = lastToken;
+      expectCategory(ALPHA);
+      return new VariableDeclaration(token);
+    }
+  }
+
   Statement parseFunctionDeclaration() {
-    String name = lastToken;
-    expectCategory(ALPHA);
+    Declaration name = parseVariableDeclaration();
     Expression fun = parseFun();
-    return new FunctionDeclaration(new VariableDeclaration(name), fun);
+    return new FunctionDeclaration(name, fun);
   }
 
   Statement parseTry() {
     expectCategory(LBRACE);
     Block body = parseBlock();
     String token = lastToken;
     Catch catchPart = null;
     if (acceptString('catch')) catchPart = parseCatch();
     Block finallyPart = null;
     if (acceptString('finally')) {
@@ skipping 54 matching lines @@
     List<SwitchClause> clauses = new List<SwitchClause>();
     while(lastCategory != RBRACE) {
       clauses.add(parseSwitchClause());
     }
     expectCategory(RBRACE);
     return new Switch(key, clauses);
   }
 
   Catch parseCatch() {
     expectCategory(LPAREN);
-    String identifier = lastToken;
-    expectCategory(ALPHA);
+    Declaration errorName = parseVariableDeclaration();
     expectCategory(RPAREN);
     expectCategory(LBRACE);
     Block body = parseBlock();
-    return new Catch(new VariableDeclaration(identifier), body);
+    return new Catch(errorName, body);
   }
 }