Address docparser review notes.

- simplify and improve registration of mypy.hooks
- do not call cleandoc (that's up to the hook user)
- doc parser hooks must return strings and not Type

Author: chadrik

mypy/fastparse.py

@@ -1,6 +1,5 @@
 from functools import wraps
 import sys
-import inspect
 
 from typing import Tuple, Union, TypeVar, Callable, Sequence, Optional, Any, cast, List
 from mypy.nodes import (
@@ -100,14 +99,11 @@ def pop_and_convert(name):
         t = type_map.pop(name, None)
         if t is None:
             return AnyType()
-        elif isinstance(t, Type):
-            return t
         else:
             return parse_str_as_type(t, line)
 
-    docstring_parser = hooks.get_docstring_parser()
-    if docstring_parser is not None:
-        type_map = docstring_parser(inspect.cleandoc(docstring), line)
+    if hooks.docstring_parser is not None:
+        type_map = hooks.docstring_parser(docstring)
         if type_map:
             arg_types = [pop_and_convert(name) for name in arg_names]
             return_type = pop_and_convert('return')
@@ -323,10 +319,9 @@ def do_func_def(self, n: Union[ast35.FunctionDef, ast35.AsyncFunctionDef],
             return_type = TypeConverter(line=n.lineno).visit(n.returns)
             # hooks
             if (not any(arg_types) and return_type is None and
-                    hooks.get_docstring_parser()):
+                    hooks.docstring_parser):
                 doc = ast35.get_docstring(n, clean=False)
                 if doc:
-                    doc = doc.decode('unicode_escape')
                     types = parse_docstring(doc, arg_names, n.lineno)
                     if types is not None:
                         arg_types, return_type = types

mypy/fastparse2.py

@@ -298,8 +298,8 @@ def visit_FunctionDef(self, n: ast27.FunctionDef) -> Statement:
             return_type = converter.visit(None)
             # hooks
             if (not any(arg_types) and return_type is None and
-                    hooks.get_docstring_parser()):
-                doc = ast27.get_docstring(n, clean=False)
+                    hooks.docstring_parser):
+                doc = cast(bytes, ast27.get_docstring(n, clean=False))
                 if doc:
                     doc = doc.decode('unicode_escape')
                     types = parse_docstring(doc, arg_names, n.lineno)

mypy/hooks.py

@@ -1,28 +1,13 @@
-from typing import Dict, Optional, Callable, Union
-from mypy.types import Type
-
-hooks = {}  # type: Dict[str, Callable]
-
-docstring_parser_type = Callable[[str, int], Optional[Dict[str, Union[str, Type]]]]
-
-
-def set_docstring_parser(func: docstring_parser_type) -> None:
-    """Enable the docstring parsing hook.
-
-    The callable must take a docstring for a function along with its line number
-    (typically passed to mypy.parsetype.parse_str_as_type), and should return
-    a mapping of argument name to type. The function's return type, if
-    specified, is stored in the mapping with the special key 'return'.
-
-    The keys of the mapping must be a subset of the arguments of the function
-    to which the docstring belongs (other than the special 'return'
-    key); an error will be raised if the mapping contains stray arguments.
-
-    The values of the mapping must be either mypy.types.Type or a valid
-    PEP484-compatible string which can be converted to a Type.
-    """
-    hooks['docstring_parser'] = func
-
-
-def get_docstring_parser() -> Optional[docstring_parser_type]:
-    return hooks.get('docstring_parser')
+from typing import Dict, Optional, Callable
+
+# The docstring_parser hook is called for each function that has a docstring
+# and no other type annotations applied, and the callable should accept the
+# docstring as an argument and return a mapping of argument name to type.
+#
+# The function's return type, if specified, is stored in the mapping with the
+# special key 'return'.  Other than 'return', the keys of the mapping must be
+# a subset of the arguments of the function to which the docstring belongs; an
+# error will be raised if the mapping contains stray arguments.
+#
+# The values of the mapping must be valid PEP484-compatible strings.
+docstring_parser = None  # type: Callable[[str], Optional[Dict[str, str]]]