bee_python 0.0.3 → 0.0.4

data/tools/logilab/logilab/astng/bases.py

@@ -1,608 +0,0 @@
-# -*- coding: utf-8 -*-
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# copyright 2003-2010 Sylvain Thenault, all rights reserved.
-# contact mailto:thenault@gmail.com
-#
-# This file is part of logilab-astng.
-#
-# logilab-astng is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as published by the
-# Free Software Foundation, either version 2.1 of the License, or (at your
-# option) any later version.
-#
-# logilab-astng is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
-
-"""This module contains base classes and functions for the nodes and some
-inference utils.
-
-"""
-
-from __future__ import generators
-
-__docformat__ = "restructuredtext en"
-
-
-try:
-    from _ast import AST
-    del AST
-    class BaseClass(object):
-        pass
-except ImportError:
-    class BaseClass:
-        pass
-
-from logilab.common.compat import set
-from logilab.astng._exceptions import (InferenceError, ASTNGError,
-                                       NotFoundError, UnresolvableName)
-
-
-class Proxy(BaseClass):
-    """a simple proxy object"""
-    _proxied = None
-
-    def __init__(self, proxied=None):
-        if proxied is not None:
-            self._proxied = proxied
-
-    def __getattr__(self, name):
-        if name == '_proxied':
-            return getattr(self.__class__, '_proxied')
-        if name in self.__dict__:
-            return self.__dict__[name]
-        return getattr(self._proxied, name)
-
-    def infer(self, context=None):
-        yield self
-
-# Inference ##################################################################
-
-
-
-class InferenceContext(object):
-    __slots__ = ('path', 'lookupname', 'callcontext', 'boundnode')
-
-    def __init__(self, path=None):
-        if path is None:
-            self.path = set()
-        else:
-            self.path = path
-        self.lookupname = None
-        self.callcontext = None
-        self.boundnode = None
-
-    def push(self, node):
-        name = self.lookupname
-        if (node, name) in self.path:
-            raise StopIteration()
-        self.path.add( (node, name) )
-
-    def clone(self):
-        # XXX copy lookupname/callcontext ?
-        clone = InferenceContext(self.path)
-        clone.callcontext = self.callcontext
-        clone.boundnode = self.boundnode
-        return clone
-
-def copy_context(context):
-    if context is not None:
-        return context.clone()
-    else:
-        return InferenceContext()
-
-
-def _infer_stmts(stmts, context, frame=None):
-    """return an iterator on statements inferred by each statement in <stmts>
-    """
-    stmt = None
-    infered = False
-    if context is not None:
-        name = context.lookupname
-        context = context.clone()
-    else:
-        name = None
-        context = InferenceContext()
-    for stmt in stmts:
-        if stmt is YES:
-            yield stmt
-            infered = True
-            continue
-        context.lookupname = stmt._infer_name(frame, name)
-        try:
-            for infered in stmt.infer(context):
-                yield infered
-                infered = True
-        except UnresolvableName:
-            continue
-        except InferenceError:
-            yield YES
-            infered = True
-    if not infered:
-        raise InferenceError(str(stmt))
-
-
-# special inference objects (e.g. may be returned as nodes by .infer()) #######
-
-class _Yes(object):
-    """a yes object"""
-    def __repr__(self):
-        return 'YES'
-    def __getattribute__(self, name):
-        if name.startswith('__') and name.endswith('__'):
-            # to avoid inspection pb
-            return super(_Yes, self).__getattribute__(name)
-        return self
-    def __call__(self, *args, **kwargs):
-        return self
-
-
-YES = _Yes()
-
-
-class Instance(Proxy):
-    """a special node representing a class instance"""
-    def getattr(self, name, context=None, lookupclass=True):
-        try:
-            values = self._proxied.instance_attr(name, context)
-        except NotFoundError:
-            if name == '__class__':
-                return [self._proxied]
-            if lookupclass:
-                # class attributes not available through the instance
-                # unless they are explicitly defined
-                if name in ('__name__', '__bases__', '__mro__'):
-                    return self._proxied.local_attr(name)
-                return self._proxied.getattr(name, context)
-            raise NotFoundError(name)
-        # since we've no context information, return matching class members as
-        # well
-        if lookupclass:
-            try:
-                return values + self._proxied.getattr(name, context)
-            except NotFoundError:
-                pass
-        return values
-
-    def igetattr(self, name, context=None):
-        """inferred getattr"""
-        try:
-            # XXX frame should be self._proxied, or not ?
-            get_attr = self.getattr(name, context, lookupclass=False)
-            return _infer_stmts(self._wrap_attr(get_attr, context), context,
-                                frame=self)
-        except NotFoundError:
-            try:
-                # fallback to class'igetattr since it has some logic to handle
-                # descriptors
-                return self._wrap_attr(self._proxied.igetattr(name, context),
-                                       context)
-            except NotFoundError:
-                raise InferenceError(name)
-
-    def _wrap_attr(self, attrs, context=None):
-        """wrap bound methods of attrs in a InstanceMethod proxies"""
-        for attr in attrs:
-            if isinstance(attr, UnboundMethod):
-                if '__builtin__.property' in attr.decoratornames():
-                    for infered in attr.infer_call_result(self, context):
-                        yield infered
-                else:
-                    yield BoundMethod(attr, self)
-            else:
-                yield attr
-
-    def infer_call_result(self, caller, context=None):
-        """infer what a class instance is returning when called"""
-        infered = False
-        for node in self._proxied.igetattr('__call__', context):
-            for res in node.infer_call_result(caller, context):
-                infered = True
-                yield res
-        if not infered:
-            raise InferenceError()
-
-    def __repr__(self):
-        return '<Instance of %s.%s at 0x%s>' % (self._proxied.root().name,
-                                                self._proxied.name,
-                                                id(self))
-    def __str__(self):
-        return 'Instance of %s.%s' % (self._proxied.root().name,
-                                      self._proxied.name)
-
-    def callable(self):
-        try:
-            self._proxied.getattr('__call__')
-            return True
-        except NotFoundError:
-            return False
-
-    def pytype(self):
-        return self._proxied.qname()
-
-    def display_type(self):
-        return 'Instance of'
-
-
-class UnboundMethod(Proxy):
-    """a special node representing a method not bound to an instance"""
-    def __repr__(self):
-        frame = self._proxied.parent.frame()
-        return '<%s %s of %s at 0x%s' % (self.__class__.__name__,
-                                         self._proxied.name,
-                                         frame.qname(), id(self))
-
-    def is_bound(self):
-        return False
-
-    def getattr(self, name, context=None):
-        if name == 'im_func':
-            return [self._proxied]
-        return super(UnboundMethod, self).getattr(name, context)
-
-    def igetattr(self, name, context=None):
-        if name == 'im_func':
-            return iter((self._proxied,))
-        return super(UnboundMethod, self).igetattr(name, context)
-
-
-class BoundMethod(UnboundMethod):
-    """a special node representing a method bound to an instance"""
-    def __init__(self,  proxy, bound):
-        UnboundMethod.__init__(self, proxy)
-        self.bound = bound
-
-    def is_bound(self):
-        return True
-
-    def infer_call_result(self, caller, context):
-        context = context.clone()
-        context.boundnode = self.bound
-        return self._proxied.infer_call_result(caller, context)
-
-
-class Generator(Proxy):
-    """a special node representing a generator"""
-    def callable(self):
-        return True
-
-    def pytype(self):
-        return '__builtin__.generator'
-
-    def display_type(self):
-        return 'Generator'
-
-
-# decorators ##################################################################
-
-def path_wrapper(func):
-    """return the given infer function wrapped to handle the path"""
-    def wrapped(node, context=None, _func=func, **kwargs):
-        """wrapper function handling context"""
-        if context is None:
-            context = InferenceContext()
-        context.push(node)
-        yielded = set()
-        for res in _func(node, context, **kwargs):
-            # unproxy only true instance, not const, tuple, dict...
-            if res.__class__ is Instance:
-                ares = res._proxied
-            else:
-                ares = res
-            if not ares in yielded:
-                yield res
-                yielded.add(ares)
-    return wrapped
-
-def yes_if_nothing_infered(func):
-    def wrapper(*args, **kwargs):
-        infered = False
-        for node in func(*args, **kwargs):
-            infered = True
-            yield node
-        if not infered:
-            yield YES
-    return wrapper
-
-def raise_if_nothing_infered(func):
-    def wrapper(*args, **kwargs):
-        infered = False
-        for node in func(*args, **kwargs):
-            infered = True
-            yield node
-        if not infered:
-            raise InferenceError()
-    return wrapper
-
-
-# Node  ######################################################################
-
-class NodeNG(BaseClass):
-    """Base Class for all ASTNG node classes.
-
-    It represents a node of the new abstract syntax tree.
-    """
-    is_statement = False
-    # attributes below are set by the builder module or by raw factories
-    lineno = None
-    fromlineno = None
-    tolineno = None
-    # parent node in the tree
-    parent = None
-    # attributes containing child node(s) redefined in most concrete classes:
-    _astng_fields = ()
-
-    def _repr_name(self):
-        """return self.name or self.attrname or '' for nice representation"""
-        return getattr(self, 'name', getattr(self, 'attrname', ''))
-
-    def __str__(self):
-        return '%s(%s)' % (self.__class__.__name__, self._repr_name())
-
-    def __repr__(self):
-        return '<%s(%s) l.%s [%s] at Ox%x>' % (self.__class__.__name__,
-                                           self._repr_name(),
-                                           self.fromlineno,
-                                           self.root().name,
-                                           id(self))
-
-
-    def accept(self, visitor):
-        klass = self.__class__.__name__
-        func = getattr(visitor, "visit_" + self.__class__.__name__.lower())
-        return func(self)
-
-    def get_children(self):
-        node_dict = self.__dict__
-        for field in self._astng_fields:
-            attr = node_dict[field]
-            if attr is None:
-                continue
-            if isinstance(attr, (list, tuple)):
-                for elt in attr:
-                    yield elt
-            else:
-                yield attr
-
-    def last_child(self):
-        """an optimized version of list(get_children())[-1]"""
-        n_dict = self.__dict__
-        for field in self._astng_fields[::-1]:
-            attr = n_dict[field]
-            if not attr: # None or empty listy / tuple
-                continue
-            if isinstance(attr, (list, tuple)):
-                return attr[-1]
-            else:
-                return attr
-        return None
-
-    def parent_of(self, node):
-        """return true if i'm a parent of the given node"""
-        parent = node.parent
-        while parent is not None:
-            if self is parent:
-                return True
-            parent = parent.parent
-        return False
-
-    def statement(self):
-        """return the first parent node marked as statement node"""
-        if self.is_statement:
-            return self
-        return self.parent.statement()
-
-    def frame(self):
-        """return the first parent frame node (i.e. Module, Function or Class)
-        """
-        return self.parent.frame()
-
-    def scope(self):
-        """return the first node defining a new scope (i.e. Module, Function,
-        Class, Lambda but also GenExpr)
-        """
-        return self.parent.scope()
-
-    def root(self):
-        """return the root node of the tree, (i.e. a Module)"""
-        if self.parent:
-            return self.parent.root()
-        return self
-
-    def child_sequence(self, child):
-        """search for the right sequence where the child lies in"""
-        for field in self._astng_fields:
-            node_or_sequence = getattr(self, field)
-            if node_or_sequence is child:
-                return [node_or_sequence]
-            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
-            if isinstance(node_or_sequence, (tuple, list)) and child in node_or_sequence:
-                return node_or_sequence
-        else:
-            msg = 'Could not found %s in %s\'s children'
-            raise ASTNGError(msg % (repr(child), repr(self)))
-
-    def locate_child(self, child):
-        """return a 2-uple (child attribute name, sequence or node)"""
-        for field in self._astng_fields:
-            node_or_sequence = getattr(self, field)
-            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
-            if child is node_or_sequence:
-                return field, child
-            if isinstance(node_or_sequence, (tuple, list)) and child in node_or_sequence:
-                return field, node_or_sequence
-        msg = 'Could not found %s in %s\'s children'
-        raise ASTNGError(msg % (repr(child), repr(self)))
-    # FIXME : should we merge child_sequence and locate_child ? locate_child
-    # is only used in are_exclusive, child_sequence one time in pylint.
-
-    def next_sibling(self):
-        """return the next sibling statement"""
-        return self.parent.next_sibling()
-
-    def previous_sibling(self):
-        """return the previous sibling statement"""
-        return self.parent.previous_sibling()
-
-    def nearest(self, nodes):
-        """return the node which is the nearest before this one in the
-        given list of nodes
-        """
-        myroot = self.root()
-        mylineno = self.fromlineno
-        nearest = None, 0
-        for node in nodes:
-            assert node.root() is myroot, \
-                   'nodes %s and %s are not from the same module' % (self, node)
-            lineno = node.fromlineno
-            if node.fromlineno > mylineno:
-                break
-            if lineno > nearest[1]:
-                nearest = node, lineno
-        # FIXME: raise an exception if nearest is None ?
-        return nearest[0]
-
-    def set_line_info(self, lastchild):
-        if self.lineno is None:
-            self.fromlineno = self._fixed_source_line()
-        else:
-            self.fromlineno = self.lineno
-        if lastchild is None:
-            self.tolineno = self.fromlineno
-        else:
-            self.tolineno = lastchild.tolineno
-        return
-        # TODO / FIXME:
-        assert self.fromlineno is not None, self
-        assert self.tolineno is not None, self
-
-    def _fixed_source_line(self):
-        """return the line number where the given node appears
-
-        we need this method since not all nodes have the lineno attribute
-        correctly set...
-        """
-        line = self.lineno
-        _node = self
-        try:
-            while line is None:
-                _node = _node.get_children().next()
-                line = _node.lineno
-        except StopIteration:
-            _node = self.parent
-            while _node and line is None:
-                line = _node.lineno
-                _node = _node.parent
-        return line
-
-    def block_range(self, lineno):
-        """handle block line numbers range for non block opening statements
-        """
-        return lineno, self.tolineno
-
-    def set_local(self, name, stmt):
-        """delegate to a scoped parent handling a locals dictionary"""
-        self.parent.set_local(name, stmt)
-
-    def nodes_of_class(self, klass, skip_klass=None):
-        """return an iterator on nodes which are instance of the given class(es)
-
-        klass may be a class object or a tuple of class objects
-        """
-        if isinstance(self, klass):
-            yield self
-        for child_node in self.get_children():
-            if skip_klass is not None and isinstance(child_node, skip_klass):
-                continue
-            for matching in child_node.nodes_of_class(klass, skip_klass):
-                yield matching
-
-    def _infer_name(self, frame, name):
-        # overridden for From, Import, Global, TryExcept and Arguments
-        return None
-
-    def infer(self, context=None):
-        """we don't know how to resolve a statement by default"""
-        # this method is overridden by most concrete classes
-        raise InferenceError(self.__class__.__name__)
-
-    def infered(self):
-        '''return list of infered values for a more simple inference usage'''
-        return list(self.infer())
-
-    def instanciate_class(self):
-        """instanciate a node if it is a Class node, else return self"""
-        return self
-
-    def has_base(self, node):
-        return False
-
-    def callable(self):
-        return False
-
-    def eq(self, value):
-        return False
-
-    def as_string(self):
-        from logilab.astng.nodes_as_string import as_string
-        return as_string(self)
-
-    def repr_tree(self, ids=False):
-        """print a nice astng tree representation"""
-        result = []
-        _repr_tree(self, result, ids=ids)
-        print "\n".join(result)
-
-
-INDENT = "    "
-
-def _repr_tree(node, result, indent='', _done=None, ids=False):
-    """built a tree representation of a node as a list of lines"""
-    if _done is None:
-        _done = set()
-    if not hasattr(node, '_astng_fields'): # not a astng node
-        return
-    if node in _done:
-        result.append( indent + 'loop in tree: %s' % node )
-        return
-    _done.add(node)
-    node_str = str(node)
-    if ids:
-        node_str += '  . \t%x' % id(node)
-    result.append( indent + node_str )
-    indent += INDENT
-    for field in node._astng_fields:
-        value = getattr(node, field)
-        if isinstance(value, (list, tuple) ):
-            result.append(  indent + field + " = [" )
-            for child in value:
-                if isinstance(child, (list, tuple) ):
-                    # special case for Dict # FIXME
-                    _repr_tree(child[0], result, indent, _done, ids)
-                    _repr_tree(child[1], result, indent, _done, ids)
-                    result.append(indent + ',')
-                else:
-                    _repr_tree(child, result, indent, _done, ids)
-            result.append(  indent + "]" )
-        else:
-            result.append(  indent + field + " = " )
-            _repr_tree(value, result, indent, _done, ids)
-
-