Merge branch 'master' into fix-typeis-for-types-with-type-params-in-unions

Author: kreathon

mypy/checker.py

@@ -26,7 +26,7 @@
 from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.checkexpr
-from mypy import errorcodes as codes, message_registry, nodes, operators
+from mypy import errorcodes as codes, join, message_registry, nodes, operators
 from mypy.binder import ConditionalTypeBinder, Frame, get_declaration
 from mypy.checkmember import (
     MemberContext,
@@ -699,6 +699,21 @@ def extract_callable_type(self, inner_type: Type | None, ctx: Context) -> Callab
                 )
                 if isinstance(inner_call, CallableType):
                     outer_type = inner_call
+            elif isinstance(inner_type, UnionType):
+                union_type = make_simplified_union(inner_type.items)
+                if isinstance(union_type, UnionType):
+                    items = []
+                    for item in union_type.items:
+                        callable_item = self.extract_callable_type(item, ctx)
+                        if callable_item is None:
+                            break
+                        items.append(callable_item)
+                    else:
+                        joined_type = get_proper_type(join.join_type_list(items))
+                        if isinstance(joined_type, CallableType):
+                            outer_type = joined_type
+                else:
+                    return self.extract_callable_type(union_type, ctx)
             if outer_type is None:
                 self.msg.not_callable(inner_type, ctx)
         return outer_type

mypy/checkmember.py

@@ -654,7 +654,7 @@ def analyze_descriptor_access(descriptor_type: Type, mx: MemberContext) -> Type:
                 analyze_descriptor_access(
                     descriptor_type, mx.copy_modified(original_type=original_type)
                 )
-                for original_type in instance_type.items
+                for original_type in instance_type.relevant_items()
             ]
         )
     elif not isinstance(descriptor_type, Instance):

mypy/join.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import overload
+from typing import Sequence, overload
 
 import mypy.typeops
 from mypy.maptype import map_instance_to_supertype
@@ -853,7 +853,7 @@ def object_or_any_from_type(typ: ProperType) -> ProperType:
     return AnyType(TypeOfAny.implementation_artifact)
 
 
-def join_type_list(types: list[Type]) -> Type:
+def join_type_list(types: Sequence[Type]) -> Type:
     if not types:
         # This is a little arbitrary but reasonable. Any empty tuple should be compatible
         # with all variable length tuples, and this makes it possible.

mypy/stubgenc.py

@@ -466,6 +466,9 @@ def is_skipped_attribute(self, attr: str) -> bool:
                 "__module__",
                 "__weakref__",
                 "__annotations__",
+                "__firstlineno__",
+                "__static_attributes__",
+                "__annotate__",
             )
             or attr in self.IGNORED_DUNDERS
             or is_pybind_skipped_attribute(attr)  # For pickling

test-data/unit/check-functools.test

@@ -324,3 +324,25 @@ p(bar, 1, "a", 3.0)  # OK
 p(bar, 1, "a", 3.0, kwarg="asdf")  # OK
 p(bar, 1, "a", "b")  # E: Argument 1 to "foo" has incompatible type "Callable[[int, str, float], None]"; expected "Callable[[int, str, str], None]"
 [builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialUnion]
+import functools
+from typing import Any, Callable, Union
+
+cls1: Any
+cls2: Union[Any, Any]
+reveal_type(functools.partial(cls1, 2)())  # N: Revealed type is "Any"
+reveal_type(functools.partial(cls2, 2)())  # N: Revealed type is "Any"
+
+fn1: Union[Callable[[int], int], Callable[[int], int]]
+reveal_type(functools.partial(fn1, 2)())  # N: Revealed type is "builtins.int"
+
+fn2: Union[Callable[[int], int], Callable[[int], str]]
+reveal_type(functools.partial(fn2, 2)())  # N: Revealed type is "builtins.object"
+
+fn3: Union[Callable[[int], int], str]
+reveal_type(functools.partial(fn3, 2)())  # E: "str" not callable \
+                                          # E: "Union[Callable[[int], int], str]" not callable \
+                                          # N: Revealed type is "builtins.int" \
+                                          # E: Argument 1 to "partial" has incompatible type "Union[Callable[[int], int], str]"; expected "Callable[..., int]"
+[builtins fixtures/tuple.pyi]

test-data/unit/check-unions.test

@@ -1258,3 +1258,34 @@ reveal_type(mix)  # N: Revealed type is "Union[Type[__main__.A], Type[__main__.B
 reveal_type(mix.field_1)  # N: Revealed type is "builtins.list[builtins.int]"
 reveal_type(mix().field_1)  # N: Revealed type is "builtins.int"
 [builtins fixtures/list.pyi]
+
+
+[case testDescriptorAccessForUnionOfTypesWithNoStrictOptional]
+# mypy: no-strict-optional
+from typing import overload, Generic, Any, TypeVar, List, Optional, Union, Type
+
+class Descriptor:
+    @overload
+    def __get__(
+        self, instance: None, owner: type
+    ) -> str:
+        ...
+
+    @overload
+    def __get__(self, instance: object, owner: type) -> int:
+        ...
+
+    def __get__(
+        self, instance: Optional[object], owner: type
+    ) -> Union[str, int]:
+        ...
+
+class A:
+    field = Descriptor()
+
+a_class_or_none: Optional[Type[A]]
+x: str = a_class_or_none.field
+
+a_or_none: Optional[A]
+y: int = a_or_none.field
+[builtins fixtures/list.pyi]