add tests for mixed async-def

Author: carljm

conformance/results/mypy/overloads_consistency.toml

@@ -4,5 +4,5 @@ errors_diff = """
 """
 output = """
 overloads_consistency.py:27: error: Overloaded function implementation cannot produce return type of signature 2  [misc]
-overloads_consistency.py:42: error: Overloaded function implementation does not accept all possible arguments of signature 2  [misc]
+overloads_consistency.py:43: error: Overloaded function implementation does not accept all possible arguments of signature 2  [misc]
 """

conformance/results/pyre/overloads_consistency.toml

@@ -4,5 +4,5 @@ errors_diff = """
 """
 output = """
 overloads_consistency.py:24:0 Incompatible overload [43]: The return type of overloaded function `return_type` (`str`) is incompatible with the return type of the implementation (`int`).
-overloads_consistency.py:39:0 Incompatible overload [43]: The implementation of `parameter_type` does not accept all possible arguments of overload defined on line `39`.
+overloads_consistency.py:40:0 Incompatible overload [43]: The implementation of `parameter_type` does not accept all possible arguments of overload defined on line `40`.
 """

conformance/results/pyre/version.toml

@@ -1,2 +1,2 @@
 version = "pyre 0.9.23"
-test_duration = 6.6
+test_duration = 6.5

conformance/results/pyright/overloads_consistency.toml

@@ -6,7 +6,7 @@ output = """
 overloads_consistency.py:27:5 - error: Overloaded implementation is not consistent with signature of overload 2
   Function return type "str" is incompatible with type "int"
     "str" is not assignable to "int" (reportInconsistentOverload)
-overloads_consistency.py:42:5 - error: Overloaded implementation is not consistent with signature of overload 2
+overloads_consistency.py:43:5 - error: Overloaded implementation is not consistent with signature of overload 2
   Type "(x: int) -> (int | str)" is not assignable to type "(x: str) -> str"
     Parameter 1: type "str" is incompatible with type "int"
       "str" is not assignable to "int" (reportInconsistentOverload)

conformance/results/pytype/overloads_consistency.toml

@@ -5,19 +5,36 @@ Doesn't appear to validate overload consistency at all.
 conformance_automated = "Fail"
 errors_diff = """
 Lines 24, 27: Expected error (tag 'return_type')
-Lines 39, 42: Expected error (tag 'parameter_type')
+Lines 40, 43: Expected error (tag 'parameter_type')
 Line 28: Unexpected errors ['overloads_consistency.py:28:12: \\x1b[1m\\x1b[31merror\\x1b[39m\\x1b[0m: in return_type: bad return type [bad-return-type]']
-Line 43: Unexpected errors ['overloads_consistency.py:43:12: \\x1b[1m\\x1b[31merror\\x1b[39m\\x1b[0m: in parameter_type: bad return type [bad-return-type]']
+Line 44: Unexpected errors ['overloads_consistency.py:44:12: \\x1b[1m\\x1b[31merror\\x1b[39m\\x1b[0m: in parameter_type: bad return type [bad-return-type]']
+Line 73: Unexpected errors ['overloads_consistency.py:73:12: \\x1b[1m\\x1b[31merror\\x1b[39m\\x1b[0m: in returns_coroutine: bad return type [bad-return-type]']
+Line 88: Unexpected errors ['overloads_consistency.py:88:5: \\x1b[1m\\x1b[31merror\\x1b[39m\\x1b[0m: in returns_coroutine_2: bad return type [bad-return-type]', 'overloads_consistency.py:88:5: \\x1b[1m\\x1b[31merror\\x1b[39m\\x1b[0m: in returns_coroutine_2: bad return type [bad-return-type]']
 """
 output = """
 overloads_consistency.py:28:12: \u001b[1m\u001b[31merror\u001b[39m\u001b[0m: in return_type: bad return type [bad-return-type]
 
     return 1
            \u001b[1m\u001b[31m~\u001b[39m\u001b[0m
 
-overloads_consistency.py:43:12: \u001b[1m\u001b[31merror\u001b[39m\u001b[0m: in parameter_type: bad return type [bad-return-type]
+overloads_consistency.py:44:12: \u001b[1m\u001b[31merror\u001b[39m\u001b[0m: in parameter_type: bad return type [bad-return-type]
 
     return 1
            \u001b[1m\u001b[31m~\u001b[39m\u001b[0m
 
+overloads_consistency.py:73:12: \u001b[1m\u001b[31merror\u001b[39m\u001b[0m: in returns_coroutine: bad return type [bad-return-type]
+
+    return 1
+           \u001b[1m\u001b[31m~\u001b[39m\u001b[0m
+
+overloads_consistency.py:88:5: \u001b[1m\u001b[31merror\u001b[39m\u001b[0m: in returns_coroutine_2: bad return type [bad-return-type]
+
+    return _wrapped(x)
+    \u001b[1m\u001b[31m~~~~~~~~~~~~~~~~~~\u001b[39m\u001b[0m
+
+overloads_consistency.py:88:5: \u001b[1m\u001b[31merror\u001b[39m\u001b[0m: in returns_coroutine_2: bad return type [bad-return-type]
+
+    return _wrapped(x)
+    \u001b[1m\u001b[31m~~~~~~~~~~~~~~~~~~\u001b[39m\u001b[0m
+
 """

conformance/results/pytype/version.toml

@@ -1,2 +1,2 @@
 version = "pytype 2024.10.11"
-test_duration = 30.3
+test_duration = 30.1

conformance/results/results.html

@@ -165,10 +165,10 @@ <h3>Python Type System Conformance Test Results</h3>
 <div class='tc-time'>1.5sec</div>
 </th>
 <th class='tc-header'><div class='tc-name'>pyre 0.9.23</div>
-<div class='tc-time'>6.6sec</div>
+<div class='tc-time'>6.5sec</div>
 </th>
 <th class='tc-header'><div class='tc-name'>pytype 2024.10.11</div>
-<div class='tc-time'>30.3sec</div>
+<div class='tc-time'>30.1sec</div>
 </th>
 </tr>
 <tr><th class="column" colspan="5">
@@ -673,10 +673,10 @@ <h3>Python Type System Conformance Test Results</h3>
 <th class="column col2 partially-conformant">Partial</th>
 </tr>
 <tr><th class="column col1">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;overloads_consistency</th>
-<th class="column col2 not-conformant">Unknown</th>
-<th class="column col2 not-conformant">Unknown</th>
-<th class="column col2 not-conformant">Unknown</th>
-<th class="column col2 not-conformant">Unknown</th>
+<th class="column col2 conformant">Pass</th>
+<th class="column col2 conformant">Pass</th>
+<th class="column col2 conformant">Pass</th>
+<th class="column col2 not-conformant"><div class="hover-text">Fail<span class="tooltip-text" id="bottom"><p>Doesn't appear to validate overload consistency at all.</p></span></div></th>
 </tr>
 <tr><th class="column col1">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;overloads_definitions</th>
 <th class="column col2 partially-conformant"><div class="hover-text">Partial<span class="tooltip-text" id="bottom"><p>Does not allow an overload with no implementation in an abstract base class.</p><p>Allows @override to be on all overloads and implementation, instead of just implementation.</p></span></div></th>

conformance/tests/overloads_consistency.py

@@ -2,7 +2,7 @@
 Tests consistency of overloads with implementation.
 """
 
-from typing import overload
+from typing import Coroutine, overload
 
 # > If an overload implementation is defined, type checkers should validate
 # > that it is consistent with all of its associated overload signatures.
@@ -29,7 +29,8 @@ def return_type(x: int | str) -> int:  # E[return_type] an overload returns `str
 
 
 # Input signature of implementation must be assignable to signature of each
-# overload:
+# overload. We don't attempt a thorough testing of input signature
+# assignability here; see `callables_subtyping.py` for that:
 
 @overload
 def parameter_type(x: int) -> int:
@@ -41,3 +42,50 @@ def parameter_type(x: str) -> str:  # E[parameter_type]
 
 def parameter_type(x: int) -> int | str:  # E[parameter_type] impl type of `x` must be assignable from overload types of `x`
     return 1
+
+
+# > Overloads are allowed to use a mixture of ``async def`` and ``def`` statements
+# > within the same overload definition. Type checkers should convert
+# > ``async def`` statements to a non-async signature (wrapping the return
+# > type in a ``Coroutine``) before testing for implementation consistency
+# > and overlapping overloads (described below).
+
+# ...and also...
+
+# > When a type checker checks the implementation for consistency with overloads,
+# > it should first apply any transforms that change the effective type of the
+# > implementation including the presence of a ``yield`` statement in the
+# > implementation body, the use of ``async def``, and the presence of additional
+# > decorators.
+
+# An overload can explicitly return `Coroutine`, while the implementation is an
+# `async def`:
+
+@overload
+def returns_coroutine(x: int) -> Coroutine[None, None, int]:
+    ...
+
+@overload
+async def returns_coroutine(x: str) -> str:
+    ...
+
+async def returns_coroutine(x: int | str) -> int | str:
+    return 1
+
+
+# The implementation can explicitly return `Coroutine`, while overloads are
+# `async def`:
+
+@overload
+async def returns_coroutine_2(x: int) -> int:
+    ...
+
+@overload
+async def returns_coroutine_2(x: str) -> str:
+    ...
+
+def returns_coroutine_2(x: int | str) -> Coroutine[None, None, int | str]:
+    return _wrapped(x)
+
+async def _wrapped(x: int | str) -> int | str:
+    return 2