Warn for missing returns with explicit Any return types

As discussed in python#7511, mypy's
`--warn-no-return` isn't really a question of type safety. It does
however enforce a rule that is "dear to Guido's heart", and I think we
should enforce it for functions that explicitly return Any as well.

Fixes python#16095

mypy/checker.py

@@ -1336,7 +1336,11 @@ def check_func_def(
                 if self.options.warn_no_return:
                     if (
                         not self.current_node_deferred
-                        and not isinstance(return_type, (NoneType, AnyType))
+                        and not isinstance(return_type, NoneType)
+                        and (
+                            not isinstance(return_type, AnyType)
+                            or return_type.type_of_any == TypeOfAny.explicit
+                        )
                         and show_error
                     ):
                         # Control flow fell off the end of a function that was

test-data/unit/check-overloading.test

@@ -187,6 +187,7 @@ def f(x: Any) -> Any:
     foo = 1
     if int():
         foo = "bar"  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    return foo
 
 @overload
 def g(x: 'A') -> 'B': ...
@@ -4906,13 +4907,15 @@ def f() -> None:
     def g(x: T) -> Dict[int, T]: ...
     def g(*args, **kwargs) -> Any:
         reveal_type(h(C()))  # N: Revealed type is "builtins.dict[builtins.str, __main__.C]"
+        return args
 
     @overload
     def h() -> None: ...
     @overload
     def h(x: T) -> Dict[str, T]: ...
     def h(*args, **kwargs) -> Any:
         reveal_type(g(C()))  # N: Revealed type is "builtins.dict[builtins.int, __main__.C]"
+        return args
 
 [builtins fixtures/dict.pyi]
 [out]

test-data/unit/check-warnings.test

@@ -140,6 +140,24 @@ def f() -> int:
     pass
 [out]
 
+[case testNoReturnExplicitAny]
+# flags: --warn-no-return
+from typing import Any
+from unknown import Mystery  # type: ignore[import]
+
+def maybe() -> bool: ...
+
+def implicit(x: Any):
+    if maybe():
+        return x
+
+def explicit(x: Any) -> Any:  # E: Missing return statement
+    if maybe():
+        return x
+
+def mystery(x: Any) -> Mystery:
+    if maybe():
+        return x
 
 -- Returning Any
 -- -------------

test-data/unit/deps.test

@@ -917,6 +917,7 @@ def f(x: str) -> submod.B: pass
 def f(x) -> Any:
     y: submod.C
     y.x
+    return y
 [file submod.py]
 class A: pass
 class B: pass
@@ -959,6 +960,7 @@ def f(x: int) -> None: pass
 def f(x: str) -> str: pass
 def f(x: Any) -> Any:
     mod.g()
+    return mod
 [file mod.py]
 def g() -> int:
     pass
@@ -976,6 +978,7 @@ def outer() -> None:
     def f(x: str) -> mod.B: pass
     def f(x: Any) -> Any:
         mod.g()
+        return mod
 [file mod.py]
 def g() -> int:
     pass
@@ -997,6 +1000,7 @@ def outer() -> None:
     def f(x: str) -> str: pass
     def f(x: Any) -> Any:
         mod.g(str())
+        return mod
 [file mod.py]
 from typing import overload
 @overload
@@ -1018,7 +1022,7 @@ class Outer:
     @overload
     def f(self, x: str, cb=mod.g) -> str: pass
     def f(self, *args: Any, **kwargs: Any) -> Any:
-        pass
+        return args
 [file mod.py]
 from typing import overload
 @overload

test-data/unit/fine-grained.test

@@ -6995,6 +6995,7 @@ def outer() -> None:
     def f(x: str) -> str: pass
     def f(x: Any) -> Any:
         y: int = mod.f()
+        return y
 [file mod.py]
 def f() -> int:
     pass
@@ -7257,6 +7258,7 @@ def f(x: str) -> submod.B: pass
 def f(x) -> Any:
     y: submod.C
     y.x = int()
+    return y
 [file submod.py]
 import other
 class A: pass