rename is_coroutine_generator -> is_async_generator, implement is_async_generator_return_type

Author: JelleZijlstra

mypy/checker.py

@@ -334,12 +334,19 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
     # for functions decorated with `@types.coroutine` or
     # `@asyncio.coroutine`.  Its single parameter corresponds to tr.
     #
+    # PEP 525 adds a new type, the asynchronous generator, which was
+    # first released in Python 3.6. Async generators are `async def`
+    # functions that can also `yield` values. They can be parameterized
+    # with two types, ty and tc, because they cannot return a value.
+    #
     # There are several useful methods, each taking a type t and a
     # flag c indicating whether it's for a generator or coroutine:
     #
     # - is_generator_return_type(t, c) returns whether t is a Generator,
     #   Iterator, Iterable (if not c), or Awaitable (if c), or
     #   AwaitableGenerator (regardless of c).
+    # - is_async_generator_return_type(t) returns whether t is an
+    #   AsyncGenerator.
     # - get_generator_yield_type(t, c) returns ty.
     # - get_generator_receive_type(t, c) returns tc.
     # - get_generator_return_type(t, c) returns tr.
@@ -361,6 +368,14 @@ def is_generator_return_type(self, typ: Type, is_coroutine: bool) -> bool:
                 return True
         return isinstance(typ, Instance) and typ.type.fullname() == 'typing.AwaitableGenerator'
 
+    def is_async_generator_return_type(self, typ: Type) -> bool:
+        """Is `typ` a valid type for an async generator?
+
+        True if `typ` is a supertype of AsyncGenerator.
+        """
+        agt = self.named_generic_type('typing.AsyncGenerator', [AnyType(), AnyType()])
+        return is_subtype(agt, typ)
+
     def get_generator_yield_type(self, return_type: Type, is_coroutine: bool) -> Type:
         """Given the declared return type of a generator (t), return the type it yields (ty)."""
         if isinstance(return_type, AnyType):
@@ -569,9 +584,9 @@ def is_implicit_any(t: Type) -> bool:
 
                 # Check that Generator functions have the appropriate return type.
                 if defn.is_generator:
-                    if defn.is_coroutine:
+                    if defn.is_async_generator:
                         if not self.is_async_generator_return_type(typ.ret_type):
-                            pass
+                            self.fail(messages.INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR, typ)
                     else:
                         if not self.is_generator_return_type(typ.ret_type, defn.is_coroutine):
                             self.fail(messages.INVALID_RETURN_TYPE_FOR_GENERATOR, typ)

mypy/nodes.py

@@ -465,15 +465,15 @@ class FuncItem(FuncBase):
     is_overload = False
     is_generator = False   # Contains a yield statement?
     is_coroutine = False   # Defined using 'async def' syntax?
-    is_coroutine_generator = False  # Is an async def generator?
+    is_async_generator = False  # Is an async def generator?
     is_awaitable_coroutine = False  # Decorated with '@{typing,asyncio}.coroutine'?
     is_static = False      # Uses @staticmethod?
     is_class = False       # Uses @classmethod?
     # Variants of function with type variables with values expanded
     expanded = None  # type: List[FuncItem]
 
     FLAGS = [
-        'is_overload', 'is_generator', 'is_coroutine', 'is_coroutine_generator',
+        'is_overload', 'is_generator', 'is_coroutine', 'is_async_generator',
         'is_awaitable_coroutine', 'is_static', 'is_class',
     ]
 

mypy/semanal.py

@@ -318,7 +318,7 @@ def visit_func_def(self, defn: FuncDef) -> None:
             self.errors.push_function(defn.name())
             self.analyze_function(defn)
             if defn.is_coroutine and isinstance(defn.type, CallableType):
-                if defn.is_coroutine_generator:
+                if defn.is_async_generator:
                     # Async generator types are handled elsewhere
                     pass
                 else:
@@ -2540,7 +2540,7 @@ def visit_yield_expr(self, expr: YieldExpr) -> None:
                     self.fail("'yield' in async function", expr, True, blocker=True)
                 else:
                     self.function_stack[-1].is_generator = True
-                    self.function_stack[-1].is_coroutine_generator = True
+                    self.function_stack[-1].is_async_generator = True
             else:
                 self.function_stack[-1].is_generator = True
         if expr.expr: