Add --disallow-subclassing-any flag (#2100)

Add a new flag that disallows classes with a base class of type `Any`.

This tends to happen when using `--silent-imports` or when using a
class from a module or library that is not typechecked by mypy.
Normally, mypy will silently accept subclassing Any, which can sometimes
lead to discrepancies which further leads to subtle bugs.

Passing in this optional flag will report an error instead,
including the name of the offending base class.

Author: Michael0x2a

docs/source/command_line.rst

@@ -11,7 +11,7 @@ flag (or its long form ``--help``)::
   usage: mypy [-h] [-v] [-V] [--python-version x.y] [--platform PLATFORM]
               [--py2] [-s] [--silent] [--almost-silent]
               [--disallow-untyped-calls] [--disallow-untyped-defs]
-              [--check-untyped-defs]
+              [--check-untyped-defs] [--disallow-subclassing-any]
               [--warn-incomplete-stub] [--warn-redundant-casts]
               [--warn-unused-ignores] [--fast-parser] [-i] [--cache-dir DIR]
               [--strict-optional] [-f] [--pdb] [--use-python-path] [--stats]
@@ -251,6 +251,14 @@ Here are some more useful flags:
 - ``--disallow-untyped-calls`` reports an error whenever a function
   with type annotations calls a function defined without annotations.
 
+- ``--disallow-subclassing-any`` reports an error whenever a class
+  inherits a value of type ``Any``. This often occurs when inheriting
+  a class that was imported from a module not typechecked by mypy while
+  using ``--silent-imports``. Since the module is silenced, the imported
+  class is given a type of ``Any``. By default, mypy will assume the
+  subclass correctly inherited the base class even though that may not
+  actually be the case. This flag makes mypy raise an error instead.
+
 - ``--incremental`` is an experimental option that enables incremental
   type checking. When enabled, mypy caches results from previous runs
   to speed up type checking. Incremental mode can help when most parts

mypy/main.py

@@ -154,6 +154,8 @@ def process_options(args: List[str],
                         " or with incomplete type annotations")
     parser.add_argument('--check-untyped-defs', action='store_true',
                         help="type check the interior of functions without type annotations")
+    parser.add_argument('--disallow-subclassing-any', action='store_true',
+                        help="disallow subclassing values of type 'Any' when defining classes")
     parser.add_argument('--warn-incomplete-stub', action='store_true',
                         help="warn if missing type annotation in typeshed, only relevant with"
                         " --check-untyped-defs enabled")

mypy/options.py

@@ -32,6 +32,9 @@ def __init__(self) -> None:
         # Type check unannotated functions
         self.check_untyped_defs = False
 
+        # Disallow subclassing values of type 'Any'
+        self.disallow_subclassing_any = False
+
         # Also check typeshed for missing annotations
         self.warn_incomplete_stub = False
 

mypy/semanal.py

@@ -769,6 +769,12 @@ 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 isinstance(base_expr, (NameExpr, MemberExpr)):
+                        msg = "Class cannot subclass '{}' (has type 'Any')".format(base_expr.name)
+                    else:
+                        msg = "Class cannot subclass value of type 'Any'"
+                    self.fail(msg, base_expr)
                 info.fallback_to_any = True
             else:
                 self.fail('Invalid base class', base_expr)

test-data/unit/check-flags.test

@@ -36,3 +36,46 @@ def f():
 [out]
 main: note: In function "f":
 main:2: error: Function is missing a type annotation
+
+[case testSubclassingAny]
+# flags: --disallow-subclassing-any
+from typing import Any
+FakeClass = None  # type: Any
+class Foo(FakeClass): pass  # E: Class cannot subclass 'FakeClass' (has type 'Any')
+[out]
+
+[case testSubclassingAnyMultipleBaseClasses]
+# flags: --disallow-subclassing-any
+from typing import Any
+FakeClass = None  # type: Any
+class ActualClass: pass
+class Foo(ActualClass, FakeClass): pass  # E: Class cannot subclass 'FakeClass' (has type 'Any')
+[out]
+
+[case testSubclassingAnySilentImports]
+# flags: --disallow-subclassing-any --silent-imports
+# cmd: mypy -m main
+
+[file main.py]
+from ignored_module import BaseClass
+class Foo(BaseClass): pass
+
+[file ignored_module.py]
+class BaseClass: pass
+
+[out]
+tmp/main.py:2: error: Class cannot subclass 'BaseClass' (has type 'Any')
+
+[case testSubclassingAnySilentImports2]
+# flags: --disallow-subclassing-any --silent-imports
+# cmd: mypy -m main
+
+[file main.py]
+import ignored_module
+class Foo(ignored_module.BaseClass): pass
+
+[file ignored_module.py]
+class BaseClass: pass
+
+[out]
+tmp/main.py:2: error: Class cannot subclass 'BaseClass' (has type 'Any')