Start adding a protocol checker for the async features added in PEP 492:

   * this patch adds the basis of a new checker, 'async', which deals
     with problems that can occur when working with async features added
     in Python with PEP 492.

   * We're also adding a new error, 'yield-inside-async-function', emitted on
     Python 3.5 and upwards when the `yield` statement is found inside
     a new coroutine function (PEP 492).

   * Another new error is added, 'not-async-context-manager', emitted when
     an async context manager block is used with an object which doesn't
     support this protocol (PEP 492).

Author: PCManticore

ChangeLog

@@ -309,6 +309,16 @@ ChangeLog for Pylint
       This fixes a false positive related to abstract-class-instantiated.
       Closes issue #648.
 
+    * Add a new checker for the async features added by PEP 492.
+
+    * Add a new error, 'yield-inside-async-function', emitted on
+      Python 3.5 and upwards when the `yield` statement is found inside
+      a new coroutine function (PEP 492).
+
+    * Add a new error, 'not-async-context-manager', emitted when
+      an async context manager block is used with an object which doesn't
+      support this protocol (PEP 492).
+
 
 
 2015-03-14 -- 1.4.3

pylint/checkers/async.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2003-2015 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:[email protected]
+# Copyright (c) 2009-2010 Arista Networks, Inc.
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+"""Checker for anything related to the async protocol (PEP 492)."""
+
+import astroid
+from astroid import exceptions
+from astroid import helpers
+
+from pylint import checkers
+from pylint.checkers import utils as checker_utils
+from pylint import interfaces
+from pylint import utils
+
+
+class AsyncChecker(checkers.BaseChecker):
+    __implements__ = interfaces.IAstroidChecker
+    name = 'async'
+    msgs = {
+        'E1700': ('Yield inside async function',
+                  'yield-inside-async-function',
+                  'Used when an `yield` or `yield from` statement is '
+                  'found inside an async function.',
+                  {'minversion': (3, 5)}),
+        'E1701': ("Async context manager '%s' doesn't implement __aenter__ and __aexit__.",
+                  'not-async-context-manager',
+                  'Used when an async context manager is used with an object '
+                  'that does not implement the async context management protocol.',
+                  {'minversion': (3, 5)}),
+    }
+
+    def open(self):
+        self._ignore_mixin_members = utils.get_global_option(self, 'ignore-mixin-members')
+
+    @checker_utils.check_messages('yield-inside-async-function')
+    def visit_asyncfunctiondef(self, node):
+        for child in node.nodes_of_class(astroid.Yield):
+            if child.scope() is node:
+                self.add_message('yield-inside-async-function', node=child)
+
+    @checker_utils.check_messages('not-async-context-manager')
+    def visit_asyncwith(self, node):
+        for ctx_mgr, _ in node.items:
+            infered = helpers.safe_infer(ctx_mgr)
+            if infered is None or infered is astroid.YES:
+                continue
+
+            if isinstance(infered, astroid.Instance):
+                try:
+                    infered.getattr('__aenter__')
+                    infered.getattr('__aexit__')
+                except exceptions.NotFoundError:
+                    if isinstance(infered, astroid.Instance):
+                        # If we do not know the bases of this class,
+                        # just skip it.
+                        if not helpers.has_known_bases(infered):
+                            continue
+                        # Just ignore mixin classes.
+                        if self._ignore_mixin_members:
+                            if infered.name[-5:].lower() == 'mixin':
+                                continue
+                else:
+                    continue
+
+            self.add_message('not-async-context-manager',
+                             node=node, args=(infered.name, ))
+
+
+def register(linter):
+    """required method to auto register this checker"""
+    linter.register_checker(AsyncChecker(linter))

pylint/test/functional/not_async_context_manager.py

@@ -0,0 +1,71 @@
+"""Test that an async context manager receives a proper object."""
+# pylint: disable=missing-docstring, import-error, too-few-public-methods
+import contextlib
+
+from ala import Portocala
+
+
+@contextlib.contextmanager
+def ctx_manager():
+    yield
+
+
+class ContextManager(object):
+    def __enter__(self):
+        pass
+    def __exit__(self, *args):
+        pass
+
+class PartialAsyncContextManager(object):
+    def __aenter__(self):
+        pass
+
+class SecondPartialAsyncContextManager(object):
+    def __aexit__(self, *args):
+        pass
+
+class UnknownBases(Portocala):
+    def __aenter__(self):
+        pass
+
+
+class AsyncManagerMixin(object):
+    pass
+
+class GoodAsyncManager(object):
+    def __aenter__(self):
+        pass
+    def __aexit__(self, *args):
+        pass
+
+class InheritExit(object):
+    def __aexit__(self, *args):
+        pass
+
+class SecondGoodAsyncManager(InheritExit):
+    def __aenter__(self):
+        pass
+
+
+async def bad_coro():
+    async with 42: # [not-async-context-manager]
+        pass
+    async with ctx_manager(): # [not-async-context-manager]
+        pass
+    async with ContextManager(): # [not-async-context-manager]
+        pass
+    async with PartialAsyncContextManager(): # [not-async-context-manager]
+        pass
+    async with SecondPartialAsyncContextManager(): # [not-async-context-manager]
+        pass
+
+
+async def good_coro():
+    async with UnknownBases():
+        pass
+    async with AsyncManagerMixin():
+        pass
+    async with GoodAsyncManager():
+        pass
+    async with SecondGoodAsyncManager():
+        pass

pylint/test/functional/not_async_context_manager.rc

@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5

pylint/test/functional/not_async_context_manager.txt

@@ -0,0 +1,5 @@
+not-async-context-manager:51:bad_coro:Async context manager 'int' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:53:bad_coro:Async context manager 'generator' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:55:bad_coro:Async context manager 'ContextManager' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:57:bad_coro:Async context manager 'PartialAsyncContextManager' doesn't implement __aenter__ and __aexit__.
+not-async-context-manager:59:bad_coro:Async context manager 'SecondPartialAsyncContextManager' doesn't implement __aenter__ and __aexit__.

pylint/test/functional/yield_inside_async_function.py

@@ -0,0 +1,12 @@
+"""Test that `yield` or `yield from` can't be used inside an async function."""
+# pylint: disable=missing-docstring
+
+async def good_coro():
+    def _inner():
+        yield 42
+        yield from [1, 2, 3]
+
+
+async def bad_coro():
+    yield 42 # [yield-inside-async-function]
+    yield from [1, 2, 3] # [yield-inside-async-function]

pylint/test/functional/yield_inside_async_function.rc

@@ -0,0 +1,2 @@
+[testoptions]
+min_pyver=3.5

pylint/test/functional/yield_inside_async_function.txt

@@ -0,0 +1,2 @@
+yield-inside-async-function:11:bad_coro:Yield inside async function
+yield-inside-async-function:12:bad_coro:Yield inside async function