feat(gix): write index trees with the native editor

Write `IndexFile.write_tree` through the native tree editor after the shared complete index validation. Keep unmerged-entry rejection and reuse the existing Tree result type. Missing non-gitlink children retain Git's `--missing-ok` behavior through fallback (GIX-7).

The staged version passes Ruff and Python syntax checks. Its SHA-1/SHA-256 native smoke and focused pytest selection pass: 48 passed in 16.38s.

Author: codex

git/_backend.py

@@ -397,6 +397,49 @@ def _hash_object(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
     return str(oid).encode("ascii") + b"\n"
 
 
+_ENTRY_KINDS = {0o100644: "blob", 0o100755: "exe", 0o120000: "link", 0o160000: "commit", 0o40000: "tree"}
+
+
+def _write_tree(repo: Any, entries: Sequence[Tuple[bytes, int, str]]) -> str:
+    names = {name for name, _mode, _oid in entries}
+    if len(names) != len(entries):
+        raise _Unsupported("duplicate or overlapping tree paths")
+    for name in names:
+        while b"/" in name:
+            name = name.rsplit(b"/", 1)[0]
+            if name in names:
+                raise _Unsupported("duplicate or overlapping tree paths")
+    for _path, mode, oid in entries:
+        object_id = gix.ObjectId(oid)
+        if object_id.is_null():
+            raise _Unsupported("null tree object IDs")
+        header = repo.try_find_header(object_id)
+        if header is None:
+            if mode != 0o160000:
+                raise _Unsupported("missing tree children (GIX-7)")
+        elif header.kind() != ("tree" if mode == 0o40000 else "commit" if mode == 0o160000 else "blob"):
+            raise _Unsupported("tree child object kind")
+    with repo.empty_tree().edit() as editor:
+        for path, mode, oid in entries:
+            editor.upsert(path, _ENTRY_KINDS[mode], gix.ObjectId(oid))
+        return str(_write("write_tree", editor.write))
+
+
+def write_tree(command: Any, entries: Sequence[Tuple[bytes, int, str]]) -> Any:
+    if gix is None:
+        return NotImplemented
+    command._require_version()
+    try:
+        result = _write_tree(_repository(command, {}), entries)
+    except _Unsupported as exc:
+        return _fallback("IndexFile.write_tree", str(exc))
+    except gix.Error as exc:
+        _logger.debug("write_tree native preparation: %s", exc)
+        return _fallback("IndexFile.write_tree", "native preparation diagnostics")
+    record("IndexFile.write_tree", "native")
+    return result
+
+
 _HANDLERS: Dict[str, Callable[[Any, List[str], Dict[str, Any]], bytes]] = {
     "rev_parse": _rev_parse,
     "ls_tree": _ls_tree,

git/index/base.py

@@ -21,6 +21,7 @@
 
 from gitdb.base import IStream
 
+from git import _backend
 from git.compat import defenc, force_bytes, safe_decode
 from git.cmd import Git
 import git.diff as git_diff
@@ -169,9 +170,8 @@ def version(self) -> int:
             )
         )
 
-    @contextlib.contextmanager
-    def _materialized_index(self) -> Generator[str, None, None]:
-        """Apply the in-memory entries to a private, Git-managed index."""
+    def _validated_entries(self) -> Dict[Tuple[PathLike, StageType], IndexEntry]:
+        """Validate the complete update before either backend can write."""
         desired: Dict[Tuple[PathLike, StageType], IndexEntry] = {}
         for key, entry in self.entries.items():
             path = os.fspath(entry.path)
@@ -181,6 +181,12 @@ def _materialized_index(self) -> Generator[str, None, None]:
             if len(entry.binsha) != self.repo._oid_size or entry.mode not in (0o100644, 0o100755, 0o120000, 0o160000):
                 raise ValueError("Invalid index object ID or mode")
             desired[(path, entry.stage)] = entry
+        return desired
+
+    @contextlib.contextmanager
+    def _materialized_index(self) -> Generator[str, None, None]:
+        """Apply the in-memory entries to a private, Git-managed index."""
+        desired = self._validated_entries()
         with tempfile.TemporaryDirectory(prefix="gitpython-index-") as directory:
             path = osp.join(directory, "index")
             env = {"GIT_INDEX_FILE": path}
@@ -670,6 +676,12 @@ def write_tree(self) -> Tree:
         for entry in self.entries.values():
             if entry.stage:
                 raise UnmergedEntriesError(entry)
+        entries = self._validated_entries()
+        native = _backend.write_tree(
+            self.repo.git, [(os.fsencode(entry.path), entry.mode, entry.hexsha) for entry in entries.values()]
+        )
+        if native is not NotImplemented:
+            return Tree(self.repo, bytes.fromhex(native), path="")
         with self._materialized_index() as path:
             oid = self.repo.git._call_process_safe("write_tree", "--missing-ok", env={"GIT_INDEX_FILE": path})
         return Tree(self.repo, bytes.fromhex(oid), path="")