pylint: upgrade to 1.4.0

third_party/logilab/astroid/protocols.py

 # 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 copy_context, \
+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__',
@@ skipping 47 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,
               }
-for key, impl in BIN_OP_IMPL.items():
+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))
@@ skipping 170 matching lines @@
         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:
-        context = copy_context(context)
+        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
-        context = copy_context(context)
-        context.callcontext = None
-        for infered in callcontext.infer_argument(self.parent, node.name, context):
-            yield infered
-        return
-    for infered in _arguments_infer_argname(self, node.name, context):
-        yield infered
+        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)
@@ skipping 42 matching lines @@
         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)