distinguish between local name on object class name, add a fallback to local name in case member.__name__ is unset, as reported by Derek Harland on python-project (june 2009)

Author: Sylvain Thénault

builder.py

@@ -173,13 +173,13 @@ def object_build(self, node, obj):
                 if member.func_code.co_filename != getattr(self._module, '__file__', None):
                     attach_dummy_node(node, name, member)
                     continue
-                object_build_function(node, member)
+                object_build_function(node, member, name)
             elif isbuiltin(member):
                 # verify this is not an imported member
                 if self._member_module(member) != self._module.__name__:
                     imported_member(node, member, name)
                     continue
-                object_build_methoddescriptor(node, member)
+                object_build_methoddescriptor(node, member, name)
             elif isclass(member):
                 # verify this is not an imported class
                 if self._member_module(member) != self._module.__name__:
@@ -190,12 +190,12 @@ def object_build(self, node, obj):
                     if not class_node in node.locals.get(name, ()):
                         node.add_local_node(class_node, name)
                 else:
-                    class_node = object_build_class(node, member)
+                    class_node = object_build_class(node, member, name)
                     # recursion
                     self.object_build(class_node, member)
             elif ismethoddescriptor(member):
                 assert isinstance(member, object)
-                object_build_methoddescriptor(node, member)
+                object_build_methoddescriptor(node, member, name)
             elif isdatadescriptor(member):
                 assert isinstance(member, object)
                 object_build_datadescriptor(node, member, name)

raw_building.py

@@ -124,42 +124,44 @@ def register_arguments(func, args=None):
             register_arguments(func, arg.elts)
 
 
-def object_build_class(node, member):
+def object_build_class(node, member, localname):
     """create astng for a living class object"""
     basenames = [base.__name__ for base in member.__bases__]
-    return _base_class_object_build(node, member, basenames)
+    return _base_class_object_build(node, member, basenames,
+                                    localname=localname)
 
-def object_build_function(node, member):
+def object_build_function(node, member, localname):
     """create astng for a living function object"""
     args, varargs, varkw, defaults = getargspec(member)
     if varargs is not None:
         args.append(varargs)
     if varkw is not None:
         args.append(varkw)
-    func = build_function(member.__name__, args, defaults,
+    func = build_function(member.__name__ or localname, args, defaults,
                           member.func_code.co_flags, member.__doc__)
-    node.add_local_node(func)
+    node.add_local_node(func, localname)
 
 def object_build_datadescriptor(node, member, name):
     """create astng for a living data descriptor object"""
     return _base_class_object_build(node, member, [], name)
 
-def object_build_methoddescriptor(node, member):
+def object_build_methoddescriptor(node, member, localname):
     """create astng for a living method descriptor object"""
     # FIXME get arguments ?
-    func = build_function(member.__name__, doc=member.__doc__)
+    func = build_function(member.__name__ or localname, 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)
+    node.add_local_node(func, localname)
 
-def _base_class_object_build(node, member, basenames, name=None):
+def _base_class_object_build(node, member, basenames, name=None, localname=None):
     """create astng for a living class object, with a given set of base names
     (e.g. ancestors)
     """
-    klass = build_class(name or member.__name__, basenames, member.__doc__)
+    klass = build_class(name or member.__name__ or localname, basenames,
+                        member.__doc__)
     klass._newstyle = isinstance(member, type)
-    node.add_local_node(klass)
+    node.add_local_node(klass, localname)
     try:
         # limit the instantiation trick since it's too dangerous
         # (such as infinite test execution...)