Make untyped decorator its own code (#19911)

Since this apparently comes up a lot, it shouldn't just be misc (it is,
however, a subcode of misc, at least at the moment, for extra backwards
compatibility).

Fixes #19148

I didn't add any tests for this and it seems like our old tests don't
have codes enabled because they didn't have to be changed. I did add
documentation for this, as required by the relevant test.

---------

Co-authored-by: A5rocks <[email protected]>

Author: wyattscarpenter

docs/source/error_code_list2.rst

@@ -676,3 +676,26 @@ Example:
                 print("red")
             case _:
                 print("other")
+
+.. _code-untyped-decorator:
+
+Error if an untyped decorator makes a typed function effectively untyped [untyped-decorator]
+--------------------------------------------------------------------------------------------
+
+If enabled with :option:`--disallow-untyped-decorators <mypy --disallow-untyped-decorators>`
+mypy generates an error if a typed function is wrapped by an untyped decorator
+(as this would effectively remove the benefits of typing the function).
+
+Example:
+
+.. code-block:: python
+
+        def printing_decorator(func):
+            def wrapper(*args, **kwds):
+                print("Calling", func)
+                return func(*args, **kwds)
+            return wrapper
+        # A decorated function.
+        @printing_decorator  # E: Untyped decorator makes function "add_forty_two" untyped  [untyped-decorator]
+        def add_forty_two(value: int) -> int:
+            return value + 42

mypy/errorcodes.py

@@ -302,6 +302,10 @@ def __hash__(self) -> int:
     sub_code_of=MISC,
 )
 
+UNTYPED_DECORATOR: Final = ErrorCode(
+    "untyped-decorator", "Error if an untyped decorator makes a typed function untyped", "General"
+)
+
 NARROWED_TYPE_NOT_SUBTYPE: Final = ErrorCode(
     "narrowed-type-not-subtype",
     "Warn if a TypeIs function's narrowed type is not a subtype of the original type",

mypy/messages.py

@@ -2008,7 +2008,11 @@ def untyped_decorated_function(self, typ: Type, context: Context) -> None:
             )
 
     def typed_function_untyped_decorator(self, func_name: str, context: Context) -> None:
-        self.fail(f'Untyped decorator makes function "{func_name}" untyped', context)
+        self.fail(
+            f'Untyped decorator makes function "{func_name}" untyped',
+            context,
+            code=codes.UNTYPED_DECORATOR,
+        )
 
     def bad_proto_variance(
         self, actual: int, tvar_name: str, expected: int, context: Context

test-data/unit/check-errorcodes.test

@@ -394,6 +394,21 @@ def f() -> None:
 def g():
     pass
 
+[case testErrorCodeUntypedDecorator]
+# flags: --disallow-untyped-decorators --warn-unused-ignores
+def d(f): return f
+
+@d  # E: Untyped decorator makes function "x" untyped  [untyped-decorator]
+def x() -> int: return 1
+@d  # type: ignore
+def y() -> int: return 2
+@d  # type: ignore[untyped-decorator]
+def best() -> int: return 3
+@d  # type: ignore[misc]  # E: Unused "type: ignore" comment  [unused-ignore] \
+                          # E: Untyped decorator makes function "z" untyped  [untyped-decorator] \
+                          # N: Error code "untyped-decorator" not covered by "type: ignore" comment
+def z() -> int: return 4
+
 [case testErrorCodeIndexing]
 from typing import Dict
 x: Dict[int, int]