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.
362 lines
13 KiB
Python
362 lines
13 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 a set of functions to handle python protocols for nodes
|
|
where it makes sense.
|
|
"""
|
|
|
|
__doctype__ = "restructuredtext en"
|
|
|
|
from astroid.exceptions import InferenceError, NoDefault, NotFoundError
|
|
from astroid.node_classes import unpack_infer
|
|
from astroid.bases import InferenceContext, \
|
|
raise_if_nothing_infered, yes_if_nothing_infered, Instance, YES
|
|
from astroid.nodes import const_factory
|
|
from astroid import nodes
|
|
|
|
BIN_OP_METHOD = {'+': '__add__',
|
|
'-': '__sub__',
|
|
'/': '__div__',
|
|
'//': '__floordiv__',
|
|
'*': '__mul__',
|
|
'**': '__power__',
|
|
'%': '__mod__',
|
|
'&': '__and__',
|
|
'|': '__or__',
|
|
'^': '__xor__',
|
|
'<<': '__lshift__',
|
|
'>>': '__rshift__',
|
|
}
|
|
|
|
UNARY_OP_METHOD = {'+': '__pos__',
|
|
'-': '__neg__',
|
|
'~': '__invert__',
|
|
'not': None, # XXX not '__nonzero__'
|
|
}
|
|
|
|
# unary operations ############################################################
|
|
|
|
def tl_infer_unary_op(self, operator):
|
|
if operator == 'not':
|
|
return const_factory(not bool(self.elts))
|
|
raise TypeError() # XXX log unsupported operation
|
|
nodes.Tuple.infer_unary_op = tl_infer_unary_op
|
|
nodes.List.infer_unary_op = tl_infer_unary_op
|
|
|
|
|
|
def dict_infer_unary_op(self, operator):
|
|
if operator == 'not':
|
|
return const_factory(not bool(self.items))
|
|
raise TypeError() # XXX log unsupported operation
|
|
nodes.Dict.infer_unary_op = dict_infer_unary_op
|
|
|
|
|
|
def const_infer_unary_op(self, operator):
|
|
if operator == 'not':
|
|
return const_factory(not self.value)
|
|
# XXX log potentially raised TypeError
|
|
elif operator == '+':
|
|
return const_factory(+self.value)
|
|
else: # operator == '-':
|
|
return const_factory(-self.value)
|
|
nodes.Const.infer_unary_op = const_infer_unary_op
|
|
|
|
|
|
# binary operations ###########################################################
|
|
|
|
BIN_OP_IMPL = {'+': lambda a, b: a + b,
|
|
'-': lambda a, b: a - b,
|
|
'/': lambda a, b: a / b,
|
|
'//': lambda a, b: a // b,
|
|
'*': lambda a, b: a * b,
|
|
'**': lambda a, b: a ** b,
|
|
'%': lambda a, b: a % b,
|
|
'&': lambda a, b: a & b,
|
|
'|': lambda a, b: a | b,
|
|
'^': lambda a, b: a ^ b,
|
|
'<<': lambda a, b: a << b,
|
|
'>>': lambda a, b: a >> b,
|
|
}
|
|
for key, impl in list(BIN_OP_IMPL.items()):
|
|
BIN_OP_IMPL[key+'='] = impl
|
|
|
|
def const_infer_binary_op(self, operator, other, context):
|
|
for other in other.infer(context):
|
|
if isinstance(other, nodes.Const):
|
|
try:
|
|
impl = BIN_OP_IMPL[operator]
|
|
|
|
try:
|
|
yield const_factory(impl(self.value, other.value))
|
|
except Exception:
|
|
# ArithmeticError is not enough: float >> float is a TypeError
|
|
# TODO : let pylint know about the problem
|
|
pass
|
|
except TypeError:
|
|
# XXX log TypeError
|
|
continue
|
|
elif other is YES:
|
|
yield other
|
|
else:
|
|
try:
|
|
for val in other.infer_binary_op(operator, self, context):
|
|
yield val
|
|
except AttributeError:
|
|
yield YES
|
|
nodes.Const.infer_binary_op = yes_if_nothing_infered(const_infer_binary_op)
|
|
|
|
|
|
def tl_infer_binary_op(self, operator, other, context):
|
|
for other in other.infer(context):
|
|
if isinstance(other, self.__class__) and operator == '+':
|
|
node = self.__class__()
|
|
elts = [n for elt in self.elts for n in elt.infer(context)
|
|
if not n is YES]
|
|
elts += [n for elt in other.elts for n in elt.infer(context)
|
|
if not n is YES]
|
|
node.elts = elts
|
|
yield node
|
|
elif isinstance(other, nodes.Const) and operator == '*':
|
|
if not isinstance(other.value, int):
|
|
yield YES
|
|
continue
|
|
node = self.__class__()
|
|
elts = [n for elt in self.elts for n in elt.infer(context)
|
|
if not n is YES] * other.value
|
|
node.elts = elts
|
|
yield node
|
|
elif isinstance(other, Instance) and not isinstance(other, nodes.Const):
|
|
yield YES
|
|
# XXX else log TypeError
|
|
nodes.Tuple.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
|
|
nodes.List.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
|
|
|
|
|
|
def dict_infer_binary_op(self, operator, other, context):
|
|
for other in other.infer(context):
|
|
if isinstance(other, Instance) and isinstance(other._proxied, nodes.Class):
|
|
yield YES
|
|
# XXX else log TypeError
|
|
nodes.Dict.infer_binary_op = yes_if_nothing_infered(dict_infer_binary_op)
|
|
|
|
def instance_infer_binary_op(self, operator, other, context):
|
|
try:
|
|
methods = self.getattr(BIN_OP_METHOD[operator])
|
|
except (NotFoundError, KeyError):
|
|
# Unknown operator
|
|
yield YES
|
|
else:
|
|
for method in methods:
|
|
if not isinstance(method, nodes.Function):
|
|
continue
|
|
for result in method.infer_call_result(self, context):
|
|
if result is not YES:
|
|
yield result
|
|
# We are interested only in the first infered method,
|
|
# don't go looking in the rest of the methods of the ancestors.
|
|
break
|
|
|
|
Instance.infer_binary_op = yes_if_nothing_infered(instance_infer_binary_op)
|
|
|
|
|
|
# assignment ##################################################################
|
|
|
|
"""the assigned_stmts method is responsible to return the assigned statement
|
|
(e.g. not inferred) according to the assignment type.
|
|
|
|
The `asspath` argument is used to record the lhs path of the original node.
|
|
For instance if we want assigned statements for 'c' in 'a, (b,c)', asspath
|
|
will be [1, 1] once arrived to the Assign node.
|
|
|
|
The `context` argument is the current inference context which should be given
|
|
to any intermediary inference necessary.
|
|
"""
|
|
|
|
def _resolve_looppart(parts, asspath, context):
|
|
"""recursive function to resolve multiple assignments on loops"""
|
|
asspath = asspath[:]
|
|
index = asspath.pop(0)
|
|
for part in parts:
|
|
if part is YES:
|
|
continue
|
|
# XXX handle __iter__ and log potentially detected errors
|
|
if not hasattr(part, 'itered'):
|
|
continue
|
|
try:
|
|
itered = part.itered()
|
|
except TypeError:
|
|
continue # XXX log error
|
|
for stmt in itered:
|
|
try:
|
|
assigned = stmt.getitem(index, context)
|
|
except (AttributeError, IndexError):
|
|
continue
|
|
except TypeError: # stmt is unsubscriptable Const
|
|
continue
|
|
if not asspath:
|
|
# we achieved to resolved the assignment path,
|
|
# don't infer the last part
|
|
yield assigned
|
|
elif assigned is YES:
|
|
break
|
|
else:
|
|
# we are not yet on the last part of the path
|
|
# search on each possibly inferred value
|
|
try:
|
|
for infered in _resolve_looppart(assigned.infer(context),
|
|
asspath, context):
|
|
yield infered
|
|
except InferenceError:
|
|
break
|
|
|
|
|
|
def for_assigned_stmts(self, node, context=None, asspath=None):
|
|
if asspath is None:
|
|
for lst in self.iter.infer(context):
|
|
if isinstance(lst, (nodes.Tuple, nodes.List)):
|
|
for item in lst.elts:
|
|
yield item
|
|
else:
|
|
for infered in _resolve_looppart(self.iter.infer(context),
|
|
asspath, context):
|
|
yield infered
|
|
|
|
nodes.For.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
|
|
nodes.Comprehension.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
|
|
|
|
|
|
def mulass_assigned_stmts(self, node, context=None, asspath=None):
|
|
if asspath is None:
|
|
asspath = []
|
|
asspath.insert(0, self.elts.index(node))
|
|
return self.parent.assigned_stmts(self, context, asspath)
|
|
nodes.Tuple.assigned_stmts = mulass_assigned_stmts
|
|
nodes.List.assigned_stmts = mulass_assigned_stmts
|
|
|
|
|
|
def assend_assigned_stmts(self, context=None):
|
|
return self.parent.assigned_stmts(self, context=context)
|
|
nodes.AssName.assigned_stmts = assend_assigned_stmts
|
|
nodes.AssAttr.assigned_stmts = assend_assigned_stmts
|
|
|
|
|
|
def _arguments_infer_argname(self, name, context):
|
|
# arguments information may be missing, in which case we can't do anything
|
|
# more
|
|
if not (self.args or self.vararg or self.kwarg):
|
|
yield YES
|
|
return
|
|
# first argument of instance/class method
|
|
if self.args and getattr(self.args[0], 'name', None) == name:
|
|
functype = self.parent.type
|
|
if functype == 'method':
|
|
yield Instance(self.parent.parent.frame())
|
|
return
|
|
if functype == 'classmethod':
|
|
yield self.parent.parent.frame()
|
|
return
|
|
if name == self.vararg:
|
|
vararg = const_factory(())
|
|
vararg.parent = self
|
|
yield vararg
|
|
return
|
|
if name == self.kwarg:
|
|
kwarg = const_factory({})
|
|
kwarg.parent = self
|
|
yield kwarg
|
|
return
|
|
# if there is a default value, yield it. And then yield YES to reflect
|
|
# we can't guess given argument value
|
|
try:
|
|
if context is None:
|
|
context = InferenceContext()
|
|
for infered in self.default_value(name).infer(context):
|
|
yield infered
|
|
yield YES
|
|
except NoDefault:
|
|
yield YES
|
|
|
|
|
|
def arguments_assigned_stmts(self, node, context, asspath=None):
|
|
if context.callcontext:
|
|
# reset call context/name
|
|
callcontext = context.callcontext
|
|
return callcontext.infer_argument(self.parent, node.name, context)
|
|
return _arguments_infer_argname(self, node.name, context)
|
|
nodes.Arguments.assigned_stmts = arguments_assigned_stmts
|
|
|
|
|
|
def assign_assigned_stmts(self, node, context=None, asspath=None):
|
|
if not asspath:
|
|
yield self.value
|
|
return
|
|
for infered in _resolve_asspart(self.value.infer(context), asspath, context):
|
|
yield infered
|
|
nodes.Assign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
|
|
nodes.AugAssign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
|
|
|
|
|
|
def _resolve_asspart(parts, asspath, context):
|
|
"""recursive function to resolve multiple assignments"""
|
|
asspath = asspath[:]
|
|
index = asspath.pop(0)
|
|
for part in parts:
|
|
if hasattr(part, 'getitem'):
|
|
try:
|
|
assigned = part.getitem(index, context)
|
|
# XXX raise a specific exception to avoid potential hiding of
|
|
# unexpected exception ?
|
|
except (TypeError, IndexError):
|
|
return
|
|
if not asspath:
|
|
# we achieved to resolved the assignment path, don't infer the
|
|
# last part
|
|
yield assigned
|
|
elif assigned is YES:
|
|
return
|
|
else:
|
|
# we are not yet on the last part of the path search on each
|
|
# possibly inferred value
|
|
try:
|
|
for infered in _resolve_asspart(assigned.infer(context),
|
|
asspath, context):
|
|
yield infered
|
|
except InferenceError:
|
|
return
|
|
|
|
|
|
def excepthandler_assigned_stmts(self, node, context=None, asspath=None):
|
|
for assigned in unpack_infer(self.type):
|
|
if isinstance(assigned, nodes.Class):
|
|
assigned = Instance(assigned)
|
|
yield assigned
|
|
nodes.ExceptHandler.assigned_stmts = raise_if_nothing_infered(excepthandler_assigned_stmts)
|
|
|
|
|
|
def with_assigned_stmts(self, node, context=None, asspath=None):
|
|
if asspath is None:
|
|
for _, vars in self.items:
|
|
if vars is None:
|
|
continue
|
|
for lst in vars.infer(context):
|
|
if isinstance(lst, (nodes.Tuple, nodes.List)):
|
|
for item in lst.nodes:
|
|
yield item
|
|
nodes.With.assigned_stmts = raise_if_nothing_infered(with_assigned_stmts)
|
|
|
|
|