Skip to content

Commit c463da0

Browse files
peter-jerry-yepeter-jerry-ye
authored
wit-parser: extend WasmImport for future/stream intrinsics (#2454)
* wit-parser: add future/stream intrinsic WasmImport naming * wit-parser: use TypeId for async payload import naming
1 parent 70394c5 commit c463da0

2 files changed

Lines changed: 446 additions & 39 deletions

File tree

‎crates/wit-component/src/dummy.rs‎

Lines changed: 98 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
use wit_parser::abi::WasmType;
22
use wit_parser::{
3-
Function, LiftLowerAbi, ManglingAndAbi, Resolve, ResourceIntrinsic, TypeDefKind, TypeId,
4-
WasmExport, WasmExportKind, WasmImport, WorldId, WorldItem, WorldKey,
3+
Function, FutureIntrinsic, LiftLowerAbi, ManglingAndAbi, Resolve, ResourceIntrinsic,
4+
StreamIntrinsic, TypeDefKind, TypeId, WasmExport, WasmExportKind, WasmImport, WorldId,
5+
WorldItem, WorldKey,
56
};
67

78
/// Generate a dummy implementation core Wasm module for a given WIT document
@@ -98,7 +99,7 @@ fn push_imported_func(
9899
wat.push_str("))\n");
99100

100101
if mangling.is_async() {
101-
push_imported_future_and_stream_intrinsics(wat, resolve, "", interface, func);
102+
push_imported_future_and_stream_intrinsics(wat, resolve, mangling, false, interface, func);
102103
}
103104
}
104105

@@ -156,63 +157,122 @@ fn push_exported_func_intrinsics(
156157
push_tys(wat, "result", &sig.results);
157158
wat.push_str("))\n");
158159

159-
push_imported_future_and_stream_intrinsics(wat, resolve, "[export]", interface, func);
160+
push_imported_future_and_stream_intrinsics(wat, resolve, mangling, true, interface, func);
160161
}
161162

162163
fn push_imported_future_and_stream_intrinsics(
163164
wat: &mut String,
164165
resolve: &Resolve,
165-
module_prefix: &str,
166+
mangling: ManglingAndAbi,
167+
exported: bool,
166168
interface: Option<&WorldKey>,
167169
func: &Function,
168170
) {
169-
let module = match interface {
170-
Some(key) => format!("{module_prefix}{}", resolve.name_world_key(key)),
171-
None => format!("{module_prefix}$root"),
172-
};
173-
let name = &func.name;
174-
175-
for (i, id) in func
176-
.find_futures_and_streams(resolve)
177-
.into_iter()
178-
.enumerate()
179-
{
171+
for id in func.find_futures_and_streams(resolve).into_iter() {
180172
match &resolve.types[id].kind {
181173
TypeDefKind::Future(_) => {
174+
let mut module = None;
175+
let mut intrinsic_name = |intrinsic, async_| {
176+
let (m, name) = resolve.wasm_import_name(
177+
mangling,
178+
WasmImport::FutureIntrinsic {
179+
interface,
180+
func,
181+
ty: Some(id),
182+
intrinsic,
183+
exported,
184+
async_,
185+
},
186+
);
187+
if let Some(prev) = &module {
188+
debug_assert_eq!(prev, &m);
189+
} else {
190+
module = Some(m);
191+
}
192+
name
193+
};
194+
195+
let new = intrinsic_name(FutureIntrinsic::New, false);
196+
let read = intrinsic_name(FutureIntrinsic::Read, false);
197+
let write = intrinsic_name(FutureIntrinsic::Write, false);
198+
let cancel_read = intrinsic_name(FutureIntrinsic::CancelRead, false);
199+
let cancel_write = intrinsic_name(FutureIntrinsic::CancelWrite, false);
200+
let drop_readable = intrinsic_name(FutureIntrinsic::DropReadable, false);
201+
let drop_writable = intrinsic_name(FutureIntrinsic::DropWritable, false);
202+
let async_read = intrinsic_name(FutureIntrinsic::Read, true);
203+
let async_write = intrinsic_name(FutureIntrinsic::Write, true);
204+
let async_cancel_read = intrinsic_name(FutureIntrinsic::CancelRead, true);
205+
let async_cancel_write = intrinsic_name(FutureIntrinsic::CancelWrite, true);
206+
let module = module.unwrap();
207+
182208
wat.push_str(&format!(
183209
r#"
184-
(import {module:?} "[future-new-{i}]{name}" (func (result i64)))
185-
(import {module:?} "[future-read-{i}]{name}" (func (param i32 i32) (result i32)))
186-
(import {module:?} "[future-write-{i}]{name}" (func (param i32 i32) (result i32)))
187-
(import {module:?} "[future-cancel-read-{i}]{name}" (func (param i32) (result i32)))
188-
(import {module:?} "[future-cancel-write-{i}]{name}" (func (param i32) (result i32)))
189-
(import {module:?} "[future-drop-readable-{i}]{name}" (func (param i32)))
190-
(import {module:?} "[future-drop-writable-{i}]{name}" (func (param i32)))
191-
(import {module:?} "[async-lower][future-read-{i}]{name}" (func (param i32 i32) (result i32)))
192-
(import {module:?} "[async-lower][future-write-{i}]{name}" (func (param i32 i32) (result i32)))
210+
(import {module:?} {new:?} (func (result i64)))
211+
(import {module:?} {read:?} (func (param i32 i32) (result i32)))
212+
(import {module:?} {write:?} (func (param i32 i32) (result i32)))
213+
(import {module:?} {cancel_read:?} (func (param i32) (result i32)))
214+
(import {module:?} {cancel_write:?} (func (param i32) (result i32)))
215+
(import {module:?} {drop_readable:?} (func (param i32)))
216+
(import {module:?} {drop_writable:?} (func (param i32)))
217+
(import {module:?} {async_read:?} (func (param i32 i32) (result i32)))
218+
(import {module:?} {async_write:?} (func (param i32 i32) (result i32)))
193219
194220
;; deferred behind 🚝
195-
;;(import {module:?} "[async-lower][future-cancel-read-{i}]{name}" (func (param i32) (result i32)))
196-
;;(import {module:?} "[async-lower][future-cancel-write-{i}]{name}" (func (param i32) (result i32)))
221+
;;(import {module:?} {async_cancel_read:?} (func (param i32) (result i32)))
222+
;;(import {module:?} {async_cancel_write:?} (func (param i32) (result i32)))
197223
"#
198224
));
199225
}
200226
TypeDefKind::Stream(_) => {
227+
let mut module = None;
228+
let mut intrinsic_name = |intrinsic, async_| {
229+
let (m, name) = resolve.wasm_import_name(
230+
mangling,
231+
WasmImport::StreamIntrinsic {
232+
interface,
233+
func,
234+
ty: Some(id),
235+
intrinsic,
236+
exported,
237+
async_,
238+
},
239+
);
240+
if let Some(prev) = &module {
241+
debug_assert_eq!(prev, &m);
242+
} else {
243+
module = Some(m);
244+
}
245+
name
246+
};
247+
248+
let new = intrinsic_name(StreamIntrinsic::New, false);
249+
let read = intrinsic_name(StreamIntrinsic::Read, false);
250+
let write = intrinsic_name(StreamIntrinsic::Write, false);
251+
let cancel_read = intrinsic_name(StreamIntrinsic::CancelRead, false);
252+
let cancel_write = intrinsic_name(StreamIntrinsic::CancelWrite, false);
253+
let drop_readable = intrinsic_name(StreamIntrinsic::DropReadable, false);
254+
let drop_writable = intrinsic_name(StreamIntrinsic::DropWritable, false);
255+
let async_read = intrinsic_name(StreamIntrinsic::Read, true);
256+
let async_write = intrinsic_name(StreamIntrinsic::Write, true);
257+
let async_cancel_read = intrinsic_name(StreamIntrinsic::CancelRead, true);
258+
let async_cancel_write = intrinsic_name(StreamIntrinsic::CancelWrite, true);
259+
let module = module.unwrap();
260+
201261
wat.push_str(&format!(
202262
r#"
203-
(import {module:?} "[stream-new-{i}]{name}" (func (result i64)))
204-
(import {module:?} "[stream-read-{i}]{name}" (func (param i32 i32 i32) (result i32)))
205-
(import {module:?} "[stream-write-{i}]{name}" (func (param i32 i32 i32) (result i32)))
206-
(import {module:?} "[stream-cancel-read-{i}]{name}" (func (param i32) (result i32)))
207-
(import {module:?} "[stream-cancel-write-{i}]{name}" (func (param i32) (result i32)))
208-
(import {module:?} "[stream-drop-readable-{i}]{name}" (func (param i32)))
209-
(import {module:?} "[stream-drop-writable-{i}]{name}" (func (param i32)))
210-
(import {module:?} "[async-lower][stream-read-{i}]{name}" (func (param i32 i32 i32) (result i32)))
211-
(import {module:?} "[async-lower][stream-write-{i}]{name}" (func (param i32 i32 i32) (result i32)))
263+
(import {module:?} {new:?} (func (result i64)))
264+
(import {module:?} {read:?} (func (param i32 i32 i32) (result i32)))
265+
(import {module:?} {write:?} (func (param i32 i32 i32) (result i32)))
266+
(import {module:?} {cancel_read:?} (func (param i32) (result i32)))
267+
(import {module:?} {cancel_write:?} (func (param i32) (result i32)))
268+
(import {module:?} {drop_readable:?} (func (param i32)))
269+
(import {module:?} {drop_writable:?} (func (param i32)))
270+
(import {module:?} {async_read:?} (func (param i32 i32 i32) (result i32)))
271+
(import {module:?} {async_write:?} (func (param i32 i32 i32) (result i32)))
212272
213273
;; deferred behind 🚝
214-
;;(import {module:?} "[async-lower][stream-cancel-read-{i}]{name}" (func (param i32) (result i32)))
215-
;;(import {module:?} "[async-lower][stream-cancel-write-{i}]{name}" (func (param i32) (result i32)))
274+
;;(import {module:?} {async_cancel_read:?} (func (param i32) (result i32)))
275+
;;(import {module:?} {async_cancel_write:?} (func (param i32) (result i32)))
216276
"#
217277
));
218278
}

0 commit comments

Comments
 (0)