Revert "pylint: upgrade to 1.3.1"

third_party/logilab/astng/scoped_nodes.py

-# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+# copyright 2003-2010 Sylvain Thenault, all rights reserved.
+# contact mailto:thenault@gmail.com
 #
-# This file is part of astroid.
+# This file is part of logilab-astng.
 #
-# astroid is free software: you can redistribute it and/or modify it
+# logilab-astng 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
+# logilab-astng 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/>.
+# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
 """This module contains the classes for "scoped" node, i.e. which are opening a
 new local scope in the language definition : Module, Class, Function (and
 Lambda, GenExpr, DictComp and SetComp to some extent).
 """
 from __future__ import with_statement
 
 __doctype__ = "restructuredtext en"
 
 import sys
 from itertools import chain
-try:
-    from io import BytesIO
-except ImportError:
-    from cStringIO import StringIO as BytesIO
 
 from logilab.common.compat import builtins
-from logilab.common.decorators import cached, cachedproperty
+from logilab.common.decorators import cached
 
-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,\
+from logilab.astng import BUILTINS_MODULE
+from logilab.astng.exceptions import NotFoundError, NoDefault, \
+     ASTNGBuildingException, InferenceError
+from logilab.astng.node_classes import Const, DelName, DelAttr, \
+     Dict, From, List, Name, Pass, Raise, Return, Tuple, Yield, \
+     are_exclusive, LookupMixIn, const_factory as cf, unpack_infer
+from logilab.astng.bases import NodeNG, InferenceContext, Instance,\
      YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, copy_context, \
-     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)
+     BUILTINS_NAME
+from logilab.astng.mixins import FilterStmtsMixin
+from logilab.astng.bases import Statement
+from logilab.astng.manager import ASTNGManager
 
 
 def remove_nodes(func, cls):
     def wrapper(*args, **kwargs):
         nodes = [n for n in func(*args, **kwargs) if not isinstance(n, cls)]
         if not nodes:
             raise NotFoundError()
         return nodes
     return wrapper
 
@@ skipping 12 matching lines @@
     else:
         locals = {}
     if name == '__name__':
         return [cf(self.name)] + locals.get(name, [])
     if name == '__doc__':
         return [cf(self.doc)] + locals.get(name, [])
     if name == '__dict__':
         return [Dict()] + locals.get(name, [])
     raise NotFoundError(name)
 
-MANAGER = AstroidManager()
+MANAGER = ASTNGManager()
 def builtin_lookup(name):
     """lookup a name into the builtin module
-    return the list of matching statements and the astroid for the builtin
+    return the list of matching statements and the astng for the builtin
     module
     """
-    builtin_astroid = MANAGER.ast_from_module(builtins)
+    builtin_astng = MANAGER.astng_from_module(builtins)
     if name == '__dict__':
-        return builtin_astroid, ()
+        return builtin_astng, ()
     try:
-        stmts = builtin_astroid.locals[name]
+        stmts = builtin_astng.locals[name]
     except KeyError:
         stmts = ()
-    return builtin_astroid, stmts
+    return builtin_astng, stmts
 
 
 # TODO move this Mixin to mixins.py; problem: 'Function' in _scope_lookup
 class LocalsDictNodeNG(LookupMixIn, NodeNG):
     """ this class provides locals handling common to Module, Function
     and Class nodes, including a dict like interface for direct access
     to locals information
     """
 
     # attributes below are set by the builder module or by raw factories
@@ skipping 101 matching lines @@
         return zip(self.keys(), self.values())
 
 
     def __contains__(self, name):
         return name in self.locals
     has_key = __contains__
 
 # Module  #####################################################################
 
 class Module(LocalsDictNodeNG):
-    _astroid_fields = ('body',)
+    _astng_fields = ('body',)
 
     fromlineno = 0
     lineno = 0
 
     # attributes below are set by the builder module or by raw factories
 
-    # the file from which as been extracted the astroid representation. It may
+    # the file from which as been extracted the astng representation. It may
     # be None if the representation has been built from a built-in module
     file = None
-    # Alternatively, if built from a string/bytes, this can be set
-    file_bytes = None
-    # encoding of python source file, so we can get unicode out of it (python2
-    # only)
-    file_encoding = None
     # the module name
     name = None
-    # boolean for astroid built from source (i.e. ast)
+    # boolean for astng built from source (i.e. ast)
     pure_python = None
     # boolean for package module
     package = None
     # dictionary of globals with name as key and node defining the global
     # as value
     globals = None
 
-    # Future imports
-    future_imports = None
-
     # names of python special attributes (handled by getattr impl.)
     special_attributes = set(('__name__', '__doc__', '__file__', '__path__',
                               '__dict__'))
     # names of module attributes available through the global scope
     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
     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 file(self.file)
         return None
 
     def block_range(self, lineno):
         """return block line numbers.
 
         start from the beginning whatever the given lineno
         """
         return self.fromlineno, self.tolineno
 
     def scope_lookup(self, node, name, offset=0):
         if name in self.scope_attrs and not name in self.locals:
             try:
                 return self, self.getattr(name)
             except NotFoundError:
                 return self, ()
         return self._scope_lookup(node, name, offset)
 
     def pytype(self):
-        return '%s.module' % BUILTINS
+        return '%s.module' % BUILTINS_MODULE
 
     def display_type(self):
         return 'Module'
 
     def getattr(self, name, context=None, ignore_locals=False):
         if name in self.special_attributes:
             if name == '__file__':
                 return [cf(self.file)] + self.locals.get(name, [])
             if name == '__path__' and self.package:
                 return [List()] + self.locals.get(name, [])
             return std_special_attributes(self, name)
         if not ignore_locals and name in self.locals:
             return self.locals[name]
         if self.package:
             try:
                 return [self.import_module(name, relative_only=True)]
-            except AstroidBuildingException:
-                raise NotFoundError(name)
-            except SyntaxError:
+            except ASTNGBuildingException:
                 raise NotFoundError(name)
             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
@@ skipping 33 matching lines @@
             return False
     else:
         absolute_import_activated = lambda self: True
 
     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:
+            return MANAGER.astng_from_module_name(absmodname)
+        except ASTNGBuildingException:
             # we only want to import a sub module or package of this module,
             # skip here
             if relative_only:
                 raise
-        return MANAGER.ast_from_module_name(modname)
+        return MANAGER.astng_from_module_name(modname)
 
     def relative_to_absolute_name(self, modname, level):
         """return the absolute module name for a relative import.
 
         The relative import can be implicit or explicit.
         """
         # XXX this returns non sens when called on an absolute import
-        # like 'pylint.checkers.astroid.utils'
+        # like 'pylint.checkers.logilab.astng.utils'
         # XXX doesn't return absolute name if self.name isn't absolute name
         if self.absolute_import_activated() and level is None:
             return modname
         if level:
             if self.package:
                 level = level - 1
             package_name = self.name.rsplit('.', level)[0]
         elif self.package:
             package_name = self.name
         else:
@@ skipping 16 matching lines @@
         try:
             living = sys.modules[self.name]
         except KeyError:
             pass
         else:
             try:
                 return living.__all__
             except AttributeError:
                 return [name for name in living.__dict__.keys()
                         if not name.startswith('_')]
-        # else lookup the astroid
+        # else lookup the astng
         #
         # We separate the different steps of lookup in try/excepts
         # to avoid catching too many Exceptions
         # However, we can not analyse dynamically constructed __all__
         try:
             all = self['__all__']
         except KeyError:
             return [name for name in self.keys() if not name.startswith('_')]
         try:
             explicit = all.assigned_stmts().next()
@@ skipping 11 matching lines @@
 
 
 class ComprehensionScope(LocalsDictNodeNG):
     def frame(self):
         return self.parent.frame()
 
     scope_lookup = LocalsDictNodeNG._scope_lookup
 
 
 class GenExpr(ComprehensionScope):
-    _astroid_fields = ('elt', 'generators')
+    _astng_fields = ('elt', 'generators')
 
     def __init__(self):
         self.locals = {}
         self.elt = None
         self.generators = []
 
 
 class DictComp(ComprehensionScope):
-    _astroid_fields = ('key', 'value', 'generators')
+    _astng_fields = ('key', 'value', 'generators')
 
     def __init__(self):
         self.locals = {}
         self.key = None
         self.value = None
         self.generators = []
 
 
 class SetComp(ComprehensionScope):
-    _astroid_fields = ('elt', 'generators')
+    _astng_fields = ('elt', 'generators')
 
     def __init__(self):
         self.locals = {}
         self.elt = None
         self.generators = []
 
 
 class _ListComp(NodeNG):
     """class representing a ListComp node"""
-    _astroid_fields = ('elt', 'generators')
+    _astng_fields = ('elt', 'generators')
     elt = None
     generators = None
 
 if sys.version_info >= (3, 0):
     class ListComp(_ListComp, ComprehensionScope):
         """class representing a ListComp node"""
         def __init__(self):
             self.locals = {}
 else:
     class ListComp(_ListComp):
         """class representing a ListComp node"""
 
 # 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()
-            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()
-            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):
-                        return 'classmethod'
-                    elif (result.name == 'staticmethod' and
-                          result.root().name == BUILTINS):
-                        return 'staticmethod'
-                    else:
-                        return
-                else:
-                    # We aren't interested in anything else returned,
-                    # so go back to the function type inference.
-                    return
-        else:
-            return
-
-def _function_type(self):
-    """
-    Function type, possible values are:
-    method, function, staticmethod, classmethod.
-    """
-    # Can't infer that this node is decorated
-    # with a subclass of `classmethod` where `type` is first set,
-    # so do it here.
-    if self.decorators:
-        for node in self.decorators.nodes:
-            if isinstance(node, CallFunc):
-                _type = _infer_decorator_callchain(node)
-                if _type is None:
-                    continue
-                else:
-                    return _type
-            if not isinstance(node, Name):
-                continue
-            try:
-                for infered in node.infer():
-                    if not isinstance(infered, Class):
-                        continue
-                    for ancestor in infered.ancestors():
-                        if isinstance(ancestor, Class):
-                            if (ancestor.name == 'classmethod' and
-                                    ancestor.root().name == BUILTINS):
-                                return 'classmethod'
-                            elif (ancestor.name == 'staticmethod' and
-                                  ancestor.root().name == BUILTINS):
-                                return 'staticmethod'
-            except InferenceError:
-                pass
-    return self._type
-
 
 class Lambda(LocalsDictNodeNG, FilterStmtsMixin):
-    _astroid_fields = ('args', 'body',)
+    _astng_fields = ('args', 'body',)
     name = '<lambda>'
 
     # function's type, 'function' | 'method' | 'staticmethod' | 'classmethod'
     type = 'function'
 
     def __init__(self):
         self.locals = {}
         self.args = []
         self.body = []
 
     def pytype(self):
         if 'method' in self.type:
-            return '%s.instancemethod' % BUILTINS
-        return '%s.function' % BUILTINS
+            return '%s.instancemethod' % BUILTINS_MODULE
+        return '%s.function' % BUILTINS_MODULE
 
     def display_type(self):
         if 'method' in self.type:
             return 'Method'
         return 'Function'
 
     def callable(self):
         return True
 
     def argnames(self):
         """return a list of argument names"""
         if self.args.args: # maybe None with builtin functions
             names = _rec_get_names(self.args.args)
         else:
             names = []
         if self.args.vararg:
             names.append(self.args.vararg)
         if self.args.kwarg:
             names.append(self.args.kwarg)
         return names
 
     def infer_call_result(self, caller, context=None):
         """infer what a function is returning when called"""
         return self.body.infer(context)
 
     def scope_lookup(self, node, name, offset=0):
-        if node in self.args.defaults or node in self.args.kw_defaults:
+        if node in self.args.defaults:
             frame = self.parent.frame()
             # line offset to avoid that def func(f=func) resolve the default
             # value to the defined function
             offset = -1
         else:
             # check this is not used in function decorators
             frame = self
         return frame._scope_lookup(node, name, offset)
 
 
 class Function(Statement, Lambda):
-    if PY3K:
-        _astroid_fields = ('decorators', 'args', 'body', 'returns')
-        returns = None
-    else:
-        _astroid_fields = ('decorators', 'args', 'body')
+    _astng_fields = ('decorators', 'args', 'body')
 
     special_attributes = set(('__name__', '__doc__', '__dict__'))
     is_function = True
     # 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
         if self.decorators is not None:
-            self.fromlineno += sum(node.tolineno - node.lineno + 1
-                                   for node in self.decorators.nodes)
-        if self.args.fromlineno < self.fromlineno:
-            self.args.fromlineno = self.fromlineno
+            self.fromlineno += len(self.decorators.nodes)
         self.tolineno = lastchild.tolineno
         self.blockstart_tolineno = 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
 
@@ skipping 24 matching lines @@
             for infnode in decnode.infer():
                 result.add(infnode.qname())
         return result
     decoratornames = cached(decoratornames)
 
     def is_bound(self):
         """return true if the function is bound to an Instance or a class"""
         return self.type == 'classmethod'
 
     def is_abstract(self, pass_is_abstract=True):
-        """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
+        """return true if the method is abstract
+        It's considered as abstract if the only statement is a raise of
+        NotImplementError, or, if pass_is_abstract, a pass statement
         """
-        if self.decorators:
-            for node in self.decorators.nodes:
-                try:
-                    infered = node.infer().next()
-                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()
+            return self.nodes_of_class(Yield, skip_klass=Function).next()
         except StopIteration:
             return False
 
     def infer_call_result(self, caller, context=None):
         """infer what a function is returning when called"""
         if self.is_generator():
-            yield Generator()
+            yield Generator(self)
             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
 
 
 def _rec_get_names(args, names=None):
     """return a list of all argument names"""
     if names is None:
         names = []
     for arg in args:
         if isinstance(arg, Tuple):
             _rec_get_names(arg.elts, names)
         else:
             names.append(arg.name)
     return names
 
 
 # Class ######################################################################
 
-
-def _is_metaclass(klass, seen=None):
-    """ Return if the given class can be
-    used as a metaclass.
-    """
-    if klass.name == 'type':
-        return True
-    if seen is None:
-        seen = set()
-    for base in klass.bases:
-        try:
-            for baseobj in base.infer():
-                if baseobj in seen:
-                    continue
-                else:
-                    seen.add(baseobj)
-                if isinstance(baseobj, Instance):
-                    # not abstract
-                    return False
-                if baseobj is YES:
-                    continue
-                if baseobj is klass:
-                    continue
-                if not isinstance(baseobj, Class):
-                    continue
-                if baseobj._type == 'metaclass':
-                    return True
-                if _is_metaclass(baseobj, seen):
-                    return True
-        except InferenceError:
-            continue
-    return False
-
-
 def _class_type(klass, ancestors=None):
     """return a Class node type to differ metaclass, interface and exception
     from 'regular' classes
     """
     # XXX we have to store ancestors in case we have a ancestor loop
     if klass._type is not None:
         return klass._type
-    if _is_metaclass(klass):
+    if klass.name == 'type':
         klass._type = 'metaclass'
     elif klass.name.endswith('Interface'):
         klass._type = 'interface'
     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
+            if _class_type(base, ancestors) != 'class':
                 klass._type = base.type
                 break
     if klass._type is None:
         klass._type = 'class'
     return klass._type
 
 def _iface_hdlr(iface_node):
     """a handler function used by interfaces to handle suspicious
     interface nodes
     """
     return True
 
 
 class Class(Statement, LocalsDictNodeNG, FilterStmtsMixin):
 
     # some of the attributes below are set by the builder module or
     # by a raw factories
 
     # a dictionary of class instances attributes
-    _astroid_fields = ('decorators', 'bases', 'body') # name
+    _astng_fields = ('decorators', 'bases', 'body') # name
 
     decorators = None
     special_attributes = set(('__name__', '__doc__', '__dict__', '__module__',
                               '__bases__', '__mro__', '__subclasses__'))
     blockstart_tolineno = None
 
     _type = None
     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
         self.doc = doc
 
     def _newstyle_impl(self, context=None):
         if context is None:
             context = InferenceContext()
         if self._newstyle is not None:
             return self._newstyle
         for base in self.ancestors(recurs=False, context=context):
             if base._newstyle_impl(context):
                 self._newstyle = True
                 break
-        klass = self._explicit_metaclass()
-        # could be any callable, we'd need to infer the result of klass(name,
-        # bases, dict).  punt if it's not a class node.
-        if klass is not None and isinstance(klass, Class):
-            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
 
     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
+            return '%s.type' % BUILTINS_MODULE
+        return '%s.classobj' % BUILTINS_MODULE
 
     def display_type(self):
         return 'Class'
 
     def callable(self):
         return True
 
-    def _is_subtype_of(self, type_name):
-        if self.qname() == type_name:
-            return True
-        for anc in self.ancestors():
-            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):
-                name = name_node.value
-            else:
-                yield YES
-                return
-            result = Class(name, None)
-            bases = caller.args[1].infer().next()
-            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
-        else:
-            yield Instance(self)
+        yield Instance(self)
 
     def scope_lookup(self, node, name, offset=0):
         if node in self.bases:
             frame = self.parent.frame()
             # line offset to avoid that class A(A) resolve the ancestor to
             # the defined class
             offset = -1
         else:
             frame = self
         return frame._scope_lookup(node, name, offset)
@@ skipping 16 matching lines @@
         # XXX inference make infinite loops possible here (see BaseTransformer
         # manipulation in the builder module for instance)
         yielded = set([self])
         if context is None:
             context = InferenceContext()
         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
+                            # duh ?
+                            continue
                         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
 
     def local_attr_ancestors(self, name, context=None):
-        """return an iterator on astroid representation of parent classes
+        """return an iterator on astng representation of parent classes
         which have <name> defined in their locals
         """
-        for astroid in self.ancestors(context=context):
-            if name in astroid:
-                yield astroid
+        for astng in self.ancestors(context=context):
+            if name in astng:
+                yield astng
 
     def instance_attr_ancestors(self, name, context=None):
-        """return an iterator on astroid representation of parent classes
+        """return an iterator on astng representation of parent classes
         which have <name> defined in their instance attribute dictionary
         """
-        for astroid in self.ancestors(context=context):
-            if name in astroid.instance_attrs:
-                yield astroid
+        for astng in self.ancestors(context=context):
+            if name in astng.instance_attrs:
+                yield astng
 
     def has_base(self, node):
         return node in self.bases
 
     def local_attr(self, name, context=None):
         """return the list of assign node associated to name in this class
         locals or in its parents
 
         :raises `NotFoundError`:
           if no attribute with this name has been find in this class or
           its parent classes
         """
         try:
             return self.locals[name]
         except KeyError:
             # get if from the first parent implementing it if any
             for class_node in self.local_attr_ancestors(name, context):
                 return class_node.locals[name]
         raise NotFoundError(name)
     local_attr = remove_nodes(local_attr, DelAttr)
 
     def instance_attr(self, name, context=None):
-        """return the astroid nodes associated to name in this class instance
+        """return the astng nodes associated to name in this class instance
         attributes dictionary and in its parents
 
         :raises `NotFoundError`:
           if no attribute with this name has been find in this class or
           its parent classes
         """
-        # Return a copy, so we don't modify self.instance_attrs,
-        # which could lead to infinite loop.
-        values = list(self.instance_attrs.get(name, []))
+        values = self.instance_attrs.get(name, [])
         # get all values from parents
         for class_node in self.instance_attr_ancestors(name, context):
             values += class_node.instance_attrs[name]
         if not values:
             raise NotFoundError(name)
         return values
     instance_attr = remove_nodes(instance_attr, DelAttr)
 
     def instanciate_class(self):
         """return Instance of Class node, else return self"""
         return Instance(self)
 
     def getattr(self, name, context=None):
         """this method doesn't look in the instance_attrs dictionary since it's
         done by an Instance proxy at inference time.
 
         It may return a YES object if the attribute has not been actually
         found but a __getattr__ or __getattribute__ method is defined
         """
         values = self.locals.get(name, [])
         if name in self.special_attributes:
             if name == '__module__':
                 return [cf(self.root().qname())] + values
-            # FIXME: do we really need the actual list of ancestors?
-            # returning [Tuple()] + values don't break any test
+            # FIXME : what is expected by passing the list of ancestors to cf:
+            # you can just do [cf(tuple())] + values without breaking any test
             # this is ticket http://www.logilab.org/ticket/52785
+            if name == '__bases__':
+                return [cf(tuple(self.ancestors(recurs=False, context=context)))] + values
             # XXX need proper meta class handling + MRO implementation
-            if name == '__bases__' or (name == '__mro__' and self.newstyle):
-                node = Tuple()
-                node.items = self.ancestors(recurs=True, context=context)
-                return [node] + values
+            if name == '__mro__' and self.newstyle:
+                # XXX mro is read-only but that's not our job to detect that
+                return [cf(tuple(self.ancestors(recurs=True, context=context)))] + values
             return std_special_attributes(self, name)
         # don't modify the list in self.locals!
         values = list(values)
         for classnode in self.ancestors(recurs=True, context=context):
             values += classnode.locals.get(name, [])
         if not values:
             raise NotFoundError(name)
         return values
 
     def igetattr(self, name, context=None):
@@ skipping 31 matching lines @@
         # need to explicitly handle optparse.Values (setattr is not detected)
         if self.name == 'Values' and self.root().name == 'optparse':
             return True
         try:
             self.getattr('__getattr__', context)
             return True
         except NotFoundError:
             #if self.newstyle: XXX cause an infinite recursion error
             try:
                 getattribute = self.getattr('__getattribute__', context)[0]
-                if getattribute.root().name != BUILTINS:
+                if getattribute.root().name != BUILTINS_NAME:
                     # class has a custom __getattribute__ defined
                     return True
             except NotFoundError:
                 pass
         return False
 
     def methods(self):
         """return an iterator on all methods defined in the class and
         its ancestors
         """
         done = {}
-        for astroid in chain(iter((self,)), self.ancestors()):
-            for meth in astroid.mymethods():
+        for astng in chain(iter((self,)), self.ancestors()):
+            for meth in astng.mymethods():
                 if meth.name in done:
                     continue
                 done[meth.name] = None
                 yield meth
 
     def mymethods(self):
         """return an iterator on all methods defined in the class"""
         for member in self.values():
             if isinstance(member, Function):
                 yield member
@@ skipping 13 matching lines @@
         missing = False
         for iface in unpack_infer(implements):
             if iface is YES:
                 missing = True
                 continue
             if not iface in found and handler_func(iface):
                 found.add(iface)
                 yield iface
         if missing:
             raise InferenceError()
-
-    _metaclass = None
-    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.
-        """
-        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()
-        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 _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
-                except NotFoundError:
-                    continue
-            else:
-                continue
-
-            if isinstance(slots, Const):
-                # a string. Ignore the following checks,
-                # but yield the node, only if it has a value
-                if slots.value:
-                    yield slots
-                continue
-            if not hasattr(slots, 'itered'):
-                # we can't obtain the values, maybe a .deque?
-                continue
-
-            if isinstance(slots, Dict):
-                values = [item[0] for item in slots.items]
-            else:
-                values = slots.itered()
-            if values is YES:
-                continue
-
-            for elt in values:
-                try:
-                    for infered in elt.infer():
-                        if infered is YES:
-                            continue
-                        if (not isinstance(infered, Const) or
-                                not isinstance(infered.value, str)):
-                            continue
-                        if not infered.value:
-                            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())