Annotate _process_diff_args without Diffable.Index

EliahKagan · EliahKagan · commit 2f5e258d2b23 · 2024-03-09T10:43:21.000-05:00
This removes the static type of Diffable's nested Index class,
Type["Index"], from the Diffable._process_diff_args method, and its
override IndexFile._process_diff_args. Further changes related to
this remain necessary, and at this time, this adds one mypy error.

The _process_diff_args methods did not handle Diffable.Index. The
base class method would pass it through, but it would not be usable
when then passed to "git diff". Instead, it is handled with correct
behavior at runtime in Diffable.diff and its IndexFile.diff
override, which handle it themselves and ensure it is never passed
to any _process_diff_args implementation.

That was already the case. The change here is mostly to type hints,
removing it from the _process_diff_args annotations, since those
methods have never actually worked with it and it probably wouldn't
make sense for them to handle it. However, this does also attempt
to help mypy figure out that Diffable.Index cannot end up as an
element of its local variable `args`. This attempt is unsuccessful.

The problem with the `args` local variable may be the reason
including Index in the parameter type annotations appeared correct
or necessary before. The issue is that Diffable.Index, even though
it ought to be used as an opaque constant, is a class. Its static
type is Type[Diffable.Index], but mypy is unable to infer that
there are no other objects of that static type, because if
Diffable.Index were subclassed, and the type object produced from
doing so (i.e. the subclass itself) were passed as an `other`
argument to the diff method, then the `other is Diffable.Index`
condition would evaluate to False.

Therefore to solve this problem it should be sufficient to decorate
the Diffable.Index class as `@final`. This works for pyright (and
thus also pylance), but it does not work for mypy (even in 1.9.0).
So that still has to be solved, and (other than via suppressions)
it may be necessary to make Diffable.Index an enumeration constant
rather than a class, so it can be annotated as a literal.
diff --git a/git/diff.py b/git/diff.py
@@ -28,7 +28,7 @@
     TYPE_CHECKING,
     cast,
 )
-from git.types import PathLike, Literal
+from git.types import Literal, PathLike, final
 
 if TYPE_CHECKING:
     from .objects.tree import Tree
@@ -94,13 +94,14 @@ class Diffable:
     repo: "Repo"
     """Repository to operate on. Must be provided by subclass or sibling class."""
 
+    @final
     class Index:
         """Stand-in indicating you want to diff against the index."""
 
     def _process_diff_args(
         self,
-        args: List[Union[PathLike, "Diffable", Type["Index"]]],
-    ) -> List[Union[PathLike, "Diffable", Type["Index"]]]:
+        args: List[Union[PathLike, "Diffable"]],
+    ) -> List[Union[PathLike, "Diffable"]]:
         """
         :return:
             Possibly altered version of the given args list.
@@ -161,7 +162,7 @@ def diff(
             :class:`~git.objects.tree.Tree` or :class:`~git.objects.commit.Commit`, or a
             git command error will occur.
         """
-        args: List[Union[PathLike, Diffable, Type["Diffable.Index"]]] = []
+        args: List[Union[PathLike, Diffable]] = []
         args.append("--abbrev=40")  # We need full shas.
         args.append("--full-index")  # Get full index paths, not only filenames.
 
@@ -184,7 +185,7 @@ def diff(
             paths = [paths]
 
         diff_cmd = self.repo.git.diff
-        if other is self.Index:
+        if other is Diffable.Index:
             args.insert(0, "--cached")
         elif other is NULL_TREE:
             args.insert(0, "-r")  # Recursive diff-tree.
diff --git a/git/index/base.py b/git/index/base.py
@@ -645,8 +645,8 @@ def write_tree(self) -> Tree:
 
     def _process_diff_args(
         self,
-        args: List[Union[PathLike, "git_diff.Diffable", Type["git_diff.Diffable.Index"]]],
-    ) -> List[Union[PathLike, "git_diff.Diffable", Type["git_diff.Diffable.Index"]]]:
+        args: List[Union[PathLike, "git_diff.Diffable"]],
+    ) -> List[Union[PathLike, "git_diff.Diffable"]]:
         try:
             args.pop(args.index(self))
         except IndexError:
@@ -1494,7 +1494,6 @@ def diff(
             Will only work with indices that represent the default git index as they
             have not been initialized with a stream.
         """
-
         # Only run if we are the default repository index.
         if self._file_path != self._index_path():
             raise AssertionError("Cannot call %r on indices that do not represent the default git index" % self.diff())
diff --git a/git/types.py b/git/types.py
@@ -22,6 +22,7 @@
         TypedDict,
         Protocol,
         SupportsIndex as SupportsIndex,
+        final,
         runtime_checkable,
     )
 else:
@@ -30,6 +31,7 @@
         SupportsIndex as SupportsIndex,
         TypedDict,
         Protocol,
+        final,
         runtime_checkable,
     )
 

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`TypedDict,`
`23`	`23`	`Protocol,`
`24`	`24`	`SupportsIndex as SupportsIndex,`
	`25`	`+ final,`
`25`	`26`	`runtime_checkable,`
`26`	`27`	`)`
`27`	`28`	`else:`
`@@ -30,6 +31,7 @@`
`30`	`31`	`SupportsIndex as SupportsIndex,`
`31`	`32`	`TypedDict,`
`32`	`33`	`Protocol,`
	`34`	`+ final,`
`33`	`35`	`runtime_checkable,`
`34`	`36`	`)`
`35`	`37`