anchor.diff:      // distinction.
       // TODO(kmillikin): If we don't get rid of this Emitter, use a more
       // efficient way to accumulate nodes.
  -    Link<ast.Node> statements;
  -    if (second is ast.Block) {
  -      statements = second.statements.nodes;
  -    } else {
  -      statements = new Link<ast.Node>();
  -      if (second is ast.Expression) {
  -        second = new ast.ExpressionStatement(second,
  -            new SymbolToken(SEMICOLON_INFO, -1));
  +    LinkBuilder<ast.Node> statements = new LinkBuilder<ast.Node>();
  +
  +    addStatements(ast.Node node) {
  +      if (node is ast.Block) {
  +        for (var n in node.statements.nodes) {
  +          statements.addLast(n);
  +        }
  +      } else if (node is ast.Expression) {
  +          statements.addLast(new ast.ExpressionStatement(node, semicolon));
  +      } else {
  +        statements.addLast(node);
         }
  -      statements = statements.prepend(second);
       }
   
  -    if (first is ast.Block) {
  -      LinkBuilder<ast.Node> front = new LinkBuilder<ast.Node>();
  -      for (var n in first.statements.nodes) {
  -        front.addLast(n);
  -      }
  -      statements = front.toLink(statements);
  -    } else {
  -      if (first is ast.Expression) {
  -        first = new ast.ExpressionStatement(first,
  -            new SymbolToken(SEMICOLON_INFO, -1));
  -      }
  -      statements = statements.prepend(first);
  -    }
  -
  -    return new ast.Block(new ast.NodeList(
  -        new BeginGroupToken(OPEN_CURLY_BRACKET_INFO, -1),
  -        statements,
  -        new SymbolToken(CLOSE_CURLY_BRACKET_INFO, -1)));
  +    addStatements(first);
  +    addStatements(second);
  +
  +    return new ast.Block(
  +        new ast.NodeList(openBrace, statements.toLink(), closeBrace));
     }
   
     ast.Node visitVariable(Variable node) {
  
positive.code:         ast.Modifiers.EMPTY, null, null);
    }
  
    static ast.SendSet makeAssignment(ast.Identifier identifier,
                                      ast.Expression expression) {
      return new ast.SendSet(
          null,
          identifier,
          new ast.Operator(new SymbolToken(EQ_INFO, -1)),
          new ast.NodeList.singleton(expression));
    }
  
  
    /**
     * Translate a list of arguments to an AST NodeList.
     */
    ast.NodeList makeArgumentList(List<Expression> args) {
      List<ast.Expression> arguments =
          args.map((e) => e.accept(this)).toList(growable: false);
      return new ast.NodeList(
          new BeginGroupToken(OPEN_PAREN_INFO, -1),
          new Link.fromList(arguments),
          new SymbolToken(CLOSE_PAREN_INFO, -1),
          ',');
    }
  
    /**
     * Concatenate a pair of AST expressions or statements into a single Block
     * statement.
     */
    static ast.Node concatenate(ast.Node first, ast.Node second) {
      // This is a convenient but very inefficient way to accumulate statements.
      // The Block and NodeList nodes are not mutable so we can't simply use a
      // Block or NodeList as an accumulator.  Using a List<Node> requires
  
negative.code:   // tree.
    dart2js.TreeElementMapping treeElements;
  
    // Tokens needed in the AST.
    final Token openParen = new BeginGroupToken(OPEN_PAREN_INFO, -1);
    final Token closeParen = new SymbolToken(CLOSE_PAREN_INFO, -1);
    final Token openBrace = new BeginGroupToken(OPEN_CURLY_BRACKET_INFO, -1);
    final Token closeBrace = new SymbolToken(CLOSE_CURLY_BRACKET_INFO, -1);
    final Token semicolon = new SymbolToken(SEMICOLON_INFO, -1);
  
    // Helper methods to construct ASTs.
    static ast.Identifier makeIdentifier(String name) {
      return new ast.Identifier(
          new StringToken.fromString(IDENTIFIER_INFO, name, -1));
    }
  
    ast.NodeList makeArgumentList(List<ast.Node> arguments) {
      return new ast.NodeList(openParen,
                              new Link<ast.Node>.fromList(arguments),
                              closeParen,
                              ',');
    }
  
    ast.Block makeBlock(List<ast.Node> statements) {
      return new ast.Block(new ast.NodeList(
          openBrace, new Link<ast.Node>.fromList(statements), closeBrace));
    }
  
    static ast.SendSet makeAssignment(ast.Identifier identifier,
                                      ast.Expression expression) {
      return new ast.SendSet(
          null,
          identifier,
          new ast.Operator(new SymbolToken(EQ_INFO, -1)),
          new ast.NodeList.singleton(expression));
    }
  
    /**
     * Translate the body of a function to an AST FunctionExpression.
     */
  