pylint: upgrade to 1.4.0

third_party/logilab/astroid/bases.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 base classes and functions for the nodes and some
 inference utils.
 """
 
 __docformat__ = "restructuredtext en"
 
 import sys
 from contextlib import contextmanager
 
+from logilab.common.decorators import cachedproperty
+
 from astroid.exceptions import (InferenceError, AstroidError, NotFoundError,
                                 UnresolvableName, UseInferenceDefault)
 
 
 if sys.version_info >= (3, 0):
     BUILTINS = 'builtins'
 else:
     BUILTINS = '__builtin__'
 
 
@@ skipping 12 matching lines @@
         if name in self.__dict__:
             return self.__dict__[name]
         return getattr(self._proxied, name)
 
     def infer(self, context=None):
         yield self
 
 
 # Inference ##################################################################
 
+MISSING = object()
+
+
 class InferenceContext(object):
-    __slots__ = ('path', 'lookupname', 'callcontext', 'boundnode')
+    __slots__ = ('path', 'callcontext', 'boundnode', 'infered')
 
-    def __init__(self, path=None):
+    def __init__(self,
+            path=None, callcontext=None, boundnode=None, infered=None):
         if path is None:
-            self.path = set()
+            self.path = frozenset()
         else:
             self.path = path
-        self.lookupname = None
-        self.callcontext = None
-        self.boundnode = None
+        self.callcontext = callcontext
+        self.boundnode = boundnode
+        if infered is None:
+            self.infered = {}
+        else:
+            self.infered = infered
 
-    def push(self, node):
-        name = self.lookupname
-        if (node, name) in self.path:
-            raise StopIteration()
-        self.path.add((node, name))
+    def push(self, key):
+        # This returns a NEW context with the same attributes, but a new key
+        # added to `path`.  The intention is that it's only passed to callees
+        # and then destroyed; otherwise scope() may not work correctly.
+        # The cache will be shared, since it's the same exact dict.
+        if key in self.path:
+            # End the containing generator
+            raise StopIteration
 
-    def clone(self):
-        # XXX copy lookupname/callcontext ?
-        clone = InferenceContext(self.path)
-        clone.callcontext = self.callcontext
-        clone.boundnode = self.boundnode
-        return clone
+        return InferenceContext(
+            self.path.union([key]),
+            self.callcontext,
+            self.boundnode,
+            self.infered,
+        )
 
     @contextmanager
-    def restore_path(self):
-        path = set(self.path)
-        yield
-        self.path = path
+    def scope(self, callcontext=MISSING, boundnode=MISSING):
+        try:
+            orig = self.callcontext, self.boundnode
+            if callcontext is not MISSING:
+                self.callcontext = callcontext
+            if boundnode is not MISSING:
+                self.boundnode = boundnode
+            yield
+        finally:
+            self.callcontext, self.boundnode = orig
 
-def copy_context(context):
-    if context is not None:
-        return context.clone()
-    else:
-        return InferenceContext()
+    def cache_generator(self, key, generator):
+        results = []
+        for result in generator:
+            results.append(result)
+            yield result
+
+        self.infered[key] = tuple(results)
+        return
 
 
-def _infer_stmts(stmts, context, frame=None):
+def _infer_stmts(stmts, context, frame=None, lookupname=None):
     """return an iterator on statements inferred by each statement in <stmts>
     """
     stmt = None
     infered = False
-    if context is not None:
-        name = context.lookupname
-        context = context.clone()
-    else:
-        name = None
+    if context is None:
         context = InferenceContext()
     for stmt in stmts:
         if stmt is YES:
             yield stmt
             infered = True
             continue
-        context.lookupname = stmt._infer_name(frame, name)
+
+        kw = {}
+        infered_name = stmt._infer_name(frame, lookupname)
+        if infered_name is not None:
+            # only returns not None if .infer() accepts a lookupname kwarg
+            kw['lookupname'] = infered_name
+
         try:
-            for infered in stmt.infer(context):
+            for infered in stmt.infer(context, **kw):
                 yield infered
                 infered = True
         except UnresolvableName:
             continue
         except InferenceError:
             yield YES
             infered = True
     if not infered:
         raise InferenceError(str(stmt))
 
@@ skipping 37 matching lines @@
         # well
         if lookupclass:
             try:
                 return values + self._proxied.getattr(name, context)
             except NotFoundError:
                 pass
         return values
 
     def igetattr(self, name, context=None):
         """inferred getattr"""
+        if not context:
+            context = InferenceContext()
         try:
             # avoid recursively inferring the same attr on the same class
-            if context:
-                context.push((self._proxied, name))
+            new_context = context.push((self._proxied, name))
             # XXX frame should be self._proxied, or not ?
-            get_attr = self.getattr(name, context, lookupclass=False)
-            return _infer_stmts(self._wrap_attr(get_attr, context), context,
-                                frame=self)
+            get_attr = self.getattr(name, new_context, lookupclass=False)
+            return _infer_stmts(
+                self._wrap_attr(get_attr, new_context),
+                new_context,
+                frame=self,
+            )
         except NotFoundError:
             try:
                 # fallback to class'igetattr since it has some logic to handle
                 # descriptors
                 return self._wrap_attr(self._proxied.igetattr(name, context),
-                                       context)
+                                            context)
             except NotFoundError:
                 raise InferenceError(name)
 
     def _wrap_attr(self, attrs, context=None):
         """wrap bound methods of attrs in a InstanceMethod proxies"""
         for attr in attrs:
             if isinstance(attr, UnboundMethod):
                 if BUILTINS + '.property' in attr.decoratornames():
                     for infered in attr.infer_call_result(self, context):
                         yield infered
@@ skipping 70 matching lines @@
 class BoundMethod(UnboundMethod):
     """a special node representing a method bound to an instance"""
     def __init__(self, proxy, bound):
         UnboundMethod.__init__(self, proxy)
         self.bound = bound
 
     def is_bound(self):
         return True
 
     def infer_call_result(self, caller, context):
-        context = context.clone()
-        context.boundnode = self.bound
-        return self._proxied.infer_call_result(caller, context)
+        with context.scope(boundnode=self.bound):
+            for infered in self._proxied.infer_call_result(caller, context):
+                yield infered
 
 
 class Generator(Instance):
     """a special node representing a generator.
 
     Proxied class is set once for all in raw_building.
     """
     def callable(self):
         return False
 
@@ skipping 11 matching lines @@
 
 
 # decorators ##################################################################
 
 def path_wrapper(func):
     """return the given infer function wrapped to handle the path"""
     def wrapped(node, context=None, _func=func, **kwargs):
         """wrapper function handling context"""
         if context is None:
             context = InferenceContext()
-        context.push(node)
+        context = context.push((node, kwargs.get('lookupname')))
+
         yielded = set()
         for res in _func(node, context, **kwargs):
             # unproxy only true instance, not const, tuple, dict...
             if res.__class__ is Instance:
                 ares = res._proxied
             else:
                 ares = res
             if not ares in yielded:
                 yield res
                 yielded.add(ares)
@@ skipping 48 matching lines @@
 
         If the instance has some explicit inference function set, it will be
         called instead of the default interface.
         """
         if self._explicit_inference is not None:
             # explicit_inference is not bound, give it self explicitly
             try:
                 return self._explicit_inference(self, context, **kwargs)
             except UseInferenceDefault:
                 pass
-        return self._infer(context, **kwargs)
+
+        if not context:
+            return self._infer(context, **kwargs)
+
+        key = (self, kwargs.get('lookupname'), context.callcontext, context.boundnode)
+        if key in context.infered:
+            return iter(context.infered[key])
+
+        return context.cache_generator(key, self._infer(context, **kwargs))
 
     def _repr_name(self):
         """return self.name or self.attrname or '' for nice representation"""
         return getattr(self, 'name', getattr(self, 'attrname', ''))
 
     def __str__(self):
         return '%s(%s)' % (self.__class__.__name__, self._repr_name())
 
     def __repr__(self):
         return '<%s(%s) l.%s [%s] at 0x%x>' % (self.__class__.__name__,
@@ skipping 17 matching lines @@
                     yield elt
             else:
                 yield attr
 
     def last_child(self):
         """an optimized version of list(get_children())[-1]"""
         for field in self._astroid_fields[::-1]:
             attr = getattr(self, field)
             if not attr: # None or empty listy / tuple
                 continue
-            if isinstance(attr, (list, tuple)):
+            if attr.__class__ in (list, tuple):
                 return attr[-1]
             else:
                 return attr
         return None
 
     def parent_of(self, node):
         """return true if i'm a parent of the given node"""
         parent = node.parent
         while parent is not None:
             if self is parent:
@@ skipping 70 matching lines @@
             assert node.root() is myroot, \
                    'nodes %s and %s are not from the same module' % (self, node)
             lineno = node.fromlineno
             if node.fromlineno > mylineno:
                 break
             if lineno > nearest[1]:
                 nearest = node, lineno
         # FIXME: raise an exception if nearest is None ?
         return nearest[0]
 
-    def set_line_info(self, lastchild):
+    # these are lazy because they're relatively expensive to compute for every
+    # single node, and they rarely get looked at
+
+    @cachedproperty
+    def fromlineno(self):
         if self.lineno is None:
-            self.fromlineno = self._fixed_source_line()
+            return self._fixed_source_line()
         else:
-            self.fromlineno = self.lineno
+            return self.lineno
+
+    @cachedproperty
+    def tolineno(self):
+        if not self._astroid_fields:
+            # can't have children
+            lastchild = None
+        else:
+            lastchild = self.last_child()
         if lastchild is None:
-            self.tolineno = self.fromlineno
+            return self.fromlineno
         else:
-            self.tolineno = lastchild.tolineno
-        return
+            return lastchild.tolineno
+
         # TODO / FIXME:
         assert self.fromlineno is not None, self
         assert self.tolineno is not None, self
 
     def _fixed_source_line(self):
         """return the line number where the given node appears
 
         we need this method since not all nodes have the lineno attribute
         correctly set...
         """
         line = self.lineno
         _node = self
         try:
             while line is None:
-                _node = _node.get_children().next()
+                _node = next(_node.get_children())
                 line = _node.lineno
         except StopIteration:
             _node = self.parent
             while _node and line is None:
                 line = _node.lineno
                 _node = _node.parent
         return line
 
     def block_range(self, lineno):
         """handle block line numbers range for non block opening statements
@@ skipping 64 matching lines @@
             return stmts[index +1]
         except IndexError:
             pass
 
     def previous_sibling(self):
         """return the previous sibling statement"""
         stmts = self.parent.child_sequence(self)
         index = stmts.index(self)
         if index >= 1:
             return stmts[index -1]