Skip to content

[C#] Simple Async support #1346

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 11 commits into
base: main
Choose a base branch
from
+504 −148
Open

[C#] Simple Async support #1346

Show file tree
Hide file tree
Changes from 10 commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
5196843
wip
yowl Jul 28, 2025
91488cf
pass simple-import-params test
yowl Aug 2, 2025
853e8d6
Merge remote-tracking branch 'origin/main' into csharp-async-simple-pr
yowl Aug 2, 2025
48ebbaa
tidy for PR
yowl Aug 2, 2025
cd60ad3
fmt
yowl Aug 2, 2025
271c689
Rremove extra test
yowl Aug 2, 2025
4908ff4
remove sln
yowl Aug 2, 2025
bd7f954
exclude failing tests
yowl Aug 2, 2025
d924d30
remove vscode files
yowl Aug 2, 2025
8ce6005
format
yowl Aug 2, 2025
c2f99f0
Add some todos, split the interop code up properly
yowl Aug 14, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 9 additions & 0 deletions crates/csharp/src/AsyncSupport.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,9 @@
/**
* Helpers for the async support.
*/

public enum CallbackCode
{
Exit = 0,
Yield = 1,
}
159 changes: 137 additions & 22 deletions crates/csharp/src/function.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@ use heck::ToUpperCamelCase;
use std::fmt::Write;
use std::mem;
use std::ops::Deref;
use wit_bindgen_core::abi::{Bindgen, Bitcast, Instruction};
use wit_bindgen_core::abi::{self, Bindgen, Bitcast, Instruction};
use wit_bindgen_core::{uwrite, uwriteln, Direction, Ns};
use wit_parser::abi::WasmType;
use wit_parser::{
Expand All @@ -32,6 +32,7 @@ pub(crate) struct FunctionBindgen<'a, 'b> {
is_block: bool,
fixed_statments: Vec<Fixed>,
parameter_type: ParameterType,
result_type: Option<Type>,
}

impl<'a, 'b> FunctionBindgen<'a, 'b> {
Expand All @@ -42,6 +43,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
params: Box<[String]>,
results: Vec<TypeId>,
parameter_type: ParameterType,
result_type: Option<Type>,
) -> FunctionBindgen<'a, 'b> {
let mut locals = Ns::default();
// Ensure temporary variable names don't clash with parameter names:
Expand All @@ -67,6 +69,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
is_block: false,
fixed_statments: Vec::new(),
parameter_type: parameter_type,
result_type: result_type,
}
}

Expand Down Expand Up @@ -304,7 +307,13 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
let ty = self
.interface_gen
.type_name_with_qualifier(&func.result.unwrap(), true);
uwriteln!(self.src, "{ty} {ret};");
let is_async = InterfaceGenerator::is_async(&func.kind);

if is_async {
uwriteln!(self.src, "Task<{ty}> {ret};");
} else {
uwriteln!(self.src, "{ty} {ret};");
}
let mut cases = Vec::with_capacity(self.results.len());
let mut oks = Vec::with_capacity(self.results.len());
let mut payload_is_void = false;
Expand Down Expand Up @@ -371,6 +380,44 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
}
ret
}

fn emit_allocation_for_type(&mut self, results: &[WasmType]) -> String {
let address = self.locals.tmp("address");
let buffer_size = self.get_size_for_type(results);
let align = self.get_align_for_type(results);
uwriteln!(self.src, "void* {address} = global::System.Runtime.InteropServices.NativeMemory.AlignedAlloc({buffer_size}, {align});");

// TODO: Store the address somewhere so we can free it when the task completes.
address
}

fn get_size_for_type(&self, results: &[WasmType]) -> usize {
match results {
[WasmType::I32] => 4,
[WasmType::I64] => 8,
[WasmType::F32] => 4,
[WasmType::F64] => 8,
[WasmType::Pointer, WasmType::Length] => 4, // TODO: Wasm64
[WasmType::PointerOrI64, WasmType::Length] => 8,
_ => {
todo!("other types not yet supported");
}
}
}

fn get_align_for_type(&self, results: &[WasmType]) -> usize {
match results {
[WasmType::I32] => 4,
[WasmType::I64] => 8,
[WasmType::F32] => 4,
[WasmType::F64] => 8,
[WasmType::Pointer, WasmType::Length] => 4, // TODO: Wasm64
[WasmType::PointerOrI64, WasmType::Length] => 8,
_ => {
todo!("other types not yet supported");
}
}
}
}

impl Bindgen for FunctionBindgen<'_, '_> {
Expand Down Expand Up @@ -400,22 +447,22 @@ impl Bindgen for FunctionBindgen<'_, '_> {
})),
Instruction::I32Load { offset }
| Instruction::PointerLoad { offset }
| Instruction::LengthLoad { offset } => results.push(format!("global::System.BitConverter.ToInt32(new global::System.Span<byte>((void*)({} + {offset}), 4))",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load8U { offset } => results.push(format!("new global::System.Span<byte>((void*)({} + {offset}), 1)[0]",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load8S { offset } => results.push(format!("(sbyte)new global::System.Span<byte>((void*)({} + {offset}), 1)[0]",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load16U { offset } => results.push(format!("global::System.BitConverter.ToUInt16(new global::System.Span<byte>((void*)({} + {offset}), 2))",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load16S { offset } => results.push(format!("global::System.BitConverter.ToInt16(new global::System.Span<byte>((void*)({} + {offset}), 2))",operands[0],offset = offset.size_wasm32())),
Instruction::I64Load { offset } => results.push(format!("global::System.BitConverter.ToInt64(new global::System.Span<byte>((void*)({} + {offset}), 8))",operands[0],offset = offset.size_wasm32())),
Instruction::F32Load { offset } => results.push(format!("global::System.BitConverter.ToSingle(new global::System.Span<byte>((void*)({} + {offset}), 4))",operands[0],offset = offset.size_wasm32())),
Instruction::F64Load { offset } => results.push(format!("global::System.BitConverter.ToDouble(new global::System.Span<byte>((void*)({} + {offset}), 8))",operands[0],offset = offset.size_wasm32())),
| Instruction::LengthLoad { offset } => results.push(format!("global::System.BitConverter.ToInt32(new global::System.Span<byte>((byte*){} + {offset}, 4))",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load8U { offset } => results.push(format!("new global::System.Span<byte>((byte*){} + {offset}, 1)[0]",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load8S { offset } => results.push(format!("(sbyte)new global::System.Span<byte>((byte*){} + {offset}, 1)[0]",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load16U { offset } => results.push(format!("global::System.BitConverter.ToUInt16(new global::System.Span<byte>((byte*){} + {offset}, 2))",operands[0],offset = offset.size_wasm32())),
Instruction::I32Load16S { offset } => results.push(format!("global::System.BitConverter.ToInt16(new global::System.Span<byte>((byte*){} + {offset}, 2))",operands[0],offset = offset.size_wasm32())),
Instruction::I64Load { offset } => results.push(format!("global::System.BitConverter.ToInt64(new global::System.Span<byte>((byte*){} + {offset}, 8))",operands[0],offset = offset.size_wasm32())),
Instruction::F32Load { offset } => results.push(format!("global::System.BitConverter.ToSingle(new global::System.Span<byte>((byte*){} + {offset}, 4))",operands[0],offset = offset.size_wasm32())),
Instruction::F64Load { offset } => results.push(format!("global::System.BitConverter.ToDouble(new global::System.Span<byte>((byte*){} + {offset}, 8))",operands[0],offset = offset.size_wasm32())),
Instruction::I32Store { offset }
| Instruction::PointerStore { offset }
| Instruction::LengthStore { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((void*)({} + {offset}), 4), {});", operands[1], operands[0],offset = offset.size_wasm32()),
| Instruction::LengthStore { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((byte*){} + {offset}, 4), {});", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::I32Store8 { offset } => uwriteln!(self.src, "*(byte*)({} + {offset}) = (byte){};", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::I32Store16 { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((void*)({} + {offset}), 2), (short){});", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::I64Store { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((void*)({} + {offset}), 8), unchecked((long){}));", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::F32Store { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((void*)({} + {offset}), 4), unchecked((float){}));", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::F64Store { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((void*)({} + {offset}), 8), unchecked((double){}));", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::I32Store16 { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((byte*){} + {offset}, 2), (short){});", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::I64Store { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((byte*){} + {offset}, 8), unchecked((long){}));", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::F32Store { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((byte*){} + {offset}, 4), unchecked((float){}));", operands[1], operands[0],offset = offset.size_wasm32()),
Instruction::F64Store { offset } => uwriteln!(self.src, "global::System.BitConverter.TryWriteBytes(new global::System.Span<byte>((byte*){} + {offset}, 8), unchecked((double){}));", operands[1], operands[0],offset = offset.size_wasm32()),

Instruction::I64FromU64 => results.push(format!("unchecked((long)({}))", operands[0])),
Instruction::I32FromChar => results.push(format!("((int){})", operands[0])),
Expand Down Expand Up @@ -956,11 +1003,24 @@ impl Bindgen for FunctionBindgen<'_, '_> {
}

Instruction::CallWasm { sig, .. } => {
let is_async = InterfaceGenerator::is_async(self.kind);

let requires_async_return_buffer_param = is_async && sig.results.len() >= 1;
let async_return_buffer = if requires_async_return_buffer_param {
let buffer = self.emit_allocation_for_type(&sig.results);
uwriteln!(self.src, "//TODO: store somewhere with the TaskCompletionSource.");
Copy link
Collaborator

@pavelsavara pavelsavara Aug 12, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think you can use new TaskCompletionSource(object? state) -> Task.AsyncState
Probably with some (internal?) helper struct/class to hold allocations and handles that you need to cleanup.

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks, I've updated the comment here, as per the remark above I'm hoping to be forced to address all these as I go through enabling the tests.

Some(buffer)
} else {
None
};

let assignment = match &sig.results[..] {
[_] => {
let result = self.locals.tmp("result");
let assignment = format!("var {result} = ");
results.push(result);
if !requires_async_return_buffer_param {
results.push(result);
}
assignment
}

Expand All @@ -971,12 +1031,32 @@ impl Bindgen for FunctionBindgen<'_, '_> {

let func_name = self.func_name.to_upper_camel_case();

let operands = operands.join(", ");
// Async functions that return a result need to pass a buffer where the result will later be written.
let operands = match async_return_buffer {
Some(ref buffer) if operands.is_empty() => buffer.clone(),
Some(ref buffer) => format!("{}, {}", operands.join(", "), buffer),
None => operands.join(", "),
};

uwriteln!(
self.src,
"{assignment} {func_name}WasmInterop.wasmImport{func_name}({operands});"
);

if let Some(buffer) = async_return_buffer {
let result = abi::lift_from_memory(
self.interface_gen.resolve,
self,
buffer.clone(),
&self.result_type.unwrap(),
);
uwriteln!(
self.src,
"global::System.Runtime.InteropServices.NativeMemory.Free({});",
buffer
);
results.push(result);
}
}

Instruction::CallInterface { func, .. } => {
Expand All @@ -1003,6 +1083,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
}
}

let is_async = InterfaceGenerator::is_async(self.kind);
match self.kind {
FunctionKind::Constructor(id) => {
let target = self.interface_gen.csharp_gen.all_resources[id].export_impl_name();
Expand All @@ -1018,7 +1099,13 @@ impl Bindgen for FunctionBindgen<'_, '_> {
};

match func.result {
None => uwriteln!(self.src, "{target}.{func_name}({oper});"),
None => {
if is_async{
uwriteln!(self.src, "var ret = {target}.{func_name}({oper});");
} else {
uwriteln!(self.src, "{target}.{func_name}({oper});");
}
}
Some(_ty) => {
let ret = self.handle_result_call(func, target, func_name, oper);
results.push(ret);
Expand All @@ -1027,6 +1114,24 @@ impl Bindgen for FunctionBindgen<'_, '_> {
}
}

if is_async {
self.interface_gen.csharp_gen.needs_async_support = true;
let name = self.func_name.to_upper_camel_case();
let ret_param = match func.result {
None => "",
Some(_ty) => "ret.Result"
};

uwriteln!(self.src, r#"if (ret.IsCompletedSuccessfully)
{{
{name}TaskReturn({ret_param});
return (uint)CallbackCode.Exit;
}}

return (uint)CallbackCode.Yield;
"#);
}

Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Might want to add a "TODO" comment here to remember to defer dropping borrowed resources until a result is returned (i.e. just before calling {name}TaskReturn).

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks, done

for (_, drop) in &self.resource_drops {
uwriteln!(self.src, "{drop}?.Dispose();");
}
Expand Down Expand Up @@ -1243,15 +1348,25 @@ impl Bindgen for FunctionBindgen<'_, '_> {
results.extend(operands.iter().take(*amt).map(|v| v.clone()));
}

Instruction::AsyncTaskReturn { .. }
| Instruction::FutureLower { .. }
| Instruction::FutureLift { .. }
Instruction::FutureLower { .. } => {
let op = &operands[0];
results.push(format!("{op}.Handle"));
}

Instruction::AsyncTaskReturn { name: _, params: _ } => {
uwriteln!(self.src, "// TODO_task_cancel.forget();");
}

Instruction::FutureLift { .. }
| Instruction::StreamLower { .. }
| Instruction::StreamLift { .. }
| Instruction::ErrorContextLower { .. }
| Instruction::ErrorContextLift { .. }
| Instruction::DropHandle { .. }
=> todo!(),
=> {
dbg!(inst);
todo!()
}
}
}

Expand Down
Loading
Loading