perf(gix): parse submodule inventory and cached fields natively

Submodule enumeration and cache refresh each launched `git config list` over
`.gitmodules`. Use the dedicated `ModulesFile` binding for raw path, URL and
branch fields, sharing the existing selection of worktree versus historical
blob sources and the existing path-containment checks.

Retain Git's parser for other/duplicate sections, ambiguous bracket syntax,
missing or implicit fields, and native parse errors. The bindings cannot yet
enumerate arbitrary sections; conservative guards preserve declaration order
and the existing errors without implementing a configuration grammar in
Python. Public and writable config parsers retain their full contracts.

The fixed probe enumerating one submodule and reloading its URL drops from
4 CLI launches to 0, including the former standalone version checks. The
regression compares declaration order, repeated raw URL values and refreshed
fields with Git, asserts zero native launches, and checks duplicate-section
and include behavior. The earlier full inventory recorded 976 relevant
configuration reads before secondary version probes.

Validation: all affected submodule and backend tests passed with Gix first
(497 tests, three skipped, one expected failure, 117.80s), then CLI (448 tests,
four skipped, one expected failure, 431.08s). Ruff lint/format, mypy, basedpyright and
`git diff --check` passed.

Author: codex

doc/gix-backend.md

@@ -141,6 +141,7 @@ The historical full-suite counts above predate this correction. A constant
 | Managed `symbolic_ref` | Nonrecursive target lookup | Mutation, command-level missing-reference diagnostics |
 | Reference enumeration, `for_each_ref` | Sorted reference names and literal prefixes, preserving symbolic aliases | Dangling symbolic refs, root refs, glob patterns, other formats/options |
 | Managed `config --get KEY` | Merged repository config snapshot | Files/streams, enumeration, mutation; GIX-12 |
+| Submodule enumeration and cached fields | Dedicated native `.gitmodules` parser over the existing worktree/blob source, with raw path/URL/branch values | Other/duplicate sections, ambiguous brackets, missing/implicit fields and parser errors; GIX-12 |
 | Worktree inventory, `worktree list` | Main and linked worktree metadata, including bare main repositories and locks | Prunable entries; GIX-14 |
 | `Repo.merge_base`, `Repo.is_ancestor` | Native graph queries for two revisions | Octopus/fork-point and other options |
 | `Commit.count` | Reachable commit count, skip/limit/first-parent | Path filters and other revision options |
@@ -162,7 +163,7 @@ The historical full-suite counts above predate this correction. A constant
 | `Repo.untracked_files` | Native directory walk | Extra status options and non-root command directories |
 | `Repo.ignored` | Native excludes with tracked-file suppression | Symlink/submodule traversal and unsupported path normalization |
 
-All native operations currently fall back for reftable (GIX-1) and repositories
+Repository-backed native operations fall back for reftable (GIX-1) and repositories
 with `extensions.compatObjectFormat` (GIX-19). Process-returning calls, timeouts,
 custom storage/environment, global Git options, and unhandled command options
 also retain their CLI contracts. A broken installed extension is reported as

git/_backend.py

@@ -17,7 +17,7 @@
 from threading import Lock
 from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Tuple, cast
 
-from git.compat import safe_decode
+from git.compat import defenc, safe_decode
 from git.exc import GitCommandError
 
 _selection = os.environ.get("GIT_PYTHON_BACKEND")
@@ -382,6 +382,48 @@ def _for_each_ref(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     )
 
 
+def submodule_config(source: Any) -> Any:
+    """Read the fields used by submodule objects from their selected config source."""
+    if gix is None:
+        return NotImplemented
+    try:
+        if isinstance(source, io.BytesIO):
+            data = source.getvalue()
+        else:
+            with open(source, "rb") as stream:
+                data = stream.read()
+        # ponytail: no bound section enumeration; conservatively reject other '['
+        # occurrences and duplicate sections until GIX-12 can preserve their order.
+        if b"\0" in data or re.search(rb"\[(?!submodule[ \t])", data, re.I):
+            raise _Unsupported("non-submodule configuration sections (GIX-12)")
+        modules = gix.ModulesFile.from_bytes(data)
+        with modules.names() as cursor:
+            names = list(cursor)
+        if data.count(b"[") != len(names):
+            raise _Unsupported("duplicate or ambiguous configuration sections (GIX-12)")
+        config = modules.config()
+        result = {}
+        for raw_name in names:
+            name = raw_name.decode(defenc)
+            values = {}
+            for option in ("path", "url", "branch"):
+                key = "submodule." + name + "." + option
+                value = config.string(key)
+                if value is None:
+                    if option != "branch" or config.boolean(key) is not None:
+                        raise _Unsupported("missing or implicit submodule fields")
+                else:
+                    values[option] = value.decode(defenc)
+            result[name] = values
+    except _Unsupported as exc:
+        return _fallback("Submodule.config", str(exc))
+    except (gix.Error, OSError, UnicodeError) as exc:
+        _logger.debug("native submodule configuration: %s", exc)
+        return _fallback("Submodule.config", "native parse diagnostics")
+    record("Submodule.config", "native")
+    return result
+
+
 def _config(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     if len(args) == 2 and args[0] == "--get":
         snapshot = repo.config_snapshot()

git/objects/submodule/base.py

@@ -32,6 +32,7 @@
 )
 
 import git
+from git import _backend
 from git.cmd import Git
 from git.config import GitConfigParser, SectionConstraint, cp
 from git.exc import (
@@ -170,6 +171,16 @@ def __init__(
     def _set_cache_(self, attr: str) -> None:
         if attr in ("path", "_url", "_branch_path"):
             reader: SectionConstraint = self.config_reader()
+            native = _backend.submodule_config(reader.config._file_or_files)
+            if native is not NotImplemented and self.name in native:
+                values = native[self.name]
+                self.path, self._url = values["path"], values["url"]
+                self._branch_path = (
+                    GitConfigParser._string_to_value(values[self.k_head_option])
+                    if self.k_head_option in values
+                    else git.Head.to_full_path(self.k_head_default)
+                )
+                return
             # Default submodule values.
             try:
                 self.path = reader.get("path")
@@ -1889,14 +1900,19 @@ def iter_items(
             raise ValueError("Commit %r could not be resolved" % parent_commit) from error
         # END handle empty iterator
 
-        for sms in parser.sections():
+        native = _backend.submodule_config(parser._file_or_files)
+        sections = parser.sections() if native is NotImplemented else [sm_section(name) for name in native]
+        for sms in sections:
             n = sm_name(sms)
-            p = parser.get(sms, "path")
-            u = parser.get(sms, "url")
-            b = cls.k_head_default
-            if parser.has_option(sms, cls.k_head_option):
-                b = str(parser.get(sms, cls.k_head_option))
-            # END handle optional information
+            if native is NotImplemented:
+                p = parser.get(sms, "path")
+                u = parser.get(sms, "url")
+                b = cls.k_head_default
+                if parser.has_option(sms, cls.k_head_option):
+                    b = str(parser.get(sms, cls.k_head_option))
+            else:
+                p, u = native[n]["path"], native[n]["url"]
+                b = native[n].get(cls.k_head_option, cls.k_head_default)
 
             # Get the binsha.
             index = repo.index

test/test_gix_backend.py

@@ -1,5 +1,6 @@
 """Exercise the installed backend, including proof that converted calls avoid Git."""
 
+from configparser import NoOptionError
 from io import BytesIO
 from pathlib import Path
 import pickle
@@ -307,6 +308,46 @@ def test_native_tree_and_commit_bytes_match_cli(repo):
         assert commit.replace(message="a changed message").hexsha == native.hexsha
 
 
+def test_native_submodule_inventory_and_cached_fields_match_cli(repo):
+    first = repo.index.commit("initial", skip_hooks=True)
+    config = Path(repo.working_dir, ".gitmodules")
+    data = (
+        '[submodule "z-last"]\npath = z\nurl = ../source z\n'
+        '[submodule "a.first"]\npath = a\nurl = ../old\nurl = ../source-a\nbranch = topic\n'
+    )
+    config.write_text(data)
+    index = repo.index
+    index.add([".gitmodules", *(BaseIndexEntry((0o160000, first.binsha, 0, path)) for path in ("z", "a"))])
+    index.commit("modules", skip_hooks=True)
+
+    def snapshot():
+        modules = repo.submodules
+        listed = [(m.name, m.path, m.url, m.branch_path) for m in modules]
+        for module in modules:
+            module._clear_cache()
+        refreshed = [(m.name, m.path, m.url, m.branch_path) for m in modules]
+        return listed, refreshed
+
+    with patch.object(_backend, "gix", None):
+        expected = snapshot()
+    count = _backend.statistics().get(("Git.execute", "CLI process"), 0)
+    with patch.object(Git, "execute", side_effect=AssertionError("unexpected submodule config CLI call")):
+        assert snapshot() == expected
+    assert _backend.statistics().get(("Git.execute", "CLI process"), 0) == count
+    assert [entry[0] for entry in expected[0]] == ["z-last", "a.first"]
+
+    # Empty/duplicate sections can change first-declaration order; use Git's parser.
+    config.write_text('[submodule "a.first"]\n' + data)
+    with patch.object(_backend, "gix", None):
+        expected = snapshot()
+    assert snapshot() == expected
+    config.write_text(data + "[include]\npath = not-read\n")
+    for native in (False, True):
+        with patch.object(_backend, "gix", gix if native else None):
+            with pytest.raises(NoOptionError, match="url"):
+                snapshot()
+
+
 def test_native_revision_path_and_mode_match_cli(repo, tmp_path):
     blob = repo.odb.store(IStream("blob", 4, BytesIO(b"data")))
     index = repo.index