Add flag to disallow implicit Any types.

These types can appear from an unanalyzed module.
If mypy encounters a type annotation that uses such a type,
it will report an error.
Fixes #3205

Author: ilinum

mypy/build.py

@@ -1387,9 +1387,7 @@ def fix_suppressed_dependencies(self, graph: Graph) -> None:
         """
         # TODO: See if it's possible to move this check directly into parse_file in some way.
         # TODO: Find a way to write a test case for this fix.
-        silent_mode = (self.options.ignore_missing_imports or
-                       self.options.follow_imports == 'skip')
-        if not silent_mode:
+        if not self.options.silent_mode():
             return
 
         new_suppressed = []

mypy/checker.py

@@ -29,6 +29,7 @@
     ARG_POS, MDEF,
     CONTRAVARIANT, COVARIANT)
 from mypy import nodes
+from mypy.typeanal import has_any_from_silent_import
 from mypy.types import (
     Type, AnyType, CallableType, FunctionLike, Overloaded, TupleType, TypedDictType,
     Instance, NoneTyp, strip_type, TypeType,
@@ -611,6 +612,18 @@ def is_implicit_any(t: Type) -> bool:
                                 self.fail(messages.RETURN_TYPE_EXPECTED, fdef)
                             if any(is_implicit_any(t) for t in fdef.type.arg_types):
                                 self.fail(messages.ARGUMENT_TYPE_EXPECTED, fdef)
+                    if self.options.disallow_implicit_any_types:
+                        if fdef.type and isinstance(fdef.type, CallableType):
+                            if has_any_from_silent_import(fdef.type.ret_type):
+                                self.fail("Return type is implicitly converted to "
+                                          "'{}' due to import from "
+                                          "unanalyzed module".format(fdef.type.ret_type), fdef)
+                            for idx, arg_type in enumerate(fdef.type.arg_types):
+                                if has_any_from_silent_import(arg_type):
+                                    self.fail("Argument {} to '{}' is implicitly converted to "
+                                              "'{}' due to import from unanalyzed "
+                                              "module".format(idx + 1, fdef.name(), arg_type),
+                                              fdef)
 
                 if name in nodes.reverse_op_method_set:
                     self.check_reverse_op_method(item, typ, name)
@@ -1706,6 +1719,10 @@ def check_simple_assignment(self, lvalue_type: Type, rvalue: Expression,
                 self.msg.deleted_as_rvalue(rvalue_type, context)
             if isinstance(lvalue_type, DeletedType):
                 self.msg.deleted_as_lvalue(lvalue_type, context)
+            elif (self.options.disallow_implicit_any_types
+                  and has_any_from_silent_import(lvalue_type)):
+                self.msg.fail("Type of {} is implicitly converted to '{}' due to import from "
+                              "unanalyzed module".format(lvalue_name, lvalue_type), context)
             else:
                 self.check_subtype(rvalue_type, lvalue_type, context, msg,
                                    '{} has type'.format(rvalue_name),

mypy/main.py

@@ -222,6 +222,9 @@ def add_invertible_flag(flag: str,
                         help="silently ignore imports of missing modules")
     parser.add_argument('--follow-imports', choices=['normal', 'silent', 'skip', 'error'],
                         default='normal', help="how to treat imports (default normal)")
+    parser.add_argument('--disallow-implicit-any-types', action='store_true',
+                        help="disallow implicit conversion of types from unanalyzed modules"
+                             " into Any")
     add_invertible_flag('--disallow-untyped-calls', default=False, strict_flag=True,
                         help="disallow calling functions without type annotations"
                         " from functions with type annotations")

mypy/options.py

@@ -19,6 +19,7 @@ class Options:
     PER_MODULE_OPTIONS = {
         "ignore_missing_imports",
         "follow_imports",
+        "disallow_implicit_any_types",
         "disallow_untyped_calls",
         "disallow_untyped_defs",
         "check_untyped_defs",
@@ -44,6 +45,7 @@ def __init__(self) -> None:
         self.report_dirs = {}  # type: Dict[str, str]
         self.ignore_missing_imports = False
         self.follow_imports = 'normal'  # normal|silent|skip|error
+        self.disallow_implicit_any_types = False
 
         # Disallow calling untyped functions from typed ones
         self.disallow_untyped_calls = False
@@ -158,3 +160,6 @@ 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 silent_mode(self) -> bool:
+        return self.ignore_missing_imports or self.follow_imports == 'skip'

mypy/semanal.py

@@ -85,7 +85,7 @@
 from mypy.nodes import implicit_module_attrs
 from mypy.typeanal import (
     TypeAnalyser, TypeAnalyserPass3, analyze_type_alias, no_subscript_builtin_alias,
-    TypeVariableQuery, TypeVarList, remove_dups,
+    TypeVariableQuery, TypeVarList, remove_dups, has_any_from_silent_import
 )
 from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError
 from mypy.sametypes import is_same_type
@@ -964,7 +964,9 @@ def analyze_base_classes(self, defn: ClassDef) -> None:
                     self.fail("Cannot subclass NewType", defn)
                 base_types.append(base)
             elif isinstance(base, AnyType):
-                if self.options.disallow_subclassing_any:
+                # if --disallow-implicit-any-types is set, the issue is reported later
+                if (self.options.disallow_subclassing_any and
+                        not self.options.disallow_implicit_any_types):
                     if isinstance(base_expr, (NameExpr, MemberExpr)):
                         msg = "Class cannot subclass '{}' (has type 'Any')".format(base_expr.name)
                     else:
@@ -974,6 +976,15 @@ def analyze_base_classes(self, defn: ClassDef) -> None:
             else:
                 self.fail('Invalid base class', base_expr)
                 info.fallback_to_any = True
+            if (self.options.disallow_implicit_any_types and
+                    has_any_from_silent_import(base)):
+                if isinstance(base_expr, (NameExpr, MemberExpr)):
+                    msg = ("Subclassing type '{}' that is implicitly converted to '{}' due to "
+                           "import from unanalyzed module".format(base_expr.name, base))
+                else:
+                    msg = ("Subclassing a type that is implicitly converted to '{}' "
+                           "due to import from unanalyzed module".format(base))
+                self.fail(msg, base_expr)
 
         # Add 'object' as implicit base if there is no other base class.
         if (not base_types and defn.fullname != 'builtins.object'):
@@ -1428,7 +1439,12 @@ def add_unknown_symbol(self, name: str, context: Context, is_import: bool = Fals
         else:
             var._fullname = self.qualified_name(name)
         var.is_ready = True
-        var.type = AnyType()
+        any_type = AnyType()
+        if self.options.silent_mode():
+            # if silent mode is not enabled, no need to report implicit conversion to Any,
+            # let mypy report an import error.
+            any_type.is_from_silent_import = is_import
+        var.type = any_type
         var.is_suppressed_import = is_import
         self.add_symbol(name, SymbolTableNode(GDEF, var, self.cur_mod_id), context)
 

mypy/typeanal.py

@@ -232,7 +232,9 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                     # context. This is slightly problematic as it allows using the type 'Any'
                     # as a base class -- however, this will fail soon at runtime so the problem
                     # is pretty minor.
-                    return AnyType()
+                    any_type = AnyType()
+                    any_type.is_from_silent_import = sym.node.type.is_from_silent_import
+                    return any_type
                 # Allow unbound type variables when defining an alias
                 if not (self.aliasing and sym.kind == TVAR and
                         self.tvar_scope.get_binding(sym) is None):
@@ -731,6 +733,23 @@ def visit_callable_type(self, t: CallableType) -> TypeVarList:
             return []
 
 
+def has_any_from_silent_import(t: Type) -> bool:
+    """Return true if this type was converted to Any because of a silenced import.
+
+    If type t is was co or is has type arguments that contain such Any type
+    this function will return true.
+    """
+    return t.accept(HasAnyFromSilentImportQuery())
+
+
+class HasAnyFromSilentImportQuery(TypeQuery[bool]):
+    def __init__(self) -> None:
+        super().__init__(any)
+
+    def visit_any(self, t: AnyType) -> bool:
+        return t.is_from_silent_import
+
+
 def make_optional_type(t: Type) -> Type:
     """Return the type corresponding to Optional[t].
 

mypy/types.py

@@ -272,6 +272,9 @@ def serialize(self) -> JsonDict:
 class AnyType(Type):
     """The type 'Any'."""
 
+    # Does this come from a silent import? Used for --disallow-implicit-any-types flag
+    is_from_silent_import = False
+
     def __init__(self, implicit: bool = False, line: int = -1, column: int = -1) -> None:
         super().__init__(line, column)
         self.implicit = implicit

test-data/unit/check-flags.test

@@ -376,3 +376,52 @@ if y:  # E: Condition must be a boolean
 if z:  # E: Condition must be a boolean
   pass
 [builtins fixtures/bool.pyi]
+
+[case testDisallowImplicitTypesIgnoreMissingTypes]
+# flags: --ignore-missing-imports --disallow-implicit-any-types
+from missing import MyType
+
+def f(x: MyType) -> None:  # E: Argument 1 to 'f' is implicitly converted to 'Any' due to import from unanalyzed module
+  pass
+
+[case testDisallowImplicitTypes]
+# flags: --disallow-implicit-any-types
+from missing import MyType
+
+def f(x: MyType) -> None:
+  pass
+[out]
+main:2: error: Cannot find module named 'missing'
+main:2: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
+
+[case testDisallowImplicitAnyVariableDefinition]
+# flags: --ignore-missing-imports --disallow-implicit-any-types
+from missing import Unchecked
+
+t: Unchecked = 12  # E: Type of variable is implicitly converted to 'Any' due to import from unanalyzed module
+
+[case testDisallowImplicitAnyGeneric]
+# flags: --ignore-missing-imports --disallow-implicit-any-types
+from missing import Unchecked
+from typing import List
+
+def foo(l: List[Unchecked]) -> List[Unchecked]:
+  t = []  # type: List[Unchecked]
+  return l
+[builtins fixtures/list.pyi]
+[out]
+main:5: error: Return type is implicitly converted to 'builtins.list[Any]' due to import from unanalyzed module
+main:5: error: Argument 1 to 'foo' is implicitly converted to 'builtins.list[Any]' due to import from unanalyzed module
+main:6: error: Type of variable is implicitly converted to 'builtins.list[Any]' due to import from unanalyzed module
+
+[case testDisallowImplicitAnyInherit]
+# flags: --ignore-missing-imports --disallow-implicit-any-types
+from missing import Unchecked
+from typing import List
+
+class C(Unchecked): # E: Subclassing type 'Unchecked' that is implicitly converted to 'Any' due to import from unanalyzed module
+  pass
+
+class A(List[Unchecked]): # E: Subclassing a type that is implicitly converted to 'builtins.list[Any]' due to import from unanalyzed module
+  pass
+[builtins fixtures/list.pyi]