Add a wasmtime::component::bindgen! macro (#5317)
* Import Wasmtime support from the `wit-bindgen` repo This commit imports the `wit-bindgen-gen-host-wasmtime-rust` crate from the `wit-bindgen` repository into the upstream Wasmtime repository. I've chosen to not import the full history here since the crate is relatively small and doesn't have a ton of complexity. While the history of the crate is quite long the current iteration of the crate's history is relatively short so there's not a ton of import there anyway. The thinking is that this can now continue to evolve in-tree. * Refactor `wasmtime-component-macro` a bit Make room for a `wit_bindgen` macro to slot in. * Add initial support for a `bindgen` macro * Add tests for `wasmtime::component::bindgen!` * Improve error forgetting `async` feature * Add end-to-end tests for bindgen * Add an audit of `unicase` * Add a license to the test-helpers crate * Add vet entry for `pulldown-cmark` * Update publish script with new crate * Try to fix publish script * Update audits * Update lock file
This commit is contained in:
Alex Crichton
412
crates/wit-bindgen/src/rust.rs
Normal file
412
crates/wit-bindgen/src/rust.rs
Normal file
@@ -0,0 +1,412 @@
|
||||
use crate::types::TypeInfo;
|
||||
use heck::*;
|
||||
use std::collections::HashMap;
|
||||
use std::fmt::Write;
|
||||
use wit_parser::*;
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq)]
|
||||
pub enum TypeMode {
|
||||
Owned,
|
||||
AllBorrowed(&'static str),
|
||||
}
|
||||
|
||||
pub trait RustGenerator<'a> {
|
||||
fn iface(&self) -> &'a Interface;
|
||||
|
||||
fn push_str(&mut self, s: &str);
|
||||
fn info(&self, ty: TypeId) -> TypeInfo;
|
||||
fn default_param_mode(&self) -> TypeMode;
|
||||
|
||||
fn print_ty(&mut self, ty: &Type, mode: TypeMode) {
|
||||
match ty {
|
||||
Type::Id(t) => self.print_tyid(*t, mode),
|
||||
Type::Bool => self.push_str("bool"),
|
||||
Type::U8 => self.push_str("u8"),
|
||||
Type::U16 => self.push_str("u16"),
|
||||
Type::U32 => self.push_str("u32"),
|
||||
Type::U64 => self.push_str("u64"),
|
||||
Type::S8 => self.push_str("i8"),
|
||||
Type::S16 => self.push_str("i16"),
|
||||
Type::S32 => self.push_str("i32"),
|
||||
Type::S64 => self.push_str("i64"),
|
||||
Type::Float32 => self.push_str("f32"),
|
||||
Type::Float64 => self.push_str("f64"),
|
||||
Type::Char => self.push_str("char"),
|
||||
Type::String => match mode {
|
||||
TypeMode::AllBorrowed(lt) => {
|
||||
self.push_str("&");
|
||||
if lt != "'_" {
|
||||
self.push_str(lt);
|
||||
self.push_str(" ");
|
||||
}
|
||||
self.push_str("str");
|
||||
}
|
||||
TypeMode::Owned => self.push_str("String"),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn print_optional_ty(&mut self, ty: Option<&Type>, mode: TypeMode) {
|
||||
match ty {
|
||||
Some(ty) => self.print_ty(ty, mode),
|
||||
None => self.push_str("()"),
|
||||
}
|
||||
}
|
||||
|
||||
fn print_tyid(&mut self, id: TypeId, mode: TypeMode) {
|
||||
let info = self.info(id);
|
||||
let lt = self.lifetime_for(&info, mode);
|
||||
let ty = &self.iface().types[id];
|
||||
if ty.name.is_some() {
|
||||
let name = if lt.is_some() {
|
||||
self.param_name(id)
|
||||
} else {
|
||||
self.result_name(id)
|
||||
};
|
||||
self.push_str(&name);
|
||||
|
||||
// If the type recursively owns data and it's a
|
||||
// variant/record/list, then we need to place the
|
||||
// lifetime parameter on the type as well.
|
||||
if info.has_list && needs_generics(self.iface(), &ty.kind) {
|
||||
self.print_generics(lt);
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
fn needs_generics(iface: &Interface, ty: &TypeDefKind) -> bool {
|
||||
match ty {
|
||||
TypeDefKind::Variant(_)
|
||||
| TypeDefKind::Record(_)
|
||||
| TypeDefKind::Option(_)
|
||||
| TypeDefKind::Result(_)
|
||||
| TypeDefKind::Future(_)
|
||||
| TypeDefKind::Stream(_)
|
||||
| TypeDefKind::List(_)
|
||||
| TypeDefKind::Flags(_)
|
||||
| TypeDefKind::Enum(_)
|
||||
| TypeDefKind::Tuple(_)
|
||||
| TypeDefKind::Union(_) => true,
|
||||
TypeDefKind::Type(Type::Id(t)) => needs_generics(iface, &iface.types[*t].kind),
|
||||
TypeDefKind::Type(Type::String) => true,
|
||||
TypeDefKind::Type(_) => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match &ty.kind {
|
||||
TypeDefKind::List(t) => self.print_list(t, mode),
|
||||
|
||||
TypeDefKind::Option(t) => {
|
||||
self.push_str("Option<");
|
||||
self.print_ty(t, mode);
|
||||
self.push_str(">");
|
||||
}
|
||||
|
||||
TypeDefKind::Result(r) => {
|
||||
self.push_str("Result<");
|
||||
self.print_optional_ty(r.ok.as_ref(), mode);
|
||||
self.push_str(",");
|
||||
self.print_optional_ty(r.err.as_ref(), mode);
|
||||
self.push_str(">");
|
||||
}
|
||||
|
||||
TypeDefKind::Variant(_) => panic!("unsupported anonymous variant"),
|
||||
|
||||
// Tuple-like records are mapped directly to Rust tuples of
|
||||
// types. Note the trailing comma after each member to
|
||||
// appropriately handle 1-tuples.
|
||||
TypeDefKind::Tuple(t) => {
|
||||
self.push_str("(");
|
||||
for ty in t.types.iter() {
|
||||
self.print_ty(ty, mode);
|
||||
self.push_str(",");
|
||||
}
|
||||
self.push_str(")");
|
||||
}
|
||||
TypeDefKind::Record(_) => {
|
||||
panic!("unsupported anonymous type reference: record")
|
||||
}
|
||||
TypeDefKind::Flags(_) => {
|
||||
panic!("unsupported anonymous type reference: flags")
|
||||
}
|
||||
TypeDefKind::Enum(_) => {
|
||||
panic!("unsupported anonymous type reference: enum")
|
||||
}
|
||||
TypeDefKind::Union(_) => {
|
||||
panic!("unsupported anonymous type reference: union")
|
||||
}
|
||||
TypeDefKind::Future(ty) => {
|
||||
self.push_str("Future<");
|
||||
self.print_optional_ty(ty.as_ref(), mode);
|
||||
self.push_str(">");
|
||||
}
|
||||
TypeDefKind::Stream(stream) => {
|
||||
self.push_str("Stream<");
|
||||
self.print_optional_ty(stream.element.as_ref(), mode);
|
||||
self.push_str(",");
|
||||
self.print_optional_ty(stream.end.as_ref(), mode);
|
||||
self.push_str(">");
|
||||
}
|
||||
|
||||
TypeDefKind::Type(t) => self.print_ty(t, mode),
|
||||
}
|
||||
}
|
||||
|
||||
fn print_list(&mut self, ty: &Type, mode: TypeMode) {
|
||||
match mode {
|
||||
TypeMode::AllBorrowed(lt) => {
|
||||
self.push_str("&");
|
||||
if lt != "'_" {
|
||||
self.push_str(lt);
|
||||
self.push_str(" ");
|
||||
}
|
||||
self.push_str("[");
|
||||
self.print_ty(ty, mode);
|
||||
self.push_str("]");
|
||||
}
|
||||
TypeMode::Owned => {
|
||||
self.push_str("Vec<");
|
||||
self.print_ty(ty, mode);
|
||||
self.push_str(">");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn print_generics(&mut self, lifetime: Option<&str>) {
|
||||
if lifetime.is_none() {
|
||||
return;
|
||||
}
|
||||
self.push_str("<");
|
||||
if let Some(lt) = lifetime {
|
||||
self.push_str(lt);
|
||||
self.push_str(",");
|
||||
}
|
||||
self.push_str(">");
|
||||
}
|
||||
|
||||
fn modes_of(&self, ty: TypeId) -> Vec<(String, TypeMode)> {
|
||||
let info = self.info(ty);
|
||||
let mut result = Vec::new();
|
||||
if info.param {
|
||||
result.push((self.param_name(ty), self.default_param_mode()));
|
||||
}
|
||||
if info.result && (!info.param || self.uses_two_names(&info)) {
|
||||
result.push((self.result_name(ty), TypeMode::Owned));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// Writes the camel-cased 'name' of the passed type to `out`, as used to name union variants.
|
||||
fn write_name(&self, ty: &Type, out: &mut String) {
|
||||
match ty {
|
||||
Type::Bool => out.push_str("Bool"),
|
||||
Type::U8 => out.push_str("U8"),
|
||||
Type::U16 => out.push_str("U16"),
|
||||
Type::U32 => out.push_str("U32"),
|
||||
Type::U64 => out.push_str("U64"),
|
||||
Type::S8 => out.push_str("I8"),
|
||||
Type::S16 => out.push_str("I16"),
|
||||
Type::S32 => out.push_str("I32"),
|
||||
Type::S64 => out.push_str("I64"),
|
||||
Type::Float32 => out.push_str("F32"),
|
||||
Type::Float64 => out.push_str("F64"),
|
||||
Type::Char => out.push_str("Char"),
|
||||
Type::String => out.push_str("String"),
|
||||
Type::Id(id) => {
|
||||
let ty = &self.iface().types[*id];
|
||||
match &ty.name {
|
||||
Some(name) => out.push_str(&name.to_upper_camel_case()),
|
||||
None => match &ty.kind {
|
||||
TypeDefKind::Option(ty) => {
|
||||
out.push_str("Optional");
|
||||
self.write_name(ty, out);
|
||||
}
|
||||
TypeDefKind::Result(_) => out.push_str("Result"),
|
||||
TypeDefKind::Tuple(_) => out.push_str("Tuple"),
|
||||
TypeDefKind::List(ty) => {
|
||||
self.write_name(ty, out);
|
||||
out.push_str("List")
|
||||
}
|
||||
TypeDefKind::Future(ty) => {
|
||||
self.write_optional_name(ty.as_ref(), out);
|
||||
out.push_str("Future");
|
||||
}
|
||||
TypeDefKind::Stream(s) => {
|
||||
self.write_optional_name(s.element.as_ref(), out);
|
||||
self.write_optional_name(s.end.as_ref(), out);
|
||||
out.push_str("Stream");
|
||||
}
|
||||
|
||||
TypeDefKind::Type(ty) => self.write_name(ty, out),
|
||||
TypeDefKind::Record(_) => out.push_str("Record"),
|
||||
TypeDefKind::Flags(_) => out.push_str("Flags"),
|
||||
TypeDefKind::Variant(_) => out.push_str("Variant"),
|
||||
TypeDefKind::Enum(_) => out.push_str("Enum"),
|
||||
TypeDefKind::Union(_) => out.push_str("Union"),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn write_optional_name(&self, ty: Option<&Type>, out: &mut String) {
|
||||
match ty {
|
||||
Some(ty) => self.write_name(ty, out),
|
||||
None => out.push_str("()"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the names for the cases of the passed union.
|
||||
fn union_case_names(&self, union: &Union) -> Vec<String> {
|
||||
enum UsedState<'a> {
|
||||
/// This name has been used once before.
|
||||
///
|
||||
/// Contains a reference to the name given to the first usage so that a suffix can be added to it.
|
||||
Once(&'a mut String),
|
||||
/// This name has already been used multiple times.
|
||||
///
|
||||
/// Contains the number of times this has already been used.
|
||||
Multiple(usize),
|
||||
}
|
||||
|
||||
// A `Vec` of the names we're assigning each of the union's cases in order.
|
||||
let mut case_names = vec![String::new(); union.cases.len()];
|
||||
// A map from case names to their `UsedState`.
|
||||
let mut used = HashMap::new();
|
||||
for (case, name) in union.cases.iter().zip(case_names.iter_mut()) {
|
||||
self.write_name(&case.ty, name);
|
||||
|
||||
match used.get_mut(name.as_str()) {
|
||||
None => {
|
||||
// Initialise this name's `UsedState`, with a mutable reference to this name
|
||||
// in case we have to add a suffix to it later.
|
||||
used.insert(name.clone(), UsedState::Once(name));
|
||||
// Since this is the first (and potentially only) usage of this name,
|
||||
// we don't need to add a suffix here.
|
||||
}
|
||||
Some(state) => match state {
|
||||
UsedState::Multiple(n) => {
|
||||
// Add a suffix of the index of this usage.
|
||||
write!(name, "{n}").unwrap();
|
||||
// Add one to the number of times this type has been used.
|
||||
*n += 1;
|
||||
}
|
||||
UsedState::Once(first) => {
|
||||
// Add a suffix of 0 to the first usage.
|
||||
first.push('0');
|
||||
// We now get a suffix of 1.
|
||||
name.push('1');
|
||||
// Then update the state.
|
||||
*state = UsedState::Multiple(2);
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
case_names
|
||||
}
|
||||
|
||||
fn param_name(&self, ty: TypeId) -> String {
|
||||
let info = self.info(ty);
|
||||
let name = self.iface().types[ty]
|
||||
.name
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.to_upper_camel_case();
|
||||
if self.uses_two_names(&info) {
|
||||
format!("{}Param", name)
|
||||
} else {
|
||||
name
|
||||
}
|
||||
}
|
||||
|
||||
fn result_name(&self, ty: TypeId) -> String {
|
||||
let info = self.info(ty);
|
||||
let name = self.iface().types[ty]
|
||||
.name
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.to_upper_camel_case();
|
||||
if self.uses_two_names(&info) {
|
||||
format!("{}Result", name)
|
||||
} else {
|
||||
name
|
||||
}
|
||||
}
|
||||
|
||||
fn uses_two_names(&self, info: &TypeInfo) -> bool {
|
||||
info.has_list
|
||||
&& info.param
|
||||
&& info.result
|
||||
&& match self.default_param_mode() {
|
||||
TypeMode::AllBorrowed(_) => true,
|
||||
TypeMode::Owned => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn lifetime_for(&self, info: &TypeInfo, mode: TypeMode) -> Option<&'static str> {
|
||||
match mode {
|
||||
TypeMode::AllBorrowed(s) if info.has_list => Some(s),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn to_rust_ident(name: &str) -> String {
|
||||
match name {
|
||||
// Escape Rust keywords.
|
||||
// Source: https://doc.rust-lang.org/reference/keywords.html
|
||||
"as" => "as_".into(),
|
||||
"break" => "break_".into(),
|
||||
"const" => "const_".into(),
|
||||
"continue" => "continue_".into(),
|
||||
"crate" => "crate_".into(),
|
||||
"else" => "else_".into(),
|
||||
"enum" => "enum_".into(),
|
||||
"extern" => "extern_".into(),
|
||||
"false" => "false_".into(),
|
||||
"fn" => "fn_".into(),
|
||||
"for" => "for_".into(),
|
||||
"if" => "if_".into(),
|
||||
"impl" => "impl_".into(),
|
||||
"in" => "in_".into(),
|
||||
"let" => "let_".into(),
|
||||
"loop" => "loop_".into(),
|
||||
"match" => "match_".into(),
|
||||
"mod" => "mod_".into(),
|
||||
"move" => "move_".into(),
|
||||
"mut" => "mut_".into(),
|
||||
"pub" => "pub_".into(),
|
||||
"ref" => "ref_".into(),
|
||||
"return" => "return_".into(),
|
||||
"self" => "self_".into(),
|
||||
"static" => "static_".into(),
|
||||
"struct" => "struct_".into(),
|
||||
"super" => "super_".into(),
|
||||
"trait" => "trait_".into(),
|
||||
"true" => "true_".into(),
|
||||
"type" => "type_".into(),
|
||||
"unsafe" => "unsafe_".into(),
|
||||
"use" => "use_".into(),
|
||||
"where" => "where_".into(),
|
||||
"while" => "while_".into(),
|
||||
"async" => "async_".into(),
|
||||
"await" => "await_".into(),
|
||||
"dyn" => "dyn_".into(),
|
||||
"abstract" => "abstract_".into(),
|
||||
"become" => "become_".into(),
|
||||
"box" => "box_".into(),
|
||||
"do" => "do_".into(),
|
||||
"final" => "final_".into(),
|
||||
"macro" => "macro_".into(),
|
||||
"override" => "override_".into(),
|
||||
"priv" => "priv_".into(),
|
||||
"typeof" => "typeof_".into(),
|
||||
"unsized" => "unsized_".into(),
|
||||
"virtual" => "virtual_".into(),
|
||||
"yield" => "yield_".into(),
|
||||
"try" => "try_".into(),
|
||||
s => s.to_snake_case(),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user