Add an option to require ignore comments have error codes

Fixes #11509

Author: PeterJCLaw

docs/source/command_line.rst

@@ -680,6 +680,15 @@ in error messages.
 
     See :ref:`error-codes` for more information.
 
+.. option:: --disallow-ignore-without-code
+
+    This flag will disallow ``type: ignore`` comments which do not have
+    error codes::
+
+        prog.py:1: error: "type: ignore" comment without error code
+
+    See :ref:`error-codes` for more information.
+
 .. option:: --pretty
 
     Use visually nicer output in error messages: use soft word wrap,

mypy/build.py

@@ -2369,6 +2369,13 @@ def generate_unused_ignore_notes(self) -> None:
                 self.verify_dependencies(suppressed_only=True)
             self.manager.errors.generate_unused_ignore_errors(self.xpath)
 
+    def generate_ignore_without_code_notes(self) -> None:
+        if self.options.disallow_ignore_without_code:
+            self.manager.errors.generate_ignore_without_code_errors(
+                self.xpath,
+                self.options.warn_unused_ignores,
+            )
+
 
 # Module import and diagnostic glue
 
@@ -3155,6 +3162,7 @@ def process_stale_scc(graph: Graph, scc: List[str], manager: BuildManager) -> No
                 graph[id].finish_passes()
     for id in stale:
         graph[id].generate_unused_ignore_notes()
+        graph[id].generate_ignore_without_code_notes()
     if any(manager.errors.is_errors_for_file(graph[id].xpath) for id in stale):
         for id in stale:
             graph[id].transitive_error = True

mypy/errors.py

@@ -485,6 +485,28 @@ def generate_unused_ignore_errors(self, file: str) -> None:
                                  None, False, False, False)
                 self._add_error_info(file, info)
 
+    def generate_ignore_without_code_errors(self,
+                                            file: str,
+                                            is_warning_unused_ignores: bool) -> None:
+        if is_typeshed_file(file) or file in self.ignored_files:
+            return
+
+        used_ignored_lines = self.used_ignored_lines[file]
+        for line, ignored_codes in self.ignored_lines[file].items():
+            if ignored_codes:
+                continue
+
+            # If the ignore is itself unused and that would be warned about, let
+            # that error stand alone
+            if is_warning_unused_ignores and not used_ignored_lines[line]:
+                continue
+
+            # Don't use report since add_error_info will ignore the error!
+            info = ErrorInfo(self.import_context(), file, self.current_module(), None,
+                             None, line, -1, 'error', '"type: ignore" comment without error code',
+                             None, False, False, False)
+            self._add_error_info(file, info)
+
     def num_messages(self) -> int:
         """Return the number of generated messages."""
         return sum(len(x) for x in self.error_info_map.values())

mypy/main.py

@@ -677,6 +677,10 @@ def add_invertible_flag(flag: str,
                              " non-overlapping types",
                         group=strictness_group)
 
+    add_invertible_flag('--disallow-ignore-without-code', default=False, strict_flag=True,
+                        help="Disallow 'type: ignore' comments which do not have error codes",
+                        group=strictness_group)
+
     strict_help = "Strict mode; enables the following flags: {}".format(
         ", ".join(strict_flag_names))
     strictness_group.add_argument(

mypy/options.py

@@ -143,6 +143,9 @@ def __init__(self) -> None:
         # Warn about unused '# type: ignore' comments
         self.warn_unused_ignores = False
 
+        # Warn about '# type: ignore' comments without error codes
+        self.disallow_ignore_without_code = False
+
         # Warn about unused '[mypy-<pattern>]'  or '[[tool.mypy.overrides]]' config sections
         self.warn_unused_configs = False
 

test-data/unit/check-errorcodes.test

@@ -135,6 +135,15 @@ x # type: ignore[name-defined, attr-defined] # E: Unused "type: ignore[attr-defi
 # flags: --warn-unused-ignores
 "x" # type: ignore[name-defined] # E: Unused "type: ignore" comment
 
+[case testErrorCodeMissingWhenRequired]
+# flags: --disallow-ignore-without-code
+"x" # type: ignore # E: "type: ignore" comment without error code
+y # type: ignore # E: "type: ignore" comment without error code
+
+[case testErrorCodeMissingDoesntTrampleUnusedIgnoresWarning]
+# flags: --disallow-ignore-without-code --warn-unused-ignores
+"x" # type: ignore # E: Unused "type: ignore" comment
+
 [case testErrorCodeIgnoreWithExtraSpace]
 x  # type: ignore   [name-defined]
 x2 # type: ignore   [ name-defined ]