Add --warn-unused-strictness-exceptions flag

Warn about strictness flags unnecessarily disabled for particular modules.
If a flag is enabled globally (either explicitly or by default) and it is
disabled for a particular module that does not have errors related to this
flag mypy will output an error.

Currently, this is implemented only for --disallow-any-generics but it should be
very straightforward to support other strictness flags.

Fixes #4018

Author: ilinum

mypy/build.py

@@ -1530,6 +1530,10 @@ def __init__(self,
             # TODO: Get mtime if not cached.
             if self.meta is not None:
                 self.interface_hash = self.meta.interface_hash
+        for option in Options.WARN_UNUSED_STRICTNESS_OPTIONS:
+            if (option in self.options.unused_strictness_whitelist and
+                    not getattr(self.options, option)):
+                self.options.unused_strictness_whitelist[option].add(self.id)
         self.add_ancestors()
         self.meta = validate_meta(self.meta, self.id, self.path, self.ignore_all, manager)
         if self.meta:
@@ -1936,6 +1940,12 @@ def dispatch(sources: List[BuildSource], manager: BuildManager) -> Graph:
     if manager.options.warn_unused_ignores:
         # TODO: This could also be a per-module option.
         manager.errors.generate_unused_ignore_notes()
+    if manager.options.warn_unused_strictness_exceptions:
+        for option in manager.options.unused_strictness_whitelist:
+            for file in manager.options.unused_strictness_whitelist[option]:
+                message = "Flag {} can be enabled for module '{}'".format(option, file)
+                manager.errors.report(-1, -1, message, blocker=False, severity='warning',
+                                      file=file)
     manager.saved_cache.update(preserve_cache(graph))
     if manager.options.dump_deps:
         # This speeds up startup a little when not using the daemon mode.

mypy/main.py

@@ -293,7 +293,10 @@ def add_invertible_flag(flag: str,
     add_invertible_flag('--warn-unused-ignores', default=False, strict_flag=True,
                         help="warn about unneeded '# type: ignore' comments")
     add_invertible_flag('--warn-unused-configs', default=False, strict_flag=True,
-                        help="warn about unnused '[mypy-<pattern>]' config sections")
+                        help="warn about unused '[mypy-<pattern>]' config sections")
+    add_invertible_flag('--warn-unused-strictness-exceptions', default=False, strict_flag=True,
+                        help="warn about strictness flags unnecessarily disabled for particular "
+                             "modules")
     add_invertible_flag('--show-error-context', default=False,
                         dest='show_error_context',
                         help='Precede errors with "note:" messages explaining context')
@@ -497,6 +500,10 @@ def add_invertible_flag(flag: str,
     if options.quick_and_dirty:
         options.incremental = True
 
+    for option in Options.WARN_UNUSED_STRICTNESS_OPTIONS:
+        if getattr(options, option):
+            options.unused_strictness_whitelist[option] = set()
+
     # Set target.
     if special_opts.modules:
         options.build_type = BuildType.MODULE

mypy/options.py

@@ -44,6 +44,10 @@ class Options:
     OPTIONS_AFFECTING_CACHE = ((PER_MODULE_OPTIONS | {"quick_and_dirty", "platform"})
                                - {"debug_cache"})
 
+    WARN_UNUSED_STRICTNESS_OPTIONS = {
+        "disallow_any_generics",
+    }
+
     def __init__(self) -> None:
         # -- build options --
         self.build_type = BuildType.STANDARD
@@ -100,6 +104,9 @@ def __init__(self) -> None:
         # Warn about unused '[mypy-<pattern>] config sections
         self.warn_unused_configs = False
 
+        # Warn about strictness flags unnecessarily disabled for particular modules
+        self.warn_unused_strictness_exceptions = False
+
         # Files in which to ignore all non-fatal errors
         self.ignore_errors = False
 
@@ -147,6 +154,9 @@ def __init__(self) -> None:
         # Map pattern back to glob
         self.unused_configs = OrderedDict()  # type: OrderedDict[Pattern[str], str]
 
+        # Dict of options to files in which they can be disabled
+        self.unused_strictness_whitelist = {}  # type: Dict[str, Set[str]]
+
         # -- development options --
         self.verbosity = 0  # More verbose messages (for troubleshooting)
         self.pdb = False
@@ -198,3 +208,8 @@ def module_matches_pattern(self, module: str, pattern: Pattern[str]) -> bool:
 
     def select_options_affecting_cache(self) -> Mapping[str, bool]:
         return {opt: getattr(self, opt) for opt in self.OPTIONS_AFFECTING_CACHE}
+
+    def remove_from_whitelist(self, flag: str, file: Optional[str]) -> None:
+        whitelist = self.unused_strictness_whitelist
+        if flag in whitelist and file in whitelist[flag]:
+            whitelist[flag].remove(file)

mypy/semanal.py

@@ -1624,7 +1624,7 @@ def type_analyzer(self, *,
                             self.note,
                             self.plugin,
                             self.options,
-                            self.is_typeshed_stub_file,
+                            self.errors,
                             aliasing=aliasing,
                             allow_tuple_literal=allow_tuple_literal,
                             allow_unnormalized=self.is_stub_file,
@@ -1733,7 +1733,7 @@ def analyze_alias(self, rvalue: Expression,
                                  self.note,
                                  self.plugin,
                                  self.options,
-                                 self.is_typeshed_stub_file,
+                                 self.errors,
                                  allow_unnormalized=True,
                                  in_dynamic_func=dynamic,
                                  global_scope=global_scope,

mypy/semanal_pass3.py

@@ -368,16 +368,20 @@ def make_type_analyzer(self, indicator: Dict[str, bool]) -> TypeAnalyserPass3:
                                  self.sem.note,
                                  self.sem.plugin,
                                  self.options,
-                                 self.is_typeshed_file,
+                                 self.errors,
                                  indicator)
 
     def check_for_omitted_generics(self, typ: Type) -> None:
-        if not self.options.disallow_any_generics or self.is_typeshed_file:
+        if self.is_typeshed_file:
             return
 
         for t in collect_any_types(typ):
             if t.type_of_any == TypeOfAny.from_omitted_generics:
-                self.fail(messages.BARE_GENERIC, t)
+                if self.options.disallow_any_generics:
+                    self.fail(messages.BARE_GENERIC, t)
+                else:
+                    self.options.remove_from_whitelist("disallow_any_generics",
+                                                       self.errors.current_module())
 
     def fail(self, msg: str, ctx: Context, *, blocker: bool = False) -> None:
         self.errors.report(ctx.get_line(), ctx.get_column(), msg)

mypy/typeanal.py

@@ -8,6 +8,7 @@
 
 import itertools
 
+from mypy.errors import Errors
 from mypy.messages import MessageBuilder
 from mypy.options import Options
 from mypy.types import (
@@ -60,7 +61,7 @@ def analyze_type_alias(node: Expression,
                        note_func: Callable[[str, Context], None],
                        plugin: Plugin,
                        options: Options,
-                       is_typeshed_stub: bool,
+                       errors: Errors,
                        allow_unnormalized: bool = False,
                        in_dynamic_func: bool = False,
                        global_scope: bool = True,
@@ -117,7 +118,7 @@ def analyze_type_alias(node: Expression,
         fail_func('Invalid type alias', node)
         return None
     analyzer = TypeAnalyser(lookup_func, lookup_fqn_func, tvar_scope, fail_func, note_func,
-                            plugin, options, is_typeshed_stub, aliasing=True,
+                            plugin, options, errors, aliasing=True,
                             allow_unnormalized=allow_unnormalized, warn_bound_tvar=warn_bound_tvar)
     analyzer.in_dynamic_func = in_dynamic_func
     analyzer.global_scope = global_scope
@@ -151,7 +152,7 @@ def __init__(self,
                  note_func: Callable[[str, Context], None],
                  plugin: Plugin,
                  options: Options,
-                 is_typeshed_stub: bool, *,
+                 errors: Errors, *,
                  aliasing: bool = False,
                  allow_tuple_literal: bool = False,
                  allow_unnormalized: bool = False,
@@ -169,7 +170,7 @@ def __init__(self,
         self.allow_unnormalized = allow_unnormalized
         self.plugin = plugin
         self.options = options
-        self.is_typeshed_stub = is_typeshed_stub
+        self.errors = errors
         self.warn_bound_tvar = warn_bound_tvar
         self.third_pass = third_pass
 
@@ -213,8 +214,12 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
             elif fullname == 'typing.Tuple':
                 if len(t.args) == 0 and not t.empty_tuple_index:
                     # Bare 'Tuple' is same as 'tuple'
-                    if self.options.disallow_any_generics and not self.is_typeshed_stub:
-                        self.fail(messages.BARE_GENERIC, t)
+                    if not self.errors.is_typeshed_file(self.errors.file):
+                        if self.options.disallow_any_generics:
+                            self.fail(messages.BARE_GENERIC, t)
+                        else:
+                            self.options.remove_from_whitelist("disallow_any_generics",
+                                                               self.errors.current_module())
                     typ = self.named_type('builtins.tuple', line=t.line, column=t.column)
                     typ.from_generic_builtin = True
                     return typ
@@ -653,15 +658,15 @@ def __init__(self,
                  note_func: Callable[[str, Context], None],
                  plugin: Plugin,
                  options: Options,
-                 is_typeshed_stub: bool,
+                 errors: Errors,
                  indicator: Dict[str, bool]) -> None:
         self.lookup_func = lookup_func
         self.lookup_fqn_func = lookup_fqn_func
         self.fail = fail_func
         self.note_func = note_func
         self.options = options
         self.plugin = plugin
-        self.is_typeshed_stub = is_typeshed_stub
+        self.errors = errors
         self.indicator = indicator
 
     def visit_instance(self, t: Instance) -> None:
@@ -672,11 +677,13 @@ def visit_instance(self, t: Instance) -> None:
         if len(t.args) != len(info.type_vars):
             if len(t.args) == 0:
                 from_builtins = t.type.fullname() in nongen_builtins and not t.from_generic_builtin
-                if (self.options.disallow_any_generics and
-                        not self.is_typeshed_stub and
-                        from_builtins):
-                    alternative = nongen_builtins[t.type.fullname()]
-                    self.fail(messages.IMPLICIT_GENERIC_ANY_BUILTIN.format(alternative), t)
+                if from_builtins and not self.errors.is_typeshed_file(self.errors.file):
+                    if self.options.disallow_any_generics:
+                        alternative = nongen_builtins[t.type.fullname()]
+                        self.fail(messages.IMPLICIT_GENERIC_ANY_BUILTIN.format(alternative), t)
+                    else:
+                        self.options.remove_from_whitelist("disallow_any_generics",
+                                                           self.errors.current_module())
                 # Insert implicit 'Any' type arguments.
                 if from_builtins:
                     # this 'Any' was already reported elsewhere
@@ -834,7 +841,7 @@ def anal_type(self, tp: UnboundType) -> Type:
                             self.note_func,
                             self.plugin,
                             self.options,
-                            self.is_typeshed_stub,
+                            self.errors,
                             third_pass=True)
         return tp.accept(tpan)
 

test-data/unit/cmdline.test

@@ -1008,3 +1008,72 @@ def get_tasks(self):
     return 'whatever'
 [out]
 a.py:1: error: Function is missing a type annotation
+
+-- Unused strictness exceptions
+-- ----------------------------
+
+[case testUnusedStrictnessExceptions]
+# cmd: mypy a.py b.py
+
+[file mypy.ini]
+[[mypy]
+warn_unused_strictness_exceptions = True
+disallow_any_generics = True
+
+[[mypy-a]
+disallow_any_generics = False
+
+[[mypy-b]
+disallow_any_generics = False
+
+[file a.py]
+from typing import List
+
+f: List = []
+[file b.py]
+from typing import List
+
+f: List[int] = []
+
+[out]
+b: warning: Flag disallow_any_generics can be enabled for module 'b'
+
+[case testUnusedStrictnessExceptionSubpattern]
+# cmd: mypy test1.py test2.py
+
+[file mypy.ini]
+[[mypy]
+warn_unused_strictness_exceptions = True
+disallow_any_generics = True
+
+[[mypy-test*]
+disallow_any_generics = False
+
+[file test1.py]
+f: list = []
+
+[file test2.py]
+from typing import List
+
+f: List[int] = []
+
+[out]
+test2: warning: Flag disallow_any_generics can be enabled for module 'test2'
+
+[case testUnusedStrictnessExceptionsNotAffectedByTypeIgnore]
+# cmd: mypy a.py
+
+[file mypy.ini]
+[[mypy]
+warn_unused_strictness_exceptions = True
+disallow_any_generics = True
+
+[[mypy-a]
+disallow_any_generics = False
+
+[file a.py]
+from typing import Tuple
+
+f: Tuple = (1, 2, 3)  # type: ignore
+
+[out]