You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
637 lines
22 KiB
Python
637 lines
22 KiB
Python
# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
|
|
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
|
|
#
|
|
# This file is part of astroid.
|
|
#
|
|
# astroid 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.
|
|
#
|
|
# astroid 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 astroid. If not, see <http://www.gnu.org/licenses/>.
|
|
"""This module contains base classes and functions for the nodes and some
|
|
inference utils.
|
|
"""
|
|
import functools
|
|
import sys
|
|
import warnings
|
|
|
|
import wrapt
|
|
|
|
from astroid import context as contextmod
|
|
from astroid import decorators as decoratorsmod
|
|
from astroid import exceptions
|
|
from astroid import util
|
|
|
|
|
|
if sys.version_info >= (3, 0):
|
|
BUILTINS = 'builtins'
|
|
else:
|
|
BUILTINS = '__builtin__'
|
|
PROPERTIES = {BUILTINS + '.property', 'abc.abstractproperty'}
|
|
# List of possible property names. We use this list in order
|
|
# to see if a method is a property or not. This should be
|
|
# pretty reliable and fast, the alternative being to check each
|
|
# decorator to see if its a real property-like descriptor, which
|
|
# can be too complicated.
|
|
# Also, these aren't qualified, because each project can
|
|
# define them, we shouldn't expect to know every possible
|
|
# property-like decorator!
|
|
# TODO(cpopa): just implement descriptors already.
|
|
POSSIBLE_PROPERTIES = {"cached_property", "cachedproperty",
|
|
"lazyproperty", "lazy_property", "reify",
|
|
"lazyattribute", "lazy_attribute",
|
|
"LazyProperty", "lazy"}
|
|
|
|
|
|
def _is_property(meth):
|
|
if PROPERTIES.intersection(meth.decoratornames()):
|
|
return True
|
|
stripped = {name.split(".")[-1] for name in meth.decoratornames()
|
|
if name is not util.YES}
|
|
return any(name in stripped for name in POSSIBLE_PROPERTIES)
|
|
|
|
|
|
class Proxy(object):
|
|
"""a simple proxy object"""
|
|
|
|
_proxied = None # proxied object may be set by class or by instance
|
|
|
|
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
|
|
|
|
|
|
def _infer_stmts(stmts, context, frame=None):
|
|
"""Return an iterator on statements inferred by each statement in *stmts*."""
|
|
stmt = None
|
|
inferred = False
|
|
if context is not None:
|
|
name = context.lookupname
|
|
context = context.clone()
|
|
else:
|
|
name = None
|
|
context = contextmod.InferenceContext()
|
|
|
|
for stmt in stmts:
|
|
if stmt is util.YES:
|
|
yield stmt
|
|
inferred = True
|
|
continue
|
|
context.lookupname = stmt._infer_name(frame, name)
|
|
try:
|
|
for inferred in stmt.infer(context=context):
|
|
yield inferred
|
|
inferred = True
|
|
except exceptions.UnresolvableName:
|
|
continue
|
|
except exceptions.InferenceError:
|
|
yield util.YES
|
|
inferred = True
|
|
if not inferred:
|
|
raise exceptions.InferenceError(str(stmt))
|
|
|
|
|
|
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 exceptions.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__', '__subclasses__'):
|
|
return self._proxied.local_attr(name)
|
|
return self._proxied.getattr(name, context)
|
|
raise exceptions.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 exceptions.NotFoundError:
|
|
pass
|
|
return values
|
|
|
|
def igetattr(self, name, context=None):
|
|
"""inferred getattr"""
|
|
if not context:
|
|
context = contextmod.InferenceContext()
|
|
try:
|
|
# avoid recursively inferring the same attr on the same class
|
|
context.push((self._proxied, name))
|
|
# 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 exceptions.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 exceptions.NotFoundError:
|
|
raise exceptions.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 _is_property(attr):
|
|
for inferred in attr.infer_call_result(self, context):
|
|
yield inferred
|
|
else:
|
|
yield BoundMethod(attr, self)
|
|
elif hasattr(attr, 'name') and attr.name == '<lambda>':
|
|
# This is a lambda function defined at class level,
|
|
# since its scope is the underlying _proxied class.
|
|
# Unfortunately, we can't do an isinstance check here,
|
|
# because of the circular dependency between astroid.bases
|
|
# and astroid.scoped_nodes.
|
|
if attr.statement().scope() == self._proxied:
|
|
if attr.args.args and attr.args.args[0].name == 'self':
|
|
yield BoundMethod(attr, self)
|
|
continue
|
|
yield attr
|
|
else:
|
|
yield attr
|
|
|
|
def infer_call_result(self, caller, context=None):
|
|
"""infer what a class instance is returning when called"""
|
|
inferred = False
|
|
for node in self._proxied.igetattr('__call__', context):
|
|
if node is util.YES or not node.callable():
|
|
continue
|
|
for res in node.infer_call_result(caller, context):
|
|
inferred = True
|
|
yield res
|
|
if not inferred:
|
|
raise exceptions.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 exceptions.NotFoundError:
|
|
return False
|
|
|
|
def pytype(self):
|
|
return self._proxied.qname()
|
|
|
|
def display_type(self):
|
|
return 'Instance of'
|
|
|
|
|
|
# TODO(cpopa): this is set in inference.py
|
|
# The circular dependency hell goes deeper and deeper.
|
|
# pylint: disable=unused-argument
|
|
def getitem(self, index, context=None):
|
|
pass
|
|
|
|
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 self._proxied.getattr(name, context)
|
|
|
|
def igetattr(self, name, context=None):
|
|
if name == 'im_func':
|
|
return iter((self._proxied,))
|
|
return self._proxied.igetattr(name, context)
|
|
|
|
def infer_call_result(self, caller, context):
|
|
# If we're unbound method __new__ of builtin object, the result is an
|
|
# instance of the class given as first argument.
|
|
if (self._proxied.name == '__new__' and
|
|
self._proxied.parent.frame().qname() == '%s.object' % BUILTINS):
|
|
infer = caller.args[0].infer() if caller.args else []
|
|
return ((x is util.YES and x or Instance(x)) for x in infer)
|
|
return self._proxied.infer_call_result(caller, 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=None):
|
|
|
|
if context is None:
|
|
context = contextmod.InferenceContext()
|
|
context = context.clone()
|
|
context.boundnode = self.bound
|
|
return super(BoundMethod, self).infer_call_result(caller, context)
|
|
|
|
|
|
class Generator(Instance):
|
|
"""a special node representing a generator.
|
|
|
|
Proxied class is set once for all in raw_building.
|
|
"""
|
|
def callable(self):
|
|
return False
|
|
|
|
def pytype(self):
|
|
return '%s.generator' % BUILTINS
|
|
|
|
def display_type(self):
|
|
return 'Generator'
|
|
|
|
def __repr__(self):
|
|
return '<Generator(%s) l.%s at 0x%s>' % (self._proxied.name, self.lineno, id(self))
|
|
|
|
def __str__(self):
|
|
return 'Generator(%s)' % (self._proxied.name)
|
|
|
|
|
|
# decorators ##################################################################
|
|
|
|
def path_wrapper(func):
|
|
"""return the given infer function wrapped to handle the path"""
|
|
@functools.wraps(func)
|
|
def wrapped(node, context=None, _func=func, **kwargs):
|
|
"""wrapper function handling context"""
|
|
if context is None:
|
|
context = contextmod.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 ares not in yielded:
|
|
yield res
|
|
yielded.add(ares)
|
|
return wrapped
|
|
|
|
@wrapt.decorator
|
|
def yes_if_nothing_inferred(func, instance, args, kwargs):
|
|
inferred = False
|
|
for node in func(*args, **kwargs):
|
|
inferred = True
|
|
yield node
|
|
if not inferred:
|
|
yield util.YES
|
|
|
|
@wrapt.decorator
|
|
def raise_if_nothing_inferred(func, instance, args, kwargs):
|
|
inferred = False
|
|
for node in func(*args, **kwargs):
|
|
inferred = True
|
|
yield node
|
|
if not inferred:
|
|
raise exceptions.InferenceError()
|
|
|
|
|
|
# Node ######################################################################
|
|
|
|
class NodeNG(object):
|
|
"""Base Class for all Astroid node classes.
|
|
|
|
It represents a node of the new abstract syntax tree.
|
|
"""
|
|
is_statement = False
|
|
optional_assign = False # True for For (and for Comprehension if py <3.0)
|
|
is_function = False # True for FunctionDef nodes
|
|
# attributes below are set by the builder module or by raw factories
|
|
lineno = None
|
|
fromlineno = None
|
|
tolineno = None
|
|
col_offset = None
|
|
# parent node in the tree
|
|
parent = None
|
|
# attributes containing child node(s) redefined in most concrete classes:
|
|
_astroid_fields = ()
|
|
# instance specific inference function infer(node, context)
|
|
_explicit_inference = None
|
|
|
|
def infer(self, context=None, **kwargs):
|
|
"""main interface to the interface system, return a generator on infered
|
|
values.
|
|
|
|
If the instance has some explicit inference function set, it will be
|
|
called instead of the default interface.
|
|
"""
|
|
if self._explicit_inference is not None:
|
|
# explicit_inference is not bound, give it self explicitly
|
|
try:
|
|
return self._explicit_inference(self, context, **kwargs)
|
|
except exceptions.UseInferenceDefault:
|
|
pass
|
|
|
|
if not context:
|
|
return self._infer(context, **kwargs)
|
|
|
|
key = (self, context.lookupname,
|
|
context.callcontext, context.boundnode)
|
|
if key in context.inferred:
|
|
return iter(context.inferred[key])
|
|
|
|
return context.cache_generator(key, self._infer(context, **kwargs))
|
|
|
|
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 0x%x>' % (self.__class__.__name__,
|
|
self._repr_name(),
|
|
self.fromlineno,
|
|
self.root().name,
|
|
id(self))
|
|
|
|
|
|
def accept(self, visitor):
|
|
func = getattr(visitor, "visit_" + self.__class__.__name__.lower())
|
|
return func(self)
|
|
|
|
def get_children(self):
|
|
for field in self._astroid_fields:
|
|
attr = getattr(self, 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]"""
|
|
for field in self._astroid_fields[::-1]:
|
|
attr = getattr(self, 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, FunctionDef or
|
|
ClassDef)
|
|
|
|
"""
|
|
return self.parent.frame()
|
|
|
|
def scope(self):
|
|
"""return the first node defining a new scope (i.e. Module,
|
|
FunctionDef, ClassDef, 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._astroid_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
|
|
|
|
msg = 'Could not find %s in %s\'s children'
|
|
raise exceptions.AstroidError(msg % (repr(child), repr(self)))
|
|
|
|
def locate_child(self, child):
|
|
"""return a 2-uple (child attribute name, sequence or node)"""
|
|
for field in self._astroid_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 find %s in %s\'s children'
|
|
raise exceptions.AstroidError(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]
|
|
|
|
# these are lazy because they're relatively expensive to compute for every
|
|
# single node, and they rarely get looked at
|
|
|
|
@decoratorsmod.cachedproperty
|
|
def fromlineno(self):
|
|
if self.lineno is None:
|
|
return self._fixed_source_line()
|
|
else:
|
|
return self.lineno
|
|
|
|
@decoratorsmod.cachedproperty
|
|
def tolineno(self):
|
|
if not self._astroid_fields:
|
|
# can't have children
|
|
lastchild = None
|
|
else:
|
|
lastchild = self.last_child()
|
|
if lastchild is None:
|
|
return self.fromlineno
|
|
else:
|
|
return lastchild.tolineno
|
|
|
|
# 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 = next(_node.get_children())
|
|
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 ImportFrom, 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 exceptions.InferenceError(self.__class__.__name__)
|
|
|
|
def inferred(self):
|
|
'''return list of inferred values for a more simple inference usage'''
|
|
return list(self.infer())
|
|
|
|
def infered(self):
|
|
warnings.warn('%s.infered() is deprecated and slated for removal '
|
|
'in astroid 2.0, use %s.inferred() instead.'
|
|
% (type(self).__name__, type(self).__name__),
|
|
PendingDeprecationWarning, stacklevel=2)
|
|
return self.inferred()
|
|
|
|
def instanciate_class(self):
|
|
"""instanciate a node if it is a ClassDef 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 astroid.as_string import to_code
|
|
return to_code(self)
|
|
|
|
def repr_tree(self, ids=False):
|
|
from astroid.as_string import dump
|
|
return dump(self)
|
|
|
|
|
|
class Statement(NodeNG):
|
|
"""Statement node adding a few attributes"""
|
|
is_statement = True
|
|
|
|
def next_sibling(self):
|
|
"""return the next sibling statement"""
|
|
stmts = self.parent.child_sequence(self)
|
|
index = stmts.index(self)
|
|
try:
|
|
return stmts[index +1]
|
|
except IndexError:
|
|
pass
|
|
|
|
def previous_sibling(self):
|
|
"""return the previous sibling statement"""
|
|
stmts = self.parent.child_sequence(self)
|
|
index = stmts.index(self)
|
|
if index >= 1:
|
|
return stmts[index -1]
|