Merge pull request #723 from wado-lang/claude/wasi-p3-update-eOVtf

Fix CM binding codegen for HTTP and streaming functions

Author: gfx

wado-compiler/src/codegen/component.rs

@@ -162,6 +162,7 @@ pub fn build_component(project: &Project, core_module: &[u8], wir_module: &WirMo
             Some("http-response-new"),
             ctx.comp_func_idx("http-response-new"),
             [
+                CanonicalOption::Async,
                 CanonicalOption::Memory(ctx.memory_idx()),
                 CanonicalOption::Realloc(ctx.core_func_idx("realloc")),
             ],
@@ -1730,8 +1731,16 @@ fn import_http_types_for_service(
         // Type generation starts after the SubResource exports.
         // CmInstanceTypeGen emits error-code and its payload structs
         // on demand when the parameter/return types are processed.
+        // Use interface hint to disambiguate types shared across packages
+        // (e.g., ErrorCode exists in http, filesystem, sockets).
         let resource_count = http_resources.len() as u32;
-        let mut type_gen = CmInstanceTypeGen::new(resource_count);
+        let http_version = project
+            .wasi_registry
+            .get_package_version("http")
+            .expect("WASI HTTP version not found in registry");
+        let http_types_interface = format!("wasi:http/types@{http_version}");
+        let mut type_gen =
+            CmInstanceTypeGen::with_interface_hint(resource_count, &http_types_interface);
         let resource_exports: IndexMap<&str, u32> = http_resources
             .iter()
             .enumerate()

wado-compiler/src/component_model.rs

@@ -718,6 +718,33 @@ impl WasiRegistry {
         self.variants.get(name).map(|(_, cases)| cases.as_slice())
     }
 
+    /// Get the variant cases by interface path + name for disambiguation.
+    /// Tries interface-qualified key first, falls back to unqualified name.
+    pub fn get_variant_cases_by_interface(
+        &self,
+        interface_path: &str,
+        name: &str,
+    ) -> Option<&[CmVariantCase]> {
+        let full_key = format!("{interface_path}#{name}");
+        self.variants
+            .get(&full_key)
+            .or_else(|| self.variants.get(name))
+            .map(|(_, cases)| cases.as_slice())
+    }
+
+    /// Get the CM variant name by interface path + name for disambiguation.
+    pub fn get_variant_cm_name_by_interface(
+        &self,
+        interface_path: &str,
+        name: &str,
+    ) -> Option<&str> {
+        let full_key = format!("{interface_path}#{name}");
+        self.variants
+            .get(&full_key)
+            .or_else(|| self.variants.get(name))
+            .map(|(cm_name, _)| cm_name.as_str())
+    }
+
     /// Check if a type name is a registered struct (WIT record)
     pub fn is_struct(&self, name: &str) -> bool {
         self.structs.contains_key(name)
@@ -1161,13 +1188,27 @@ use wasm_encoder::{ComponentValType, InstanceType, PrimitiveValType, TypeBounds}
 pub struct CmInstanceTypeGen {
     next_idx: u32,
     cache: IndexMap<String, u32>,
+    /// Optional interface path hint for disambiguating types with the same name
+    /// across different WASI interfaces (e.g., "wasi:http/types@..." to select
+    /// HTTP's `ErrorCode` over filesystem's `ErrorCode`).
+    interface_hint: Option<String>,
 }
 
 impl CmInstanceTypeGen {
     pub fn new(start_idx: u32) -> Self {
         Self {
             next_idx: start_idx,
             cache: IndexMap::default(),
+            interface_hint: None,
+        }
+    }
+
+    /// Create a new generator with an interface hint for type disambiguation.
+    pub fn with_interface_hint(start_idx: u32, interface_hint: &str) -> Self {
+        Self {
+            next_idx: start_idx,
+            cache: IndexMap::default(),
+            interface_hint: Some(interface_hint.to_string()),
         }
     }
 
@@ -1461,8 +1502,21 @@ impl CmInstanceTypeGen {
                         self.cache.insert(cache_key, idx);
                         ComponentValType::Type(idx)
                     } else if wasi_registry.is_variant(name) {
-                        let cm_name = wasi_registry.get_variant_cm_name(name).unwrap().to_string();
-                        let cases = wasi_registry.get_variant_cases(name).unwrap().to_vec();
+                        let (cm_name, cases) = if let Some(hint) = &self.interface_hint {
+                            let cm = wasi_registry
+                                .get_variant_cm_name_by_interface(hint, name)
+                                .unwrap()
+                                .to_string();
+                            let cs = wasi_registry
+                                .get_variant_cases_by_interface(hint, name)
+                                .unwrap()
+                                .to_vec();
+                            (cm, cs)
+                        } else {
+                            let cm = wasi_registry.get_variant_cm_name(name).unwrap().to_string();
+                            let cs = wasi_registry.get_variant_cases(name).unwrap().to_vec();
+                            (cm, cs)
+                        };
                         let idx = self.define_variant(
                             instance_type,
                             &cm_name,

wado-compiler/src/synthesis/cm_binding.rs

@@ -2676,71 +2676,13 @@ fn synthesize_adapter(
     // The binding's return type to the Wado caller:
     let adapter_return_type;
 
-    // Streaming path: functions with Stream params that callers must write to
-    // before the subtask completes. For functions returning tuples with Future
-    // (like read_via_stream -> [Stream, Future]), the async path lifts the full
-    // tuple from outptr after wait_for_subtask.
-    let is_streaming_func = !func_info.is_async && func_info.has_streaming_param();
-    if is_streaming_func {
-        // Streaming function (sync function with stream params, e.g. write_via_stream).
-        // canon lower with async option returns a packed subtask handle, but for sync
-        // functions the subtask completes immediately (Returned status). The actual
-        // return value (Future handle) is written to the outptr by the canon lower.
-        //
-        // We wait for the subtask (no-op for Returned), read the Future handle from
-        // outptr, free outptr, and return the Future handle. The caller writes stream
-        // data and then drops the Future to wait for completion.
-        if let Some((outptr_local, outptr_size, outptr_align)) = async_outptr_info {
-            let subtask_local = next_local;
-            local_types.push(TypeTable::I32);
-            next_local += 1;
-            body_stmts.push(let_stmt(
-                "__subtask",
-                subtask_local,
-                TypeTable::I32,
-                raw_call_expr,
-            ));
-            body_stmts.push(expr_stmt(internal_call(
-                "wait_for_subtask",
-                vec![local_ref(subtask_local, "__subtask", TypeTable::I32)],
-                TypeTable::UNIT,
-            )));
-            // Read Future handle from outptr
-            let future_handle_local = next_local;
-            local_types.push(TypeTable::I32);
-            next_local += 1;
-            body_stmts.push(let_stmt(
-                "__future_handle",
-                future_handle_local,
-                TypeTable::I32,
-                builtin_call(
-                    "i32_load",
-                    vec![local_ref(outptr_local, "__async_outptr", TypeTable::I32)],
-                    TypeTable::I32,
-                ),
-            ));
-            // Free outptr
-            body_stmts.push(expr_stmt(builtin_call(
-                "realloc",
-                vec![
-                    local_ref(outptr_local, "__async_outptr", TypeTable::I32),
-                    i32_const(outptr_size as i32),
-                    i32_const(outptr_align as i32),
-                    i32_const(0),
-                ],
-                TypeTable::I32,
-            )));
-            body_stmts.push(return_stmt(Some(local_ref(
-                future_handle_local,
-                "__future_handle",
-                TypeTable::I32,
-            ))));
-        } else {
-            // No outptr (shouldn't happen for streaming functions with return type)
-            body_stmts.push(return_stmt(Some(raw_call_expr)));
-        }
-        adapter_return_type = TypeTable::I32;
-    } else if needs_async_lower {
+    // Async/streaming path: functions lowered with `async` canon option.
+    // This covers both truly async functions (func_info.is_async) and sync
+    // functions with streaming params (Stream/Future) that require async lowering.
+    // Non-async functions with streaming params complete synchronously (RETURNED
+    // status), so wait_for_subtask is a no-op. The result is always written to the
+    // outptr and lifted via synthesize_lift based on the return type metadata.
+    if needs_async_lower {
         // WASI P3 async calling convention: the lowered function returns a subtask
         // handle (i32). 0 = completed synchronously; non-zero = async task in-flight.
         // In both cases, the result is written to the async results buffer in linear memory.