Google Git Google Git
Sign in
fuchsia/third_party/github.com/python/mypy/46e199dacf3cf8a1792b0a0ee560a2d865906ab2/./test-data/unit/check-isinstance.test
blob: acd81839fcdc72cdee2bf1b96a489e98b6b9a972 [file]
[case testForcedAssignment]
# flags: --warn-unreachable
x = 1 # type: object
y = 1
def f(): x, y # Prevent independent redefinition
y = x # E: Incompatible types in assignment (expression has type "object", variable has type "int")
x = 2
y = x
[builtins fixtures/tuple.pyi]
[case testJoinAny]
# flags: --warn-unreachable
from typing import List, Any
x: List[Any]
def foo() -> List[int]: pass
def bar() -> List[str]: pass
if bool():
x = foo()
else:
x = bar()
x * 2
[builtins fixtures/list.pyi]
[case testGeneratorExpressionTypes]
# flags: --warn-unreachable
class A: y = 1
x = [A()]
y = [x]
z = [1,2]
z = [a.y for b in y for a in b]
[builtins fixtures/list.pyi]
[case testIsinstanceNestedTuple]
# flags: --warn-unreachable
from typing import Union, List, Tuple, Dict
def f(x: Union[int, str, List]) -> None:
if isinstance(x, (str, (int,))):
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str"
x[1] # E: Value of type "int | str" is not indexable
else:
reveal_type(x) # N: Revealed type is "builtins.list[Any]"
x[1]
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
if isinstance(x, (str, (list,))):
reveal_type(x) # N: Revealed type is "builtins.str | builtins.list[Any]"
x[1]
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceNarrowsSequenceParentFromElement]
# flags: --warn-unreachable
from __future__ import annotations
def f1(x: list[str] | list[int]) -> None:
if isinstance(x[0], str):
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str]"
reveal_type(x[0]) # N: Revealed type is "builtins.str"
else:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.int]"
reveal_type(x[0]) # N: Revealed type is "builtins.int"
def f2(x: tuple[str, ...] | tuple[int, ...]) -> None:
if isinstance(x[0], str):
reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.str, ...]"
reveal_type(x[0]) # N: Revealed type is "builtins.str"
else:
reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.int, ...]"
reveal_type(x[0]) # N: Revealed type is "builtins.int"
def f3(x: tuple[str, str] | tuple[int, int]) -> None:
if isinstance(x[0], str):
reveal_type(x) # N: Revealed type is "tuple[builtins.str, builtins.str]"
else:
reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.int]"
class A: ...
class B: ...
class C(A, B): ...
def f4(x: list[A] | list[B]):
# Technically this is unsound in the presence of multiple inheritance,
# but we already do this kind of narrowing for tuples
if isinstance(x[0], A):
reveal_type(x) # N: Revealed type is "builtins.list[__main__.A]"
else:
reveal_type(x) # N: Revealed type is "builtins.list[__main__.B]"
def f5(x: tuple[A, ...] | tuple[B, ...]):
if isinstance(x[0], A):
reveal_type(x) # N: Revealed type is "builtins.tuple[__main__.A, ...]"
else:
reveal_type(x) # N: Revealed type is "builtins.tuple[__main__.B, ...]"
def f6(x: tuple[A, A] | tuple[B, B]):
if isinstance(x[0], A):
reveal_type(x) # N: Revealed type is "tuple[__main__.A, __main__.A]"
else:
reveal_type(x) # N: Revealed type is "tuple[__main__.B, __main__.B]"
class AA(A): ...
def f7(x: list[A] | list[AA]):
if isinstance(x[0], AA):
reveal_type(x) # N: Revealed type is "builtins.list[__main__.A] | builtins.list[__main__.AA]"
else:
reveal_type(x) # N: Revealed type is "builtins.list[__main__.A] | builtins.list[__main__.AA]"
def f8(x: list[str] | list[str | None]):
if x[0] is not None:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | builtins.list[builtins.str | None]"
else:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str | None]"
[builtins fixtures/tuple.pyi]
[case testClassAttributeInitialization]
# flags: --warn-unreachable
class A:
x: int
def __init__(self) -> None:
self.y: int
z = self.x
w = self.y
[case testAssignmentSubtypes]
# flags: --warn-unreachable
from typing import Union
def foo(x: Union[str, int]):
if isinstance(x, int):
x = 'a'
x + 'a'
z = x
y = [x]
y[0] + 'a'
# TODO: should we allow these two lines?
y + [1] # E: List item 0 has incompatible type "int"; expected "str"
z = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "str")
x: int
y = [x]
[builtins fixtures/isinstancelist.pyi]
[case testFunctionDefaultArgs]
# flags: --warn-unreachable
class A: pass
class B(A): y = 1
x = A()
def foo(x: A = B()):
x.y # E: "A" has no attribute "y"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceFancyConditionals]
# flags: --warn-unreachable
class A: pass
class B(A):
y = 1
x = A()
if isinstance(x, B):
x.y
while isinstance(x, B):
x.y
while isinstance(x, B):
x.y
x = B()
[builtins fixtures/isinstance.pyi]
[case testSubtypingWithAny]
# flags: --warn-unreachable
class A:
y = 1
class B(A):
z = 1
def foo(): pass
x = A()
if int():
x = B()
x.z
x = foo()
reveal_type(x) # N: Revealed type is "Any"
reveal_type(x) # N: Revealed type is "__main__.A"
[case testSingleMultiAssignment]
# flags: --warn-unreachable
x = 'a'
(x,) = ('a',)
[case testUnionMultiAssignment]
# flags: --warn-unreachable
from typing import Union
x: Union[int, str]
if int():
x = 1
x = 'a'
x + 1 # E: Unsupported operand types for + ("str" and "int")
x = 1
(x, y) = ('a', 1)
x + 1 # E: Unsupported operand types for + ("str" and "int")
[builtins fixtures/isinstancelist.pyi]
[case testUnionIfZigzag]
# flags: --warn-unreachable
from typing import Union
def f(x: Union[int, str]) -> None:
if 1: # Without this, the assignment below could create a new variable "x" of type "int"
x = 1
if x:
x = 'a'
x = 1
x + 1
x + 1
[builtins fixtures/isinstancelist.pyi]
[case testTwoLoopsUnion]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
def bar() -> None:
x = foo()
if isinstance(x, int):
return
while bool():
x + 'a'
while bool():
x = foo()
if bool():
return
x = 'a'
x + 'a'
[builtins fixtures/isinstancelist.pyi]
[case testComplicatedBlocks]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
def bar() -> None:
x = foo()
if isinstance(x, int):
return
while bool():
x + 'a'
while bool():
x = foo()
if bool():
return
x = 'a'
x + 'a'
x = foo()
if isinstance(x, int):
return
while bool():
x + 'a'
while bool():
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
x = foo()
if bool():
continue
x = 'a'
x = 'a'
x + 'a'
[builtins fixtures/isinstancelist.pyi]
[case testUnionTryExcept]
# flags: --warn-unreachable
class A:
y = A()
class B(A):
z = 1
x = A()
def f(): x # Prevent redefinition of x
x = B()
x.z
try:
x.z
x = A()
x = B()
x.z
except:
pass
x.z # E: "A" has no attribute "z"
[case testUnionTryExcept2]
# flags: --warn-unreachable
class A:
y = A()
class B(A):
z = 1
x = A()
try:
x.z # E: "A" has no attribute "z"
x = A()
x = B()
x.z
except:
x.z # E: "A" has no attribute "z"
x = B()
x.z
else:
x = B()
x.z
[case testUnionTryExcept3]
# flags: --warn-unreachable
class A:
y = A()
class B(A):
z = 1
x = A()
def f(): x # Prevent redefinition of x
x = B()
try:
raise BaseException()
x = A() # E: Statement is unreachable
except:
pass
x.z
x = B()
try:
x = A()
raise BaseException()
except:
pass
x.z # E: "A" has no attribute "z"
x = B()
try:
pass
except:
x = A()
raise BaseException()
x.z
try:
x = A()
except:
pass
x.z # E: "A" has no attribute "z"
x = B()
try:
pass
except:
x = A()
x.z # E: "A" has no attribute "z"
[builtins fixtures/exception.pyi]
[case testUnionTryExcept4]
# flags: --warn-unreachable
class A: pass
class B(A):
z = 1
x = A()
while bool():
try:
x.z # E: "A" has no attribute "z"
x = A()
except:
x = B()
else:
x = B()
x.z
[builtins fixtures/exception.pyi]
[case testUnionTryFinally]
# flags: --warn-unreachable
class A: pass
class B(A):
b = 1
x = A()
def f(): x # Prevent redefinition
x = B()
try:
x = A()
x.b # E: "A" has no attribute "b"
x = B()
finally:
x.b # E: "A" has no attribute "b"
x.b
[case testUnionTryFinally2]
# flags: --warn-unreachable
class A: pass
class B(A):
b = 1
x = A()
def f(): x # Prevent redefinition
x = B()
try:
x = A()
x = B()
except:
pass
finally:
pass
x.b # E: "A" has no attribute "b"
[case testUnionTryFinally3]
# flags: --warn-unreachable
class A: pass
class B(A):
b = 1
x = A()
def f(): x # Prevent redefinition
x = B()
try:
x = A()
x = B()
except:
pass
finally:
x = B()
x.b
[case testUnionTryFinally4]
# flags: --warn-unreachable
class A: pass
class B(A):
b = 1
while 2:
x = A()
def f(): x # Prevents redefinition
x = B()
try:
x = A()
x = B()
except:
pass
finally:
x.b # E: "A" has no attribute "b"
if not isinstance(x, B):
break
x.b
[builtins fixtures/isinstancelist.pyi]
[case testUnionTryFinally5]
# flags: --warn-unreachable
class A: pass
class B(A):
b = 1
while 2:
x = A()
try:
x = A()
x = B()
finally:
x.b # E: "A" has no attribute "b"
break
x.b # E: Statement is unreachable
x.b # E: Statement is unreachable
[case testUnionTryFinally6]
# flags: --warn-unreachable
class A: pass
class B(A):
b = 1
def f() -> int:
x = B() # type: A
try:
x = B()
except:
x = A()
# An exception could occur here
x = B()
finally:
return x.b # E: "A" has no attribute "b"
[case testUnionListIsinstance]
# flags: --warn-unreachable
from typing import Union, List
def f(x: Union[List[int], List[str], int]) -> None:
if isinstance(x, list):
a = x[0]
if isinstance(a, int):
a + 1
a + 'x' # E: Unsupported operand types for + ("int" and "str")
# type of a?
reveal_type(x) # N: Revealed type is "builtins.list[builtins.int] | builtins.list[builtins.str]"
x + 1 # E: Unsupported operand types for + ("list[int]" and "int") \
# E: Unsupported operand types for + ("list[str]" and "int") \
# N: Left operand is of type "list[int] | list[str]"
else:
x[0] # E: Value of type "int" is not indexable
x + 1
x[0] # E: Value of type "list[int] | list[str] | int" is not indexable
x + 1 # E: Unsupported operand types for + ("list[int]" and "int") \
# E: Unsupported operand types for + ("list[str]" and "int") \
# N: Left operand is of type "list[int] | list[str] | int"
[builtins fixtures/isinstancelist.pyi]
[case testUnionListIsinstance2]
# flags: --warn-unreachable
from typing import Union, List
class A:
a = 1
class B: pass
class C: pass
def g(x: Union[A, B]) -> A: pass
def h(x: C) -> A: pass
def f(x: Union[A, B, C]) -> None:
if isinstance(x, C):
x = h(x)
else:
x = g(x)
x.a
[builtins fixtures/isinstancelist.pyi]
[case testUnionStrictDefnBasic]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
if int():
x = 1
x = x + 1
x = foo()
x = x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
if isinstance(x, str):
x = x + 1 # E: Unsupported operand types for + ("str" and "int")
x = 1
x = x + 1
[builtins fixtures/isinstancelist.pyi]
[case testSubtypeRedefinitionBasic]
# flags: --warn-unreachable
from typing import Union
class A: pass
class B(A):
y = 1
x = A()
x.y # E: "A" has no attribute "y"
x = B()
x.y # OK: x is known to be a B
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceBasic]
# flags: --warn-unreachable
from typing import Union
x: Union[int, str]
if isinstance(x, str):
x = x + 1 # E: Unsupported operand types for + ("str" and "int")
x = x + 'a'
else:
x = x + 'a' # E: Unsupported operand types for + ("int" and "str")
x = x + 1
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceIndexing]
# flags: --warn-unreachable
from typing import Union
x: Union[int, str]
j = [x]
if isinstance(j[0], str):
j[0] = j[0] + 'a'
j[0] = j[0] + 1 # E: Unsupported operand types for + ("str" and "int")
else:
j[0] = j[0] + 'a' # E: Unsupported operand types for + ("int" and "str")
j[0] = j[0] + 1
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceSubClassMember]
# flags: --warn-unreachable
from typing import Union
class Animal: pass
class Dog(Animal):
paws = 4 # type: Union[int, str]
def bark(self): pass
class House:
pet: Animal
h = House()
h.pet = Dog()
while bool():
if isinstance(h.pet, Dog):
if isinstance(h.pet.paws, str):
x = h.pet.paws + 'a'
y = h.pet.paws + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
z = h.pet.paws + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
if isinstance(h.pet.paws, str):
x = h.pet.paws + 'a'
break
y = h.pet.paws + 1
z = h.pet.paws + 'a' # E: Unsupported operand types for + ("int" and "str")
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceSubClassReset]
# flags: --warn-unreachable
class A:
pass
class B(A):
b = 1
class C:
a = A()
x = C()
x.a.b # E: "A" has no attribute "b"
if isinstance(x.a, B):
x.a.b
x = C()
x.a.b # E: "A" has no attribute "b"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceTuple]
# flags: --warn-unreachable
from typing import Union
class A: pass
class B:
def method2(self, arg: int):
return 123
class C:
def method2(self, arg: int):
return 456
def method3(self, arg: str):
return 'abc'
v = A() # type: Union[A, B, C]
if isinstance(v, (B, C)):
v.method2(123)
v.method3('xyz') # E: Item "B" of "B | C" has no attribute "method3"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceNeverWidens]
# flags: --warn-unreachable
from typing import Union
class A: pass
class B: pass
class C: pass
a = A() # type: A
assert isinstance(a, (A, B))
reveal_type(a) # N: Revealed type is "__main__.A"
b = A() # type: Union[A, B]
assert isinstance(b, (A, B, C))
reveal_type(b) # N: Revealed type is "__main__.A | __main__.B"
[builtins fixtures/isinstance.pyi]
[case testMemberAssignmentChanges]
# flags: --warn-unreachable
from typing import Union
class Dog:
paws = 1 # type: Union[int, str]
pet = Dog()
pet.paws + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
pet.paws = 'a'
pet.paws + 'a'
pet.paws = 1
pet.paws + 1
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceSubClassMemberHard]
# flags: --warn-unreachable
from typing import Union
class Animal:
pass
class Dog(Animal):
paws = 4 # type: Union[int, str]
def bark(self): pass
class House:
pet: Animal
h = House()
h.pet = Dog()
if isinstance(h.pet, Dog):
if isinstance(h.pet.paws, str):
for i in [1]:
# TODO: should we allow this if iterable is of length one or zero?
h.pet.paws + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
if bool():
break
h.pet.paws = 1
h.pet.paws + 1
if isinstance(h.pet.paws, str):
h.pet.paws + 'a'
else:
h.pet.paws + 1
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceReturn]
# flags: --warn-unreachable
from typing import Union
def foo() -> None:
x = 1 # type: Union[int, str]
if isinstance(x, int):
return
y = x + 'asdad'
def bar() -> None:
x = 1 # type: Union[int, str]
if isinstance(x, int):
return
else:
pass
y = x + 'asdad'
foo()
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceBadBreak]
# flags: --warn-unreachable
from typing import Union
def foo() -> None:
x: Union[int, str]
if isinstance(x, int):
for z in [1,2]:
break
else:
pass
y = x + 'asdad' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
foo()
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceThreeUnion]
# flags: --warn-unreachable
from typing import Union, List
x: Union[int, str, List[int]]
while bool():
if isinstance(x, int):
x + 1
elif isinstance(x, str):
x + 'a'
else:
x + [1]
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# E: Unsupported operand types for + ("list[int]" and "str") \
# N: Left operand is of type "int | str | list[int]"
x + [1] # E: Unsupported operand types for + ("int" and "list[int]") \
# E: Unsupported operand types for + ("str" and "list[int]") \
# N: Left operand is of type "int | str | list[int]"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceThreeUnion2]
# flags: --warn-unreachable
from typing import Union, List
x: Union[int, str, List[int]]
while bool():
if isinstance(x, int):
x + 1
break
elif isinstance(x, str):
x + 'a'
break
x + [1]
x + 'a' # E: Unsupported operand types for + ("list[int]" and "str")
x + [1] # E: Unsupported operand types for + ("int" and "list[int]") \
# E: Unsupported operand types for + ("str" and "list[int]") \
# N: Left operand is of type "int | str | list[int]"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceThreeUnion3]
# flags: --warn-unreachable
from typing import Union, List
while bool():
x: Union[int, str, List[int]]
def f(): x # Prevent redefinition
x = 1
if isinstance(x, int):
x + 1
break
elif isinstance(x, str): # E: Statement is unreachable
x + 'a'
break
x + [1] # These lines aren't reached because x was an int # E: Statement is unreachable
x + 'a'
x + [1] # E: Unsupported operand types for + ("int" and "list[int]") \
# E: Unsupported operand types for + ("str" and "list[int]") \
# N: Left operand is of type "int | str | list[int]"
[builtins fixtures/isinstancelist.pyi]
[case testRemovingTypeRepeatedly]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
for i in [1, 2]:
x = foo()
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
if isinstance(x, int):
break
x + 'a'
x = foo()
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
if isinstance(x, int):
break
x + 'a'
x = foo()
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
if isinstance(x, int):
break
x + 'a'
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
[builtins fixtures/isinstancelist.pyi]
[case testModifyRepeatedly]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
x = 1
x + 1
x + 'a' # E: Unsupported operand types for + ("int" and "str")
x = 'a'
x + 1 # E: Unsupported operand types for + ("str" and "int")
x + 'a'
x = foo()
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x + 'a' # E: Unsupported operand types for + ("int" and "str") \
# N: Left operand is of type "int | str"
[builtins fixtures/isinstancelist.pyi]
[case testModifyLoop]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 'a'
x + 1 # E: Unsupported operand types for + ("str" and "int")
x = 1
x + 1
while bool():
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 'a'
[builtins fixtures/isinstancelist.pyi]
[case testModifyLoop2]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 'a'
x + 1 # E: Unsupported operand types for + ("str" and "int")
x = 1
x + 1
for i in [1]:
x = 'a'
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
[builtins fixtures/isinstancelist.pyi]
[case testModifyLoop3]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x = 1
while bool():
x + 1
x = 'a'
break
else:
x + 1
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 1
for y in [1]:
x + 1
x = 'a'
break
else:
x + 1
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
[builtins fixtures/isinstancelist.pyi]
[case testModifyLoopWhile4]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x = 1
while bool():
x + 1
if bool():
x = 'a'
break
else:
x + 1
x = 'a'
x + 'a'
x = 1
while bool():
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
if bool():
x = 'a'
continue
else:
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 'a'
x + 'a'
[builtins fixtures/isinstancelist.pyi]
[case testModifyLoopFor4]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x = 1
for y in [1]:
x + 1
if bool():
x = 'a'
break
else:
x + 1
x = 'a'
x + 'a'
x = 1
for y in [1]:
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
if bool():
x = 'a'
continue
else:
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 'a'
x + 'a'
[builtins fixtures/isinstancelist.pyi]
[case testModifyNestedLoop]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
def f(): x # Prevent redefinition
x = 1
for y in [1]:
for z in [1]:
break
else:
x = 'a'
break
else:
x + 1
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
x = 1
while bool():
while bool():
break
else:
x = 'a'
break
else:
x + 1
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
[builtins fixtures/isinstancelist.pyi]
[case testModifyLoopLong]
# flags: --warn-unreachable
from typing import Union
class A: a = 1
def foo() -> Union[int, str, A]: pass
def bar() -> None:
x = foo()
x + 1 # E: Unsupported left operand type for + ("A") \
# N: Left operand is of type "int | str | A" \
# E: Unsupported operand types for + ("str" and "int")
if isinstance(x, A):
x.a
else:
if isinstance(x, int):
x + 1
x + 'a' # E: Unsupported operand types for + ("int" and "str")
else:
x + 'a'
x.a # E: "str" has no attribute "a"
x = A()
if isinstance(x, str):
x + 'a'
else:
while bool():
if isinstance(x, int):
x + 1
else:
x.a
break
while bool():
if isinstance(x, int):
x + 1
else:
x.a
continue
while bool():
if isinstance(x, int):
x + 1
else:
x.a # E: Item "str" of "str | A" has no attribute "a"
x = 'a'
[builtins fixtures/isinstancelist.pyi]
[case testWhileExitCondition1]
# flags: --warn-unreachable
from typing import Union
x = 1 # type: Union[int, str]
while isinstance(x, int):
if bool():
continue
x = 'a'
else:
reveal_type(x) # N: Revealed type is "builtins.str"
reveal_type(x) # N: Revealed type is "builtins.str"
[builtins fixtures/isinstance.pyi]
[case testWhileExitCondition2]
# flags: --warn-unreachable
from typing import Union
x = 1 # type: Union[int, str]
while isinstance(x, int):
if bool():
break
x = 'a'
else:
reveal_type(x) # N: Revealed type is "builtins.str"
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str"
[builtins fixtures/isinstance.pyi]
[case testWhileLinkedList]
# flags: --warn-unreachable
from typing import Union
LinkedList = Union['Cons', 'Nil']
class Nil: pass
class Cons:
tail: LinkedList
def last(x: LinkedList) -> Nil:
while isinstance(x, Cons):
x = x.tail
return x
[builtins fixtures/isinstance.pyi]
[case testReturnAndFlow]
# flags: --warn-unreachable
def foo() -> int:
return 1 and 2
return 'a' # E: Statement is unreachable
[case testCastIsinstance]
# flags: --warn-unreachable
from typing import Union
def foo() -> Union[int, str]: pass
x = foo()
y = 1 # type: int
if isinstance(x, str):
x = y
x + 1
x + 'a' # E: Unsupported operand types for + ("int" and "str")
[builtins fixtures/isinstancelist.pyi]
[case testUnreachableCode]
# flags: --warn-unreachable
x = 1 # type: int
while bool():
x = 'a' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
break
x = 'a' # Note: no error because unreachable code # E: Statement is unreachable
[builtins fixtures/isinstancelist.pyi]
[case testUnreachableCode2]
# flags: --warn-unreachable
x = 1
while bool():
try:
pass
except:
continue
else:
continue
x + 'a' # E: Statement is unreachable
[builtins fixtures/isinstance.pyi]
[case testUnreachableWhileTrue]
# flags: --warn-unreachable
def f(x: int) -> None:
while True:
if x:
return
1() # E: Statement is unreachable
[builtins fixtures/bool.pyi]
[case testUnreachableAssertFalse]
# flags: --warn-unreachable
def f() -> None:
assert False
1() # E: Statement is unreachable
[builtins fixtures/bool.pyi]
[case testUnreachableAssertFalse2]
# flags: --warn-unreachable
def f() -> None:
# The old parser doesn't understand the syntax below
assert False, "hi"
1() # E: Statement is unreachable
[builtins fixtures/bool.pyi]
[case testUnreachableReturnOrAssertFalse]
# flags: --warn-unreachable
def f(x: int) -> int:
if x:
return x
else:
assert False
1() # E: Statement is unreachable
[builtins fixtures/bool.pyi]
[case testUnreachableTryExcept]
# flags: --warn-unreachable
def f() -> None:
try:
f()
return
except BaseException:
return
1() # E: Statement is unreachable
[builtins fixtures/exception.pyi]
[case testUnreachableTryExceptElse]
# flags: --warn-unreachable
def f() -> None:
try:
f()
except BaseException:
return
else:
return
1() # E: Statement is unreachable
[builtins fixtures/exception.pyi]
[case testUnreachableTryReturnFinally1]
# flags: --warn-unreachable
def f() -> None:
try:
return
finally:
pass
1() # E: Statement is unreachable
[case testUnreachableTryReturnFinally2]
# flags: --warn-unreachable
def f() -> None:
try:
pass
finally:
return
1() # E: Statement is unreachable
[case testUnreachableTryReturnExceptRaise]
# flags: --warn-unreachable
def f() -> None:
try:
return
except:
raise
1() # E: Statement is unreachable
[case testUnreachableReturnLambda]
# flags: --warn-unreachable
from typing import Callable
def g(t: Callable[[int], int]) -> int: pass
def f() -> int:
return g(lambda x: x)
1() # E: Statement is unreachable
[case testIsinstanceAnd]
# flags: --warn-unreachable
class A: pass
class B(A):
flag = 1
x = B() # type: A
if isinstance(x, B) and 1:
x.flag
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceShortcircuit]
# flags: --warn-unreachable
class A:
pass
class B(A):
flag = 1
x = B() # type: A
if isinstance(x, B) and x.flag:
pass
if isinstance(x, B) or x.flag: # E: "A" has no attribute "flag"
pass
if not isinstance(x, B) or x.flag:
pass
if not isinstance(x, B) and x.flag: # E: "A" has no attribute "flag"
pass
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceExpression]
# flags: --warn-unreachable
class A:
pass
class B(A):
flag = 1
x = B() # type: A
x.flag if isinstance(x, B) else 0
0 if not isinstance(x, B) else x.flag
0 if isinstance(x, B) else x.flag # E: "A" has no attribute "flag"
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceMultiAnd]
# flags: --warn-unreachable
class A: pass
class B(A):
flag = 1
class C(A):
glaf = 1
x = B() # type: A
y = C() # type: A
if isinstance(x, B) and isinstance(y, C):
x.flag += 1
y.glaf += 1
x() # E: "B" not callable
y() # E: "C" not callable
else:
x() # E: "A" not callable
y() # E: "A" not callable
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceMultiAndSpecialCase]
# flags: --warn-unreachable
class A:
# Ensure A.__add__ and int.__add__ are different to
# force 'isinstance(y, int)' checks below to never succeed.
def __add__(self, other: A) -> A: pass
class B(A):
flag = 1
class C(A):
glaf = 1
x = B() # type: A
y = C() # type: A
if isinstance(x, B) and isinstance(y, int): # E: Subclass of "A" and "int" cannot exist: would have incompatible method signatures
1() # E: Statement is unreachable
if isinstance(y, int) and isinstance(x, B): # E: Subclass of "A" and "int" cannot exist: would have incompatible method signatures \
# E: Right operand of "and" is never evaluated
1() # E: Statement is unreachable
if isinstance(y, int) and y > 42: # E: Subclass of "A" and "int" cannot exist: would have incompatible method signatures \
# E: Right operand of "and" is never evaluated
1() # E: Statement is unreachable
[builtins fixtures/isinstancelist.pyi]
[case testReturnWithCallExprAndIsinstance]
# flags: --warn-unreachable
from typing import Union
def f(x: Union[int, str]) -> None:
if not isinstance(x, int):
return foo()
x() # E: "int" not callable
def foo(): pass
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceOr1]
# flags: --warn-unreachable
from typing import Optional
def f(a: bool, x: object) -> Optional[int]:
if a or not isinstance(x, int):
return None
reveal_type(x) # N: Revealed type is "builtins.int"
return x
[builtins fixtures/isinstance.pyi]
[case testIsinstanceOr2]
# flags: --warn-unreachable
from typing import Optional
def g(a: bool, x: object) -> Optional[int]:
if not isinstance(x, int) or a:
return None
reveal_type(x) # N: Revealed type is "builtins.int"
return x
[builtins fixtures/isinstance.pyi]
[case testIsinstanceOr3]
# flags: --warn-unreachable
from typing import Optional
def h(a: bool, x: object) -> Optional[int]:
if a or isinstance(x, int):
return None
return x # E: Incompatible return value type (got "object", expected "int | None")
[builtins fixtures/isinstance.pyi]
[case testIsinstanceWithOverlappingUnionType]
# flags: --warn-unreachable
from typing import Union
def f(x: Union[float, int]) -> None:
if isinstance(x, float):
pass
if not isinstance(x, int):
f(x)
[builtins fixtures/isinstance.pyi]
[case testIsinstanceWithOverlappingUnionType2]
# flags: --warn-unreachable
from typing import Union
class A: pass
class B(A): pass
def f(x: Union[A, B]) -> None:
if isinstance(x, A):
pass
if not isinstance(x, B):
f(x)
[builtins fixtures/isinstance.pyi]
[case testIsinstanceWithOverlappingPromotionTypes]
# flags: --warn-unreachable
from typing import Union
def f1(x: Union[float, int]) -> None:
# We ignore promotions in isinstance checks
if isinstance(x, float):
reveal_type(x) # N: Revealed type is "builtins.float"
else:
reveal_type(x) # N: Revealed type is "builtins.int"
class FloatLike: pass
class IntLike(FloatLike): pass
def f2(x: Union[FloatLike, IntLike]) -> None:
if isinstance(x, FloatLike):
reveal_type(x) # N: Revealed type is "__main__.FloatLike"
else:
reveal_type(x) # E: Statement is unreachable
[builtins fixtures/isinstance.pyi]
[case testIsinstanceOfSuperclass]
# flags: --warn-unreachable
class A: pass
class B(A): pass
x = B()
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.B"
if not isinstance(x, A):
reveal_type(x) # E: Statement is unreachable
x = A()
reveal_type(x) # N: Revealed type is "__main__.B"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceOfNonoverlapping]
# flags: --warn-unreachable
class A: pass
class B: pass
x = B()
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
else:
reveal_type(x) # N: Revealed type is "__main__.B"
reveal_type(x) # N: Revealed type is "__main__.B"
[builtins fixtures/isinstance.pyi]
[case testAssertIsinstance]
# flags: --warn-unreachable
def f(x: object):
assert isinstance(x, int)
y = 0 # type: int
y = x
[builtins fixtures/isinstance.pyi]
[case testUnionAssertIsinstance]
# flags: --warn-unreachable
from typing import Union
def f(x: Union[str, int]):
assert isinstance(x, int)
y = 0 # type: int
y = x
[builtins fixtures/isinstance.pyi]
[case testAnyAssertIsinstance]
# flags: --warn-unreachable
from typing import Any
def f(x: Any):
assert isinstance(x, int) # this should narrow x to type int
x + "foo" # E: Unsupported operand types for + ("int" and "str")
[builtins fixtures/isinstance.pyi]
[case testIsinstanceNarrowingAny]
# flags: --warn-unreachable
from typing import Any
class A: pass
class B(A): pass
def f1(x: Any) -> None:
if x and isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.A"
if isinstance(x, A) and x:
reveal_type(x) # N: Revealed type is "__main__.A"
def f2(x: Any) -> None:
if isinstance(x, A) and not isinstance(x, B):
reveal_type(x) # N: Revealed type is "__main__.A"
if not isinstance(x, B) and isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.A"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceOfGenericClassRetainsParameters]
# flags: --warn-unreachable
from typing import List, Union
def f(x: Union[List[int], str]) -> None:
if isinstance(x, list):
x[0]() # E: "int" not callable
else:
reveal_type(x) # N: Revealed type is "builtins.str"
reveal_type(x) # N: Revealed type is "builtins.list[builtins.int] | builtins.str"
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceOrIsinstance]
# flags: --warn-unreachable
class A: pass
class B(A):
flag = 1
class C(A):
flag = 2
x1 = A()
if isinstance(x1, B) or isinstance(x1, C):
reveal_type(x1) # N: Revealed type is "__main__.B | __main__.C"
f = x1.flag # type: int
else:
reveal_type(x1) # N: Revealed type is "__main__.A"
f = 0
reveal_type(x1) # N: Revealed type is "__main__.A"
x2 = A()
if isinstance(x2, A) or isinstance(x2, C): # E: Right operand of "or" is never evaluated
reveal_type(x2) # N: Revealed type is "__main__.A"
f = x2.flag # E: "A" has no attribute "flag"
else:
1() # E: Statement is unreachable
reveal_type(x2) # N: Revealed type is "__main__.A"
[builtins fixtures/isinstance.pyi]
[case testComprehensionIsInstance]
# flags: --warn-unreachable
from typing import List, Union
a = [] # type: List[Union[int, str]]
l = [x for x in a if isinstance(x, int)]
g = (x for x in a if isinstance(x, int))
d = {0: x for x in a if isinstance(x, int)}
reveal_type(l) # N: Revealed type is "builtins.list[builtins.int]"
reveal_type(g) # N: Revealed type is "typing.Generator[builtins.int, None, None]"
reveal_type(d) # N: Revealed type is "builtins.dict[builtins.int, builtins.int]"
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceInWrongOrderInBooleanOp]
# flags: --warn-unreachable
class A:
m = 1
def f(x: object) -> None:
if x.m and isinstance(x, A) or False: # E: "object" has no attribute "m"
pass
[builtins fixtures/isinstance.pyi]
[case testIsinstanceAndOr]
# flags: --warn-unreachable
class A:
a: 'A'
def f(x: object) -> None:
b = isinstance(x, A) and x.a or A()
reveal_type(b) # N: Revealed type is "__main__.A"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceWithUnknownType]
# flags: --warn-unreachable
from typing import Union
def f(x: Union[int, str], typ: type) -> None:
if isinstance(x, (typ, int)):
x + 1 # E: Unsupported operand types for + ("str" and "int") \
# N: Left operand is of type "int | str"
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str"
else:
reveal_type(x) # N: Revealed type is "builtins.str"
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithUnknownTypeMultipleNarrowing]
# flags: --strict-equality --warn-unreachable --python-version 3.10
from __future__ import annotations
from typing import Iterable
from typing_extensions import TypeAlias
import types
# Regression test for https://github.com/python/mypy/issues/21181
# We don't have the same type context as with the real stubs, so sort of fake it
_ClassInfoLike: TypeAlias = "type | tuple[_ClassInfoLike, ...]"
class A: ...
class B(A): ...
def fake_type_context(ts: list[type[A]]) -> _ClassInfoLike:
return tuple(ts) # E: Too many arguments for "tuple"
def f1(x: A | None) -> None:
if x is not None:
reveal_type(x) # N: Revealed type is "__main__.A"
if isinstance(x, object):
reveal_type(x) # N: Revealed type is "__main__.A"
def f2(x: A | None, ts: list[type[A]]) -> None:
if x is not None:
reveal_type(x) # N: Revealed type is "__main__.A"
if isinstance(x, fake_type_context(ts)):
reveal_type(x) # N: Revealed type is "__main__.A"
def f3(x: A | None, t: type | type[A]) -> None:
if x is not None:
reveal_type(x) # N: Revealed type is "__main__.A"
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A"
def f4(x: A | None, t: type) -> None:
if x is not None:
reveal_type(x) # N: Revealed type is "__main__.A"
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A"
def f5(x: object | None, ta: type[A], tb: type[B]) -> None:
if x is not None:
reveal_type(x) # N: Revealed type is "builtins.object"
if isinstance(x, ta):
reveal_type(x) # N: Revealed type is "__main__.A"
if isinstance(x, tb):
reveal_type(x) # N: Revealed type is "__main__.B"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithBoundedType]
# flags: --warn-unreachable
from typing import Union, Type
class A: pass
def f(x: Union[int, A], a: Type[A]) -> None:
if isinstance(x, (a, int)):
reveal_type(x) # N: Revealed type is "builtins.int | __main__.A"
else:
reveal_type(x) # N: Revealed type is "__main__.A"
reveal_type(x) # N: Revealed type is "builtins.int | __main__.A"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithEmtpy2ndArg]
# flags: --warn-unreachable
from typing import Union
def f(x: Union[int, str]) -> None:
if isinstance(x, ()):
reveal_type(x) # E: Statement is unreachable
else:
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithTypeObject]
# flags: --warn-unreachable
from typing import Union, Type
class A: pass
def f(x: Union[int, A], a: Type[A]) -> None:
if isinstance(x, a):
reveal_type(x) # N: Revealed type is "__main__.A"
elif isinstance(x, int):
reveal_type(x) # N: Revealed type is "builtins.int"
else:
reveal_type(x) # N: Revealed type is "__main__.A"
reveal_type(x) # N: Revealed type is "builtins.int | __main__.A"
[builtins fixtures/isinstancelist.pyi]
[case testIssubclassUnreachable]
# flags: --warn-unreachable
from typing import Type, Sequence, Union
x: Type[str]
if issubclass(x, int): # E: Subclass of "str" and "int" cannot exist: would have incompatible method signatures
reveal_type(x) # E: Statement is unreachable
class X: pass
class Y(X): pass
class Z(X): pass
a: Union[Type[Y], Type[Z]]
if issubclass(a, X):
reveal_type(a) # N: Revealed type is "type[__main__.Y] | type[__main__.Z]"
else:
reveal_type(a) # E: Statement is unreachable
[builtins fixtures/isinstancelist.pyi]
[case testIssubclasDestructuringUnions1]
# flags: --warn-unreachable
from typing import Union, List, Tuple, Dict, Type
def f(x: Union[Type[int], Type[str], Type[List]]) -> None:
if issubclass(x, (str, (int,))):
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str"
x()[1] # E: Value of type "int | str" is not indexable
else:
reveal_type(x) # N: Revealed type is "type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.list[Any]"
x()[1]
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
if issubclass(x, (str, (list,))):
reveal_type(x) # N: Revealed type is "type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.str | builtins.list[Any]"
x()[1]
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
[builtins fixtures/isinstancelist.pyi]
[case testIssubclasDestructuringUnions2]
# flags: --warn-unreachable
from typing import Union, List, Tuple, Dict, Type
def f(x: Type[Union[int, str, List]]) -> None:
if issubclass(x, (str, (int,))):
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str"
x()[1] # E: Value of type "int | str" is not indexable
else:
reveal_type(x) # N: Revealed type is "type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.list[Any]"
x()[1]
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
if issubclass(x, (str, (list,))):
reveal_type(x) # N: Revealed type is "type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.str | builtins.list[Any]"
x()[1]
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
[builtins fixtures/isinstancelist.pyi]
[case testIssubclasDestructuringUnions3]
# flags: --warn-unreachable
from typing import Union, List, Tuple, Dict, Type
def f(x: Type[Union[int, str, List]]) -> None:
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
if issubclass(x, (str, (int,))):
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str"
x()[1] # E: Value of type "int | str" is not indexable
else:
reveal_type(x) # N: Revealed type is "type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.list[Any]"
x()[1]
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
if issubclass(x, (str, (list,))):
reveal_type(x) # N: Revealed type is "type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.str | builtins.list[Any]"
x()[1]
reveal_type(x) # N: Revealed type is "type[builtins.int] | type[builtins.str] | type[builtins.list[Any]]"
reveal_type(x()) # N: Revealed type is "builtins.int | builtins.str | builtins.list[Any]"
[builtins fixtures/isinstancelist.pyi]
[case testIssubclass]
# flags: --warn-unreachable
from typing import Type, ClassVar
class Goblin:
level: int
class GoblinAmbusher(Goblin):
job: ClassVar[str] = 'Ranger'
def test_issubclass(cls: Type[Goblin]) -> None:
if issubclass(cls, GoblinAmbusher):
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinAmbusher]"
cls.level
cls.job
ga = cls()
ga.level = 15
ga.job
ga.job = "Warrior" # E: Cannot assign to class variable "job" via instance
else:
reveal_type(cls) # N: Revealed type is "type[__main__.Goblin]"
cls.level
cls.job # E: "type[Goblin]" has no attribute "job"
g = cls()
g.level = 15
g.job # E: "Goblin" has no attribute "job"
[builtins fixtures/isinstancelist.pyi]
[case testIssubclassDeepHierarchy]
# flags: --warn-unreachable
from typing import Type, ClassVar
class Mob: pass
class Goblin(Mob):
level: int
class GoblinAmbusher(Goblin):
job: ClassVar[str] = 'Ranger'
def test_issubclass(cls: Type[Mob]) -> None:
if issubclass(cls, Goblin):
reveal_type(cls) # N: Revealed type is "type[__main__.Goblin]"
cls.level
cls.job # E: "type[Goblin]" has no attribute "job"
g = cls()
g.level = 15
g.job # E: "Goblin" has no attribute "job"
if issubclass(cls, GoblinAmbusher):
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinAmbusher]"
cls.level
cls.job
g = cls()
g.level = 15
g.job
g.job = 'Warrior' # E: Cannot assign to class variable "job" via instance
else:
reveal_type(cls) # N: Revealed type is "type[__main__.Mob]"
cls.job # E: "type[Mob]" has no attribute "job"
cls.level # E: "type[Mob]" has no attribute "level"
m = cls()
m.level = 15 # E: "Mob" has no attribute "level"
m.job # E: "Mob" has no attribute "job"
if issubclass(cls, GoblinAmbusher):
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinAmbusher]"
cls.job
cls.level
ga = cls()
ga.level = 15
ga.job
ga.job = 'Warrior' # E: Cannot assign to class variable "job" via instance
if issubclass(cls, GoblinAmbusher):
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinAmbusher]"
cls.level
cls.job
ga = cls()
ga.level = 15
ga.job
ga.job = "Warrior" # E: Cannot assign to class variable "job" via instance
[builtins fixtures/isinstancelist.pyi]
[case testIssubclassTuple]
# flags: --warn-unreachable
from typing import Type, ClassVar
class Mob: pass
class Goblin(Mob):
level: int
class GoblinAmbusher(Goblin):
job: ClassVar[str] = 'Ranger'
class GoblinDigger(Goblin):
job: ClassVar[str] = 'Thief'
def test_issubclass(cls: Type[Mob]) -> None:
if issubclass(cls, (Goblin, GoblinAmbusher)):
reveal_type(cls) # N: Revealed type is "type[__main__.Goblin]"
cls.level
cls.job # E: "type[Goblin]" has no attribute "job"
g = cls()
g.level = 15
g.job # E: "Goblin" has no attribute "job"
if issubclass(cls, GoblinAmbusher):
cls.level
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinAmbusher]"
cls.job
ga = cls()
ga.level = 15
ga.job
ga.job = "Warrior" # E: Cannot assign to class variable "job" via instance
else:
reveal_type(cls) # N: Revealed type is "type[__main__.Mob]"
cls.job # E: "type[Mob]" has no attribute "job"
cls.level # E: "type[Mob]" has no attribute "level"
m = cls()
m.level = 15 # E: "Mob" has no attribute "level"
m.job # E: "Mob" has no attribute "job"
if issubclass(cls, GoblinAmbusher):
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinAmbusher]"
cls.job
cls.level
ga = cls()
ga.level = 15
ga.job
ga.job = "Warrior" # E: Cannot assign to class variable "job" via instance
if issubclass(cls, (GoblinDigger, GoblinAmbusher)):
reveal_type(cls) # N: Revealed type is "type[__main__.GoblinDigger] | type[__main__.GoblinAmbusher]"
cls.level
cls.job
g = cls()
g.level = 15
g.job
g.job = "Warrior" # E: Cannot assign to class variable "job" via instance
[builtins fixtures/isinstancelist.pyi]
[case testIssubclassBuiltins]
# flags: --warn-unreachable
from typing import List, Type
class MyList(List): pass
class MyIntList(List[int]): pass
def f(cls: Type[object]) -> None:
if issubclass(cls, MyList):
reveal_type(cls) # N: Revealed type is "type[__main__.MyList]"
cls()[0]
else:
reveal_type(cls) # N: Revealed type is "type[builtins.object]"
cls()[0] # E: Value of type "object" is not indexable
if issubclass(cls, MyIntList):
reveal_type(cls) # N: Revealed type is "type[__main__.MyIntList]"
cls()[0] + 1
[builtins fixtures/isinstancelist.pyi]
[case testIssubclassTypeVar]
# flags: --strict-equality --warn-unreachable
from __future__ import annotations
from typing import TypeVar
ClassT = TypeVar("ClassT", bound=type)
def directed_meet(cls0: ClassT, cls1: ClassT) -> ClassT | None:
if issubclass(cls1, cls0):
return cls1
if issubclass(cls0, cls1):
return cls0
return None
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceTypeArgs]
# flags: --warn-unreachable
from typing import Iterable, TypeVar
x = 1
isinstance(x, Iterable)
isinstance(x, Iterable[int]) # E: Parameterized generics cannot be used with class or instance checks
isinstance(x, (int, Iterable[int])) # E: Parameterized generics cannot be used with class or instance checks
isinstance(x, (int, (str, Iterable[int]))) # E: Parameterized generics cannot be used with class or instance checks
[builtins fixtures/isinstancelist.pyi]
[typing fixtures/typing-full.pyi]
[case testIsinstanceAnyAlias]
# flags: --warn-unreachable
from typing import Any
A = Any
isinstance(object(), A) # E: Cannot use isinstance() with Any type
[builtins fixtures/isinstance.pyi]
[case testIsinstanceTypeArgsAliases]
# flags: --warn-unreachable
from typing import Iterable, TypeVar
x = 1
T = TypeVar('T')
It = Iterable
It2 = Iterable[T]
isinstance(x, It[int]) # E: Parameterized generics cannot be used with class or instance checks
isinstance(x, It)
isinstance(x, It2[int]) # E: Parameterized generics cannot be used with class or instance checks
isinstance(x, It2) # E: Parameterized generics cannot be used with class or instance checks
[builtins fixtures/isinstance.pyi]
[typing fixtures/typing-full.pyi]
[case testIssubclassTypeArgs]
# flags: --warn-unreachable
from typing import Iterable, TypeVar
x = int
issubclass(x, Iterable)
issubclass(x, Iterable[int]) # E: Parameterized generics cannot be used with class or instance checks
issubclass(x, (int, Iterable[int])) # E: Parameterized generics cannot be used with class or instance checks
[builtins fixtures/isinstance.pyi]
[typing fixtures/typing-full.pyi]
[case testIssubclassWithMetaclasses]
# flags: --no-strict-optional --warn-unreachable
class FooMetaclass(type): ...
class Foo(metaclass=FooMetaclass): ...
class Bar: ...
fm: FooMetaclass
reveal_type(fm) # N: Revealed type is "__main__.FooMetaclass"
if issubclass(fm, Foo):
reveal_type(fm) # N: Revealed type is "type[__main__.Foo]"
if issubclass(fm, Bar):
reveal_type(fm) # N: Revealed type is "None"
[builtins fixtures/isinstance.pyi]
[case testIssubclassWithMetaclassesStrictOptional]
# flags: --warn-unreachable
class FooMetaclass(type): ...
class BarMetaclass(type): ...
class Foo(metaclass=FooMetaclass): ...
class Bar(metaclass=BarMetaclass): ...
class Baz: ...
fm: FooMetaclass
reveal_type(fm) # N: Revealed type is "__main__.FooMetaclass"
if issubclass(fm, Foo):
reveal_type(fm) # N: Revealed type is "type[__main__.Foo]"
if issubclass(fm, Bar):
reveal_type(fm) # N: Revealed type is "type[__main__.Bar]"
if issubclass(fm, Baz):
reveal_type(fm) # N: Revealed type is "type[__main__.Baz]"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceAndNarrowTypeVariable]
# flags: --warn-unreachable
from typing import TypeVar
class A: pass
class B(A):
attr: int
T = TypeVar('T', bound=A)
def f(x: T) -> None:
if isinstance(x, B):
reveal_type(x) # N: Revealed type is "T`-1"
reveal_type(x.attr) # N: Revealed type is "builtins.int"
else:
reveal_type(x) # N: Revealed type is "T`-1"
x.attr # E: "T" has no attribute "attr"
reveal_type(x) # N: Revealed type is "T`-1"
x.attr # E: "T" has no attribute "attr"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceAndNegativeNarrowTypeVariableWithUnionBound1]
# flags: --warn-unreachable
from typing import Union, TypeVar
class A:
a: int
class B:
b: int
T = TypeVar("T", bound=Union[A, B])
def f(x: T) -> T:
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "T`-1"
x.a
x.b # E: "T" has no attribute "b"
if bool():
return x
else:
reveal_type(x) # N: Revealed type is "T`-1"
x.a # E: "T" has no attribute "a"
x.b
x.a # E: Item "B" of the upper bound "A | B" of type variable "T" has no attribute "a"
x.b # E: Item "A" of the upper bound "A | B" of type variable "T" has no attribute "b"
return x
[builtins fixtures/isinstance.pyi]
[case testIsinstanceAndNegativeNarrowTypeVariableWithUnionBound2]
# flags: --warn-unreachable
from typing import Union, TypeVar
class A:
a: int
class B:
b: int
T = TypeVar("T", bound=Union[A, B])
def f(x: T) -> T:
if isinstance(x, A):
return x
x.a # E: "T" has no attribute "a"
x.b # OK
return x
[builtins fixtures/isinstance.pyi]
[case testIsinstanceAndTypeType]
# flags: --warn-unreachable
from typing import Type
def f(x: Type[int]) -> None:
if isinstance(x, type):
reveal_type(x) # N: Revealed type is "type[builtins.int]"
else:
reveal_type(x) # E: Statement is unreachable
reveal_type(x) # N: Revealed type is "type[builtins.int]"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceVariableSubstitution]
# flags: --warn-unreachable
T = (int, str)
U = (list, T)
x: object = None
if isinstance(x, T):
reveal_type(x) # N: Revealed type is "builtins.int | builtins.str"
if isinstance(x, U):
reveal_type(x) # N: Revealed type is "builtins.list[Any] | builtins.int | builtins.str"
if isinstance(x, (set, (list, T))):
reveal_type(x) # N: Revealed type is "builtins.set[Any] | builtins.list[Any] | builtins.int | builtins.str"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceTooFewArgs]
# flags: --warn-unreachable
isinstance() # E: Missing positional arguments "x", "t" in call to "isinstance"
x: object
if isinstance(): # E: Missing positional arguments "x", "t" in call to "isinstance"
x = 1
reveal_type(x) # N: Revealed type is "builtins.int"
if isinstance(x): # E: Missing positional argument "t" in call to "isinstance"
x = 1
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/isinstancelist.pyi]
[case testIsSubclassTooFewArgs]
# flags: --warn-unreachable
from typing import Type
issubclass() # E: Missing positional arguments "x", "t" in call to "issubclass"
y: Type[object]
if issubclass(): # E: Missing positional arguments "x", "t" in call to "issubclass"
reveal_type(y) # N: Revealed type is "type[builtins.object]"
if issubclass(y): # E: Missing positional argument "t" in call to "issubclass"
reveal_type(y) # N: Revealed type is "type[builtins.object]"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceTooManyArgs]
# flags: --warn-unreachable
isinstance(1, 1, 1) # E: Too many arguments for "isinstance" \
# E: Argument 2 to "isinstance" has incompatible type "int"; expected "type | tuple[Any, ...]"
x: object
if isinstance(x, str, 1): # E: Too many arguments for "isinstance"
reveal_type(x) # N: Revealed type is "builtins.object"
x = 1
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/isinstancelist.pyi]
[case testIsinstanceNarrowAnyExplicit]
# flags: --warn-unreachable
from typing import Any
def narrow_any_to_str_then_reassign_to_int() -> None:
v: Any = 1
if isinstance(v, str):
reveal_type(v) # N: Revealed type is "builtins.str"
v = 2
reveal_type(v) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceNarrowAnyImplicit]
# flags: --warn-unreachable
def foo(): ...
def narrow_any_to_str_then_reassign_to_int() -> None:
v = foo()
if isinstance(v, str):
reveal_type(v) # N: Revealed type is "builtins.str"
v = 2
reveal_type(v) # N: Revealed type is "builtins.int"
[builtins fixtures/isinstance.pyi]
[case testNarrowTypeAfterInList]
# flags: --warn-unreachable
from typing import List, Optional
x: List[int]
y: Optional[int]
if y in x:
reveal_type(y) # N: Revealed type is "builtins.int"
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
if y not in x:
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int"
[builtins fixtures/list.pyi]
[case testNarrowTypeAfterInListOfOptional]
# flags: --warn-unreachable
from typing import List, Optional
x: List[Optional[int]]
y: Optional[int]
if y not in x:
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
[builtins fixtures/list.pyi]
[case testNarrowTypeAfterInListNonOverlapping]
# flags: --warn-unreachable
from typing import List, Optional
def f(x: List[str], y: Optional[int]) -> None:
if y in x:
reveal_type(y) # E: Statement is unreachable
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
[builtins fixtures/list.pyi]
[case testNarrowTypeAfterInListNested]
# flags: --warn-unreachable
from typing import List, Optional, Any
def f(x: Optional[int], lst: Optional[List[int]], nested_any: List[List[Any]]) -> None:
if lst in nested_any:
reveal_type(lst) # N: Revealed type is "builtins.list[builtins.int]"
if x in nested_any:
reveal_type(x) # E: Statement is unreachable
[builtins fixtures/list.pyi]
[case testNarrowTypeAfterInTuple]
# flags: --warn-unreachable
class A: pass
class B(A): pass
class C(A): pass
def f(y: B | None):
if y in (B(), C()):
reveal_type(y) # N: Revealed type is "__main__.B"
else:
reveal_type(y) # N: Revealed type is "__main__.B | None"
[builtins fixtures/tuple.pyi]
[case testNarrowTypeAfterInNamedTuple]
# flags: --warn-unreachable
from typing import NamedTuple, Optional
class NT(NamedTuple):
x: int
y: int
nt: NT
y: Optional[int]
if y not in nt:
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testNarrowTypeAfterInDict]
# flags: --warn-unreachable
from typing import Dict, Optional
x: Dict[str, int]
y: Optional[str]
if y in x:
reveal_type(y) # N: Revealed type is "builtins.str"
else:
reveal_type(y) # N: Revealed type is "builtins.str | None"
if y not in x:
reveal_type(y) # N: Revealed type is "builtins.str | None"
else:
reveal_type(y) # N: Revealed type is "builtins.str"
[builtins fixtures/dict.pyi]
[case testNarrowTypeAfterInNoAnyOrObject]
# flags: --warn-unreachable
from typing import Any, List, Optional
x: List[Any]
z: List[object]
y: Optional[int]
if y in x:
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
if y not in z:
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
[typing fixtures/typing-medium.pyi]
[builtins fixtures/list.pyi]
[case testNarrowTypeAfterInUserDefined]
# flags: --warn-unreachable
from typing import Container, Optional
class C(Container[int]):
def __contains__(self, item: object) -> bool:
return item is 'surprise'
y: Optional[int]
# We never trust user defined types
if y in C():
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
if y not in C():
reveal_type(y) # N: Revealed type is "builtins.int | None"
else:
reveal_type(y) # N: Revealed type is "builtins.int | None"
[typing fixtures/typing-full.pyi]
[builtins fixtures/list.pyi]
[case testNarrowTypeAfterInSet]
# flags: --warn-unreachable
from typing import Optional, Set
s: Set[str]
y: Optional[str]
if y in {'a', 'b', 'c'}:
reveal_type(y) # N: Revealed type is "builtins.str"
else:
reveal_type(y) # N: Revealed type is "builtins.str | None"
if y not in s:
reveal_type(y) # N: Revealed type is "builtins.str | None"
else:
reveal_type(y) # N: Revealed type is "builtins.str"
[builtins fixtures/set.pyi]
[case testNarrowTypeAfterInTypedDict]
# flags: --warn-unreachable
from typing import Optional, TypedDict
class TD(TypedDict):
a: int
b: str
td: TD
def f() -> None:
x: Optional[str]
if x not in td:
return
reveal_type(x) # N: Revealed type is "builtins.str"
[builtins fixtures/dict.pyi]
[typing fixtures/typing-typeddict.pyi]
[case testIsinstanceWidensWithAnyArg]
# flags: --warn-unreachable
from typing import Any
class A: ...
B: Any
x: A
x.foo() # E: "A" has no attribute "foo"
assert isinstance(x, B)
x.foo()
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceWidensUnionWithAnyArg]
# flags: --warn-unreachable
from typing import Any, Union
class A: ...
B: Any
x: Union[A, B]
reveal_type(x) # N: Revealed type is "__main__.A | Any"
assert isinstance(x, B)
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceNarrowsAfterNoneCheckWithAnyUnion]
# flags: --warn-unreachable
from typing import Any, Union
def f(val: Union[Any, str]) -> None:
if val is None or isinstance(val, str):
reveal_type(val) # N: Revealed type is "None | builtins.str"
return
reveal_type(val) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testIsinstanceIgnoredImport]
# flags: --warn-unreachable
from typing import Union
from foo import A # type: ignore
def f(x: Union[A, str]) -> None:
x.method_only_in_a() # E: Item "str" of "Any | str" has no attribute "method_only_in_a"
if isinstance(x, A):
x.method_only_in_a()
[builtins fixtures/isinstance.pyi]
[case testIsinstanceIgnoredImportDualAny]
# flags: --warn-unreachable
from typing import Any
from foo import Bad, OtherBad # type: ignore
x: Any
if isinstance(x, Bad):
reveal_type(x) # N: Revealed type is "Any"
else:
reveal_type(x) # N: Revealed type is "Any"
if isinstance(x, (Bad, OtherBad)):
reveal_type(x) # N: Revealed type is "Any"
else:
reveal_type(x) # N: Revealed type is "Any"
y: object
if isinstance(y, Bad):
reveal_type(y) # N: Revealed type is "Any"
else:
reveal_type(y) # N: Revealed type is "builtins.object"
class Ok: pass
z: Any
if isinstance(z, Ok):
reveal_type(z) # N: Revealed type is "__main__.Ok"
else:
reveal_type(z) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceInitialNoneCheckSkipsImpossibleCasesNoStrictOptional]
# flags: --warn-unreachable
from typing import Optional, Union
class A: pass
def foo1(x: Union[A, str, None]) -> None:
if x is None:
reveal_type(x) # N: Revealed type is "None"
elif isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # N: Revealed type is "builtins.str"
def foo2(x: Optional[str]) -> None:
if x is None:
reveal_type(x) # N: Revealed type is "None"
elif isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "builtins.str" and "__main__.A">"
else:
reveal_type(x) # N: Revealed type is "builtins.str"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceInitialNoneCheckSkipsImpossibleCasesInNoStrictOptional]
# flags: --no-strict-optional --warn-unreachable
from typing import Optional, Union
class A: pass
def foo1(x: Union[A, str, None]) -> None:
if x is None:
reveal_type(x) # N: Revealed type is "None"
elif isinstance(x, A):
# Note that Union[None, A] == A in no-strict-optional
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # N: Revealed type is "builtins.str"
def foo2(x: Optional[str]) -> None:
if x is None:
reveal_type(x) # N: Revealed type is "None"
elif isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "builtins.str" and "__main__.A">"
else:
reveal_type(x) # N: Revealed type is "builtins.str"
[builtins fixtures/isinstance.pyi]
[case testNoneCheckDoesNotMakeTypeVarOptional]
# flags: --warn-unreachable
from typing import TypeVar
T = TypeVar('T')
def foo_if(x: T) -> T:
out = None
out = x
if out is None:
pass
return out
def foo_while(x: T) -> T:
out = None
out = x
while out is None:
pass
return out
[builtins fixtures/isinstance.pyi]
[case testNoneCheckDoesNotNarrowWhenUsingTypeVarsNoStrictOptional]
# flags: --no-strict-optional --warn-unreachable
from typing import TypeVar
T = TypeVar('T')
def foo(x: T) -> T:
out = None
out = x
if out is None:
pass
return out
[builtins fixtures/isinstance.pyi]
[case testNoneAndGenericTypesOverlapNoStrictOptional]
# flags: --no-strict-optional --warn-unreachable
from typing import Union, Optional, List
# Note: this test is indirectly making sure meet.is_overlapping_types
# correctly ignores 'None' in unions.
def foo(x: Optional[List[str]]) -> None:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | None"
assert isinstance(x, list)
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str]"
def bar(x: Union[List[str], List[int], None]) -> None:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | builtins.list[builtins.int] | None"
assert isinstance(x, list)
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | builtins.list[builtins.int]"
[builtins fixtures/isinstancelist.pyi]
[case testNoneAndGenericTypesOverlapStrictOptional]
# flags: --warn-unreachable
from typing import Union, Optional, List
# This test is the same as the one above, except for strict-optional.
# It isn't testing anything explicitly and mostly exists for the sake
# of completeness.
def foo(x: Optional[List[str]]) -> None:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | None"
assert isinstance(x, list)
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str]"
def bar(x: Union[List[str], List[int], None]) -> None:
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | builtins.list[builtins.int] | None"
assert isinstance(x, list)
reveal_type(x) # N: Revealed type is "builtins.list[builtins.str] | builtins.list[builtins.int]"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithStarExpression]
# flags: --warn-unreachable
from typing import Union, List, Tuple
def f(var: Union[List[str], Tuple[str, str], str]) -> None:
reveal_type(var) # N: Revealed type is "builtins.list[builtins.str] | tuple[builtins.str, builtins.str] | builtins.str"
if isinstance(var, (list, *(str, int))):
reveal_type(var) # N: Revealed type is "builtins.list[builtins.str] | builtins.str"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithStarExpressionAndVariable]
# flags: --warn-unreachable
from typing import Union
def f(var: Union[int, str]) -> None:
reveal_type(var) # N: Revealed type is "builtins.int | builtins.str"
some_types = (str, tuple)
another_type = list
if isinstance(var, (*some_types, another_type)):
reveal_type(var) # N: Revealed type is "builtins.str"
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceWithWrongStarExpression]
# flags: --warn-unreachable
var = 'some string'
if isinstance(var, *(str, int)): # E: Too many arguments for "isinstance"
pass
[builtins fixtures/isinstancelist.pyi]
[case testIsInstanceAdHocIntersectionBasic]
# flags: --warn-unreachable
class A:
def f1(self) -> int: ...
class B:
def f2(self) -> int: ...
class C:
def f3(self) -> int: ...
x: A
if isinstance(x, B):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
if isinstance(x, C):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A", "__main__.B", and "__main__.C">"
reveal_type(x.f1()) # N: Revealed type is "builtins.int"
reveal_type(x.f2()) # N: Revealed type is "builtins.int"
reveal_type(x.f3()) # N: Revealed type is "builtins.int"
x.bad() # E: "<subclass of "__main__.A", "__main__.B", and "__main__.C">" has no attribute "bad"
else:
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
else:
reveal_type(x) # N: Revealed type is "__main__.A"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionRepeatedChecks]
# flags: --warn-unreachable
class A: pass
class B: pass
x: A
if isinstance(x, B):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
if isinstance(x, B):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionIncompatibleClasses]
# flags: --warn-unreachable
class A:
def f(self) -> int: ...
class B:
def f(self) -> str: ...
class C:
def f(self) -> str: ...
class Example(A, B): pass # E: Definition of "f" in base class "A" is incompatible with definition in base class "B"
x: A
if isinstance(x, B): # E: Subclass of "A" and "B" cannot exist: would have incompatible method signatures
reveal_type(x) # E: Statement is unreachable
else:
reveal_type(x) # N: Revealed type is "__main__.A"
y: C
if isinstance(y, B):
reveal_type(y) # N: Revealed type is "__main__.<subclass of "__main__.C" and "__main__.B">"
if isinstance(y, A): # E: Subclass of "C", "B", and "A" cannot exist: would have incompatible method signatures
reveal_type(y) # E: Statement is unreachable
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionReversed]
# flags: --warn-unreachable
from abc import abstractmethod
from typing import Literal
class A0:
def f(self) -> Literal[0]:
...
class A1:
def f(self) -> Literal[1]:
...
class A2:
def f(self) -> Literal[2]:
...
class B:
@abstractmethod
def f(self) -> Literal[1, 2]:
...
def t0(self) -> None:
if isinstance(self, A0): # E: Subclass of "B" and "A0" cannot exist: would have incompatible method signatures
x0: Literal[0] = self.f() # E: Statement is unreachable
def t1(self) -> None:
if isinstance(self, A1):
reveal_type(self) # N: Revealed type is "__main__.<subclass of "__main__.A1" and "__main__.B">"
x0: Literal[0] = self.f() # E: Incompatible types in assignment (expression has type "Literal[1]", variable has type "Literal[0]")
x1: Literal[1] = self.f()
def t2(self) -> None:
if isinstance(self, (A0, A1)):
reveal_type(self) # N: Revealed type is "__main__.<subclass of "__main__.A1" and "__main__.B">"
x0: Literal[0] = self.f() # E: Incompatible types in assignment (expression has type "Literal[1]", variable has type "Literal[0]")
x1: Literal[1] = self.f()
def t3(self) -> None:
if isinstance(self, (A1, A2)):
reveal_type(self) # N: Revealed type is "__main__.<subclass of "__main__.A1" and "__main__.B"> | __main__.<subclass of "__main__.A2" and "__main__.B">"
x0: Literal[0] = self.f() # E: Incompatible types in assignment (expression has type "Literal[1, 2]", variable has type "Literal[0]")
x1: Literal[1] = self.f() # E: Incompatible types in assignment (expression has type "Literal[1, 2]", variable has type "Literal[1]")
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionGenerics]
# flags: --warn-unreachable
from typing import Generic, TypeVar
class Parent: pass
class Child(Parent): pass
T = TypeVar('T')
class A(Generic[T]):
def f(self) -> T: ...
class B:
def f(self) -> Parent: ...
x: A[int]
if isinstance(x, B): # E: Subclass of "A[int]" and "B" cannot exist: would have incompatible method signatures
reveal_type(x) # E: Statement is unreachable
else:
reveal_type(x) # N: Revealed type is "__main__.A[builtins.int]"
y: A[Parent]
if isinstance(y, B):
reveal_type(y) # N: Revealed type is "__main__.<subclass of "__main__.A[__main__.Parent]" and "__main__.B">"
reveal_type(y.f()) # N: Revealed type is "__main__.Parent"
else:
reveal_type(y) # N: Revealed type is "__main__.A[__main__.Parent]"
z: A[Child]
if isinstance(z, B):
reveal_type(z) # N: Revealed type is "__main__.<subclass of "__main__.A[__main__.Child]" and "__main__.B">"
reveal_type(z.f()) # N: Revealed type is "__main__.Child"
else:
reveal_type(z) # N: Revealed type is "__main__.A[__main__.Child]"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionGenericsWithValues]
# flags: --warn-unreachable
from typing import TypeVar
class A:
attr: int
class B:
attr: int
class C:
attr: str
T1 = TypeVar('T1', A, B)
def f1(x: T1) -> T1:
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.A" \
# N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
if isinstance(x, B):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">" \
# N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
else:
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # N: Revealed type is "__main__.B"
return x
T2 = TypeVar('T2', B, C)
def f2(x: T2) -> T2:
if isinstance(x, B):
reveal_type(x) # N: Revealed type is "__main__.B"
# Note: even though --warn-unreachable is set, we don't report
# errors for the below: we don't yet have a way of filtering out
# reachability errors that occur for only one variation of the
# TypeVar yet.
if isinstance(x, C):
reveal_type(x)
else:
reveal_type(x) # N: Revealed type is "__main__.B"
else:
reveal_type(x) # N: Revealed type is "__main__.C"
return x
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionGenericsWithValuesDirectReturn]
# flags: --warn-unreachable
from typing import TypeVar
class A:
attr: int
class B:
attr: int
class C:
attr: str
T1 = TypeVar('T1', A, B)
def f1(x: T1) -> T1:
if isinstance(x, A):
# The error message is confusing, but we indeed do run into problems if
# 'x' is a subclass of __main__.A and __main__.B
return A() # E: Incompatible return value type (got "A", expected "B")
else:
return B()
T2 = TypeVar('T2', B, C)
def f2(x: T2) -> T2:
if isinstance(x, B):
# In contrast, it's impossible for a subclass of "B" and "C" to
# exist, so this is fine
return B()
else:
return C()
[builtins fixtures/isinstance.pyi]
[case testIsInstanceDisjointBase]
# flags: --warn-unreachable
from typing_extensions import disjoint_base
@disjoint_base
class Disjoint1: pass
@disjoint_base
class Disjoint2: pass
@disjoint_base
class Disjoint3(Disjoint1): pass
class Child(Disjoint1): pass
class Unrelated: pass
def f(d1: Disjoint1, u: Unrelated, c: Child) -> object:
if isinstance(d1, Disjoint2): # E: Subclass of "Disjoint1" and "Disjoint2" cannot exist: have distinct disjoint bases
return u # E: Statement is unreachable
if isinstance(u, Disjoint1): # OK
return d1
if isinstance(c, Disjoint3): # OK
return c
if isinstance(c, Disjoint2): # E: Subclass of "Child" and "Disjoint2" cannot exist: have distinct disjoint bases
return c # E: Statement is unreachable
return d1
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionUsage]
# flags: --warn-unreachable
class A: pass
class B: pass
class Concrete(A, B): pass
def accept_a(a: A) -> None: pass
def accept_b(a: B) -> None: pass
def accept_concrete(c: Concrete) -> None: pass
x: A
if isinstance(x, B):
var = x
reveal_type(var) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
accept_a(var)
accept_b(var)
accept_concrete(var) # E: Argument 1 to "accept_concrete" has incompatible type "<subclass of "__main__.A" and "__main__.B">"; expected "Concrete"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionReinfer]
# flags: --warn-unreachable
class A: pass
class B: pass
x: A
assert isinstance(x, B)
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
y: A
assert isinstance(y, B)
reveal_type(y) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
x = y
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionWithUnions]
# flags: --warn-unreachable
from typing import Type, Union
class A: pass
class B: pass
class C: pass
class D: pass
v1: A
if isinstance(v1, (B, C)):
reveal_type(v1) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B"> | __main__.<subclass of "__main__.A" and "__main__.C">"
v2: Union[A, B]
if isinstance(v2, C):
reveal_type(v2) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.C"> | __main__.<subclass of "__main__.B" and "__main__.C">"
v3: Union[A, B]
if isinstance(v3, (C, D)):
reveal_type(v3) # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.C"> | __main__.<subclass of "__main__.A" and "__main__.D"> | __main__.<subclass of "__main__.B" and "__main__.C"> | __main__.<subclass of "__main__.B" and "__main__.D">"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionSameNames]
# flags: --warn-unreachable
from foo import A as A2
class A: pass
x: A
if isinstance(x, A2):
reveal_type(x) # N: Revealed type is "__main__.<subclass of "__main__.A" and "foo.A">"
[file foo.py]
class A: pass
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionBadMro]
# flags: --warn-unreachable
class X: pass
class Y: pass
class A(X, Y): pass
class B(Y, X): pass
foo: A
if isinstance(foo, B): # E: Subclass of "A" and "B" cannot exist: would have inconsistent method resolution order
reveal_type(foo) # E: Statement is unreachable
[builtins fixtures/isinstance.pyi]
[case testIsInstanceAdHocIntersectionAmbiguousClass]
# flags: --warn-unreachable
from typing import Any
class Concrete:
x: int
class Ambiguous:
x: Any
# We bias towards assuming these two classes could be overlapping
foo: Concrete
if isinstance(foo, Ambiguous):
reveal_type(foo) # N: Revealed type is "__main__.<subclass of "__main__.Concrete" and "__main__.Ambiguous">"
reveal_type(foo.x) # N: Revealed type is "builtins.int"
[builtins fixtures/isinstance.pyi]
[case testIsSubclassAdHocIntersection]
# flags: --warn-unreachable
from typing import Type
class A:
x: int
class B:
x: int
class C:
x: str
x: Type[A]
if issubclass(x, B):
reveal_type(x) # N: Revealed type is "type[__main__.<subclass of "__main__.A" and "__main__.B">]"
if issubclass(x, C): # E: Subclass of "A", "B", and "C" cannot exist: would have incompatible method signatures
reveal_type(x) # E: Statement is unreachable
else:
reveal_type(x) # N: Revealed type is "type[__main__.<subclass of "__main__.A" and "__main__.B">]"
else:
reveal_type(x) # N: Revealed type is "type[__main__.A]"
[builtins fixtures/isinstance.pyi]
[case testHasAttrExistingAttribute]
# flags: --warn-unreachable
class C:
x: int
c: C
if hasattr(c, "x"):
reveal_type(c.x) # N: Revealed type is "builtins.int"
else:
# We don't mark this unreachable since people may check for deleted attributes
reveal_type(c.x) # N: Revealed type is "builtins.int"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeInstance]
# flags: --warn-unreachable
class B: ...
b: B
if hasattr(b, "x"):
reveal_type(b.x) # N: Revealed type is "Any"
else:
b.x # E: "B" has no attribute "x"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeFunction]
# flags: --warn-unreachable
def foo(x: int) -> None: ...
if hasattr(foo, "x"):
reveal_type(foo.x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeClassObject]
# flags: --warn-unreachable
class C: ...
if hasattr(C, "x"):
reveal_type(C.x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeTypeType]
# flags: --warn-unreachable
from typing import Type
class C: ...
c: Type[C]
if hasattr(c, "x"):
reveal_type(c.x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeTypeVar]
# flags: --warn-unreachable
from typing import TypeVar
T = TypeVar("T")
def foo(x: T) -> T:
if hasattr(x, "x"):
reveal_type(x.x) # N: Revealed type is "Any"
return x
else:
return x
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeChained]
# flags: --warn-unreachable
class B: ...
b: B
if hasattr(b, "x"):
reveal_type(b.x) # N: Revealed type is "Any"
elif hasattr(b, "y"):
reveal_type(b.y) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeNested]
# flags: --warn-unreachable
class A: ...
class B: ...
x: A
if hasattr(x, "x"):
if isinstance(x, B):
reveal_type(x.x) # N: Revealed type is "Any"
if hasattr(x, "x") and hasattr(x, "y"):
reveal_type(x.x) # N: Revealed type is "Any"
reveal_type(x.y) # N: Revealed type is "Any"
if hasattr(x, "x"):
if hasattr(x, "y"):
reveal_type(x.x) # N: Revealed type is "Any"
reveal_type(x.y) # N: Revealed type is "Any"
if hasattr(x, "x") or hasattr(x, "y"):
x.x # E: "A" has no attribute "x"
x.y # E: "A" has no attribute "y"
[builtins fixtures/isinstance.pyi]
[case testHasAttrPreciseType]
# flags: --warn-unreachable
class A: ...
x: A
if hasattr(x, "a") and isinstance(x.a, int):
reveal_type(x.a) # N: Revealed type is "builtins.int"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeUnion]
# flags: --warn-unreachable
from typing import Union
class A: ...
class B:
x: int
xu: Union[A, B]
if hasattr(xu, "x"):
reveal_type(xu) # N: Revealed type is "__main__.A | __main__.B"
reveal_type(xu.x) # N: Revealed type is "Any | builtins.int"
else:
reveal_type(xu) # N: Revealed type is "__main__.A"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeOuterUnion]
# flags: --warn-unreachable
from typing import Union
class A: ...
class B: ...
xu: Union[A, B]
if isinstance(xu, B):
if hasattr(xu, "x"):
reveal_type(xu.x) # N: Revealed type is "Any"
if isinstance(xu, B) and hasattr(xu, "x"):
reveal_type(xu.x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testHasAttrDoesntInterfereGetAttr]
# flags: --warn-unreachable
class C:
def __getattr__(self, attr: str) -> str: ...
c: C
if hasattr(c, "foo"):
reveal_type(c.foo) # N: Revealed type is "builtins.str"
[builtins fixtures/isinstance.pyi]
[case testHasAttrMissingAttributeLiteral]
# flags: --warn-unreachable
from typing import Final
class B: ...
b: B
ATTR: Final = "x"
if hasattr(b, ATTR):
reveal_type(b.x) # N: Revealed type is "Any"
else:
b.x # E: "B" has no attribute "x"
[builtins fixtures/isinstance.pyi]
[case testHasAttrDeferred]
# flags: --warn-unreachable
def foo() -> str: ...
class Test:
def stream(self) -> None:
if hasattr(self, "_body"):
reveal_type(self._body) # N: Revealed type is "builtins.str"
def body(self) -> str:
if not hasattr(self, "_body"):
self._body = foo()
return self._body
[builtins fixtures/isinstance.pyi]
[case testHasAttrModule]
# flags: --warn-unreachable
import mod
if hasattr(mod, "y"):
reveal_type(mod.y) # N: Revealed type is "Any"
reveal_type(mod.x) # N: Revealed type is "builtins.int"
else:
mod.y # E: Module has no attribute "y"
reveal_type(mod.x) # N: Revealed type is "builtins.int"
if hasattr(mod, "x"):
mod.y # E: Module has no attribute "y"
reveal_type(mod.x) # N: Revealed type is "builtins.int"
else:
mod.y # E: Module has no attribute "y"
reveal_type(mod.x) # N: Revealed type is "builtins.int"
[file mod.py]
x: int
[builtins fixtures/module.pyi]
[case testHasAttrDoesntInterfereModuleGetAttr]
# flags: --warn-unreachable
import mod
if hasattr(mod, "y"):
reveal_type(mod.y) # N: Revealed type is "builtins.str"
[file mod.py]
def __getattr__(attr: str) -> str: ...
[builtins fixtures/module.pyi]
[case testMultipleHasAttr]
# flags: --warn-unreachable
# https://github.com/python/mypy/issues/20596
from __future__ import annotations
from typing import Any
def len(obj: object) -> Any: ...
def f(x: type | str):
if (
hasattr(x, "__origin__")
and x.__origin__ is list
and hasattr(x, "__args__")
and len(x.__args__) == 1
):
reveal_type(x.__args__[0]) # N: Revealed type is "Any"
[builtins fixtures/module.pyi]
[case testTypeIsntLostAfterNarrowing]
# flags: --warn-unreachable
from typing import Any
var: Any
reveal_type(var) # N: Revealed type is "Any"
assert isinstance(var, (bool, str))
reveal_type(var) # N: Revealed type is "builtins.bool | builtins.str"
if isinstance(var, bool):
reveal_type(var) # N: Revealed type is "builtins.bool"
# Type of var shouldn't fall back to Any
reveal_type(var) # N: Revealed type is "builtins.bool | builtins.str"
[builtins fixtures/isinstance.pyi]
[case testReuseIntersectionForRepeatedIsinstanceCalls]
# flags: --warn-unreachable
class A: ...
class B: ...
a: A
if isinstance(a, B):
c = a
if isinstance(a, B):
c = a
[builtins fixtures/isinstance.pyi]
[case testIsInstanceTypeAny]
# flags: --strict-equality --warn-unreachable
from typing import Any
def foo(x: object, t: type[Any]):
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceObject]
# flags: --strict-equality --warn-unreachable
from typing import Any
def foo(x: object, t: object):
if isinstance(x, t): # E: Argument 2 to "isinstance" has incompatible type "object"; expected "type[object] | tuple[type[object], ...]"
reveal_type(x) # N: Revealed type is "builtins.object"
[builtins fixtures/isinstance.pyi]
[case testIsInstanceOrExprInTuple]
# flags: --strict-equality --warn-unreachable
from typing import Any
def f1(x: object):
if isinstance(x, str | (int, dict)): # E: Argument 2 to "isinstance" has incompatible type "object"; expected "type | tuple[Any, ...]"
reveal_type(x) # N: Revealed type is "builtins.str"
if type(x) == str | (int, dict):
reveal_type(x) # N: Revealed type is "builtins.object"
def f2(x: Any):
if isinstance(x, str | (int, dict)): # E: Argument 2 to "isinstance" has incompatible type "object"; expected "type | tuple[Any, ...]"
reveal_type(x) # N: Revealed type is "builtins.str"
if type(x) == str | (int, dict):
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/primitives.pyi]
[case testIsInstanceUnionOfTuples]
# flags: --strict-equality --warn-unreachable
from __future__ import annotations
from typing import TypeVar, Iterator, final
T1 = TypeVar("T1")
T2 = TypeVar("T2")
T3 = TypeVar("T3")
def extract(
values: object,
ts: (
tuple[type[T1]]
| tuple[type[T1], type[T2]]
| tuple[type[T1], type[T2], type[T3]]
)
) -> Iterator[T1 | T2 | T3]:
if isinstance(values, ts):
reveal_type(values) # N: Revealed type is "T1`-1 | T2`-2 | T3`-3"
yield values
raise
class A: ...
class B: ...
def f1(x: A | B, t: tuple[type[A]] | tuple[type[B]]):
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A | __main__.B"
else:
reveal_type(x) # N: Revealed type is "__main__.A | __main__.B"
def f2(x: object, t: tuple[type[A]] | tuple[type[B]]):
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A | __main__.B"
else:
reveal_type(x) # N: Revealed type is "builtins.object"
@final
class FA: ...
@final
class FB: ...
def g1(x: FA | FB, t: tuple[type[FA]] | tuple[type[FB]]):
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.FA | __main__.FB"
else:
reveal_type(x) # N: Revealed type is "__main__.FA | __main__.FB"
def g2(x: object, t: tuple[type[FA]] | tuple[type[FB]]):
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.FA | __main__.FB"
else:
reveal_type(x) # N: Revealed type is "builtins.object"
[builtins fixtures/primitives.pyi]
[case testIsInstanceTypeVarBoundToType]
# flags: --strict-equality --warn-unreachable
from __future__ import annotations
from typing import TypeVar, Protocol
class A(Protocol):
x: int
T = TypeVar("T", bound=type[A])
def foo(x: object, t: T):
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A"
reveal_type(x.x) # N: Revealed type is "builtins.int"
[builtins fixtures/primitives.pyi]
[case testIsInstanceFinalTypeObject]
# flags: --strict-equality --warn-unreachable
from __future__ import annotations
from typing import final
@final
class A: ...
def f1(x: A, t: type[A]):
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # E: Statement is unreachable
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # E: Statement is unreachable
def f2(x: A | None, t: type[A]):
if isinstance(x, A):
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # N: Revealed type is "None"
if isinstance(x, t):
reveal_type(x) # N: Revealed type is "__main__.A"
else:
reveal_type(x) # N: Revealed type is "None"
[builtins fixtures/isinstancelist.pyi]