Address review

Author: sobolevn

Lib/test/test_ast/test_ast.py

@@ -222,24 +222,126 @@ def test_negative_locations_for_compile(self):
 
     def test_docstring_optimization_single_node(self):
         # https://github.com/python/cpython/issues/137308
+        class_example1 = textwrap.dedent('''
+            class A:
+                """Docstring"""
+        ''')
+        class_example2 = textwrap.dedent('''
+            class A:
+                """
+                Docstring"""
+        ''')
+        def_example1 = textwrap.dedent('''
+            def some():
+                """Docstring"""
+        ''')
+        def_example2 = textwrap.dedent('''
+            def some():
+                """Docstring
+                                       """
+        ''')
+        async_def_example1 = textwrap.dedent('''
+            async def some():
+                """Docstring"""
+        ''')
+        async_def_example2 = textwrap.dedent('''
+            async def some():
+                """
+                Docstring
+            """
+        ''')
         for code in [
-            'class A: """Docstring"""',
-            'def func(): """Docstring"""',
-            'async def func(): """Docstring"""',
+            class_example1,
+            class_example2,
+            def_example1,
+            def_example2,
+            async_def_example1,
+            async_def_example2,
         ]:
             for opt_level in [0, 1, 2]:
                 with self.subTest(code=code, opt_level=opt_level):
                     mod = ast.parse(code, optimize=opt_level)
                     self.assertEqual(len(mod.body[0].body), 1)
                     if opt_level == 2:
-                        self.assertIsInstance(mod.body[0].body[0], ast.Pass)
+                        pass_stmt = mod.body[0].body[0]
+                        self.assertIsInstance(pass_stmt, ast.Pass)
+                        self.assertEqual(
+                            vars(pass_stmt),
+                            {
+                                'lineno': 3,
+                                'col_offset': 4,
+                                'end_lineno': 3,
+                                'end_col_offset': 8,
+                            },
+                        )
+                    else:
+                        self.assertIsInstance(mod.body[0].body[0], ast.Expr)
+                        self.assertIsInstance(
+                            mod.body[0].body[0].value,
+                            ast.Constant,
+                        )
+
+                    compile(code, "a", "exec")
+                    compile(code, "a", "exec", optimize=opt_level)
+                    compile(mod, "a", "exec")
+                    compile(mod, "a", "exec", optimize=opt_level)
+
+    def test_docstring_optimization_multiple_nodes(self):
+        # https://github.com/python/cpython/issues/137308
+        class_example = textwrap.dedent(
+            """
+            class A:
+                '''
+                Docstring
+                '''
+                x = 1
+            """
+        )
+
+        def_example = textwrap.dedent(
+            """
+            def some():
+                '''
+                Docstring
+
+            '''
+                x = 1
+            """
+        )
+
+        async_def_example = textwrap.dedent(
+            """
+            async def some():
+
+                '''Docstring
+
+            '''
+                x = 1
+            """
+        )
+
+        for code in [
+            class_example,
+            def_example,
+            async_def_example,
+        ]:
+            for opt_level in [0, 1, 2]:
+                with self.subTest(code=code, opt_level=opt_level):
+                    mod = ast.parse(code, optimize=opt_level)
+                    if opt_level == 2:
+                        self.assertNotIsInstance(
+                            mod.body[0].body[0],
+                            (ast.Pass, ast.Expr),
+                        )
                     else:
                         self.assertIsInstance(mod.body[0].body[0], ast.Expr)
                         self.assertIsInstance(
                             mod.body[0].body[0].value,
                             ast.Constant,
                         )
 
+                    compile(code, "a", "exec")
+                    compile(code, "a", "exec", optimize=opt_level)
                     compile(mod, "a", "exec")
                     compile(mod, "a", "exec", optimize=opt_level)
 

Misc/NEWS.d/next/Core_and_Builtins/2025-08-02-10-27-53.gh-issue-137308.at05p_.rst

@@ -1,3 +1,3 @@
-Replace a single docstring in a node body to a :keyword:`pass`, so node's
-body is never empty. There was a :exc:`ValueError` in :func:`compile`
-otherwise.
+A standalone docstring in a node body is optimized as a :keyword:`pass`
+statement to ensure that the node's body is never empty. There was a
+:exc:`ValueError` in :func:`compile` otherwise.

Python/ast_preprocess.c

@@ -438,6 +438,7 @@ stmt_seq_remove_item(asdl_stmt_seq *stmts, Py_ssize_t idx)
 static int
 remove_docstring(asdl_stmt_seq *stmts, Py_ssize_t idx, PyArena *ctx_)
 {
+    assert(_PyAST_GetDocString(stmts) != NULL);
     // In case there's just the docstring in the body, replace it with `pass`
     // keyword, so body won't be empty.
     if (asdl_seq_LEN(stmts) == 1) {