Merge branch 'master' into special_case_typeddict_get

Author: randolf-scholz

mypy/meet.py

@@ -170,7 +170,9 @@ def narrow_declared_type(declared: Type, narrowed: Type) -> Type:
     ):
         # We put this branch early to get T(bound=Union[A, B]) instead of
         # Union[T(bound=A), T(bound=B)] that will be confusing for users.
-        return declared.copy_modified(upper_bound=original_narrowed)
+        return declared.copy_modified(
+            upper_bound=narrow_declared_type(declared.upper_bound, original_narrowed)
+        )
     elif not is_overlapping_types(declared, narrowed, prohibit_none_typevar_overlap=True):
         if state.strict_optional:
             return UninhabitedType()

mypy/typeops.py

@@ -789,9 +789,9 @@ def false_only(t: Type) -> ProperType:
             if not ret_type.can_be_false:
                 return UninhabitedType(line=t.line)
         elif isinstance(t, Instance):
-            if t.type.is_final or t.type.is_enum:
+            if (t.type.is_final or t.type.is_enum) and state.strict_optional:
                 return UninhabitedType(line=t.line)
-        elif isinstance(t, LiteralType) and t.is_enum_literal():
+        elif isinstance(t, LiteralType) and t.is_enum_literal() and state.strict_optional:
             return UninhabitedType(line=t.line)
 
         new_t = copy_type(t)

test-data/unit/check-inference.test

@@ -1964,6 +1964,31 @@ if 'x' in d:  # E: "None" has no attribute "__iter__" (not iterable)
 reveal_type(d)  # N: Revealed type is "None"
 [builtins fixtures/dict.pyi]
 
+[case testNoWrongUnreachableWarningWithNoStrictOptionalAndFinalInstance]
+# flags: --no-strict-optional --warn-unreachable
+from typing import final, Optional
+
+@final
+class C: ...
+
+x: Optional[C]
+if not x:
+    x = C()
+[builtins fixtures/dict.pyi]
+
+[case testNoWrongUnreachableWarningWithNoStrictOptionalAndEnumLiteral]
+# flags: --no-strict-optional --warn-unreachable
+from enum import Enum
+from typing import Literal, Optional
+
+class E(Enum):
+    a = 1
+
+x: Optional[Literal[E.a]]
+if not x:
+    x = E.a
+[builtins fixtures/dict.pyi]
+
 [case testInferFromEmptyListWhenUsingInWithStrictEquality]
 # flags: --strict-equality
 def f() -> None:

test-data/unit/check-typeguard.test

@@ -825,6 +825,26 @@ def handle(model: Model) -> int:
     return 0
 [builtins fixtures/tuple.pyi]
 
+[case testTypeGuardedTypeDoesNotLeakTypeVar]
+# flags: --debug-serialize
+# https://github.com/python/mypy/issues/20015
+from typing import Generic, TypeVar, TypeGuard
+
+class A: ...
+class B: ...
+
+def is_a(_: object) -> TypeGuard[A]: return True
+def is_b(_: object) -> TypeGuard[B]: return True
+
+_T = TypeVar("_T")
+
+class Foo(Generic[_T]):
+    def __init__(self, v: _T) -> None:
+        if is_a(v) or is_b(v):
+            self.v = v
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
 [case testTypeGuardRestrictTypeVarUnion]
 from typing import Union, TypeVar
 from typing_extensions import TypeGuard

test-data/unit/fixtures/typing-full.pyi

@@ -34,6 +34,7 @@ no_type_check = 0
 ClassVar = 0
 Final = 0
 TypedDict = 0
+TypeGuard = 0
 NoReturn = 0
 NewType = 0
 Self = 0