Specialize plain slice type hints (#13007)

stdlib/_ctypes.pyi

@@ -6,7 +6,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, Final, Generic, Literal, TypeVar, final, overload, type_check_only
+from typing import Any, ClassVar, Final, Generic, Literal, SupportsIndex, TypeVar, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
 _T = TypeVar("_T")
@@ -134,7 +134,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):
@@ -342,11 +342,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

@@ -80,20 +80,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

@@ -300,7 +300,7 @@ 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: ...
@@ -308,7 +308,7 @@ class IndexableBuffer(Buffer, Protocol):
 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

@@ -80,12 +80,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

@@ -633,9 +633,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
@@ -746,7 +746,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: ...
@@ -856,12 +856,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]
@@ -933,14 +933,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):
@@ -1047,7 +1047,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: ...
@@ -1147,12 +1147,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]: ...
@@ -1352,7 +1352,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]: ...
 
 @disjoint_base

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,7 +97,7 @@ 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: ...
 
 if sys.version_info >= (3, 12):
@@ -105,7 +105,7 @@ if sys.version_info >= (3, 12):
         @overload
         def __getitem__(self, key: SupportsIndex) -> Any: ...
         @overload
-        def __getitem__(self, key: slice) -> Any: ...
+        def __getitem__(self, key: slice[SupportsIndex | None]) -> Any: ...
 
 else:
     @disjoint_base
@@ -113,7 +113,7 @@ else:
         @overload
         def __getitem__(self, key: SupportsIndex) -> Any: ...
         @overload
-        def __getitem__(self, key: slice) -> Any: ...
+        def __getitem__(self, key: slice[SupportsIndex | None]) -> Any: ...
 
 class BaseConfigurator:
     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, disjoint_base
 
 ACCESS_DEFAULT: Final = 0
@@ -77,14 +77,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

@@ -172,15 +172,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, type_check_only
+from typing import Any, Generic, Literal, Protocol, SupportsIndex, TypeVar, overload, type_check_only
 
 __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

@@ -443,10 +443,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__ = [
@@ -305,9 +305,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

@@ -95,7 +95,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

@@ -658,7 +658,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: ...
@@ -674,19 +674,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: ...

stdlib/xml/etree/ElementTree.pyi

@@ -123,14 +123,14 @@ class Element(Generic[_Tag]):
     @overload
     def __getitem__(self, key: SupportsIndex, /) -> Element: ...
     @overload
-    def __getitem__(self, key: slice, /) -> list[Element]: ...
+    def __getitem__(self, key: slice[SupportsIndex | None], /) -> list[Element]: ...
     def __len__(self) -> int: ...
     # Doesn't actually exist at runtime, but instance of the class are indeed iterable due to __getitem__.
     def __iter__(self) -> Iterator[Element]: ...
     @overload
     def __setitem__(self, key: SupportsIndex, value: Element[Any], /) -> None: ...
     @overload
-    def __setitem__(self, key: slice, value: Iterable[Element[Any]], /) -> None: ...
+    def __setitem__(self, key: slice[SupportsIndex | None], value: Iterable[Element[Any]], /) -> None: ...
 
     # Doesn't really exist in earlier versions, where __len__ is called implicitly instead
     @deprecated("Testing an element's truth value is deprecated.")