a sketch of the new Rebuilders including '# XXX old code'

--HG--
branch : rebuild

2 files changed, 810 insertions, 177 deletions

diff --git a/_nodes_ast.py b/_nodes_ast.py
index 7cafee4f..1ad14be3 100644
--- a/_nodes_ast.py
+++ b/_nodes_ast.py
@@ -76,7 +76,7 @@ from _ast import (
     )
 
 from logilab.astng.utils import ASTVisitor
-import logilab.astng.nodes as new
+from logilab.astng import nodes as new
 
 _BIN_OP_CLASSES = {_Add: '+',
                    _BitAnd: '&',
@@ -160,110 +160,436 @@ def native_repr_tree(node, indent='', _done=None):
             print indent + f, repr(attr)
 
 
-_Num.accept = lambda self, visitor: visitor.visit_num(self)
-_Str.accept = lambda self, visitor: visitor.visit_str(self)
-
-
+from logilab.astng.rebuilder import RebuildVisitor
 # _ast rebuilder ##############################################################
 
-class TreeRebuilder(ASTVisitor):
+class TreeRebuilder(RebuildVisitor):
     """Rebuilds the _ast tree to become an ASTNG tree"""
 
-    def __init__(self, rebuild_visitor):
-        self.visitor = rebuild_visitor
+    def visit_arguments(self, node):
+        """visit a Arguments node by returning a fresh instance of it"""
+        newnode = new.Arguments()
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.defaults = [self.visit(child, node) for child in node.defaults]
+        return newnode
+
+    def visit_assattr(self, node):
+        """visit a AssAttr node by returning a fresh instance of it"""
+        newnode = new.AssAttr()
+        newnode.expr = self.visit(node.expr, node)
+        return newnode
+
+    def visit_assname(self, node):
+        """visit a AssName node by returning a fresh instance of it"""
+        newnode = new.AssName()
+        return newnode
 
     def visit_assert(self, node):
-        node.fail = node.msg
-        del node.msg
+        """visit a Assert node by returning a fresh instance of it"""
+        newnode = new.Assert()
+        newnode.test = self.visit(node.test, node)
+        newnode.fail = self.visit(node.msg, node)
+        return newnode
+
+    def visit_assign(self, node):
+        """visit a Assign node by returning a fresh instance of it"""
+        newnode = new.Assign()
+        newnode.targets = [self.visit(child, node) for child in node.targets]
+        newnode.value = self.visit(node.value, node)
+        return newnode
 
     def visit_augassign(self, node):
-        node.op = _BIN_OP_CLASSES[node.op.__class__]
+        """visit a AugAssign node by returning a fresh instance of it"""
+        newnode = new.AugAssign()
+        newnode.target = self.visit(node.target, node)
+        newnode.value = self.visit(node.value, node)
+        return newnode
+
+    def visit_backquote(self, node):
+        """visit a Backquote node by returning a fresh instance of it"""
+        newnode = new.Backquote()
+        newnode.value = self.visit(node.value, node)
+        return newnode
 
     def visit_binop(self, node):
-        node.op = _BIN_OP_CLASSES[node.op.__class__]
+        """visit a BinOp node by returning a fresh instance of it"""
+        newnode = new.BinOp()
+        newnode.left = self.visit(node.left, node)
+        newnode.right = self.visit(node.right, node)
+        newnode.op = _BIN_OP_CLASSES[node.op.__class__]
+        return newnode
 
     def visit_boolop(self, node):
-        node.op = _BOOL_OP_CLASSES[node.op.__class__]
+        """visit a BoolOp node by returning a fresh instance of it"""
+        newnode = new.BoolOp()
+        newnode.values = [self.visit(child, node) for child in node.values]
+        newnode.op = _BOOL_OP_CLASSES[node.op.__class__]
+        return newnode
+
+    def visit_break(self, node):
+        """visit a Break node by returning a fresh instance of it"""
+        newnode = new.Break()
+        return newnode
 
     def visit_callfunc(self, node):
+        """visit a CallFunc node by returning a fresh instance of it"""
+        newnode = new.CallFunc()
+        newnode.func = self.visit(node.func, node)
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.starargs = [self.visit(child, node) for child in node.starargs]
+        newnode.kwargs = [self.visit(child, node) for child in node.kwargs]
+        # XXX old code
         node.args.extend(node.keywords)
         del node.keywords
+        # end old
         return newnode
 
     def visit_class(self, node):
-        _init_set_doc(node)
+        """visit a Class node by returning a fresh instance of it"""
+        newnode = new.Class()
+        _init_set_doc(node, newnode)
+        newnode.bases = [self.visit(child, node) for child in node.bases]
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
 
     def visit_compare(self, node):
-        node.ops = [(_CMP_OP_CLASSES[op.__class__], expr)
-                    for op, expr in zip(node.ops, node.comparators)]
+        """visit a Compare node by returning a fresh instance of it"""
+        newnode = new.Compare()
+        newnode.left = self.visit(node.left, node)
+        newnode.ops = [self.visit(child, node) for child in node.ops]
+        # XXX old code
+        node.ops = [(_CMP_OP_CLASSES[op.__class__], expr) 
+                    for (op, expr) in zip(node.ops, node.comparators)]
         del node.comparators
+        # end old
+        return newnode
+
+    def visit_comprehension(self, node):
+        """visit a Comprehension node by returning a fresh instance of it"""
+        newnode = new.Comprehension()
+        newnode.target = self.visit(node.target, node)
+        newnode.iter = self.visit(node.iter, node)
+        newnode.ifs = [self.visit(child, node) for child in node.ifs]
+        return newnode
+
+    def visit_const(self, node):
+        """visit a Const node by returning a fresh instance of it"""
+        newnode = new.Const()
+        return newnode
+
+    def visit_continue(self, node):
+        """visit a Continue node by returning a fresh instance of it"""
+        newnode = new.Continue()
+        return newnode
+
+    def visit_decorators(self, node):
+        """visit a Decorators node by returning a fresh instance of it"""
+        newnode = new.Decorators()
+        newnode.nodes = [self.visit(child, node) for child in node.nodes]
+        return newnode
+
+    def visit_delattr(self, node):
+        """visit a DelAttr node by returning a fresh instance of it"""
+        newnode = new.DelAttr()
+        newnode.expr = self.visit(node.expr, node)
+        return newnode
+
+    def visit_delname(self, node):
+        """visit a DelName node by returning a fresh instance of it"""
+        newnode = new.DelName()
+        return newnode
+
+    def visit_delete(self, node):
+        """visit a Delete node by returning a fresh instance of it"""
+        newnode = new.Delete()
+        newnode.targets = [self.visit(child, node) for child in node.targets]
+        return newnode
 
     def visit_dict(self, node):
-        node.items = zip(node.keys, node.values)
-        del node.keys, node.values
+        """visit a Dict node by returning a fresh instance of it"""
+        newnode = new.Dict()
+        newnode.items = [(self.visit(key, node),self.visit(value, node)) 
+                          for key, value in zip(node.keys, node.values)]
+        return newnode
+
+    def visit_discard(self, node):
+        """visit a Discard node by returning a fresh instance of it"""
+        if isinstance(node.value, _ast.Yield):
+            return self.visit(node.value, node)
+        newnode = new.Discard()
+        newnode.value = self.visit(node.value, node)
+        return newnode
+
+    def visit_ellipsis(self, node):
+        """visit an Ellipsis node by returning a fresh instance of it"""
+        newnode = new.Ellipsis()
+        return newnode
+
+    def visit_emptynode(self, node):
+        """visit an EmptyNode node by returning a fresh instance of it"""
+        newnode = new.EmptyNode()
+        return newnode
+
+    def visit_excepthandler(self, node):
+        """visit an ExceptHandler node by returning a fresh instance of it"""
+        newnode = new.ExceptHandler()
+        newnode.type = self.visit(node.type, node)
+        newnode.name = self.visit(node.name, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
 
     def visit_exec(self, node):
-        node.expr = node.body
-        del node.body
+        """visit an Exec node by returning a fresh instance of it"""
+        newnode = new.Exec()
+        newnode.expr = self.visit(node.body, node)
+        newnode.globals = [self.visit(child, node) for child in node.globals]
+        newnode.locals = [self.visit(child, node) for child in node.locals]
+        return newnode
+
+    def visit_extslice(self, node):
+        """visit an ExtSlice node by returning a fresh instance of it"""
+        newnode = new.ExtSlice()
+        newnode.dims = self.visit(node.dims, node)
+        return newnode
+
+    def visit_for(self, node):
+        """visit a For node by returning a fresh instance of it"""
+        newnode = new.For()
+        newnode.target = self.visit(node.target, node)
+        newnode.iter = self.visit(node.iter, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        return newnode
+
+    def visit_from(self, node):
+        """visit a From node by returning a fresh instance of it"""
+        names = [(alias.name, alias.asname) for alias in node.names]
+        newnode = new.From(node.module, names)
+        return newnode
 
     def visit_function(self, node):
-        _init_set_doc(node)
+        """visit a Function node by returning a fresh instance of it"""
+        newnode = new.Function()
+        _init_set_doc(node, newnode)
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.body = [self.visit(child, node) for child in node.body]
         if 'decorators' in node._fields: # py < 2.6
             attr = 'decorators'
         else:
             attr = 'decorator_list'
         decorators = getattr(node, attr)
-        delattr(node, attr)
         if decorators:
-            node.decorators = new.Decorators(decorators)
+            newnode.decorators = Decorators(decorators)
         else:
-            node.decorators = None
+            newnode.decorators = None
+        return newnode
+
+    def visit_genexpr(self, node):
+        """visit a GenExpr node by returning a fresh instance of it"""
+        newnode = new.GenExpr()
+        newnode.elt = self.visit(node.elt, node)
+        newnode.generators = [self.visit(child, node) for child in node.generators]
+        return newnode
 
     def visit_getattr(self, node):
+        """visit a Getattr node by returning a fresh instance of it"""
+        newnode = new.Getattr()
+        newnode.expr = self.visit(node.expr, node)
+        # XXX old code
         node.attrname = node.attr
         node.expr = node.value
         del node.attr, node.value
-        if isinstance(self.visitor.asscontext, Delete):
-            node.__class__ = new.DelAttr
-        elif self.visitor.asscontext is not None:
-            node.__class__ = new.AssAttr
+        if isinstance(self.asscontext, Delete):
+            node.__class__ = DelAttr
+        else:
+            if self.asscontext is not None:
+                node.__class__ = AssAttr
+        # end old
+        return newnode
+
+    def visit_global(self, node):
+        """visit a Global node by returning a fresh instance of it"""
+        newnode = new.Global()
+        # XXX newnode.globals/targets = ...
+        return newnode
+
+    def visit_if(self, node):
+        """visit a If node by returning a fresh instance of it"""
+        newnode = new.If()
+        newnode.test = self.visit(node.test, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        return newnode
+
+    def visit_ifexp(self, node):
+        """visit a IfExp node by returning a fresh instance of it"""
+        newnode = new.IfExp()
+        newnode.test = self.visit(node.test, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        return newnode
 
     def visit_import(self, node):
-        node.names = [(alias.name, alias.asname) for alias in node.names]
+        """visit a Import node by returning a fresh instance of it"""
+        newnode = new.Import()
+        newnode.names = [(alias.name, alias.asname) for alias in node.names]
+        return newnode
 
-    def visit_from(self, node):
-        node.names = [(alias.name, alias.asname) for alias in node.names]
-        node.modname = node.module
-        del node.module
+    def visit_index(self, node):
+        """visit a Index node by returning a fresh instance of it"""
+        newnode = new.Index()
+        newnode.value = self.visit(node.value, node)
+        return newnode
+
+    def visit_keyword(self, node):
+        """visit a Keyword node by returning a fresh instance of it"""
+        newnode = new.Keyword()
+        newnode.value = self.visit(node.value, node)
+        return newnode
+
+    def visit_lambda(self, node):
+        """visit a Lambda node by returning a fresh instance of it"""
+        newnode = new.Lambda()
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
+
+    def visit_list(self, node):
+        """visit a List node by returning a fresh instance of it"""
+        newnode = new.List()
+        newnode.elts = [self.visit(child, node) for child in node.elts]
+        return newnode
+
+    def visit_listcomp(self, node):
+        """visit a ListComp node by returning a fresh instance of it"""
+        newnode = new.ListComp()
+        newnode.elt = self.visit(node.elt, node)
+        newnode.generators = [self.visit(child, node)
+                              for child in node.generators]
+        return newnode
 
     def visit_module(self, node):
-        _init_set_doc(node)
+        """visit a Module node by returning a fresh instance of it"""
+        print "build new Module"
+        newnode = new.Module()
+        _init_set_doc(node, newnode)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
 
     def visit_name(self, node):
-        node.name = node.id
-        del node.id
-        if isinstance(self.visitor.asscontext, Delete):
-            node.__class__ = new.DelName
-        elif self.visitor.asscontext is not None:
-            node.__class__ = new.AssName
+        """visit a Name node by returning a fresh instance of it"""
+        newnode = new.Name()
+        newnode.name = node.id
+        # XXX old code
+        if isinstance(self.asscontext, Delete):
+            node.__class__ = DelName
+        else:
+            if self.asscontext is not None:
+                node.__class__ = AssName
+        # end old
+        return newnode
 
     def visit_num(self, node):
-        node.__class__ = new.Const
-        node.value = node.n
-        del node.n
+        """visit a a Num node by returning a fresh instance of Const"""
+        newnode = new.Const()
+        newnode.value = node.n
+        return newnode
 
     def visit_str(self, node):
-        node.__class__ = new.Const
-        node.value = node.s
-        del node.s
+        """visit a a Str node by returning a fresh instance of Const"""
+        newnode = new.Const()
+        newnode.value = node.s
+        return newnode
+
+    def visit_pass(self, node):
+        """visit a Pass node by returning a fresh instance of it"""
+        newnode = new.Pass()
+        return newnode
+
+    def visit_print(self, node):
+        """visit a Print node by returning a fresh instance of it"""
+        newnode = new.Print()
+        newnode.dest = self.visit(node.dest, node)
+        newnode.values = [self.visit(child, node) for child in node.values]
+        return newnode
+
+    def visit_raise(self, node):
+        """visit a Raise node by returning a fresh instance of it"""
+        newnode = new.Raise()
+        newnode.type = self.visit(node.type, node)
+        newnode.inst = self.visit(node.inst, node)
+        newnode.tback = self.visit(node.tback, node)
+        return newnode
+
+    def visit_return(self, node):
+        """visit a Return node by returning a fresh instance of it"""
+        newnode = new.Return()
+        newnode.value = self.visit(node.value, node)
+        return newnode
+
+    def visit_slice(self, node):
+        """visit a Slice node by returning a fresh instance of it"""
+        newnode = new.Slice()
+        newnode.lower = self.visit(node.lower, node)
+        newnode.upper = self.visit(node.upper, node)
+        newnode.step = self.visit(node.step, node)
+        return newnode
+
+    def visit_subscript(self, node):
+        """visit a Subscript node by returning a fresh instance of it"""
+        newnode = new.Subscript()
+        newnode.value = self.visit(node.value, node)
+        newnode.slice = self.visit(node.slice, node)
+        return newnode
+
+    def visit_tryexcept(self, node):
+        """visit a TryExcept node by returning a fresh instance of it"""
+        newnode = new.TryExcept()
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.handlers = [self.visit(child, node) for child in node.handlers]
+        newnode.orelse = self.visit(node.orelse, node)
+        return newnode
+
+    def visit_tryfinally(self, node):
+        """visit a TryFinally node by returning a fresh instance of it"""
+        newnode = new.TryFinally()
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.finalbody = self.visit(node.finalbody, node)
+        return newnode
+
+    def visit_tuple(self, node):
+        """visit a Tuple node by returning a fresh instance of it"""
+        newnode = new.Tuple()
+        newnode.elts = [self.visit(child, node) for child in node.elts]
+        return newnode
 
     def visit_unaryop(self, node):
-        node.op = _UNARY_OP_CLASSES[node.op.__class__]
+        """visit a UnaryOp node by returning a fresh instance of it"""
+        newnode = new.UnaryOp()
+        newnode.operand = self.visit(node.operand, node)
+        newnode.op = _UNARY_OP_CLASSES[node.op.__class__]
+        return newnode
+
+    def visit_while(self, node):
+        """visit a While node by returning a fresh instance of it"""
+        newnode = new.While()
+        newnode.test = self.visit(node.test, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        return newnode
 
     def visit_with(self, node):
-        """build compiler like node """
-        node.vars = node.optional_vars
-        node.expr = node.context_expr
-        del node.optional_vars, node.context_expr
+        """visit a With node by returning a fresh instance of it"""
+        newnode = new.With()
+        newnode.expr = self.visit(node.context_expr, node)
+        newnode.vars = self.visit(node.optional_vars, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
 
+    def visit_yield(self, node):
+        """visit a Yield node by returning a fresh instance of it"""
+        newnode = new.Yield()
+        newnode.value = self.visit(node.value, node)
+        # removing discard parent handled in visit_discard
+        return newnode
 
diff --git a/_nodes_compiler.py b/_nodes_compiler.py
index f43433c8..07e0049f 100644
--- a/_nodes_compiler.py
+++ b/_nodes_compiler.py
@@ -51,25 +51,12 @@ from compiler.ast import AssList as _AssList, AssTuple as _AssTuple,\
 from logilab.astng.utils import ASTVisitor
 from logilab.astng._exceptions import NodeRemoved, ASTNGError
 
+import logilab.astng.nodes as new
+from logilab.astng.rebuilder import RebuildVisitor
 
-# set missing accept methods
-_AssList.accept = lambda self, visitor: visitor.visit_asslist(self)
-_AssTuple.accept = lambda self, visitor: visitor.visit_asstuple(self)
-_Printnl.accept = lambda self, visitor: visitor.visit_printnl(self)
-_Slice.accept = lambda self, visitor: visitor.visit_slice(self)
-_GenExprFor.accept = lambda self, visitor: visitor.visit_comprehension(self)
-for boolopcls in (_And, _Or):
-    boolopcls.accept = lambda self, visitor: visitor.visit_boolop(self)
-for unaryopcls in (_UnaryAdd, _UnarySub, _Not,_Invert):
-    unaryopcls.accept = lambda self, visitor: visitor.visit_unaryop(self)
-for binopcls in (_Add, _Div, _FloorDiv, _Mod, _Mul, _Power, _Sub, _Bitand,
-                 _Bitor, _Bitxor, _LeftShift, _RightShift):
-    binopcls.accept = lambda self, visitor: visitor.visit_binop(self)
 
 class BaseClass: pass
 
-import logilab.astng.nodes as new
-
 
 # introduced in python 2.5
 From.level = 0 # will be overridden by instance attribute with py>=2.5
@@ -235,12 +222,9 @@ def _filter_none(node):
     else:
         return node
 
-class TreeRebuilder(ASTVisitor):
-    """Rebuilds the compiler tree to become an ASTNG tree"""
-
-    def __init__(self, rebuild_visitor):
-        self.visitor = rebuild_visitor
 
+class TreeRebuilder(RebuildVisitor):
+    """Rebuilds the compiler tree to become an ASTNG tree"""
 
     def insert_delstmt_if_necessary(self, node):
         """insert a Delete statement node if necessary
@@ -263,101 +247,219 @@ class TreeRebuilder(ASTVisitor):
             stmt.tolineno = node.tolineno
             node.parent = stmt
             stmt.targets = [node]
-        self.visitor.asscontext = stmt
+        self.asscontext = stmt
         return stmt is node
 
-    # scoped nodes #######################################################
-
-    def visit_function(self, node):
-        # remove Stmt node
-        node.body = node.code.nodes
-        del node.code
-        args_compiler_to_ast(node)
-
-    def visit_lambda(self, node):
-        node.body = node.code
-        del node.code
-        args_compiler_to_ast(node)
-
-    def visit_class(self, node):
-        # remove Stmt node
-        node.body = node.code.nodes
-        del node.code
-
-    def visit_module(self, node):
-        # remove Stmt node
-        node.body = node.node.nodes
-        del node.node
-        return True
-
-    #  other visit_<node> #####################################################
+    def visit_arguments(self, node):
+        """visit an Arguments node by returning a fresh instance of it"""
+        newnode = new.Arguments()
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.defaults = [self.visit(child, node) for child in node.defaults]
+        return newnode
 
     def visit_assattr(self, node):
+        """visit an AssAttr node by returning a fresh instance of it"""
+        newnode = new.AssAttr()
+        newnode.expr = self.visit(node.expr, node)
+        # XXX old code
         if node.flags == 'OP_DELETE':
             self.insert_delstmt_if_necessary(node)
-            node.__class__ = new.DelAttr
+            node.__class__ = DelAttr
         del node.flags
-
-    def visit_assign(self, node):
-        node.value = node.expr
-        node.targets = node.nodes
-        del node.nodes, node.expr
-
-    def visit_asslist(self, node):
-        self.insert_delstmt_if_necessary(node)
-        node.__class__ = new.List
-        self.visit_list(node)
-
-    def visit_asstuple(self, node):
-        if not self.insert_delstmt_if_necessary(node):
-            node.__class__ = new.Tuple
-            self.visit_tuple(node)
+        # end old
+        return newnode
 
     def visit_assname(self, node):
+        """visit an AssName node by returning a fresh instance of it"""
+        newnode = new.AssName()
+        # XXX old code
         if node.flags == 'OP_DELETE':
             self.insert_delstmt_if_necessary(node)
-            node.__class__ = new.DelName
+            node.__class__ = DelName
         del node.flags
+        # end old
+        return newnode
+
+    def visit_assert(self, node):
+        """visit an Assert node by returning a fresh instance of it"""
+        newnode = new.Assert()
+        newnode.test = self.visit(node.test, node)
+        newnode.fail = self.visit(node.fail, node)
+        return newnode
+
+    def visit_assign(self, node):
+        """visit an Assign node by returning a fresh instance of it"""
+        newnode = new.Assign()
+        newnode.targets = [self.visit(child, node) for child in node.targets]
+        newnode.value = self.visit(node.value, node)
+        # XXX old code
+        node.value = node.expr
+        node.targets = node.nodes
+        del node.nodes, node.expr
+        # end old
+        return newnode
 
     def visit_augassign(self, node):
+        """visit an AugAssign node by returning a fresh instance of it"""
+        newnode = new.AugAssign()
+        newnode.target = self.visit(node.target, node)
+        newnode.value = self.visit(node.value, node)
+        # XXX old code
         node.value = node.expr
         del node.expr
         node.target = node.node
         del node.node
+        # end old
+        return newnode
+
 
-    def visit_backquote(self, node):
+   def visit_backquote(self, node):
+        """visit a Backquote node by returning a fresh instance of it"""
+        newnode = new.Backquote()
+        newnode.value = self.visit(node.value, node)
+        # XXX old code
         node.value = node.expr
         del node.expr
+        # end old
+        return newnode
 
     def visit_binop(self, node):
-        node.op = BinOp_OP_CLASSES[node.__class__]
-        node.__class__ = new.BinOp # XXX just instanciate the node
+        """visit a BinOp node by returning a fresh instance of it"""
+        newnode = new.BinOp()
+        newnode.left = self.visit(node.left, node)
+        newnode.right = self.visit(node.right, node)
+        # XXX old code
+        node.op = BinOp.OP_CLASSES[node.__class__]
+        node.__class__ = BinOp
         if node.op in ('&', '|', '^'):
             node.right = node.nodes[-1]
-            bitop = BinOp_BIT_CLASSES[node.op]
+            bitop = BinOp.BIT_CLASSES[node.op]
             if len(node.nodes) > 2:
                 node.left = bitop(node.nodes[:-1])
             else:
                 node.left = node.nodes[0]
             del node.nodes
+        # end old
+        return newnode
 
     def visit_boolop(self, node):
-        node.op = BoolOp_OP_CLASSES[node.__class__]
-        node.__class__ = new.BoolOp # XXX just instanciate the node
+        """visit a BoolOp node by returning a fresh instance of it"""
+        newnode = new.BoolOp()
+        newnode.values = [self.visit(child, node) for child in node.values]
+        # XXX old code
+        node.op = BoolOp.OP_CLASSES[node.__class__]
+        node.__class__ = BoolOp
         node.values = node.nodes
         del node.nodes
+        # end old
+        return newnode
+
+    def visit_break(self, node):
+        """visit a Break node by returning a fresh instance of it"""
+        newnode = new.Break()
+        return newnode
 
     def visit_callfunc(self, node):
+        """visit a CallFunc node by returning a fresh instance of it"""
+        newnode = new.CallFunc()
+        newnode.func = self.visit(node.func, node)
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.starargs = [self.visit(child, node) for child in node.starargs]
+        newnode.kwargs = [self.visit(child, node) for child in node.kwargs]
+        # XXX old code
         node.func = node.node
         node.starargs = node.star_args
         node.kwargs = node.dstar_args
         del node.node, node.star_args, node.dstar_args
+        # end old
+        return newnode
+
+    def visit_class(self, node):
+        """visit a Class node by returning a fresh instance of it"""
+        newnode = new.Class()
+        newnode.bases = [self.visit(child, node) for child in node.bases]
+        newnode.body = [self.visit(child, node) for child in node.body]
+        # XXX old code
+        node.body = node.code.nodes
+        del node.code
+        # end old
+        return newnode
 
     def visit_compare(self, node):
+        """visit a Compare node by returning a fresh instance of it"""
+        newnode = new.Compare()
+        newnode.left = self.visit(node.left, node)
+        newnode.ops = [self.visit(child, node) for child in node.ops]
+        # XXX old code
         node.left = node.expr
         del node.expr
+        # end old
+        return newnode
+
+    def visit_comprehension(self, node):
+        """visit a Comprehension node by returning a fresh instance of it"""
+        newnode = new.Comprehension()
+        newnode.target = self.visit(node.target, node)
+        newnode.iter = self.visit(node.iter, node)
+        newnode.ifs = [self.visit(child, node) for child in node.ifs]
+        # XXX old code
+        if hasattr(node, 'list'):
+            # ListCompFor
+            node.iter = node.list
+            del node.list
+        else: # GenExprFor
+            node.__class__ = Comprehension
+        node.target = node.assign
+        if node.ifs:
+            node.ifs = [iff.test for iff in node.ifs]
+        del node.assign
+        # end old
+        return newnode
+
+    def visit_const(self, node):
+        """visit a Const node by returning a fresh instance of it"""
+        newnode = new.Const()
+        return newnode
+
+    def visit_continue(self, node):
+        """visit a Continue node by returning a fresh instance of it"""
+        newnode = new.Continue()
+        return newnode
+
+    def visit_decorators(self, node):
+        """visit a Decorators node by returning a fresh instance of it"""
+        newnode = new.Decorators()
+        newnode.nodes = [self.visit(child, node) for child in node.nodes]
+        return newnode
+
+    def visit_delattr(self, node):
+        """visit a DelAttr node by returning a fresh instance of it"""
+        newnode = new.DelAttr()
+        newnode.expr = self.visit(node.expr, node)
+        return newnode
+
+    def visit_delname(self, node):
+        """visit a DelName node by returning a fresh instance of it"""
+        newnode = new.DelName()
+        return newnode
+
+    def visit_delete(self, node):
+        """visit a Delete node by returning a fresh instance of it"""
+        newnode = new.Delete()
+        newnode.targets = [self.visit(child, node) for child in node.targets]
+        return newnode
+
+    def visit_dict(self, node):
+        """visit a Dict node by returning a fresh instance of it"""
+        newnode = new.Dict()
+        newnode.items = [self.visit(child, node) for child in node.items]
+        return newnode
 
     def visit_discard(self, node):
+        """visit a Discard node by returning a fresh instance of it"""
+        newnode = new.Discard()
+        newnode.value = self.visit(node.value, node)
+        # XXX old code
         node.value = node.expr
         del node.expr
         if node.lineno is None:
@@ -365,36 +467,123 @@ class TreeRebuilder(ASTVisitor):
             # is ended by a semi-colon
             node.parent.child_sequence(node).remove(node)
             raise NodeRemoved
+        # end old
+        return newnode
+
+    def visit_ellipsis(self, node):
+        """visit an Ellipsis node by returning a fresh instance of it"""
+        newnode = new.Ellipsis()
+        return newnode
+
+    def visit_emptynode(self, node):
+        """visit an EmptyNode node by returning a fresh instance of it"""
+        newnode = new.EmptyNode()
+        return newnode
+
+    def visit_excepthandler(self, node):
+        """visit an ExceptHandler node by returning a fresh instance of it"""
+        newnode = new.ExceptHandler()
+        newnode.type = self.visit(node.type, node)
+        newnode.name = self.visit(node.name, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
 
     def visit_exec(self, node):
-        node.locals, node.globals = node.globals, node.locals
+        """visit an Exec node by returning a fresh instance of it"""
+        newnode = new.Exec()
+        newnode.expr = self.visit(node.expr, node)
+        newnode.globals = [self.visit(child, node) for child in node.globals]
+        newnode.locals = [self.visit(child, node) for child in node.locals]
+        # XXX old code
+        (node.locals, node.globals) = (node.globals, node.locals)
+        # end old
+        return newnode
+
+    def visit_extslice(self, node):
+        """visit an ExtSlice node by returning a fresh instance of it"""
+        newnode = new.ExtSlice()
+        newnode.dims = self.visit(node.dims, node)
+        return newnode
 
     def visit_for(self, node):
+        """visit a For node by returning a fresh instance of it"""
+        newnode = new.For()
+        newnode.target = self.visit(node.target, node)
+        newnode.iter = self.visit(node.iter, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        # XXX old code
         node.target = node.assign
         del node.assign
         node.iter = node.list
         del node.list
         node.body = node.body.nodes
         _init_else_node(node)
+        # end old
+        return newnode
+
+    def visit_from(self, node):
+        """visit a From node by returning a fresh instance of it"""
+        newnode = new.From(node.modname, nodes.names)
+        return newnode
+
+
+    def visit_function(self, node):
+        """visit a Function node by returning a fresh instance of it"""
+        newnode = new.Function()
+        newnode.decorators = [self.visit(child, node) for child in node.decorators]
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.body = [self.visit(child, node) for child in node.body]
+        # XXX old code
+        node.body = node.code.nodes
+        del node.code
+        args_compiler_to_ast(node)
+        # end old
+        return newnode
 
     def visit_genexpr(self, node):
+        """visit a GenExpr node by returning a fresh instance of it"""
+        newnode = new.GenExpr()
+        newnode.elt = self.visit(node.elt, node)
+        newnode.generators = [self.visit(child, node) for child in node.generators]
+        # XXX old code
         # remove GenExprInner node
         node.elt = node.code.expr
         node.generators = node.code.quals
         del node.code
+        # end old
+        return newnode
 
     def visit_getattr(self, node):
-        if isinstance(self.visitor.asscontext, new.AugAssign):
-            node.__class__ = new.AssAttr
+        """visit a Getattr node by returning a fresh instance of it"""
+        newnode = new.Getattr()
+        newnode.expr = self.visit(node.expr, node)
+        # XXX old code
+        if isinstance(self.visitor.asscontext, AugAssign):
+            node.__class__ = AssAttr
+        # end old
+        return newnode
+
+    def visit_global(self, node):
+        """visit a Global node by returning a fresh instance of it"""
+        newnode = new.Global()
+        return newnode
+
 
     def visit_if(self, node):
-        node.test, body = node.tests[0]
+        """visit an If node by returning a fresh instance of it"""
+        newnode = new.If()
+        newnode.test = self.visit(node.test, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        # XXX old code
+        (node.test, body) = node.tests[0]
         node.body = body.nodes
         if node.tests[1:]:
             # create If node and put it in orelse
             # rely on the fact that the new If node will be visited
             # as well until no more tests remains
-            subnode = If(node.tests[1:], node.else_ )
+            subnode = If(node.tests[1:], node.else_)
             subnode.fromlineno = node.tests[1][0].fromlineno
             subnode.tolineno = node.tests[1][1].nodes[-1].tolineno
             subnode.blockstart_tolineno = node.tests[1][0].tolineno
@@ -403,60 +592,140 @@ class TreeRebuilder(ASTVisitor):
         else: # handle orelse
             _init_else_node(node)
         del node.tests
-
-    def visit_list(self, node):
-        node.elts = node.nodes
-        del node.nodes
+        # end old
+        return newnode
+
+    def visit_ifexp(self, node):
+        """visit an IfExp node by returning a fresh instance of it"""
+        newnode = new.IfExp()
+        newnode.test = self.visit(node.test, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        return newnode
+
+    def visit_import(self, node):
+        """visit an Import node by returning a fresh instance of it"""
+        newnode = new.Import()
+        return newnode
+
+    def visit_index(self, node):
+        """visit an Index node by returning a fresh instance of it"""
+        newnode = new.Index()
+        newnode.value = self.visit(node.value, node)
+        return newnode
 
     def visit_keyword(self, node):
+        """visit a Keyword node by returning a fresh instance of it"""
+        newnode = new.Keyword()
+        newnode.value = self.visit(node.value, node)
+        # XXX old code
         node.value = node.expr
         node.arg = node.name
         del node.expr, node.name
+        # end old
+        return newnode
+
+    def visit_lambda(self, node):
+        """visit a Lambda node by returning a fresh instance of it"""
+        newnode = new.Lambda()
+        newnode.args = [self.visit(child, node) for child in node.args]
+        newnode.body = [self.visit(child, node) for child in node.body]
+        # XXX old code
+        node.body = node.code
+        del node.code
+        args_compiler_to_ast(node)
+        # end old
+        return newnode
+
+    def visit_list(self, node):
+        """visit a List node by returning a fresh instance of it"""
+        newnode = new.List()
+        newnode.elts = [self.visit(child, node) for child in node.elts]
+        # XXX old code
+        node.elts = node.nodes
+        del node.nodes
+        # end old
+        return newnode
 
     def visit_listcomp(self, node):
+        """visit a ListComp node by returning a fresh instance of it"""
+        newnode = new.ListComp()
+        newnode.elt = self.visit(node.elt, node)
+        newnode.generators = [self.visit(child, node) for child in node.generators]
+        # XXX old code
         node.elt = node.expr
         node.generators = node.quals
         del node.expr, node.quals
+        # end old
+        return newnode
 
-    def visit_name(self, node):
-        if isinstance(self.visitor.asscontext, new.AugAssign):
-            node.__class__ = new.AssName
+    def visit_module(self, node):
+        """visit a Module node by returning a fresh instance of it"""
+        newnode = new.Module()
+        newnode.body = [self.visit(child, node) for child in node.body]
+        # XXX old code
+        node.body = node.node.nodes
+        del node.node
+        return True
+        # end old
+        return newnode
 
-    def visit_comprehension(self, node):
-        if hasattr(node, "list"):
-            # ListCompFor
-            node.iter = node.list
-            del node.list
-        else: # GenExprFor
-            node.__class__ = new.Comprehension
-        node.target = node.assign
-        if node.ifs:
-            node.ifs = [iff.test for iff in node.ifs ]
-        del node.assign
+    def visit_name(self, node):
+        """visit a Name node by returning a fresh instance of it"""
+        newnode = new.Name()
+        # XXX old code
+        if isinstance(self.visitor.asscontext, AugAssign):
+            node.__class__ = AssName
+        # end old
+        return newnode
+
+    def visit_pass(self, node):
+        """visit a Pass node by returning a fresh instance of it"""
+        newnode = new.Pass()
+        return newnode
 
     def visit_print(self, node):
+        """visit a Print node by returning a fresh instance of it"""
+        newnode = new.Print()
+        newnode.dest = self.visit(node.dest, node)
+        newnode.values = [self.visit(child, node) for child in node.values]
+        # XXX old code
         node.values = node.nodes
         del node.nodes
         node.nl = False
-
-    def visit_printnl(self, node):
-        node.__class__ = Print
-        node.values = node.nodes
-        del node.nodes
-        node.nl = True
+        # end old
+        return newnode
 
     def visit_raise(self, node):
+        """visit a Raise node by returning a fresh instance of it"""
+        newnode = new.Raise()
+        newnode.type = self.visit(node.type, node)
+        newnode.inst = self.visit(node.inst, node)
+        newnode.tback = self.visit(node.tback, node)
+        # XXX old code
         node.type = node.expr1
         node.inst = node.expr2
         node.tback = node.expr3
         del node.expr1, node.expr2, node.expr3
+        # end old
+        return newnode
 
     def visit_return(self, node):
-        """visit Return: filter None Const"""
-        node.value = _filter_none( node.value )
+        """visit a Return node by returning a fresh instance of it"""
+        newnode = new.Return()
+        newnode.value = self.visit(node.value, node)
+        # XXX old code
+        node.value = _filter_none(node.value)
+        # end old
+        return newnode
 
     def visit_slice(self, node):
-        """visit slice"""
+        """visit a Slice node by returning a fresh instance of it"""
+        newnode = new.Slice()
+        newnode.lower = self.visit(node.lower, node)
+        newnode.upper = self.visit(node.upper, node)
+        newnode.step = self.visit(node.step, node)
+        # XXX old code
         # /!\ Careful :
         # if the node comes from compiler, it is actually an astng.Subscript
         # with only 'lower' and 'upper' attributes; no 'step'.
@@ -472,64 +741,102 @@ class TreeRebuilder(ASTVisitor):
             self.insert_delstmt_if_necessary(node)
         else:
             assert node.flags in ('OP_APPLY', 'OP_ASSIGN')
-        node.__class__ = Subscript # XXX what should we do here ?
+        node.__class__ = Subscript
         node.value = node.expr
-        node.slice = ew.Slice(node.lower, node.upper, None,
-                           node.lineno)
+        node.slice = Slice(node.lower, node.upper, None, node.lineno)
         del node.expr, node.lower, node.upper, node.flags
+        # end old
+        return newnode
 
     def visit_subscript(self, node):
+        """visit a Subscript node by returning a fresh instance of it"""
+        newnode = new.Subscript()
+        newnode.value = self.visit(node.value, node)
+        newnode.slice = self.visit(node.slice, node)
+        # XXX old code
         if node.flags == 'OP_DELETE':
             self.insert_delstmt_if_necessary(node)
         node.value = node.expr
         if [n for n in node.subs if isinstance(n, Sliceobj)]:
             subs = node.subs
-            if len(node.subs) == 1:# Slice
+            if len(node.subs) == 1:
                 subs = node.subs[0].nodes
-                node.slice = new.Slice(subs[0], subs[1], subs[2], node.lineno)
+                node.slice = Slice(subs[0], subs[1], subs[2], node.lineno)
             else: # ExtSlice
-                node.slice = new.ExtSlice()
-                node.dims = [_extslice(n) for n in node.subs]
+                node.slice = ExtSlice(node.subs)
         else: # Index
-            node.slice = new.Index(node.subs)
+            node.slice = Index(node.subs)
         del node.expr, node.subs, node.flags
+        # end old
+        return newnode
+
 
     def visit_tryexcept(self, node):
+        """visit a TryExcept node by returning a fresh instance of it"""
+        newnode = new.TryExcept()
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.handlers = [self.visit(child, node) for child in node.handlers]
+        newnode.orelse = self.visit(node.orelse, node)
+        # XXX old code
         # remove Stmt node
         node.body = node.body.nodes
-        # remove Stmt node
-        node.handlers = [new.ExceptHandler(exctype, excobj, body.nodes)
-                        for exctype, excobj, body in node.handlers]
+        node.handlers = [ExceptHandler(exctype, excobj, body, node) for (exctype, excobj, body) in node.handlers]
         _init_else_node(node)
+        # end old
+        return newnode
 
     def visit_tryfinally(self, node):
-        # remove Stmt nodes
+        """visit a TryFinally node by returning a fresh instance of it"""
+        newnode = new.TryFinally()
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.finalbody = self.visit(node.finalbody, node)
+        # XXX old code
         node.body = node.body.nodes
         node.finalbody = node.final.nodes
         del node.final
+        # end old
+        return newnode
 
-    visit_tuple = visit_list
+    def visit_tuple(self, node):
+        """visit a Tuple node by returning a fresh instance of it"""
+        newnode = new.Tuple()
+        newnode.elts = [self.visit(child, node) for child in node.elts]
+        return newnode
 
     def visit_unaryop(self, node):
-        node.op = UnaryOp_OP_CLASSES[node.__class__]
-        node.__class__ = new.UnaryOp # XXX just instanciate the node
+        """visit an UnaryOp node by returning a fresh instance of it"""
+        newnode = new.UnaryOp()
+        newnode.operand = self.visit(node.operand, node)
+        # XXX old code
+        node.op = UnaryOp.OP_CLASSES[node.__class__]
+        node.__class__ = UnaryOp
         node.operand = node.expr
         del node.expr
+        # end old
+        return newnode
 
     def visit_while(self, node):
+        """visit a While node by returning a fresh instance of it"""
+        newnode = new.While()
+        newnode.test = self.visit(node.test, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        newnode.orelse = self.visit(node.orelse, node)
+        # XXX old code
         node.body = node.body.nodes
         _init_else_node(node)
+        # end old
+    def visit_with(self, node):
+        """visit a With node by returning a fresh instance of it"""
+        newnode = new.With()
+        newnode.expr = self.visit(node.expr, node)
+        newnode.vars = self.visit(node.vars, node)
+        newnode.body = [self.visit(child, node) for child in node.body]
+        return newnode
 
     def visit_yield(self, node):
-        """visit yield : add parent Discard node"""
-        if not isinstance(node.parent, new.Discard):
-            stmt = new.Discard(None)
-            del stmt.expr
-            stmt.value = node
-            stmt.fromlineno = node.fromlineno
-            stmt.tolineno = node.tolineno
-            node.parent.replace(node, stmt)
-            node.parent = stmt
-
+        """visit a Yield node by returning a fresh instance of it"""
+        newnode = new.Yield()
+        newnode.value = self.visit(node.value, node)
+        return newnode