fix(core): async return instruction usage (#1414)

This commit fixes a few issues in the async return machinery:

1. `Instruction::Return` calculation of `amt` for functions with no
return values

2. Missing use of `Instruction::AsyncTaskReturn`

3. Determination of whether to pass a pointer or flat params for async functions

Both issues were in the function with no result case:

For (1), the code did not take into account that the async
functions *always* return at least the async state (a single i64).

For (2), the code did not use an `Instruction::AsyncTaskReturn`, rather
than a regular `Instruction::Return`

For (3), the code did not take into account whether the number of
results was lower than the max flattened values or not

Author: vados-cosmonic

crates/core/src/abi.rs

@@ -1271,7 +1271,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                         self.emit(&Instruction::AsyncTaskReturn { name, params });
                     }
 
-                    // All async/non-async cases with results that need to be returned are present here
+                    // All async/non-async cases with results that need to be returned
                     //
                     // In practice, async imports should not end up here, as the returned result of an
                     // async import is *not* a pointer but instead a status code.
@@ -1281,14 +1281,24 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                         self.emit(&Instruction::AsyncTaskReturn { name, params });
                     }
 
-                    // All async/non-async cases with no results simply return
-                    //
-                    // In practice, an async import will never get here (it always has a result, the error code)
+                    // All async/non-async cases with no results
                     (_, None) => {
-                        self.emit(&Instruction::Return {
-                            func,
-                            amt: sig.results.len(),
-                        });
+                        if async_ {
+                            let name = &format!("[task-return]{}", func.name);
+                            self.emit(&Instruction::AsyncTaskReturn {
+                                name: name,
+                                params: if sig.results.len() > MAX_FLAT_ASYNC_PARAMS {
+                                    &[WasmType::Pointer]
+                                } else {
+                                    &sig.results
+                                },
+                            });
+                        } else {
+                            self.emit(&Instruction::Return {
+                                func,
+                                amt: sig.results.len(),
+                            });
+                        }
                     }
                 }