Add --disallow-untyped-functions

Author: ddfisher

mypy/build.py

@@ -54,6 +54,8 @@
 FAST_PARSER = 'fast-parser'      # Use experimental fast parser
 # Disallow calling untyped functions from typed ones
 DISALLOW_UNTYPED_CALLS = 'disallow-untyped-calls'
+# Disallow defining untyped (or incompletely typed) functions
+DISALLOW_UNTYPED_FUNCS = 'disallow-untyped-funcs'
 
 # State ids. These describe the states a source file / module can be in a
 # build.
@@ -383,7 +385,8 @@ def __init__(self, data_dir: str,
         self.type_checker = TypeChecker(self.errors,
                                         modules,
                                         self.pyversion,
-                                        DISALLOW_UNTYPED_CALLS in self.flags)
+                                        DISALLOW_UNTYPED_CALLS in self.flags,
+                                        DISALLOW_UNTYPED_FUNCS in self.flags)
         self.states = []  # type: List[State]
         self.module_files = {}  # type: Dict[str, str]
         self.module_deps = {}  # type: Dict[Tuple[str, str], bool]

mypy/checker.py

@@ -366,10 +366,12 @@ class TypeChecker(NodeVisitor[Type]):
     current_node_deferred = False
     # This makes it an error to call an untyped function from a typed one
     disallow_untyped_calls = False
+    # This makes it an error to define an untyped or partially-typed function
+    disallow_untyped_funcs = False
 
     def __init__(self, errors: Errors, modules: Dict[str, MypyFile],
                  pyversion: Tuple[int, int] = defaults.PYTHON3_VERSION,
-                 disallow_untyped_calls=False) -> None:
+                 disallow_untyped_calls=False, disallow_untyped_funcs=False) -> None:
         """Construct a type checker.
 
         Use errors to report type check errors. Assume symtable has been
@@ -393,6 +395,7 @@ def __init__(self, errors: Errors, modules: Dict[str, MypyFile],
         self.pass_num = 0
         self.current_node_deferred = False
         self.disallow_untyped_calls = disallow_untyped_calls
+        self.disallow_untyped_funcs = disallow_untyped_funcs
 
     def visit_file(self, file_node: MypyFile, path: str) -> None:
         """Type check a mypy file with the given path."""
@@ -658,6 +661,20 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: str) -> None:
                     self.fail(messages.INIT_MUST_HAVE_NONE_RETURN_TYPE,
                               item.type)
 
+                if self.disallow_untyped_funcs:
+                    # Check for functions with unspecified/not fully specified types.
+                    def is_implicit_any(t: Type) -> bool:
+                        return isinstance(t, AnyType) and t.implicit
+
+                    if fdef.type is None:
+                        self.fail(messages.FUNCTION_TYPE_EXPECTED, fdef)
+                    elif isinstance(fdef.type, CallableType):
+                        if is_implicit_any(fdef.type.ret_type):
+                            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 name in nodes.reverse_op_method_set:
                 self.check_reverse_op_method(item, typ, name)
             elif name == '__getattr__':

mypy/main.py

@@ -180,6 +180,9 @@ def process_options(args: List[str]) -> Tuple[List[BuildSource], Options]:
         elif args[0] == '--disallow-untyped-calls':
             options.build_flags.append(build.DISALLOW_UNTYPED_CALLS)
             args = args[1:]
+        elif args[0] == '--disallow-untyped-functions':
+            options.build_flags.append(build.DISALLOW_UNTYPED_FUNCS)
+            args = args[1:]
         elif args[0] in ('--version', '-V'):
             ver = True
             args = args[1:]
@@ -315,6 +318,8 @@ def usage(msg: str = None) -> None:
   -s, --silent-imports  don't follow imports to .py files
   --disallow-untyped-calls  disallow calling functions without type annotations
                             from functions with type annotations
+  --disallow-untyped-funcs  disallow defining functions without type annotations
+                            or with incomplete type annotations
   --implicit-any     behave as though all functions were annotated with Any
   -f, --dirty-stubs  don't warn if typeshed is out of sync
   --pdb              invoke pdb on fatal error

mypy/messages.py

@@ -73,6 +73,9 @@
 RETURN_TYPE_CANNOT_BE_CONTRAVARIANT = "Cannot use a contravariant type variable as return type"
 FUNCTION_PARAMETER_CANNOT_BE_COVARIANT = "Cannot use a covariant type variable as a parameter"
 INCOMPATIBLE_IMPORT_OF = "Incompatible import of"
+FUNCTION_TYPE_EXPECTED = "Function is missing a type annotation"
+RETURN_TYPE_EXPECTED = "Function is missing a return type annotation"
+ARGUMENT_TYPE_EXPECTED = "Function is missing a type annotation for one or more arguments"
 
 
 class MessageBuilder:

mypy/parse.py

@@ -477,8 +477,8 @@ def parse_function(self, no_type_checks: bool=False) -> FuncDef:
                 if is_method and name == '__init__':
                     ret_type = UnboundType('None', [])
                 else:
-                    ret_type = AnyType()
-                typ = CallableType([AnyType() for _ in args],
+                    ret_type = AnyType(implicit=True)
+                typ = CallableType([AnyType(implicit=True) for _ in args],
                                    arg_kinds,
                                    [a.variable.name() for a in args],
                                    ret_type,
@@ -812,9 +812,9 @@ def construct_function_type(self, args: List[Argument], ret_type: Type,
         arg_types = [arg.type_annotation for arg in args]
         for i in range(len(arg_types)):
             if arg_types[i] is None:
-                arg_types[i] = AnyType()
+                arg_types[i] = AnyType(implicit=True)
         if ret_type is None:
-            ret_type = AnyType()
+            ret_type = AnyType(implicit=True)
         arg_kinds = [arg.kind for arg in args]
         arg_names = [arg.variable.name() for arg in args]
         return CallableType(arg_types, arg_kinds, arg_names, ret_type, None, name=None,

mypy/types.py

@@ -102,6 +102,10 @@ def accept(self, visitor: 'TypeVisitor[T]') -> T:
 class AnyType(Type):
     """The type 'Any'."""
 
+    def __init__(self, implicit=False, line: int = -1) -> None:
+        super().__init__(line)
+        self.implicit = implicit
+
     def accept(self, visitor: 'TypeVisitor[T]') -> T:
         return visitor.visit_any(self)