Merge branch 'master' into literals_as_anyof_types

Author: randolf-scholz

mypy/checker.py

@@ -2526,8 +2526,6 @@ def check_argument_types(
 
         The check_call docstring describes some of the arguments.
         """
-        if self.chk.can_skip_diagnostics:
-            return
         self.check_var_args_kwargs(arg_types, arg_kinds, context)
 
         check_arg = check_arg or self.check_arg
@@ -4288,29 +4286,32 @@ def check_boolean_op(self, e: OpExpr) -> Type:
 
         assert e.op in ("and", "or")  # Checked by visit_op_expr
 
+        left_map: mypy.checker.TypeMap
+        right_map: mypy.checker.TypeMap
         if e.right_always:
-            left_map: mypy.checker.TypeMap = None
-            right_map: mypy.checker.TypeMap = {}
+            left_map, right_map = {e.left: UninhabitedType()}, {}
         elif e.right_unreachable:
-            left_map, right_map = {}, None
+            left_map, right_map = {}, {e.right: UninhabitedType()}
         elif e.op == "and":
             right_map, left_map = self.chk.find_isinstance_check(e.left)
         elif e.op == "or":
             left_map, right_map = self.chk.find_isinstance_check(e.left)
 
-        # If left_map is None then we know mypy considers the left expression
+        # If left_map is unreachable then we know mypy considers the left expression
         # to be redundant.
+        left_unreachable = mypy.checker.is_unreachable_map(left_map)
         if (
             codes.REDUNDANT_EXPR in self.chk.options.enabled_error_codes
-            and left_map is None
+            and left_unreachable
             # don't report an error if it's intentional
             and not e.right_always
         ):
             self.msg.redundant_left_operand(e.op, e.left)
 
+        right_unreachable = mypy.checker.is_unreachable_map(right_map)
         if (
             self.chk.should_report_unreachable_issues()
-            and right_map is None
+            and right_unreachable
             # don't report an error if it's intentional
             and not e.right_unreachable
         ):
@@ -4320,16 +4321,14 @@ def check_boolean_op(self, e: OpExpr) -> Type:
             right_map, e.right, self._combined_context(expanded_left_type)
         )
 
-        if left_map is None and right_map is None:
+        if left_unreachable and right_unreachable:
             return UninhabitedType()
 
-        if right_map is None:
+        if right_unreachable:
             # The boolean expression is statically known to be the left value
-            assert left_map is not None
             return left_type
-        if left_map is None:
+        if left_unreachable:
             # The boolean expression is statically known to be the right value
-            assert right_map is not None
             return right_type
 
         if e.op == "and":
@@ -5913,14 +5912,12 @@ def check_for_comp(self, e: GeneratorExpr | DictionaryComprehension) -> None:
 
                 # values are only part of the comprehension when all conditions are true
                 true_map, false_map = self.chk.find_isinstance_check(condition)
-
-                if true_map:
-                    self.chk.push_type_map(true_map)
+                self.chk.push_type_map(true_map)
 
                 if codes.REDUNDANT_EXPR in self.chk.options.enabled_error_codes:
-                    if true_map is None:
+                    if mypy.checker.is_unreachable_map(true_map):
                         self.msg.redundant_condition_in_comprehension(False, condition)
-                    elif false_map is None:
+                    elif mypy.checker.is_unreachable_map(false_map):
                         self.msg.redundant_condition_in_comprehension(True, condition)
 
     def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = False) -> Type:
@@ -5931,9 +5928,9 @@ def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = F
         # but only for the current expression
         if_map, else_map = self.chk.find_isinstance_check(e.cond)
         if codes.REDUNDANT_EXPR in self.chk.options.enabled_error_codes:
-            if if_map is None:
+            if mypy.checker.is_unreachable_map(if_map):
                 self.msg.redundant_condition_in_if(False, e.cond)
-            elif else_map is None:
+            elif mypy.checker.is_unreachable_map(else_map):
                 self.msg.redundant_condition_in_if(True, e.cond)
 
         if ctx is None:
@@ -5974,14 +5971,14 @@ def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = F
 
     def analyze_cond_branch(
         self,
-        map: dict[Expression, Type] | None,
+        map: dict[Expression, Type],
         node: Expression,
         context: Type | None,
         allow_none_return: bool = False,
         suppress_unreachable_errors: bool = True,
     ) -> Type:
         with self.chk.binder.frame_context(can_skip=True, fall_through=0):
-            if map is None:
+            if mypy.checker.is_unreachable_map(map):
                 # We still need to type check node, in case we want to
                 # process it for isinstance checks later. Since the branch was
                 # determined to be unreachable, any errors should be suppressed.

mypy/checkexpr.py

@@ -31,7 +31,7 @@
 )
 
 # Modules that may fail when imported, or that may have side effects (fully qualified).
-NOT_IMPORTABLE_MODULES = ()
+NOT_IMPORTABLE_MODULES: tuple[str, ...] = ()
 
 # Typing constructs to be replaced by their builtin equivalents.
 TYPING_BUILTIN_REPLACEMENTS: Final = {

mypy/stubutil.py

@@ -2141,7 +2141,6 @@ if y in x:
 else:
     reveal_type(y)  # N: Revealed type is "builtins.int | None"
 [builtins fixtures/list.pyi]
-[out]
 
 [case testNarrowTypeAfterInListNested]
 # flags: --warn-unreachable

test-data/unit/check-isinstance.test

@@ -3246,14 +3246,15 @@ class B: ...
 
 T = TypeVar("T")
 
-def forgets_about_subclasses1(self, obj: T) -> T:
+def forgets_about_subclasses(self, obj: T) -> T:
     if isinstance(obj, A):
         return A()  # E: Incompatible return value type (got "A", expected "T")
     elif isinstance(obj, B):
         return B()  # E: Incompatible return value type (got "B", expected "T")
     raise
 
 def correct1(self, obj: T) -> T:
+    # TODO: mypy should not error in this case
     if type(obj) == A:
         return A()  # E: Incompatible return value type (got "A", expected "T")
     elif type(obj) == B:
@@ -3262,7 +3263,10 @@ def correct1(self, obj: T) -> T:
 
 T_value = TypeVar("T_value", A, B)
 
-def forgets_about_subclasses2(self, obj: T_value) -> T_value:
+def forgets_about_multiple_inheritance(self, obj: T_value) -> T_value:
+    # Note that it is a little confusing that mypy only errors in the first branch here, but this
+    # is a branch that would be taken by a subclass of both A and B.
+    # See also https://github.com/python/mypy/issues/10302#issuecomment-3832182574
     if isinstance(obj, A):
         return A()  # E: Incompatible return value type (got "A", expected "B")
     elif isinstance(obj, B):
@@ -3479,6 +3483,71 @@ def bar(X: type[T]) -> T:
     raise
 [builtins fixtures/type.pyi]
 
+[case testNarrowingConstrainedTypeVarType]
+# flags: --strict-equality --warn-unreachable
+from typing import TypeVar, Any, Type
+
+TargetType = TypeVar("TargetType", int, float, str)
+
+# TODO: this behaviour is incorrect, it will be fixed by improving reachability
+def convert_type(target_type: Type[TargetType]) -> TargetType:
+    if target_type == str:
+        return str()  # E: Incompatible return value type (got "str", expected "int") \
+                      # E: Incompatible return value type (got "str", expected "float")
+    if target_type == int:
+        return int()  # E: Incompatible return value type (got "int", expected "str")
+    if target_type == float:
+        return float()  # E: Incompatible return value type (got "float", expected "int") \
+                        # E: Incompatible return value type (got "float", expected "str")
+    raise
+[builtins fixtures/primitives.pyi]
+
+
+[case testNarrowingEqualityWithPromotions]
+# flags: --strict-equality --warn-unreachable
+from __future__ import annotations
+from typing import Literal
+
+# TODO: the behaviour on some of these test cases is incorrect
+def f1(number: float, i: int):
+    if number == i:
+        reveal_type(number)  # N: Revealed type is "builtins.float"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
+
+def f2(number: float, five: Literal[5]):
+    if number == five:
+        reveal_type(number)  # E: Statement is unreachable
+        reveal_type(five)
+
+def f3(number: float | int, five: Literal[5]):
+    if number == five:
+        reveal_type(number)  # N: Revealed type is "Literal[5]"
+        reveal_type(five)  # N: Revealed type is "Literal[5]"
+
+def f4(number: float | None, i: int):
+    if number == i:
+        reveal_type(number)  # N: Revealed type is "builtins.float | None"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
+
+def f5(number: float | int, i: int):
+    if number == i:
+        reveal_type(number)  # N: Revealed type is "builtins.int"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
+
+def f6(number: float | complex, i: int):
+    if number == i:
+        reveal_type(number)  # N: Revealed type is "builtins.float | builtins.complex"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
+
+class Custom:
+    def __eq__(self, other: object) -> bool: return True
+
+def f7(number: float, x: Custom | int):
+    if number == x:
+        reveal_type(number)  # N: Revealed type is "builtins.float"
+        reveal_type(x)  # N: Revealed type is "__main__.Custom"
+[builtins fixtures/primitives.pyi]
+
 [case testNarrowingAnyNegativeIntersection-xfail]
 # flags: --strict-equality --warn-unreachable
 # https://github.com/python/mypy/issues/20597

test-data/unit/check-narrowing.test

@@ -2940,7 +2940,25 @@ class Gleemer:
 
 
 [case testPartialTypeProtocolHashable]
-# flags: --no-strict-optional
+# flags: --no-strict-optional --no-local-partial-types
+from typing import Protocol
+
+class Hashable(Protocol):
+    def __hash__(self) -> int: ...
+
+class ObjectHashable:
+    def __hash__(self) -> int: ...
+
+class DataArray(ObjectHashable):
+    __hash__ = None
+
+    def f(self, x: Hashable) -> None:
+        reveal_type([self, x])  # N: Revealed type is "builtins.list[builtins.object]"
+[builtins fixtures/tuple.pyi]
+
+
+[case testPartialTypeProtocolHashableLocalPartialTypes]
+# flags: --no-strict-optional --local-partial-types
 from typing import Protocol
 
 class Hashable(Protocol):

test-data/unit/check-protocols.test

@@ -36,12 +36,17 @@ match m:
     case other:
         reveal_type(other)  # N: Revealed type is "Any"
 
-[case testMatchLiteralPatternAlreadyNarrower-skip]
-m: bool
+[case testMatchLiteralPatternBoolIntAlreadyNarrower]
+# flags: --strict-equality --warn-unreachable
 
-match m:
-    case 1:
-        reveal_type(m)  # This should probably be unreachable, but isn't detected as such.
+def foo(m: bool, x: int):
+    match m:
+        case 1:
+            reveal_type(m)  # N: Revealed type is "Literal[1]"
+
+    match m:
+        case x:
+            reveal_type(m)  # N: Revealed type is "builtins.bool"
 [builtins fixtures/primitives.pyi]
 
 [case testMatchLiteralPatternUnreachable]
@@ -402,7 +407,7 @@ match d.tag:
         reveal_type(d)  # N: Revealed type is "__main__.B"
         reveal_type(d.num)  # N: Revealed type is "builtins.int"
 
-[case testMatchSequenceUnion-skip]
+[case testMatchSequenceUnion]
 from typing import List, Union
 m: Union[List[List[str]], str]
 
@@ -1878,7 +1883,8 @@ match m:
         assert_never(unreachable)
 [builtins fixtures/enum.pyi]
 
-[case testMatchLiteralPatternEnumCustomEquals-skip]
+[case testMatchLiteralPatternEnumCustomEquals]
+# flags: --strict-equality --warn-unreachable
 from enum import Enum
 class Medal(Enum):
     gold = 1
@@ -1891,9 +1897,9 @@ m: Medal
 
 match m:
     case Medal.gold:
-        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
-    case _:
         reveal_type(m)  # N: Revealed type is "__main__.Medal"
+    case _:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.silver] | Literal[__main__.Medal.bronze]"
 [builtins fixtures/enum.pyi]
 
 [case testMatchNarrowUsingPatternGuardSpecialCase]
@@ -2035,7 +2041,8 @@ match c:
         assert_never(c) # E: Argument 1 to "assert_never" has incompatible type "Literal['red']"; expected "Never"
 [typing fixtures/typing-typeddict.pyi]
 
-[case testMatchAsPatternIntersection-skip]
+[case testMatchAsPatternIntersection]
+# flags: --strict-equality --warn-unreachable
 class A: pass
 class B: pass
 class C: pass
@@ -2046,7 +2053,7 @@ def f(x: A) -> None:
             reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
         case C() as y:
             reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.C">"
-    reveal_type(y)  # N: Revealed type is "Union[__main__.<subclass of "__main__.A" and "__main__.B">, __main__.<subclass of "__main__.A" and "__main__.C">]"
+    reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B"> | __main__.<subclass of "__main__.A" and "__main__.C">"
 
 [case testMatchWithBreakAndContinue]
 def f(x: int | str | None) -> None:

test-data/unit/check-python310.test

@@ -1533,17 +1533,24 @@ reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.int]"
 [builtins fixtures/tuple.pyi]
 
 [case testTupleOverlapDifferentTuples]
+# flags: --warn-unreachable
 from typing import Optional, Tuple
 class A: pass
 class B: pass
 
-possibles: Tuple[int, Tuple[A]]
-x: Optional[Tuple[B]]
+def f1(possibles: Tuple[int, Tuple[A]], x: Optional[Tuple[B]]):
+    if x in possibles:
+        reveal_type(x)  # N: Revealed type is "tuple[__main__.B]"
+    else:
+        reveal_type(x) # N: Revealed type is "tuple[__main__.B] | None"
+
+class AA(A): pass
 
-if x in possibles:
-    reveal_type(x) # N: Revealed type is "tuple[__main__.B]"
-else:
-    reveal_type(x) # N: Revealed type is "tuple[__main__.B] | None"
+def f2(possibles: Tuple[int, Tuple[A]], x: Optional[Tuple[AA]]):
+    if x in possibles:
+        reveal_type(x)  # N: Revealed type is "tuple[__main__.AA]"
+    else:
+        reveal_type(x) # N: Revealed type is "tuple[__main__.AA] | None"
 
 [builtins fixtures/tuple.pyi]