Merge main into default

1 files changed, 56 insertions, 49 deletions

diff --git a/astroid/raw_building.py b/astroid/raw_building.py
index 42fc085..ce80b0e 100644
--- a/astroid/raw_building.py
+++ b/astroid/raw_building.py
@@ -19,26 +19,23 @@
 (build_* functions) or from living object (object_build_* functions)
 """
 
-__docformat__ = "restructuredtext en"
-
-import sys
+import inspect
 import logging
 import os
-from os.path import abspath
-from inspect import (getargspec, isdatadescriptor, isfunction, ismethod,
-                     ismethoddescriptor, isclass, isbuiltin, ismodule,
-                     isroutine)
+import sys
+import types
+
 import six
 
-from astroid.node_classes import CONST_CLS
-from astroid.nodes import (Module, ClassDef, Const, const_factory, ImportFrom,
-                           FunctionDef, EmptyNode, Name, Arguments)
-from astroid.bases import BUILTINS, Generator
-from astroid.manager import AstroidManager
+from astroid import bases
+from astroid import manager
+from astroid import node_classes
+from astroid import nodes
 
 
-MANAGER = AstroidManager()
-_CONSTANTS = tuple(CONST_CLS) # the keys of CONST_CLS eg python builtin types
+MANAGER = manager.AstroidManager()
+# the keys of CONST_CLS eg python builtin types
+_CONSTANTS = tuple(node_classes.CONST_CLS)
 _JYTHON = os.name == 'java'
 _BUILTINS = vars(six.moves.builtins)
 _LOG = logging.getLogger(__name__)
@@ -48,7 +45,7 @@ def _io_discrepancy(member):
     # _io module names itself `io`: http://bugs.python.org/issue18602
     member_self = getattr(member, '__self__', None)
     return (member_self and
-            ismodule(member_self) and
+            inspect.ismodule(member_self) and
             member_self.__name__ == '_io' and
             member.__module__ == 'io')
 
@@ -63,58 +60,63 @@ def attach_dummy_node(node, name, object=_marker):
     """create a dummy node and register it in the locals of the given
     node with the specified name
     """
-    enode = EmptyNode()
+    enode = nodes.EmptyNode()
     enode.object = object
     _attach_local_node(node, enode, name)
 
 def _has_underlying_object(self):
     return hasattr(self, 'object') and self.object is not _marker
 
-EmptyNode.has_underlying_object = _has_underlying_object
+nodes.EmptyNode.has_underlying_object = _has_underlying_object
 
 def attach_const_node(node, name, value):
     """create a Const node and register it in the locals of the given
     node with the specified name
     """
-    if not name in node.special_attributes:
-        _attach_local_node(node, const_factory(value), name)
+    if name not in node.special_attributes:
+        _attach_local_node(node, nodes.const_factory(value), name)
 
 def attach_import_node(node, modname, membername):
     """create a ImportFrom node and register it in the locals of the given
     node with the specified name
     """
-    from_node = ImportFrom(modname, [(membername, None)])
+    from_node = nodes.ImportFrom(modname, [(membername, None)])
     _attach_local_node(node, from_node, membername)
 
 
 def build_module(name, doc=None):
     """create and initialize a astroid Module node"""
-    return Module(name, doc, package=False, parent=None, pure_python=False)
+    node = nodes.Module(name, doc, pure_python=False)
+    node.package = False
+    node.parent = None
+    return node
+
 
 def build_class(name, basenames=(), doc=None):
     """create and initialize a astroid ClassDef node"""
     node = ClassDef(name, doc)
     for base in basenames:
-        basenode = Name()
+        basenode = nodes.Name()
         basenode.name = base
         node.bases.append(basenode)
         basenode.parent = node
     return node
 
+
 def build_function(name, args=None, defaults=None, flag=0, doc=None):
     """create and initialize a astroid FunctionDef node"""
     args, defaults = args or [], defaults or []
     # first argument is now a list of decorators
-    func = FunctionDef(name, doc)
-    func.args = argsnode = Arguments()
+    func = nodes.FunctionDef(name, doc)
+    func.args = argsnode = nodes.Arguments()
     argsnode.args = []
     for arg in args:
-        argsnode.args.append(Name())
+        argsnode.args.append(nodes.Name())
         argsnode.args[-1].name = arg
         argsnode.args[-1].parent = argsnode
     argsnode.defaults = []
     for default in defaults:
-        argsnode.defaults.append(const_factory(default))
+        argsnode.defaults.append(nodes.const_factory(default))
         argsnode.defaults[-1].parent = argsnode
     argsnode.kwarg = None
     argsnode.vararg = None
@@ -126,7 +128,7 @@ def build_function(name, args=None, defaults=None, flag=0, doc=None):
 
 def build_from_import(fromname, names):
     """create and initialize an astroid ImportFrom import statement"""
-    return ImportFrom(fromname, [(name, None) for name in names])
+    return nodes.ImportFrom(fromname, [(name, None) for name in names])
 
 def register_arguments(func, args=None):
     """add given arguments to local
@@ -141,32 +143,37 @@ def register_arguments(func, args=None):
         if func.args.kwarg:
             func.set_local(func.args.kwarg, func.args)
     for arg in args:
-        if isinstance(arg, Name):
+        if isinstance(arg, nodes.Name):
             func.set_local(arg.name, arg)
         else:
             register_arguments(func, arg.elts)
 
+
 def object_build_class(node, member, localname):
     """create astroid for a living class object"""
     basenames = [base.__name__ for base in member.__bases__]
     return _base_class_object_build(node, member, basenames,
                                     localname=localname)
 
+
 def object_build_function(node, member, localname):
     """create astroid for a living function object"""
-    args, varargs, varkw, defaults = getargspec(member)
+    args, varargs, varkw, defaults = inspect.getargspec(member)
     if varargs is not None:
         args.append(varargs)
     if varkw is not None:
         args.append(varkw)
     func = build_function(getattr(member, '__name__', None) or localname, args,
-                          defaults, six.get_function_code(member).co_flags, member.__doc__)
+                          defaults, six.get_function_code(member).co_flags,
+                          member.__doc__)
     node.add_local_node(func, localname)
 
+
 def object_build_datadescriptor(node, member, name):
     """create astroid for a living data descriptor object"""
     return _base_class_object_build(node, member, [], name)
 
+
 def object_build_methoddescriptor(node, member, localname):
     """create astroid for a living method descriptor object"""
     # FIXME get arguments ?
@@ -177,6 +184,7 @@ def object_build_methoddescriptor(node, member, localname):
     func.args.args = None
     node.add_local_node(func, localname)
 
+
 def _base_class_object_build(node, member, basenames, name=None, localname=None):
     """create astroid for a living class object, with a given set of base names
     (e.g. ancestors)
@@ -198,7 +206,7 @@ def _base_class_object_build(node, member, basenames, name=None, localname=None)
         pass
     else:
         for name, obj in instdict.items():
-            valnode = EmptyNode()
+            valnode = nodes.EmptyNode()
             valnode.object = obj
             valnode.parent = klass
             valnode.lineno = 1
@@ -250,7 +258,7 @@ class InspectBuilder(object):
         except AttributeError:
             # in jython, java modules have no __doc__ (see #109562)
             node = build_module(modname)
-        node.file = node.path = path and abspath(path) or path
+        node.file = node.path = path and os.path.abspath(path) or path
         node.name = modname
         MANAGER.cache_module(node)
         node.package = hasattr(module, '__path__')
@@ -272,21 +280,21 @@ class InspectBuilder(object):
                 # damned ExtensionClass.Base, I know you're there !
                 attach_dummy_node(node, name)
                 continue
-            if ismethod(member):
+            if inspect.ismethod(member):
                 member = six.get_method_function(member)
-            if isfunction(member):
+            if inspect.isfunction(member):
                 _build_from_function(node, name, member, self._module)
-            elif isbuiltin(member):
+            elif inspect.isbuiltin(member):
                 if (not _io_discrepancy(member) and
                         self.imported_member(node, member, name)):
                     continue
                 object_build_methoddescriptor(node, member, name)
-            elif isclass(member):
+            elif inspect.isclass(member):
                 if self.imported_member(node, member, name):
                     continue
                 if member in self._done:
                     class_node = self._done[member]
-                    if not class_node in node.locals.get(name, ()):
+                    if class_node not in node.locals.get(name, ()):
                         node.add_local_node(class_node, name)
                 else:
                     class_node = object_build_class(node, member, name)
@@ -294,15 +302,15 @@ class InspectBuilder(object):
                     self.object_build(class_node, member)
                 if name == '__class__' and class_node.parent is None:
                     class_node.parent = self._done[self._module]
-            elif ismethoddescriptor(member):
+            elif inspect.ismethoddescriptor(member):
                 assert isinstance(member, object)
                 object_build_methoddescriptor(node, member, name)
-            elif isdatadescriptor(member):
+            elif inspect.isdatadescriptor(member):
                 assert isinstance(member, object)
                 object_build_datadescriptor(node, member, name)
             elif isinstance(member, _CONSTANTS):
                 attach_const_node(node, name, member)
-            elif isroutine(member):
+            elif inspect.isroutine(member):
                 # This should be called for Jython, where some builtin
                 # methods aren't catched by isbuiltin branch.
                 _build_from_function(node, name, member, self._module)
@@ -327,7 +335,7 @@ class InspectBuilder(object):
                 # Python 2.5.1 (r251:54863, Sep  1 2010, 22:03:14)
                 # >>> print object.__new__.__module__
                 # None
-                modname = BUILTINS
+                modname = six.moves.builtins.__name__
             else:
                 attach_dummy_node(node, name, member)
                 return True
@@ -359,10 +367,10 @@ def _astroid_bootstrapping(astroid_builtin=None):
     # this boot strapping is necessary since we need the Const nodes to
     # inspect_build builtins, and then we can proxy Const
     if astroid_builtin is None:
-        from logilab.common.compat import builtins
+        from six.moves import builtins
         astroid_builtin = Astroid_BUILDER.inspect_build(builtins)
 
-    for cls, node_cls in CONST_CLS.items():
+    for cls, node_cls in node_classes.CONST_CLS.items():
         if cls is type(None):
             proxy = build_class('NoneType')
             proxy.parent = astroid_builtin
@@ -383,10 +391,9 @@ _astroid_bootstrapping()
 # infinite recursion (see https://bugs.launchpad.net/pylint/+bug/456870)
 def _set_proxied(const):
     return _CONST_PROXY[const.value.__class__]
-Const._proxied = property(_set_proxied)
+nodes.Const._proxied = property(_set_proxied)
 
-from types import GeneratorType
-_GeneratorType = ClassDef(GeneratorType.__name__, GeneratorType.__doc__)
-_GeneratorType.parent = MANAGER.astroid_cache[BUILTINS]
-Generator._proxied = _GeneratorType
-Astroid_BUILDER.object_build(Generator._proxied, GeneratorType)
+_GeneratorType = nodes.ClassDef(types.GeneratorType.__name__, types.GeneratorType.__doc__)
+_GeneratorType.parent = MANAGER.astroid_cache[six.moves.builtins.__name__]
+bases.Generator._proxied = _GeneratorType
+Astroid_BUILDER.object_build(bases.Generator._proxied, types.GeneratorType)