Pass a parent in raw_building when building a new Function or Class

astroid/raw_building.py

@@ -54,14 +54,16 @@ def _attach_local_node(parent, node, name):
     parent.add_local_node(node)
 
 
-def _add_dunder_class(func, member):
+def _add_dunder_class(func, member, parent=None):
     """Add a __class__ member to the given func node, if we can determine it."""
     python_cls = member.__class__
     cls_name = getattr(python_cls, "__name__", None)
     if not cls_name:
         return
     cls_bases = [ancestor.__name__ for ancestor in python_cls.__bases__]
-    ast_klass = build_class(cls_name, cls_bases, python_cls.__doc__)
+    ast_klass = build_class(
+        name=cls_name, basenames=cls_bases, doc=python_cls.__doc__, parent=parent
+    )
     func.instance_attrs["__class__"] = [ast_klass]
 
 
@@ -108,9 +110,9 @@ def build_module(name, doc=None):
     return node
 
 
-def build_class(name, basenames=(), doc=None):
+def build_class(name, basenames=(), parent=None, doc=None):
     """create and initialize an astroid ClassDef node"""
-    node = nodes.ClassDef(name, doc)
+    node = nodes.ClassDef(name=name, doc=doc, parent=parent)
     for base in basenames:
         basenode = nodes.Name()
         basenode.name = base
@@ -119,12 +121,12 @@ def build_class(name, basenames=(), doc=None):
     return node
 
 
-def build_function(name, args=None, defaults=None, doc=None):
+def build_function(name, parent=None, args=None, defaults=None, doc=None):
     """create and initialize an astroid FunctionDef node"""
     args, defaults = args or [], defaults or []
     # first argument is now a list of decorators
-    func = nodes.FunctionDef(name, doc)
-    func.args = argsnode = nodes.Arguments()
+    func = nodes.FunctionDef(name, doc, parent=parent)
+    func.args = argsnode = nodes.Arguments(parent=func)
     argsnode.args = []
     for arg in args:
         argsnode.args.append(nodes.Name())
@@ -134,9 +136,6 @@ def build_function(name, args=None, defaults=None, doc=None):
     for default in defaults:
         argsnode.defaults.append(nodes.const_factory(default))
         argsnode.defaults[-1].parent = argsnode
-    argsnode.kwarg = None
-    argsnode.vararg = None
-    argsnode.parent = func
     if args:
         register_arguments(func)
     return func
@@ -181,7 +180,11 @@ def object_build_function(node, member, localname):
     if varkw is not None:
         args.append(varkw)
     func = build_function(
-        getattr(member, "__name__", None) or localname, args, defaults, member.__doc__
+        name=getattr(member, "__name__", None) or localname,
+        parent=node,
+        args=args,
+        defaults=defaults,
+        doc=member.__doc__,
     )
     node.add_local_node(func, localname)
 
@@ -195,23 +198,26 @@ def object_build_methoddescriptor(node, member, localname):
     """create astroid for a living method descriptor object"""
     # FIXME get arguments ?
     func = build_function(
-        getattr(member, "__name__", None) or localname, doc=member.__doc__
+        name=getattr(member, "__name__", None) or localname,
+        parent=node,
+        doc=member.__doc__,
     )
     # set node's arguments to None to notice that we have no information, not
     # and empty argument list
     func.args.args = None
     node.add_local_node(func, localname)
-    _add_dunder_class(func, member)
+    _add_dunder_class(func, member, parent=node)
 
 
 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)
     """
     klass = build_class(
-        name or getattr(member, "__name__", None) or localname,
-        basenames,
-        member.__doc__,
+        name=name or getattr(member, "__name__", None) or localname,
+        basenames=basenames,
+        doc=member.__doc__,
+        parent=node,
     )
     klass._newstyle = isinstance(member, type)
     node.add_local_node(klass, localname)
@@ -395,11 +401,9 @@ def _astroid_bootstrapping(astroid_builtin=None):
     # pylint: disable=redefined-outer-name
     for cls, node_cls in node_classes.CONST_CLS.items():
         if cls is type(None):
-            proxy = build_class("NoneType")
-            proxy.parent = astroid_builtin
+            proxy = build_class("NoneType", parent=astroid_builtin)
         elif cls is type(NotImplemented):
-            proxy = build_class("NotImplementedType")
-            proxy.parent = astroid_builtin
+            proxy = build_class("NotImplementedType", parent=astroid_builtin)
         else:
             proxy = astroid_builtin.getattr(cls.__name__)[0]
         if cls in (dict, list, set, tuple):
@@ -418,18 +422,20 @@ def _set_proxied(const):
 nodes.Const._proxied = property(_set_proxied)
 
 _GeneratorType = nodes.ClassDef(
-    types.GeneratorType.__name__, types.GeneratorType.__doc__
+    name=types.GeneratorType.__name__,
+    doc=types.GeneratorType.__doc__,
+    parent=MANAGER.astroid_cache[builtins.__name__],
 )
-_GeneratorType.parent = MANAGER.astroid_cache[builtins.__name__]
 bases.Generator._proxied = _GeneratorType
 Astroid_BUILDER.object_build(bases.Generator._proxied, types.GeneratorType)
 
 if hasattr(types, "AsyncGeneratorType"):
     # pylint: disable=no-member; AsyncGeneratorType
     _AsyncGeneratorType = nodes.ClassDef(
-        types.AsyncGeneratorType.__name__, types.AsyncGeneratorType.__doc__
+        name=types.AsyncGeneratorType.__name__,
+        doc=types.AsyncGeneratorType.__doc__,
+        parent=MANAGER.astroid_cache[builtins.__name__],
     )
-    _AsyncGeneratorType.parent = MANAGER.astroid_cache[builtins.__name__]
     bases.AsyncGenerator._proxied = _AsyncGeneratorType
     Astroid_BUILDER.object_build(
         bases.AsyncGenerator._proxied, types.AsyncGeneratorType
@@ -452,7 +458,10 @@ def _set_proxied(const):
 )
 for _type in BUILTIN_TYPES:
     if _type.__name__ not in _builtins:
-        cls = nodes.ClassDef(_type.__name__, _type.__doc__)
-        cls.parent = MANAGER.astroid_cache[builtins.__name__]
+        cls = nodes.ClassDef(
+            name=_type.__name__,
+            doc=_type.__doc__,
+            parent=MANAGER.astroid_cache[builtins.__name__],
+        )
         Astroid_BUILDER.object_build(cls, _type)
         _builtins[_type.__name__] = cls

astroid/scoped_nodes.py

@@ -1639,9 +1639,8 @@ def infer_call_result(self, caller=None, context=None):
             metaclass = next(caller.args[0].infer(context))
             if isinstance(metaclass, ClassDef):
                 class_bases = [next(arg.infer(context)) for arg in caller.args[1:]]
-                new_class = ClassDef(name="temporary_class")
+                new_class = ClassDef(name="temporary_class", parent=self)
                 new_class.hide = True
-                new_class.parent = self
                 new_class.postinit(
                     bases=[base for base in class_bases if base != util.Uninferable],
                     body=[],