Add option to limit strict Optional errors to whitelist of globs (#2060)

Author: ddfisher

docs/source/command_line.rst

@@ -227,6 +227,18 @@ Here are some more useful flags:
   use of ``None`` values -- they are valid everywhere. See :ref:`strict_optional` for
   more about this feature.
 
+- ``--strict-optional-whitelist`` attempts to suppress strict Optional-related
+  errors in non-whitelisted files.  Takes an arbitrary number of globs as the
+  whitelist.  This option is intended to be used to incrementally roll out
+  ``--strict-optional`` to a large codebase that already has mypy annotations.
+  However, this flag comes with some significant caveats.  It does not suppress
+  all errors caused by turning on ``--strict-optional``, only most of them, so
+  there may still be a bit of upfront work to be done before it can be used in
+  CI.  It will also suppress some errors that would be caught in a
+  non-strict-Optional run.  Therefore, when using this flag, you should also
+  re-check your code without ``--strict-optional`` to ensure new type errors
+  are not introduced.
+
 - ``--disallow-untyped-defs`` reports an error whenever it encounters
   a function definition without type annotations.
 

mypy/checker.py

@@ -2,6 +2,7 @@
 
 import itertools
 import contextlib
+import fnmatch
 import os
 import os.path
 
@@ -114,7 +115,10 @@ class TypeChecker(NodeVisitor[Type]):
     # Have we deferred the current function? If yes, don't infer additional
     # types during this pass within the function.
     current_node_deferred = False
+    # Is this file a typeshed stub?
     is_typeshed_stub = False
+    # Should strict Optional-related errors be suppressed in this file?
+    suppress_none_errors = False
     options = None  # type: Options
 
     def __init__(self, errors: Errors, modules: Dict[str, MypyFile], options: Options) -> None:
@@ -148,6 +152,12 @@ def visit_file(self, file_node: MypyFile, path: str) -> None:
         self.weak_opts = file_node.weak_opts
         self.enter_partial_types()
         self.is_typeshed_stub = self.errors.is_typeshed_file(path)
+        if self.options.strict_optional_whitelist is None:
+            self.suppress_none_errors = False
+        else:
+            self.suppress_none_errors = not any(fnmatch.fnmatch(path, pattern)
+                                                for pattern
+                                                in self.options.strict_optional_whitelist)
 
         for d in file_node.defs:
             self.accept(d)
@@ -2125,6 +2135,8 @@ def check_subtype(self, subtype: Type, supertype: Type, context: Context,
             if self.is_unusable_type(subtype):
                 self.msg.does_not_return_value(subtype, context)
             else:
+                if self.should_suppress_optional_error([subtype]):
+                    return False
                 extra_info = []  # type: List[str]
                 if subtype_label is not None or supertype_label is not None:
                     subtype_str, supertype_str = self.msg.format_distinctly(subtype, supertype)
@@ -2137,6 +2149,17 @@ def check_subtype(self, subtype: Type, supertype: Type, context: Context,
                 self.fail(msg, context)
             return False
 
+    def contains_none(self, t: Type):
+        return (
+            isinstance(t, NoneTyp) or
+            (isinstance(t, UnionType) and any(self.contains_none(ut) for ut in t.items)) or
+            (isinstance(t, TupleType) and any(self.contains_none(tt) for tt in t.items)) or
+            (isinstance(t, Instance) and t.args and any(self.contains_none(it) for it in t.args))
+        )
+
+    def should_suppress_optional_error(self, related_types: List[Type]) -> bool:
+        return self.suppress_none_errors and any(self.contains_none(t) for t in related_types)
+
     def named_type(self, name: str) -> Instance:
         """Return an instance type with type given by the name and no
         type arguments. For example, named_type('builtins.object')

mypy/checkexpr.py

@@ -289,7 +289,7 @@ def check_call(self, callee: Type, args: List[Node],
         elif isinstance(callee, Instance):
             call_function = analyze_member_access('__call__', callee, context,
                                          False, False, False, self.named_type,
-                                         self.not_ready_callback, self.msg)
+                                         self.not_ready_callback, self.msg, chk=self.chk)
             return self.check_call(call_function, args, arg_kinds, context, arg_names,
                                    callable_node, arg_messages)
         elif isinstance(callee, TypeVarType):
@@ -709,6 +709,8 @@ def check_arg(self, caller_type: Type, original_caller_type: Type,
         elif isinstance(caller_type, DeletedType):
             messages.deleted_as_rvalue(caller_type, context)
         elif not is_subtype(caller_type, callee_type):
+            if self.chk.should_suppress_optional_error([caller_type, callee_type]):
+                return
             messages.incompatible_argument(n, m, callee, original_caller_type,
                                            caller_kind, context)
 
@@ -757,7 +759,8 @@ def overload_call_target(self, arg_types: List[Type], arg_kinds: List[int],
                     match.append(typ)
                 best_match = max(best_match, similarity)
         if not match:
-            messages.no_variant_matches_arguments(overload, arg_types, context)
+            if not self.chk.should_suppress_optional_error(arg_types):
+                messages.no_variant_matches_arguments(overload, arg_types, context)
             return AnyType()
         else:
             if len(match) == 1:
@@ -871,7 +874,8 @@ def analyze_ordinary_member_access(self, e: MemberExpr,
             # This is a reference to a non-module attribute.
             return analyze_member_access(e.name, self.accept(e.expr), e,
                                          is_lvalue, False, False,
-                                         self.named_type, self.not_ready_callback, self.msg)
+                                         self.named_type, self.not_ready_callback, self.msg,
+                                         chk=self.chk)
 
     def analyze_external_member_access(self, member: str, base_type: Type,
                                        context: Context) -> Type:
@@ -880,7 +884,8 @@ def analyze_external_member_access(self, member: str, base_type: Type,
         """
         # TODO remove; no private definitions in mypy
         return analyze_member_access(member, base_type, context, False, False, False,
-                                     self.named_type, self.not_ready_callback, self.msg)
+                                     self.named_type, self.not_ready_callback, self.msg,
+                                     chk=self.chk)
 
     def visit_int_expr(self, e: IntExpr) -> Type:
         """Type check an integer literal (trivial)."""
@@ -1032,7 +1037,8 @@ def check_op_local(self, method: str, base_type: Type, arg: Node,
         Return tuple (result type, inferred operator method type).
         """
         method_type = analyze_member_access(method, base_type, context, False, False, True,
-                                            self.named_type, self.not_ready_callback, local_errors)
+                                            self.named_type, self.not_ready_callback, local_errors,
+                                            chk=self.chk)
         return self.check_call(method_type, [arg], [nodes.ARG_POS],
                                context, arg_messages=local_errors)
 
@@ -1555,7 +1561,7 @@ def analyze_super(self, e: SuperExpr, is_lvalue: bool) -> Type:
                     return analyze_member_access(e.name, self_type(e.info), e,
                                                  is_lvalue, True, False,
                                                  self.named_type, self.not_ready_callback,
-                                                 self.msg, base)
+                                                 self.msg, base, chk=self.chk)
         else:
             # Invalid super. This has been reported by the semantic analyzer.
             return AnyType()

mypy/checkmember.py

@@ -17,6 +17,8 @@
 from mypy.semanal import self_type
 from mypy import messages
 from mypy import subtypes
+if False:  # import for forward declaration only
+    import mypy.checker
 
 
 def analyze_member_access(name: str,
@@ -29,7 +31,8 @@ def analyze_member_access(name: str,
                           not_ready_callback: Callable[[str, Context], None],
                           msg: MessageBuilder,
                           override_info: TypeInfo = None,
-                          report_type: Type = None) -> Type:
+                          report_type: Type = None,
+                          chk: 'mypy.checker.TypeChecker' = None) -> Type:
     """Analyse attribute access.
 
     This is a general operation that supports various different variations:
@@ -74,27 +77,30 @@ def analyze_member_access(name: str,
             return analyze_member_var_access(name, typ, info, node,
                                              is_lvalue, is_super, builtin_type,
                                              not_ready_callback, msg,
-                                             report_type=report_type)
+                                             report_type=report_type, chk=chk)
     elif isinstance(typ, AnyType):
         # The base object has dynamic type.
         return AnyType()
     elif isinstance(typ, NoneTyp):
+        if chk and chk.should_suppress_optional_error([typ]):
+            return AnyType()
         # The only attribute NoneType has are those it inherits from object
         return analyze_member_access(name, builtin_type('builtins.object'), node, is_lvalue,
                                      is_super, is_operator, builtin_type, not_ready_callback, msg,
-                                     report_type=report_type)
+                                     report_type=report_type, chk=chk)
     elif isinstance(typ, UnionType):
         # The base object has dynamic type.
         msg.disable_type_names += 1
         results = [analyze_member_access(name, subtype, node, is_lvalue, is_super,
-                                         is_operator, builtin_type, not_ready_callback, msg)
+                                         is_operator, builtin_type, not_ready_callback, msg,
+                                         chk=chk)
                    for subtype in typ.items]
         msg.disable_type_names -= 1
         return UnionType.make_simplified_union(results)
     elif isinstance(typ, TupleType):
         # Actually look up from the fallback instance type.
         return analyze_member_access(name, typ.fallback, node, is_lvalue, is_super,
-                                     is_operator, builtin_type, not_ready_callback, msg)
+                                     is_operator, builtin_type, not_ready_callback, msg, chk=chk)
     elif isinstance(typ, FunctionLike) and typ.is_type_obj():
         # Class attribute.
         # TODO super?
@@ -123,18 +129,18 @@ def analyze_member_access(name: str,
             # Look up from the 'type' type.
             return analyze_member_access(name, typ.fallback, node, is_lvalue, is_super,
                                          is_operator, builtin_type, not_ready_callback, msg,
-                                         report_type=report_type)
+                                         report_type=report_type, chk=chk)
         else:
             assert False, 'Unexpected type {}'.format(repr(ret_type))
     elif isinstance(typ, FunctionLike):
         # Look up from the 'function' type.
         return analyze_member_access(name, typ.fallback, node, is_lvalue, is_super,
                                      is_operator, builtin_type, not_ready_callback, msg,
-                                     report_type=report_type)
+                                     report_type=report_type, chk=chk)
     elif isinstance(typ, TypeVarType):
         return analyze_member_access(name, typ.upper_bound, node, is_lvalue, is_super,
                                      is_operator, builtin_type, not_ready_callback, msg,
-                                     report_type=report_type)
+                                     report_type=report_type, chk=chk)
     elif isinstance(typ, DeletedType):
         msg.deleted_as_rvalue(typ, node)
         return AnyType()
@@ -155,7 +161,10 @@ def analyze_member_access(name: str,
         fallback = builtin_type('builtins.type')
         return analyze_member_access(name, fallback, node, is_lvalue, is_super,
                                      is_operator, builtin_type, not_ready_callback, msg,
-                                     report_type=report_type)
+                                     report_type=report_type, chk=chk)
+
+    if chk and chk.should_suppress_optional_error([typ]):
+        return AnyType()
     return msg.has_no_attr(report_type, name, node)
 
 
@@ -164,7 +173,8 @@ def analyze_member_var_access(name: str, itype: Instance, info: TypeInfo,
                               builtin_type: Callable[[str], Instance],
                               not_ready_callback: Callable[[str, Context], None],
                               msg: MessageBuilder,
-                              report_type: Type = None) -> Type:
+                              report_type: Type = None,
+                              chk: 'mypy.checker.TypeChecker' = None) -> Type:
     """Analyse attribute access that does not target a method.
 
     This is logically part of analyze_member_access and the arguments are
@@ -200,6 +210,8 @@ def analyze_member_var_access(name: str, itype: Instance, info: TypeInfo,
         msg.undefined_in_superclass(name, node)
         return AnyType()
     else:
+        if chk and chk.should_suppress_optional_error([itype]):
+            return AnyType()
         return msg.has_no_attr(report_type or itype, name, node)
 
 

mypy/main.py

@@ -174,6 +174,11 @@ def process_options(args: List[str],
     parser.add_argument('--strict-optional', action='store_true',
                         dest='special-opts:strict_optional',
                         help="enable experimental strict Optional checks")
+    parser.add_argument('--strict-optional-whitelist', metavar='GLOB', nargs='*',
+                        help="suppress strict Optional errors in all but the provided files "
+                        "(experimental -- read documentation before using!).  "
+                        "Implies --strict-optional.  Has the undesirable side-effect of "
+                        "suppressing other errors in non-whitelisted files.")
     parser.add_argument('--pdb', action='store_true', help="invoke pdb on fatal error")
     parser.add_argument('--show-traceback', '--tb', action='store_true',
                         help="show traceback on fatal error")
@@ -268,7 +273,7 @@ def process_options(args: List[str],
             parser.error("May only specify one of: module, package, files, or command.")
 
     # Set build flags.
-    if special_opts.strict_optional:
+    if special_opts.strict_optional or options.strict_optional_whitelist is not None:
         experiments.STRICT_OPTIONAL = True
 
     # Set reports.

mypy/options.py

@@ -1,7 +1,7 @@
 from mypy import defaults
 import pprint
 import sys
-from typing import Any, Optional, Tuple
+from typing import Any, Optional, Tuple, List
 
 
 class BuildType:
@@ -40,6 +40,10 @@ def __init__(self) -> None:
 
         # Warn about unused '# type: ignore' comments
         self.warn_unused_ignores = False
+
+        # Files in which to allow strict-Optional related errors
+        self.strict_optional_whitelist = None   # type: Optional[List[str]]
+
         # -- development options --
         self.verbosity = 0  # More verbose messages (for troubleshooting)
         self.pdb = False

test-data/unit/check-optional.test

@@ -379,3 +379,52 @@ reveal_type(None if bool() else 0)  # E: Revealed type is 'Union[builtins.int, b
 [case testListWithNone]
 reveal_type([0, None, 0])    # E: Revealed type is 'builtins.list[Union[builtins.int, builtins.None]]'
 [builtins fixtures/list.pyi]
+
+[case testOptionalWhitelistSuppressesOptionalErrors]
+# flags: --strict-optional-whitelist
+import a
+import b
+[file a.py]
+from typing import Optional
+x = None  # type: Optional[str]
+x + "foo"
+
+[file b.py]
+from typing import Optional
+x = None  # type: Optional[int]
+x + 1
+
+[case testOptionalWhitelistPermitsOtherErrors]
+# flags: --strict-optional-whitelist
+import a
+import b
+[file a.py]
+from typing import Optional
+x = None  # type: Optional[str]
+x + "foo"
+
+[file b.py]
+from typing import Optional
+x = None  # type: Optional[int]
+x + 1
+1 + "foo"
+[out]
+main:3: note: In module imported here:
+tmp/b.py:4: error: Unsupported operand types for + ("int" and "str")
+
+[case testOptionalWhitelistPermitsWhitelistedFiles]
+# flags: --strict-optional-whitelist **/a.py
+import a
+import b
+[file a.py]
+from typing import Optional
+x = None  # type: Optional[str]
+x + "foo"
+
+[file b.py]
+from typing import Optional
+x = None  # type: Optional[int]
+x + 1
+[out]
+main:2: note: In module imported here:
+tmp/a.py:3: error: Unsupported left operand type for + (some union)