-- 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 arguments 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 arguments 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 arguments 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 arguments 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 arguments 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 arguments 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 arguments 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 testInlineErrorCodesOverrideConfigSmall]
# flags: --config-file tmp/mypy.ini
import tests.baz
[file tests/__init__.py]
[file tests/baz.py]
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 testInlineErrorCodesOverrideConfigSmall2]
# flags: --config-file tmp/mypy.ini
import tests.bar
import tests.baz
[file tests/__init__.py]
[file tests/baz.py]
42 + "no"  # type: ignore
[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 mypy.ini]
\[mypy]
enable_error_code = ignore-without-code, truthy-bool

\[mypy-tests.*]
disable_error_code = ignore-without-code


[case testInlineErrorCodesOverrideConfigSmallBackward]
# flags: --config-file tmp/mypy.ini
import tests.bar
import tests.baz
[file tests/__init__.py]
[file tests/baz.py]
42 + "no"  # type: ignore # E: "type: ignore" comment without error code (consider "type: ignore[operator]" instead)
[file tests/bar.py]
# mypy: disable-error-code="ignore-without-code"
42 + "no"  # type: ignore

[file mypy.ini]
\[mypy]
enable_error_code = ignore-without-code, truthy-bool

\[mypy-tests.*]
enable_error_code = ignore-without-code

[case testInlineOverrideConfig]
# 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 # type: ignore  # E: Unused "type: ignore" comment

[file tests/__init__.py]
[file tests/bar.py]
# mypy: warn_unused_ignores

def foo() -> int: ...
if foo: ...  # E: Function "foo" could always be true in boolean context
42 # type: ignore  # E: Unused "type: ignore" comment

[file tests/baz.py]
# mypy: disable-error-code="truthy-bool"
class Foo:
    pass

foo = Foo()
if foo: ...
42 # type: ignore

[file mypy.ini]
\[mypy]
warn_unused_ignores = True

\[mypy-tests.*]
warn_unused_ignores = False


[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

[case testInlinePythonVersion]
# mypy: python-version=3.10  # E: python_version not supported in inline configuration

[case testInlineErrorCodesArentRuinedByOthersBaseCase]
# mypy: disable-error-code=name-defined
a

[case testInlineErrorCodesArentRuinedByOthersInvalid]
# mypy: disable-error-code=name-defined
# mypy: AMONGUS
a
[out]
main:2: error: Unrecognized option: amongus = True

[case testInlineErrorCodesArentRuinedByOthersInvalidBefore]
# mypy: AMONGUS
# mypy: disable-error-code=name-defined
a
[out]
main:1: error: Unrecognized option: amongus = True

[case testInlineErrorCodesArentRuinedByOthersSe]
# mypy: disable-error-code=name-defined
# mypy: strict-equality
def is_magic(x: bytes) -> bool:
    y
    return x == 'magic' # E: Unsupported left operand type for == ("bytes")

[case testInlineConfigErrorCodesOffAndOn]
# mypy: disable-error-code=name-defined
# mypy: enable-error-code=name-defined
a # E: Name "a" is not defined

[case testInlineConfigErrorCodesOnAndOff]
# mypy: enable-error-code=name-defined
# mypy: disable-error-code=name-defined
a # E: Name "a" is not defined

[case testConfigFileErrorCodesOnAndOff]
# flags: --config-file tmp/mypy.ini
import foo
[file foo.py]
42 + "no"  # type: ignore  # E: "type: ignore" comment without error code (consider "type: ignore[operator]" instead)
[file mypy.ini]
\[mypy]
enable_error_code = ignore-without-code
disable_error_code = ignore-without-code

[case testInlineConfigBaseCaseWui]
# mypy: warn_unused_ignores
x = 1 # type: ignore # E: Unused "type: ignore" comment

[case testInlineConfigIsntRuinedByOthersInvalidWui]
# mypy: warn_unused_ignores
# mypy: AMONGUS
x = 1 # type: ignore # E: Unused "type: ignore" comment
[out]
main:2: error: Unrecognized option: amongus = True