Revert "pylint: upgrade to 1.3.1"

third_party/logilab/astng/protocols.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 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 astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# 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.
 #
-# astroid is distributed in the hope that it will be useful, but
+# 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 astroid. If not, see <http://www.gnu.org/licenses/>.
+# with logilab-astng. 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 copy_context, \
-     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__'
-                  }
+from logilab.astng.exceptions import InferenceError, NoDefault
+from logilab.astng.node_classes import unpack_infer
+from logilab.astng.bases import copy_context, \
+     raise_if_nothing_infered, yes_if_nothing_infered, Instance, Generator, YES
+from logilab.astng.nodes import const_factory
+from logilab.astng import nodes
 
 # 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
 
@@ skipping 23 matching lines @@
                '/':  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 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:
@@ skipping 42 matching lines @@
 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.
 
@@ skipping 13 matching lines @@
             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
+            except TypeError, exc: # 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
@@ skipping 44 matching lines @@
     # 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
+        yield const_factory(())
         return
     if name == self.kwarg:
-        kwarg = const_factory({})
-        kwarg.parent = self
-        yield kwarg
+        yield const_factory({})
         return
     # if there is a default value, yield it. And then yield YES to reflect
     # we can't guess given argument value
     try:
         context = copy_context(context)
         for infered in self.default_value(name).infer(context):
             yield infered
         yield YES
     except NoDefault:
         yield YES
@@ skipping 55 matching lines @@
 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
+        for lst in self.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)