anchor.diff:      });
     };
   
  -  visitSymbolLiteral(ast.SymbolLiteral node) => (f, s) {
  +  visitSymbolLiteral(ast.SymbolLiteral node) => (s) {
       return s(node);
     };
   
     // ---- TypedLiterals ----
  -  visitListLiteral(ast.ListLiteral node) => (f, s) {
  -    _translateExpressionList(node.elements)(f, (elts) {
  +  visitListLiteral(ast.ListLiteral node) => (s) {
  +    _translateExpressionList(node.elements, (elts) {
         s(AstFactory.listLiteral(elts));
       });
     };
   
  -  visitMapLiteral(ast.MapLiteral node) => (f, s) {
  +  visitMapLiteral(ast.MapLiteral node) => (s) {
       var list = new ast.NodeList<ast.Expression>(node);
       for (var entry in node.entries) {
         list.add(entry.key);
         list.add(entry.value);
       }
  -    _translateExpressionList(list)(f, (exprs) {
  +    _translateExpressionList(list, (exprs) {
         var entries = <ast.MapLiteralEntry>[];
         for (var i = 0; i < exprs.length; i += 2) {
           entries.add(new ast.MapLiteralEntry(
  
positive.code:   };
  
    visitFunctionDeclarationStatement(
        ast.FunctionDeclarationStatement node) => (f, r, s) {
      var decl = new AsyncTransformer().visit(node.functionDeclaration);
      addStatement(new ast.FunctionDeclarationStatement(decl));
      return s();
    };
  
    visitIfStatement(ast.IfStatement node) => (f, r, s) {
      var hasElse = node.elseStatement != null;
      return visit(node.condition)(f, (expr) {
        var joinName = newName('join');
        var joinFun = reifyStatementCont(s);
        addStatement(
  
negative.code:                 loopBlock)));
      if (node.variables != null) {
        assert(node.variables.variables.isNotEmpty);
        return _translateForDeclarations(node.variables.variables, (args) {
          assert(args.length == parameters.length);
          addStatement(AstFactory.returnStatement2(
              AstFactory.functionExpressionInvocation(
  