Improve handling of "lambda: None"

"lambda: None" might be used either where a function returning an
Optional[T] is expected, or where a function not returning a value is
expected. Previously it would always treated as the former; now the
context is used to decide.

When no context is available, the lambda is now treated as a function
not returning a value. This seems more consistent with the fact that
you can't define a variable 'a = None' without a type annotation or
declare a function to return NoneTyp. (If really desperate for the
other meaning of "lambda: None", you can write a generic function.)

Fixes python#1425.

Author: rwbarton

mypy/checkexpr.py

@@ -1262,6 +1262,9 @@ def visit_func_expr(self, e: FuncExpr) -> Type:
         if not inferred_type:
             # No useful type context.
             ret_type = e.expr().accept(self.chk)
+            if isinstance(ret_type, NoneTyp):
+                # Refuse to infer NoneTyp as return type. Use Void instead.
+                ret_type = Void()
             if not e.arguments:
                 # Form 'lambda: e'; just use the inferred return type.
                 return CallableType([], [], [], ret_type, self.named_type('builtins.function'))
@@ -1276,6 +1279,11 @@ def visit_func_expr(self, e: FuncExpr) -> Type:
             if e.expr() not in self.chk.type_map:
                 self.accept(e.expr())
             ret_type = self.chk.type_map[e.expr()]
+            if isinstance(ret_type, NoneTyp):
+                # For "lambda ...: None", just use type from the context.
+                # Important when the context is Callable[..., None] which
+                # really means Void. See #1425.
+                return inferred_type
             return replace_callable_return_type(inferred_type, ret_type)
 
     def infer_lambda_type_using_context(self, e: FuncExpr) -> CallableType:

mypy/test/data/check-inference-context.test

@@ -611,6 +611,13 @@ T = TypeVar('T')
 def foo(arg: Callable[..., T]) -> None: pass
 foo(lambda: 1)
 
+[case testLambdaNoneInContext]
+from typing import Callable
+def f(x: Callable[[], None]) -> None: pass
+def g(x: Callable[[], int]) -> None: pass
+f(lambda: None)
+g(lambda: None)
+
 
 -- Overloads + generic functions
 -- -----------------------------

mypy/test/data/check-inference.test

@@ -1026,6 +1026,14 @@ class A: pass
 class B: pass
 [builtins fixtures/list.py]
 
+[case testInferLambdaNone]
+from typing import Callable
+def f(x: Callable[[], None]) -> None: pass
+def g(x: Callable[[], int]) -> None: pass
+a = lambda: None
+f(a)
+g(a) # E: Argument 1 to "g" has incompatible type Callable[[], None]; expected Callable[[], int]
+
 
 -- Boolean operators
 -- -----------------