[case testUnannotatedFunction]

# flags: --disallow-untyped-defs

def f(x): pass

[out]

main:2: error: Function is missing a type annotation

[case testUnannotatedArgument]

# flags: --disallow-untyped-defs

def f(x) -> int: pass

[out]

main:2: error: Function is missing a type annotation for one or more parameters

[case testNoArgumentFunction]

# flags: --disallow-untyped-defs

def f() -> int: pass

[out]

[case testUnannotatedReturn]

# flags: --disallow-untyped-defs

def f(x: int): pass

[out]

main:2: error: Function is missing a return type annotation

[case testUnannotatedReturnWithFastParser]

# flags: --disallow-untyped-defs

def f(x: int): pass

[out]

main:2: error: Function is missing a return type annotation

[case testLambda]

# flags: --disallow-untyped-defs

lambda x: x

[out]

[case testUntypedDef]

# flags: --disallow-untyped-defs

def f():

1 + "str"

[out]

main:2: error: Function is missing a return type annotation

main:2: note: Use "-> None" if function does not return a value

[case testUnannotatedReturnWithOnlySelfArgument]

# flags: --disallow-untyped-defs

def f(self): pass

[out]

main:2: error: Function is missing a return type annotation

main:2: note: Use "-> None" if function does not return a value

[case testUnannotatedReturnWithNontrivialReturn]

# flags: --disallow-untyped-defs

def f(): return 1

[out]

main:2: error: Function is missing a return type annotation

[case testUntypedAsyncDef]

# flags: --disallow-untyped-defs

async def f(): # E: Function is missing a return type annotation \

# N: Use "-> None" if function does not return a value

pass

[builtins fixtures/async_await.pyi]

[typing fixtures/typing-async.pyi]

[case testAsyncUnannotatedArgument]

# flags: --disallow-untyped-defs

async def f(x) -> None: # E: Function is missing a type annotation for one or more parameters

pass

[builtins fixtures/async_await.pyi]

[typing fixtures/typing-async.pyi]

[case testAsyncUnannotatedReturn]

# flags: --disallow-untyped-defs

from typing import Any

async def f(x: int): # E: Function is missing a return type annotation

pass

# Make sure explicit Any is allowed.

async def g(x: int) -> Any:

pass

[builtins fixtures/async_await.pyi]

[typing fixtures/typing-async.pyi]

[case testDisallowUntypedDefsAndGeneric]

# flags: --disallow-untyped-defs --disallow-any-generics

def get_tasks(self):

return 'whatever'

[out]

main:2: error: Function is missing a return type annotation

[case testDisallowUntypedDefsUntypedDecorator]

# flags: --disallow-untyped-decorators

def d(p):

return p

@d # E: Untyped decorator makes function "f" untyped

def f(i: int) -> int:

return i

[case testDisallowUntypedDecoratorsUnresolvedDecorator]

# flags: --disallow-untyped-decorators --ignore-missing-imports

from nonexistent import d

@d # E: Untyped decorator makes function "f" untyped

def f(i: int) -> int:

return i

[case testDisallowUntypedDecoratorUntypedDef]

# flags: --disallow-untyped-decorators

def d(p):

return p

@d # no error

def f(): pass

[case testDisallowUntypedDecoratorsPartialFunction]

# flags: --disallow-untyped-decorators

def d(p):

return p

@d # E: Untyped decorator makes function "f" untyped

def f(x) -> None: pass

@d # E: Untyped decorator makes function "g" untyped

def g(x, y: int): pass

@d # E: Untyped decorator makes function "h" untyped

def h(x: int): pass

[case testDisallowUntypedDecoratorsImpreciseDecorator]

# flags: --disallow-untyped-decorators

from typing import Any

def d(p) -> Any:

return p

@d # no error

def f() -> None: pass

[case testDisallowUntypedDecoratorsMultipleDecorators]

# flags: --disallow-untyped-decorators

from typing import Any

def d1(p):

return p

def d2(p):

return p

def d3(p) -> Any:

return p

@d1 # E: Untyped decorator makes function "f" untyped

@d2 # E: Untyped decorator makes function "f" untyped

@d3 # no error

@d1 # E: Untyped decorator makes function "f" untyped

def f() -> None: pass

[case testDisallowUntypedDecoratorsCallableInstance]

# flags: --disallow-untyped-decorators

from typing import Callable

class TypedDecorator:

def __call__(self, c: Callable) -> Callable:

return function

class UntypedDecorator:

def __call__(self, c):

return function

@TypedDecorator()

def f() -> None: pass

@UntypedDecorator() # E: Untyped decorator makes function "g" untyped

def g() -> None: pass

@TypedDecorator()

@UntypedDecorator() # E: Untyped decorator makes function "h" untyped

def h() -> None: pass

@UntypedDecorator() # E: Untyped decorator makes function "i" untyped

@TypedDecorator()

def i() -> None: pass

reveal_type(f) # N: Revealed type is "def (*Any, **Any) -> Any"

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

reveal_type(h) # N: Revealed type is "def (*Any, **Any) -> Any"

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

[case testDisallowUntypedDecoratorsCallableInstanceDecoratedCall]

# flags: --disallow-untyped-decorators

from typing import Callable, TypeVar

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

def typed_decorator(c: C) -> C:

return c

def untyped_decorator(c):

return c

class TypedDecorator:

@typed_decorator

def __call__(self, c: Callable) -> Callable:

return function

class UntypedDecorator1:

@untyped_decorator

def __call__(self, c):

return function

class UntypedDecorator2:

@untyped_decorator # E: Untyped decorator makes function "__call__" untyped

def __call__(self, c: Callable) -> Callable:

return function

class UntypedDecorator3:

@typed_decorator

@untyped_decorator # E: Untyped decorator makes function "__call__" untyped

def __call__(self, c: Callable) -> Callable:

return function

class UntypedDecorator4:

@untyped_decorator # E: Untyped decorator makes function "__call__" untyped

@typed_decorator

def __call__(self, c: Callable) -> Callable:

return function

@TypedDecorator()

def f() -> None: pass

@UntypedDecorator1() # E: Untyped decorator makes function "g1" untyped

def g1() -> None: pass

@UntypedDecorator2() # E: Untyped decorator makes function "g2" untyped

def g2() -> None: pass

@UntypedDecorator3() # E: Untyped decorator makes function "g3" untyped

def g3() -> None: pass

@UntypedDecorator4() # E: Untyped decorator makes function "g4" untyped

def g4() -> None: pass

reveal_type(f) # N: Revealed type is "def (*Any, **Any) -> Any"

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

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

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

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

[builtins fixtures/bool.pyi]

[case testDisallowUntypedDecoratorsNonCallableInstance]

# flags: --disallow-untyped-decorators

class Decorator:

pass

@Decorator() # E: "Decorator" not callable

def f() -> None: pass

[case testSubclassingAny]

# flags: --disallow-subclassing-any

from typing import Any

FakeClass = None # type: Any

class Foo(FakeClass): pass # E: Class cannot subclass "FakeClass" (has type "Any")

[out]

[case testSubclassingAnyMultipleBaseClasses]

# flags: --disallow-subclassing-any

from typing import Any

FakeClass = None # type: Any

class ActualClass: pass

class Foo(ActualClass, FakeClass): pass # E: Class cannot subclass "FakeClass" (has type "Any")

[out]

[case testSubclassingAnySilentImports]

# flags: --disallow-subclassing-any --follow-imports=skip

# cmd: mypy -m main

[file main.py]

from ignored_module import BaseClass

class Foo(BaseClass): pass

[file ignored_module.py]

class BaseClass: pass

[out]

tmp/main.py:2: error: Class cannot subclass "BaseClass" (has type "Any")

[case testSubclassingAnySilentImports2]

# flags: --disallow-subclassing-any --follow-imports=skip

# cmd: mypy -m main

[file main.py]

import ignored_module

class Foo(ignored_module.BaseClass): pass

[file ignored_module.py]

class BaseClass: pass

[out]

tmp/main.py:2: error: Class cannot subclass "BaseClass" (has type "Any")

[case testWarnNoReturnIgnoresTrivialFunctions]

# flags: --warn-no-return

def f() -> int:

pass

def g() -> int:

...

def h() -> int:

"""with docstring"""

pass

def i() -> int:

"""with docstring"""

...

def j() -> int:

u"""with unicode docstring"""

pass

def k() -> int:

"""docstring only"""

[case testWarnNoReturnWorksWithAlwaysTrue]

# flags: --warn-no-return

PY3 = True

def f() -> int:

if PY3:

return 0

else:

return 0

[builtins fixtures/bool.pyi]

[case testWarnNoReturnWorksWithAlwaysFalse]

# flags: --warn-no-return

PY2 = False

def f() -> int:

if PY2:

return 0

else:

return 0

[builtins fixtures/bool.pyi]

[case testWarnNoReturnWorksWithMypyTrue]

# flags: --warn-no-return

MYPY = False

def f() -> int:

if MYPY:

return 0

else:

return 0

[builtins fixtures/bool.pyi]

[case testNoReturnDisallowsReturn]

# flags: --warn-no-return

from typing import NoReturn

def f() -> NoReturn:

if bool():

return 5 # E: Return statement in function which does not return

else:

return # E: Return statement in function which does not return

[builtins fixtures/dict.pyi]

[case testNoReturnWithoutImplicitReturn]

# flags: --warn-no-return

from typing import NoReturn

def no_return() -> NoReturn: pass

def f() -> NoReturn:

no_return()

[builtins fixtures/dict.pyi]

[case testNoReturnDisallowsImplicitReturn]

# flags: --warn-no-return

from typing import NoReturn

def f() -> NoReturn: # E: Implicit return in function which does not return

non_trivial_function = 1

[builtins fixtures/dict.pyi]

[case testNoReturnImplicitReturnCheckInDeferredNode]

# flags: --warn-no-return

from typing import NoReturn

def exit() -> NoReturn: ...

def force_forward_reference() -> int:

return 4

def f() -> NoReturn:

x

exit()

x = force_forward_reference()

[builtins fixtures/exception.pyi]

[case testNoReturnNoWarnNoReturn]

# flags: --warn-no-return

from typing import NoReturn

def no_return() -> NoReturn: pass

def f() -> int:

if bool():

return 0

else:

no_return()

[builtins fixtures/dict.pyi]

[case testNoReturnInExpr]

# flags: --warn-no-return

from typing import NoReturn

def no_return() -> NoReturn: pass

def f() -> int:

return 0

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

[builtins fixtures/dict.pyi]

[case testNoReturnVariable]

# flags: --warn-no-return

from typing import NoReturn

x = 0 # type: NoReturn # E: Incompatible types in assignment (expression has type "int", variable has type "Never")

[builtins fixtures/dict.pyi]

[case testNoReturnAsync]

# flags: --warn-no-return

from typing import NoReturn

async def f() -> NoReturn: ...

async def g() -> NoReturn:

await f()

async def h() -> NoReturn: # E: Implicit return in function which does not return

# Purposely not evaluating coroutine

_ = f()

[builtins fixtures/dict.pyi]

[typing fixtures/typing-async.pyi]

[case testNoWarnNoReturn]

# flags: --no-warn-no-return

import typing

def implicit_optional_return(arg) -> typing.Optional[str]:

if arg:

return "false"

def unsound_implicit_return(arg) -> str: # E: Incompatible return value type (implicitly returns "None", expected "str")

if arg:

return "false"

def implicit_return_gen(arg) -> typing.Generator[int, None, typing.Optional[str]]:

yield 1

def unsound_implicit_return_gen(arg) -> typing.Generator[int, None, str]: # E: Incompatible return value type (implicitly returns "None", expected "str")

yield 1

[builtins fixtures/dict.pyi]

[case testNoWarnNoReturnNoStrictOptional]

# flags: --no-warn-no-return --no-strict-optional

import typing

def implicit_optional_return(arg) -> typing.Optional[str]:

if arg:

return "false"

def unsound_implicit_return(arg) -> str:

if arg:

return "false"

def implicit_return_gen(arg) -> typing.Generator[int, None, typing.Optional[str]]:

yield 1

def unsound_implicit_return_gen(arg) -> typing.Generator[int, None, str]:

yield 1

[builtins fixtures/dict.pyi]

[case testNoReturnImportFromTyping]

from typing import NoReturn

def h() -> NoReturn:

if bool():

return 5 # E: Return statement in function which does not return

else:

return # E: Return statement in function which does not return

def no_return() -> NoReturn: pass

def f() -> NoReturn:

no_return()

x: NoReturn = 0 # E: Incompatible types in assignment (expression has type "int", variable has type "Never")

[builtins fixtures/dict.pyi]

[case testShowErrorContextFunction]

# flags: --show-error-context

def f() -> None:

0 + ""

[out]

main: note: In function "f":

main:3: error: Unsupported operand types for + ("int" and "str")

[case testShowErrorContextClass]

# flags: --show-error-context

class A:

0 + ""

[out]

main: note: In class "A":

main:3: error: Unsupported operand types for + ("int" and "str")

[case testShowErrorContextMember]

# flags: --show-error-context

class A:

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

self.f("")

[out]

main: note: In member "f" of class "A":

main:4: error: Argument 1 to "f" of "A" has incompatible type "str"; expected "int"

[case testShowErrorContextModule]

# flags: --show-error-context

import m

[file m.py]

0 + ""

[out]

main:2: note: In module imported here:

tmp/m.py:1: error: Unsupported operand types for + ("int" and "str")

[case testShowErrorContextTopLevel]

# flags: --show-error-context

def f() -> None:

0 + ""

0 + ""

[out]

main: note: In function "f":

main:3: error: Unsupported operand types for + ("int" and "str")

main: note: At top level:

main:4: error: Unsupported operand types for + ("int" and "str")

[case testShowErrorContextFromHere]

# flags: --show-error-context

import a

[file a.py]

import b

[file b.py]

0 + ""

[out]

tmp/a.py:1: note: In module imported here,

main:2: note: ... from here:

tmp/b.py:1: error: Unsupported operand types for + ("int" and "str")

[case testFollowImportsNormal]

# flags: --follow-imports=normal

from mod import x

x + 0

x + "" # E: Unsupported operand types for + ("int" and "str")

import mod

mod.x + 0

mod.x + "" # E: Unsupported operand types for + ("int" and "str")

mod.y # E: Module has no attribute "y"

mod + 0 # E: Unsupported left operand type for + (Module)

[file mod.py]

1 + "" # E: Unsupported operand types for + ("int" and "str")

x = 0

x += "" # E: Unsupported operand types for + ("int" and "str")

[case testFollowImportsSilent]

# flags: --follow-imports=silent

from mod import x

x + "" # E: Unsupported operand types for + ("int" and "str")

import mod

mod.x + "" # E: Unsupported operand types for + ("int" and "str")

mod.y # E: Module has no attribute "y"

mod + 0 # E: Unsupported left operand type for + (Module)

[file mod.py]

1 + ""

x = 0

x += ""

[case testFollowImportsSilentOverloadResolution]

# flags: --follow-imports=silent

from mod import x

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

[file mod.py]

from typing import overload

@overload

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

@overload

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

def f(x: int | str) -> int | str:

return x

x = f("")

[case testFollowImportsSilentReverseOperator]

# flags: --follow-imports=silent

from mod import x

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

[file mod.py]

class A:

def __add__(self, other: int) -> int: ...

class B:

def __radd__(self, other: A) -> str: ...

x = A() + B()

[case testFollowImportsSilentTypedDictUnion]

# flags: --follow-imports=silent

from mod import x

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

[file mod.py]

from typing_extensions import TypedDict

class A(TypedDict):

value: int

class B(TypedDict):

value: str

data: A | B

data = {"value": ""}

x = data["value"]

[file typing_extensions.pyi]

TypedDict = 0

class _TypedDict: pass

[case testFollowImportsSilentTypeIgnore]

# flags: --warn-unused-ignores --follow-imports=silent

import mod

[file mod.py]

x = 3 # type: ignore

[case testFollowImportsSkip]

# flags: --follow-imports=skip

from mod import x

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

x + ""

import mod

reveal_type(mod.x) # N: Revealed type is "Any"

[file mod.py]

this deliberate syntax error will not be reported

[case testFollowImportsError]

# flags: --follow-imports=error

from mod import x # E: Import of "mod" ignored \

# N: (Using --follow-imports=error, module not passed on command line)

x + ""

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

import mod

reveal_type(mod.x) # N: Revealed type is "Any"

[file mod.py]

deliberate syntax error

[case testFollowImportsSelective]

# flags: --config-file tmp/mypy.ini

import normal

import silent

import skip

import error # E: Import of "error" ignored \

# N: (Using --follow-imports=error, module not passed on command line)

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

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

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

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

[file mypy.ini]

\[mypy]

\[mypy-normal]

follow_imports = normal

\[mypy-silent]

follow_imports = silent

\[mypy-skip]

follow_imports = skip

\[mypy-error]

follow_imports = error

[file normal.py]

x = 0

x += '' # E: Unsupported operand types for + ("int" and "str")

[file silent.py]

x = 0

x += ''

[file skip.py]

bla bla

[file error.py]

bla bla

[case testFlagsFile]

# flags: @tmp/flagsfile

x: int

FLAG = False

if not FLAG:

x = "unreachable"

[file flagsfile]

----always-true=FLAG

[case testConfigFile]

# flags: --config-file tmp/mypy.ini

x: int

FLAG = False

if not FLAG:

x = "unreachable"

[file mypy.ini]

\[mypy]

always_true = FLAG

[case testAltConfigFile]

# flags: --config-file tmp/config.ini

x: int

FLAG = False

if not FLAG:

x = "unreachable"

[file config.ini]

\[mypy]

always_true = FLAG

[case testMultipleGlobConfigSection]

# flags: --config-file tmp/mypy.ini

import x, y, z

[file mypy.ini]

\[mypy]

\[mypy-x.*,z.*]

disallow_untyped_defs = True

[file x.py]

def f(a): pass # E: Function is missing a type annotation

[file y.py]

def f(a): pass

[file z.py]

def f(a): pass # E: Function is missing a type annotation

[case testConfigMypyPath]

# flags: --config-file tmp/mypy.ini

import no_stubs # E: Cannot find implementation or library stub for module named "no_stubs" \

# N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports

from foo import foo

from bar import bar

from baz import baz

baz(bar(foo(42)))

baz(bar(foo('oof'))) # E: Argument 1 to "foo" has incompatible type "str"; expected "int"

[file mypy.ini]

\[mypy]

mypy_path =

$MYPY_CONFIG_FILE_DIR/foo_dir:$MYPY_CONFIG_FILE_DIR/bar_dir

, $MYPY_CONFIG_FILE_DIR/baz_dir

[file foo_dir/foo.pyi]

def foo(x: int) -> str: ...

[file bar_dir/bar.pyi]

def bar(x: str) -> list: ...

[file baz_dir/baz.pyi]

def baz(x: list) -> dict: ...

[case testDisallowAnyGenericsBuiltinCollections]

# flags: --config-file tmp/mypy.ini

import m

[file mypy.ini]

\[mypy]

\[mypy-m]

disallow_any_generics = True

[file m.py]

def j(s: set) -> None: pass # E: Missing type arguments for generic type "set"

[builtins fixtures/set.pyi]

[case testDisallowAnyGenericsTypingCollections]

# flags: --config-file tmp/mypy.ini

import m

[file mypy.ini]

\[mypy]

\[mypy-m]

disallow_any_generics = True

[file m.py]

from typing import Set

def j(s: Set) -> None: pass # E: Missing type arguments for generic type "Set"

[builtins fixtures/set.pyi]

[case testSectionInheritance]

# flags: --config-file tmp/mypy.ini

import a, a.foo, a.b.c, a.b.c.d.e

[file a/__init__.py]

0()

[file a/foo.py]

0()

[file a/b/__init__.py]

[file a/b/c/__init__.py]

0()

[file a/b/c/d/__init__.py]

[file a/b/c/d/e/__init__.py]

from typing import List

def g(x: List) -> None: pass # E: Missing type arguments for generic type "List"

g(None) # E: Argument 1 to "g" has incompatible type "None"; expected "list[Any]"

[file mypy.ini]

\[mypy]

allow_any_generics = True

strict_optional = False

\[mypy-a.*]

ignore_errors = True

\[mypy-a.b.*]

disallow_any_generics = True

ignore_errors = True

\[mypy-a.b.c.*]

ignore_errors = True

\[mypy-a.b.c.d.*]

ignore_errors = True

\[mypy-a.b.c.d.e.*]

ignore_errors = True

strict_optional = True

\[mypy-a.b.c.d.e]

ignore_errors = False

[case testFollowImportStubs1]

# flags: --config-file tmp/mypy.ini

import math # E: Import of "math" ignored \

# N: (Using --follow-imports=error, module not passed on command line)

math.frobnicate()

[file mypy.ini]

\[mypy]

\[mypy-math.*]

follow_imports = error

follow_imports_for_stubs = True

[case testFollowImportStubs2]

# flags: --config-file tmp/mypy.ini

import math

math.frobnicate()

[file mypy.ini]

\[mypy]

\[mypy-math.*]

follow_imports = skip

follow_imports_for_stubs = True

[case testConfigUnstructuredGlob]

# flags: --config-file tmp/mypy.ini

import emarg.foo, emarg.villip, emarg.hatch.villip.nus, emarg.hatch.villip.mankangulisk, foo.lol

[file mypy.ini]

\[mypy]

ignore_errors = true

\[mypy-*.lol]

ignore_errors = false

\[mypy-emarg.*]

ignore_errors = false

\[mypy-emarg.*.villip.*]

ignore_errors = true

\[mypy-emarg.hatch.villip.mankangulisk]

ignore_errors = false

[file emarg/__init__.py]

[file emarg/foo.py]

fail # E: Name "fail" is not defined

[file emarg/villip.py]

fail

[file emarg/hatch/__init__.py]

[file emarg/hatch/villip/__init__.py]

[file emarg/hatch/villip/nus.py]

fail

[file emarg/hatch/villip/mankangulisk.py]

fail # E: Name "fail" is not defined

[file foo/__init__.py]

[file foo/lol.py]

fail # E: Name "fail" is not defined

[case testIgnoreMissingImportsFalse]

from mod import x

[out]

main:1: error: Cannot find implementation or library stub for module named "mod"

main:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports

[case testIgnoreMissingImportsTrue]

# flags: --ignore-missing-imports

from mod import x

[out]

[case testNoConfigFile]

# flags: --config-file=

# type: ignore

[file mypy.ini]

\[mypy]

warn_unused_ignores = True

[out]

[case testPerFileIncompleteDefsBasic]

# flags: --config-file tmp/mypy.ini

import standard, incomplete

[file standard.py]

def incomplete(x) -> int:

return 0

[file incomplete.py]

def incomplete(x) -> int: # E: Function is missing a type annotation for one or more parameters

return 0

[file mypy.ini]

\[mypy]

disallow_incomplete_defs = False

\[mypy-incomplete]

disallow_incomplete_defs = True

[case testPerFileIncompleteDefsBasicPyProjectTOML]

# flags: --config-file tmp/pyproject.toml

import standard, incomplete

[file standard.py]

def incomplete(x) -> int:

return 0

[file incomplete.py]

def incomplete(x) -> int: # E: Function is missing a type annotation for one or more parameters

return 0

[file pyproject.toml]

\[tool.mypy]

disallow_incomplete_defs = false

\[[tool.mypy.overrides]]

module = 'incomplete'

disallow_incomplete_defs = true

[case testPerFileStrictOptionalBasic]

# flags: --config-file tmp/mypy.ini

import standard, optional

[file standard.py]

x = 0

if int():

x = None

[file optional.py]

x = 0

if int():

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

[file mypy.ini]

\[mypy]

strict_optional = False

\[mypy-optional]

strict_optional = True

[case testPerFileStrictOptionalBasicPyProjectTOML]

# flags: --config-file tmp/pyproject.toml

import standard, optional

[file standard.py]

x = 0

if int():

x = None

[file optional.py]

x = 0

if int():

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

[file pyproject.toml]

\[tool.mypy]

strict_optional = false

\[[tool.mypy.overrides]]

module = 'optional'

strict_optional = true

[case testPerFileStrictOptionalBasicImportStandard]

# flags: --config-file tmp/mypy.ini

import standard, optional

[file standard.py]

from typing import Optional

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

an_int = 0 # type: int

optional_int = None # type: Optional[int]

f(an_int) # ints can be used as ints

f(optional_int) # optional ints can be used as ints in this file

[file optional.py]

import standard

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

standard.an_int = None # E: Incompatible types in assignment (expression has type "None", variable has type "int")

standard.optional_int = None # OK -- explicitly declared as optional

f(standard.an_int) # ints can be used as ints

f(standard.optional_int) # E: Argument 1 to "f" has incompatible type "None"; expected "int"

[file mypy.ini]

\[mypy]

strict_optional = False

\[mypy-optional]

strict_optional = True

[case testPerFileStrictOptionalBasicImportStandardPyProjectTOML]

# flags: --config-file tmp/pyproject.toml

import standard, optional

[file standard.py]

from typing import Optional

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

an_int = 0 # type: int

optional_int = None # type: Optional[int]

f(an_int) # ints can be used as ints

f(optional_int) # optional ints can be used as ints in this file

[file optional.py]

import standard

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

standard.an_int = None # E: Incompatible types in assignment (expression has type "None", variable has type "int")

standard.optional_int = None # OK -- explicitly declared as optional

f(standard.an_int) # ints can be used as ints

f(standard.optional_int) # E: Argument 1 to "f" has incompatible type "None"; expected "int"

[file pyproject.toml]

\[tool.mypy]

strict_optional = false

\[[tool.mypy.overrides]]

module = 'optional'

strict_optional = true

[case testPerFileStrictOptionalBasicImportOptional]

# flags: --config-file tmp/mypy.ini

import standard, optional