diff options
author | Torsten Marek <shlomme@gmail.com> | 2014-11-08 23:47:14 +0100 |
---|---|---|
committer | Torsten Marek <shlomme@gmail.com> | 2014-11-08 23:47:14 +0100 |
commit | 0c7327e7599c69843ffdb884d313863ec36cb6dd (patch) | |
tree | b089fb5596dce312bdc84cf5028937449a453dda /astroid/protocols.py | |
parent | 206aceba12b2aa9b8cce7fd0681905239e0f0cc5 (diff) | |
download | astroid-0c7327e7599c69843ffdb884d313863ec36cb6dd.tar.gz |
Move all astroid modules into a its own directory, which is now the package.
python setup.py develop now works.
Diffstat (limited to 'astroid/protocols.py')
-rw-r--r-- | astroid/protocols.py | 361 |
1 files changed, 361 insertions, 0 deletions
diff --git a/astroid/protocols.py b/astroid/protocols.py new file mode 100644 index 0000000..4dd515f --- /dev/null +++ b/astroid/protocols.py @@ -0,0 +1,361 @@ +# 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) + + |