Allow assignments to function definitions

This also fixes certain bogus errors about conditional
imports/definitions of functions.

Author: JukkaL

mypy/semanal.py

@@ -1112,7 +1112,7 @@ def is_self_member_ref(self, memberexpr: MemberExpr) -> bool:
         return isinstance(node, Var) and (cast(Var, node)).is_self
 
     def check_lvalue_validity(self, node: Node, ctx: Context) -> None:
-        if isinstance(node, (FuncDef, TypeInfo, TypeVarExpr)):
+        if isinstance(node, (TypeInfo, TypeVarExpr)):
             self.fail('Invalid assignment target', ctx)
 
     def store_declared_types(self, lvalue: Node, typ: Type) -> None:

mypy/test/data/check-functions.test

@@ -1174,3 +1174,15 @@ class A(Generic[t]):
     def foo(self, x: t) -> None:
         return None
 [builtins fixtures/bool.py]
+
+
+-- Redefining functions
+-- --------------------
+
+
+[case testRedefineFunction]
+def f(x): pass
+def g(x, y): pass
+def h(y): pass
+f = h
+f = g # E: Incompatible types in assignment (expression has type Callable[[Any, Any], Any], variable has type Callable[[Any], Any])

mypy/test/data/check-modules.test

@@ -144,7 +144,6 @@ _m.f("hola")
 def f(c:str) -> None: pass
 [out]
 
-
 [case testImportWithStubIncompatibleType]
 import _m
 _m.f("hola")
@@ -472,8 +471,9 @@ x = 1
 [out]
 
 
--- Conditional definitions
--- -----------------------
+-- Conditional definitions and function redefinitions via module object
+-- --------------------------------------------------------------------
+
 
 [case testConditionalImportAndAssign]
 try:
@@ -543,6 +543,68 @@ except:
 def f(x): pass
 def g(x, y): pass
 
+[case testImportVariableAndAssignNone]
+try:
+    from m import x
+except:
+    x = None
+[file m.py]
+x = 1
+
+[case testImportFunctionAndAssignNone]
+try:
+    from m import f
+except:
+    f = None
+[file m.py]
+def f(): pass
+
+[case testImportFunctionAndAssignFunction]
+def g(x): pass
+try:
+    from m import f
+except:
+    f = g
+[file m.py]
+def f(y): pass
+
+[case testImportFunctionAndAssignIncompatible]
+try:
+    from m import f
+except:
+    f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+[file m.py]
+def f(): pass
+
+[case testAssignToFuncDefViaGlobalDecl2]
+import typing
+from m import f
+def g() -> None:
+    global f
+    f = None
+    f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+[file m.py]
+def f(): pass
+[out]
+main: note: In function "g":
+
+[case testAssignToFuncDefViaNestedModules]
+import m.n
+m.n.f = None
+m.n.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+[file m/__init__.py]
+[file m/n.py]
+def f(): pass
+[out]
+
+[case testAssignToFuncDefViaModule]
+import m
+m.f = None
+m.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+[file m.py]
+def f(): pass
+[out]
+
 
 -- Test cases that simulate 'mypy -m modname'
 --

mypy/test/data/semanal-errors.test

@@ -786,44 +786,6 @@ class D(str): pass # ok
 class A(A): pass # E: Cycle in inheritance hierarchy
 [out]
 
-[case testAssignToFuncDef]
-def f(): pass
-f = None # E: Invalid assignment target
-[out]
-
-[case testAssignToFuncDefViaModule]
-import m
-m.f = None # E: Invalid assignment target
-[file m.py]
-def f(): pass
-[out]
-
-[case testAssignToFuncDefViaNestedModules]
-import m.n
-m.n.f = None # E: Invalid assignment target
-[file m/__init__.py]
-[file m/n.py]
-def f(): pass
-[out]
-
-[case testAssignToFuncDefViaImport]
-from m import f
-f = None # E: Invalid assignment target
-[file m.py]
-def f(): pass
-[out]
-
-[case testAssignToFuncDefViaGlobalDecl2]
-import typing
-from m import f
-def g() -> None:
-    global f
-    f = None # E: Invalid assignment target
-[file m.py]
-def f(): pass
-[out]
-main: note: In function "g":
-
 [case testAssignToTypeDef]
 import typing
 class A: pass