check-optional.test

-- Tests for strict Optional behavior

[case testImplicitNoneType]
x = None
x()  # E: None not callable

[case testExplicitNoneType]
x = None  # type: None
x()  # E: None not callable

[case testNoneMemberOfOptional]
from typing import Optional
x = None  # type: Optional[int]

[case testTypeMemberOfOptional]
from typing import Optional
x = 0  # type: Optional[int]

[case testNoneNotMemberOfType]
x = None  # type: int
[out]
main:1: error: Incompatible types in assignment (expression has type None, variable has type "int")

[case testTypeNotMemberOfNone]
x = 0  # type: None
[out]
main:1: error: Incompatible types in assignment (expression has type "int", variable has type None)

[case testOptionalNotMemberOfType]
from typing import Optional
def f(a: int) -> None: pass
x = None  # type:  Optional[int]
f(x)  # E: Argument 1 to "f" has incompatible type "Optional[int]"; expected "int"

[case testIsinstanceCases]
from typing import Optional
x = None  # type:  Optional[int]
if isinstance(x, int):
  reveal_type(x)  # E: Revealed type is 'builtins.int'
else:
  reveal_type(x)  # E: Revealed type is 'builtins.None'
[builtins fixtures/isinstance.py]

[case testIfCases]
from typing import Optional
x = None  # type:  Optional[int]
if x:
  reveal_type(x)  # E: Revealed type is 'builtins.int'
else:
  reveal_type(x)  # E: Revealed type is 'Union[builtins.int, builtins.None]'
[builtins fixtures/bool.py]

[case testIfNotCases]
from typing import Optional
x = None  # type:  Optional[int]
if not x:
  reveal_type(x)  # E: Revealed type is 'Union[builtins.int, builtins.None]'
else:
  reveal_type(x)  # E: Revealed type is 'builtins.int'
[builtins fixtures/bool.py]

[case testIsNotNoneCases]
from typing import Optional
x = None  # type:  Optional[int]
if x is not None:
  reveal_type(x)  # E: Revealed type is 'builtins.int'
else:
  reveal_type(x)  # E: Revealed type is 'builtins.None'
[builtins fixtures/bool.py]

[case testIsNoneCases]
from typing import Optional
x = None  # type:  Optional[int]
if x is None:
  reveal_type(x)  # E: Revealed type is 'builtins.None'
else:
  reveal_type(x)  # E: Revealed type is 'builtins.int'
[builtins fixtures/bool.py]

[case testLambdaReturningNone]
f = lambda: None
x = f()

[case testNoneArgumentType]
def f(x: None) -> None: pass
f(None)

[case testInferOptionalFromDefaultNone]
def f(x: int = None) -> None:
  x + 1  # E: Unsupported left operand type for + (some union)
f(None)
[out]
main: note: In function "f":

[case testInferOptionalFromDefaultNoneWithFastParser]
# options: fast_parser
def f(x: int = None) -> None:
  x + 1  # E: Unsupported left operand type for + (some union)
f(None)
[out]
main: note: In function "f":

[case testInferOptionalType]
x = None
if bool():
  # scope limit assignment
  x = 1
  # in scope of the assignment, x is an int
  reveal_type(x)  # E: Revealed type is 'builtins.int'
# out of scope of the assignment, it's an Optional[int]
reveal_type(x)  # E: Revealed type is 'Union[builtins.int, builtins.None]'
[builtins fixtures/bool.py]

[case testInferOptionalTypeLocallyBound]
x = None
x = 1
reveal_type(x)  # E: Revealed type is 'builtins.int'


[case testInferOptionalTypeFromOptional]
from typing import Optional
y = None  # type: Optional[int]
x = None
x = y
reveal_type(x)  # E: Revealed type is 'Union[builtins.int, builtins.None]'

[case testInferOptionalListType]
x = [None]
x.append(1)
reveal_type(x)  # E: Revealed type is 'builtins.list[Union[builtins.int, builtins.None]]'
[builtins fixtures/list.py]

[case testInferNonOptionalListType]
x = []
x.append(1)
x()  # E: List[int] not callable
[builtins fixtures/list.py]

[case testInferOptionalDictKeyValueTypes]
x = {None: None}
x["bar"] = 1
reveal_type(x)  # E: Revealed type is 'builtins.dict[Union[builtins.str, builtins.None], Union[builtins.int, builtins.None]]'
[builtins fixtures/dict.py]

[case testInferNonOptionalDictType]
x = {}
x["bar"] = 1
x()  # E: Dict[str, int] not callable
[builtins fixtures/dict.py]

[case testNoneClassVariable]
from typing import Optional
class C:
    x = None  # type: int
    def __init__(self) -> None:
        self.x = 0

[case testNoneClassVariableInInit]
from typing import Optional
class C:
    x = None  # type: int
    def __init__(self) -> None:
        self.x = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
[out]
main: note: In member "__init__" of class "C":

[case testMultipleAssignmentNoneClassVariableInInit]
from typing import Optional
class C:
    x, y = None, None  # type: int, str
    def __init__(self) -> None:
        self.x = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
        self.y = None  # E: Incompatible types in assignment (expression has type None, variable has type "str")
[out]
main: note: In member "__init__" of class "C":

[case testOverloadWithNone]
from typing import overload
@overload
def f(x: None) -> str: pass
@overload
def f(x: int) -> int: pass
reveal_type(f(None))  # E: Revealed type is 'builtins.str'
reveal_type(f(0))  # E: Revealed type is 'builtins.int'

[case testOptionalTypeOrTypePlain]
from typing import Optional
def f(a: Optional[int]) -> int:
    return a or 0
[out]

[case testOptionalTypeOrTypeTypeVar]
from typing import Optional, TypeVar
T = TypeVar('T')
def f(a: Optional[T], b: T) -> T:
    return a or b
[out]

[case testOptionalTypeOrTypeBothOptional]
from typing import Optional
def f(a: Optional[int], b: Optional[int]) -> None:
    reveal_type(a or b)
def g(a: int, b: Optional[int]) -> None:
    reveal_type(a or b)
[out]
main: note: In function "f":
main:3: error: Revealed type is 'Union[builtins.int, builtins.None]'
main: note: In function "g":
main:5: error: Revealed type is 'Union[builtins.int, builtins.None]'

[case testOptionalTypeOrTypeComplexUnion]
from typing import Union
def f(a: Union[int, str, None]) -> None:
    reveal_type(a or 'default')
[out]
main: note: In function "f":
main:3: error: Revealed type is 'Union[builtins.int, builtins.str]'

[case testOptionalTypeOrTypeNoTriggerPlain]
from typing import Optional
def f(a: Optional[int], b: int) -> int:
    return b or a
[out]
main: note: In function "f":
main:3: error: Incompatible return value type (got "Optional[int]", expected "int")

[case testOptionalTypeOrTypeNoTriggerTypeVar]
from typing import Optional, TypeVar
T = TypeVar('T')
def f(a: Optional[T], b: T) -> T:
    return b or a
[out]
main: note: In function "f":
main:4: error: Incompatible return value type (got "Optional[T]", expected "T")

[case testNoneOrStringIsString]
def f() -> str:
    a = None
    b = ''
    return a or b
[out]

[case testNoneOrTypeVarIsTypeVar]
from typing import TypeVar
T = TypeVar('T')
def f(b: T) -> T:
    a = None
    return a or b
[out]

[case testYieldNothingInFunctionReturningGenerator]
from typing import Generator
def f() -> Generator[None, None, None]:
    yield
[out]

[case testNoneAndStringIsNone]
a = None
b = "foo"
reveal_type(a and b)  # E: Revealed type is 'builtins.None'

[case testNoneMatchesObjectInOverload]
import a
a.f(None)

[file a.pyi]
from typing import overload
@overload
def f() -> None: ...
@overload
def f(o: object) -> None: ...

[case testGenericSubclassReturningNone]
from typing import Generic, TypeVar

T = TypeVar('T')

class Base(Generic[T]):
  def f(self) -> T:
    pass

class SubNone(Base[None]):
  def f(self) -> None:
    pass

class SubInt(Base[int]):
  def f(self) -> int:
    return 1

[case testUseOfNoneReturningFunction]
from typing import Optional
def f() -> None:
    pass

def g(x: Optional[int]) -> int:
  pass

x = f()  # E: Function does not return a value
f() + 1  # E: Function does not return a value
g(f())  # E: Function does not return a value

[case testEmptyReturn]
def f() -> None:
    return

[case testReturnNone]
def f() -> None:
    return None

[case testNoneCallable]
from typing import Callable
def f() -> None: pass
x = f  # type: Callable[[], None]

[case testOptionalCallable]
from typing import Callable, Optional
T = Optional[Callable[..., None]]

[case testAnyTypeInPartialTypeList]
# options: check_untyped_defs
def f(): ...

def lookup_field(name, obj):
    try:
        pass
    except:
        attr = f()
    else:
        attr = None
[out]
main: note: In function "lookup_field":
main:10: error: Need type annotation for variable

[case testTernaryWithNone]
reveal_type(None if bool() else 0)  # E: Revealed type is 'Union[builtins.int, builtins.None]'
[builtins fixtures/bool.py]

[case testListWithNone]
reveal_type([0, None, 0])    # E: Revealed type is 'builtins.list[Union[builtins.int, builtins.None]]'
[builtins fixtures/list.py]