collections: make UserDict, UserList, and UserString concrete (#1477)

* collections: make UserDict, UserList, and UserString concrete

* add version checks

573b44c18f

* remove redundant methods

stdlib/3/collections/__init__.pyi

@@ -59,9 +59,128 @@ else:
     def namedtuple(typename: str, field_names: Union[str, Iterable[str]],
                    verbose: bool = ..., rename: bool = ...) -> Type[tuple]: ...
 
-class UserDict(MutableMapping): ...
-class UserList(MutableSequence): ...
-class UserString(Sequence): ...
+_UserDictT = TypeVar('_UserDictT', bound=UserDict)
+
+class UserDict(MutableMapping[_KT, _VT]):
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _KT) -> _VT: ...
+    def __setitem__(self, key: _KT, item: _VT) -> None: ...
+    def __delitem__(self, key: _KT) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __contains__(self, key: object) -> bool: ...
+    def copy(self: _UserDictT) -> _UserDictT: ...
+    @classmethod
+    def fromkeys(cls: Type[_UserDictT], iterable: Iterable[_KT], value: Optional[_VT] = ...) -> _UserDictT: ...
+
+_UserListT = TypeVar('_UserListT', bound=UserList)
+
+class UserList(MutableSequence[_T]):
+    def __init__(self, initlist: Optional[Iterable[_T]] = ...) -> None: ...
+    def __lt__(self, other: object) -> bool: ...
+    def __le__(self, other: object) -> bool: ...
+    def __gt__(self, other: object) -> bool: ...
+    def __ge__(self, other: object) -> bool: ...
+    def __contains__(self, item: object) -> bool: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, i: slice) -> Sequence[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, i: slice, o: Iterable[_T]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    def __add__(self: _UserListT, other: Iterable[_T]) -> _UserListT: ...
+    def __iadd__(self: _UserListT, other: Iterable[_T]) -> _UserListT: ...
+    def __mul__(self: _UserListT, n: int) -> _UserListT: ...
+    def __imul__(self: _UserListT, n: int) -> _UserListT: ...
+    def append(self, item: _T) -> None: ...
+    def insert(self, i: int, item: _T) -> None: ...
+    def pop(self, i: int = ...) -> _T: ...
+    def remove(self, item: _T) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self: _UserListT) -> _UserListT: ...
+    def count(self, item: _T) -> int: ...
+    def index(self, item: _T, *args: Any) -> int: ...
+    def reverse(self) -> None: ...
+    def sort(self, *args: Any, **kwds: Any) -> None: ...
+    def extend(self, other: Iterable[_T]) -> None: ...
+
+_UserStringT = TypeVar('_UserStringT', bound=UserString)
+
+class UserString(Sequence[str]):
+    def __init__(self, seq: object) -> None: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __complex__(self) -> complex: ...
+    if sys.version_info >= (3, 5):
+        def __getnewargs__(self) -> Tuple[str]: ...
+    def __lt__(self, string: Union[str, UserString]) -> bool: ...
+    def __le__(self, string: Union[str, UserString]) -> bool: ...
+    def __gt__(self, string: Union[str, UserString]) -> bool: ...
+    def __ge__(self, string: Union[str, UserString]) -> bool: ...
+    def __contains__(self, char: object) -> bool: ...
+    def __len__(self) -> int: ...
+    # It should return a str to implement Sequence correctly, but it doesn't.
+    def __getitem__(self: _UserStringT, i: Union[int, slice]) -> _UserStringT: ...  # type: ignore
+    def __add__(self: _UserStringT, other: object) -> _UserStringT: ...
+    def __mul__(self: _UserStringT, n: int) -> _UserStringT: ...
+    def __mod__(self: _UserStringT, args: Any) -> _UserStringT: ...
+    def capitalize(self: _UserStringT) -> _UserStringT: ...
+    if sys.version_info >= (3, 5):
+        def casefold(self: _UserStringT) -> _UserStringT: ...
+    def center(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
+    def count(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UserStringT: ...
+    def endswith(self, suffix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ...
+    def expandtabs(self: _UserStringT, tabsize: int = ...) -> _UserStringT: ...
+    def find(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def format(self, *args: Any, **kwds: Any) -> str: ...
+    if sys.version_info >= (3, 5):
+        def format_map(self, mapping: Mapping[str, Any]) -> str: ...
+    def index(self, sub: str, start: int = ..., end: int = ...) -> int: ...
+    def isalpha(self) -> bool: ...
+    def isalnum(self) -> bool: ...
+    def isdecimal(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def isidentifier(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isnumeric(self) -> bool: ...
+    if sys.version_info >= (3, 5):
+        def isprintable(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, seq: Iterable[str]) -> str: ...
+    def ljust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
+    def lower(self: _UserStringT) -> _UserStringT: ...
+    def lstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
+    if sys.version_info >= (3, 5):
+        @staticmethod
+        @overload
+        def maketrans(x: Union[Dict[int, Any], Dict[str, Any]]) -> Dict[int, Any]: ...
+        @staticmethod
+        @overload
+        def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Any]: ...
+    def partition(self, sep: str) -> Tuple[str, str, str]: ...
+    def replace(self: _UserStringT, old: Union[str, UserString], new: Union[str, UserString], maxsplit: int = ...) -> _UserStringT: ...
+    def rfind(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def rindex(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def rjust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
+    def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
+    def rstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
+    def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    def splitlines(self, keepends: bool = ...) -> List[str]: ...
+    def startswith(self, prefix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ...
+    def strip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
+    def swapcase(self: _UserStringT) -> _UserStringT: ...
+    def title(self: _UserStringT) -> _UserStringT: ...
+    def translate(self: _UserStringT, *args: Any) -> _UserStringT: ...
+    def upper(self: _UserStringT) -> _UserStringT: ...
+    def zfill(self: _UserStringT, width: int) -> _UserStringT: ...
+
 
 # Technically, deque only derives from MutableSequence in 3.5.
 # But in practice it's not worth losing sleep over.