test-data/unit/fine-grained-cycles.test

-- Test cases for fine-grained incremental checking and import cycles
--
-- The comment at the top of fine-grained.test explains how these tests
-- work.

[case testFunctionSelfReferenceThroughImportCycle]
import a
[file a.py]
from b import f
[file b.py]
import a

def f() -> None:
    a.f()
[file b.py.2]
import a

def f(x: int) -> None:
    a.f()
[out]
==
b.py:4: error: Missing positional argument "x" in call to "f"

[case testClassSelfReferenceThroughImportCycle]
import a
[file a.py]
from b import A
[file b.py]
import a

class A:
    def g(self) -> None: pass

def f() -> None:
    a.A().g()
[file b.py.2]
import a

class A:
    def g(self, x: int) -> None: pass

def f() -> None:
    a.A().g()
[out]
==
b.py:7: error: Missing positional argument "x" in call to "g" of "A"

[case testAnnotationSelfReferenceThroughImportCycle]
import a
[file a.py]
from b import A
[file b.py]
import a

x: a.A

class A:
    def g(self) -> None: pass

def f() -> None:
    x.g()
[file b.py.2]
import a

x: a.A

class A:
    def g(self, x: int) -> None: pass

def f() -> None:
    x.g()
[out]
==
b.py:9: error: Missing positional argument "x" in call to "g" of "A"

[case testModuleSelfReferenceThroughImportCycle]
import a
[file a.py]
import b
[file b.py]
import a

def f() -> None:
    a.b.f()
[file b.py.2]
import a

def f(x: int) -> None:
    a.b.f()
[out]
==
b.py:4: error: Missing positional argument "x" in call to "f"

[case testVariableSelfReferenceThroughImportCycle]
import a
[file a.py]
from b import x
[file b.py]
import a

x: int

def f() -> None:
    a.x = 1
[file b.py.2]
import a

x: str

def f() -> None:
    a.x = 1
[out]
==
b.py:6: error: Incompatible types in assignment (expression has type "int", variable has type "str")

[case testReferenceToTypeThroughCycle]
import a

[file a.py]
from b import C

def f() -> C: pass

[file b.py]
import a

class C:
    def g(self) -> None: pass

def h() -> None:
    c = a.f()
    c.g()

[file b.py.2]
import a

class C:
    def g(self, x: int) -> None: pass

def h() -> None:
    c = a.f()
    c.g()

[out]
==
b.py:8: error: Missing positional argument "x" in call to "g" of "C"

[case testReferenceToTypeThroughCycleAndDeleteType]
import a

[file a.py]
from b import C

def f() -> C: pass

[file b.py]
import a

class C:
    def g(self) -> None: pass

def h() -> None:
    c = a.f()
    c.g()

[file b.py.2]
import a

def h() -> None:
    c = a.f()
    c.g()

[out]
==
a.py:1: error: Module 'b' has no attribute 'C'

[case testReferenceToTypeThroughCycleAndReplaceWithFunction]

import a

[file a.py]
from b import C

def f() -> C: pass

[file b.py]
import a

class C:
    def g(self) -> None: pass

def h() -> None:
    c = a.f()
    c.g()

[file b.py.2]
import a

def C() -> int: pass

def h() -> None:
    c = a.f()
    c.g()

[out]
==
a.py:3: error: Function "b.C" is not valid as a type
a.py:3: note: Perhaps you need "Callable[...]" or a callback protocol?
b.py:7: error: C? has no attribute "g"

-- TODO: More import cycle:
--
-- * "from x import y" through cycle
-- * "from x import *" through cycle
-- * "Cls.module" though cycle
-- * TypeVar
-- * type alias
-- * all kinds of reference deleted
-- * all kinds of reference rebound to different kind
--
-- etc.