Big cleanup

--HG--
branch : _ast_compat

1 files changed, 0 insertions, 407 deletions

diff --git a/builder.py b/builder.py
index 67643afe..080081e0 100644
--- a/builder.py
+++ b/builder.py
@@ -167,413 +167,6 @@ class ASTNGBuilder:
             #getattr(self.rebuilder, 'delayed_visit_%s' % node_name)(dnode)
         return node
 
-    # callbacks to build from an existing compiler.ast tree ###################
-    
-    def set_context(self, node, childnode):
-        if isinstance(node, nodes.Assign):
-            if childnode in node.targets:
-                self._asscontext = node
-            else:
-                self._asscontext = None
-        elif isinstance(node, (nodes.AugAssign, nodes.ListCompFor)):
-            if childnode is node.target:
-                self._asscontext = node
-            else:
-                self._asscontext = None
-        
-    def visit_default(self, node):
-        """default visit method, handle the parent attribute"""
-        try:
-            node.parent = self._par_stack[-1]
-        except:
-            print node, self._par_stack[-1]
-            raise
-        assert node.parent is not node
-        self._par_stack.append(node)
-
-    def leave_default(self, _):       
-        """default leave method, handle the parent attribute"""
-        self._par_stack.pop()
-
-    def visit_assert(self, node):
-        self.visit_default(node)
-        nodes.init_assert(node)
-
-    def visit_assign(self, node):
-        """visit a Assign node -> check for classmethod and staticmethod
-        + __metaclass__
-        """
-        self.visit_default(node)
-        nodes.init_assign(node)
-        klass = node.parent.frame()
-        if isinstance(klass, nodes.Class) and \
-            isinstance(node.value, nodes.CallFunc) and \
-            isinstance(node.value, nodes.Name):
-            func_name = node.value.name
-            if func_name in ('classmethod', 'staticmethod'):
-                for ass_node in node.targets:
-                    try:
-                        meth = klass[ass_node.name]
-                        if isinstance(meth, nodes.Function):
-                            meth.type = func_name
-                    except (AttributeError, KeyError):
-                        continue
-        elif getattr(node.targets[0], 'name', None) == '__metaclass__': # XXX check more...
-            self._metaclass[-1] = 'type' # XXX get the actual metaclass
-
-    def visit_augassign(self, node):
-        """visit a AugAssign node -> add name to locals"""
-        self.visit_default(node)
-        nodes.init_augassign(node)
-        if not isinstance(node.target, nodes.Name):
-            return  # XXX
-        # XXX quick fix : _ast.Name not yet visited
-        target = node.target
-        if hasattr(target, "name"):
-            self._add_local(node, node.target.name)
-        else:
-            self._add_local(node, node.target.id)
-
-    def visit_backquote(self, node):
-        self.visit_default(node)
-        nodes.init_backquote(node)
-
-    def visit_binop(self, node):
-        self.visit_default(node)
-        nodes.init_binop(node)
-
-    def visit_boolop(self, node):
-        self.visit_default(node)
-        nodes.init_boolop(node)
-
-    def visit_callfunc(self, node):
-        self.visit_default(node)
-        nodes.init_callfunc(node)
-
-    def visit_class(self, node):
-        """visit a Class node -> init node and push the corresponding
-        object or None on the top of the stack
-        """
-        self.visit_default(node)
-        node.instance_attrs = {}
-        self._push(node)
-        nodes.init_class(node)
-        for name, value in ( ('__name__', node.name),
-                             ('__module__', node.root().name),
-                             ('__doc__', node.doc) ):
-            const = nodes.const_factory(value)
-            const.parent = node
-            node.locals[name] = [const]
-        attach___dict__(node)
-        self._metaclass.append(self._metaclass[-1])
-    visit_classdef = visit_class
-
-    def leave_class(self, node):
-        """leave a Class node -> pop the last item on the stack"""
-        self.leave_default(node)
-        self._stack.pop()
-        metaclass = self._metaclass.pop()
-        if not node.bases:
-            # no base classes, detect new / style old style according to
-            # current scope
-            node._newstyle = metaclass == 'type'
-        node.basenames = [as_string(bnode) for bnode in node.bases]
-    leave_classdef = leave_class
-
-    def visit_compare(self, node):
-        self.visit_default(node)
-        nodes.init_compare(node)
-
-    def visit_dict(self, node): 
-        self.visit_default(node)
-        nodes.init_dict(node)
-
-    def visit_discard(self, node):
-        self.visit_default(node)
-        nodes.init_discard(node)
-
-    def visit_exec(self, node):
-        self.visit_default(node)
-        nodes.init_exec(node)
-
-    def visit_from(self, node):
-        """visit a From node -> add imported names to locals"""
-        self.visit_default(node)
-        nodes.init_import_from(node)
-        # add names imported by the import to locals
-        for (name, asname) in node.names:
-            if name == '*':
-                try:
-                    imported = node.root().import_module(node.modname)
-                except ASTNGBuildingException:
-                    continue
-                for name in imported.wildcard_import_names():
-                    node.parent.set_local(name, node)
-            else:
-                node.parent.set_local(asname or name, node)
-
-    def visit_for(self, node):
-        self.visit_default(node)
-        nodes.init_for(node)
-
-    def visit_function(self, node):
-        """visit a Function node -> init node and push the corresponding
-        object or None on the top of the stack
-        """
-        self.visit_default(node)
-        self._global_names.append({})
-        nodes.init_function(node)
-        if isinstance(node.parent.frame(), nodes.Class):
-            if node.name == '__new__':
-                node.type = 'classmethod'
-            else:
-                node.type = 'method'
-        self._push(node)
-        register_arguments(node, node.argnames)
-    visit_functiondef = visit_function
-
-    def leave_function(self, node):
-        """leave a Function node -> pop the last item on the stack"""
-        self.leave_default(node)
-        self._stack.pop()
-        self._global_names.pop()
-    leave_functiondef = leave_function
-
-    def visit_genexpr(self, node):
-        """visit a GenExpr node -> init node locals"""
-        self.visit_default(node)
-        node.locals = {}
-        nodes.init_genexpr(node)
-    visit_generatorexp = visit_genexpr
-
-    def visit_getattr(self, node):
-        """visit a Attribute node under a Assign -> delay it to handle
-        members definition later
-        """
-        self.visit_default(node)
-        nodes.init_getattr(node)
-        self._delayed.append(node)
-
-    def visit_global(self, node):
-        """visit a Global node -> add declared names to locals"""
-        self.visit_default(node)
-        if not self._global_names: # global at the module level, no effect
-            return
-        for name in node.names:
-            self._global_names[-1].setdefault(name, []).append(node)
-
-    def visit_if(self, node):
-        self.visit_default(node)
-        nodes.init_if(node)
-
-    def visit_import(self, node):
-        """visit a Import node -> add imported names to locals"""
-        self.visit_default(node)
-        nodes.init_import(node)
-        for (name, asname) in node.names:
-            name = asname or name
-            node.parent.set_local(name.split('.')[0], node)
-
-    def visit_keyword(self, node):
-        self.visit_default(node)
-        nodes.init_keyword(node)
-
-    def visit_lambda(self, node):
-        """visit a Lambda node -> init node locals"""
-        self.visit_default(node)
-        nodes.init_lambda(node)
-        node.locals = {}
-        register_arguments(node, node.argnames)
-
-    def visit_list(self, node):
-        self.visit_default(node)
-        nodes.init_list(node)
-
-    def visit_listcomp(self, node):
-        self.visit_default(node)
-        nodes.init_listcomp(node)
-
-    def visit_listcompfor(self, node):
-        self.visit_default(node)
-        nodes.init_listcompfor(node)
-
-    def visit_module(self, node):
-        """visit a Module node -> init node and push the corresponding
-        object or None on the top of the stack
-        """
-        self._stack = [self._module]
-        self._par_stack = [node]
-        self._metaclass = ['']
-        self._global_names = []
-        node.globals = node.locals = {}
-        nodes.init_module(node)
-        for name, value in ( ('__name__', node.name),
-                             ('__file__', node.path),
-                             ('__doc__', node.doc) ):
-            const = nodes.const_factory(value)
-            const.parent = node
-            node.locals[name] = [const]
-        if node.package:
-            # FIXME: List(Const())
-            const = nodes.const_factory(value)
-            const.parent = node
-            node.locals['__path__'] = [const]
-        attach___dict__(node)
-
-    def leave_module(self, _):
-        """leave a Module node -> pop the last item on the stack and check
-        the stack is empty
-        """
-        self._stack.pop()
-        assert not self._stack, 'Stack is not empty : %s' % self._stack
-        self._par_stack.pop()
-        assert not self._par_stack, \
-               'Parent stack is not empty : %s' % self._par_stack
-
-    def visit_name(self, node):
-        nodes.init_name(node)
-        try:
-            cls, value = nodes.CONST_NAME_TRANSFORMS[node.name]
-            node.__class__ = cls
-            node.value = value
-        except KeyError:
-            pass
-        self.visit_default(node)
-        if self._asscontext is not None:
-            self._add_local(node, node.name)
-
-    def visit_print(self, node):
-        self.visit_default(node)
-        nodes.init_print(node)
-
-    def visit_raise(self, node):
-        self.visit_default(node)
-        nodes.init_raise(node)
-
-    def visit_slice(self, node):
-        self.visit_default(node)
-        nodes.init_slice(node)
-
-    def visit_subscript(self, node):
-        self.visit_default(node)
-        nodes.init_subscript(node)
-
-    def visit_tryexcept(self, node):
-        self.visit_default(node)
-        nodes.init_try_except(node)
-
-    def visit_tryfinally(self, node):
-        self.visit_default(node)
-        nodes.init_try_finally(node)
-
-    def visit_tuple(self, node): 
-        self.visit_default(node)
-        nodes.init_tuple(node)
-
-    def visit_unaryop(self, node):
-        self.visit_default(node)
-        nodes.init_unaryop(node)
-
-    def visit_while(self, node):
-        self.visit_default(node)
-        nodes.init_while(node)
-
-
-    def _add_local(self, node, name):
-        if self._global_names and name in self._global_names[-1]:
-            node.root().set_local(name, node)
-        else:
-            node.parent.set_local(name, node)
-
-    def _push(self, node):
-        """update the stack and init some parts of the Function or Class node
-        """
-        obj = getattr(self._stack[-1], node.name, None)
-        self._stack.append(obj)
-        node.locals = {}
-        node.parent.frame().set_local(node.name, node)
-
-    # py2.4 (compiler mode) only callbacks ####################################
-
-    def leave_decorators(self, node):
-        """python >= 2.4
-        visit a Decorator node -> check for classmethod and staticmethod
-        """
-        func = node.parent
-        for decorator_expr in node.nodes:
-            if isinstance(decorator_expr, nodes.Name) and \
-                   decorator_expr.name in ('classmethod', 'staticmethod'):
-                func.type = decorator_expr.name
-        self.leave_default(node)
-
-    def visit_assname(self, node):
-        """visit a AssName node -> add name to locals"""
-        self.visit_default(node)
-        self._add_local(node, node.name)
-        nodes.init_assname(node)
-
-    def visit_assattr(self, node):
-        self.visit_default(node)
-        nodes.init_assattr(node)
-        if node.__class__ == nodes.Getattr:
-            self._delayed.append(node)
-
-    def visit_asslist(self, node):
-        self.visit_default(node)
-        nodes.init_asslist(node)
-
-    def visit_asstuple(self, node):
-        self.visit_default(node)
-        nodes.init_asstuple(node)
-
-    def visit_printnl(self, node):
-        self.visit_default(node)
-        nodes.init_printnl(node)
-
-    def delayed_visit_getattr(self, node):
-        """visit a AssAttr/ GetAttr node -> add name to locals, handle members
-        definition
-        """
-        return # XXX
-        try:
-            frame = node.frame()
-            for infered in node.expr.infer():
-                if infered is nodes.YES:
-                    continue
-                try:
-                    if infered.__class__ is nodes.Instance:
-                        infered = infered._proxied
-                        iattrs = infered.instance_attrs
-                    else:
-                        iattrs = infered.locals
-                except AttributeError:
-                    import traceback
-                    traceback.print_exc()
-                    continue
-                values = iattrs.setdefault(node.attrname, [])
-                if node in values:
-                    continue
-                # get assign in __init__ first XXX useful ?
-                if frame.name == '__init__' and values and not \
-                       values[0].frame().name == '__init__':
-                    values.insert(0, node)
-                else:
-                    values.append(node)
-        except InferenceError:
-            pass
-
-    # py2.5 (ast mode) only callbacks #########################################
-
-    def visit_num(self, node):
-        self.visit_default(node)
-        nodes.init_num(node)
-
-    def visit_str(self, node):
-        self.visit_default(node)
-        nodes.init_str(node)
-
-    delayed_visit_attribute = delayed_visit_getattr
-
 
     # astng from living objects ###############################################
     #