update FUNCTION_TYPE_EXPECTED err handling, update tests

Author: Charulata Lodha

mypy/checker.py

@@ -1649,21 +1649,8 @@ def is_unannotated_any(t: Type | None) -> bool:
             unannotated_args + [fdef.type.ret_type]
         )
 
-        show_untyped = not self.is_typeshed_stub or self.options.warn_incomplete_stub
-        check_incomplete_defs = self.options.disallow_incomplete_defs and has_explicit_annotation
-
         def handle_function_args_type_annotation() -> None:
-            if fdef.type is None:
-                if fdef.arguments:
-                    if len(fdef.arguments) == 1 and (
-                        fdef.arguments[0].variable.is_cls or fdef.arguments[0].variable.is_self
-                    ):
-                        # its not an error
-                        pass
-                    else:
-                        self.fail(message_registry.FUNCTION_TYPE_EXPECTED, fdef)
-
-            elif isinstance(fdef.type, CallableType):
+            if isinstance(fdef.type, CallableType):
                 if unannotated_args:
                     if len(unannotated_args) < 5:
                         self.fail(
@@ -1681,17 +1668,8 @@ def handle_function_args_type_annotation() -> None:
                         )
 
         def handle_return_type_annotation() -> None:
-            if fdef.type is None:
-                has_return = has_return_statement(fdef)
-                if has_return:
-                    self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
-                if not has_return and not fdef.is_generator:
-                    self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
-                    self.note(
-                        'Use "-> None" if function does not return a value',
-                        fdef,
-                        code=codes.NO_UNTYPED_DEF,
-                    )
+            if fdef.type is None and self.options.disallow_untyped_defs:
+                self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
             elif isinstance(fdef.type, CallableType):
                 ret_type = get_proper_type(fdef.type.ret_type)
                 if is_unannotated_any(ret_type):
@@ -1705,10 +1683,21 @@ def handle_return_type_annotation() -> None:
                     if is_unannotated_any(self.get_coroutine_return_type(ret_type)):
                         self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
 
+        show_untyped = not self.is_typeshed_stub or self.options.warn_incomplete_stub
+        check_incomplete_defs = self.options.disallow_incomplete_defs and has_explicit_annotation
+
         if show_untyped and (self.options.disallow_untyped_defs or check_incomplete_defs):
-            if (isinstance(fdef.type, CallableType) and check_incomplete_defs) or (
-                self.options.disallow_untyped_defs
-            ):
+            if fdef.type is None:
+                if not has_explicit_annotation and self.options.disallow_untyped_defs:
+                    self.fail(message_registry.FUNCTION_TYPE_EXPECTED, fdef)
+                    if not has_return_statement(fdef) and not fdef.is_generator:
+                        self.note(
+                            'Use "-> None" if function does not return a value',
+                            fdef,
+                            code=codes.NO_UNTYPED_DEF,
+                        )
+
+            elif isinstance(fdef.type, CallableType):
                 handle_return_type_annotation()
                 handle_function_args_type_annotation()
 
@@ -2117,8 +2106,7 @@ def check_method_override(
             and (self.options.check_untyped_defs or not defn.is_dynamic())
             and (
                 # don't check override for synthesized __replace__ methods from dataclasses
-                defn.name != "__replace__"
-                or defn.info.metadata.get("dataclass_tag") is None
+                defn.name != "__replace__" or defn.info.metadata.get("dataclass_tag") is None
             )
         )
         found_method_base_classes: list[TypeInfo] = []
@@ -4292,7 +4280,8 @@ def check_lvalue(
             self.store_type(lvalue, lvalue_type)
         elif isinstance(lvalue, (TupleExpr, ListExpr)):
             types = [
-                self.check_lvalue(sub_expr)[0] or
+                self.check_lvalue(sub_expr)[0]
+                or
                 # This type will be used as a context for further inference of rvalue,
                 # we put Uninhabited if there is no information available from lvalue.
                 UninhabitedType()

test-data/unit/check-async-await.test

@@ -705,7 +705,7 @@ async def f() -> AsyncGenerator[Any, Any]:
 async def h() -> Any:
     yield 0
 
-async def g():  # E: Function is missing a return type annotation
+async def g():  # E: Function is missing a type annotation
     yield 0
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]

test-data/unit/check-columns.test

@@ -175,7 +175,7 @@ if int():
     def f(x: int): # E:5: Function is missing a return type annotation
         pass
 
-    def g(x): # E:5: Function is missing a type annotation
+    def g(x): # E:5: Function is missing a type annotation # N:5: Use "-> None" if function does not return a value
         pass
 
 [case testColumnNameIsNotDefined]

test-data/unit/check-errorcodes.test

@@ -362,26 +362,27 @@ a.x  # E: Item "B" of "Union[A, B]" has no attribute "x"  [union-attr]
 [case testErrorCodeFunctionHasNoAnnotation]
 # flags: --disallow-untyped-defs
 
-def f(x):  # E: Function is missing a type annotation  [no-untyped-def]
+def f(x):  # E: Function is missing a type annotation  [no-untyped-def] # N: Use "-> None" if function does not return a value
     pass
 
 def g(x: int):  # E: Function is missing a return type annotation  [no-untyped-def]
     pass
 
-def h(x) -> None:  # E: Function is missing a type annotation for one or more arguments  [no-untyped-def]
+def h(x) -> None:  # E: Function is missing a type annotation for one or more arguments: "x"  [no-untyped-def]
     pass
 
-def gen():  # E: Function is missing a return type annotation  [no-untyped-def]
+def gen():  # E: Function is missing a type annotation  [no-untyped-def]
     yield 1
 
 def gen2(x: int):  # E: Function is missing a return type annotation  [no-untyped-def]
     yield 1
 
-async def asyncf():  # E: Function is missing a return type annotation  [no-untyped-def]
+async def asyncf():  # E: Function is missing a type annotation  [no-untyped-def]
     return 0
 
 async def asyncf2(x: int):  # E: Function is missing a return type annotation  [no-untyped-def]
     return 0
+
 [typing fixtures/typing-async.pyi]
 [builtins fixtures/tuple.pyi]
 

test-data/unit/check-flags.test

@@ -2,9 +2,8 @@
 # flags: --disallow-untyped-defs
 def f(x): pass
 [out]
-main:2: error: Function is missing a return type annotation
-main:2: note: Use "-> None" if function does not return a value
 main:2: error: Function is missing a type annotation
+main:2: note: Use "-> None" if function does not return a value
 
 [case testUnannotatedArgumentSingle]
 # flags: --disallow-untyped-defs
@@ -33,7 +32,7 @@ def f() -> int: return 1
 # flags: --disallow-untyped-defs
 def f(): return 5
 [out]
-main:2: error: Function is missing a return type annotation
+main:2: error: Function is missing a type annotation
 
 [case testUnannotatedReturn]
 # flags: --disallow-untyped-defs
@@ -57,27 +56,25 @@ lambda x: x
 def f():
     1 + "str"
 [out]
-main:2: error: Function is missing a return type annotation
+main:2: error: Function is missing a type annotation
 main:2: note: Use "-> None" if function does not return a value
 
 [case testUnannotatedReturnWithOnlySelfArgument]
 # flags: --disallow-untyped-defs
 def f(self): pass
 [out]
-main:2: error: Function is missing a return type annotation
-main:2: note: Use "-> None" if function does not return a value
 main:2: error: Function is missing a type annotation
+main:2: note: Use "-> None" if function does not return a value
 
 [case testUnannotatedReturnWithNontrivialReturn]
 # flags: --disallow-untyped-defs
 def f(): return 1
 [out]
-main:2: error: Function is missing a return type annotation
+main:2: error: Function is missing a type annotation
 
 [case testUntypedAsyncDef]
 # flags: --disallow-untyped-defs
-async def f():  # E: Function is missing a return type annotation \
-                # N: Use "-> None" if function does not return a value
+async def f():  # E: Function is missing a type annotation # N: Use "-> None" if function does not return a value
     pass
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-medium.pyi]
@@ -105,7 +102,6 @@ async def g(x: int) -> Any:
 def get_tasks(self):
     return 'whatever'
 [out]
-main:2: error: Function is missing a return type annotation
 main:2: error: Function is missing a type annotation
 
 [case testDisallowUntypedDefsUntypedDecorator]
@@ -2323,13 +2319,13 @@ ignore_errors = True
 # flags: --config-file tmp/mypy.ini
 import x, y, z
 [file x.py]
-def f(a): ...  # E: Function is missing a return type annotation # N: Use "-> None" if function does not return a value # E: Function is missing a type annotation
+def f(a): ...  # E: Function is missing a type annotation # N: Use "-> None" if function does not return a value
 def g(a: int) -> int: return f(a)
 [file y.py]
 def f(a): pass
 def g(a: int) -> int: return f(a)
 [file z.py]
-def f(a): pass  # E: Function is missing a return type annotation # N: Use "-> None" if function does not return a value # E: Function is missing a type annotation
+def f(a): pass  # E: Function is missing a type annotation # N: Use "-> None" if function does not return a value
 def g(a: int) -> int: return f(a)  # E: Call to untyped function "f" in typed context
 [file mypy.ini]
 \[mypy]

test-data/unit/check-ignore.test

@@ -261,7 +261,7 @@ ERROR # E: Name "ERROR" is not defined
 [case testIgnoreInsideFunctionDoesntAffectWhole]
 # flags: --disallow-untyped-defs
 
-def f():  # E: Function is missing a return type annotation
+def f():  # E: Function is missing a type annotation
     42 + 'no way'  # type: ignore
     return 0
 

test-data/unit/check-python38.test

@@ -10,7 +10,7 @@ class C: ...  # E: Name "C" already defined on line 4
 def d(f): ...  # type: ignore
 @d
 
-def f(): ...  # E: Function is missing a return type annotation \
+def f(): ...  # E: Function is missing a type annotation \
               # N: Use "-> None" if function does not return a value
 
 [case testIgnoreDecoratedFunction1]
@@ -116,7 +116,7 @@ def g(x: int): ...
 
 [case testPEP570ArgTypesMissing]
 # flags: --disallow-untyped-defs
-def f(arg, /) -> None: ...  # E: Function is missing a type annotation for one or more arguments
+def f(arg, /) -> None: ...  # E: Function is missing a type annotation for one or more arguments: "arg"
 
 [case testPEP570ArgTypesBadDefault]
 def f(arg: int = "ERROR", /) -> None: ...  # E: Incompatible default for argument "arg" (default has type "str", argument has type "int")

test-data/unit/cmdline.test

@@ -203,7 +203,9 @@ def f(a): pass
 def f(a): pass
 [out]
 z.py:1: error: Function is missing a type annotation
+z.py:1: note: Use "-> None" if function does not return a value
 x.py:1: error: Function is missing a type annotation
+x.py:1: note: Use "-> None" if function does not return a value
 
 [case testConfigErrorNoSection]
 # cmd: mypy -c pass

test-data/unit/daemon.test

@@ -65,17 +65,17 @@ files = ./foo.py
 [case testDaemonRunMultipleStrict]
 $ dmypy run -- foo.py --strict --follow-imports=error
 Daemon started
-foo.py:1: error: Function is missing a return type annotation
+foo.py:1: error: Function is missing a type annotation
 foo.py:1: note: Use "-> None" if function does not return a value
 Found 1 error in 1 file (checked 1 source file)
 == Return code: 1
 $ dmypy run -- bar.py --strict --follow-imports=error
-bar.py:1: error: Function is missing a return type annotation
+bar.py:1: error: Function is missing a type annotation
 bar.py:1: note: Use "-> None" if function does not return a value
 Found 1 error in 1 file (checked 1 source file)
 == Return code: 1
 $ dmypy run -- foo.py --strict --follow-imports=error
-foo.py:1: error: Function is missing a return type annotation
+foo.py:1: error: Function is missing a type annotation
 foo.py:1: note: Use "-> None" if function does not return a value
 Found 1 error in 1 file (checked 1 source file)
 == Return code: 1
@@ -96,7 +96,7 @@ $ dmypy run -- foo.py --follow-imports=error
 Restarting: configuration changed
 Daemon stopped
 Daemon started
-foo.py:1: error: Function is missing a return type annotation
+foo.py:1: error: Function is missing a type annotation
 foo.py:1: note: Use "-> None" if function does not return a value
 Found 1 error in 1 file (checked 1 source file)
 == Return code: 1
@@ -120,7 +120,7 @@ $ dmypy run -- foo.py --follow-imports=error --pretty
 Restarting: configuration changed
 Daemon stopped
 Daemon started
-foo.py:1: error: Function is missing a return type annotation
+foo.py:1: error: Function is missing a type annotation
     def f():
     ^
 foo.py:1: note: Use "-> None" if function does not return a value

test-data/unit/fine-grained.test

@@ -10485,13 +10485,13 @@ def f(): pass
 def f(): pass
 [file unrelated.txt.3]
 [out]
-a.py:1: error: Function is missing a return type annotation
+a.py:1: error: Function is missing a type annotation
 a.py:1: note: Use "-> None" if function does not return a value
 ==
-b.py:1: error: Function is missing a return type annotation
+b.py:1: error: Function is missing a type annotation
 b.py:1: note: Use "-> None" if function does not return a value
 ==
-a.py:1: error: Function is missing a return type annotation
+a.py:1: error: Function is missing a type annotation
 a.py:1: note: Use "-> None" if function does not return a value
 
 [case testModuleLevelGetAttrInStub]