| -- Checks for 'mypy: option' directives inside files |
| |
| [case testInlineSimple1] |
| |
| # mypy: disallow-any-generics, no-warn-no-return |
| |
| from typing import List, Optional |
| def foo() -> Optional[List]: # E: Missing type parameters for generic type "List" |
| 20 |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineSimple2] |
| |
| # mypy: disallow-any-generics |
| # mypy: no-warn-no-return |
| |
| from typing import List, Optional |
| def foo() -> Optional[List]: # E: Missing type parameters for generic type "List" |
| 20 |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineSimple3] |
| |
| # mypy: disallow-any-generics=true, warn-no-return=0 |
| |
| from typing import List, Optional |
| def foo() -> Optional[List]: # E: Missing type parameters for generic type "List" |
| 20 |
| |
| [builtins fixtures/list.pyi] |
| |
| |
| [case testInlineSimple4] |
| |
| # mypy: disallow-any-generics = true, warn-no-return = 0 |
| |
| from typing import List, Optional |
| def foo() -> Optional[List]: # E: Missing type parameters for generic type "List" |
| 20 |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineList] |
| |
| # mypy: disallow-any-generics,always-false="FOO,BAR" |
| |
| from typing import List |
| |
| def foo(FOO: bool, BAR: bool) -> List: # E: Missing type parameters for generic type "List" |
| if FOO or BAR: |
| 1+'lol' |
| return [] |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineInvert1] |
| # flags: --disallow-any-generics --allow-untyped-globals |
| import a |
| [file a.py] |
| # mypy: allow-any-generics, disallow-untyped-globals |
| |
| x = [] # E: Need type annotation for "x" (hint: "x: List[<type>] = ...") |
| |
| from typing import List |
| def foo() -> List: |
| ... |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineInvert2] |
| |
| import a |
| [file a.py] |
| # mypy: no-always-true |
| |
| [out] |
| tmp/a.py:1: error: Can not invert non-boolean key always_true |
| |
| [case testInlineIncremental1] |
| |
| import a |
| [file a.py] |
| # mypy: disallow-any-generics, no-warn-no-return |
| |
| from typing import List, Optional |
| def foo() -> Optional[List]: |
| 20 |
| |
| [file a.py.2] |
| # mypy: no-warn-no-return |
| |
| from typing import List, Optional |
| def foo() -> Optional[List]: |
| 20 |
| |
| [file a.py.3] |
| from typing import List, Optional |
| def foo() -> Optional[List]: |
| 20 |
| [out] |
| tmp/a.py:4: error: Missing type parameters for generic type "List" |
| [out2] |
| [out3] |
| tmp/a.py:2: error: Missing return statement |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineIncremental2] |
| |
| # flags2: --disallow-any-generics |
| import a |
| [file a.py] |
| # mypy: no-warn-no-return |
| |
| from typing import Optional, List |
| def foo() -> Optional[List]: |
| 20 |
| |
| [file b.py.2] |
| # no changes to a.py, but flag change should cause recheck |
| |
| [out] |
| [out2] |
| tmp/a.py:4: error: Missing type parameters for generic type "List" |
| |
| [builtins fixtures/list.pyi] |
| |
| [case testInlineIncremental3] |
| import a, b |
| [file a.py] |
| # mypy: no-warn-no-return |
| from typing import Optional |
| |
| def foo() -> Optional[int]: |
| 20 |
| |
| [file b.py] |
| [file b.py.2] |
| # no changes to a.py and we want to make sure it isn't rechecked |
| [out] |
| [out2] |
| [rechecked b] |
| |
| [case testInlineError1] |
| # mypy: invalid-whatever |
| # mypy: no-warn-no-return; no-strict-optional |
| # mypy: always-true=FOO,BAR |
| # mypy: always-true="FOO,BAR |
| [out] |
| main:1: error: Unrecognized option: invalid_whatever = True |
| main:2: error: Unrecognized option: no_warn_no_return; no_strict_optional = True |
| main:3: error: Unrecognized option: bar = True |
| main:4: error: Unterminated quote in configuration comment |
| |
| [case testInlineError2] |
| # mypy: skip-file |
| [out] |
| main:1: error: Unrecognized option: skip_file = True |
| |
| [case testInlineStrict] |
| # mypy: strict |
| [out] |
| main:1: error: Setting "strict" not supported in inline configuration: specify it in a configuration file instead, or set individual inline flags (see "mypy -h" for the list of flags enabled in strict mode) |
| |
| [case testInlineErrorCodes] |
| # mypy: enable-error-code="ignore-without-code,truthy-bool" |
| class Foo: |
| pass |
| |
| foo = Foo() |
| if foo: ... # E: "__main__.foo" has type "Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context |
| 42 + "no" # type: ignore # E: "type: ignore" comment without error code (consider "type: ignore[operator]" instead) |
| |
| [case testInlineErrorCodesOverrideConfig] |
| # flags: --config-file tmp/mypy.ini |
| import foo |
| import tests.bar |
| import tests.baz |
| [file foo.py] |
| # mypy: disable-error-code="truthy-bool" |
| class Foo: |
| pass |
| |
| foo = Foo() |
| if foo: ... |
| 42 + "no" # type: ignore # E: "type: ignore" comment without error code (consider "type: ignore[operator]" instead) |
| |
| [file tests/__init__.py] |
| [file tests/bar.py] |
| # mypy: enable-error-code="ignore-without-code" |
| |
| def foo() -> int: ... |
| if foo: ... # E: Function "foo" could always be true in boolean context |
| 42 + "no" # type: ignore # E: "type: ignore" comment without error code (consider "type: ignore[operator]" instead) |
| |
| [file tests/baz.py] |
| # mypy: disable-error-code="truthy-bool" |
| class Foo: |
| pass |
| |
| foo = Foo() |
| if foo: ... |
| 42 + "no" # type: ignore |
| |
| [file mypy.ini] |
| \[mypy] |
| enable_error_code = ignore-without-code, truthy-bool |
| |
| \[mypy-tests.*] |
| disable_error_code = ignore-without-code |
| |
| [case testIgnoreErrorsSimple] |
| # mypy: ignore-errors=True |
| |
| def f() -> None: |
| while 1(): |
| pass |
| |
| [case testIgnoreErrorsInImportedModule] |
| from m import C |
| c = C() |
| reveal_type(c.x) # N: Revealed type is "builtins.int" |
| |
| [file m.py] |
| # mypy: ignore-errors=True |
| |
| class C: |
| def f(self) -> None: |
| self.x = 1 |
| |
| [case testIgnoreErrorsWithLambda] |
| # mypy: ignore-errors=True |
| |
| def f(self, x=lambda: 1) -> None: |
| pass |
| |
| class C: |
| def f(self) -> None: |
| l = lambda: 1 |
| self.x = 1 |
| |
| [case testIgnoreErrorsWithUnsafeSuperCall_no_empty] |
| |
| from m import C |
| |
| class D(C): |
| def m(self) -> None: |
| super().m1() |
| super().m2() \ |
| # E: Call to abstract method "m2" of "C" with trivial body via super() is unsafe |
| super().m3() \ |
| # E: Call to abstract method "m3" of "C" with trivial body via super() is unsafe |
| super().m4() \ |
| # E: Call to abstract method "m4" of "C" with trivial body via super() is unsafe |
| super().m5() \ |
| # E: Call to abstract method "m5" of "C" with trivial body via super() is unsafe |
| super().m6() \ |
| # E: Call to abstract method "m6" of "C" with trivial body via super() is unsafe |
| super().m7() |
| |
| def m1(self) -> int: |
| return 0 |
| |
| def m2(self) -> int: |
| return 0 |
| |
| def m3(self) -> int: |
| return 0 |
| |
| def m4(self) -> int: |
| return 0 |
| |
| def m5(self) -> int: |
| return 0 |
| |
| def m6(self) -> int: |
| return 0 |
| |
| [file m.py] |
| # mypy: ignore-errors=True |
| import abc |
| |
| class C: |
| @abc.abstractmethod |
| def m1(self) -> int: |
| """x""" |
| return 0 |
| |
| @abc.abstractmethod |
| def m2(self) -> int: |
| """doc""" |
| |
| @abc.abstractmethod |
| def m3(self) -> int: |
| pass |
| |
| @abc.abstractmethod |
| def m4(self) -> int: ... |
| |
| @abc.abstractmethod |
| def m5(self) -> int: |
| """doc""" |
| ... |
| |
| @abc.abstractmethod |
| def m6(self) -> int: |
| raise NotImplementedError() |
| |
| @abc.abstractmethod |
| def m7(self) -> int: |
| raise NotImplementedError() |
| pass |
| |
| [builtins fixtures/exception.pyi] |
| |
| [case testInlineErrorCodesMultipleCodes] |
| # mypy: disable-error-code="truthy-bool, ignore-without-code" |
| class Foo: |
| pass |
| |
| foo = Foo() |
| if foo: ... |
| 42 + "no" # type: ignore |
