chore: run fmt and fix clippy in moonbit test tooling

Author: peter-jerry-ye

crates/moonbit/src/async_support.rs

@@ -5,16 +5,16 @@ use std::{
 
 use heck::ToUpperCamelCase;
 use wit_bindgen_core::{
-    abi::{self, deallocate_lists_in_types, lift_from_memory, WasmSignature},
-    dealias, uwriteln,
     Direction, Files, Source,
+    abi::{self, WasmSignature, deallocate_lists_in_types, lift_from_memory},
+    dealias, uwriteln,
     wit_parser::{
         Function, LiftLowerAbi, ManglingAndAbi, Param, Type, TypeDefKind, TypeId, WasmImport,
     },
 };
 
 use crate::pkg::ToMoonBitIdent;
-use crate::{ffi, indent, FunctionBindgen};
+use crate::{FunctionBindgen, ffi, indent};
 
 use super::InterfaceGenerator;
 
@@ -618,13 +618,8 @@ fn wasmLift{camel_name}{index}(stream_handle : Int) -> {lifted} {{
 
         let lift_builtins = if let Some(inner_ty) = inner_type {
             let resolve = self.resolve.clone();
-            let mut lift_bindgen = FunctionBindgen::new(
-                self,
-                Box::new([]),
-                Direction::Import,
-                true,
-                false,
-            );
+            let mut lift_bindgen =
+                FunctionBindgen::new(self, Box::new([]), Direction::Import, true, false);
             lift_bindgen.use_ffi(ffi::MALLOC);
             lift_bindgen.use_ffi(ffi::FREE);
 
@@ -737,13 +732,8 @@ fn wasmLower{camel_name}{index}(stream : {lifted}) -> Int {{
         let lower_builtins = if let Some(inner_ty) = inner_type {
             let resolve = self.resolve.clone();
             let elem_type = self.world_gen.pkg_resolver.type_name(self.name, &inner_ty);
-            let mut lower_bindgen = FunctionBindgen::new(
-                self,
-                Box::new([]),
-                Direction::Export,
-                true,
-                false,
-            );
+            let mut lower_bindgen =
+                FunctionBindgen::new(self, Box::new([]), Direction::Export, true, false);
             lower_bindgen.use_ffi(ffi::MALLOC);
             lower_bindgen.use_ffi(ffi::FREE);
 

crates/moonbit/src/lib.rs

@@ -11,8 +11,7 @@ use wit_bindgen_core::{
     AsyncFilterSet, Direction, Files, InterfaceGenerator as CoreInterfaceGenerator, Ns, Source,
     WorldGenerator,
     abi::{self, AbiVariant, Bindgen, Bitcast, Instruction, LiftLower, WasmType},
-    dealias,
-    uwrite, uwriteln,
+    dealias, uwrite, uwriteln,
     wit_parser::{
         Alignment, ArchitectureSize, Docs, Enum, Flags, FlagsRepr, Function, Handle, Int,
         InterfaceId, LiftLowerAbi, Mangling, ManglingAndAbi, Param, Record, Resolve,
@@ -858,6 +857,9 @@ impl InterfaceGenerator<'_> {
             #doc(hidden)
             pub fn {func_name}({params}) -> {result_type} {{
                 {async_pkg}with_waitableset(async fn() {{
+                    // Intentionally run export body in a task-group child task.
+                    // MoonBit's structured concurrency model uses the task group
+                    // as an umbrella for async work started by the export.
                     {async_pkg}with_task_group(async fn(task_group) {{
                         {cleanup_list}
                         {src}
@@ -1076,7 +1078,12 @@ impl InterfaceGenerator<'_> {
             })
             .collect::<Vec<_>>();
 
-        // For async exports, add taskgroup parameter (always Unit type)
+        // For async exports, add a task-group parameter.
+        //
+        // This is intentionally `TaskGroup[Unit]` even when the function result
+        // type is not `Unit`: this task group models the umbrella lifetime for
+        // export-side structured concurrency and cancellation, rather than the
+        // direct return payload type of the exported function.
         if async_ && matches!(direction, Direction::Export) {
             params.push("task_group : @async.TaskGroup[Unit]".to_string());
         }
@@ -2945,11 +2952,11 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 match ty {
                     Type::Id(id) => match &self.interface_gen.resolve.types[*id].kind {
                         TypeDefKind::Handle(Handle::Own(_)) => {
-                            let constructor =
-                                self.interface_gen.world_gen.pkg_resolver.type_constructor(
-                                    self.interface_gen.name,
-                                    ty,
-                                );
+                            let constructor = self
+                                .interface_gen
+                                .world_gen
+                                .pkg_resolver
+                                .type_constructor(self.interface_gen.name, ty);
                             uwriteln!(self.src, "let _ = {constructor}::drop({op});");
                         }
                         TypeDefKind::Future(_) | TypeDefKind::Stream(_) => {

crates/test/src/moonbit.rs

@@ -1,5 +1,5 @@
 use crate::{LanguageMethods, Runner};
-use anyhow::{bail, Context};
+use anyhow::{Context, bail};
 use serde::Deserialize;
 use std::process::Command;
 
@@ -103,10 +103,7 @@ impl LanguageMethods for MoonBit {
             .find(|path| path.exists())
             .cloned()
             .with_context(|| {
-                format!(
-                    "failed to locate MoonBit output wasm, looked in: {:?}",
-                    artifact_candidates
-                )
+                format!("failed to locate MoonBit output wasm, looked in: {artifact_candidates:?}",)
             })?;
         // Embed WIT files
         let manifest_dir = compile.component.path.parent().unwrap();