update check_for_missing_annotations to give note for None return type, give missing arg names in err msg

Author: Charulata Lodha

mypy/checker.py

@@ -1633,32 +1633,65 @@ def is_reverse_op_method(self, method_name: str) -> bool:
 
     def check_for_missing_annotations(self, fdef: FuncItem) -> None:
         # Check for functions with unspecified/not fully specified types.
-        def is_unannotated_any(t: Type) -> bool:
+        def is_unannotated_any(t: Type | None) -> bool:
             if not isinstance(t, ProperType):
                 return False
             return isinstance(t, AnyType) and t.type_of_any == TypeOfAny.unannotated
 
+        unannotated_args = [
+            a.variable.name
+            for a in fdef.arguments
+            if not (a.variable.is_cls or a.variable.is_self)
+            and is_unannotated_any(a.variable.type)
+        ]
+
         has_explicit_annotation = isinstance(fdef.type, CallableType) and any(
-            not is_unannotated_any(t) for t in fdef.type.arg_types + [fdef.type.ret_type]
+            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
-        if show_untyped and (self.options.disallow_untyped_defs or check_incomplete_defs):
-            if fdef.type is None and self.options.disallow_untyped_defs:
-                if not fdef.arguments or (
-                    len(fdef.arguments) == 1
-                    and (fdef.arg_names[0] == "self" or fdef.arg_names[0] == "cls")
-                ):
-                    self.fail(message_registry.RETURN_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',
+
+        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 unannotated_args:
+                    if len(unannotated_args) < 5:
+                        self.fail(
+                            message_registry.ARGUMENT_TYPE_EXPECTED.format(
+                                ", ".join(f'"{arg}"' for arg in unannotated_args)
+                            ),
                             fdef,
-                            code=codes.NO_UNTYPED_DEF,
                         )
-                else:
-                    self.fail(message_registry.FUNCTION_TYPE_EXPECTED, fdef)
+                    else:
+                        self.fail(
+                            message_registry.ARGUMENT_TYPE_EXPECTED.format(
+                                str(", ".join(f'"{arg}"' for arg in unannotated_args[:5]) + "...")
+                            ),
+                            fdef,
+                        )
+
+        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,
+                    )
             elif isinstance(fdef.type, CallableType):
                 ret_type = get_proper_type(fdef.type.ret_type)
                 if is_unannotated_any(ret_type):
@@ -1671,8 +1704,13 @@ def is_unannotated_any(t: Type) -> bool:
                 elif fdef.is_coroutine and isinstance(ret_type, Instance):
                     if is_unannotated_any(self.get_coroutine_return_type(ret_type)):
                         self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
-                if any(is_unannotated_any(t) for t in fdef.type.arg_types):
-                    self.fail(message_registry.ARGUMENT_TYPE_EXPECTED, fdef)
+
+        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
+            ):
+                handle_return_type_annotation()
+                handle_function_args_type_annotation()
 
     def check___new___signature(self, fdef: FuncDef, typ: CallableType) -> None:
         self_type = fill_typevars_with_any(fdef.info)
@@ -2079,8 +2117,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] = []
@@ -4254,7 +4291,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()
@@ -6787,7 +6825,6 @@ def refine_away_none_in_comparison(
         if_map, else_map = {}, {}
 
         if not non_optional_types or (len(non_optional_types) != len(chain_indices)):
-
             # Narrow e.g. `Optional[A] == "x"` or `Optional[A] is "x"` to `A` (which may be
             # convenient but is strictly not type-safe):
             for i in narrowable_operand_indices:

mypy/message_registry.py

@@ -126,7 +126,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
     "Function is missing a return type annotation", codes.NO_UNTYPED_DEF
 )
 ARGUMENT_TYPE_EXPECTED: Final = ErrorMessage(
-    "Function is missing a type annotation for one or more arguments", codes.NO_UNTYPED_DEF
+    "Function is missing a type annotation for one or more arguments: {}", code=codes.ASSIGNMENT
 )
 KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE: Final = ErrorMessage(
     'Keyword argument only valid with "str" key type in call to "dict"'

test-data/unit/check-flags.test

@@ -2,19 +2,39 @@
 # 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
 
-[case testUnannotatedArgument]
+[case testUnannotatedArgumentSingle]
+# flags: --disallow-untyped-defs
+def f(x) -> int: return 1
+[out]
+main:2: error: Function is missing a type annotation for one or more arguments: "x"
+
+[case testUnannotatedArgumentLessThan5]
+# flags: --disallow-untyped-defs
+def f(x, y, z, a:int, b) -> int: return 1
+[out]
+main:2: error: Function is missing a type annotation for one or more arguments: "x", "y", "z", "b"
+
+[case testUnannotatedArgument5orMore]
 # flags: --disallow-untyped-defs
-def f(x) -> int: pass
+def f(x, y, z, a:int, b, c, d, e, f:int) -> int: return 1
 [out]
-main:2: error: Function is missing a type annotation for one or more arguments
+main:2: error: Function is missing a type annotation for one or more arguments: "x", "y", "z", "b", "c"...
 
-[case testNoArgumentFunction]
+[case testNoArgumentValidReturnType]
 # flags: --disallow-untyped-defs
-def f() -> int: pass
+def f() -> int: return 1
 [out]
 
+[case testNoArgumentMissingReturnTypeFunction]
+# flags: --disallow-untyped-defs
+def f(): return 5
+[out]
+main:2: error: Function is missing a return type annotation
+
 [case testUnannotatedReturn]
 # flags: --disallow-untyped-defs
 def f(x: int): pass
@@ -46,6 +66,7 @@ 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
 
 [case testUnannotatedReturnWithNontrivialReturn]
 # flags: --disallow-untyped-defs
@@ -63,7 +84,7 @@ async def f():  # E: Function is missing a return type annotation \
 
 [case testAsyncUnannotatedArgument]
 # flags: --disallow-untyped-defs
-async def f(x) -> None:  # E: Function is missing a type annotation for one or more arguments
+async def f(x) -> None:  # E: Function is missing a type annotation for one or more arguments: "x"
     pass
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
@@ -85,6 +106,7 @@ 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]
 # flags: --disallow-untyped-decorators
@@ -659,7 +681,7 @@ import standard, incomplete
 def incomplete(x) -> int:
     return 0
 [file incomplete.py]
-def incomplete(x) -> int:  # E: Function is missing a type annotation for one or more arguments
+def incomplete(x) -> int:  # E: Function is missing a type annotation for one or more arguments: "x"
     return 0
 [file mypy.ini]
 \[mypy]
@@ -676,7 +698,7 @@ import standard, incomplete
 def incomplete(x) -> int:
     return 0
 [file incomplete.py]
-def incomplete(x) -> int:  # E: Function is missing a type annotation for one or more arguments
+def incomplete(x) -> int:  # E: Function is missing a type annotation for one or more arguments: "x"
     return 0
 [file pyproject.toml]
 \[tool.mypy]
@@ -1351,7 +1373,7 @@ def g(m: Movie) -> Movie:
 
 def f(i: int):  # E: Function is missing a return type annotation
     pass
-def g(i) -> None:  # E: Function is missing a type annotation for one or more arguments
+def g(i) -> None:  # E: Function is missing a type annotation for one or more arguments: "i"
     pass
 def h(i: int) -> int:  # no error
     return i
@@ -1378,7 +1400,7 @@ def f(i: int, s):
 
 [out]
 main:3: error: Function is missing a return type annotation
-main:3: error: Function is missing a type annotation for one or more arguments
+main:3: error: Function is missing a type annotation for one or more arguments: "s"
 
 [case testDisallowIncompleteDefsAttrsNoAnnotations]
 # flags: --disallow-incomplete-defs
@@ -1405,7 +1427,7 @@ class Annotated:
 import attrs
 
 @attrs.define
-class PartiallyAnnotated:  # E: Function is missing a type annotation for one or more arguments
+class PartiallyAnnotated:  # E: Function is missing a type annotation for one or more arguments: "baz"
     bar: int = attrs.field()
     baz = attrs.field()
 
@@ -2301,13 +2323,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 type annotation
+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 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 type annotation
+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 g(a: int) -> int: return f(a)  # E: Call to untyped function "f" in typed context
 [file mypy.ini]
 \[mypy]