JS templates

sdk/lib/_internal/compiler/implementation/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;
 
+
+/**
+ * Global template manager.  We should aim to have a fixed number of
+ * templates. This implies that we do not use js('xxx') to parse text that is
+ * constructed from values that depend on names in the Dart program.
+ *
+ * TODO(sra): Find the remaining places where js('xxx') used to parse an

[floitsch, 2014/04/22 16:11:18]

I'm currently pushing to remove all statics from the system.
If possible we should make this an instance variable.

[sra1, 2014/04/23 02:33:50]

I'm not sure how to find it without making the templates tedious to use.
They are reasonably staged.  In batch mode (and pub) on the second compile most
JS parsing will have been done.

+ * unbounded number of expression, or institute a cache policy.
+ */
+TemplateManager templateManager = new TemplateManager();
+
+
+/**
+
+[js] is a singleton instace of JsBuilder.  JsBuilder is a set of conveniences
+for constructing JavaScript ASTs.
+
+[string] and [number] are used to create leaf AST nodes:
+
+    var s = js.string('hello');    //  s = new LiteralString('"hello"')
+    var n = js.number(123);        //  n = new LiteralNumber(123)
+    var vFoo = new VariableUse('foo')  --> foo

[floitsch, 2014/04/22 16:11:18]

what does `new VariableUse` have to do with `js`?

[sra1, 2014/04/23 02:33:50]

Done.

+
+In the line above `a --> b` means Dart expression `a` evaluates to a JavaScript
+AST that would pretty-print as `b`.
+
+The [call] method constructs an Expression AST.  Since the builder is bound to

[floitsch, 2014/04/22 16:11:18]

Not sure I understand the second sentence. It's just saying that js ==
JsBuilder, right? But that's the first sentence of this whole dartdoc.

[sra1, 2014/04/23 02:33:50]

Done.

+[js] `js` is used to construct JavaScript from a fragment of source.
+
+No argument
+
+    js('window.alert("hello")')  -->  window.alert("hello")
+
+The input text can contain placeholders `#` that are replace with provided

[floitsch, 2014/04/22 16:11:18]

replaced

[sra1, 2014/04/23 02:33:50]

Done.

+arguments.  A single argument can be passed directly:
+
+    js('window.alert(#)', s)   -->  window.alert("hello")
+
+Multiple arguments are passed as a list:
+
+    js('# + #', [s, s])  -->  "hello" + "hello"
+
+The [statement] method constructs a Statement AST, but is otherwise like the
+[call] method.  This constructs a Return AST:
+
+    var ret = js.statement('return #;', n);  -->  return 123;
+
+A placeholder in a Statement context must be followed by a semicolon ';'.  You
+can think of a statement placeholder as being `#;` to explain why the output
+still has one semicolon:
+
+    js.statement('if (happy) #;', ret)
+    -->
+    if (happy)
+      return 123;
+
+If the placeholder is not followed by a semicolon, it is part of an expression.
+Here the paceholder is in the position of a function in a function call.
+
+    js.statement('if (happy) #("Happy!")', vFoo)
+    -->
+    if (happy)
+      foo("Happy!");
+
+Generally, a placeholder in an expression position requires an Expression AST as
+an argument and a placeholder in a statement position requires a Statement AST.
+An expression will be converted to a Statement of needed by creating an
+ExpessionStatement.  A String argument in a will be converted into a VariableUse
+and requires that the string is a JavaScript identifier.
+
+    js('# + 1', vFoo)       -->  foo + 1
+    js('# + 1', 'foo')      -->  foo + 1
+    js('# + 1', 'foo.bar')  -->  assertion failure
+
+Some placeholder positions are _splicing contexts_.  A function argument list is
+a splicing expression context.  A placeholder in a splicing expression context
+can take a single Expression (or String, converted to VariableUse) or an
+Iterable of Expressions (and/or Strings).
+
+    // non-splicing argument:
+    js('#(#)', ['say', s])        -->  say("hello")
+    // splicing arguments:
+    js('#(#)', ['say', []])       -->  say()
+    js('#(#)', ['say', [s]])      -->  say("hello")
+    js('#(#)', ['say', [s, n]])   -->  say("hello", 123)
+
+A splicing context can be used to append 'lists' and add extra elements:
+
+    js('foo(#, #, 1)', [ ['a', n], s])       -->  foo(a, 123, "hello", 1)
+    js('foo(#, #, 1)', [ ['a', n], [s, n]])  -->  foo(a, 123, "hello", 123, 1)
+    js('foo(#, #, 1)', [ [], [s, n]])        -->  foo("hello", 123, 1)
+    js('foo(#, #, 1)', [ [], [] ])           -->  foo(1)
+
+The generation of a compile-time optional argument expression can be chosen by
+providing an empty or singleton list.
+
+In addition to Expressions and Statements, there are Parameters, which occur
+only in the parameter list of a function expression or declaration.
+Placeholders in parameter positions behave like placeholders in Expression
+positions, except only Parameter AST nodes are permitted.  String arguments for
+parameter placeholders are converted to Parameter AST nodes.
+
+    var pFoo = new Parameter('foo')
+    js('function(#) { return #; }', [pFoo, vFoo]) --> function(foo){return foo;}
+
+Expressions and Parameters are not compatible with each other's context:
+
+    js('function(#) { return #; }', [vFoo, vFoo]) --> error
+    js('function(#) { return #; }', [pFoo, pFoo]) --> error
+
+The parameter context is a splicing context.  When combined with the
+context-sensitive conversion of Strings, this simplifies the construction of
+trampoline-like functions:
+
+    var args = ['a', 'b'];
+    js('function(#) { return f(this, #); }', [args, args])
+    -->
+    function(a, b) { return f(this, a, b); }
+
+A statement placeholder in a Block is also in a splicing context.  In addition
+to splicing Iterables, statement placeholders in a Block will also splice a
+Block or an EmptyStatement.  This flattens nested blocks and allows blocks to be
+appended.
+
+    var b1 = js.statement('{ 1; 2; }');
+    var sEmpty = new Emptystatement();
+    js.statement('{ #; #; #; #; }', [sEmpty, b1, b1, sEmpty])
+    -->
+    { 1; 2; 1; 2; }
+
+A placeholder in the context of an if-statement condition also accepts a Dart
+bool argument, which select then-part or else-part of the if-statement:
+
+    js.statement('if (#) return;', vFoo)   -->  if (foo) return;
+    js.statement('if (#) return;', true)   -->  return;
+    js.statement('if (#) return;', false)  -->  ;   // empty statement
+    var eTrue = new LiteralBool(true);
+    js.statement('if (#) return;', eTrue)  -->  if (true) return;
+
+Combined with block splicing, if-statement condition context placeholders allows
+the creation of tenplates that select code depending on variables.
+
+    js.statement('{ 1; if (#) 2; else { 3; 4; } 5;}', true)
+    --> { 1; 2; 5; }
+
+    js.statement('{ 1; if (#) 2; else { 3; 4; } 5;}', false)
+    --> { 1; 3; 4; 5; }
+
+A placeholder following a period in a property access is in a property access
+context.  This is just like an expression context, except String arguments are
+converted to JavaScript property accesses.  In JavaScript, `a.b` is short-hand
+for `a["b"]`:
+
+    js('a[#]', vFoo)  -->  a[foo]
+    js('a[#]', s)     -->  a.hello    (i.e. a["hello"]).
+    js('a[#]', 'x')   -->  a[x]
+
+    js('a.#', vFoo)   -->  a[foo]
+    js('a.#', s)      -->  a.hello    (i.e. a["hello"])
+    js('a.#', 'x')    -->  a.x        (i.e. a["x"])
+
+(Question - should `.#` be restricted to permit only String arguments? The
+template should probably be writted with `[]` if non-strings are accepted.)

[floitsch, 2014/04/22 16:11:18]

I would say yes. Let's not allow non-string arguments.

I'm not even sure I like "a.#", but I haven't yet seen the use-cases.

[sra1, 2014/04/23 02:33:50]

Presumably you saw that a.# was used extensively.

+
+
+Object initialiers allow placeholders in the key posiition:

[floitsch, 2014/04/22 16:11:18]

initializers position

[sra1, 2014/04/23 02:33:50]

Done.

+
+    js('{#:1, #:2}',  [s, 'bye'])    -->  {hello: 1, bye: 2}
+
+
+TODO: Array initializers and object initializers could support splicing.  In

[floitsch, 2014/04/22 16:11:18]

TODO(sra) or TODO(issue-number)

[sra1, 2014/04/23 02:33:50]

I rephased this since I'm not sure it is a TODO.

+the array case, we would need some way to know if an ArrayInitializer argument
+should be splice or is intended as a single value.
+
+TODO: There are no placeholders in definition contexts:

[floitsch, 2014/04/22 16:11:18]

ditto.

[sra1, 2014/04/23 02:33:50]

I rephased this since I'm not sure it is a TODO.

+
+    function #(){}
+    var #=1;
+
+*/
+const JsBuilder js = const JsBuilder();

[floitsch, 2014/04/22 16:11:18]

In order to get rid of the static state we could remove the global "js" and make
it a member of all the classes that need it.
That is: js-backend would create a new JsBuilder (that contains state for the
template canonicalization). Other classes could then have a js getter that
redirects to backend.js.

[floitsch, 2014/04/22 16:11:18]

On the other hand I can see how this makes repeated compilations more
efficient...

[sra1, 2014/04/23 02:33:50]

That is part of the plan :-)

[sra1, 2014/04/23 02:33:50]

Or we could make the state independent of any compilation.
If we do have slow leaks we could put in an LRU-like cache.

+
+
 class JsBuilder {
   const JsBuilder();
 
   /**
    * Parses a bit of JavaScript, and returns an expression.
    *
    * See the MiniJsParser class.
    *
-   * [expression] can be an [Expression] or a list of [Expression]s, which will
-   * be interpolated into the source at the '#' signs.
+   * [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 expression]) {
-    var result = new MiniJsParser(source).expression();
-    if (expression == null) return result;
-
-    List<Node> nodes;
-    if (expression is List) {
-      nodes = expression;
-    } else {
-      nodes = <Node>[expression];
-    }
-    if (nodes.length != result.interpolatedNodes.length) {
-      throw 'Unmatched number of interpolated expressions given ${nodes.length}'
-          ' expected ${result.interpolatedNodes.length}';
-    }
-    for (int i = 0; i < nodes.length; i++) {
-      result.interpolatedNodes[i].assign(nodes[i]);
-    }
-
-    return result.value;
+  Expression call(String source, [var arguments]) {
+    Template template = _findExpressionTemplate(source);
+    if (arguments == null) return template.instantiate([]);
+    return template.instantiate(arguments is List ? arguments : [arguments]);
   }
 
-  Statement statement(String source) {
-    var result = new MiniJsParser(source).statement();
-    // TODO(sra): Interpolation.
-    return result;
+  /**
+   * 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]);
   }
 
-  // Parse JavaScript written in the JS foreign instruction.
-  Expression parseForeignJS(String source, [var expression]) {
-    // We can parse simple JS with the mini parser.  At the moment we can't
-    // handle JSON literals and function literals, both of which contain "{".
-    if (source.contains("{") || source.startsWith("throw ")) {
-      assert(expression == null);
-      return new LiteralExpression(source);
+  /**
+   * 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
+    // functions, as this leads to unanticipated capture of temporaries that can

[floitsch, 2014/04/22 16:11:18]

-can-

[sra1, 2014/04/23 02:33:50]

Done.

+    // are reused after capture.
+    if (source.startsWith("throw ")) {
+      return _findStatementTemplate(source);
+    } else {
+      return _findExpressionTemplate(source);
     }
-    return call(source, expression);
+  }
+
+  Template _findExpressionTemplate(String source) {
+    Template template = templateManager.lookupExpressionTemplate(source);
+    if (template == null) {
+      MiniJsParser parser = new MiniJsParser(source);
+      Expression expression = parser.expression();
+      template = templateManager.defineExpressionTemplate(source, expression);
+    }
+    return template;
+  }
+
+  Template _findStatementTemplate(String source) {
+    Template template = templateManager.lookupStatementTemplate(source);
+    if (template == null) {
+      MiniJsParser parser = new MiniJsParser(source);
+      Statement expression = parser.statement();

[floitsch, 2014/04/22 16:11:18]

s/expression/statement

[sra1, 2014/04/23 02:33:50]

Done.

+      template = templateManager.defineStatementTemplate(source, expression);
+    }
+    return template;
+  }
+
+  /**
+   * Creates an Expression template without caching the result.
+   */
+  Template uncachedExpressionTemplate(String source) {
+    MiniJsParser parser = new MiniJsParser(source);
+    Expression expression = parser.expression();
+    return new Template(
+        source, expression, isExpression: true, forceCopy: false);
+  }
+
+  /**
+   * Create an Expression template which has [ast] as the result.  This is used
+   * to wrap a generated AST in a zero-argument Template so it can be passed to
+   * context that expects a template.
+   */
+  Template expressionTemplateYielding(Node ast) {
+    return new Template.withExpressionResult(ast);
   }
 
   /// Creates a litteral js string from [value].
   LiteralString escapedString(String value) {
     // Do not escape unicode characters and ' because they are allowed in the
     // string literal anyway.
     String escaped =
         value.replaceAllMapped(new RegExp('\n|"|\\|\0|\b|\t|\v'), (match) {
       switch (match.group(0)) {
         case "\n" : return r"\n";
@@ skipping 16 matching lines @@
   /// Creates a litteral js string from [value].
   ///
   /// Note that this function only puts quotes around [value]. It does not do
   /// any escaping, so use only when you can guarantee that [value] does not
   /// contain newlines or backslashes. For escaping the string use
   /// [escapedString].
   LiteralString string(String value) => new LiteralString('"$value"');
 
   LiteralNumber number(num value) => new LiteralNumber('$value');
 
-  If if_(condition, thenPart, [elsePart]) {
-    condition = toExpression(condition);
-    return (elsePart == null)
-        ? new If.noElse(condition, toStatement(thenPart))
-        : new If(condition, toStatement(thenPart), toStatement(elsePart));
-  }
-
-  Return return_([value]) {
-    return new Return(value == null ? null : toExpression(value));
-  }
-
-  Block block(statement) {
-    if (statement is Block) {
-      return statement;
-    } else if (statement is List) {
-      List<Statement> statements = statement
-          .map(toStatement)
-          .where((s) => s is !EmptyStatement)
-          .toList();
-      return new Block(statements);
-    } else {
-      return new Block(<Statement>[toStatement(statement)]);
-    }
-  }
-
-  Fun fun(parameters, body) {
-    Parameter toParameter(parameter) {
-      if (parameter is String) {
-        return new Parameter(parameter);
-      } else if (parameter is Parameter) {
-        return parameter;
-      } else {
-        throw new ArgumentError('parameter should be a String or a Parameter');
-      }
-    }
-    if (parameters is! List) {
-      parameters = [parameters];
-    }
-    return new Fun(parameters.map(toParameter).toList(), block(body));
-  }
-
-  VariableDeclarationList defineVar(String name, [initializer]) {
-    if (initializer != null) {
-      initializer = toExpression(initializer);
-    }
-    var declaration = new VariableDeclaration(name);
-    var initialization = [new VariableInitialization(declaration, initializer)];
-    return new VariableDeclarationList(initialization);
-  }
-
-  Statement toStatement(statement) {
-    if (statement is List) {
-      return block(statement);
-    } else if (statement is Node) {
-      return statement.toStatement();
-    } else {
-      throw new ArgumentError('statement');
-    }
-  }
-
-  Expression toExpression(expression) {
-    if (expression == null) {
-      return null;
-    } else if (expression is Expression) {
-      return expression;
-    } else if (expression is String) {
-      return this(expression);
-    } else if (expression is num) {
-      return new LiteralNumber('$expression');
-    } else if (expression is bool) {
-      return new LiteralBool(expression);
-    } else if (expression is Map) {
-      if (!expression.isEmpty) {
-        throw new ArgumentError('expression should be an empty Map');
-      }
-      return new ObjectInitializer([]);
-    } else if (expression is List) {
-      var values = new List<ArrayElement>.generate(expression.length,
-          (index) => new ArrayElement(index, toExpression(expression[index])));
-      return new ArrayInitializer(values.length, values);
-    } else {
-      throw new ArgumentError('expression should be an Expression, '
-                              'a String, a num, a bool, a Map, or a List;');
-    }
-  }
-
-  ForIn forIn(String name, object, statement) {
-    return new ForIn(defineVar(name),
-                     toExpression(object),
-                     toStatement(statement));
-  }
-
-  For for_(init, condition, update, statement) {
-    return new For(
-        toExpression(init), toExpression(condition), toExpression(update),
-        toStatement(statement));
-  }
-
-  While while_(condition, statement) {
-    return new While(
-        toExpression(condition), toStatement(statement));
-  }
-
-  Try try_(body, {catchPart, finallyPart}) {
-    if (catchPart != null) catchPart = toStatement(catchPart);
-    if (finallyPart != null) finallyPart = toStatement(finallyPart);
-    return new Try(toStatement(body), catchPart, finallyPart);
-  }
+  //Expression toExpression(expression) {

[floitsch, 2014/04/22 16:11:18]

dead code?

[sra1, 2014/04/23 02:33:50]

Yes.  It was the only one that was slightly painful to remove, so I would not
mind too much if something like it came back to convert Dart mixed element-type
lists into JS expression.

+  //  if (expression == null) {
+  //    return null;
+  //  } else if (expression is Expression) {
+  //    return expression;
+  //  } else if (expression is String) {
+  //    return this(expression);
+  //  } else if (expression is num) {
+  //    return new LiteralNumber('$expression');
+  //  } else if (expression is bool) {
+  //    return new LiteralBool(expression);
+  //  } else if (expression is Map) {
+  //    if (!expression.isEmpty) {
+  //      throw new ArgumentError('expression should be an empty Map');
+  //    }
+  //    return new ObjectInitializer([]);
+  //  } else if (expression is List) {
+  //    var values = new List<ArrayElement>.generate(expression.length,
+  //        (index) => new ArrayElement(index, toExpression(expression[index])));
+  //    return new ArrayInitializer(values.length, values);
+  //  } else {
+  //    throw new ArgumentError('expression should be an Expression, '
+  //                            'a String, a num, a bool, a Map, or a List;');
+  //  }
+  //}
 
   Comment comment(String text) => new Comment(text);
 }
 
-const JsBuilder js = const JsBuilder();
-
 LiteralString string(String value) => js.string(value);
 
 class MiniJsParserError {
   MiniJsParserError(this.parser, this.message) { }
 
   final MiniJsParser parser;
   final String message;
 
   String toString() {
     int pos = parser.lastPosition;
@@ skipping 21 matching lines @@
 /// * identifiers.
 /// * dot access.
 /// * method calls.
 /// * [] access.
 /// * array, string, regexp, boolean, null and numeric literals.
 /// * most operators.
 /// * brackets.
 /// * var declarations.
 /// * operator precedence.
 /// Notable things it can't do yet include:
-/// * non-empty object literals.
-/// * throw, return.
-/// * statements, including any flow control (if, while, for, etc.)
+/// * some statements are still missing (do-while, while, switch.

[floitsch, 2014/04/22 16:11:18]

missing closing parenthesis.

[sra1, 2014/04/23 02:33:50]

Done.

 ///
 /// It's a fairly standard recursive descent parser.
 ///
 /// Literal strings are passed through to the final JS source code unchanged,
 /// including the choice of surrounding quotes, so if you parse
 /// r'var x = "foo\n\"bar\""' you will end up with
 ///   var x = "foo\n\"bar\"" in the final program.  \x and \u escapes are not
 /// allowed in string and regexp literals because the machinery for checking
 /// their correctness is rather involved.
 class MiniJsParser {
@@ skipping 134 matching lines @@
     } while (currentCode != delimiter);
     position++;
     return src.substring(lastPosition, position);
   }
 
   void getToken() {
     skippedNewline = false;
     for (;;) {
       if (position >= src.length) break;
       int code = src.codeUnitAt(position);
-      //  Skip '//' style comment.
+      //  Skip '//' and '/*' style comments.
       if (code == charCodes.$SLASH &&
-          position + 1 < src.length &&
-          src.codeUnitAt(position + 1) == charCodes.$SLASH) {
-        int nextPosition = src.indexOf('\n', position);
-        if (nextPosition == -1) nextPosition = src.length;
-        position = nextPosition;
-      } else {
-        if (category(code) != WHITESPACE) break;
-        if (code == charCodes.$LF) skippedNewline = true;
-        ++position;
+          position + 1 < src.length) {
+        if (src.codeUnitAt(position + 1) == charCodes.$SLASH) {
+          int nextPosition = src.indexOf('\n', position);
+          if (nextPosition == -1) nextPosition = src.length;
+          position = nextPosition;
+          continue;
+        } else if (src.codeUnitAt(position + 1) == charCodes.$STAR) {
+          int nextPosition = src.indexOf('*/', position + 2);
+          if (nextPosition == -1) error('Unterminated comment');
+          position = nextPosition + 2;
+          continue;
+        }
       }
+      if (category(code) != WHITESPACE) break;
+      if (code == charCodes.$LF) skippedNewline = true;
+      ++position;
     }
 
     if (position == src.length) {
       lastCategory = NONE;
       lastToken = null;
       lastPosition = position;
       return;
     }
     int code = src.codeUnitAt(position);
     lastPosition = position;
@@ skipping 75 matching lines @@
 
   void expectSemicolon() {
     if (acceptSemicolon()) return;
     error('Expected SEMICOLON');
   }
 
   bool acceptSemicolon() {
     // Accept semicolon or automatically inserted semicolon before close brace.
     // Miniparser forbids other kinds of semicolon insertion.
     if (RBRACE == lastCategory) return true;
+    if (NONE == lastCategory) return true;  // end of input
     if (skippedNewline) {
       error('No automatic semicolon insertion at preceding newline');
     }
     return acceptCategory(SEMICOLON);
   }
 
   bool acceptString(String string) {
     if (lastToken == string) {
       getToken();
       return true;
@@ skipping 39 matching lines @@
       }
       return new ArrayInitializer(values.length, values);
     } else if (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)) {
-      InterpolatedExpression expression = new InterpolatedExpression(null);
+      InterpolatedExpression expression =
+          new InterpolatedExpression(interpolatedValues.length);
       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);
-    String argumentName = lastToken;
-    if (acceptCategory(ALPHA)) {
-      params.add(new Parameter(argumentName));
-      while (acceptCategory(COMMA)) {
-        argumentName = lastToken;
-        expectCategory(ALPHA);
-        params.add(new Parameter(argumentName));
+    if (!acceptCategory(RPAREN)) {
+      for (;;) {
+        if (acceptCategory(HASH)) {
+          InterpolatedParameter parameter =
+              new InterpolatedParameter(interpolatedValues.length);
+          interpolatedValues.add(parameter);
+          params.add(parameter);
+        } else {
+          String argumentName = lastToken;
+          expectCategory(ALPHA);
+          params.add(new Parameter(argumentName));
+        }
+        if (acceptCategory(COMMA)) continue;
+        expectCategory(RPAREN);
+        break;
       }
     }
-    expectCategory(RPAREN);
+
     expectCategory(LBRACE);
     Block block = parseBlock();
     return new Fun(params, block);
   }
 
   Expression parseObjectInitializer() {
     List<Property> properties = <Property>[];
     for (;;) {
       if (acceptCategory(RBRACE)) break;
       // 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)) {
+        InterpolatedLiteral interpolatedLiteral =
+            new InterpolatedLiteral(interpolatedValues.length);
+        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);
     }
     return new ObjectInitializer(properties);
@@ skipping 42 matching lines @@
       } else {
         // 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);
+      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");
       }
     } else {
       expectCategory(ALPHA);
     }
@@ skipping 131 matching lines @@
     } else {
       return parseExpression();
     }
   }
 
   Expression expression() {
     Expression expression = parseVarDeclarationOrExpression();
     if (lastCategory != NONE || position != src.length) {
       error("Unparsed junk: ${categoryToString(lastCategory)}");
     }
-    if (!interpolatedValues.isEmpty) {
-      return new JSExpression(expression, interpolatedValues);
-    }
     return expression;
   }
 
   Statement statement() {
     Statement statement = parseStatement();
     if (lastCategory != NONE || position != src.length) {
       error("Unparsed junk: ${categoryToString(lastCategory)}");
     }
     // TODO(sra): interpolated capture here?
     return statement;
   }
 
   Block parseBlock() {
     List<Statement> statements = <Statement>[];
 
     while (!acceptCategory(RBRACE)) {
       Statement statement = parseStatement();
       statements.add(statement);
     }
     return new Block(statements);
   }
 
   Statement parseStatement() {
     if (acceptCategory(LBRACE)) return parseBlock();
 
+    if (acceptCategory(SEMICOLON)) return new EmptyStatement();
+
     if (lastCategory == ALPHA) {
       if (acceptString('return')) return parseReturn();
 
       if (acceptString('throw')) return parseThrow();
 
       if (acceptString('break')) {
         return parseBreakOrContinue((label) => new Break(label));
       }
 
       if (acceptString('continue')) {
         return parseBreakOrContinue((label) => new Continue(label));
       }
 
       if (acceptString('if')) return parseIfThenElse();
 
       if (acceptString('for')) return parseFor();
 
       if (acceptString('function')) return parseFunctionDeclaration();
 
+      if (acceptString('try')) return parseTry();
+
       if (acceptString('var')) {
         Expression declarations = parseVariableDeclarationList();
         expectSemicolon();
         return new ExpressionStatement(declarations);
       }
 
       if (lastToken == 'case' ||
           lastToken == 'do' ||
           lastToken == 'while' ||
           lastToken == 'switch' ||
-          lastToken == 'try' ||
           lastToken == 'with') {
         error('Not implemented in mini parser');
       }
     }
 
-    if (acceptCategory(HASH)) {
-      InterpolatedStatement statement = new InterpolatedStatement(null);
-      interpolatedValues.add(statement);
-      return statement;
-    }
 
     // TODO:  label: statement
 
+    bool checkForInterpolatedStatement = lastCategory == HASH;
+
     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);
+        interpolatedValues[interpolatedValues.length - 1] = statement;
+        return statement;
+      }
+    }
+
     return new ExpressionStatement(expression);
   }
 
   Statement parseReturn() {
     if (acceptSemicolon()) return new Return();
     Expression expression = parseExpression();
     expectSemicolon();
     return new Return(expression);
   }
 
@@ skipping 55 matching lines @@
       return finishFor(null);
     }
 
     if (acceptString('var')) {
       String identifier = lastToken;
       expectCategory(ALPHA);
       if (acceptString('in')) {
         Expression objectExpression = parseExpression();
         expectCategory(RPAREN);
         Statement body = parseStatement();
-        return new ForIn(js.defineVar(identifier), objectExpression, body);
+        return new ForIn(
+            new VariableDeclarationList([
+                new VariableInitialization(
+                    new VariableDeclaration(identifier), null)]),
+            objectExpression,
+            body);
       }
       Expression declarations = finishVariableDeclarationList(identifier);
       expectCategory(SEMICOLON);
       return finishFor(declarations);
     }
 
     Expression init = parseExpression();
     expectCategory(SEMICOLON);
     return finishFor(init);
   }
 
   Statement parseFunctionDeclaration() {
     String name = lastToken;
     expectCategory(ALPHA);
     Expression fun = parseFun();
     return new FunctionDeclaration(new VariableDeclaration(name), fun);
   }
-}
 
-/**
- * Clone a JSExpression node into an expression where all children
- * have been cloned, and [InterpolatedExpression]s have been replaced
- * with real [Expression].
- */
-class UninterpolateJSExpression extends BaseVisitor<Node> {
-  final List<Expression> arguments;
-  int argumentIndex = 0;
-
-  UninterpolateJSExpression(this.arguments);
-
-  void error(message) {
-    throw message;
+  Statement parseTry() {
+    expectCategory(LBRACE);
+    Block body = parseBlock();
+    String token = lastToken;
+    Catch catchPart = null;
+    if (acceptString('catch')) catchPart = parseCatch();
+    Block finallyPart = null;
+    if (acceptString('finally')) {
+      expectCategory(LBRACE);
+      finallyPart = parseBlock();
+    } else {
+      if (catchPart == null) error("expected 'finally'");
+    }
+    return new Try(body, catchPart, finallyPart);
   }
 
-  Node visitNode(Node node) {
-    error('Cannot handle $node');
-    return null;
-  }
-
-  Node copyPosition(Node oldNode, Node newNode) {
-    newNode.sourcePosition = oldNode.sourcePosition;
-    newNode.endSourcePosition = oldNode.endSourcePosition;
-    return newNode;
-  }
-
-  Node visit(Node node) {
-    return node == null ? null : node.accept(this);
-  }
-
-  List<Node> visitList(List<Node> list) {
-    return list.map((e) => visit(e)).toList();
-  }
-
-  Node visitLiteralString(LiteralString node) {
-    return node;
-  }
-
-  Node visitVariableUse(VariableUse node) {
-    return node;
-  }
-
-  Node visitAccess(PropertyAccess node) {
-    return copyPosition(node,
-        new PropertyAccess(visit(node.receiver), visit(node.selector)));
-  }
-
-  Node visitCall(Call node) {
-    return copyPosition(node,
-        new Call(visit(node.target), visitList(node.arguments)));
-  }
-
-  Node visitInterpolatedExpression(InterpolatedExpression expression) {
-    return arguments[argumentIndex++];
-  }
-
-  Node visitInterpolatedStatement(InterpolatedStatement statement) {
-    return arguments[argumentIndex++];
-  }
-
-  Node visitJSExpression(JSExpression expression) {
-    assert(argumentIndex == 0);
-    Node result = visit(expression.value);
-    if (argumentIndex != arguments.length) {
-      error("Invalid number of arguments");
-    }
-    assert(result is! JSExpression);
-    return result;
-  }
-
-  Node visitLiteralExpression(LiteralExpression node) {
-    assert(argumentIndex == 0);
-    return copyPosition(node,
-        new LiteralExpression.withData(node.template, arguments));
-  }
-
-  Node visitAssignment(Assignment node) {
-    return copyPosition(node,
-        new Assignment._internal(visit(node.leftHandSide),
-                                 visit(node.compoundTarget),
-                                 visit(node.value)));
-  }
-
-  Node visitRegExpLiteral(RegExpLiteral node) {
-    return node;
-  }
-
-  Node visitLiteralNumber(LiteralNumber node) {
-    return node;
-  }
-
-  Node visitBinary(Binary node) {
-    return copyPosition(node,
-        new Binary(node.op, visit(node.left), visit(node.right)));
-  }
-
-  Node visitPrefix(Prefix node) {
-    return copyPosition(node,
-        new Prefix(node.op, visit(node.argument)));
-  }
-
-  Node visitPostfix(Postfix node) {
-    return copyPosition(node,
-        new Postfix(node.op, visit(node.argument)));
-  }
-
-  Node visitNew(New node) {
-    return copyPosition(node,
-        new New(visit(node.target), visitList(node.arguments)));
-  }
-
-  Node visitArrayInitializer(ArrayInitializer node) {
-    return copyPosition(node,
-        new ArrayInitializer(node.length, visitList(node.elements)));
-  }
-
-  Node visitArrayElement(ArrayElement node) {
-    return copyPosition(node,
-        new ArrayElement(node.index, visit(node.value)));
-  }
-
-  Node visitConditional(Conditional node) {
-    return copyPosition(node,
-        new Conditional(visit(node.condition),
-                        visit(node.then),
-                        visit(node.otherwise)));
-  }
-
-  Node visitLiteralNull(LiteralNull node) {
-    return node;
-  }
-
-  Node visitLiteralBool(LiteralBool node) {
-    return node;
+  Catch parseCatch() {
+    expectCategory(LPAREN);
+    String identifier = lastToken;
+    expectCategory(ALPHA);
+    expectCategory(RPAREN);
+    expectCategory(LBRACE);
+    Block body = parseBlock();
+    return new Catch(new VariableDeclaration(identifier), body);
   }
 }