Replace plain slice type hints with IndexSlice.

stdlib/_ctypes.pyi

@@ -5,7 +5,7 @@ from abc import abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
 from ctypes import CDLL, ArgumentError as ArgumentError, c_void_p
 from types import GenericAlias
-from typing import Any, ClassVar, Generic, TypeVar, final, overload, type_check_only
+from typing import Any, ClassVar, Generic, SupportsIndex, TypeVar, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
 _T = TypeVar("_T")
@@ -130,7 +130,7 @@ class _Pointer(_PointerLike, _CData, Generic[_CT], metaclass=_PyCPointerType):
     @overload
     def __getitem__(self, key: int, /) -> Any: ...
     @overload
-    def __getitem__(self, key: slice, /) -> list[Any]: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> list[Any]: ...
     def __setitem__(self, key: int, value: Any, /) -> None: ...
 
 if sys.version_info < (3, 14):
@@ -313,11 +313,11 @@ class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
     @overload
     def __getitem__(self, key: int, /) -> Any: ...
     @overload
-    def __getitem__(self, key: slice, /) -> list[Any]: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> list[Any]: ...
     @overload
     def __setitem__(self, key: int, value: Any, /) -> None: ...
     @overload
-    def __setitem__(self, key: slice, value: Iterable[Any], /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: Iterable[Any], /) -> None: ...
     def __iter__(self) -> Iterator[Any]: ...
     # Can't inherit from Sized because the metaclass conflict between
     # Sized and _CData prevents using _CDataMeta.

stdlib/_operator.pyi

@@ -79,20 +79,20 @@ def concat(a: Sequence[_T], b: Sequence[_T], /) -> Sequence[_T]: ...
 def contains(a: Container[object], b: object, /) -> bool: ...
 def countOf(a: Iterable[object], b: object, /) -> int: ...
 @overload
-def delitem(a: MutableSequence[Any], b: SupportsIndex, /) -> None: ...
+def delitem(a: MutableSequence[Any], b: int, /) -> None: ...
 @overload
-def delitem(a: MutableSequence[Any], b: slice, /) -> None: ...
+def delitem(a: MutableSequence[Any], b: slice[int | None], /) -> None: ...
 @overload
 def delitem(a: MutableMapping[_K, Any], b: _K, /) -> None: ...
 @overload
-def getitem(a: Sequence[_T], b: slice, /) -> Sequence[_T]: ...
+def getitem(a: Sequence[_T], b: slice[int | None], /) -> Sequence[_T]: ...
 @overload
 def getitem(a: SupportsGetItem[_K, _V], b: _K, /) -> _V: ...
 def indexOf(a: Iterable[_T], b: _T, /) -> int: ...
 @overload
-def setitem(a: MutableSequence[_T], b: SupportsIndex, c: _T, /) -> None: ...
+def setitem(a: MutableSequence[_T], b: int, c: _T, /) -> None: ...
 @overload
-def setitem(a: MutableSequence[_T], b: slice, c: Sequence[_T], /) -> None: ...
+def setitem(a: MutableSequence[_T], b: slice[int | None], c: Sequence[_T], /) -> None: ...
 @overload
 def setitem(a: MutableMapping[_K, _V], b: _K, c: _V, /) -> None: ...
 def length_hint(obj: object, default: int = 0, /) -> int: ...

stdlib/_typeshed/__init__.pyi

@@ -286,15 +286,15 @@ WriteableBuffer: TypeAlias = Buffer
 ReadableBuffer: TypeAlias = Buffer  # stable
 
 class SliceableBuffer(Buffer, Protocol):
-    def __getitem__(self, slice: slice, /) -> Sequence[int]: ...
+    def __getitem__(self, slice: slice[SupportsIndex | None], /) -> Sequence[int]: ...
 
 class IndexableBuffer(Buffer, Protocol):
     def __getitem__(self, i: int, /) -> int: ...
 
 class SupportsGetItemBuffer(SliceableBuffer, IndexableBuffer, Protocol):
     def __contains__(self, x: Any, /) -> bool: ...
     @overload
-    def __getitem__(self, slice: slice, /) -> Sequence[int]: ...
+    def __getitem__(self, slice: slice[SupportsIndex | None], /) -> Sequence[int]: ...
     @overload
     def __getitem__(self, i: int, /) -> int: ...
 

stdlib/array.pyi

@@ -62,12 +62,12 @@ class array(MutableSequence[_T]):
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> _T: ...
     @overload
-    def __getitem__(self, key: slice, /) -> array[_T]: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> array[_T]: ...
     @overload  # type: ignore[override]
     def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
     @overload
-    def __setitem__(self, key: slice, value: array[_T], /) -> None: ...
-    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: array[_T], /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice[SupportsIndex | None], /) -> None: ...
     def __add__(self, value: array[_T], /) -> array[_T]: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __ge__(self, value: array[_T], /) -> bool: ...

stdlib/builtins.pyi

@@ -616,9 +616,9 @@ class str(Sequence[str]):
     def __eq__(self, value: object, /) -> bool: ...
     def __ge__(self, value: str, /) -> bool: ...
     @overload
-    def __getitem__(self: LiteralString, key: SupportsIndex | slice, /) -> LiteralString: ...
+    def __getitem__(self: LiteralString, key: SupportsIndex | slice[SupportsIndex | None], /) -> LiteralString: ...
     @overload
-    def __getitem__(self, key: SupportsIndex | slice, /) -> str: ...  # type: ignore[misc]
+    def __getitem__(self, key: SupportsIndex | slice[SupportsIndex | None], /) -> str: ...  # type: ignore[misc]
     def __gt__(self, value: str, /) -> bool: ...
     def __hash__(self) -> int: ...
     @overload
@@ -722,7 +722,7 @@ class bytes(Sequence[int]):
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, key: slice, /) -> bytes: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> bytes: ...
     def __add__(self, value: ReadableBuffer, /) -> bytes: ...
     def __mul__(self, value: SupportsIndex, /) -> bytes: ...
     def __rmul__(self, value: SupportsIndex, /) -> bytes: ...
@@ -826,12 +826,12 @@ class bytearray(MutableSequence[int]):
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, key: slice, /) -> bytearray: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> bytearray: ...
     @overload
     def __setitem__(self, key: SupportsIndex, value: SupportsIndex, /) -> None: ...
     @overload
-    def __setitem__(self, key: slice, value: Iterable[SupportsIndex] | bytes, /) -> None: ...
-    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: Iterable[SupportsIndex] | bytes, /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice[SupportsIndex | None], /) -> None: ...
     def __add__(self, value: ReadableBuffer, /) -> bytearray: ...
     # The superclass wants us to accept Iterable[int], but that fails at runtime.
     def __iadd__(self, value: ReadableBuffer, /) -> Self: ...  # type: ignore[override]
@@ -903,14 +903,14 @@ class memoryview(Sequence[_I]):
     @overload
     def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> _I: ...
     @overload
-    def __getitem__(self, key: slice, /) -> memoryview[_I]: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> memoryview[_I]: ...
     def __contains__(self, x: object, /) -> bool: ...
     def __iter__(self) -> Iterator[_I]: ...
     def __len__(self) -> int: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
     @overload
-    def __setitem__(self, key: slice, value: ReadableBuffer, /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: ReadableBuffer, /) -> None: ...
     @overload
     def __setitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], value: _I, /) -> None: ...
     if sys.version_info >= (3, 10):
@@ -1012,7 +1012,7 @@ class tuple(Sequence[_T_co]):
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> _T_co: ...
     @overload
-    def __getitem__(self, key: slice, /) -> tuple[_T_co, ...]: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> tuple[_T_co, ...]: ...
     def __iter__(self) -> Iterator[_T_co]: ...
     def __lt__(self, value: tuple[_T_co, ...], /) -> bool: ...
     def __le__(self, value: tuple[_T_co, ...], /) -> bool: ...
@@ -1111,12 +1111,12 @@ class list(MutableSequence[_T]):
     @overload
     def __getitem__(self, i: SupportsIndex, /) -> _T: ...
     @overload
-    def __getitem__(self, s: slice, /) -> list[_T]: ...
+    def __getitem__(self, s: slice[SupportsIndex | None], /) -> list[_T]: ...
     @overload
     def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
     @overload
-    def __setitem__(self, key: slice, value: Iterable[_T], /) -> None: ...
-    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: Iterable[_T], /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice[SupportsIndex | None], /) -> None: ...
     # Overloading looks unnecessary, but is needed to work around complex mypy problems
     @overload
     def __add__(self, value: list[_T], /) -> list[_T]: ...
@@ -1312,7 +1312,7 @@ class range(Sequence[int]):
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, key: slice, /) -> range: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> range: ...
     def __reversed__(self) -> Iterator[int]: ...
 
 class property:

stdlib/collections/__init__.pyi

@@ -129,12 +129,12 @@ class UserList(MutableSequence[_T]):
     @overload
     def __getitem__(self, i: SupportsIndex) -> _T: ...
     @overload
-    def __getitem__(self, i: slice) -> Self: ...
+    def __getitem__(self, i: slice[SupportsIndex | None]) -> Self: ...
     @overload
     def __setitem__(self, i: SupportsIndex, item: _T) -> None: ...
     @overload
-    def __setitem__(self, i: slice, item: Iterable[_T]) -> None: ...
-    def __delitem__(self, i: SupportsIndex | slice) -> None: ...
+    def __setitem__(self, i: slice[SupportsIndex | None], item: Iterable[_T]) -> None: ...
+    def __delitem__(self, i: SupportsIndex | slice[SupportsIndex | None]) -> None: ...
     def __add__(self, other: Iterable[_T]) -> Self: ...
     def __radd__(self, other: Iterable[_T]) -> Self: ...
     def __iadd__(self, other: Iterable[_T]) -> Self: ...
@@ -174,7 +174,7 @@ class UserString(Sequence[UserString]):
     def __hash__(self) -> int: ...
     def __contains__(self, char: object) -> bool: ...
     def __len__(self) -> int: ...
-    def __getitem__(self, index: SupportsIndex | slice) -> Self: ...
+    def __getitem__(self, index: SupportsIndex | slice[SupportsIndex | None]) -> Self: ...
     def __iter__(self) -> Iterator[Self]: ...
     def __reversed__(self) -> Iterator[Self]: ...
     def __add__(self, other: object) -> Self: ...

stdlib/logging/config.pyi

@@ -97,14 +97,14 @@ class ConvertingList(list[Any], ConvertingMixin):  # undocumented
     @overload
     def __getitem__(self, key: SupportsIndex) -> Any: ...
     @overload
-    def __getitem__(self, key: slice) -> Any: ...
+    def __getitem__(self, key: slice[SupportsIndex | None]) -> Any: ...
     def pop(self, idx: SupportsIndex = -1) -> Any: ...
 
 class ConvertingTuple(tuple[Any, ...], ConvertingMixin):  # undocumented
     @overload
     def __getitem__(self, key: SupportsIndex) -> Any: ...
     @overload
-    def __getitem__(self, key: slice) -> Any: ...
+    def __getitem__(self, key: slice[SupportsIndex | None]) -> Any: ...
 
 class BaseConfigurator:  # undocumented
     CONVERT_PATTERN: Pattern[str]

stdlib/mmap.pyi

@@ -2,7 +2,7 @@ import os
 import sys
 from _typeshed import ReadableBuffer, Unused
 from collections.abc import Iterator
-from typing import Final, Literal, NoReturn, overload
+from typing import Final, Literal, NoReturn, SupportsIndex, overload
 from typing_extensions import Self
 
 ACCESS_DEFAULT: Final = 0
@@ -76,14 +76,14 @@ class mmap:
     def read(self, n: int | None = None) -> bytes: ...
     def write(self, bytes: ReadableBuffer) -> int: ...
     @overload
-    def __getitem__(self, key: int, /) -> int: ...
+    def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, key: slice, /) -> bytes: ...
-    def __delitem__(self, key: int | slice, /) -> NoReturn: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> bytes: ...
+    def __delitem__(self, key: SupportsIndex | slice[SupportsIndex | None], /) -> NoReturn: ...
     @overload
-    def __setitem__(self, key: int, value: int, /) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: int, /) -> None: ...
     @overload
-    def __setitem__(self, key: slice, value: ReadableBuffer, /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: ReadableBuffer, /) -> None: ...
     # Doesn't actually exist, but the object actually supports "in" because it has __getitem__,
     # so we claim that there is also a __contains__ to help type checkers.
     def __contains__(self, o: object, /) -> bool: ...

stdlib/multiprocessing/managers.pyi

@@ -171,15 +171,15 @@ class BaseListProxy(BaseProxy, MutableSequence[_T]):
     __builtins__: ClassVar[dict[str, Any]]
     def __len__(self) -> int: ...
     def __add__(self, x: list[_T], /) -> list[_T]: ...
-    def __delitem__(self, i: SupportsIndex | slice, /) -> None: ...
+    def __delitem__(self, i: SupportsIndex | slice[SupportsIndex | None], /) -> None: ...
     @overload
     def __getitem__(self, i: SupportsIndex, /) -> _T: ...
     @overload
-    def __getitem__(self, s: slice, /) -> list[_T]: ...
+    def __getitem__(self, s: slice[SupportsIndex | None], /) -> list[_T]: ...
     @overload
     def __setitem__(self, i: SupportsIndex, o: _T, /) -> None: ...
     @overload
-    def __setitem__(self, s: slice, o: Iterable[_T], /) -> None: ...
+    def __setitem__(self, s: slice[SupportsIndex | None], o: Iterable[_T], /) -> None: ...
     def __mul__(self, n: SupportsIndex, /) -> list[_T]: ...
     def __rmul__(self, n: SupportsIndex, /) -> list[_T]: ...
     def __imul__(self, value: SupportsIndex, /) -> Self: ...

stdlib/multiprocessing/sharedctypes.pyi

@@ -5,7 +5,7 @@ from ctypes import _SimpleCData, c_char
 from multiprocessing.context import BaseContext
 from multiprocessing.synchronize import _LockLike
 from types import TracebackType
-from typing import Any, Generic, Literal, Protocol, TypeVar, overload
+from typing import Any, Generic, Literal, Protocol, SupportsIndex, TypeVar, overload
 
 __all__ = ["RawValue", "RawArray", "Value", "Array", "copy", "synchronized"]
 
@@ -103,27 +103,27 @@ class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
 class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, i: slice) -> list[_T]: ...
+    def __getitem__(self, i: slice[SupportsIndex | None]) -> list[_T]: ...
     @overload
-    def __getitem__(self, i: int) -> _T: ...
+    def __getitem__(self, i: SupportsIndex) -> _T: ...
     @overload
-    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
+    def __setitem__(self, i: slice[SupportsIndex | None], value: Iterable[_T]) -> None: ...
     @overload
-    def __setitem__(self, i: int, value: _T) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
+    def __setitem__(self, i: SupportsIndex, value: _T) -> None: ...
+    def __getslice__(self, start: SupportsIndex, stop: SupportsIndex) -> list[_T]: ...
+    def __setslice__(self, start: SupportsIndex, stop: SupportsIndex, values: Iterable[_T]) -> None: ...
 
 class SynchronizedString(SynchronizedArray[bytes]):
     @overload  # type: ignore[override]
-    def __getitem__(self, i: slice) -> bytes: ...
+    def __getitem__(self, i: slice[SupportsIndex | None]) -> bytes: ...
     @overload
-    def __getitem__(self, i: int) -> bytes: ...
+    def __getitem__(self, i: SupportsIndex) -> bytes: ...
     @overload  # type: ignore[override]
-    def __setitem__(self, i: slice, value: bytes) -> None: ...
+    def __setitem__(self, i: slice[SupportsIndex | None], value: bytes) -> None: ...
     @overload
-    def __setitem__(self, i: int, value: bytes) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
-    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
+    def __setitem__(self, i: SupportsIndex, value: bytes) -> None: ...
+    def __getslice__(self, start: SupportsIndex, stop: SupportsIndex) -> bytes: ...  # type: ignore[override]
+    def __setslice__(self, start: SupportsIndex, stop: SupportsIndex, values: bytes) -> None: ...  # type: ignore[override]
 
     value: bytes
     raw: bytes

stdlib/sqlite3/__init__.pyi

@@ -435,10 +435,10 @@ class PrepareProtocol:
 class Row(Sequence[Any]):
     def __new__(cls, cursor: Cursor, data: tuple[Any, ...], /) -> Self: ...
     def keys(self) -> list[str]: ...
-    @overload
+    @overload  # Note: really needs int instead of SupportsIndex
     def __getitem__(self, key: int | str, /) -> Any: ...
-    @overload
-    def __getitem__(self, key: slice, /) -> tuple[Any, ...]: ...
+    @overload  # Note: SupportsIndex does work within slices.
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> tuple[Any, ...]: ...
     def __hash__(self) -> int: ...
     def __iter__(self) -> Iterator[Any]: ...
     def __len__(self) -> int: ...

stdlib/traceback.pyi

@@ -2,7 +2,7 @@ import sys
 from _typeshed import SupportsWrite, Unused
 from collections.abc import Generator, Iterable, Iterator, Mapping
 from types import FrameType, TracebackType
-from typing import Any, ClassVar, Literal, overload
+from typing import Any, ClassVar, Literal, SupportsIndex, overload
 from typing_extensions import Self, TypeAlias, deprecated
 
 __all__ = [
@@ -288,9 +288,9 @@ class FrameSummary:
     @overload
     def __getitem__(self, pos: Literal[3]) -> str | None: ...
     @overload
-    def __getitem__(self, pos: int) -> Any: ...
+    def __getitem__(self, pos: SupportsIndex) -> Any: ...
     @overload
-    def __getitem__(self, pos: slice) -> tuple[Any, ...]: ...
+    def __getitem__(self, pos: slice[SupportsIndex | None]) -> tuple[Any, ...]: ...
     def __iter__(self) -> Iterator[Any]: ...
     def __eq__(self, other: object) -> bool: ...
     def __len__(self) -> Literal[4]: ...

stdlib/tracemalloc.pyi

@@ -90,7 +90,7 @@ class Traceback(Sequence[Frame]):
     @overload
     def __getitem__(self, index: SupportsIndex) -> Frame: ...
     @overload
-    def __getitem__(self, index: slice) -> Sequence[Frame]: ...
+    def __getitem__(self, index: slice[SupportsIndex | None]) -> Sequence[Frame]: ...
     def __contains__(self, frame: Frame) -> bool: ...  # type: ignore[override]
     def __len__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...

stdlib/typing.pyi

@@ -633,7 +633,7 @@ class Sequence(Reversible[_T_co], Collection[_T_co]):
     def __getitem__(self, index: int) -> _T_co: ...
     @overload
     @abstractmethod
-    def __getitem__(self, index: slice) -> Sequence[_T_co]: ...
+    def __getitem__(self, index: slice[int | None]) -> Sequence[_T_co]: ...
     # Mixin methods
     def index(self, value: Any, start: int = 0, stop: int = ...) -> int: ...
     def count(self, value: Any) -> int: ...
@@ -649,19 +649,19 @@ class MutableSequence(Sequence[_T]):
     def __getitem__(self, index: int) -> _T: ...
     @overload
     @abstractmethod
-    def __getitem__(self, index: slice) -> MutableSequence[_T]: ...
+    def __getitem__(self, index: slice[int | None]) -> MutableSequence[_T]: ...
     @overload
     @abstractmethod
     def __setitem__(self, index: int, value: _T) -> None: ...
     @overload
     @abstractmethod
-    def __setitem__(self, index: slice, value: Iterable[_T]) -> None: ...
+    def __setitem__(self, index: slice[int | None], value: Iterable[_T]) -> None: ...
     @overload
     @abstractmethod
     def __delitem__(self, index: int) -> None: ...
     @overload
     @abstractmethod
-    def __delitem__(self, index: slice) -> None: ...
+    def __delitem__(self, index: slice[int | None]) -> None: ...
     # Mixin methods
     def append(self, value: _T) -> None: ...
     def clear(self) -> None: ...