pylint: upgrade to 1.4.0

third_party/logilab/astroid/scoped_nodes.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 12 matching lines @@
 
 __doctype__ = "restructuredtext en"
 
 import sys
 from itertools import chain
 try:
     from io import BytesIO
 except ImportError:
     from cStringIO import StringIO as BytesIO
 
+import six
 from logilab.common.compat import builtins
 from logilab.common.decorators import cached, cachedproperty
 
 from astroid.exceptions import NotFoundError, \
      AstroidBuildingException, InferenceError
 from astroid.node_classes import Const, DelName, DelAttr, \
      Dict, From, List, Pass, Raise, Return, Tuple, Yield, YieldFrom, \
      LookupMixIn, const_factory as cf, unpack_infer, Name, CallFunc
 from astroid.bases import NodeNG, InferenceContext, Instance,\
-     YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, copy_context, \
+     YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, \
      BUILTINS
 from astroid.mixins import FilterStmtsMixin
 from astroid.bases import Statement
 from astroid.manager import AstroidManager
 
 ITER_METHODS = ('__iter__', '__getitem__')
 PY3K = sys.version_info >= (3, 0)
 
 
 def remove_nodes(func, cls):
@@ skipping 131 matching lines @@
     def __iter__(self):
         """method from the `dict` interface returning an iterator on
         `self.keys()`
         """
         return iter(self.keys())
 
     def keys(self):
         """method from the `dict` interface returning a tuple containing
         locally defined names
         """
-        return self.locals.keys()
+        return list(self.locals.keys())
 
     def values(self):
         """method from the `dict` interface returning a tuple containing
         locally defined nodes which are instance of `Function` or `Class`
         """
         return [self[key] for key in self.keys()]
 
     def items(self):
         """method from the `dict` interface returning a list of tuple
         containing each locally defined name with its associated node,
         which is an instance of `Function` or `Class`
         """
-        return zip(self.keys(), self.values())
+        return list(zip(self.keys(), self.values()))
 
 
     def __contains__(self, name):
         return name in self.locals
     has_key = __contains__
 
 # Module  #####################################################################
 
 class Module(LocalsDictNodeNG):
     _astroid_fields = ('body',)
@@ skipping 31 matching lines @@
     scope_attrs = set(('__name__', '__doc__', '__file__', '__path__'))
 
     def __init__(self, name, doc, pure_python=True):
         self.name = name
         self.doc = doc
         self.pure_python = pure_python
         self.locals = self.globals = {}
         self.body = []
         self.future_imports = set()
 
-    @property
+    @cachedproperty
     def file_stream(self):
         if self.file_bytes is not None:
             return BytesIO(self.file_bytes)
         if self.file is not None:
             return open(self.file, 'rb')
         return None
 
     def block_range(self, lineno):
         """return block line numbers.
 
@@ skipping 34 matching lines @@
             except Exception:# XXX pylint tests never pass here; do we need it?
                 import traceback
                 traceback.print_exc()
         raise NotFoundError(name)
     getattr = remove_nodes(getattr, DelName)
 
     def igetattr(self, name, context=None):
         """inferred getattr"""
         # set lookup name since this is necessary to infer on import nodes for
         # instance
-        context = copy_context(context)
-        context.lookupname = name
+        if not context:
+            context = InferenceContext()
         try:
-            return _infer_stmts(self.getattr(name, context), context, frame=self)
+            return _infer_stmts(self.getattr(name, context), context, frame=self, lookupname=name)
         except NotFoundError:
             raise InferenceError(name)
 
     def fully_defined(self):
         """return True if this module has been built from a .py file
         and so contains a complete representation including the code
         """
         return self.file is not None and self.file.endswith('.py')
 
     def statement(self):
         """return the first parent node marked as statement node
         consider a module as a statement...
         """
         return self
 
     def previous_sibling(self):
         """module has no sibling"""
         return
 
     def next_sibling(self):
         """module has no sibling"""
         return
 
     if sys.version_info < (2, 8):
-        def absolute_import_activated(self):
+        @cachedproperty
+        def _absolute_import_activated(self):
             for stmt in self.locals.get('absolute_import', ()):
                 if isinstance(stmt, From) and stmt.modname == '__future__':
                     return True
             return False
     else:
-        absolute_import_activated = lambda self: True
+        _absolute_import_activated = True
+
+    def absolute_import_activated(self):
+        return self._absolute_import_activated
 
     def import_module(self, modname, relative_only=False, level=None):
         """import the given module considering self as context"""
         if relative_only and level is None:
             level = 0
         absmodname = self.relative_to_absolute_name(modname, level)
         try:
             return MANAGER.ast_from_module_name(absmodname)
         except AstroidBuildingException:
             # we only want to import a sub module or package of this module,
@@ skipping 42 matching lines @@
         else:
             try:
                 return living.__all__
             except AttributeError:
                 return [name for name in living.__dict__.keys()
                         if not name.startswith('_')]
         # else lookup the astroid
         #
         # We separate the different steps of lookup in try/excepts
         # to avoid catching too many Exceptions
-        # However, we can not analyse dynamically constructed __all__
+        default = [name for name in self.keys() if not name.startswith('_')]
         try:
             all = self['__all__']
         except KeyError:
-            return [name for name in self.keys() if not name.startswith('_')]
+            return default
         try:
-            explicit = all.assigned_stmts().next()
+            explicit = next(all.assigned_stmts())
         except InferenceError:
-            return [name for name in self.keys() if not name.startswith('_')]
+            return default
         except AttributeError:
             # not an assignment node
             # XXX infer?
-            return [name for name in self.keys() if not name.startswith('_')]
+            return default
+
+        # Try our best to detect the exported name.
+        infered = []
         try:
-            # should be a Tuple/List of constant string / 1 string not allowed
-            return [const.value for const in explicit.elts]
-        except AttributeError:
-            return [name for name in self.keys() if not name.startswith('_')]
+            explicit = next(explicit.infer())
+        except InferenceError:
+            return default
+        if not isinstance(explicit, (Tuple, List)):
+            return default
+
+        str_const = lambda node: (isinstance(node, Const) and
+                                  isinstance(node.value, six.string_types))
+        for node in explicit.elts:
+            if str_const(node):
+                infered.append(node.value)
+            else:
+                try:
+                    infered_node = next(node.infer())
+                except InferenceError:
+                    continue
+                if str_const(infered_node):
+                    infered.append(infered_node.value)
+        return infered
+
 
 
 class ComprehensionScope(LocalsDictNodeNG):
     def frame(self):
         return self.parent.frame()
 
     scope_lookup = LocalsDictNodeNG._scope_lookup
 
 
 class GenExpr(ComprehensionScope):
@@ skipping 42 matching lines @@
 # Function  ###################################################################
 
 def _infer_decorator_callchain(node):
     """ Detect decorator call chaining and see if the
     end result is a static or a classmethod.
     """
     current = node
     while True:
         if isinstance(current, CallFunc):
             try:
-                current = current.func.infer().next()
+                current = next(current.func.infer())
             except InferenceError:
                 return
         elif isinstance(current, Function):
             if not current.parent:
                 return
             try:
                 # TODO: We don't handle multiple inference results right now,
                 #       because there's no flow to reason when the return
                 #       is what we are looking for, a static or a class method.
-                result = current.infer_call_result(current.parent).next()
+                result = next(current.infer_call_result(current.parent))
+                if current is result:
+                    # This will lead to an infinite loop, where a decorator
+                    # returns itself.
+                    return
             except (StopIteration, InferenceError):
                 return
             if isinstance(result, (Function, CallFunc)):
                 current = result
             else:
                 if isinstance(result, Instance):
                     result = result._proxied
                 if isinstance(result, Class):
                     if (result.name == 'classmethod' and
                             result.root().name == BUILTINS):
@@ skipping 110 matching lines @@
     # attributes below are set by the builder module or by raw factories
     blockstart_tolineno = None
     decorators = None
     _type = "function"
     type = cachedproperty(_function_type)
 
     def __init__(self, name, doc):
         self.locals = {}
         self.args = []
         self.body = []
-        self.decorators = None
         self.name = name
         self.doc = doc
         self.extra_decorators = []
         self.instance_attrs = {}
 
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        # lineno is the line number of the first decorator, we want the def statement lineno
+    @cachedproperty
+    def fromlineno(self):
+        # lineno is the line number of the first decorator, we want the def
+        # statement lineno
+        lineno = self.lineno
         if self.decorators is not None:
-            self.fromlineno += sum(node.tolineno - node.lineno + 1
+            lineno += sum(node.tolineno - node.lineno + 1
                                    for node in self.decorators.nodes)
-        if self.args.fromlineno < self.fromlineno:
-            self.args.fromlineno = self.fromlineno
-        self.tolineno = lastchild.tolineno
-        self.blockstart_tolineno = self.args.tolineno
+
+        return lineno
+
+    @cachedproperty
+    def blockstart_tolineno(self):
+        return self.args.tolineno
 
     def block_range(self, lineno):
         """return block line numbers.
 
         start from the "def" position whatever the given lineno
         """
         return self.fromlineno, self.tolineno
 
     def getattr(self, name, context=None):
         """this method doesn't look in the instance_attrs dictionary since it's
@@ skipping 32 matching lines @@
         """Returns True if the method is abstract.
 
         A method is considered abstract if
          - the only statement is 'raise NotImplementedError', or
          - the only statement is 'pass' and pass_is_abstract is True, or
          - the method is annotated with abc.astractproperty/abc.abstractmethod
         """
         if self.decorators:
             for node in self.decorators.nodes:
                 try:
-                    infered = node.infer().next()
+                    infered = next(node.infer())
                 except InferenceError:
                     continue
                 if infered and infered.qname() in ('abc.abstractproperty',
                                                    'abc.abstractmethod'):
                     return True
 
         for child_node in self.body:
             if isinstance(child_node, Raise):
                 if child_node.raises_not_implemented():
                     return True
             if pass_is_abstract and isinstance(child_node, Pass):
                 return True
             return False
         # empty function is the same as function with a single "pass" statement
         if pass_is_abstract:
             return True
 
     def is_generator(self):
         """return true if this is a generator function"""
         # XXX should be flagged, not computed
-        try:
-            return self.nodes_of_class((Yield, YieldFrom),
-                                       skip_klass=(Function, Lambda)).next()
-        except StopIteration:
-            return False
+        return next(self.nodes_of_class((Yield, YieldFrom),
+                                        skip_klass=(Function, Lambda)), False)
 
     def infer_call_result(self, caller, context=None):
         """infer what a function is returning when called"""
         if self.is_generator():
             yield Generator()
             return
+        # This is really a gigantic hack to work around metaclass generators
+        # that return transient class-generating functions. Pylint's AST structure
+        # cannot handle a base class object that is only used for calling __new__,
+        # but does not contribute to the inheritance structure itself. We inject
+        # a fake class into the hierarchy here for several well-known metaclass
+        # generators, and filter it out later.
+        if (self.name == 'with_metaclass' and 
+                len(self.args.args) == 1 and 
+                self.args.vararg is not None):
+            metaclass = next(caller.args[0].infer(context))
+            if isinstance(metaclass, Class):
+                c = Class('temporary_class', None)
+                c.hide = True
+                c.parent = self
+                c.bases = [next(b.infer(context)) for b in caller.args[1:]]
+                c._metaclass = metaclass
+                yield c
+                return
         returns = self.nodes_of_class(Return, skip_klass=Function)
         for returnnode in returns:
             if returnnode.value is None:
                 yield Const(None)
             else:
                 try:
                     for infered in returnnode.value.infer(context):
                         yield infered
                 except InferenceError:
                     yield YES
@@ skipping 61 matching lines @@
     elif klass.name.endswith('Exception'):
         klass._type = 'exception'
     else:
         if ancestors is None:
             ancestors = set()
         if klass in ancestors:
             # XXX we are in loop ancestors, and have found no type
             klass._type = 'class'
             return 'class'
         ancestors.add(klass)
-        # print >> sys.stderr, '_class_type', repr(klass)
         for base in klass.ancestors(recurs=False):
             name = _class_type(base, ancestors)
             if name != 'class':
                 if name == 'metaclass' and not _is_metaclass(klass):
                     # don't propagate it if the current class
                     # can't be a metaclass
                     continue
                 klass._type = base.type
                 break
     if klass._type is None:
@@ skipping 14 matching lines @@
 
     # a dictionary of class instances attributes
     _astroid_fields = ('decorators', 'bases', 'body') # name
 
     decorators = None
     special_attributes = set(('__name__', '__doc__', '__dict__', '__module__',
                               '__bases__', '__mro__', '__subclasses__'))
     blockstart_tolineno = None
 
     _type = None
+    _metaclass_hack = False
+    hide = False
     type = property(_class_type,
                     doc="class'type, possible values are 'class' | "
                     "'metaclass' | 'interface' | 'exception'")
 
     def __init__(self, name, doc):
         self.instance_attrs = {}
         self.locals = {}
         self.bases = []
         self.body = []
         self.name = name
@@ skipping 15 matching lines @@
             self._newstyle = klass._newstyle_impl(context)
         if self._newstyle is None:
             self._newstyle = False
         return self._newstyle
 
     _newstyle = None
     newstyle = property(_newstyle_impl,
                         doc="boolean indicating if it's a new style class"
                         "or not")
 
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        self.blockstart_tolineno = self.bases and self.bases[-1].tolineno or self.fromlineno
-        if lastchild is not None:
-            self.tolineno = lastchild.tolineno
-        # else this is a class with only a docstring, then tolineno is (should be) already ok
+    @cachedproperty
+    def blockstart_tolineno(self):
+        if self.bases:
+            return self.bases[-1].tolineno
+        else:
+            return self.fromlineno
 
     def block_range(self, lineno):
         """return block line numbers.
 
         start from the "class" position whatever the given lineno
         """
         return self.fromlineno, self.tolineno
 
     def pytype(self):
         if self.newstyle:
             return '%s.type' % BUILTINS
         return '%s.classobj' % BUILTINS
 
     def display_type(self):
         return 'Class'
 
     def callable(self):
         return True
 
-    def _is_subtype_of(self, type_name):
+    def is_subtype_of(self, type_name, context=None):
         if self.qname() == type_name:
             return True
-        for anc in self.ancestors():
+        for anc in self.ancestors(context=context):
             if anc.qname() == type_name:
                 return True
 
     def infer_call_result(self, caller, context=None):
         """infer what a class is returning when called"""
-        if self._is_subtype_of('%s.type' % (BUILTINS,)) and len(caller.args) == 3:
-            name_node = caller.args[0].infer().next()
-            if isinstance(name_node, Const) and isinstance(name_node.value, basestring):
+        if self.is_subtype_of('%s.type' % (BUILTINS,), context) and len(caller.args) == 3:
+            name_node = next(caller.args[0].infer(context))
+            if (isinstance(name_node, Const) and
+                    isinstance(name_node.value, six.string_types)):
                 name = name_node.value
             else:
                 yield YES
                 return
             result = Class(name, None)
-            bases = caller.args[1].infer().next()
+            bases = next(caller.args[1].infer(context))
             if isinstance(bases, (Tuple, List)):
                 result.bases = bases.itered()
             else:
                 # There is currently no AST node that can represent an 'unknown'
                 # node (YES is not an AST node), therefore we simply return YES here
                 # although we know at least the name of the class.
                 yield YES
                 return
             result.parent = caller.parent
             yield result
@@ skipping 18 matching lines @@
 
     def ancestors(self, recurs=True, context=None):
         """return an iterator on the node base classes in a prefixed
         depth first order
 
         :param recurs:
           boolean indicating if it should recurse or return direct
           ancestors only
         """
         # FIXME: should be possible to choose the resolution order
-        # XXX inference make infinite loops possible here (see BaseTransformer
-        # manipulation in the builder module for instance)
+        # FIXME: inference make infinite loops possible here
         yielded = set([self])
         if context is None:
             context = InferenceContext()
+        if sys.version_info[0] >= 3:
+            if not self.bases and self.qname() != 'builtins.object':
+                yield builtin_lookup("object")[1][0]
+                return
+
         for stmt in self.bases:
-            with context.restore_path():
-                try:
-                    for baseobj in stmt.infer(context):
-                        if not isinstance(baseobj, Class):
-                            if isinstance(baseobj, Instance):
-                                baseobj = baseobj._proxied
-                            else:
-                                # duh ?
-                                continue
+            try:
+                for baseobj in stmt.infer(context):
+                    if not isinstance(baseobj, Class):
+                        if isinstance(baseobj, Instance):
+                            baseobj = baseobj._proxied
+                        else:
+                            # duh ?
+                            continue
+                    if not baseobj.hide:
                         if baseobj in yielded:
                             continue # cf xxx above
                         yielded.add(baseobj)
                         yield baseobj
-                        if recurs:
-                            for grandpa in baseobj.ancestors(True, context):
-                                if grandpa in yielded:
-                                    continue # cf xxx above
-                                yielded.add(grandpa)
-                                yield grandpa
-                except InferenceError:
-                    # XXX log error ?
-                    continue
+                    if recurs:
+                        for grandpa in baseobj.ancestors(recurs=True,
+                                                         context=context):
+                            if grandpa in yielded:
+                                continue # cf xxx above
+                            yielded.add(grandpa)
+                            yield grandpa
+            except InferenceError:
+                # XXX log error ?
+                continue
 
     def local_attr_ancestors(self, name, context=None):
         """return an iterator on astroid representation of parent classes
         which have <name> defined in their locals
         """
         for astroid in self.ancestors(context=context):
             if name in astroid:
                 yield astroid
 
     def instance_attr_ancestors(self, name, context=None):
@@ skipping 74 matching lines @@
         if not values:
             raise NotFoundError(name)
         return values
 
     def igetattr(self, name, context=None):
         """inferred getattr, need special treatment in class to handle
         descriptors
         """
         # set lookup name since this is necessary to infer on import nodes for
         # instance
-        context = copy_context(context)
-        context.lookupname = name
+        if not context:
+            context = InferenceContext()
         try:
             for infered in _infer_stmts(self.getattr(name, context), context,
-                                        frame=self):
+                                        frame=self, lookupname=name):
                 # yield YES object instead of descriptors when necessary
                 if not isinstance(infered, Const) and isinstance(infered, Instance):
                     try:
                         infered._proxied.getattr('__get__', context)
                     except NotFoundError:
                         yield infered
                     else:
                         yield YES
                 else:
                     yield function_to_method(infered, self)
@@ skipping 70 matching lines @@
     def _explicit_metaclass(self):
         """ Return the explicit defined metaclass
         for the current class.
 
         An explicit defined metaclass is defined
         either by passing the ``metaclass`` keyword argument
         in the class definition line (Python 3) or (Python 2) by
         having a ``__metaclass__`` class attribute, or if there are
         no explicit bases but there is a global ``__metaclass__`` variable.
         """
+        for base in self.bases:
+            try:
+                for baseobj in base.infer():
+                    if isinstance(baseobj, Class) and baseobj.hide:
+                        self._metaclass = baseobj._metaclass
+                        self._metaclass_hack = True
+                        break
+            except InferenceError:
+                pass
+
         if self._metaclass:
             # Expects this from Py3k TreeRebuilder
             try:
                 return next(node for node in self._metaclass.infer()
                             if node is not YES)
             except (InferenceError, StopIteration):
                 return None
         if sys.version_info >= (3, ):
             return None
 
         if '__metaclass__' in self.locals:
             assignment = self.locals['__metaclass__'][-1]
         elif self.bases:
             return None
         elif '__metaclass__' in self.root().locals:
             assignments = [ass for ass in self.root().locals['__metaclass__']
                            if ass.lineno < self.lineno]
             if not assignments:
                 return None
             assignment = assignments[-1]
         else:
             return None
 
         try:
-            infered = assignment.infer().next()
+            infered = next(assignment.infer())
         except InferenceError:
             return
         if infered is YES: # don't expose this
             return None
         return infered
 
     def metaclass(self):
         """ Return the metaclass of this class.
 
         If this class does not define explicitly a metaclass,
         then the first defined metaclass in ancestors will be used
         instead.
         """
         klass = self._explicit_metaclass()
         if klass is None:
             for parent in self.ancestors():
                 klass = parent.metaclass()
                 if klass is not None:
                     break
         return klass
 
+    def has_metaclass_hack(self):
+        return self._metaclass_hack
+
     def _islots(self):
         """ Return an iterator with the inferred slots. """
         if '__slots__' not in self.locals:
             return
         for slots in self.igetattr('__slots__'):
             # check if __slots__ is a valid type
             for meth in ITER_METHODS:
                 try:
                     slots.getattr(meth)
                     break
@@ skipping 31 matching lines @@
                             continue
                         yield infered
                 except InferenceError:
                     continue
 
     # Cached, because inferring them all the time is expensive
     @cached
     def slots(self):
         """ Return all the slots for this node. """
         return list(self._islots())