Extract nested function definitions (#13625)

Author: AA-Turner

doc/conf.py

@@ -297,14 +297,12 @@ def linkify_issues_in_changelog(
 ) -> None:
     """Linkify issue references like #123 in changelog to GitHub."""
     if docname == 'changes':
+        linkified_changelog = re.sub(r'(?:PR)?#([0-9]+)\b', _linkify, source[0])
+        source[0] = linkified_changelog
 
-        def linkify(match: re.Match[str]) -> str:
-            url = 'https://github.com/sphinx-doc/sphinx/issues/' + match[1]
-            return f'`{match[0]} <{url}>`_'
-
-        linkified_changelog = re.sub(r'(?:PR)?#([0-9]+)\b', linkify, source[0])
 
-        source[0] = linkified_changelog
+def _linkify(match: re.Match[str], /) -> str:
+    return f'`{match[0]} <https://github.com/sphinx-doc/sphinx/issues/{match[1]}>`__'
 
 
 REDIRECT_TEMPLATE = """

sphinx/builders/_epub_base.py

@@ -279,16 +279,6 @@ def fix_ids(self, tree: nodes.document) -> None:
         Some readers crash because they interpret the part as a
         transport protocol specification.
         """
-
-        def update_node_id(node: Element) -> None:
-            """Update IDs of given *node*."""
-            new_ids: list[str] = []
-            for node_id in node['ids']:
-                new_id = self.fix_fragment('', node_id)
-                if new_id not in new_ids:
-                    new_ids.append(new_id)
-            node['ids'] = new_ids
-
         for reference in tree.findall(nodes.reference):
             if 'refuri' in reference:
                 m = self.refuri_re.match(reference['refuri'])
@@ -298,66 +288,75 @@ def update_node_id(node: Element) -> None:
                 reference['refid'] = self.fix_fragment('', reference['refid'])
 
         for target in tree.findall(nodes.target):
-            update_node_id(target)
+            self._update_node_id(target)
 
             next_node: Node = target.next_node(ascend=True)
             if isinstance(next_node, nodes.Element):
-                update_node_id(next_node)
+                self._update_node_id(next_node)
 
         for desc_signature in tree.findall(addnodes.desc_signature):
-            update_node_id(desc_signature)
+            self._update_node_id(desc_signature)
+
+    def _update_node_id(self, node: Element, /) -> None:
+        """Update IDs of given *node*."""
+        new_ids: list[str] = []
+        for node_id in node['ids']:
+            new_id = self.fix_fragment('', node_id)
+            if new_id not in new_ids:
+                new_ids.append(new_id)
+        node['ids'] = new_ids
+
+    @staticmethod
+    def _make_footnote_ref(doc: nodes.document, label: str) -> nodes.footnote_reference:
+        """Create a footnote_reference node with children"""
+        footnote_ref = nodes.footnote_reference('[#]_')
+        footnote_ref.append(nodes.Text(label))
+        doc.note_autofootnote_ref(footnote_ref)
+        return footnote_ref
+
+    @staticmethod
+    def _make_footnote(doc: nodes.document, label: str, uri: str) -> nodes.footnote:
+        """Create a footnote node with children"""
+        footnote = nodes.footnote(uri)
+        para = nodes.paragraph()
+        para.append(nodes.Text(uri))
+        footnote.append(para)
+        footnote.insert(0, nodes.label('', label))
+        doc.note_autofootnote(footnote)
+        return footnote
+
+    @staticmethod
+    def _footnote_spot(tree: nodes.document) -> tuple[Element, int]:
+        """Find or create a spot to place footnotes.
+
+        The function returns the tuple (parent, index).
+        """
+        # The code uses the following heuristic:
+        # a) place them after the last existing footnote
+        # b) place them after an (empty) Footnotes rubric
+        # c) create an empty Footnotes rubric at the end of the document
+        fns = list(tree.findall(nodes.footnote))
+        if fns:
+            fn = fns[-1]
+            return fn.parent, fn.parent.index(fn) + 1
+        for node in tree.findall(nodes.rubric):
+            if len(node) == 1 and node.astext() == FOOTNOTES_RUBRIC_NAME:
+                return node.parent, node.parent.index(node) + 1
+        doc = next(tree.findall(nodes.document))
+        rub = nodes.rubric()
+        rub.append(nodes.Text(FOOTNOTES_RUBRIC_NAME))
+        doc.append(rub)
+        return doc, doc.index(rub) + 1
 
     def add_visible_links(
         self, tree: nodes.document, show_urls: str = 'inline'
     ) -> None:
         """Add visible link targets for external links"""
-
-        def make_footnote_ref(
-            doc: nodes.document, label: str
-        ) -> nodes.footnote_reference:
-            """Create a footnote_reference node with children"""
-            footnote_ref = nodes.footnote_reference('[#]_')
-            footnote_ref.append(nodes.Text(label))
-            doc.note_autofootnote_ref(footnote_ref)
-            return footnote_ref
-
-        def make_footnote(doc: nodes.document, label: str, uri: str) -> nodes.footnote:
-            """Create a footnote node with children"""
-            footnote = nodes.footnote(uri)
-            para = nodes.paragraph()
-            para.append(nodes.Text(uri))
-            footnote.append(para)
-            footnote.insert(0, nodes.label('', label))
-            doc.note_autofootnote(footnote)
-            return footnote
-
-        def footnote_spot(tree: nodes.document) -> tuple[Element, int]:
-            """Find or create a spot to place footnotes.
-
-            The function returns the tuple (parent, index).
-            """
-            # The code uses the following heuristic:
-            # a) place them after the last existing footnote
-            # b) place them after an (empty) Footnotes rubric
-            # c) create an empty Footnotes rubric at the end of the document
-            fns = list(tree.findall(nodes.footnote))
-            if fns:
-                fn = fns[-1]
-                return fn.parent, fn.parent.index(fn) + 1
-            for node in tree.findall(nodes.rubric):
-                if len(node) == 1 and node.astext() == FOOTNOTES_RUBRIC_NAME:
-                    return node.parent, node.parent.index(node) + 1
-            doc = next(tree.findall(nodes.document))
-            rub = nodes.rubric()
-            rub.append(nodes.Text(FOOTNOTES_RUBRIC_NAME))
-            doc.append(rub)
-            return doc, doc.index(rub) + 1
-
         if show_urls == 'no':
             return
         if show_urls == 'footnote':
             doc = next(tree.findall(nodes.document))
-            fn_spot, fn_idx = footnote_spot(tree)
+            fn_spot, fn_idx = self._footnote_spot(tree)
             nr = 1
         for node in list(tree.findall(nodes.reference)):
             uri = node.get('refuri', '')
@@ -371,9 +370,9 @@ def footnote_spot(tree: nodes.document) -> tuple[Element, int]:
                 elif show_urls == 'footnote':
                     label = FOOTNOTE_LABEL_TEMPLATE % nr
                     nr += 1
-                    footnote_ref = make_footnote_ref(doc, label)
+                    footnote_ref = self._make_footnote_ref(doc, label)
                     node.parent.insert(idx, footnote_ref)
-                    footnote = make_footnote(doc, label, uri)
+                    footnote = self._make_footnote(doc, label, uri)
                     fn_spot.insert(fn_idx, footnote)
                     footnote_ref['refid'] = footnote['ids'][0]
                     footnote.add_backref(footnote_ref['ids'][0])

sphinx/domains/c/_parser.py

@@ -369,10 +369,7 @@ def _parse_logical_or_expression(self) -> ASTExpression:
         # pm             = cast             .*, ->*
         def _parse_bin_op_expr(self: DefinitionParser, op_id: int) -> ASTExpression:
             if op_id + 1 == len(_expression_bin_ops):
-
-                def parser() -> ASTExpression:
-                    return self._parse_cast_expression()
-
+                parser = self._parse_cast_expression
             else:
 
                 def parser() -> ASTExpression:
@@ -760,10 +757,7 @@ def _parse_declarator_name_suffix(
                     if self.skip_string(']'):
                         size = None
                     else:
-
-                        def parser() -> ASTExpression:
-                            return self._parse_expression()
-
+                        parser = self._parse_expression
                         size = self._parse_expression_fallback([']'], parser)
                         self.skip_ws()
                         if not self.skip_string(']'):
@@ -1025,10 +1019,7 @@ def _parse_enumerator(self) -> ASTEnumerator:
         init = None
         if self.skip_string('='):
             self.skip_ws()
-
-            def parser() -> ASTExpression:
-                return self._parse_constant_expression()
-
+            parser = self._parse_constant_expression
             init_val = self._parse_expression_fallback([], parser)
             init = ASTInitializer(init_val)
         return ASTEnumerator(name, init, attrs)

sphinx/domains/c/_symbol.py

@@ -445,43 +445,19 @@ def on_missing_qualified_symbol(
         # First check if one of those with a declaration matches.
         # If it's a function, we need to compare IDs,
         # otherwise there should be only one symbol with a declaration.
-        def make_cand_symbol() -> Symbol:
-            if Symbol.debug_lookup:
-                Symbol.debug_print('begin: creating candidate symbol')
-            symbol = Symbol(
-                parent=lookup_result.parent_symbol,
-                ident=lookup_result.ident,
-                declaration=declaration,
-                docname=docname,
-                line=line,
-            )
-            if Symbol.debug_lookup:
-                Symbol.debug_print('end:   creating candidate symbol')
-            return symbol
 
         if len(with_decl) == 0:
             cand_symbol = None
         else:
-            cand_symbol = make_cand_symbol()
-
-            def handle_duplicate_declaration(
-                symbol: Symbol, cand_symbol: Symbol
-            ) -> None:
-                if Symbol.debug_lookup:
-                    Symbol.debug_indent += 1
-                    Symbol.debug_print('redeclaration')
-                    Symbol.debug_indent -= 1
-                    Symbol.debug_indent -= 2
-                # Redeclaration of the same symbol.
-                # Let the new one be there, but raise an error to the client
-                # so it can use the real symbol as subscope.
-                # This will probably result in a duplicate id warning.
-                cand_symbol.isRedeclaration = True
-                raise _DuplicateSymbolError(symbol, declaration)
+            cand_symbol = self._make_cand_symbol(
+                lookup_result, declaration, docname, line
+            )
 
             if declaration.objectType != 'function':
                 assert len(with_decl) <= 1
-                handle_duplicate_declaration(with_decl[0], cand_symbol)
+                self._handle_duplicate_declaration(
+                    with_decl[0], cand_symbol, declaration
+                )
                 # (not reachable)
 
             # a function, so compare IDs
@@ -493,7 +469,7 @@ def handle_duplicate_declaration(
                 if Symbol.debug_lookup:
                     Symbol.debug_print('old_id: ', old_id)
                 if cand_id == old_id:
-                    handle_duplicate_declaration(symbol, cand_symbol)
+                    self._handle_duplicate_declaration(symbol, cand_symbol, declaration)
                     # (not reachable)
             # no candidate symbol found with matching ID
         # if there is an empty symbol, fill that one
@@ -507,7 +483,7 @@ def handle_duplicate_declaration(
             if cand_symbol is not None:
                 return cand_symbol
             else:
-                return make_cand_symbol()
+                return self._make_cand_symbol(lookup_result, declaration, docname, line)
         else:
             if Symbol.debug_lookup:
                 Symbol.debug_print(
@@ -529,6 +505,42 @@ def handle_duplicate_declaration(
             symbol._fill_empty(declaration, docname, line)
             return symbol
 
+    @staticmethod
+    def _make_cand_symbol(
+        lookup_result: SymbolLookupResult,
+        declaration: ASTDeclaration | None,
+        docname: str | None,
+        line: int | None,
+    ) -> Symbol:
+        if Symbol.debug_lookup:
+            Symbol.debug_print('begin: creating candidate symbol')
+        symbol = Symbol(
+            parent=lookup_result.parent_symbol,
+            ident=lookup_result.ident,
+            declaration=declaration,
+            docname=docname,
+            line=line,
+        )
+        if Symbol.debug_lookup:
+            Symbol.debug_print('end:   creating candidate symbol')
+        return symbol
+
+    @staticmethod
+    def _handle_duplicate_declaration(
+        symbol: Symbol, cand_symbol: Symbol, declaration: ASTDeclaration
+    ) -> None:
+        if Symbol.debug_lookup:
+            Symbol.debug_indent += 1
+            Symbol.debug_print('redeclaration')
+            Symbol.debug_indent -= 1
+            Symbol.debug_indent -= 2
+        # Redeclaration of the same symbol.
+        # Let the new one be there, but raise an error to the client
+        # so it can use the real symbol as subscope.
+        # This will probably result in a duplicate id warning.
+        cand_symbol.isRedeclaration = True
+        raise _DuplicateSymbolError(symbol, declaration)
+
     def merge_with(
         self, other: Symbol, docnames: list[str], env: BuildEnvironment
     ) -> None:

sphinx/domains/cpp/__init__.py

@@ -1056,6 +1056,15 @@ def merge_domaindata(self, docnames: Set[str], otherdata: dict[str, Any]) -> Non
             logger.debug('\tresult end')
             logger.debug('merge_domaindata end')
 
+    def _check_type(self, typ: str, decl_typ: str) -> bool:
+        if typ == 'any':
+            return True
+        objtypes = self.objtypes_for_role(typ)
+        if objtypes:
+            return decl_typ in objtypes
+        logger.debug(f'Type is {typ}, declaration type is {decl_typ}')  # NoQA: G004
+        raise AssertionError
+
     def _resolve_xref_inner(
         self,
         env: BuildEnvironment,
@@ -1150,16 +1159,7 @@ def _resolve_xref_inner(
         typ = typ.removeprefix('cpp:')
         decl_typ = s.declaration.objectType
 
-        def check_type() -> bool:
-            if typ == 'any':
-                return True
-            objtypes = self.objtypes_for_role(typ)
-            if objtypes:
-                return decl_typ in objtypes
-            logger.debug(f'Type is {typ}, declaration type is {decl_typ}')  # NoQA: G004
-            raise AssertionError
-
-        if not check_type():
+        if not self._check_type(typ, decl_typ):
             logger.warning(
                 'cpp:%s targets a %s (%s).',
                 typ,
@@ -1299,6 +1299,12 @@ def get_full_qualified_name(self, node: Element) -> str | None:
         return f'{parent_name}::{target}'
 
 
+def _init_stuff(app: Sphinx) -> None:
+    Symbol.debug_lookup = app.config.cpp_debug_lookup
+    Symbol.debug_show_tree = app.config.cpp_debug_show_tree
+    app.config.cpp_index_common_prefix.sort(reverse=True)
+
+
 def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_domain(CPPDomain)
     app.add_config_value('cpp_index_common_prefix', [], 'env', types=frozenset({list}))
@@ -1318,12 +1324,7 @@ def setup(app: Sphinx) -> ExtensionMetadata:
     app.add_config_value('cpp_debug_lookup', False, '', types=frozenset({bool}))
     app.add_config_value('cpp_debug_show_tree', False, '', types=frozenset({bool}))
 
-    def init_stuff(app: Sphinx) -> None:
-        Symbol.debug_lookup = app.config.cpp_debug_lookup
-        Symbol.debug_show_tree = app.config.cpp_debug_show_tree
-        app.config.cpp_index_common_prefix.sort(reverse=True)
-
-    app.connect('builder-inited', init_stuff)
+    app.connect('builder-inited', _init_stuff)
 
     return {
         'version': 'builtin',