anchor.diff:          node.rightBracket);
     }
   
  +  visitClassTypeAlias(ast.ClassTypeAlias node) {
  +    return node;
  +  }
  +
  +  visitEnumDeclaration(ast.EnumDeclaration node) {
  +    return node;
  +  }
  +
  +  visitFunctionDeclaration(ast.FunctionDeclaration node) {
  +    node.functionExpression.body = visit(node.functionExpression.body);
  +    return node;
  +  }
  +
  +  visitFunctionTypeAlias(ast.FunctionTypeAlias node) {
  +    return node;
  +  }
  +
  +  visitTopLevelVariableDeclaration(ast.TopLevelVariableDeclaration node) {
  +    return node;
  +  }
  +
  +  // ---- ClassMembers ----
     visitConstructorDeclaration(ast.ConstructorDeclaration node) {
       return node;
     }
  
positive.code:               AstFactory.propertyAccess2(identifier(result), 'future'))]);
    }
  
    visitExpressionFunctionBody(ast.ExpressionFunctionBody node) {
      if (node.keyword == null) return node;
      return visit(AstFactory.blockFunctionBody2(
          [AstFactory.returnStatement2(node.expression)])
          ..keyword = node.keyword);
    }
  
    visitEmptyFunctionBody(ast.EmptyFunctionBody node) {
      return node;
    }
  
    visitFunctionTypeAlias(ast.FunctionTypeAlias node) {
      return node;
    }
  
    visitCatchClause(ast.CatchClause node) => (f, r, s) {
      return visit(node.body)(f, r, s);
    };
  
    visitVariableDeclarationList(ast.VariableDeclarationList node) {
      return new ast.VariableDeclarationList(
          node.documentationComment,
          node.metadata,
          node.keyword,
          node.type,
          node.variables.map(visit).toList(growable: false));
    }
  
    void residualizeDeclarationList(scanner.Keyword keyword,
                                    List<ast.VariableDeclaration> decls) {
      if (decls.isEmpty) return;
      addStatement(AstFactory.variableDeclarationStatement2(keyword, decls));
    }
  
    DeclarationListTransformer translateDeclarationList(
        scanner.Keyword keyword,
        ast.VariableDeclarationList node) {
      assert(node.variables.isNotEmpty);
      return (ErrorCont f, DeclarationListCont s) {
        translateDecl(ast.VariableDeclaration decl, cont) {
          if (decl.initializer == null) {
            return cont(decl);
          } else {
            return visitExpression(decl.initializer)(f, (expr) {
              return cont(AstFactory.variableDeclaration2(decl.name.name, expr));
            });
          }
        }
  
        var decls = [];
        // The continuation for the last declaration.
        var cont = (decl) {
          decls.add(decl);
          return s(decls);
        };
        for (var i = node.variables.length - 1; i >= 1; --i) {
          var nextCont = cont;
          // The continuation for the i-1 declaration.
          cont = (decl) {
            decls.add(decl);
            var nextDecl = node.variables[i];
            if (awaits.contains(nextDecl)) {
              residualizeDeclarationList(keyword, decls);
              decls.clear();
            }
            translateDecl(nextDecl, nextCont);
          };
        }
        translateDecl(node.variables.first, cont);
      };
    }
  
    visitVariableDeclaration(ast.VariableDeclaration node) {
      return new ast.VariableDeclaration(
          node.documentationComment,
          node.metadata,
          node.name,
          node.equals,
          visit(node.initializer));
    }
  
    // Statements
    StatementTransformer visitBlock(ast.Block node) {
      return (ErrorCont f, ReturnCont r, StatementCont s) {
        for (var stmt in node.statements.reversed) {
          var current = s;
          s = () {
            return visit(stmt)(f, r, current);
          };
        }
        return s();
      };
    }
  
    StatementTransformer visitBreakStatement(ast.BreakStatement node) {
      return (ErrorCont f, ReturnCont r, StatementCont s) {
        addStatement(
            AstFactory.functionExpressionInvocation(
                breakTargets.last, [nullLiteral()]));
      };
    }
  
    StatementTransformer visitContinueStatement(ast.ContinueStatement node) {
      return (ErrorCont f, ReturnCont r, StatementCont s) {
        addStatement(
            AstFactory.functionExpressionInvocation(
                continueTargets.last, [nullLiteral()]));
      };
    }
  
    StatementTransformer visitDoStatement(ast.DoStatement node) {
      return (ErrorCont f, ReturnCont r, StatementCont s) {
        var breakName = newName('break');
        var continueName = newName('continue');
        var loopName = newName('loop');
  
        var savedBlock = currentBlock;
        var breakBlock = currentBlock = emptyBlock();
        s();
  
        var continueBlock = currentBlock = emptyBlock();
        visitExpression(node.condition)(f, (expr) {
          addStatement(AstFactory.ifStatement2(
            expr,
            block([AstFactory.methodInvocation(
                AstFactory.functionExpressionInvocation(
  
negative.code:   }
  
    bool visitBlockFunctionBody(ast.BlockFunctionBody node) {
      if (node.isSynchronous || node.isGenerator) return false;
      visit(node.block);
      return false;
    }
  
    bool visitExpressionFunctionBody(ast.ExpressionFunctionBody node) {
      if (node.isSynchronous || node.isGenerator) return false;
      visit(node.expression);
      return false;
    }
  
    bool visitEmptyFunctionBody(ast.EmptyFunctionBody node) {
  