Merge remote-tracking branch 'upstream/master' into super_call

Lib/test/test_dis.py

@@ -809,6 +809,31 @@ def f(self): return super().x
    0: __class__"""
         self.assertEqual(dedent(dis.code_info(g["C"].f)), expected_dis_info)
 
+    def test_super_attr_load_self_cell(self):
+        src = """
+        class C:
+            def f(self):
+                lambda: self
+                return super().x
+        """
+        expected = """\
+  4           0 LOAD_CLOSURE             0 (self)
+              2 BUILD_TUPLE              1
+              4 LOAD_CONST               1 (<code object <lambda> at 0x..., file "<string>", line 4>)
+              6 LOAD_CONST               2 ('C.f.<locals>.<lambda>')
+              8 MAKE_FUNCTION            8 (closure)
+             10 POP_TOP
+
+  5          12 LOAD_GLOBAL              0 (super)
+             14 LOAD_DEREF               1 (__class__)
+             16 LOAD_DEREF               0 (self)
+             18 LOAD_ATTR_SUPER          3 ((1, True))
+             20 RETURN_VALUE
+"""
+        g = {}
+        exec(dedent(src), g)
+        self.do_disassembly_test(g["C"].f, expected)
+
     def test_super_attr_store(self):
         src = """
         class C:

Lib/test/test_gdb.py

@@ -928,12 +928,12 @@ def test_wrapper_call(self):
         cmd = textwrap.dedent('''
             class MyList(list):
                 def __init__(self):
-                    super().__init__()   # wrapper_call()
+                    super().__init__()   # wrapperdescr_call()
 
             id("first break point")
             l = MyList()
         ''')
-        cmds_after_breakpoint = ['break wrapper_call', 'continue']
+        cmds_after_breakpoint = ['break wrapperdescr_call', 'continue']
         if CET_PROTECTION:
             # bpo-32962: same case as in get_stack_trace():
             # we need an additional 'next' command in order to read
@@ -945,7 +945,7 @@ def __init__(self):
         gdb_output = self.get_stack_trace(cmd,
                                           cmds_after_breakpoint=cmds_after_breakpoint)
         self.assertRegex(gdb_output,
-                         r"<method-wrapper u?'__init__' of MyList object at ")
+                         r"methoddescr-wrapper '__init__'>, args=\(<MyList at ")
 
 
 class PyPrintTests(DebuggerTests):

Python/compile.c

@@ -4148,13 +4148,13 @@ is_super_call(struct compiler *c, expr_ty e)
         return 0;
     }
     // try to find "super" symbol being defined in file
-    int scope = PyST_GetScope(c->u->u_ste, super_name);
+    int scope = _PyST_GetScope(c->u->u_ste, super_name);
     // any scoping besides GLOBAL_IMPLICIT is not accepted
     if (scope != GLOBAL_IMPLICIT)  {
         return -1;
     }
     // ensure it is not defined in top level scope
-    scope = PyST_GetScope(c->c_st->st_top, super_name);
+    scope = _PyST_GetScope(c->c_st->st_top, super_name);
     if (scope != 0 && scope != GLOBAL_IMPLICIT) {
         return -1;
     }

Tools/gdb/libpython.py

@@ -358,7 +358,6 @@ def subclass_from_type(cls, t):
             # Handle any kind of error e.g. NULL ptrs by simply using the base
             # class
             return cls
-
         #print('tp_flags = 0x%08x' % tp_flags)
         #print('tp_name = %r' % tp_name)
 
@@ -370,6 +369,7 @@ def subclass_from_type(cls, t):
                     'frozenset' : PySetObjectPtr,
                     'builtin_function_or_method' : PyCFunctionObjectPtr,
                     'method-wrapper': wrapperobject,
+                    'wrapper_descriptor': wrapperdescrobject,
                     }
         if tp_name in name_map:
             return name_map[tp_name]
@@ -1401,6 +1401,24 @@ def write_repr(self, out, visited):
         proxy = self.proxyval(visited)
         out.write(proxy)
 
+class wrapperdescrobject(PyObjectPtr):
+    _typename = 'wrapperdescrobject'
+
+    def safe_name(self):
+        try:
+            name = self.field('d_base')['name'].string()
+            return repr(name)
+        except (NullPyObjectPtr, RuntimeError, UnicodeDecodeError):
+            return '<unknown name>'
+
+    def proxyval(self, visited):
+        name = self.safe_name()
+        return ("<methoddescr-wrapper %s>"
+                % (name,))
+
+    def write_repr(self, out, visited):
+        proxy = self.proxyval(visited)
+        out.write(proxy)
 
 def int_from_int(gdbval):
     return int(gdbval)
@@ -1439,7 +1457,7 @@ def pretty_printer_lookup(gdbval):
 
     type = type.target().unqualified()
     t = str(type)
-    if t in ("PyObject", "PyFrameObject", "PyUnicodeObject", "wrapperobject"):
+    if t in ("PyObject", "PyFrameObject", "PyUnicodeObject", "wrapperobject", "PyWrapperDescrObject"):
         return PyObjectPtrPrinter(gdbval)
 
 """
@@ -1573,7 +1591,6 @@ def is_other_python_frame(self):
         caller = frame.name()
         if not caller:
             return False
-
         if (caller.startswith('cfunction_vectorcall_') or
             caller == 'cfunction_call'):
             arg_name = 'func'
@@ -1603,6 +1620,17 @@ def is_other_python_frame(self):
             except RuntimeError:
                 return '<wrapper_call invocation (unable to read %s)>' % arg_name
 
+        if caller == 'wrapperdescr_call':
+            arg_name = 'descr'
+            try:
+                func = frame.read_var(arg_name)
+                return str(func)
+            except ValueError:
+                return ('<wrapperdescr_call invocation (unable to read %s: '
+                        'missing debuginfos?)>' % arg_name)
+            except RuntimeError:
+                return '<wrapperdescr_call invocation (unable to read %s)>' % arg_name
+
         # This frame isn't worth reporting:
         return False