[case testForcedAssignment]

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]

from typing import List, Any

x = None # type: 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]

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]

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 'Union[builtins.int, builtins.str]'

x[1] # E: Value of type "Union[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 'Union[builtins.int, builtins.str, builtins.list[Any]]'

if isinstance(x, (str, (list,))):

reveal_type(x) # N: Revealed type is 'Union[builtins.str, builtins.list[Any]]'

x[1]

reveal_type(x) # N: Revealed type is 'Union[builtins.int, builtins.str, builtins.list[Any]]'

[builtins fixtures/isinstancelist.pyi]

[case testClassAttributeInitialization]

class A:

x = None # type: int

def __init__(self) -> None:

self.y = None # type: int

z = self.x

w = self.y

[case testAssignmentSubtypes]

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 = None # type: int

y = [x]

[builtins fixtures/isinstancelist.pyi]

[case testFunctionDefaultArgs]

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]

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]

class A:

y = 1

class B(A):

z = 1

def foo(): pass

x = A()

if int():

x = B()

x.z

x = foo()

x.z # E: "A" has no attribute "z"

x.y

[case testSingleMultiAssignment]

x = 'a'

(x,) = ('a',)

[case testUnionMultiAssignment]

from typing import Union

x = None # type: 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]

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]

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]

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 "Union[int, str]"

x = foo()

if bool():

continue

x = 'a'

x = 'a'

x + 'a'

[builtins fixtures/isinstancelist.pyi]

[case testUnionTryExcept]

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]

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]

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()

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]

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]

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]

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]

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]

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]

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

x.b

[case testUnionTryFinally6]

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]

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 'Union[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 "Union[List[int], List[str]]"

else:

x[0] # E: Value of type "int" is not indexable

x + 1

x[0] # E: Value of type "Union[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 "Union[List[int], List[str], int]"

[builtins fixtures/isinstancelist.pyi]

[case testUnionListIsinstance2]

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]

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 "Union[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]

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]

from typing import Union

x = None # type: 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]

from typing import Union

x = None # type: 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]

from typing import Union

class Animal: pass

class Dog(Animal):

paws = 4 # type: Union[int, str]

def bark(self): pass

class House:

pet = None # type: 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 "Union[int, str]"

z = h.pet.paws + 'a' # E: Unsupported operand types for + ("int" and "str") \

# N: Left operand is of type "Union[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]

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]

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 "Union[B, C]" has no attribute "method3"

[builtins fixtures/isinstance.pyi]

[case testIsinstanceNeverWidens]

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 'Union[__main__.A, __main__.B]'

[builtins fixtures/isinstance.pyi]

[case testMemberAssignmentChanges]

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 "Union[int, str]"

pet.paws = 'a'

pet.paws + 'a'

pet.paws = 1

pet.paws + 1

[builtins fixtures/isinstancelist.pyi]

[case testIsInstanceSubClassMemberHard]

from typing import Union

class Animal:

pass

class Dog(Animal):

paws = 4 # type: Union[int, str]

def bark(self): pass

class House:

pet = None # type: 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 "Union[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]

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]

from typing import Union

def foo() -> None:

x = None # type: 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 "Union[int, str]"

foo()

[builtins fixtures/isinstancelist.pyi]

[case testIsInstanceThreeUnion]

from typing import Union, List

x = None # type: 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 "Union[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 "Union[int, str, List[int]]"

[builtins fixtures/isinstancelist.pyi]

[case testIsInstanceThreeUnion2]

from typing import Union, List

x = None # type: 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 "Union[int, str, List[int]]"

[builtins fixtures/isinstancelist.pyi]

[case testIsInstanceThreeUnion3]

from typing import Union, List

while bool():

x = None # type: Union[int, str, List[int]]

def f(): x # Prevent redefinition

x = 1

if isinstance(x, int):

x + 1

break

elif isinstance(x, str):

x + 'a'

break

x + [1] # These lines aren't reached because x was an int

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 "Union[int, str, List[int]]"

[builtins fixtures/isinstancelist.pyi]

[case testRemovingTypeRepeatedly]

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 "Union[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 "Union[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 "Union[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 "Union[int, str]"

[builtins fixtures/isinstancelist.pyi]

[case testModifyRepeatedly]

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 "Union[int, str]"

x + 'a' # E: Unsupported operand types for + ("int" and "str") \

# N: Left operand is of type "Union[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 "Union[int, str]"

x + 'a' # E: Unsupported operand types for + ("int" and "str") \

# N: Left operand is of type "Union[int, str]"

[builtins fixtures/isinstancelist.pyi]

[case testModifyLoop]

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 "Union[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 "Union[int, str]"

x = 'a'

[builtins fixtures/isinstancelist.pyi]

[case testModifyLoop2]

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 "Union[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 "Union[int, str]"

[builtins fixtures/isinstancelist.pyi]

[case testModifyLoop3]

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 "Union[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 "Union[int, str]"

[builtins fixtures/isinstancelist.pyi]

[case testModifyLoopWhile4]

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 "Union[int, str]"

if bool():

x = 'a'

continue

else:

x + 1 # E: Unsupported operand types for + ("str" and "int") \

# N: Left operand is of type "Union[int, str]"

x = 'a'

x + 'a'

[builtins fixtures/isinstancelist.pyi]

[case testModifyLoopFor4]

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 "Union[int, str]"

if bool():

x = 'a'

continue

else:

x + 1 # E: Unsupported operand types for + ("str" and "int") \

# N: Left operand is of type "Union[int, str]"

x = 'a'

x + 'a'

[builtins fixtures/isinstancelist.pyi]

[case testModifyNestedLoop]

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 "Union[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 "Union[int, str]"

[builtins fixtures/isinstancelist.pyi]

[case testModifyLoopLong]

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 "Union[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):