fix(bindgen): fix task.return param spill check

Author: vados-cosmonic

crates/js-component-bindgen/src/intrinsics/lift.rs

@@ -842,25 +842,41 @@ impl LiftIntrinsic {
 
                             let liftResults;
                             if (knownLen !== undefined) {{ // list with known length
-
                                 if (ctx.useDirectParams) {{
-                                    // list with known length w/ direct params
-                                    const dataPtr = ctx.params[0];
-                                    ctx.params = ctx.params.slice(1);
-
-                                    // TODO(???): is it possible for all values to come in from params?
+                                    if (ctx.memory === null) {{
+                                        // If this lift should be using direct params,
+                                        // and the memory is missing, we are in the case where
+                                        // a fixed length list (or other value) is being passed only
+                                        // via parameters to the function.
+                                        //
+                                        // Normally, we would expect to use the direct parameters as a
+                                        // memory location + size, but in this case, *all* values are being passed directly,
+                                        // via params.
+                                        //
+                                        {debug_log_fn}('memory unexpectedly missing while lifting unknown length list', {{ ctx }});
+                                        liftResults = [ctx.params.slice(0, knownLen), ctx];
+                                        ctx.params = ctx.params.slice(knownLen);
+                                    }} else {{
+                                        // in-memory list with unknown length w/ direct params
+                                        const dataPtr = ctx.params[0];
+                                        ctx.params = ctx.params.slice(1);
+
+                                        ctx.useDirectParams = false;
+                                        const originalPtr = ctx.storagePtr;
+                                        ctx.storageLen = knownLen * elemSize32;
+
+                                        liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, knownLen);
+
+                                        ctx.useDirectParams = true;
+                                        ctx.storagePtr = undefined;
+                                        ctx.storageLen = undefined;
+                                    }}
+                                }} else {{ // indirect params
+                                    if (ctx.memory === null) {{
+                                        {debug_log_fn}('memory unexpectedly missing while lifting known length list', {{ knownLen, ctx }});
+                                        throw new Error(`memory missing while lifting known length (${{knownLen}}) list`);
+                                    }}
 
-                                    ctx.useDirectParams = false;
-                                    const originalPtr = ctx.storagePtr;
-                                    ctx.storageLen = knownLen * elemSize32;
-
-                                    liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, knownLen);
-
-                                    ctx.useDirectParams = true;
-                                    ctx.storagePtr = null;
-                                    ctx.storageLen = null;
-
-                                }} else {{
                                     ctx.storageLen = knownLen * elemSize32;
                                     liftResults = readValuesAndReset(ctx, null, ctx.storagePtr, knownLen);
                                 }}
@@ -880,8 +896,8 @@ impl LiftIntrinsic {
                                     liftResults = readValuesAndReset(ctx, originalPtr, dataPtr, len);
 
                                     ctx.useDirectParams = true;
-                                    ctx.storagePtr = null;
-                                    ctx.storageLen = null;
+                                    ctx.storagePtr = undefined;
+                                    ctx.storageLen = undefined;
 
                                 }} else {{
                                     // unknown length list ptr w/ in-memory params

crates/js-component-bindgen/src/intrinsics/p3/async_task.rs

@@ -454,7 +454,6 @@ impl AsyncTaskIntrinsic {
                     function {task_return_fn}(ctx) {{
                         const {{
                             componentIdx,
-                            useDirectParams,
                             getMemoryFn,
                             memoryIdx,
                             callbackFnIdx,
@@ -464,6 +463,7 @@ impl AsyncTaskIntrinsic {
                         }} = ctx;
                         const params = [...arguments].slice(1);
                         const memory = getMemoryFn();
+                        let useDirectParams = ctx.useDirectParams;
 
                         const {{ taskID }} = {get_global_current_task_meta_fn}(componentIdx);
 
@@ -511,6 +511,10 @@ impl AsyncTaskIntrinsic {
 
                         let liftCtx = {{ memory, useDirectParams, params, componentIdx, stringEncoding }};
                         if (!useDirectParams) {{
+                            if (!ctx.memory) {{
+                                {debug_log_fn}('missing memory despite indirect param usage', {{ useDirectParams, liftCtx, ctx }});
+                                throw new Error('missing memory despite indirect param usage');
+                            }}
                             liftCtx.storagePtr = params[0];
                             liftCtx.storageLen = params[1];
                         }}
@@ -519,7 +523,7 @@ impl AsyncTaskIntrinsic {
                         {debug_log_fn}('[{task_return_fn}()] lifting results out of memory', {{ liftCtx }});
                         for (const liftFn of liftFns) {{
                             if (liftCtx.storageLen !== undefined && liftCtx.storageLen <= 0) {{
-                                {debug_log_fn}("[{task_return_fn}()] ran out of range while writing");
+                                {debug_log_fn}(`[{task_return_fn}()] ran out of range while writing storageLen = [${{liftCtx.storageLen}}]`);
                                 throw new Error('ran out of storage while writing');
                             }}
                             const [ val, newLiftCtx ] = liftFn(liftCtx);

crates/js-component-bindgen/src/transpile_bindgen.rs

@@ -55,11 +55,9 @@ use crate::{
     requires_async_porcelain, source, uwrite, uwriteln,
 };
 
-/// Number of flat parameters allowed before spilling over to memory
-/// for an async function
-///
-/// See [`wit-bindgen-core`] and the Component Model spec
-const MAX_ASYNC_FLAT_PARAMS: usize = 4;
+/// Size of flat parameters that can be sent, for example via the `task.return`
+/// intrinsic, when returning from an async func
+const MAX_FLAT_PARAMS: usize = 16;
 
 #[derive(Debug, Default, Clone)]
 pub struct TranspileOpts {
@@ -2530,7 +2528,7 @@ impl<'a> Instantiator<'a, '_> {
                             .unwrap_or(0)
                     })
                     .sum();
-                let use_direct_params = result_flat_param_total < MAX_ASYNC_FLAT_PARAMS;
+                let use_direct_params = result_flat_param_total < MAX_FLAT_PARAMS;
 
                 // Build up a list of all the lifting functions that will be needed for the types
                 // that are actually being passed through task.return