diff --git a/crates/gen-guest-c/src/lib.rs b/crates/gen-guest-c/src/lib.rs index c2509d22c..256b5c87c 100644 --- a/crates/gen-guest-c/src/lib.rs +++ b/crates/gen-guest-c/src/lib.rs @@ -990,7 +990,7 @@ impl Generator for C { self.src.c, "__attribute__((import_module(\"{}\"), import_name(\"{}\")))", iface.name, - iface.mangle_funcname(func) + func.name ); let import_name = self.names.tmp(&format!( "__wasm_import_{}_{}", @@ -1067,7 +1067,7 @@ impl Generator for C { uwriteln!( self.src.c, "__attribute__((export_name(\"{}\")))", - iface.mangle_funcname(func) + func.name ); let import_name = self.names.tmp(&format!( "__wasm_export_{}_{}", diff --git a/crates/gen-guest-rust/src/lib.rs b/crates/gen-guest-rust/src/lib.rs index e13a94124..15e01d499 100644 --- a/crates/gen-guest-rust/src/lib.rs +++ b/crates/gen-guest-rust/src/lib.rs @@ -528,13 +528,12 @@ impl Generator for RustWasm { fn export(&mut self, iface: &Interface, func: &Function) { let iface_name = iface.name.to_snake_case(); - let name_mangled = iface.mangle_funcname(func); let name_snake = func.name.to_snake_case(); let name = match &iface.module { Some(module) => { - format!("{module}#{}", name_mangled) + format!("{module}#{}", func.name) } - None => format!("{}{}", self.opts.symbol_namespace, name_mangled), + None => format!("{}{}", self.opts.symbol_namespace, func.name), }; self.src.push_str(&format!("#[export_name = \"{name}\"]\n")); @@ -1470,13 +1469,8 @@ impl Bindgen for FunctionBindgen<'_> { Instruction::IterBasePointer => results.push("base".to_string()), - Instruction::CallWasm { - iface, - base_name: _, - mangled_name, - sig, - } => { - let func = self.declare_import(iface, mangled_name, &sig.params, &sig.results); + Instruction::CallWasm { iface, name, sig } => { + let func = self.declare_import(iface, name, &sig.params, &sig.results); // ... then call the function with all our operands if sig.results.len() > 0 { diff --git a/crates/gen-guest-teavm-java/src/lib.rs b/crates/gen-guest-teavm-java/src/lib.rs index 5573a7051..ce48a6254 100644 --- a/crates/gen-guest-teavm-java/src/lib.rs +++ b/crates/gen-guest-teavm-java/src/lib.rs @@ -650,7 +650,7 @@ impl Generator for TeaVmJava { }; let module = &iface.name; - let name = iface.mangle_funcname(func); + let name = &func.name; let sig = iface.wasm_signature(AbiVariant::GuestImport, func); @@ -706,7 +706,7 @@ impl Generator for TeaVmJava { assert!(!bindgen.needs_cleanup_list); let src = bindgen.src; - let name = iface.mangle_funcname(func); + let name = &func.name; let result_type = match &sig.results[..] { [] => "void", diff --git a/crates/gen-host-js/src/lib.rs b/crates/gen-host-js/src/lib.rs index 90a608727..78d10b05b 100644 --- a/crates/gen-host-js/src/lib.rs +++ b/crates/gen-host-js/src/lib.rs @@ -674,7 +674,7 @@ impl Generator for Js { .entry(*resource) .or_insert(Vec::new()), }; - dst.push((iface.mangle_funcname(func), src)); + dst.push((func.name.to_string(), src)); } // As with `abi_variant` above, we're generating host-side bindings here @@ -2136,14 +2136,13 @@ impl Bindgen for FunctionBindgen<'_> { Instruction::CallWasm { iface: _, - base_name: _, - mangled_name, + name, sig, } => { self.bind_results(sig.results.len(), results); self.src.js(&self.src_object); self.src.js("._exports['"); - self.src.js(&mangled_name); + self.src.js(&name); self.src.js("']("); self.src.js(&operands.join(", ")); self.src.js(");\n"); diff --git a/crates/gen-host-wasmtime-py/src/lib.rs b/crates/gen-host-wasmtime-py/src/lib.rs index 6ef7d5bbd..7d064dbd4 100644 --- a/crates/gen-host-wasmtime-py/src/lib.rs +++ b/crates/gen-host-wasmtime-py/src/lib.rs @@ -41,8 +41,7 @@ struct Imports { } struct Import { - base_name: String, - mangled_name: String, + name: String, src: Source, wasm_ty: String, pysig: String, @@ -57,7 +56,7 @@ struct Exports { struct Export { python_type: &'static str, - base_name: String, + name: String, } #[derive(Default, Debug, Clone)] @@ -448,8 +447,7 @@ impl Generator for WasmtimePy { ); wasm_ty.push_str("])"); let import = Import { - base_name: func.name.clone(), - mangled_name: iface.mangle_funcname(func), + name: func.name.clone(), src: func_body, wasm_ty, pysig, @@ -530,7 +528,7 @@ impl Generator for WasmtimePy { "memory".to_string(), Export { python_type: "wasmtime.Memory", - base_name: "memory".to_owned(), + name: "memory".to_owned(), }, ); } @@ -539,15 +537,15 @@ impl Generator for WasmtimePy { name.clone(), Export { python_type: "wasmtime.Func", - base_name: name.clone(), + name: name.clone(), }, ); } exports.fields.insert( - iface.mangle_funcname(func), + func.name.clone(), Export { python_type: "wasmtime.Func", - base_name: func.name.clone(), + name: func.name.clone(), }, ); @@ -712,8 +710,8 @@ impl Generator for WasmtimePy { self.src.push_str(&format!( "linker.define('{}', '{}', wasmtime.Func(store, ty, {}, access_caller = True))\n", iface.name, - func.mangled_name, - func.base_name.to_snake_case(), + func.name, + func.name.to_snake_case(), )); } @@ -767,7 +765,7 @@ impl Generator for WasmtimePy { for (_name, export) in exports.fields.iter() { self.src.push_str(&format!( "_{}: {}\n", - export.base_name.to_snake_case(), + export.name.to_snake_case(), export.python_type )); } @@ -826,7 +824,7 @@ impl Generator for WasmtimePy { self._{snake} = {snake} ", name = name, - snake = export.base_name.to_snake_case(), + snake = export.name.to_snake_case(), ty = export.python_type, )); } @@ -1694,8 +1692,7 @@ impl Bindgen for FunctionBindgen<'_> { } Instruction::CallWasm { iface: _, - base_name, - mangled_name: _, + name, sig, } => { if sig.results.len() > 0 { @@ -1711,7 +1708,7 @@ impl Bindgen for FunctionBindgen<'_> { } builder.push_str(&self.src_object); builder.push_str("._"); - builder.push_str(&base_name.to_snake_case()); + builder.push_str(&name.to_snake_case()); builder.push_str("(caller"); if operands.len() > 0 { builder.push_str(", "); @@ -1771,7 +1768,7 @@ impl Bindgen for FunctionBindgen<'_> { name.clone(), Export { python_type: "wasmtime.Func", - base_name: name.clone(), + name: name.clone(), }, ); let name = name.to_snake_case(); diff --git a/crates/gen-host-wasmtime-rust/src/lib.rs b/crates/gen-host-wasmtime-rust/src/lib.rs index 0da6744a2..ce9f53c97 100644 --- a/crates/gen-host-wasmtime-rust/src/lib.rs +++ b/crates/gen-host-wasmtime-rust/src/lib.rs @@ -618,7 +618,7 @@ impl Generator for Wasmtime { .entry(iface.name.to_string()) .or_insert(Vec::new()) .push(Import { - name: iface.mangle_funcname(func), + name: func.name.to_string(), closure, trait_signature, }); @@ -758,8 +758,7 @@ impl Generator for Wasmtime { format!("wasmtime::TypedFunc<{}>", cvt), format!( "instance.get_typed_func::<{}, _>(&mut store, \"{}\")?", - cvt, - iface.mangle_funcname(func), + cvt, func.name, ), ), ); @@ -1907,8 +1906,7 @@ impl Bindgen for FunctionBindgen<'_> { Instruction::CallWasm { iface: _, - base_name, - mangled_name: _, + name, sig, } => { if sig.results.len() > 0 { @@ -1923,7 +1921,7 @@ impl Bindgen for FunctionBindgen<'_> { self.push_str(") = "); } self.push_str("self."); - self.push_str(&to_rust_ident(base_name)); + self.push_str(&to_rust_ident(name)); self.push_str(".call("); self.push_str("&mut caller, ("); for operand in operands { diff --git a/crates/wit-parser/src/abi.rs b/crates/wit-parser/src/abi.rs index 2770cb5b8..66bbb12ff 100644 --- a/crates/wit-parser/src/abi.rs +++ b/crates/wit-parser/src/abi.rs @@ -615,8 +615,7 @@ def_instruction! { /// provided inline as well as the types if necessary. CallWasm { iface: &'a Interface, - base_name: &'a str, - mangled_name: String, + name: &'a str, sig: &'a WasmSignature, } : [sig.params.len()] => [sig.results.len()], @@ -1154,8 +1153,7 @@ impl<'a, B: Bindgen> Generator<'a, B> { assert_eq!(self.stack.len(), sig.params.len()); self.emit(&Instruction::CallWasm { iface: self.iface, - base_name: &func.name, - mangled_name: self.iface.mangle_funcname(func), + name: &func.name, sig: &sig, }); diff --git a/crates/wit-parser/src/lib.rs b/crates/wit-parser/src/lib.rs index 7de26c382..75b877d16 100644 --- a/crates/wit-parser/src/lib.rs +++ b/crates/wit-parser/src/lib.rs @@ -7,7 +7,6 @@ use std::path::{Path, PathBuf}; pub mod abi; mod ast; -pub mod mangle; mod sizealign; pub use sizealign::*; diff --git a/crates/wit-parser/src/mangle.rs b/crates/wit-parser/src/mangle.rs deleted file mode 100644 index d7f2b95ce..000000000 --- a/crates/wit-parser/src/mangle.rs +++ /dev/null @@ -1,647 +0,0 @@ -//! Canonical ABI name mangling. -//! -//! This file implements the name mangling scheme defined [here] -//! [here]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#canonical-module-type - -use crate::{ - Case, EnumCase, Field, Flag, Function, Interface, Params, ResourceId, Result_, Results, Stream, - Type, TypeDefKind, UnionCase, -}; - -const CABI_VERSION: &str = "0.1"; - -enum PreSpace { - False, - True, -} - -impl Interface { - pub fn mangle_funcname(&self, func: &Function) -> String { - self.mangle_funcname_with_name(&func.name, func) - } - - pub fn mangle_start_funcname(&self, func: &Function) -> String { - self.mangle_funcname_with_name(&format!("cabi_start{{cabi={}}}", CABI_VERSION), func) - } - - fn mangle_funcname_with_name(&self, name: &str, func: &Function) -> String { - format!( - "{}: func{} -> {}", - name, - self.mangle_param_types(&func.params, PreSpace::False), - self.mangle_result_types(&func.results, PreSpace::True) - ) - } - - fn mangle_param_types(&self, es: &Params, _pre_space: PreSpace) -> String { - format!( - "({})", - es.iter() - .map(|e| format!("{}: {}", e.0, self.mangle_valtype(e.1))) - .collect::>() - .join(", ") - ) - } - - fn mangle_result_types(&self, es: &Results, _pre_space: PreSpace) -> String { - match es { - Results::Named(es) => { - format!( - "({})", - es.iter() - .map(|e| format!("{}: {}", e.0, self.mangle_valtype(e.1))) - .collect::>() - .join(", ") - ) - } - Results::Anon(ty) => self.mangle_valtype(*ty), - } - } - - fn mangle_valtype(&self, t: Type) -> String { - match t { - Type::Bool => "bool".to_owned(), - Type::S8 => "s8".to_owned(), - Type::U8 => "u8".to_owned(), - Type::S16 => "s16".to_owned(), - Type::U16 => "u16".to_owned(), - Type::S32 => "s32".to_owned(), - Type::U32 => "u32".to_owned(), - Type::S64 => "s64".to_owned(), - Type::U64 => "u64".to_owned(), - Type::Float32 => "float32".to_owned(), - Type::Float64 => "float64".to_owned(), - Type::Char => "char".to_owned(), - Type::String => "string".to_owned(), - Type::Handle(id) => self.mangle_handletype(id), - Type::Id(id) => self.mangle_valtypedef(&self.types[id].kind), - } - } - - fn mangle_valtypedef(&self, kind: &TypeDefKind) -> String { - match kind { - TypeDefKind::List(t) => format!("list<{}>", self.mangle_valtype(*t)), - TypeDefKind::Record(r) => self.mangle_recordtype(&r.fields), - TypeDefKind::Tuple(t) => self.mangle_tupletype(&t.types), - TypeDefKind::Flags(f) => self.mangle_flags(&f.flags), - TypeDefKind::Variant(v) => self.mangle_varianttype(&v.cases), - TypeDefKind::Enum(e) => self.mangle_enumtype(&e.cases), - TypeDefKind::Union(u) => self.mangle_uniontype(&u.cases), - TypeDefKind::Option(t) => self.mangle_optiontype(*t), - TypeDefKind::Result(r) => self.mangle_resulttype(r), - TypeDefKind::Future(t) => self.mangle_futuretype(*t), - TypeDefKind::Stream(s) => self.mangle_streamtype(s), - TypeDefKind::Type(t) => self.mangle_valtype(*t), - } - } - - fn mangle_recordtype(&self, fields: &[Field]) -> String { - format!( - "record {{ {} }}", - fields - .iter() - .map(|f| format!("{}: {}", f.name, self.mangle_valtype(f.ty))) - .collect::>() - .join(", ") - ) - } - - fn mangle_tupletype(&self, ts: &[Type]) -> String { - format!( - "tuple<{}>", - ts.iter() - .map(|t| self.mangle_valtype(*t)) - .collect::>() - .join(", ") - ) - } - - fn mangle_flags(&self, labels: &[Flag]) -> String { - format!( - "flags {{ {} }}", - labels - .iter() - .map(|f| f.name.clone()) - .collect::>() - .join(", ") - ) - } - - fn mangle_varianttype(&self, cases: &[Case]) -> String { - format!( - "variant {{ {} }}", - cases - .iter() - .map(|c| format!( - "{}{}", - c.name, - match c.ty { - Some(ty) => format!("({})", self.mangle_valtype(ty)), - None => "".to_string(), - } - )) - .collect::>() - .join(", ") - ) - } - - fn mangle_enumtype(&self, labels: &[EnumCase]) -> String { - format!( - "enum {{ {} }}", - labels - .iter() - .map(|l| l.name.clone()) - .collect::>() - .join(", ") - ) - } - - fn mangle_uniontype(&self, cases: &[UnionCase]) -> String { - format!( - "union {{ {} }}", - cases - .iter() - .map(|case| self.mangle_valtype(case.ty)) - .collect::>() - .join(", ") - ) - } - - fn mangle_optiontype(&self, t: Type) -> String { - format!("option<{}>", self.mangle_valtype(t)) - } - - fn mangle_resulttype(&self, result: &Result_) -> String { - match result { - Result_ { - ok: Some(ok), - err: Some(err), - } => { - format!( - "result<{}, {}>", - self.mangle_valtype(*ok), - self.mangle_valtype(*err) - ) - } - Result_ { - ok: None, - err: Some(err), - } => { - format!("result<_, {}>", self.mangle_valtype(*err)) - } - Result_ { - ok: Some(ok), - err: None, - } => { - format!("result<{}>", self.mangle_valtype(*ok)) - } - Result_ { - ok: None, - err: None, - } => { - format!("result",) - } - } - } - - fn mangle_handletype(&self, id: ResourceId) -> String { - format!("handle<{}>", self.resources[id].name) - } - - fn mangle_futuretype(&self, ty: Option) -> String { - match ty { - Some(ty) => format!("future<{}>", self.mangle_valtype(ty)), - None => format!("future"), - } - } - - fn mangle_streamtype(&self, stream: &Stream) -> String { - match stream { - Stream { - element: Some(element), - end: Some(end), - } => { - format!( - "stream<{}, {}>", - self.mangle_valtype(*element), - self.mangle_valtype(*end) - ) - } - Stream { - element: None, - end: Some(end), - } => { - format!("stream<_, {}>", self.mangle_valtype(*end)) - } - Stream { - element: Some(element), - end: None, - } => { - format!("stream<{}>", self.mangle_valtype(*element)) - } - Stream { - element: None, - end: None, - } => { - format!("stream",) - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{ - Docs, Enum, Flag, Flags, FunctionKind, Record, Resource, Result_, Tuple, Union, Variant, - }; - - #[test] - fn test_funcname() { - let interface = Interface::default(); - - assert_eq!( - interface.mangle_funcname(&Function { - docs: Docs::default(), - name: "foo".to_owned(), - kind: FunctionKind::Freestanding, - params: Vec::new(), - results: Results::empty(), - }), - "foo: func() -> ()" - ); - assert_eq!( - interface.mangle_funcname(&Function { - docs: Docs::default(), - name: "foo".to_owned(), - kind: FunctionKind::Freestanding, - params: vec![("a".to_owned(), Type::S64)], - results: Results::Anon(Type::S32) - }), - "foo: func(a: s64) -> s32" - ); - assert_eq!( - interface.mangle_funcname(&Function { - docs: Docs::default(), - name: "foo".to_owned(), - kind: FunctionKind::Freestanding, - params: vec![("a".to_owned(), Type::S64), ("b".to_owned(), Type::U64)], - results: Results::Anon(Type::S32) - }), - "foo: func(a: s64, b: u64) -> s32" - ); - assert_eq!( - interface.mangle_funcname(&Function { - docs: Docs::default(), - name: "foo".to_owned(), - kind: FunctionKind::Freestanding, - params: vec![("a".to_owned(), Type::S64), ("b".to_owned(), Type::U64)], - results: Results::Named(vec![ - ("x".to_owned(), Type::S32), - ("y".to_owned(), Type::U32) - ]) - }), - "foo: func(a: s64, b: u64) -> (x: s32, y: u32)" - ); - } - - #[test] - fn test_start_funcname() { - let interface = Interface::default(); - - assert_eq!( - interface.mangle_start_funcname(&Function { - docs: Docs::default(), - name: "foo".to_owned(), - kind: FunctionKind::Freestanding, - params: Vec::new(), - results: Results::empty(), - }), - format!("cabi_start{{cabi={}}}: func() -> ()", CABI_VERSION) - ); - } - - #[test] - fn test_types() { - let iface = Interface::default(); - assert_eq!(iface.mangle_valtype(Type::Bool), "bool"); - assert_eq!(iface.mangle_valtype(Type::S8), "s8"); - assert_eq!(iface.mangle_valtype(Type::U8), "u8"); - assert_eq!(iface.mangle_valtype(Type::S16), "s16"); - assert_eq!(iface.mangle_valtype(Type::U16), "u16"); - assert_eq!(iface.mangle_valtype(Type::S32), "s32"); - assert_eq!(iface.mangle_valtype(Type::U32), "u32"); - assert_eq!(iface.mangle_valtype(Type::S64), "s64"); - assert_eq!(iface.mangle_valtype(Type::U64), "u64"); - assert_eq!(iface.mangle_valtype(Type::Float32), "float32"); - assert_eq!(iface.mangle_valtype(Type::Float64), "float64"); - assert_eq!(iface.mangle_valtype(Type::Char), "char"); - assert_eq!(iface.mangle_valtype(Type::String), "string"); - } - - #[test] - fn test_listtype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::List(Type::U16)), - "list" - ); - } - - #[test] - fn test_recordtype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Record(Record { fields: Vec::new() })), - "record { }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Record(Record { - fields: vec![Field { - name: "x".to_owned(), - docs: Docs::default(), - ty: Type::Float32 - }] - })), - "record { x: float32 }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Record(Record { - fields: vec![ - Field { - name: "x".to_owned(), - docs: Docs::default(), - ty: Type::Float32 - }, - Field { - name: "y".to_owned(), - docs: Docs::default(), - ty: Type::Float64 - } - ] - })), - "record { x: float32, y: float64 }" - ); - } - - #[test] - fn test_tupletype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Tuple(Tuple { types: Vec::new() })), - "tuple<>" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Tuple(Tuple { - types: vec![Type::Float32] - })), - "tuple" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Tuple(Tuple { - types: vec![Type::Float32, Type::Float64] - })), - "tuple" - ); - } - - #[test] - fn test_flags() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Flags(Flags { flags: Vec::new() })), - "flags { }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Flags(Flags { - flags: vec![Flag { - name: "red".to_owned(), - docs: Docs::default() - }] - })), - "flags { red }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Flags(Flags { - flags: vec![ - Flag { - name: "red".to_owned(), - docs: Docs::default() - }, - Flag { - name: "green".to_owned(), - docs: Docs::default() - } - ] - })), - "flags { red, green }" - ); - } - - #[test] - fn test_varianttype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Variant(Variant { cases: Vec::new() })), - "variant { }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Variant(Variant { - cases: vec![Case { - name: "x".to_owned(), - docs: Docs::default(), - ty: Some(Type::Float32) - }] - })), - "variant { x(float32) }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Variant(Variant { - cases: vec![ - Case { - name: "x".to_owned(), - docs: Docs::default(), - ty: Some(Type::Float32) - }, - Case { - name: "y".to_owned(), - docs: Docs::default(), - ty: Some(Type::Float64) - }, - Case { - name: "z".to_owned(), - docs: Docs::default(), - ty: None, - } - ] - })), - "variant { x(float32), y(float64), z }" - ); - } - - #[test] - fn test_enumtype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Enum(Enum { cases: Vec::new() })), - "enum { }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Enum(Enum { - cases: vec![EnumCase { - name: "x".to_owned(), - docs: Docs::default(), - }] - })), - "enum { x }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Enum(Enum { - cases: vec![ - EnumCase { - name: "x".to_owned(), - docs: Docs::default(), - }, - EnumCase { - name: "y".to_owned(), - docs: Docs::default(), - } - ] - })), - "enum { x, y }" - ); - } - - #[test] - fn test_uniontype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Union(Union { cases: Vec::new() })), - "union { }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Union(Union { - cases: vec![UnionCase { - docs: Docs::default(), - ty: Type::Float32 - }] - })), - "union { float32 }" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Union(Union { - cases: vec![ - UnionCase { - docs: Docs::default(), - ty: Type::Float32 - }, - UnionCase { - docs: Docs::default(), - ty: Type::Float64 - } - ] - })), - "union { float32, float64 }" - ); - } - - #[test] - fn test_optiontype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Option(Type::S8)), - "option" - ); - } - - #[test] - fn test_resulttype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Result(Result_ { - ok: Some(Type::S32), - err: Some(Type::U32) - })), - "result" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Result(Result_ { - ok: None, - err: Some(Type::U32) - })), - "result<_, u32>" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Result(Result_ { - ok: Some(Type::S32), - err: None - })), - "result" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Result(Result_ { - ok: None, - err: None - })), - "result" - ); - } - - #[test] - fn test_handletype() { - let mut iface = Interface::default(); - let id = iface.resources.alloc(Resource { - name: "thing".to_owned(), - docs: Docs::default(), - foreign_module: None, - supertype: None, - }); - assert_eq!(iface.mangle_valtype(Type::Handle(id)), "handle"); - } - - #[test] - fn test_futuretype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Future(Some(Type::S8))), - "future" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Future(None)), - "future" - ); - } - - #[test] - fn test_streamtype() { - let iface = Interface::default(); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Stream(Stream { - element: Some(Type::S8), - end: Some(Type::U8) - })), - "stream" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Stream(Stream { - element: None, - end: Some(Type::U8) - })), - "stream<_, u8>" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Stream(Stream { - element: Some(Type::S8), - end: None - })), - "stream" - ); - assert_eq!( - iface.mangle_valtypedef(&TypeDefKind::Stream(Stream { - element: None, - end: None - })), - "stream" - ); - } -} diff --git a/tests/codegen/multi-return.wit b/tests/codegen/multi-return.wit index 880e1c5fc..932c7c169 100644 --- a/tests/codegen/multi-return.wit +++ b/tests/codegen/multi-return.wit @@ -1,5 +1,5 @@ -a: func() -b: func() -> () -c: func() -> u32 -d: func() -> (a: u32) -e: func() -> (a: u32, b: float32) +mra: func() +mrb: func() -> () +mrc: func() -> u32 +mrd: func() -> (a: u32) +mre: func() -> (a: u32, b: float32) diff --git a/tests/runtime/invalid/wasm.rs b/tests/runtime/invalid/wasm.rs index 2713da015..00c95cb80 100644 --- a/tests/runtime/invalid/wasm.rs +++ b/tests/runtime/invalid/wasm.rs @@ -2,21 +2,21 @@ wit_bindgen_guest_rust::export!("../../tests/runtime/invalid/exports.wit"); #[link(wasm_import_module = "imports")] extern "C" { - #[link_name = "roundtrip-bool: func(a: bool) -> bool"] + #[link_name = "roundtrip-bool"] fn roundtrip_bool(a: i32) -> i32; - #[link_name = "roundtrip-u16: func(a: u16) -> u16"] + #[link_name = "roundtrip-u16"] fn roundtrip_u16(a: i32) -> i32; - #[link_name = "roundtrip-u8: func(a: u8) -> u8"] + #[link_name = "roundtrip-u8"] fn roundtrip_u8(a: i32) -> i32; - #[link_name = "roundtrip-s16: func(a: s16) -> s16"] + #[link_name = "roundtrip-s16"] fn roundtrip_s16(a: i32) -> i32; - #[link_name = "roundtrip-s8: func(a: s8) -> s8"] + #[link_name = "roundtrip-s8"] fn roundtrip_s8(a: i32) -> i32; - #[link_name = "roundtrip-char: func(a: char) -> char"] + #[link_name = "roundtrip-char"] fn roundtrip_char(a: i32) -> i32; - #[link_name = "roundtrip-enum: func(a: enum { a, b, c }) -> enum { a, b, c }"] + #[link_name = "roundtrip-enum"] fn roundtrip_enum(a: i32) -> i32; - #[link_name = "get-internal: func(a: handle) -> u32"] + #[link_name = "get-internal"] fn get_internal(a: i32) -> i32; }