Refactor various typing related issues

doc/how_tos/custom_checkers.rst

@@ -117,14 +117,14 @@ Next we'll track when we enter and leave a function.
 
 .. code-block:: python
 
-  def __init__(self, linter=None):
+  def __init__(self, linter: PyLinter =None) -> None:
       super(UniqueReturnChecker, self).__init__(linter)
       self._function_stack = []
 
-  def visit_functiondef(self, node):
+  def visit_functiondef(self, node: nodes.FunctioDef) -> None:
       self._function_stack.append([])
 
-  def leave_functiondef(self, node):
+  def leave_functiondef(self, node: nodes.FunctionDef) -> None:
       self._function_stack.pop()
 
 In the constructor we initialise a stack to keep a list of return nodes
@@ -138,13 +138,13 @@ and to remove the list of return nodes when we leave the function.
 
 Finally we'll implement the check.
 We will define a ``visit_return`` function,
-which is called with a :class:`.astroid.node_classes.Return` node.
+which is called with a :class:`.astroid.nodes.Return` node.
 
 .. _astroid_extract_node:
 .. TODO We can shorten/remove this bit once astroid has API docs.
 
 We'll need to be able to figure out what attributes a
-:class:`.astroid.node_classes.Return` node has available.
+:class:`.astroid.nodes.Return` node has available.
 We can use :func:`astroid.extract_node` for this::
 
   >>> node = astroid.extract_node("return 5")
@@ -178,8 +178,8 @@ Now we know how to use the astroid node, we can implement our check.
 
 .. code-block:: python
 
-  def visit_return(self, node):
-      if not isinstance(node.value, astroid.node_classes.Const):
+  def visit_return(self, node: nodes.Return) -> None:
+      if not isinstance(node.value, nodes.Const):
           return
 
       for other_return in self._function_stack[-1]:

pylint/checkers/async.py

@@ -46,15 +46,15 @@ def open(self):
         self._async_generators = ["contextlib.asynccontextmanager"]
 
     @checker_utils.check_messages("yield-inside-async-function")
-    def visit_asyncfunctiondef(self, node):
+    def visit_asyncfunctiondef(self, node: nodes.AsyncFunctionDef) -> None:
         for child in node.nodes_of_class(nodes.Yield):
             if child.scope() is node and (
                 sys.version_info[:2] == (3, 5) or isinstance(child, nodes.YieldFrom)
             ):
                 self.add_message("yield-inside-async-function", node=child)
 
     @checker_utils.check_messages("not-async-context-manager")
-    def visit_asyncwith(self, node):
+    def visit_asyncwith(self, node: nodes.AsyncWith) -> None:
         for ctx_mgr, _ in node.items:
             inferred = checker_utils.safe_infer(ctx_mgr)
             if inferred is None or inferred is astroid.Uninferable: