make run_cell_async a regular coroutine

separate "should it be async" to a `should_run_async` public method

Author: minrk

IPython/core/interactiveshell.py

@@ -2815,32 +2815,74 @@ def _run_cell(self, raw_cell:str, store_history:bool, silent:bool, shell_futures
             shell_futures=shell_futures,
         )
 
-        # run_cell_async is async, but may not actually need and eventloop.
+        # run_cell_async is async, but may not actually need an eventloop.
         # when this is the case, we want to run it using the pseudo_sync_runner
         # so that code can invoke eventloops (for example via the %run , and
         # `%paste` magic.
+        if self.should_run_async(raw_cell):
+            runner = self.loop_runner
+        else:
+
+            runner = _pseudo_sync_runner
+
         try:
-            interactivity = coro.send(None)
-        except StopIteration as exc:
-            return exc.value
+            return runner(coro)
+        except Exception as e:
+            info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
+            result = ExecutionResult(info)
+            result.error_in_exec = e
+            self.showtraceback(running_compiled_code=True)
+            return result
+        return
 
-        # if code was not async, sending `None` was actually executing the code.
-        if isinstance(interactivity, ExecutionResult):
-            return interactivity
+    def should_run_async(self, raw_cell: str) -> bool:
+        """Return whether a cell should be run asynchronously
 
-        if interactivity == 'async':
-            try:
-                return self.loop_runner(coro)
-            except Exception as e:
-                info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
-                result = ExecutionResult(info)
-                result.error_in_exec = e
-                self.showtraceback(running_compiled_code=True)
-                return result
-        return _pseudo_sync_runner(coro)
+        Parameters
+        ----------
+        cell: str
+            The code to be executed
+
+        Returns
+        -------
+        result: bool
+            Whether the code should be run asynchronously or not
+        """
+        if not self.autoawait:
+            return False
+        try:
+            cell = self.transform_cell(raw_cell)
+        except Exception:
+            # any exception during transform will be raised
+            # prior to execution
+            return False
+        return _should_be_async(cell)
+
+    def transform_cell(self, raw_cell: str) -> str:
+        """Transform a raw cell into Python code to be executed
+
+        Parameters
+        ----------
+        raw_cell: str
+            The IPython-syntax code to be executed
+
+        Returns
+        -------
+        cell: str
+            Transformed Python code to be executed
+        """
+        # Static input transformations
+        cell = self.input_transformer_manager.transform_cell(raw_cell)
+        if len(cell.splitlines()) == 1:
+            # Dynamic transformations - only applied for single line commands
+            with self.builtin_trap:
+                # use prefilter_lines to handle trailing newlines
+                # restore trailing newline for ast.parse
+                cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
+        return cell
 
     @asyncio.coroutine
-    def run_cell_async(self, raw_cell:str, store_history=False, silent=False, shell_futures=True) -> ExecutionResult:
+    def run_cell_async(self, raw_cell: str, store_history=False, silent=False, shell_futures=True) -> ExecutionResult:
         """Run a complete IPython cell asynchronously.
 
         Parameters
@@ -2895,24 +2937,13 @@ def error_before_exec(value):
         # prefilter_manager) raises an exception, we store it in this variable
         # so that we can display the error after logging the input and storing
         # it in the history.
-        preprocessing_exc_tuple = None
         try:
-            # Static input transformations
-            cell = self.input_transformer_manager.transform_cell(raw_cell)
-        except SyntaxError:
+            cell = self.transform_cell(raw_cell)
+        except Exception:
+            cell = raw_cell
             preprocessing_exc_tuple = sys.exc_info()
-            cell = raw_cell  # cell has to exist so it can be stored/logged
         else:
-            if len(cell.splitlines()) == 1:
-                # Dynamic transformations - only applied for single line commands
-                with self.builtin_trap:
-                    try:
-                        # use prefilter_lines to handle trailing newlines
-                        # restore trailing newline for ast.parse
-                        cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
-                    except Exception:
-                        # don't allow prefilter errors to crash IPython
-                        preprocessing_exc_tuple = sys.exc_info()
+            preprocessing_exc_tuple = None
 
         # Store raw and processed history
         if store_history:
@@ -2941,7 +2972,7 @@ def error_before_exec(value):
             with self.display_trap:
                 # Compile to bytecode
                 try:
-                    if self.autoawait and _should_be_async(cell):
+                    if self.should_run_async(cell):
                         # the code AST below will not be user code: we wrap it
                         # in an `async def`. This will likely make some AST
                         # transformer below miss some transform opportunity and
@@ -2987,12 +3018,10 @@ def error_before_exec(value):
                 interactivity = "none" if silent else self.ast_node_interactivity
                 if _run_async:
                     interactivity = 'async'
-                # yield interactivity so let run_cell decide whether to use
-                # an async loop_runner
-                yield interactivity
+
                 has_raised = yield from self.run_ast_nodes(code_ast.body, cell_name,
                        interactivity=interactivity, compiler=compiler, result=result)
-                
+
                 self.last_execution_succeeded = not has_raised
                 self.last_execution_result = result
 
@@ -3008,7 +3037,7 @@ def error_before_exec(value):
             self.execution_count += 1
 
         return result
-    
+
     def transform_ast(self, node):
         """Apply the AST transformations from self.ast_transformers