use escaping::{escape_id, handle_2big_enum_variant, NamingConvention};
use heck::{ToShoutySnakeCase, ToSnakeCase};
use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};
use witx::{BuiltinType, Id, Type, TypeRef, WasmType};
use crate::{lifetimes::LifetimeExt, UserErrorType};
pub fn type_(id: &Id) -> Ident {
escape_id(id, NamingConvention::CamelCase)
}
pub fn builtin_type(b: BuiltinType) -> TokenStream {
match b {
BuiltinType::U8 { .. } => quote!(u8),
BuiltinType::U16 => quote!(u16),
BuiltinType::U32 { .. } => quote!(u32),
BuiltinType::U64 => quote!(u64),
BuiltinType::S8 => quote!(i8),
BuiltinType::S16 => quote!(i16),
BuiltinType::S32 => quote!(i32),
BuiltinType::S64 => quote!(i64),
BuiltinType::F32 => quote!(f32),
BuiltinType::F64 => quote!(f64),
BuiltinType::Char => quote!(char),
}
}
pub fn wasm_type(ty: WasmType) -> TokenStream {
match ty {
WasmType::I32 => quote!(i32),
WasmType::I64 => quote!(i64),
WasmType::F32 => quote!(f32),
WasmType::F64 => quote!(f64),
}
}
pub fn type_ref(tref: &TypeRef, lifetime: TokenStream) -> TokenStream {
match tref {
TypeRef::Name(nt) => {
let ident = type_(&nt.name);
if nt.tref.needs_lifetime() {
quote!(#ident<#lifetime>)
} else {
quote!(#ident)
}
}
TypeRef::Value(ty) => match &**ty {
Type::Builtin(builtin) => builtin_type(*builtin),
Type::Pointer(pointee) | Type::ConstPointer(pointee) => {
let pointee_type = type_ref(&pointee, lifetime.clone());
quote!(wiggle::GuestPtr<#lifetime, #pointee_type>)
}
Type::List(pointee) => match &**pointee.type_() {
Type::Builtin(BuiltinType::Char) => {
quote!(wiggle::GuestPtr<#lifetime, str>)
}
_ => {
let pointee_type = type_ref(&pointee, lifetime.clone());
quote!(wiggle::GuestPtr<#lifetime, [#pointee_type]>)
}
},
Type::Variant(v) => match v.as_expected() {
Some((ok, err)) => {
let ok = match ok {
Some(ty) => type_ref(ty, lifetime.clone()),
None => quote!(()),
};
let err = match err {
Some(ty) => type_ref(ty, lifetime.clone()),
None => quote!(()),
};
quote!(Result<#ok, #err>)
}
None => unimplemented!("anonymous variant ref {:?}", tref),
},
Type::Record(r) if r.is_tuple() => {
let types = r
.members
.iter()
.map(|m| type_ref(&m.tref, lifetime.clone()))
.collect::<Vec<_>>();
quote!((#(#types,)*))
}
_ => unimplemented!("anonymous type ref {:?}", tref),
},
}
}
pub fn enum_variant(id: &Id) -> Ident {
handle_2big_enum_variant(id).unwrap_or_else(|| escape_id(id, NamingConvention::CamelCase))
}
pub fn flag_member(id: &Id) -> Ident {
format_ident!("{}", id.as_str().to_shouty_snake_case())
}
pub fn int_member(id: &Id) -> Ident {
format_ident!("{}", id.as_str().to_shouty_snake_case())
}
pub fn struct_member(id: &Id) -> Ident {
escape_id(id, NamingConvention::SnakeCase)
}
pub fn module(id: &Id) -> Ident {
escape_id(id, NamingConvention::SnakeCase)
}
pub fn trait_name(id: &Id) -> Ident {
escape_id(id, NamingConvention::CamelCase)
}
pub fn func(id: &Id) -> Ident {
escape_id(id, NamingConvention::SnakeCase)
}
pub fn func_param(id: &Id) -> Ident {
escape_id(id, NamingConvention::SnakeCase)
}
pub fn func_ptr_binding(id: &Id) -> Ident {
format_ident!("{}_ptr", id.as_str().to_snake_case())
}
pub fn func_len_binding(id: &Id) -> Ident {
format_ident!("{}_len", id.as_str().to_snake_case())
}
fn builtin_name(b: &BuiltinType) -> &'static str {
match b {
BuiltinType::U8 { .. } => "u8",
BuiltinType::U16 => "u16",
BuiltinType::U32 { .. } => "u32",
BuiltinType::U64 => "u64",
BuiltinType::S8 => "i8",
BuiltinType::S16 => "i16",
BuiltinType::S32 => "i32",
BuiltinType::S64 => "i64",
BuiltinType::F32 => "f32",
BuiltinType::F64 => "f64",
BuiltinType::Char => "char",
}
}
fn snake_typename(tref: &TypeRef) -> String {
match tref {
TypeRef::Name(nt) => nt.name.as_str().to_snake_case(),
TypeRef::Value(ty) => match &**ty {
Type::Builtin(b) => builtin_name(&b).to_owned(),
_ => panic!("unexpected anonymous type: {:?}", ty),
},
}
}
pub fn user_error_conversion_method(user_type: &UserErrorType) -> Ident {
let abi_type = snake_typename(&user_type.abi_type());
format_ident!(
"{}_from_{}",
abi_type,
user_type.method_fragment().to_snake_case()
)
}
mod escaping {
use {
heck::{ToSnakeCase, ToUpperCamelCase},
proc_macro2::Ident,
quote::format_ident,
witx::Id,
};
pub enum NamingConvention {
CamelCase,
SnakeCase,
}
pub fn escape_id(id: &Id, conv: NamingConvention) -> Ident {
use NamingConvention::{CamelCase, SnakeCase};
match (conv, id.as_str()) {
(CamelCase, "self") => format_ident!("Self_"),
(CamelCase, s) => format_ident!("{}", s.to_upper_camel_case()),
(SnakeCase, s) => {
let s = s.to_snake_case();
if STRICT.iter().chain(RESERVED).any(|k| *k == s) {
format_ident!("{}_", s)
} else {
format_ident!("{}", s) }
}
}
}
const STRICT: &[&str] = &[
"as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum",
"extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move",
"mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait",
"true", "type", "unsafe", "use", "where", "while",
];
const RESERVED: &[&str] = &[
"abstract", "become", "box", "do", "final", "macro", "override", "priv", "try", "typeof",
"unsized", "virtual", "yield",
];
pub fn handle_2big_enum_variant(id: &Id) -> Option<Ident> {
if id.as_str() == "2big" {
Some(format_ident!("TooBig"))
} else {
None
}
}
}