Remove context.lookupname; make it an argument to infer() when appropriate.

1 files changed, 18 insertions, 28 deletions

diff --git a/inference.py b/inference.py
index 7bc2313b..6fcb02d3 100644
--- a/inference.py
+++ b/inference.py
@@ -146,9 +146,7 @@ def infer_name(self, context=None):
     frame, stmts = self.lookup(self.name)
     if not stmts:
         raise UnresolvableName(self.name)
-    with context.scope(lookupname=self.name):
-        for infered in _infer_stmts(stmts, context, frame):
-            yield infered
+    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
 
@@ -161,7 +159,6 @@ def infer_callfunc(self, context=None):
         with context.scope(
             callcontext=CallContext(self.args, self.starargs, self.kwargs),
             boundnode=None,
-            lookupname=None,
         ):
             if callee is YES:
                 yield callee
@@ -176,39 +173,33 @@ def infer_callfunc(self, context=None):
 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()
-    with context.scope(lookupname=name):
-        for infered in self.infer(context, asname=False):
-            yield infered
+    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(self.modname)
     try:
-        with context.scope(lookupname=name):
-            for infered in _infer_stmts(module.getattr(name, ignore_locals=module is self.root()), context):
-                yield infered
+        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)
 
 
@@ -221,7 +212,7 @@ def infer_getattr(self, context=None):
             yield owner
             continue
         try:
-            with context.scope(boundnode=owner, lookupname=None):
+            with context.scope(boundnode=owner):
                 for obj in owner.igetattr(self.attrname, context):
                     yield obj
         except (NotFoundError, InferenceError):
@@ -233,11 +224,11 @@ 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)
@@ -345,11 +336,10 @@ def infer_binop(self, context=None):
 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