Skip to content
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

Implement support for the standard mangling scheme in the component model #1828

Merged
merged 8 commits into from
Oct 2, 2024
Merged

Implement support for the standard mangling scheme in the component model #1828

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
464aeab
Use `ExportMap` for naming component exports
alexcrichton Sep 26, 2024
51a2f8b
Decouple import/export encodings from core names
alexcrichton Sep 26, 2024
9094e79
Remove core wasm name guess in adapter GC
alexcrichton Sep 28, 2024
22eaa40
Support the new name mangling scheme for components
alexcrichton Sep 26, 2024
3368973
Update `embed --dummy` with new ABI names
alexcrichton Sep 28, 2024
ed037a5
Add a flag to require the new mangling scheme
alexcrichton Sep 28, 2024
d614725
Fix tests
alexcrichton Sep 28, 2024
da3e973
Update some test expectations
alexcrichton Sep 30, 2024
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
148 changes: 112 additions & 36 deletions crates/wit-component/src/dummy.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,11 @@
use wit_parser::abi::{AbiVariant, WasmType};
use wit_parser::{Function, Resolve, TypeDefKind, TypeId, WorldId, WorldItem};
use wit_parser::{
Function, Mangling, Resolve, ResourceIntrinsic, TypeDefKind, TypeId, WasmExport, WasmImport,
WorldId, WorldItem, WorldKey,
};

/// Generate a dummy implementation core Wasm module for a given WIT document
pub fn dummy_module(resolve: &Resolve, world: WorldId) -> Vec<u8> {
pub fn dummy_module(resolve: &Resolve, world: WorldId, mangling: Mangling) -> Vec<u8> {
let world = &resolve.worlds[world];
let mut wat = String::new();
wat.push_str("(module\n");
Expand All @@ -11,27 +14,41 @@ pub fn dummy_module(resolve: &Resolve, world: WorldId) -> Vec<u8> {
WorldItem::Function(func) => {
let sig = resolve.wasm_signature(AbiVariant::GuestImport, func);

wat.push_str(&format!("(import \"$root\" \"{}\" (func", func.name));
let (module, name) = resolve.wasm_import_name(
mangling,
WasmImport::Func {
interface: None,
func,
},
);

wat.push_str(&format!("(import {module:?} {name:?} (func"));
push_tys(&mut wat, "param", &sig.params);
push_tys(&mut wat, "result", &sig.results);
wat.push_str("))\n");
}
WorldItem::Interface { id: import, .. } => {
let name = resolve.name_world_key(name);
for (_, func) in resolve.interfaces[*import].functions.iter() {
let sig = resolve.wasm_signature(AbiVariant::GuestImport, func);

wat.push_str(&format!("(import \"{name}\" \"{}\" (func", func.name));
let (module, name) = resolve.wasm_import_name(
mangling,
WasmImport::Func {
interface: Some(name),
func,
},
);
wat.push_str(&format!("(import {module:?} {name:?} (func"));
push_tys(&mut wat, "param", &sig.params);
push_tys(&mut wat, "result", &sig.results);
wat.push_str("))\n");
}
for (_, ty) in resolve.interfaces[*import].types.iter() {
push_resource_func_imports(&mut wat, resolve, &name, *ty);
push_resource_func_imports(&mut wat, resolve, Some(name), *ty, mangling);
}
}
WorldItem::Type(id) => {
push_resource_func_imports(&mut wat, resolve, "$root", *id);
push_resource_func_imports(&mut wat, resolve, None, *id, mangling);
}
}
}
Expand All @@ -42,77 +59,136 @@ pub fn dummy_module(resolve: &Resolve, world: WorldId) -> Vec<u8> {
WorldItem::Interface { id, .. } => *id,
_ => continue,
};
let module = format!("[export]{}", resolve.name_world_key(name));
for (name, ty) in resolve.interfaces[export].types.iter() {
let ty = &resolve.types[*ty];
for resource in resolve.interfaces[export].types.values().copied() {
let ty = &resolve.types[resource];
match ty.kind {
TypeDefKind::Resource => {}
_ => continue,
}
wat.push_str(&format!(
"\
(import \"{module}\" \"[resource-drop]{name}\" (func (param i32)))
(import \"{module}\" \"[resource-new]{name}\" (func (param i32) (result i32)))
(import \"{module}\" \"[resource-rep]{name}\" (func (param i32) (result i32)))
"
));
let intrinsics = [
(ResourceIntrinsic::ExportedDrop, "(func (param i32))"),
(
ResourceIntrinsic::ExportedNew,
"(func (param i32) (result i32))",
),
(
ResourceIntrinsic::ExportedRep,
"(func (param i32) (result i32))",
),
];
for (intrinsic, sig) in intrinsics {
let (module, name) = resolve.wasm_import_name(
mangling,
WasmImport::ResourceIntrinsic {
interface: Some(name),
resource,
intrinsic,
},
);
wat.push_str(&format!("(import {module:?} {name:?} {sig})\n"));
}
}
}

for (name, export) in world.exports.iter() {
match export {
WorldItem::Function(func) => {
push_func(&mut wat, &func.name, resolve, func);
push_func_export(&mut wat, resolve, None, func, mangling);
}
WorldItem::Interface { id: export, .. } => {
let name = resolve.name_world_key(name);
for (_, func) in resolve.interfaces[*export].functions.iter() {
let name = func.core_export_name(Some(&name));
push_func(&mut wat, &name, resolve, func);
push_func_export(&mut wat, resolve, Some(name), func, mangling);
}

// Feign destructors for any resource that this interface
// exports
for (resource_name, ty) in resolve.interfaces[*export].types.iter() {
let ty = &resolve.types[*ty];
for resource in resolve.interfaces[*export].types.values().copied() {
let ty = &resolve.types[resource];
match ty.kind {
TypeDefKind::Resource => {}
_ => continue,
}
wat.push_str(&format!(
"(func (export \"{name}#[dtor]{resource_name}\") (param i32))"
));
let name = resolve.wasm_export_name(
mangling,
WasmExport::ResourceDtor {
interface: name,
resource,
},
);
wat.push_str(&format!("(func (export {name:?}) (param i32))"));
}
}
WorldItem::Type(_) => {}
}
}

wat.push_str("(memory (export \"memory\") 0)\n");
wat.push_str(
"(func (export \"cabi_realloc\") (param i32 i32 i32 i32) (result i32) unreachable)\n",
);
let memory = resolve.wasm_export_name(mangling, WasmExport::Memory);
wat.push_str(&format!("(memory (export {memory:?}) 0)\n"));
let realloc = resolve.wasm_export_name(mangling, WasmExport::Realloc);
wat.push_str(&format!(
"(func (export {realloc:?}) (param i32 i32 i32 i32) (result i32) unreachable)\n"
));
let initialize = resolve.wasm_export_name(mangling, WasmExport::Initialize);
wat.push_str(&format!("(func (export {initialize:?}))"));
wat.push_str(")\n");

return wat::parse_str(&wat).unwrap();

fn push_resource_func_imports(wat: &mut String, resolve: &Resolve, module: &str, ty: TypeId) {
let ty = &resolve.types[ty];
fn push_resource_func_imports(
wat: &mut String,
resolve: &Resolve,
interface: Option<&WorldKey>,
resource: TypeId,
mangling: Mangling,
) {
let ty = &resolve.types[resource];
match ty.kind {
TypeDefKind::Resource => {}
_ => return,
}
let name = ty.name.as_ref().unwrap();
wat.push_str(&format!("(import \"{module}\" \"[resource-drop]{name}\""));
wat.push_str(" (func (param i32)))\n");
let (module, name) = resolve.wasm_import_name(
mangling,
WasmImport::ResourceIntrinsic {
interface,
resource,
intrinsic: ResourceIntrinsic::ImportedDrop,
},
);
wat.push_str(&format!("(import {module:?} {name:?} (func (param i32)))"));
}

fn push_func(wat: &mut String, name: &str, resolve: &Resolve, func: &Function) {
fn push_func_export(
wat: &mut String,
resolve: &Resolve,
interface: Option<&WorldKey>,
func: &Function,
mangling: Mangling,
) {
let sig = resolve.wasm_signature(AbiVariant::GuestExport, func);
let name = resolve.wasm_export_name(
mangling,
WasmExport::Func {
interface,
func,
post_return: false,
},
);
wat.push_str(&format!("(func (export \"{name}\")"));
push_tys(wat, "param", &sig.params);
push_tys(wat, "result", &sig.results);
wat.push_str(" unreachable)\n");

let name = resolve.wasm_export_name(
mangling,
WasmExport::Func {
interface,
func,
post_return: true,
},
);
wat.push_str(&format!("(func (export \"{name}\")"));
push_tys(wat, "param", &sig.results);
wat.push_str(")\n");
}

fn push_tys(dst: &mut String, desc: &str, params: &[WasmType]) {
Expand Down
Loading