render types: render -> None in callables

Author: KotlinIsland

.mypy/baseline.json

@@ -4,6 +4,8 @@
 ### Enhancements
 - Similar errors on the same line will now not be removed
 - Render generic upper bound with `: ` instead of ` <: `
+- Render uninhabited type as `Never` instead of `<nothing>`
+- Render Callables with `-> None`
 ### Fixes
 - Handle positional only `/` parameters in overload implementation inference
 - Render inferred literal without `?`

CHANGELOG.md

@@ -3062,6 +3062,8 @@ def visit_callable_type(self, t: CallableType) -> str:
                     s += f" -> TypeGuard[{t.type_guard.accept(self)}]"
                 else:
                     s += f" -> {t.ret_type.accept(self)}"
+            elif mypy.options._based:
+                s += " -> None"
 
             s = self.render_callable_type_params(t, lambda x: x.accept(self)) + s
 

mypy/types.py

@@ -3,18 +3,18 @@
 
 [case testSimple]
 def f(): ...
-reveal_type(f)  # N: Revealed type is "def ()"
+reveal_type(f)  # N: Revealed type is "def () -> None"
 reveal_type(f())  # N: Revealed type is "None"
 
 def g(i: int): ...
-reveal_type(g)  # N: Revealed type is "def (i: int)"
+reveal_type(g)  # N: Revealed type is "def (i: int) -> None"
 
 class A:
     def f(self): ...
     def g(self, i: int): ...
 
-reveal_type(A.f)  # N: Revealed type is "def (self: __main__.A)"
-reveal_type(A.g)  # N: Revealed type is "def (self: __main__.A, i: int)"
+reveal_type(A.f)  # N: Revealed type is "def (self: __main__.A) -> None"
+reveal_type(A.g)  # N: Revealed type is "def (self: __main__.A, i: int) -> None"
 
 
 [case testUntypedDefs]
@@ -24,7 +24,7 @@ def f(): ...
 reveal_type(f)  # N: Revealed type is "def () -> Untyped"
 
 def g(i: int): ...
-reveal_type(g)  # N: Revealed type is "def (i: int)"
+reveal_type(g)  # N: Revealed type is "def (i: int) -> None"
 
 def h(i: int, j): ...  # E: Function is missing a type annotation for one or more arguments  [no-untyped-def]
 
@@ -36,8 +36,8 @@ class A:
 
 reveal_type(A.f)  # N: Revealed type is "def (self: __main__.A) -> Untyped"
 reveal_type(A.g)  # N: Revealed type is "def (self: __main__.A, i: Untyped) -> Untyped"
-reveal_type(A.h)  # N: Revealed type is "def (self: __main__.A, i: int)"
-reveal_type(A.i)  # N: Revealed type is "def (self: __main__.A, i: int, j: Untyped)"
+reveal_type(A.h)  # N: Revealed type is "def (self: __main__.A, i: int) -> None"
+reveal_type(A.i)  # N: Revealed type is "def (self: __main__.A, i: int, j: Untyped) -> None"
 
 
 [case testIncompleteDefs]
@@ -47,7 +47,7 @@ def f(i): ...
 reveal_type(f)  # N: Revealed type is "def (i: Untyped) -> Untyped"
 
 def g(i: int, j): ...
-reveal_type(g)  # N: Revealed type is "def (i: int, j: Untyped)"
+reveal_type(g)  # N: Revealed type is "def (i: int, j: Untyped) -> None"
 
 class A:
     def f(self): ...
@@ -57,8 +57,8 @@ class A:
 
 reveal_type(A.f)  # N: Revealed type is "def (self: __main__.A) -> Untyped"
 reveal_type(A.g)  # N: Revealed type is "def (self: __main__.A, i: Untyped) -> Untyped"
-reveal_type(A.h)  # N: Revealed type is "def (self: __main__.A, i: int)"
-reveal_type(A.i)  # N: Revealed type is "def (self: __main__.A, i: int, j: Untyped)"
+reveal_type(A.h)  # N: Revealed type is "def (self: __main__.A, i: int) -> None"
+reveal_type(A.i)  # N: Revealed type is "def (self: __main__.A, i: int, j: Untyped) -> None"
 
 
 [case testGenerator]
@@ -144,15 +144,15 @@ class A:
     def f(self, i: int): ...
     def f(self, i: int = 0): ...
 
-reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A), def (self: __main__.A, i: int))"
+reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A) -> None, def (self: __main__.A, i: int) -> None)"
 
 @overload
 def f(): ...
 @overload
 def f(i: int): ...
 def f(i: int = 0): ...
 
-reveal_type(f)  # N: Revealed type is "Overload(def (), def (i: int))"
+reveal_type(f)  # N: Revealed type is "Overload(def () -> None, def (i: int) -> None)"
 
 
 [case testOverloadIncomplete]
@@ -168,7 +168,7 @@ class A:
     def f(self, i, j: int): ...
     def f(self, i: int = 0, j: int = 0): ...
 
-reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A), def (self: __main__.A, i: Untyped), def (self: __main__.A, i: Untyped, j: int))"
+reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A) -> None, def (self: __main__.A, i: Untyped) -> None, def (self: __main__.A, i: Untyped, j: int) -> None)"
 
 @overload
 def f(): ...
@@ -178,7 +178,7 @@ def f(i): ...
 def f(i, j: int): ...
 def f(i: int = 0, j: int = 0): ...
 
-reveal_type(f)  # N: Revealed type is "Overload(def (), def (i: Untyped), def (i: Untyped, j: int))"
+reveal_type(f)  # N: Revealed type is "Overload(def () -> None, def (i: Untyped) -> None, def (i: Untyped, j: int) -> None)"
 
 
 [case testOverloadUntyped]
@@ -194,7 +194,7 @@ class A:
     def f(self, *, j: int): ...
     def f(self, i: int = 0, j: int = 0): ...
 
-reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A), def (self: __main__.A, i: Untyped), def (self: __main__.A, *, j: int))"
+reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A) -> None, def (self: __main__.A, i: Untyped) -> None, def (self: __main__.A, *, j: int) -> None)"
 
 @overload
 def f(): ...
@@ -204,7 +204,7 @@ def f(i): ...
 def f(*, j: int): ...
 def f(i: int = 0, j: int = 0): ...
 
-reveal_type(f)  # N: Revealed type is "Overload(def (), def (i: Untyped), def (*, j: int))"
+reveal_type(f)  # N: Revealed type is "Overload(def () -> None, def (i: Untyped) -> None, def (*, j: int) -> None)"
 
 [case testOverloadOther]
 # flags: --allow-untyped-defs --allow-incomplete-defs --allow-any-expr
@@ -219,7 +219,7 @@ class A:
     def f(self, i, j: int): ...
     def f(self, i: int = 0, j: int = 0) -> object: ...
 
-reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A) -> int, def (self: __main__.A, i: Untyped), def (self: __main__.A, i: Untyped, j: int))"
+reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A) -> int, def (self: __main__.A, i: Untyped) -> None, def (self: __main__.A, i: Untyped, j: int) -> None)"
 
 class B:
     @overload
@@ -230,12 +230,12 @@ class B:
     def f(self, i, j: int) -> int: ...
     def f(self, i: int = 0, j: int = 0) -> object: ...
 
-reveal_type(B.f)  # N: Revealed type is "Overload(def (self: __main__.B) -> str, def (self: __main__.B, i: Untyped), def (self: __main__.B, i: Untyped, j: int) -> int)"
+reveal_type(B.f)  # N: Revealed type is "Overload(def (self: __main__.B) -> str, def (self: __main__.B, i: Untyped) -> None, def (self: __main__.B, i: Untyped, j: int) -> int)"
 
 
 [case testNewHasError]
 # flags: --no-infer-function-types
 class A:
     def __new__(cls): ...  # E: "__new__" must return a class instance (got "None")  [misc]
 
-reveal_type(A.__new__)  # N: Revealed type is "def (cls: type[__main__.A])"
+reveal_type(A.__new__)  # N: Revealed type is "def (cls: type[__main__.A]) -> None"

test-data/unit/check-based-default-return.test

@@ -2,7 +2,7 @@
 # flags: --config-file tmp/mypy.ini
 from b import foo
 foo(1, 2)  # E: Call to incomplete function "foo" in typed context  [no-untyped-call] \
-           # N: Type is "def (a: int, b: Untyped)"
+           # N: Type is "def (a: int, b: Untyped) -> None"
 
 [file b.py]
 def foo(a: int, b): ...

test-data/unit/check-based-incomplete-defs.test

@@ -20,8 +20,8 @@ class B1(A1):
 
 reveal_type(A1.__new__)  # N: Revealed type is "def (cls: type[__main__.A1]) -> Untyped"
 reveal_type(B1.__new__)  # N: Revealed type is "def (cls: type[__main__.B1]) -> Untyped"
-reveal_type(A1.__init__)  # N: Revealed type is "def (self: __main__.A1)"
-reveal_type(B1.__init__)  # N: Revealed type is "def (self: __main__.B1)"
+reveal_type(A1.__init__)  # N: Revealed type is "def (self: __main__.A1) -> None"
+reveal_type(B1.__init__)  # N: Revealed type is "def (self: __main__.B1) -> None"
 
 class A2:
     def __new__(cls, a: int): ...
@@ -32,8 +32,8 @@ class B2(A2):
 
 reveal_type(A2.__new__)  # N: Revealed type is "def (cls: type[__main__.A2], a: int) -> __main__.A2"
 reveal_type(B2.__new__)  # N: Revealed type is "def (cls: type[__main__.B2], a: int) -> __main__.B2"
-reveal_type(A2.__init__)  # N: Revealed type is "def (self: __main__.A2, a: int)"
-reveal_type(B2.__init__)  # N: Revealed type is "def (self: __main__.B2, a: int)"
+reveal_type(A2.__init__)  # N: Revealed type is "def (self: __main__.A2, a: int) -> None"
+reveal_type(B2.__init__)  # N: Revealed type is "def (self: __main__.B2, a: int) -> None"
 
 
 [case testInferFunctionTypesComplete-xfail]
@@ -46,8 +46,8 @@ class B1(A1):
 
 reveal_type(A1.__new__)  # N: Revealed type is "def (cls: type[__main__.A1]) -> __main__.A1"
 reveal_type(B1.__new__)  # N: Revealed type is "def (cls: type[__main__.B1]) -> __main__.B1"
-reveal_type(A1.__init__)  # N: Revealed type is "def (self: __main__.A1)"
-reveal_type(B1.__init__)  # N: Revealed type is "def (self: __main__.B1)"
+reveal_type(A1.__init__)  # N: Revealed type is "def (self: __main__.A1) -> None"
+reveal_type(B1.__init__)  # N: Revealed type is "def (self: __main__.B1) -> None"
 
 class A2:
     def __new__(cls, a: int): ...
@@ -58,21 +58,21 @@ class B2(A2):
 
 reveal_type(A2.__new__)  # N: Revealed type is "def (cls: type[__main__.A2], a: int) -> __main__.A2"
 reveal_type(B2.__new__)  # N: Revealed type is "def (cls: type[__main__.B2], a: int) -> __main__.B2"
-reveal_type(A2.__init__)  # N: Revealed type is "def (self: __main__.A2, a: int)"
-reveal_type(B2.__init__)  # N: Revealed type is "def (self: __main__.B2, a: int)"
+reveal_type(A2.__init__)  # N: Revealed type is "def (self: __main__.A2, a: int) -> None"
+reveal_type(B2.__init__)  # N: Revealed type is "def (self: __main__.B2, a: int) -> None"
 
 
 [case testDefaultInstance-xfail]
 class A: ...
 def f(a=A()): ...
-reveal_type(f)  # N: Revealed type is "def (a: __main__.A =)"
+reveal_type(f)  # N: Revealed type is "def (a: __main__.A =) -> None"
 
 class B:
     def foo(self, a: object): ...
 class C(B):
     def foo(self, a=A()): ...
 
-reveal_type(C.foo)  # N: Revealed type is "def (self: __main__.C, a: object =)"
+reveal_type(C.foo)  # N: Revealed type is "def (self: __main__.C, a: object =) -> None"
 
 
 [case testDontInferFunctionTypes]
@@ -105,7 +105,7 @@ class B2(A2):
 
 reveal_type(A2.__new__)  # N: Revealed type is "def (cls: type[__main__.A2], a: int) -> Untyped"
 reveal_type(B2.__new__)  # N: Revealed type is "def (cls: type[__main__.B2], a: Untyped) -> Untyped"
-reveal_type(A2.__init__)  # N: Revealed type is "def (self: __main__.A2, a: int)"
+reveal_type(A2.__init__)  # N: Revealed type is "def (self: __main__.A2, a: int) -> None"
 reveal_type(B2.__init__)  # N: Revealed type is "def (self: __main__.B2, a: Untyped) -> Untyped"
 
 
@@ -169,7 +169,7 @@ def foo(a='1') -> None:
 def foo(a="1") -> None:
     reveal_type(a)  # N: Revealed type is "int | str"
 
-reveal_type(foo)  # N: Revealed type is "Overload(def (a: int), def (a: str =))"
+reveal_type(foo)  # N: Revealed type is "Overload(def (a: int) -> None, def (a: str =) -> None)"
 
 
 [case testOverloadMixedPositionalKeyword]
@@ -338,7 +338,7 @@ reveal_type(A.f)  # N: Revealed type is "Overload(def (self: __main__.A, f: int)
 reveal_type(B.f)  # N: Revealed type is "Overload(def (self: __main__.B, f: int) -> str, def (self: __main__.B, f: str) -> int)"
 reveal_type(C.f)  # N: Revealed type is "Overload(def (self: __main__.C, f: int) -> str, def (self: __main__.C, f: str) -> int)"
 reveal_type(D.f)  # N: Revealed type is "Overload(def (self: __main__.D, f: int) -> str, def (self: __main__.D, f: str) -> int)"
-reveal_type(E.f)  # N: Revealed type is "def (self: __main__.E, f: str)"
+reveal_type(E.f)  # N: Revealed type is "def (self: __main__.E, f: str) -> None"
 reveal_type(F.f)  # N: Revealed type is "Overload(def (self: __main__.F, f: int) -> str, def (self: __main__.F, f: str) -> int)"
 reveal_type(G.f)  # N: Revealed type is "Overload(def (self: __main__.G, f: int) -> str, def (self: __main__.G, f: str) -> int)"
 
@@ -367,7 +367,7 @@ def bar(a=1) -> None:
     1 + ""  # E: Unsupported operand types for + ("int" and "str")  [operator]
 
 bar()
-reveal_type(bar)  # N: Revealed type is "def (a: int =)"
+reveal_type(bar)  # N: Revealed type is "def (a: int =) -> None"
 
 
 [case inferPropertyTypes]
@@ -467,4 +467,4 @@ def deco(func: T) -> T: ...
 @deco
 def b(b=True) -> None: ...
 
-reveal_type(b)  # N: Revealed type is "def (b: bool =)"
+reveal_type(b)  # N: Revealed type is "def (b: bool =) -> None"

test-data/unit/check-based-infer-function-types.test

@@ -1,8 +1,8 @@
 [case testGenericMethod]
 from typing import TypeVar, Generic, Union
 
-T = TypeVar('T')
-T2 = TypeVar('T2')
+T = TypeVar('T', bound=str)
+T2 = TypeVar('T2', bound=int)
 
 class A(Generic[T2]):
     def f(self, t: T, t2: T2) -> Union[T, T2]:
@@ -12,10 +12,10 @@ class A(Generic[T2]):
             t = t2  # E: Incompatible types in assignment (expression has type "T2@A", variable has type "T@f")  [assignment]
         return t
 
-reveal_type(A.f)  # N: Revealed type is "def [T2 (from A), T] (self: __main__.A[T2], t: T, t2: T2) -> T | T2"
-reveal_type(A[int]().f)  # N: Revealed type is "def [T] (t: T, t2: int) -> T | int"
+reveal_type(A.f)  # N: Revealed type is "def [T2 (from A): int, T: str] (self: __main__.A[T2], t: T, t2: T2) -> T | T2"
+reveal_type(A[int]().f)  # N: Revealed type is "def [T: str] (t: T, t2: int) -> T | int"
 A.f = 1  # E: Cannot assign to a method  [assignment] \
-         # E: Incompatible types in assignment (expression has type "int", variable has type "[T2 (from A), T] (A[T2], T, T2) -> T | T2")  [assignment]
+         # E: Incompatible types in assignment (expression has type "int", variable has type "[T2 (from A): int, T: str] (A[T2], T, T2) -> T | T2")  [assignment]
 
 
 [case testGenericFunction]
@@ -58,7 +58,7 @@ from typing import TypeVar
 T = TypeVar("T", bound=int)
 
 def foo(t: T): ...
-reveal_type(foo)  # N: Revealed type is "def [T: int] (t: T)"
+reveal_type(foo)  # N: Revealed type is "def [T: int] (t: T) -> None"
 
 
 [case testInferredNever]
@@ -73,3 +73,9 @@ def b() -> NoReturn: ...
 reveal_type(a)  # N: Revealed type is "Never"
 reveal_type(b)  # N: Revealed type is "def () -> Never"
 b = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "() -> Never")  [assignment]
+
+
+[case testRenderNoneReturn]
+def foo(): ...
+reveal_type(foo)  # N: Revealed type is "def () -> None"
+foo = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "() -> None")  [assignment]

test-data/unit/check-based-type-render.test

@@ -47,9 +47,9 @@ def f1(a: List): ...
 def f2(a: List[Untyped]): ...
 a = [1]
 f1(a)  # E: Call to incomplete function "f1" in typed context  [no-untyped-call] \
-       # N: Type is "def (a: list[Untyped])"
+       # N: Type is "def (a: list[Untyped]) -> None"
 f2(a)  # E: Call to incomplete function "f2" in typed context  [no-untyped-call] \
-       # N: Type is "def (a: list[Untyped])"
+       # N: Type is "def (a: list[Untyped]) -> None"
 
 
 [case testIncompleteCall]