-- Test cases for the new semantic analyzer

[case testNewAnalyzerEmpty]

[case testNewAnalyzerSimpleAssignment]

x = 1

x.y # E: "int" has no attribute "y"

y # E: Name "y" is not defined

[case testNewAnalyzerSimpleAnnotation]

x: int = 0

y: str = 0 \

# E: Incompatible types in assignment (expression has type "int", variable has type "str")

[case testNewAnalyzerSimpleClass]

class A:

x: int

a: A

a.x

a.y # E: "A" has no attribute "y"

[case testNewAnalyzerErrorInClassBody]

class A:

x # E: Name "x" is not defined

[case testNewAnalyzerTypeAnnotationForwardReference]

class A:

b: B

class B:

a: A

a: A

b: B

a.b = a # E: Incompatible types in assignment (expression has type "A", variable has type "B")

a.b = b

b.a = a

b.a = b # E: Incompatible types in assignment (expression has type "B", variable has type "A")

[case testNewAnalyzerTypeAnnotationCycle1]

import b

[file a.py]

import b

class A: pass

y: b.B

y() # E: "B" not callable

[file b.py]

import a

class B: pass

x: a.A

reveal_type(x) # N: Revealed type is "a.A"

[case testNewAnalyzerTypeAnnotationCycle2]

import a

[file a.py]

from b import B

class A: pass

y: B

y() # E: "B" not callable

[file b.py]

from a import A

class B: pass

x: A

x() # E: "A" not callable

[case testNewAnalyzerTypeAnnotationCycle3]

import b

[file a.py]

from b import bad # E: Module "b" has no attribute "bad"; maybe "bad2"?

[file b.py]

from a import bad2 # E: Module "a" has no attribute "bad2"; maybe "bad"?

[case testNewAnalyzerTypeAnnotationCycle4]

import b

[file a.py]

from b import bad # E: Module "b" has no attribute "bad"

[file b.py]

# TODO: Could we generate an error here as well?

from a import bad

[targets a, b, a, b, a, b, a, b, __main__]

[case testNewAnalyzerExportedValuesInImportAll]

from m import *

_ = a

_ = b

_ = c

_ = d

_e = e

_f = f # E: Name "f" is not defined

_ = _g # E: Name "_g" is not defined

reveal_type(_e) # N: Revealed type is "m.A"

[file m.py]

__all__ = ['a']

__all__ += ('b',)

__all__.append('c')

__all__.extend(('d', 'e'))

a = b = c = d = _g = 1

e: 'A'

f: 'A'

class A: ...

[builtins fixtures/module_all.pyi]

[case testNewAnalyzerSimpleFunction]

def f(x: int) -> str:

return 'x'

def g(x: int) -> int:

y = f(1)

return y # E: Incompatible return value type (got "str", expected "int")

[case testNewAnalyzerSimpleMethod]

class A:

def __init__(self, x: int) -> None:

self.x = x

def f(self) -> str:

return self.x # E: Incompatible return value type (got "int", expected "str")

def g(self) -> int:

return self.f() # E: Incompatible return value type (got "str", expected "int")

[case testNewAnalyzerFunctionForwardRef]

def f() -> None:

x = g(1) # E: Argument 1 to "g" has incompatible type "int"; expected "str"

reveal_type(x) # N: Revealed type is "builtins.str"

def g(x: str) -> str:

return x

[case testNewAnalyzerExportedImportThreePasses]

import b

[file a.py]

from b import b1 as a2

from b import b2 as a3

def a1() -> int: pass

reveal_type(a3()) # N: Revealed type is "builtins.int"

[file b.py]

from a import a1 as b2

from a import a2 as b3

def b1() -> str: pass

reveal_type(b3()) # N: Revealed type is "builtins.str"

[case testNewAnalyzerBool]

reveal_type(True) # N: Revealed type is "Literal[True]?"

reveal_type(False) # N: Revealed type is "Literal[False]?"

[case testNewAnalyzerNewTypeMultiplePasses]

import b

[file a.py]

from typing import NewType

import b

class A: pass

N2 = NewType('N2', b.N1)

def f1(x: A) -> None: pass

def f2(x: b.N1) -> None: pass

def f3(x: N2) -> None: pass

a = A()

n1 = b.N1(a)

n2 = N2(n1)

f1(a)

f1(n1)

f1(n2)

f2(a) # E: Argument 1 to "f2" has incompatible type "A"; expected "N1"

f2(n1)

f2(n2)

f3(a) # E: Argument 1 to "f3" has incompatible type "A"; expected "N2"

f3(n1) # E: Argument 1 to "f3" has incompatible type "N1"; expected "N2"

f3(n2)

# Test N2 etc.

[file b.py]

from typing import NewType

import a

N1 = NewType('N1', a.A)

[case testNewAnalyzerInheritanceForwardRef]

class C(B):

pass

class B(A):

pass

class A:

def __init__(self, x: str) -> None: pass

def f(self, x: int) -> None: pass

C(1) # E: Argument 1 to "C" has incompatible type "int"; expected "str"

B(1) # E: Argument 1 to "B" has incompatible type "int"; expected "str"

C('').f('') # E: Argument 1 to "f" of "A" has incompatible type "str"; expected "int"

B('').f('') # E: Argument 1 to "f" of "A" has incompatible type "str"; expected "int"

[case testNewAnalyzerInheritanceMROInCycle]

import a

[file a.py]

from b import A

import b

class B(A):

b: int

class D(b.C):

d: int

d = D()

reveal_type(d.a) # N: Revealed type is "builtins.int"

reveal_type(d.b) # N: Revealed type is "builtins.int"

reveal_type(d.c) # N: Revealed type is "builtins.int"

reveal_type(d.d) # N: Revealed type is "builtins.int"

[file b.py]

from a import B

class A:

a: int

class C(B):

c: int

[targets b, a, b, a, __main__]

[case testNewAnalyzerTypedDictClass]

from typing import TypedDict

import a

class T1(TypedDict):

x: A

class A: pass

reveal_type(T1(x=A())) # N: Revealed type is "TypedDict('__main__.T1', {'x': __main__.A})"

[file a.py]

from typing import TypedDict

from b import TD1 as TD2, TD3

class T2(TD3):

x: int

reveal_type(T2(x=2)) # N: Revealed type is "TypedDict('a.T2', {'x': builtins.int})"

[file b.py]

from a import TypedDict as TD1

from a import TD2 as TD3

[builtins fixtures/dict.pyi]

[typing fixtures/typing-typeddict.pyi]

[case testNewAnalyzerTypedDictClassInheritance]

from typing import TypedDict

class T2(T1):

y: int

class T1(TypedDict):

x: str

class T3(TypedDict):

x: str

class T4(T3):

y: A

class A: pass

T2(x=0, y=0) # E: Incompatible types (expression has type "int", TypedDict item "x" has type "str")

x: T2

reveal_type(x) # N: Revealed type is "TypedDict('__main__.T2', {'x': builtins.str, 'y': builtins.int})"

y: T4

reveal_type(y) # N: Revealed type is "TypedDict('__main__.T4', {'x': builtins.str, 'y': __main__.A})"

[builtins fixtures/dict.pyi]

[typing fixtures/typing-typeddict.pyi]

[case testNewAnalyzerRedefinitionAndDeferral1a]

import a

[file a.py]

MYPY = False

if MYPY:

from b import x as y

x = 0

def y(): pass # E: Name "y" already defined on line 4

reveal_type(y) # N: Revealed type is "builtins.int"

y2 = y

class y2: pass # E: Name "y2" already defined on line 9

reveal_type(y2) # N: Revealed type is "builtins.int"

y3, y4 = y, y

if MYPY: # Tweak processing order

from b import f as y3 # E: Incompatible import of "y3" (imported name has type "Callable[[], Any]", local name has type "int")

reveal_type(y3) # N: Revealed type is "builtins.int"

[file b.py]

from a import x

def f(): pass

[targets a, b, a, a.y, b.f, __main__]

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerRedefinitionAndDeferral1b]

import a

[file a.py]

from b import x as y

x = 0

def y(): pass # E: Name "y" already defined on line 2

reveal_type(y) # N: Revealed type is "builtins.int"

y2 = y

class y2: pass # E: Name "y2" already defined on line 7

reveal_type(y2) # N: Revealed type is "builtins.int"

y3, y4 = y, y

from b import f as y3 # E: Incompatible import of "y3" (imported name has type "Callable[[], Any]", local name has type "int")

reveal_type(y3) # N: Revealed type is "builtins.int"

[file b.py]

MYPY = False

if MYPY: # Tweak processing order

from a import x

def f(): pass

[targets b, a, b, a, b.f, a.y, __main__]

[case testNewAnalyzerRedefinitionAndDeferral2a]

import a

[file a.py]

MYPY = False

if MYPY: # Tweak processing order

from b import C as C2

class C: pass

class C2: pass # E: Name "C2" already defined on line 4

[file b.py]

from a import C

[case testNewAnalyzerRedefinitionAndDeferral2b]

import a

[file a.py]

from b import C as C2

class C: pass

class C2: pass # E: Name "C2" already defined on line 2

[file b.py]

MYPY = False

if MYPY: # Tweak processing order

from a import C

[case testNewAnalyzerRedefinitionAndDeferral3]

import a

[file a.py]

from b import f as g

def f(): pass

a, *b = g()

class b(): pass # E: Name "b" already defined on line 4

reveal_type(b) # N: Revealed type is "Any"

[file b.py]

from a import f

[case testNewAnalyzerImportStarForwardRef1]

import a

[file a.py]

x: A

reveal_type(x) # N: Revealed type is "b.A"

from b import *

class A: pass # E: Name "A" already defined (possibly by an import)

[file b.py]

class A: pass

MYPY = False

if MYPY: # Tweak processing order

from a import x

[case testNewAnalyzerImportStarForwardRef2]

import a

[file a.py]

x: A

reveal_type(x) # N: Revealed type is "b.A"

MYPY = False

if MYPY: # Tweak processing order

from b import *

class A: pass # E: Name "A" already defined (possibly by an import)

[file b.py]

class A: pass

from a import x

[case testNewAnalyzerClassInFunction]

def main() -> None:

x: C

class C:

def __init__(self) -> None:

self.x: A

x() # E: "C" not callable

reveal_type(x.x) # N: Revealed type is "__main__.A@8"

class A: pass

[case testNewAnalyzerMutuallyRecursiveFunctions]

def main() -> None:

def f() -> int:

reveal_type(g()) # N: Revealed type is "builtins.str"

return int()

def g() -> str:

reveal_type(f()) # N: Revealed type is "builtins.int"

return str()

[case testNewAnalyzerMissingNamesInFunctions]

def main() -> None:

def f() -> None:

x # E: Name "x" is not defined

class C:

x # E: Name "x" is not defined

[case testNewAnalyzerCyclicDefinitions]

# flags: --disable-error-code used-before-def

gx = gy # E: Cannot resolve name "gy" (possible cyclic definition)

gy = gx

def main() -> None:

class C:

def meth(self) -> None:

lx = ly # E: Cannot resolve name "ly" (possible cyclic definition) \

# N: Recursive types are not allowed at function scope

ly = lx

[case testNewAnalyzerCyclicDefinitionCrossModule]

import b

[file a.py]

import b

x = b.x # E: Cannot resolve attribute "x" (possible cyclic definition) \

# E: Module has no attribute "x"

[file b.py]

import a

x = a.x

[builtins fixtures/module.pyi]

[case testNewAnalyzerMutuallyRecursiveOverloadedFunctions]

from typing import overload, Union

def main() -> None:

@overload

def f(x: int) -> int: ...

@overload

def f(x: str) -> str: ...

def f(x: Union[int, str]) -> Union[int, str]:

reveal_type(g(str())) # N: Revealed type is "builtins.str"

return x

@overload

def g(x: int) -> int: ...

@overload

def g(x: str) -> str: ...

def g(x: Union[int, str]) -> Union[int, str]:

reveal_type(f(int())) # N: Revealed type is "builtins.int"

return float() # E: Incompatible return value type (got "float", expected "int | str")

[case testNewAnalyzerNestedClassInMethod]

class C:

class D:

def meth(self) -> None:

x: Out.In

reveal_type(x.t) # N: Revealed type is "builtins.int"

class Out:

class In:

def meth(self) -> None:

self.t: int

[case testNewAnalyzerDeeplyNestedFunctions]

class Out:

class In:

def meth(self) -> None:

x: C.D

reveal_type(x.t) # N: Revealed type is "__main__.Test@10"

class C:

class D:

def meth(self) -> None:

self.t: Test

class Test:

def test(self) -> None:

def one() -> int:

reveal_type(other()) # N: Revealed type is "builtins.str"

return int()

def other() -> str:

reveal_type(one()) # N: Revealed type is "builtins.int"

return str()

[case testNewAnalyzerNestedClass1]

class A:

class B:

x: int

def __init__(self, x: int) -> None:

self.x = x

def f(self) -> str:

return self.x # E: Incompatible return value type (got "int", expected "str")

b: A.B

b = A.B('') # E: Argument 1 to "B" has incompatible type "str"; expected "int"

reveal_type(b) # N: Revealed type is "__main__.A.B"

reveal_type(b.x) # N: Revealed type is "builtins.int"

reveal_type(b.f()) # N: Revealed type is "builtins.str"

[case testNewAnalyzerNestedClass2]

class A:

class B:

x: int

def __init__(self, x: int) -> None:

self.x = x

def f(self) -> str:

return self.x # E: Incompatible return value type (got "int", expected "str")

b: A.B

b = A.B('') # E: Argument 1 to "B" has incompatible type "str"; expected "int"

reveal_type(b) # N: Revealed type is "__main__.A.B"

reveal_type(b.x) # N: Revealed type is "builtins.int"

reveal_type(b.f()) # N: Revealed type is "builtins.str"

[case testNewAnalyzerGenerics]

from typing import TypeVar, Generic

T = TypeVar('T')

class C(Generic[T]):

def __init__(self, x: T) -> None:

self.x = x

def get(self) -> T:

return self.x

c: C[int]

c2: C[int, str] # E: "C" expects 1 type argument, but 2 given

c3: C

c = C('') # E: Argument 1 to "C" has incompatible type "str"; expected "int"

reveal_type(c.get()) # N: Revealed type is "builtins.int"

reveal_type(c2) # N: Revealed type is "__main__.C[Any]"

reveal_type(c3) # N: Revealed type is "__main__.C[Any]"

[case testNewAnalyzerGenericsTypeVarForwardRef]

from typing import TypeVar, Generic

class C(Generic[T]):

def __init__(self, x: T) -> None:

self.x = x

def get(self) -> T:

return self.x

T = TypeVar('T')

c: C[int]

reveal_type(c) # N: Revealed type is "__main__.C[builtins.int]"

c = C('') # E: Argument 1 to "C" has incompatible type "str"; expected "int"

reveal_type(c.get()) # N: Revealed type is "builtins.int"

[case testNewAnalyzerTypeAlias]

from typing import Union, TypeVar, Generic

T = TypeVar('T')

S = TypeVar('S')

class D(Generic[T, S]): pass

class C: pass

C2 = C

U = Union[C, int]

G = D[T, C]

c: C2

reveal_type(c) # N: Revealed type is "__main__.C"

u: U

reveal_type(u) # N: Revealed type is "__main__.C | builtins.int"

g: G[int]

reveal_type(g) # N: Revealed type is "__main__.D[builtins.int, __main__.C]"

[case testNewAnalyzerTypeAlias2]

from typing import Union

class C(D): pass

A = Union[C, int]

x: A

reveal_type(x) # N: Revealed type is "__main__.C | builtins.int"

class D: pass

[case testNewAnalyzerBuiltinTypeAliases]

from typing import List

x: List[C]

reveal_type(x) # N: Revealed type is "builtins.list[__main__.C]"

class C: pass

[builtins fixtures/list.pyi]

[case testNewAnalyzerVersionCheck]

import sys

if sys.version_info[0] < 2:

1()

import nonexistent

else:

def f(x: int) -> None: pass

f('') # E: Argument 1 to "f" has incompatible type "str"; expected "int"

def g() -> None:

if sys.version_info[0] < 3:

import nonexistent2

else:

1() # E: "int" not callable

[builtins fixtures/ops.pyi]

[case testNewAnalyzerVersionCheck2]

import sys

assert sys.version_info[0] == 3

1() # E: "int" not callable

assert sys.version_info[0] < 3

''()

[builtins fixtures/ops.pyi]

[case testNewAnalyzerOverload]

from typing import overload, Union

@overload

def f(x: int) -> int: ...

@overload

def f(x: str) -> str: ...

def f(x: Union[int, str]) -> Union[int, str]:

return 1.0 # E: Incompatible return value type (got "float", expected "int | str")

f(1)

f('')

f(1.0) # E: No overload variant of "f" matches argument type "float" \

# N: Possible overload variants: \

# N: def f(x: int) -> int \

# N: def f(x: str) -> str

[case testNewAnalyzerOverload2]

from typing import overload, Union

class A:

@overload

def f(self, x: int) -> int: ...

@overload

def f(self, x: str) -> str: ...

def f(self, x: Union[int, str]) -> Union[int, str]:

return 1.0 # E: Incompatible return value type (got "float", expected "int | str")

a = A()

a.f(1)

a.f('')

a.f(1.0) # E: No overload variant of "f" of "A" matches argument type "float" \

# N: Possible overload variants: \

# N: def f(self, x: int) -> int \

# N: def f(self, x: str) -> str

[case testNewAnalyzerPromotion]

def f(x: float) -> None: pass

y: int

f(y)

f(1)

[builtins fixtures/primitives.pyi]

[case testNewAnalyzerFunctionDecorator]

# flags: --disable-error-code used-before-def

from typing import Callable

@dec

def f1(x: int) -> int:

return '' # E: Incompatible return value type (got "str", expected "int")

def dec(f: Callable[[int], int]) -> Callable[[str], str]: ...

@dec

def f2(x: int) -> int:

return '' # E: Incompatible return value type (got "str", expected "int")

f1(1) # E: Argument 1 to "f1" has incompatible type "int"; expected "str"

reveal_type(f1('')) # N: Revealed type is "builtins.str"

f2(1) # E: Argument 1 to "f2" has incompatible type "int"; expected "str"

[case testNewAnalyzerTypeVarForwardReference]

# flags: --disable-error-code used-before-def

from typing import TypeVar, Generic

T = TypeVar('T')

XY = TypeVar('XY', X, Y)

class C(Generic[T]): pass

class D(C[XY], Generic[XY]): pass

class X: pass

class Y: pass

x: D[int] # E: Value of type variable "XY" of "D" cannot be "int"

y: D[Y]

[case testNewAnalyzerTypeVarForwardReference2]

from typing import TypeVar, Generic

T = TypeVar('T')

XY = TypeVar('XY', 'X', 'Y')

class C(Generic[T]): pass

class D(C[XY]): pass

class X: pass

class Y: pass

x: D[int] # E: Value of type variable "XY" of "D" cannot be "int"

y: D[Y]

[case testNewAnalyzerTypeVarForwardReferenceValuesDeferred]

from typing import TypeVar, Generic

T = TypeVar('T')

XY = TypeVar('XY', 'X', 'Y')

class C(Generic[T]): pass

class D(C[XY], Generic[XY]): pass

class X(Defer): pass

class Y(Defer): pass

class Defer: ...

x: D[int] # E: Value of type variable "XY" of "D" cannot be "int"

y: D[Y]

[builtins fixtures/list.pyi]

[case testNewAnalyzerTypeVarForwardReferenceBoundDeferred]

from typing import TypeVar, Generic

T = TypeVar('T')

TY = TypeVar('TY', bound='Y')

class C(Generic[T]): pass

class D(C[TY], Generic[TY]): pass

class Y(Defer): pass

class Defer: ...

x: D[int] # E: Type argument "int" of "D" must be a subtype of "Y"

y: D[Y]

[case testNewAnalyzerTypeVarForwardReferenceErrors]

from typing import TypeVar, Generic

class C(Generic[T]):

def __init__(self, x: T) -> None: ...

def func(x: U) -> U: ...

U = TypeVar('U', asdf, asdf) # E: Name "asdf" is not defined

T = TypeVar('T', bound='asdf') # E: Name "asdf" is not defined

reveal_type(C) # N: Revealed type is "def [T <: Any] (x: T`1) -> __main__.C[T`1]"

reveal_type(func) # N: Revealed type is "def [U in (Any, Any)] (x: U`-1) -> U`-1"

[case testNewAnalyzerSubModuleInCycle]

import a

[file a.py]

MYPY = False

if MYPY:

from b.c import x

[file b/__init__.pyi]

import b.c

[file b/c.pyi]

x = 0

import a

[case testNewAnalyzerBaseClassSelfReference]

from typing import TypeVar, Generic

T = TypeVar('T')

class A(Generic[T]): pass

class C(A[C]):

pass

class D(A['D']):

pass

a1: A[C] = C()

a2: A[D] = C() \

# E: Incompatible types in assignment (expression has type "C", variable has type "A[D]")

[case testNewAnalyzerTypeVarBoundForwardRef]

from typing import TypeVar

T = TypeVar('T', bound='C')

class C: pass

class D(C): pass

class E: pass

def f(x: T) -> T:

return x

reveal_type(f(D())) # N: Revealed type is "__main__.D"

f(E()) # E: Value of type variable "T" of "f" cannot be "E"

[case testNewAnalyzerNameExprRefersToIncompleteType]

import a

[file a.py]

from b import f

class C(D): pass

class D: pass

[file b.py]

from a import C

reveal_type(C()) # N: Revealed type is "a.C"

def f(): pass

[case testNewAnalyzerMemberExprRefersToIncompleteType]

import a

[file a.py]

from b import f

class C(D): pass

class D: pass

[file b.py]

import a

reveal_type(a.C()) # N: Revealed type is "a.C"

def f(): pass

[case testNewAnalyzerNamedTupleCall]

from typing import NamedTuple

class Other: pass

In = NamedTuple('In', [('s', str), ('t', Other)])

Out = NamedTuple('Out', [('x', In), ('y', Other)])

o: Out

i: In

reveal_type(o) # N: Revealed type is "tuple[tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.Out]"

reveal_type(o.x) # N: Revealed type is "tuple[builtins.str, __main__.Other, fallback=__main__.In]"

reveal_type(o.y) # N: Revealed type is "__main__.Other"

reveal_type(o.x.t) # N: Revealed type is "__main__.Other"

reveal_type(i.t) # N: Revealed type is "__main__.Other"

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleClass]

from typing import NamedTuple

o: Out

i: In

class Out(NamedTuple):

x: In

y: Other

reveal_type(o) # N: Revealed type is "tuple[tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.Out]"

reveal_type(o.x) # N: Revealed type is "tuple[builtins.str, __main__.Other, fallback=__main__.In]"

reveal_type(o.y) # N: Revealed type is "__main__.Other"

reveal_type(o.x.t) # N: Revealed type is "__main__.Other"

reveal_type(i.t) # N: Revealed type is "__main__.Other"

class In(NamedTuple):

s: str

t: Other

class Other: pass

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleCallNested]

from typing import NamedTuple

o: C.Out

i: C.In

reveal_type(o) # N: Revealed type is "tuple[tuple[builtins.str, __main__.C.Other, fallback=__main__.C.In], __main__.C.Other, fallback=__main__.C.Out]"

reveal_type(o.x) # N: Revealed type is "tuple[builtins.str, __main__.C.Other, fallback=__main__.C.In]"

reveal_type(o.y) # N: Revealed type is "__main__.C.Other"

reveal_type(o.x.t) # N: Revealed type is "__main__.C.Other"

reveal_type(i.t) # N: Revealed type is "__main__.C.Other"

class C:

In = NamedTuple('In', [('s', str), ('t', Other)])

Out = NamedTuple('Out', [('x', In), ('y', Other)])

class Other: pass

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleClassNested]

from typing import NamedTuple

o: C.Out

i: C.In

reveal_type(o) # N: Revealed type is "tuple[tuple[builtins.str, __main__.C.Other, fallback=__main__.C.In], __main__.C.Other, fallback=__main__.C.Out]"

reveal_type(o.x) # N: Revealed type is "tuple[builtins.str, __main__.C.Other, fallback=__main__.C.In]"

reveal_type(o.y) # N: Revealed type is "__main__.C.Other"

reveal_type(o.x.t) # N: Revealed type is "__main__.C.Other"

reveal_type(i.t) # N: Revealed type is "__main__.C.Other"

class C:

class Out(NamedTuple):

x: C.In

y: C.Other

class In(NamedTuple):

s: str

t: C.Other

class Other: pass

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleCallNestedMethod]

from typing import NamedTuple

class C:

def get_tuple(self) -> None:

Out = NamedTuple('Out', [('x', 'In'), ('y', 'Other')])

In = NamedTuple('In', [('s', str), ('t', 'Other')])

class Other: pass

self.o: Out

c = C()

reveal_type(c.o) # N: Revealed type is "tuple[tuple[builtins.str, __main__.Other@7, fallback=__main__.C.In@6], __main__.Other@7, fallback=__main__.C.Out@5]"

reveal_type(c.o.x) # N: Revealed type is "tuple[builtins.str, __main__.Other@7, fallback=__main__.C.In@6]"

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleClassNestedMethod]

from typing import NamedTuple

class C:

def get_tuple(self) -> None:

class Out(NamedTuple):

x: In

y: Other

def method(self) -> In: ...

class In(NamedTuple):

s: str

t: Other

class Other: pass

self.o: Out

c = C()

reveal_type(c.o) # N: Revealed type is "tuple[tuple[builtins.str, __main__.Other@12, fallback=__main__.C.In@9], __main__.Other@12, fallback=__main__.C.Out@5]"

reveal_type(c.o.x) # N: Revealed type is "tuple[builtins.str, __main__.Other@12, fallback=__main__.C.In@9]"

reveal_type(c.o.method()) # N: Revealed type is "tuple[builtins.str, __main__.Other@12, fallback=__main__.C.In@9]"

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleClassForwardMethod]

from typing import NamedTuple

n: NT

reveal_type(n.get_other()) # N: Revealed type is "tuple[builtins.str, fallback=__main__.Other]"

reveal_type(n.get_other().s) # N: Revealed type is "builtins.str"

class NT(NamedTuple):

x: int

y: int

def get_other(self) -> Other: pass

class Other(NamedTuple):

s: str

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleSpecialMethods]

from typing import NamedTuple

class Other: pass

In = NamedTuple('In', [('s', str), ('t', Other)])

Out = NamedTuple('Out', [('x', In), ('y', Other)])

class SubO(Out): pass

o: SubO

reveal_type(SubO._make) # N: Revealed type is "def (iterable: typing.Iterable[Any]) -> tuple[tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.SubO]"

reveal_type(o._replace(y=Other())) # N: Revealed type is "tuple[tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.SubO]"

[builtins fixtures/tuple.pyi]

[case testNewAnalyzerNamedTupleBaseClass]

from typing import NamedTuple

class Other: pass

class In(NamedTuple):

s: str

t: Other

class Out(NamedTuple('Out', [('x', In), ('y', Other)])):