pylint: upgrade to 1.4.0

third_party/logilab/astroid/inference.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.
 #
@@ skipping 10 matching lines @@
 __doctype__ = "restructuredtext en"
 
 from itertools import chain
 
 from astroid import nodes
 
 from astroid.manager import AstroidManager
 from astroid.exceptions import (AstroidError, InferenceError, NoDefault,
                                 NotFoundError, UnresolvableName)
 from astroid.bases import (YES, Instance, InferenceContext,
-                           _infer_stmts, copy_context, path_wrapper,
+                           _infer_stmts, path_wrapper,
                            raise_if_nothing_infered)
 from astroid.protocols import (
     _arguments_infer_argname,
     BIN_OP_METHOD, UNARY_OP_METHOD)
 
 MANAGER = AstroidManager()
 
 
 class CallContext(object):
     """when inferring a function call, this class is used to remember values
@@ skipping 126 matching lines @@
     if not stmts:
         # Try to see if the name is enclosed in a nested function
         # and use the higher (first function) scope for searching.
         # TODO: should this be promoted to other nodes as well?
         parent_function = _higher_function_scope(self.scope())
         if parent_function:
             _, stmts = parent_function.lookup(self.name)
 
         if not stmts:
             raise UnresolvableName(self.name)
-    context = context.clone()
-    context.lookupname = self.name
-    return _infer_stmts(stmts, context, frame)
+    return _infer_stmts(stmts, context, frame, self.name)
 nodes.Name._infer = path_wrapper(infer_name)
 nodes.AssName.infer_lhs = infer_name # won't work with a path wrapper
 
 
 def infer_callfunc(self, context=None):
     """infer a CallFunc node by trying to guess what the function returns"""
-    callcontext = context.clone()
-    callcontext.callcontext = CallContext(self.args, self.starargs, self.kwargs)
-    callcontext.boundnode = None
+    if context is None:
+        context = InferenceContext()
     for callee in self.func.infer(context):
-        if callee is YES:
-            yield callee
-            continue
-        try:
-            if hasattr(callee, 'infer_call_result'):
-                for infered in callee.infer_call_result(self, callcontext):
-                    yield infered
-        except InferenceError:
-            ## XXX log error ?
-            continue
+        with context.scope(
+            callcontext=CallContext(self.args, self.starargs, self.kwargs),
+            boundnode=None,
+        ):
+            if callee is YES:
+                yield callee
+                continue
+            try:
+                if hasattr(callee, 'infer_call_result'):
+                    for infered in callee.infer_call_result(self, context):
+                        yield infered
+            except InferenceError:
+                ## XXX log error ?
+                continue
 nodes.CallFunc._infer = path_wrapper(raise_if_nothing_infered(infer_callfunc))
 
 
-def infer_import(self, context=None, asname=True):
+def infer_import(self, context=None, asname=True, lookupname=None):
     """infer an Import node: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
+    if lookupname is None:
         raise InferenceError()
     if asname:
-        yield self.do_import_module(self.real_name(name))
+        yield self.do_import_module(self.real_name(lookupname))
     else:
-        yield self.do_import_module(name)
+        yield self.do_import_module(lookupname)
 nodes.Import._infer = path_wrapper(infer_import)
 
 def infer_name_module(self, name):
     context = InferenceContext()
-    context.lookupname = name
-    return self.infer(context, asname=False)
+    return self.infer(context, asname=False, lookupname=name)
 nodes.Import.infer_name_module = infer_name_module
 
 
-def infer_from(self, context=None, asname=True):
+def infer_from(self, context=None, asname=True, lookupname=None):
     """infer a From nodes: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
+    if lookupname is None:
         raise InferenceError()
     if asname:
-        name = self.real_name(name)
+        lookupname = self.real_name(lookupname)
     module = self.do_import_module()
     try:
-        context = copy_context(context)
-        context.lookupname = name
-        return _infer_stmts(module.getattr(name, ignore_locals=module is self.root()), context)
+        return _infer_stmts(module.getattr(lookupname, ignore_locals=module is self.root()), context, lookupname=lookupname)
     except NotFoundError:
-        raise InferenceError(name)
+        raise InferenceError(lookupname)
 nodes.From._infer = path_wrapper(infer_from)
 
 
 def infer_getattr(self, context=None):
     """infer a Getattr node by using getattr on the associated object"""
-    #context = context.clone()
+    if not context:
+        context = InferenceContext()
     for owner in self.expr.infer(context):
         if owner is YES:
             yield owner
             continue
         try:
-            context.boundnode = owner
-            for obj in owner.igetattr(self.attrname, context):
-                yield obj
-            context.boundnode = None
+            with context.scope(boundnode=owner):
+                for obj in owner.igetattr(self.attrname, context):
+                    yield obj
         except (NotFoundError, InferenceError):
-            context.boundnode = None
+            pass
         except AttributeError:
             # XXX method / function
-            context.boundnode = None
+            pass
 nodes.Getattr._infer = path_wrapper(raise_if_nothing_infered(infer_getattr))
 nodes.AssAttr.infer_lhs = raise_if_nothing_infered(infer_getattr) # # won't work with a path wrapper
 
 
-def infer_global(self, context=None):
-    if context.lookupname is None:
+def infer_global(self, context=None, lookupname=None):
+    if lookupname is None:
         raise InferenceError()
     try:
-        return _infer_stmts(self.root().getattr(context.lookupname), context)
+        return _infer_stmts(self.root().getattr(lookupname), context)
     except NotFoundError:
         raise InferenceError()
 nodes.Global._infer = path_wrapper(infer_global)
 
 
 def infer_subscript(self, context=None):
     """infer simple subscription such as [1,2,3][0] or (1,2,3)[-1]"""
-    value = self.value.infer(context).next()
+    value = next(self.value.infer(context))
     if value is YES:
         yield YES
         return
 
-    index = self.slice.infer(context).next()
+    index = next(self.slice.infer(context))
     if index is YES:
         yield YES
         return
 
     if isinstance(index, nodes.Const):
         try:
             assigned = value.getitem(index.value, context)
         except AttributeError:
             raise InferenceError()
         except (IndexError, TypeError):
             yield YES
             return
+
+        # Prevent inferring if the infered subscript
+        # is the same as the original subscripted object.
+        if self is assigned:
+            yield YES
+            return
         for infered in assigned.infer(context):
             yield infered
     else:
         raise InferenceError()
 nodes.Subscript._infer = path_wrapper(infer_subscript)
 nodes.Subscript.infer_lhs = raise_if_nothing_infered(infer_subscript)
 
 def infer_unaryop(self, context=None):
     for operand in self.operand.infer(context):
         try:
@@ skipping 40 matching lines @@
     for lhs in self.left.infer(context):
         for val in _infer_binop(self.op, lhs, self.right, context, failures):
             yield val
     for lhs in failures:
         for rhs in self.right.infer(context):
             for val in _infer_binop(self.op, rhs, lhs, context):
                 yield val
 nodes.BinOp._infer = path_wrapper(infer_binop)
 
 
-def infer_arguments(self, context=None):
-    name = context.lookupname
-    if name is None:
+def infer_arguments(self, context=None, lookupname=None):
+    if lookupname is None:
         raise InferenceError()
-    return _arguments_infer_argname(self, name, context)
+    return _arguments_infer_argname(self, lookupname, context)
 nodes.Arguments._infer = infer_arguments
 
 
 def infer_ass(self, context=None):
     """infer a AssName/AssAttr: need to inspect the RHS part of the
     assign node
     """
     stmt = self.statement()
     if isinstance(stmt, nodes.AugAssign):
         return stmt.infer(context)
@@ skipping 26 matching lines @@
                                                             context=context):
                 yield infered
         except AstroidError:
             yield YES
 nodes.EmptyNode._infer = path_wrapper(infer_empty_node)
 
 
 def infer_index(self, context=None):
     return self.value.infer(context)
 nodes.Index._infer = infer_index