| [case testSuggestCallsites1] | |
| # suggest: --callsites foo.foo | |
| [file foo.py] | |
| def foo(arg): | |
| return 12 | |
| var = 0 | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| foo(arg='xyz') | |
| args = [''] | |
| foo(*args) | |
| kwds = {'arg': ''} | |
| foo(**kwds) | |
| [builtins fixtures/dict.pyi] | |
| [out] | |
| bar.py:3: (str) | |
| bar.py:4: (arg=str) | |
| bar.py:6: (*list[str]) | |
| bar.py:8: (**dict[str, str]) | |
| == | |
| [case testSuggestCallsitesStep2] | |
| # suggest2: --callsites foo.foo | |
| [file foo.py] | |
| def foo(arg): | |
| return 12 | |
| var = 0 | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| foo(arg='xyz') | |
| args = [''] | |
| foo(*args) | |
| kwds = {'arg': ''} | |
| foo(**kwds) | |
| [builtins fixtures/dict.pyi] | |
| [out] | |
| == | |
| bar.py:3: (str) | |
| bar.py:4: (arg=str) | |
| bar.py:6: (*list[str]) | |
| bar.py:8: (**dict[str, str]) | |
| [case testMaxGuesses] | |
| # suggest: foo.foo | |
| # suggest: --max-guesses=2 foo.foo | |
| [file foo.py] | |
| # The idea here is that we can only find the union type with more guesses. | |
| def foo(x, y): | |
| if not isinstance(x, int): | |
| x+'1' | |
| foo(1, 2) | |
| foo('3', '4') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (int | str, object) -> None | |
| (object, object) -> None | |
| == | |
| [case testSuggestInferFunc1] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| def foo(arg, lol=None): | |
| if isinstance(arg, int): | |
| arg+1 | |
| else: | |
| assert arg | |
| arg+'1' | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| foo(lol=10, arg=10) | |
| foo(None) | |
| def untyped(x) -> None: | |
| foo(x) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str | int | None, int | None) -> None | |
| == | |
| [case testSuggestInferFunc2] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| def foo(arg): | |
| return arg | |
| [file bar.py] | |
| from foo import foo | |
| def thing() -> str: | |
| return '' | |
| def bar() -> None: | |
| # We stick it in a list so that the argument type is marked as "inferred", | |
| # which we want to make sure doesn't show up. | |
| x = ['hello'] | |
| foo(x[0]) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestInferFuncAny1] | |
| # suggest: foo.foo | |
| # suggest: foo.bar | |
| [file foo.py] | |
| def foo(arg): | |
| return arg.x | |
| def bar(arg): | |
| pass | |
| [file bar.py] | |
| from foo import bar | |
| bar(None) | |
| [out] | |
| (Any) -> Any | |
| (Any | None) -> None | |
| == | |
| [case testSuggestInferFuncAny2] | |
| # suggest: --no-any foo.foo | |
| # suggest: --no-any foo.bar | |
| [file foo.py] | |
| def foo(arg): | |
| return arg.x | |
| def bar(arg): | |
| pass | |
| [file bar.py] | |
| from foo import bar | |
| bar(None) | |
| [out] | |
| No guesses that match criteria! | |
| No guesses that match criteria! | |
| == | |
| [case testSuggestInferTuple] | |
| # suggest: --no-any foo.foo | |
| [file foo.py] | |
| def foo(): | |
| return 1, "1" | |
| [builtins fixtures/tuple.pyi] | |
| [out] | |
| () -> Tuple[int, str] | |
| == | |
| [case testSuggestInferNamedTuple] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from typing import NamedTuple | |
| N = NamedTuple('N', [('x', int)]) | |
| def foo(): | |
| return N(1) | |
| [builtins fixtures/tuple.pyi] | |
| [out] | |
| () -> foo.N | |
| == | |
| [case testSuggestInferTypedDict] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from typing import TypedDict | |
| TD = TypedDict('TD', {'x': int}) | |
| def foo(): | |
| return bar() | |
| def bar() -> TD: ... | |
| [builtins fixtures/dict.pyi] | |
| [typing fixtures/typing-typeddict.pyi] | |
| [out] | |
| () -> foo.TD | |
| == | |
| [case testSuggestWithNested] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| def foo(): | |
| def bar(): | |
| return 1 | |
| return 'lol' | |
| [out] | |
| () -> str | |
| == | |
| [case testSuggestReexportNaming] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from bar import A | |
| def foo(x): | |
| return A(), A.C() | |
| [file bar.py] | |
| from baz import A | |
| [file baz.py] | |
| class A: | |
| class C: | |
| ... | |
| class B: ... | |
| [file caller.py] | |
| from foo import foo | |
| from baz import B | |
| foo(B()) | |
| [builtins fixtures/tuple.pyi] | |
| [out] | |
| (baz.B) -> Tuple[foo.A, foo:A.C] | |
| == | |
| [case testSuggestReexportNamingNameMatchesModule1] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| import bar | |
| def foo(): | |
| return bar.bar() | |
| [file bar.py] | |
| class bar: ... # name matches module name | |
| [out] | |
| () -> bar.bar | |
| == | |
| [case testSuggestReexportNamingNameMatchesModule2] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| import bar | |
| import qux | |
| def foo(): | |
| return qux.bar() | |
| [file bar.py] | |
| [file qux.py] | |
| class bar: ... # name matches another module name | |
| [out] | |
| () -> qux.bar | |
| == | |
| [case testSuggestInferInit] | |
| # suggest: foo.Foo.__init__ | |
| [file foo.py] | |
| class Foo: | |
| def __init__(self, arg): | |
| self.arg = arg | |
| [file bar.py] | |
| from foo import Foo | |
| Foo('lol') | |
| [out] | |
| (str) -> None | |
| == | |
| [case testSuggestInferMethod1] | |
| # suggest: --no-any foo.Foo.foo | |
| [file foo.py] | |
| class Foo: | |
| def __init__(self) -> None: | |
| self.y = '10' | |
| def foo(self, arg, lol=None): | |
| if isinstance(arg, int): | |
| return arg+1 | |
| else: | |
| assert arg | |
| return arg+self.y | |
| [file bar.py] | |
| from foo import Foo | |
| def bar() -> None: | |
| x = Foo() | |
| x.foo('abc') | |
| x.foo(lol=10, arg=10) | |
| x.foo(None) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str | int | None, int | None) -> object | |
| == | |
| [case testSuggestInferMethod2] | |
| # suggest: foo.Foo.foo | |
| [file foo.py] | |
| class Foo: | |
| def i(self, x: int) -> int: return x | |
| def s(self, x: str) -> str: return x | |
| def foo(self, arg, lol=None): | |
| if isinstance(arg, int): | |
| return self.i(arg) | |
| else: | |
| assert arg | |
| return self.s(arg) | |
| [file bar.py] | |
| from typing import Union | |
| from foo import Foo | |
| def bar() -> None: | |
| x = Foo() | |
| x.foo('abc') | |
| x.foo(lol=10, arg=10) | |
| a: Union[str, int] = x.foo(None) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str | int | None, int | None) -> int | str | |
| == | |
| [case testSuggestInferMethod3] | |
| # suggest2: foo.Foo.foo | |
| [file foo.py] | |
| class Foo: | |
| def foo(self, lol = None): | |
| pass | |
| def lol(self) -> None: | |
| self.foo('lol') | |
| [file bar.py] | |
| from foo import Foo | |
| def bar() -> None: | |
| x = Foo() | |
| x.foo('abc') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| == | |
| (str | None) -> None | |
| [case testSuggestBackflow] | |
| # suggest: foo.foo | |
| # suggest: foo.bar | |
| # suggest: foo.baz | |
| # suggest: foo.Cls.spam | |
| # suggest: foo.method | |
| # suggest: foo.meet | |
| # suggest: foo.has_nested | |
| [file foo.py] | |
| from typing import Any, List, Optional | |
| class A: pass | |
| class B(A): | |
| def test(self, x: A) -> None: | |
| pass | |
| def take_optional_a(x: Optional[A]) -> None: | |
| pass | |
| def take_a(x: A) -> None: | |
| pass | |
| def take_b(x: B) -> None: | |
| pass | |
| def take_any(x: Any) -> None: | |
| pass | |
| def take_kws(a: A, b: B) -> None: | |
| pass | |
| def take_star(*a: A) -> None: | |
| pass | |
| def foo(x): | |
| take_b(x) | |
| def bar(x): | |
| take_b(x) | |
| bar(A()) | |
| def baz(x, y): | |
| take_kws(a=y, b=x) | |
| class Cls: | |
| def spam(self, x, y): | |
| take_star(x, y) | |
| def method(x): | |
| b = B() | |
| b.test(x) | |
| def meet(x, y): | |
| take_a(x) | |
| take_b(x) | |
| take_a(y) | |
| take_optional_a(y) | |
| take_any(y) | |
| foo(y) # unannotated | |
| def has_nested(x): | |
| def nested(): | |
| take_b(x) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (foo.B) -> None | |
| (foo.A) -> None | |
| (foo.B, foo.A) -> None | |
| (foo.A, foo.A) -> None | |
| (foo.A) -> None | |
| (foo.B, foo.A) -> None | |
| (foo.B) -> None | |
| == | |
| [case testSuggestInferFunctionUnreachable] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| import sys | |
| def foo(lol): | |
| if sys.platform == 'nothing': | |
| return lol | |
| else: | |
| return lol + lol | |
| [file bar.py] | |
| from foo import foo | |
| foo('test') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestInferMethodStep2] | |
| # suggest2: foo.Foo.foo | |
| [file foo.py] | |
| class Foo: | |
| def i(self, x: int) -> int: return x | |
| def s(self, x: str) -> str: return x | |
| def foo(self, arg, lol=None): | |
| if isinstance(arg, int): | |
| return self.i(arg) | |
| else: | |
| assert arg | |
| return self.s(arg) | |
| [file bar.py] | |
| from typing import Union | |
| from foo import Foo | |
| def bar() -> None: | |
| x = Foo() | |
| x.foo('abc') | |
| x.foo(lol=10, arg=10) | |
| a: Union[str, int] = x.foo(None) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| == | |
| (str | int | None, int | None) -> int | str | |
| [case testSuggestInferNestedMethod] | |
| # suggest: foo.Foo.Bar.baz | |
| [file foo.py] | |
| class Foo: | |
| class Bar: | |
| def baz(self, lol): | |
| return lol | |
| [file bar.py] | |
| from foo import Foo | |
| def bar() -> None: | |
| x = Foo.Bar() | |
| x.baz('abc') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestCallable] | |
| # suggest: foo.foo | |
| # suggest: foo.bar | |
| # suggest: --flex-any=0.9 foo.bar | |
| # suggest: foo.baz | |
| # suggest: foo.quux | |
| [file foo.py] | |
| def foo(f): | |
| return f(0, "lol") | |
| def bar(f): | |
| return f(0, "lol", 100) | |
| def baz(f): | |
| return f(y=1) + f(x=10, y=1) | |
| def quux(f): | |
| return f(1) | |
| [file bar.py] | |
| from typing import Any | |
| from foo import foo, bar, baz, quux | |
| def whatever(x: int, y: str) -> int: | |
| return 0 | |
| def starargs(*args: Any) -> int: | |
| return 0 | |
| def named(*, x: int = 0, y: int) -> str: | |
| return '0' | |
| # we don't properly handle default really. we just assume it is | |
| # actually required. | |
| def default(x: int = 0) -> str: | |
| return '0' | |
| def test() -> None: | |
| foo(whatever) | |
| bar(starargs) | |
| baz(named) | |
| quux(default) | |
| [builtins fixtures/primitives.pyi] | |
| [out] | |
| (Callable[[int, str], int]) -> int | |
| (Callable[..., int]) -> int | |
| No guesses that match criteria! | |
| (Callable[..., str]) -> str | |
| (Callable[[int], str]) -> str | |
| == | |
| [case testSuggestNewSemanal] | |
| # suggest: foo.Foo.foo | |
| # suggest: foo.foo | |
| [file foo.py] | |
| class Foo: | |
| def __init__(self) -> None: | |
| self.y = '10' | |
| def foo(self, arg, lol=None): | |
| if isinstance(arg, int): | |
| return arg+1 | |
| else: | |
| assert arg | |
| return arg+self.y | |
| def foo(arg, lol=None): | |
| if isinstance(arg, int): | |
| arg+1 | |
| else: | |
| assert arg | |
| arg+'1' | |
| [file bar.py] | |
| from foo import Foo, foo | |
| def bar() -> None: | |
| x = Foo() | |
| x.foo('abc') | |
| x.foo(lol=10, arg=10) | |
| x.foo(None) | |
| def baz() -> None: | |
| foo('abc') | |
| foo(lol=10, arg=10) | |
| foo(None) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str | int | None, int | None) -> object | |
| (str | int | None, int | None) -> None | |
| == | |
| [case testSuggestInferFuncDecorator1] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from typing import TypeVar | |
| F = TypeVar('F') | |
| def dec(x: F) -> F: | |
| return x | |
| @dec | |
| def foo(arg): | |
| return arg | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestInferFuncDecorator2] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from typing import TypeVar, Callable, Any | |
| F = TypeVar('F', bound=Callable[..., Any]) | |
| def dec(x: F) -> F: | |
| return x | |
| @dec | |
| def foo(arg): | |
| return arg | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestInferFuncDecorator3] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from typing import TypeVar, Callable, Any | |
| F = TypeVar('F', bound=Callable[..., Any]) | |
| def dec(s: str) -> Callable[[F], F]: | |
| def f(x: F) -> F: | |
| return x | |
| return f | |
| @dec('lol') | |
| def foo(arg): | |
| return arg | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestInferFuncDecorator4] | |
| # suggest: foo.foo | |
| [file dec.py] | |
| from typing import TypeVar, Callable, Any | |
| F = TypeVar('F', bound=Callable[..., Any]) | |
| def dec(s: str) -> Callable[[F], F]: | |
| def f(x: F) -> F: | |
| return x | |
| return f | |
| [file foo.py] | |
| import dec | |
| @dec.dec('lol') | |
| def foo(arg): | |
| return arg | |
| [file bar.py] | |
| from foo import foo | |
| def bar() -> None: | |
| foo('abc') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestInferFuncDecorator5] | |
| # suggest: foo.foo1 | |
| # suggest: foo.foo2 | |
| # suggest: foo.foo3 | |
| [file foo.py] | |
| from __future__ import annotations | |
| from typing import TypeVar, Generator, Callable | |
| F = TypeVar('F') | |
| # simplified `@contextmanager | |
| class _impl: | |
| def __call__(self, f: F) -> F: return f | |
| def contextmanager(gen: Callable[[], Generator[None, None, None]]) -> Callable[[], _impl]: return _impl | |
| @contextmanager | |
| def gen() -> Generator[None, None, None]: | |
| yield | |
| @gen() | |
| def foo1(x): | |
| return x | |
| foo1('hi') | |
| inst = gen() | |
| @inst | |
| def foo2(x): | |
| return x | |
| foo2('hello') | |
| ref = gen | |
| @ref() | |
| def foo3(x): | |
| return x | |
| foo3('hello hello') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| (str) -> str | |
| (str) -> str | |
| == | |
| [case testSuggestInferFuncDecorator6] | |
| # suggest: foo.f | |
| [file foo.py] | |
| from __future__ import annotations | |
| from typing import Callable, Protocol, TypeVar | |
| from typing_extensions import ParamSpec | |
| P = ParamSpec('P') | |
| R = TypeVar('R') | |
| R_co = TypeVar('R_co', covariant=True) | |
| class Proto(Protocol[P, R_co]): | |
| def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co: ... | |
| def dec1(f: Callable[P, R]) -> Callable[P, R]: ... | |
| def dec2(f: Callable[..., R]) -> Callable[..., R]: ... | |
| def dec3(f: Proto[P, R_co]) -> Proto[P, R_co]: ... | |
| @dec1 | |
| @dec2 | |
| @dec3 | |
| def f(x): | |
| return x | |
| f('hi') | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (str) -> str | |
| == | |
| [case testSuggestFlexAny1] | |
| # suggest: --flex-any=0.4 m.foo | |
| # suggest: --flex-any=0.7 m.foo | |
| # suggest: --flex-any=0.4 m.bar | |
| # suggest: --flex-any=0.6 m.bar | |
| # suggest2: --flex-any=0.4 m.foo | |
| # suggest2: --flex-any=0.7 m.foo | |
| [file m.py] | |
| from typing import Any | |
| any: Any | |
| def foo(arg): | |
| return 0 | |
| def bar(x, y): | |
| return any | |
| [file n.py] | |
| from typing import Any | |
| any: Any | |
| from m import foo, bar | |
| def wtvr() -> None: | |
| foo(any) | |
| bar(1, 2) | |
| [file n.py.2] | |
| from typing import Any | |
| any: Any | |
| from m import foo, bar | |
| def wtvr() -> None: | |
| foo([any]) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (Any) -> int | |
| No guesses that match criteria! | |
| (int, int) -> Any | |
| No guesses that match criteria! | |
| == | |
| (list[Any]) -> int | |
| (list[Any]) -> int | |
| [case testSuggestFlexAny2] | |
| # suggest: --flex-any=0.5 m.baz | |
| # suggest: --flex-any=0.0 m.baz | |
| # suggest: --flex-any=0.5 m.F.foo | |
| # suggest: --flex-any=0.7 m.F.foo | |
| # suggest: --flex-any=0.7 m.noargs | |
| [file m.py] | |
| # Test mostly corner cases | |
| # Test that a None return doesn't get counted | |
| def baz(x): | |
| pass | |
| class F: | |
| # Test that self doesn't get counted | |
| def foo(self, x): | |
| return 0 | |
| # Make sure we don't crash on noarg functions | |
| def noargs(): | |
| pass | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| No guesses that match criteria! | |
| (Any) -> None | |
| (Any) -> int | |
| No guesses that match criteria! | |
| () -> None | |
| == | |
| [case testSuggestClassMethod] | |
| # suggest: foo.F.bar | |
| # suggest: foo.F.baz | |
| # suggest: foo.F.eggs | |
| [file foo.py] | |
| class F: | |
| @classmethod | |
| def bar(cls, x, y): | |
| return x | |
| @staticmethod | |
| def baz(x, y): | |
| return x | |
| @classmethod | |
| def spam(cls): | |
| # type: () -> None | |
| cls.eggs(4) | |
| @classmethod | |
| def eggs(cls, x): | |
| pass | |
| [file bar.py] | |
| from foo import F | |
| def bar(iany) -> None: | |
| F.bar(0, iany) | |
| F().bar(0, 5) | |
| F.baz('lol', iany) | |
| F().baz('lol', 10) | |
| [builtins fixtures/classmethod.pyi] | |
| [out] | |
| (int, int) -> int | |
| (str, int) -> str | |
| (int) -> None | |
| == | |
| [case testSuggestNewInit] | |
| # suggest: foo.F.__init__ | |
| # suggest: foo.F.__new__ | |
| [file foo.py] | |
| class F: | |
| def __new__(cls, t): | |
| return super().__new__(cls) | |
| def __init__(self, t): | |
| self.t = t | |
| [file bar.py] | |
| from foo import F | |
| def bar(iany) -> None: | |
| F(0) | |
| [out] | |
| (int) -> None | |
| (int) -> Any | |
| == | |
| [case testSuggestColonBasic] | |
| # suggest: tmp/foo.py:1 | |
| # suggest: tmp/bar/baz.py:2 | |
| [file foo.py] | |
| def func(arg): | |
| return 0 | |
| func('test') | |
| from bar.baz import C | |
| C().method('test') | |
| [file bar/__init__.py] | |
| [file bar/baz.py] | |
| class C: | |
| def method(self, x): | |
| return 0 | |
| [out] | |
| (str) -> int | |
| (str) -> int | |
| == | |
| [case testSuggestColonAfter] | |
| # suggest: tmp/foo.py:6 | |
| # suggest: tmp/foo.py:15 | |
| # suggest: tmp/foo.py:16 | |
| # suggest: tmp/foo.py:18 | |
| [file foo.py] | |
| from typing import TypeVar | |
| F = TypeVar('F') | |
| def foo(): | |
| # hi | |
| return 1 | |
| def dec(x: F) -> F: | |
| return x | |
| class A: | |
| @dec | |
| def bar(self): | |
| return 1.0 | |
| @dec | |
| def baz(): | |
| return 'test' | |
| [out] | |
| () -> int | |
| () -> float | |
| () -> str | |
| () -> str | |
| == | |
| [case testSuggestParent] | |
| # suggest: foo.B.foo | |
| # suggest: foo.B.bar | |
| # suggest: foo.C.foo | |
| [file foo.py] | |
| from typing import TypeVar, Callable, Any | |
| F = TypeVar('F', bound=Callable[..., Any]) | |
| def deco(f: F) -> F: ... | |
| class A: | |
| def foo(self, x: int) -> float: | |
| return 0.0 | |
| @deco | |
| def bar(self, x: int) -> float: | |
| return 0.0 | |
| class B(A): | |
| def foo(self, x): | |
| return 0.0 | |
| @deco | |
| def bar(self, x): | |
| return 0.0 | |
| class C(B): | |
| def foo(self, x): | |
| return 0.0 | |
| [out] | |
| (int) -> float | |
| (int) -> float | |
| (int) -> float | |
| == | |
| [case testSuggestColonBadLocation] | |
| # suggest: tmp/foo.py:7:8:9 | |
| [file foo.py] | |
| [out] | |
| Malformed location for function: tmp/foo.py:7:8:9. Must be either package.module.Class.method or path/to/file.py:line | |
| == | |
| [case testSuggestColonBadLine] | |
| # suggest: tmp/foo.py:bad | |
| [file foo.py] | |
| [out] | |
| Line number must be a number. Got bad | |
| == | |
| [case testSuggestColonBadFile] | |
| # suggest: tmp/foo.txt:1 | |
| [file foo.txt] | |
| def f(): pass | |
| [out] | |
| Source file is not a Python file | |
| == | |
| [case testSuggestColonClass] | |
| # suggest: tmp/foo.py:1 | |
| [file foo.py] | |
| class C: | |
| pass | |
| [out] | |
| Cannot find a function at line 1 | |
| == | |
| [case testSuggestColonDecorator] | |
| # suggest: tmp/foo.py:6 | |
| [file foo.py] | |
| from typing import TypeVar, Callable, Any | |
| F = TypeVar('F', bound=Callable[..., Any]) | |
| def deco(f: F) -> F: ... | |
| @deco | |
| def func(arg): | |
| return 0 | |
| func('test') | |
| [out] | |
| (str) -> int | |
| == | |
| [case testSuggestColonMethod] | |
| # suggest: tmp/foo.py:3 | |
| [file foo.py] | |
| class Out: | |
| class In: | |
| def method(self, x): | |
| return Out() | |
| x: Out.In | |
| x.method(x) | |
| [out] | |
| (foo:Out.In) -> foo.Out | |
| == | |
| [case testSuggestColonMethodJSON] | |
| # suggest: --json tmp/foo.py:3 | |
| [file foo.py] | |
| class Out: | |
| class In: | |
| def method(self, x): | |
| return Out() | |
| x: Out.In | |
| x.method(x) | |
| [out] | |
| \[{"func_name": "Out.In.method", "line": 3, "path": "tmp/foo.py", "samples": 0, "signature": {"arg_types": ["foo:Out.In"], "return_type": "foo.Out"}}] | |
| == | |
| [case testSuggestColonNonPackageDir] | |
| # cmd: mypy foo/bar/baz.py | |
| # suggest: tmp/foo/bar/baz.py:1 | |
| [file foo/bar/baz.py] | |
| def func(arg): | |
| return 0 | |
| func('test') | |
| [out] | |
| (str) -> int | |
| == | |
| [case testSuggestUseFixmeBasic] | |
| # suggest: --use-fixme=UNKNOWN foo.foo | |
| # suggest: --use-fixme=UNKNOWN foo.bar | |
| [file foo.py] | |
| def foo(): | |
| return g() | |
| def bar(x): | |
| return None | |
| def g(): ... | |
| x = bar(g()) | |
| [out] | |
| () -> UNKNOWN | |
| (UNKNOWN) -> None | |
| == | |
| [case testSuggestUseFixmeNoNested] | |
| # suggest: --use-fixme=UNKNOWN foo.foo | |
| [file foo.py] | |
| from typing import List, Any | |
| def foo(x, y): | |
| return x, y | |
| def f() -> List[Any]: ... | |
| def g(): ... | |
| z = foo(f(), g()) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (list[Any], UNKNOWN) -> Tuple[list[Any], Any] | |
| == | |
| [case testSuggestBadImport] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| from nothing import Foo # type: ignore | |
| def foo(x: Foo): | |
| return 10 | |
| [out] | |
| (foo.Foo) -> int | |
| == | |
| [case testSuggestDict] | |
| # suggest: foo.foo | |
| # suggest: foo.bar | |
| # suggest: foo.baz | |
| # suggest: foo.quux | |
| # suggest: foo.spam | |
| [file foo.py] | |
| from typing import List, Any | |
| def foo(): | |
| return {'x': 5} | |
| def bar(): | |
| return {} | |
| def baz() -> List[Any]: | |
| return [{'x': 5}] | |
| def quux() -> List[Any]: | |
| return [1] | |
| def spam(x): | |
| pass | |
| spam({'x': 5}) | |
| [builtins fixtures/dict.pyi] | |
| [out] | |
| () -> dict[str, int] | |
| () -> dict[Any, Any] | |
| () -> list[dict[str, int]] | |
| () -> list[int] | |
| (dict[str, int]) -> None | |
| == | |
| [case testSuggestWithErrors] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| 1+'no' | |
| def foo(): | |
| return 10 | |
| [out] | |
| foo.py:1: error: Unsupported operand types for + ("int" and "str") | |
| () -> int | |
| == | |
| foo.py:1: error: Unsupported operand types for + ("int" and "str") | |
| [case testSuggestWithBlockingError] | |
| # suggest: foo.foo | |
| [file foo.py] | |
| def foo(): | |
| return 10 | |
| ( | |
| [out] | |
| foo.py:4: error: Unexpected EOF while parsing | |
| Command 'suggest' is only valid after a 'check' command (that produces no parse errors) | |
| == | |
| foo.py:4: error: Unexpected EOF while parsing | |
| -- ) | |
| [case testSuggestRefine] | |
| # suggest: foo.foo | |
| # suggest: foo.spam | |
| # suggest: foo.eggs | |
| # suggest: foo.take_l | |
| # suggest: foo.union | |
| # suggest: foo.callable1 | |
| # suggest: foo.callable2 | |
| # suggest: foo.optional1 | |
| # suggest: foo.optional2 | |
| # suggest: foo.optional3 | |
| # suggest: foo.optional4 | |
| # suggest: foo.optional5 | |
| # suggest: foo.optional_any | |
| # suggest: foo.dict1 | |
| # suggest: foo.tuple1 | |
| [file foo.py] | |
| from typing import Any, List, Union, Callable, Optional, Set, Dict, Tuple | |
| def bar(): | |
| return 10 | |
| def foo(x: int, y): | |
| return x + y | |
| foo(bar(), 10) | |
| def spam(x: int, y: Any) -> Any: | |
| return x + y | |
| spam(bar(), 20) | |
| def eggs(x: int) -> List[Any]: | |
| a = [x] | |
| return a | |
| def take_l(x: List[Any]) -> Any: | |
| return x[0] | |
| test = [10, 20] | |
| take_l(test) | |
| def union(x: Union[int, str]): | |
| pass | |
| union(10) | |
| def add1(x: float) -> int: | |
| pass | |
| def callable1(f: Callable[[int], Any]): | |
| return f(10) | |
| callable1(add1) | |
| def callable2(f: Callable[..., Any]): | |
| return f(10) | |
| callable2(add1) | |
| def optional1(x: Optional[Any]): | |
| pass | |
| optional1(10) | |
| def optional2(x: Union[None, int, Any]): | |
| if x is None: | |
| pass | |
| elif isinstance(x, str): | |
| pass | |
| else: | |
| add1(x) | |
| optional2(10) | |
| optional2('test') | |
| def optional3(x: Optional[List[Any]]): | |
| assert x | |
| return x[0] | |
| optional3(test) | |
| set_test = {1, 2} | |
| def optional4(x: Union[Set[Any], List[Any]]): | |
| pass | |
| optional4(test) | |
| optional4(set_test) | |
| def optional5(x: Optional[Any]): | |
| pass | |
| optional5(10) | |
| optional5(None) | |
| def optional_any(x: Optional[Any] = None): | |
| pass | |
| def dict1(d: Dict[int, Any]): | |
| pass | |
| d: Dict[Any, int] | |
| dict1(d) | |
| def tuple1(d: Tuple[int, Any]): | |
| pass | |
| t: Tuple[Any, int] | |
| tuple1(t) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (int, int) -> int | |
| (int, int) -> int | |
| (int) -> list[int] | |
| (list[int]) -> int | |
| (int | str) -> None | |
| (Callable[[int], int]) -> int | |
| (Callable[[float], int]) -> int | |
| (int | None) -> None | |
| (None | int | str) -> None | |
| (list[int] | None) -> int | |
| (set[int] | list[int]) -> None | |
| (int | None) -> None | |
| (Any | None) -> None | |
| (dict[int, int]) -> None | |
| (Tuple[int, int]) -> None | |
| == | |
| [case testSuggestRefine2] | |
| # suggest: foo.optional5 | |
| [file foo.py] | |
| from typing import Optional, Any | |
| def optional5(x: Optional[Any]): | |
| pass | |
| optional5(10) | |
| optional5(None) | |
| [builtins fixtures/isinstancelist.pyi] | |
| [out] | |
| (int | None) -> None | |
| == |