Add regression tests for builtins.pow and object.__reduce__

pyrightconfig.json

@@ -2,7 +2,8 @@
     "typeshedPath": ".",
     "include": [
         "stdlib",
-        "stubs"
+        "stubs",
+        "test_cases"
     ],
     "exclude": [
         "**/@python2"

pyrightconfig.stricter.json

@@ -3,7 +3,8 @@
     "typeshedPath": ".",
     "include": [
         "stdlib",
-        "stubs"
+        "stubs",
+        "test_cases"
     ],
     "exclude": [
         "**/@python2",

stdlib/builtins.pyi

@@ -101,8 +101,6 @@ class object:
     def __format__(self, __format_spec: str) -> str: ...
     def __getattribute__(self, __name: str) -> Any: ...
     def __sizeof__(self) -> int: ...
-    # return type of pickle methods is rather hard to express in the current type system
-    # see #6661 and https://docs.python.org/3/library/pickle.html#object.__reduce__
     def __reduce__(self) -> str | tuple[Any, ...]: ...
     if sys.version_info >= (3, 8):
         def __reduce_ex__(self, __protocol: SupportsIndex) -> str | tuple[Any, ...]: ...
@@ -260,8 +258,6 @@ class int:
     def __pow__(self, __x: _PositiveInteger, __modulo: None = ...) -> int: ...
     @overload
     def __pow__(self, __x: _NegativeInteger, __modulo: None = ...) -> float: ...
-    # positive x -> int; negative x -> float
-    # return type must be Any as `int | float` causes too many false-positive errors
     @overload
     def __pow__(self, __x: int, __modulo: None = ...) -> Any: ...
     def __rpow__(self, __x: int, __mod: int | None = ...) -> Any: ...
@@ -317,8 +313,6 @@ class float:
     def __divmod__(self, __x: float) -> tuple[float, float]: ...
     @overload
     def __pow__(self, __x: int, __mod: None = ...) -> float: ...
-    # positive x -> float; negative x -> complex
-    # return type must be Any as `float | complex` causes too many false-positive errors
     @overload
     def __pow__(self, __x: float, __mod: None = ...) -> Any: ...
     def __radd__(self, __x: float) -> float: ...
@@ -328,7 +322,6 @@ class float:
     def __rtruediv__(self, __x: float) -> float: ...
     def __rmod__(self, __x: float) -> float: ...
     def __rdivmod__(self, __x: float) -> tuple[float, float]: ...
-    # Returns complex if the argument is negative.
     def __rpow__(self, __x: float, __mod: None = ...) -> Any: ...
     def __getnewargs__(self) -> tuple[float]: ...
     def __trunc__(self) -> int: ...
@@ -1418,15 +1411,10 @@ if sys.version_info >= (3, 8):
     def pow(base: int, exp: _PositiveInteger, mod: None = ...) -> int: ...  # type: ignore[misc]
     @overload
     def pow(base: int, exp: _NegativeInteger, mod: None = ...) -> float: ...  # type: ignore[misc]
-    # int base & positive-int exp -> int; int base & negative-int exp -> float
-    # return type must be Any as `int | float` causes too many false-positive errors
     @overload
     def pow(base: int, exp: int, mod: None = ...) -> Any: ...
     @overload
     def pow(base: float, exp: int, mod: None = ...) -> float: ...
-    # float base & float exp could return float or complex
-    # return type must be Any (same as complex base, complex exp),
-    # as `float | complex` causes too many false-positive errors
     @overload
     def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = ...) -> Any: ...
     @overload

test_cases/README.md

@@ -0,0 +1,27 @@
+## Regression tests for typeshed
+
+This directory contains regression tests for the stubs found elsewhere in the
+typeshed repo. Each file contains a number of test cases, all of which should
+pass a type checker without error.
+
+The internal structure of this directory should mimic typeshed as a whole.
+However, unlike the rest of typeshed, this directory largely contains `.py`
+files. This is because the purpose of this folder is to test the implications
+of typeshed changes for end users. For example, the stub for `builtins.pow` is
+found in `stdlib/builtins.pyi`, and the regression tests for `pow` are found in
+`test_cases/stdlib/test_builtins.py`.
+
+100% test coverage for typeshed is neither necessary nor desirable, as it would
+lead to unnecessary code duplication. Moreover, typeshed has multiple other
+mechanisms for spotting errors in the stubs. As such, this directory should
+only contain tests for functions and classes which are known to have caused
+problems in the past, where the stubs are difficult to get right.
+
+Note that, unlike elsewhere in typeshed, the test cases in this directory
+cannot always use modern syntax for type hints. For example, PEP 604 syntax
+(unions with a pipe `|` operator) is new in Python 3.10. While this syntax can
+be used on older Python versions in a `.pyi` file, code using this syntax will
+fail at runtime on Python <=3.9. Since the test cases all use `.py` extensions,
+and since the tests need to pass on all Python versions >=3.6, PEP 604 syntax
+cannot be used in a test case. Use `typing.Union` and `typing.Optional`
+instead.

test_cases/stdlib/test_builtins.py

@@ -0,0 +1,56 @@
+from decimal import Decimal
+from fractions import Fraction
+from typing import Any, NoReturn, Tuple, Union
+from typing_extensions import Literal, assert_type
+
+
+#
+# REGRESSION TESTS FOR OBJECT.__REDUCE__
+#
+# The following should pass without error (see #6661):
+class Diagnostic:
+    def __reduce__(self) -> Union[str, Tuple[Any, ...]]:
+        res = super().__reduce__()
+        if isinstance(res, tuple) and len(res) >= 3:
+            res[2]["_info"] = 42
+
+        return res
+
+
+#
+# REGRESSION TESTS FOR POW()
+#
+assert_type(pow(1, 0), Literal[1])  # See #7163
+assert_type(pow(1, 0, None), Literal[1])  # See #7163
+assert_type(pow(2, 4, 0), NoReturn)
+assert_type(pow(2, 4), int)
+assert_type(pow(5, -7), float)
+assert_type(pow(2, 4, 5), int)  # pow(<smallint>, <smallint>, <smallint>)
+assert_type(pow(2, 35, 3), int)  # pow(<smallint>, <bigint>, <smallint>)
+assert_type(pow(4.6, 8), float)
+assert_type(pow(5.1, 4, None), float)
+assert_type(pow(complex(6), 6.2), complex)
+assert_type(pow(complex(9), 7.3, None), complex)
+assert_type(pow(Fraction(), 4, None), Fraction)
+assert_type(pow(Fraction(3, 7), complex(1, 8)), complex)
+assert_type(pow(complex(4, -8), Fraction(2, 3)), complex)
+assert_type(pow(Decimal("1.0"), Decimal("1.6")), Decimal)
+assert_type(pow(Decimal("1.0"), Decimal("1.0"), Decimal("1.0")), Decimal)
+assert_type(pow(Decimal("4.6"), 7, None), Decimal)
+assert_type((4).__pow__(7, 4), int)
+assert_type((4).__pow__(6, None), int)
+assert_type(complex(9).__pow__(3.1, None), complex)
+assert_type(Decimal("2.6").__pow__(5, None), Decimal)
+
+# These would ideally be more precise, but `Any` is acceptable
+# They have to be `Any` due to the fact that type-checkers can't distinguish between positive and negative numbers for the second argument to `pow()`
+#
+# int for positive 2nd-arg, float otherwise
+assert_type(pow(4, 65), Any)
+assert_type(pow(3, 57, None), Any)
+# float for positive 2nd-arg, complex otherwise
+assert_type(pow(4.7, 7.4), Any)
+assert_type(pow(4.7, 9.2, None), Any)
+assert_type((6.2).__pow__(5.2, None), Any)
+# See #7046 -- float for a positive 1st arg, complex otherwise
+assert_type((-2) ** 0.5, Any)