Merge branch 'master' into fix-3-arg-range

Author: BobTheBuidler

.github/workflows/test_stubgenc.yml

@@ -11,7 +11,7 @@ on:
     - 'mypy/stubgenc.py'
     - 'mypy/stubdoc.py'
     - 'mypy/stubutil.py'
-    - 'test-data/stubgen/**'
+    - 'test-data/pybind11_fixtures/**'
 
 permissions:
   contents: read

mypy/checker.py

@@ -7905,6 +7905,10 @@ def is_writable_attribute(self, node: Node) -> bool:
         return False
 
     def get_isinstance_type(self, expr: Expression) -> list[TypeRange] | None:
+        """Get the type(s) resulting from an isinstance check.
+
+        Returns an empty list for isinstance(x, ()).
+        """
         if isinstance(expr, OpExpr) and expr.op == "|":
             left = self.get_isinstance_type(expr.left)
             if left is None and is_literal_none(expr.left):
@@ -7944,11 +7948,6 @@ def get_isinstance_type(self, expr: Expression) -> list[TypeRange] | None:
                 types.append(TypeRange(typ, is_upper_bound=False))
             else:  # we didn't see an actual type, but rather a variable with unknown value
                 return None
-        if not types:
-            # this can happen if someone has empty tuple as 2nd argument to isinstance
-            # strictly speaking, we should return UninhabitedType but for simplicity we will simply
-            # refuse to do any type inference for now
-            return None
         return types
 
     def is_literal_enum(self, n: Expression) -> bool:
@@ -8185,59 +8184,82 @@ def conditional_types(
         UninhabitedType means unreachable.
         None means no new information can be inferred.
     """
-    if proposed_type_ranges:
-        if len(proposed_type_ranges) == 1:
-            target = proposed_type_ranges[0].item
-            target = get_proper_type(target)
-            if isinstance(target, LiteralType) and (
-                target.is_enum_literal() or isinstance(target.value, bool)
-            ):
-                enum_name = target.fallback.type.fullname
-                current_type = try_expanding_sum_type_to_union(current_type, enum_name)
-        proposed_items = [type_range.item for type_range in proposed_type_ranges]
-        proposed_type = make_simplified_union(proposed_items)
-        if isinstance(get_proper_type(current_type), AnyType):
-            return proposed_type, current_type
-        elif isinstance(proposed_type, AnyType):
-            # We don't really know much about the proposed type, so we shouldn't
-            # attempt to narrow anything. Instead, we broaden the expr to Any to
-            # avoid false positives
-            return proposed_type, default
-        elif not any(type_range.is_upper_bound for type_range in proposed_type_ranges) and (
-            # concrete subtypes
-            is_proper_subtype(current_type, proposed_type, ignore_promotions=True)
-            # structural subtypes
-            or (
-                (
-                    isinstance(proposed_type, CallableType)
-                    or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
-                )
-                and is_subtype(current_type, proposed_type, ignore_promotions=True)
-            )
+    if proposed_type_ranges is None:
+        # An isinstance check, but we don't understand the type
+        return current_type, default
+
+    if not proposed_type_ranges:
+        # This is the case for `if isinstance(x, ())` which always returns False.
+        return UninhabitedType(), default
+
+    if len(proposed_type_ranges) == 1:
+        # expand e.g. bool -> Literal[True] | Literal[False]
+        target = proposed_type_ranges[0].item
+        target = get_proper_type(target)
+        if isinstance(target, LiteralType) and (
+            target.is_enum_literal() or isinstance(target.value, bool)
         ):
-            # Expression is always of one of the types in proposed_type_ranges
-            return default, UninhabitedType()
-        elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
-            # Expression is never of any type in proposed_type_ranges
-            return UninhabitedType(), default
-        else:
-            # we can only restrict when the type is precise, not bounded
-            proposed_precise_type = UnionType.make_union(
-                [
-                    type_range.item
-                    for type_range in proposed_type_ranges
-                    if not type_range.is_upper_bound
-                ]
-            )
-            remaining_type = restrict_subtype_away(
-                current_type,
-                proposed_precise_type,
+            enum_name = target.fallback.type.fullname
+            current_type = try_expanding_sum_type_to_union(current_type, enum_name)
+
+    proper_type = get_proper_type(current_type)
+    # factorize over union types: isinstance(A|B, C) -> yes = A_yes | B_yes
+    if isinstance(proper_type, UnionType):
+        result: list[tuple[Type | None, Type | None]] = [
+            conditional_types(
+                union_item,
+                proposed_type_ranges,
+                default=union_item,
                 consider_runtime_isinstance=consider_runtime_isinstance,
             )
-            return proposed_type, remaining_type
+            for union_item in get_proper_types(proper_type.items)
+        ]
+        # separate list of tuples into two lists
+        yes_types, no_types = zip(*result)
+        proposed_type = make_simplified_union([t for t in yes_types if t is not None])
     else:
-        # An isinstance check, but we don't understand the type
-        return current_type, default
+        proposed_items = [type_range.item for type_range in proposed_type_ranges]
+        proposed_type = make_simplified_union(proposed_items)
+
+    if isinstance(proper_type, AnyType):
+        return proposed_type, current_type
+    elif isinstance(proposed_type, AnyType):
+        # We don't really know much about the proposed type, so we shouldn't
+        # attempt to narrow anything. Instead, we broaden the expr to Any to
+        # avoid false positives
+        return proposed_type, default
+    elif not any(type_range.is_upper_bound for type_range in proposed_type_ranges) and (
+        # concrete subtypes
+        is_proper_subtype(current_type, proposed_type, ignore_promotions=True)
+        # structural subtypes
+        or (
+            (
+                isinstance(proposed_type, CallableType)
+                or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
+            )
+            and is_subtype(current_type, proposed_type, ignore_promotions=True)
+        )
+    ):
+        # Expression is always of one of the types in proposed_type_ranges
+        return default, UninhabitedType()
+    elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
+        # Expression is never of any type in proposed_type_ranges
+        return UninhabitedType(), default
+    else:
+        # we can only restrict when the type is precise, not bounded
+        proposed_precise_type = UnionType.make_union(
+            [
+                type_range.item
+                for type_range in proposed_type_ranges
+                if not type_range.is_upper_bound
+            ]
+        )
+        remaining_type = restrict_subtype_away(
+            current_type,
+            proposed_precise_type,
+            consider_runtime_isinstance=consider_runtime_isinstance,
+        )
+        return proposed_type, remaining_type
 
 
 def conditional_types_to_typemaps(

test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/__init__.pyi

@@ -1,17 +1,18 @@
-import os
+import pathlib
+import typing
 from . import demo as demo
 from typing import overload
 
 class StaticMethods:
     def __init__(self, *args, **kwargs) -> None: ...
     @overload
     @staticmethod
-    def overloaded_static_method(value: int) -> int: ...
+    def overloaded_static_method(value: typing.SupportsInt) -> int: ...
     @overload
     @staticmethod
-    def overloaded_static_method(value: float) -> float: ...
+    def overloaded_static_method(value: typing.SupportsFloat) -> float: ...
     @staticmethod
-    def some_static_method(a: int, b: int) -> int: ...
+    def some_static_method(a: typing.SupportsInt, b: typing.SupportsInt) -> int: ...
 
 class TestStruct:
     field_readwrite: int
@@ -23,5 +24,5 @@ class TestStruct:
 def func_incomplete_signature(*args, **kwargs): ...
 def func_returning_optional() -> int | None: ...
 def func_returning_pair() -> tuple[int, float]: ...
-def func_returning_path() -> os.PathLike: ...
+def func_returning_path() -> pathlib.Path: ...
 def func_returning_vector() -> list[float]: ...

test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/demo.pyi

@@ -1,3 +1,4 @@
+import typing
 from typing import ClassVar, overload
 
 PI: float
@@ -9,7 +10,7 @@ class Point:
         __entries: ClassVar[dict] = ...
         degree: ClassVar[Point.AngleUnit] = ...
         radian: ClassVar[Point.AngleUnit] = ...
-        def __init__(self, value: int) -> None: ...
+        def __init__(self, value: typing.SupportsInt) -> None: ...
         def __eq__(self, other: object) -> bool: ...
         def __hash__(self) -> int: ...
         def __index__(self) -> int: ...
@@ -26,7 +27,7 @@ class Point:
         inch: ClassVar[Point.LengthUnit] = ...
         mm: ClassVar[Point.LengthUnit] = ...
         pixel: ClassVar[Point.LengthUnit] = ...
-        def __init__(self, value: int) -> None: ...
+        def __init__(self, value: typing.SupportsInt) -> None: ...
         def __eq__(self, other: object) -> bool: ...
         def __hash__(self) -> int: ...
         def __index__(self) -> int: ...
@@ -46,16 +47,16 @@ class Point:
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self, x: float, y: float) -> None: ...
+    def __init__(self, x: typing.SupportsFloat, y: typing.SupportsFloat) -> None: ...
     def as_list(self) -> list[float]: ...
     @overload
-    def distance_to(self, x: float, y: float) -> float: ...
+    def distance_to(self, x: typing.SupportsFloat, y: typing.SupportsFloat) -> float: ...
     @overload
     def distance_to(self, other: Point) -> float: ...
     @property
     def length(self) -> float: ...
 
 def answer() -> int: ...
-def midpoint(left: float, right: float) -> float: ...
-def sum(arg0: int, arg1: int) -> int: ...
-def weighted_midpoint(left: float, right: float, alpha: float = ...) -> float: ...
+def midpoint(left: typing.SupportsFloat, right: typing.SupportsFloat) -> float: ...
+def sum(arg0: typing.SupportsInt, arg1: typing.SupportsInt) -> int: ...
+def weighted_midpoint(left: typing.SupportsFloat, right: typing.SupportsFloat, alpha: typing.SupportsFloat = ...) -> float: ...

test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/__init__.pyi

@@ -1,4 +1,5 @@
-import os
+import pathlib
+import typing
 from . import demo as demo
 from typing import overload
 
@@ -7,27 +8,27 @@ class StaticMethods:
         """Initialize self.  See help(type(self)) for accurate signature."""
     @overload
     @staticmethod
-    def overloaded_static_method(value: int) -> int:
+    def overloaded_static_method(value: typing.SupportsInt) -> int:
         """overloaded_static_method(*args, **kwargs)
         Overloaded function.
 
-        1. overloaded_static_method(value: int) -> int
+        1. overloaded_static_method(value: typing.SupportsInt) -> int
 
-        2. overloaded_static_method(value: float) -> float
+        2. overloaded_static_method(value: typing.SupportsFloat) -> float
         """
     @overload
     @staticmethod
-    def overloaded_static_method(value: float) -> float:
+    def overloaded_static_method(value: typing.SupportsFloat) -> float:
         """overloaded_static_method(*args, **kwargs)
         Overloaded function.
 
-        1. overloaded_static_method(value: int) -> int
+        1. overloaded_static_method(value: typing.SupportsInt) -> int
 
-        2. overloaded_static_method(value: float) -> float
+        2. overloaded_static_method(value: typing.SupportsFloat) -> float
         """
     @staticmethod
-    def some_static_method(a: int, b: int) -> int:
-        """some_static_method(a: int, b: int) -> int
+    def some_static_method(a: typing.SupportsInt, b: typing.SupportsInt) -> int:
+        """some_static_method(a: typing.SupportsInt, b: typing.SupportsInt) -> int
 
         None
         """
@@ -46,10 +47,10 @@ class TestStruct:
 def func_incomplete_signature(*args, **kwargs):
     """func_incomplete_signature() -> dummy_sub_namespace::HasNoBinding"""
 def func_returning_optional() -> int | None:
-    """func_returning_optional() -> Optional[int]"""
+    """func_returning_optional() -> int | None"""
 def func_returning_pair() -> tuple[int, float]:
-    """func_returning_pair() -> Tuple[int, float]"""
-def func_returning_path() -> os.PathLike:
-    """func_returning_path() -> os.PathLike"""
+    """func_returning_pair() -> tuple[int, float]"""
+def func_returning_path() -> pathlib.Path:
+    """func_returning_path() -> pathlib.Path"""
 def func_returning_vector() -> list[float]:
-    """func_returning_vector() -> List[float]"""
+    """func_returning_vector() -> list[float]"""