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
+ * 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)
+
+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.
+
+No argument
+
+    js('window.alert("hello")')  -->  window.alert("hello")
+
+The input text can contain placeholders `#` that are replaced with provided
+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 the function in a function call:
+
+    var vFoo = new VariableUse('foo');
+    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 if needed by creating an
+ExpessionStatement.  A String argument 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 selects the 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.)
+
+
+Object initialiers allow placeholders in the key property name position:
+
+    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.
    *
    * 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 are
+    // reused after capture.
+    if (source.startsWith("throw ")) {
+      return _findStatementTemplate(source);
+    } else {
+      return _findExpressionTemplate(source);
     }
-    return call(source, expression);
   }
 
-  /// Creates a litteral js string from [value].
+  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 statement = parser.statement();
+      template = templateManager.defineStatementTemplate(source, statement);
+    }
+    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);
+  }
+
+  Template statementTemplateYielding(Node ast) {
+    return new Template.withStatementResult(ast);
+  }
+
+  /// Creates a literal 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";
         case "\\" : return r"\\";
         case "\"" : return r'\"';
         case "\0" : return r"\0";
         case "\b" : return r"\b";
         case "\t" : return r"\t";
         case "\f" : return r"\f";
         case "\v" : return r"\v";
       }
     });
     LiteralString result = string(escaped);
     // We don't escape ' under the assumption that the string is wrapped
     // into ". Verify that assumption.
     assert(result.value.codeUnitAt(0) == '"'.codeUnitAt(0));
     return result;
   }
 
-  /// Creates a litteral js string from [value].
+  /// Creates a literal 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);
-  }
-
   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 20 matching lines @@
 /// AST nodes.  Handles:
 /// * identifiers.
 /// * dot access.
 /// * method calls.
 /// * [] access.
 /// * array, string, regexp, boolean, null and numeric literals.
 /// * most operators.
 /// * brackets.
 /// * var declarations.
 /// * operator precedence.
+/// * anonymous funtions and named function expressions and declarations.
 /// 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).
 ///
 /// 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);
   }
 }