writeln!(w, "\tpub result: *mut {},", ok_type).unwrap();
} else {
writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the OK variant").unwrap();
- writeln!(w, "\tpub result: *mut std::ffi::c_void,").unwrap();
+ writeln!(w, "\tpub result: *mut core::ffi::c_void,").unwrap();
}
if err_type != "()" {
writeln!(w, "\t/// A pointer to the contents in the error state.").unwrap();
writeln!(w, "\tpub err: *mut {},", err_type).unwrap();
} else {
writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the Err variant").unwrap();
- writeln!(w, "\tpub err: *mut std::ffi::c_void,").unwrap();
+ writeln!(w, "\tpub err: *mut core::ffi::c_void,").unwrap();
}
writeln!(w, "}}").unwrap();
writeln!(w, "#[repr(C)]").unwrap();
if ok_type != "()" {
writeln!(w, "\t\t\tresult: Box::into_raw(Box::new(o)),").unwrap();
} else {
- writeln!(w, "\t\t\tresult: std::ptr::null_mut(),").unwrap();
+ writeln!(w, "\t\t\tresult: core::ptr::null_mut(),").unwrap();
}
writeln!(w, "\t\t}},").unwrap();
writeln!(w, "\t\tresult_ok: true,").unwrap();
if err_type != "()" {
writeln!(w, "\t\t\terr: Box::into_raw(Box::new(e)),").unwrap();
} else {
- writeln!(w, "\t\t\terr: std::ptr::null_mut(),").unwrap();
+ writeln!(w, "\t\t\terr: core::ptr::null_mut(),").unwrap();
}
writeln!(w, "\t\t}},").unwrap();
writeln!(w, "\t\tresult_ok: false,").unwrap();
writeln!(w, "\t}}").unwrap();
writeln!(w, "}}").unwrap();
+ writeln!(w, "/// Checks if the given object is currently in the success state").unwrap();
+ writeln!(w, "#[no_mangle]").unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_is_ok(o: &{}) -> bool {{", mangled_container, mangled_container).unwrap();
+ writeln!(w, "\to.result_ok").unwrap();
+ writeln!(w, "}}").unwrap();
+
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Frees any resources used by the {}.", mangled_container).unwrap();
writeln!(w, "pub extern \"C\" fn {}_free(_res: {}) {{ }}", mangled_container, mangled_container).unwrap();
writeln!(w, "\t\tlet contents = if o.result_ok {{").unwrap();
if ok_type != "()" {
writeln!(w, "\t\t\tlet result = unsafe {{ o.contents.result }};").unwrap();
- writeln!(w, "\t\t\tunsafe {{ o.contents.result = std::ptr::null_mut() }};").unwrap();
+ writeln!(w, "\t\t\tunsafe {{ o.contents.result = core::ptr::null_mut() }};").unwrap();
writeln!(w, "\t\t\t{}Ptr {{ result }}", mangled_container).unwrap();
} else {
writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.result) }};").unwrap();
- writeln!(w, "\t\t\to.contents.result = std::ptr::null_mut();").unwrap();
- writeln!(w, "\t\t\t{}Ptr {{ result: std::ptr::null_mut() }}", mangled_container).unwrap();
+ writeln!(w, "\t\t\to.contents.result = core::ptr::null_mut();").unwrap();
+ writeln!(w, "\t\t\t{}Ptr {{ result: core::ptr::null_mut() }}", mangled_container).unwrap();
}
writeln!(w, "\t\t}} else {{").unwrap();
if err_type != "()" {
writeln!(w, "\t\t\tlet err = unsafe {{ o.contents.err }};").unwrap();
- writeln!(w, "\t\t\tunsafe {{ o.contents.err = std::ptr::null_mut(); }}").unwrap();
+ writeln!(w, "\t\t\tunsafe {{ o.contents.err = core::ptr::null_mut(); }}").unwrap();
writeln!(w, "\t\t\t{}Ptr {{ err }}", mangled_container).unwrap();
} else {
writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.err) }};").unwrap();
- writeln!(w, "\t\t\to.contents.err = std::ptr::null_mut();").unwrap();
- writeln!(w, "\t\t\t{}Ptr {{ err: std::ptr::null_mut() }}", mangled_container).unwrap();
+ writeln!(w, "\t\t\to.contents.err = core::ptr::null_mut();").unwrap();
+ writeln!(w, "\t\t\t{}Ptr {{ err: core::ptr::null_mut() }}", mangled_container).unwrap();
}
writeln!(w, "\t\t}};").unwrap();
writeln!(w, "\t\tSelf {{").unwrap();
if ok_type != "()" {
writeln!(w, "\t\t\t\tresult: Box::into_raw(Box::new(<{}>::clone(unsafe {{ &*self.contents.result }})))", ok_type).unwrap();
} else {
- writeln!(w, "\t\t\t\tresult: std::ptr::null_mut()").unwrap();
+ writeln!(w, "\t\t\t\tresult: core::ptr::null_mut()").unwrap();
}
writeln!(w, "\t\t\t}} }}").unwrap();
writeln!(w, "\t\t}} else {{").unwrap();
if err_type != "()" {
writeln!(w, "\t\t\t\terr: Box::into_raw(Box::new(<{}>::clone(unsafe {{ &*self.contents.err }})))", err_type).unwrap();
} else {
- writeln!(w, "\t\t\t\terr: std::ptr::null_mut()").unwrap();
+ writeln!(w, "\t\t\t\terr: core::ptr::null_mut()").unwrap();
}
writeln!(w, "\t\t\t}} }}").unwrap();
writeln!(w, "\t\t}}").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Creates a new {} which has the same data as `orig`", mangled_container).unwrap();
writeln!(w, "/// but with all dynamically-allocated buffers duplicated in new buffers.").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ orig.clone() }}", mangled_container, mangled_container, mangled_container).unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ Clone::clone(&orig) }}", mangled_container, mangled_container, mangled_container).unwrap();
}
}
writeln!(w, "impl {} {{", mangled_container).unwrap();
writeln!(w, "\t#[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<{}> {{", inner_type).unwrap();
writeln!(w, "\t\tif self.datalen == 0 {{ return Vec::new(); }}").unwrap();
- writeln!(w, "\t\tlet ret = unsafe {{ Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }}.into();").unwrap();
- writeln!(w, "\t\tself.data = std::ptr::null_mut();").unwrap();
+ writeln!(w, "\t\tlet ret = unsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }}.into();").unwrap();
+ writeln!(w, "\t\tself.data = core::ptr::null_mut();").unwrap();
writeln!(w, "\t\tself.datalen = 0;").unwrap();
writeln!(w, "\t\tret").unwrap();
writeln!(w, "\t}}").unwrap();
writeln!(w, "\t#[allow(unused)] pub(crate) fn as_slice(&self) -> &[{}] {{", inner_type).unwrap();
- writeln!(w, "\t\tunsafe {{ std::slice::from_raw_parts_mut(self.data, self.datalen) }}").unwrap();
+ writeln!(w, "\t\tunsafe {{ core::slice::from_raw_parts_mut(self.data, self.datalen) }}").unwrap();
writeln!(w, "\t}}").unwrap();
writeln!(w, "}}").unwrap();
writeln!(w, "impl Drop for {} {{", mangled_container).unwrap();
writeln!(w, "\tfn drop(&mut self) {{").unwrap();
writeln!(w, "\t\tif self.datalen == 0 {{ return; }}").unwrap();
- writeln!(w, "\t\tunsafe {{ Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap();
+ writeln!(w, "\t\tlet _ = unsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap();
writeln!(w, "\t}}").unwrap();
writeln!(w, "}}").unwrap();
if clonable {
writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
writeln!(w, "\t\tlet mut res = Vec::new();").unwrap();
writeln!(w, "\t\tif self.datalen == 0 {{ return Self::from(res); }}").unwrap();
- writeln!(w, "\t\tres.extend_from_slice(unsafe {{ std::slice::from_raw_parts_mut(self.data, self.datalen) }});").unwrap();
+ writeln!(w, "\t\tres.extend_from_slice(unsafe {{ core::slice::from_raw_parts_mut(self.data, self.datalen) }});").unwrap();
writeln!(w, "\t\tSelf::from(res)").unwrap();
writeln!(w, "\t}}").unwrap();
writeln!(w, "}}").unwrap();
writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
writeln!(w, "\t\tSelf {{").unwrap();
for idx in 0..types.len() {
- writeln!(w, "\t\t\t{}: self.{}.clone(),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap();
+ writeln!(w, "\t\t\t{}: Clone::clone(&self.{}),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap();
}
writeln!(w, "\t\t}}").unwrap();
writeln!(w, "\t}}").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Creates a new tuple which has the same data as `orig`").unwrap();
writeln!(w, "/// but with all dynamically-allocated buffers duplicated in new buffers.").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ orig.clone() }}", mangled_container, mangled_container, mangled_container).unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ Clone::clone(&orig) }}", mangled_container, mangled_container, mangled_container).unwrap();
}
writeln!(w, "/// Creates a new {} from the contained elements.", mangled_container).unwrap();
writeln!(w, "/// An enum which can either contain a {} or not", inner_type).unwrap();
writeln!(w, "pub enum {} {{", mangled_container).unwrap();
writeln!(w, "\t/// When we're in this state, this {} contains a {}", mangled_container, inner_type).unwrap();
- writeln!(w, "\tSome({}),", inner_type).unwrap();
+ if inner_type != "" {
+ writeln!(w, "\tSome({}),", inner_type).unwrap();
+ } else {
+ writeln!(w, "\tSome,").unwrap();
+ }
writeln!(w, "\t/// When we're in this state, this {} contains nothing", mangled_container).unwrap();
writeln!(w, "\tNone").unwrap();
writeln!(w, "}}").unwrap();
writeln!(w, "impl {} {{", mangled_container).unwrap();
writeln!(w, "\t#[allow(unused)] pub(crate) fn is_some(&self) -> bool {{").unwrap();
- writeln!(w, "\t\tif let Self::Some(_) = self {{ true }} else {{ false }}").unwrap();
+ writeln!(w, "\t\tif let Self::None = self {{ false }} else {{ true }}").unwrap();
writeln!(w, "\t}}").unwrap();
- writeln!(w, "\t#[allow(unused)] pub(crate) fn take(mut self) -> {} {{", inner_type).unwrap();
- writeln!(w, "\t\tif let Self::Some(v) = self {{ v }} else {{ unreachable!() }}").unwrap();
+ writeln!(w, "\t#[allow(unused)] pub(crate) fn is_none(&self) -> bool {{").unwrap();
+ writeln!(w, "\t\t!self.is_some()").unwrap();
writeln!(w, "\t}}").unwrap();
+ if inner_type != "" {
+ writeln!(w, "\t#[allow(unused)] pub(crate) fn take(mut self) -> {} {{", inner_type).unwrap();
+ writeln!(w, "\t\tif let Self::Some(v) = self {{ v }} else {{ unreachable!() }}").unwrap();
+ writeln!(w, "\t}}").unwrap();
+ }
writeln!(w, "}}").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Constructs a new {} containing a {}", mangled_container, inner_type).unwrap();
- writeln!(w, "pub extern \"C\" fn {}_some(o: {}) -> {} {{", mangled_container, inner_type, mangled_container).unwrap();
- writeln!(w, "\t{}::Some(o)", mangled_container).unwrap();
+ if inner_type != "" {
+ writeln!(w, "pub extern \"C\" fn {}_some(o: {}) -> {} {{", mangled_container, inner_type, mangled_container).unwrap();
+ writeln!(w, "\t{}::Some(o)", mangled_container).unwrap();
+ } else {
+ writeln!(w, "pub extern \"C\" fn {}_some() -> {} {{", mangled_container, mangled_container).unwrap();
+ writeln!(w, "\t{}::Some", mangled_container).unwrap();
+ }
writeln!(w, "}}").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Creates a new {} which has the same data as `orig`", mangled_container).unwrap();
writeln!(w, "/// but with all dynamically-allocated buffers duplicated in new buffers.").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ orig.clone() }}", mangled_container, mangled_container, mangled_container).unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ Clone::clone(&orig) }}", mangled_container, mangled_container, mangled_container).unwrap();
}
}
+/// Prints the docs from a given attribute list unless its tagged no export
+pub fn writeln_fn_docs<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, args: I, ret: &syn::ReturnType) where I: Iterator<Item = &'a syn::FnArg> {
+ writeln_docs_impl(w, attrs, prefix, Some((types, generics,
+ args.filter_map(|arg| if let syn::FnArg::Typed(ty) = arg {
+ if let syn::Pat::Ident(id) = &*ty.pat {
+ Some((id.ident.to_string(), &*ty.ty))
+ } else { unimplemented!() }
+ } else { None }),
+ if let syn::ReturnType::Type(_, ty) = ret { Some(&**ty) } else { None },
+ None
+ )));
+}
+
/// Prints the docs from a given attribute list unless its tagged no export
pub fn writeln_docs<W: std::io::Write>(w: &mut W, attrs: &[syn::Attribute], prefix: &str) {
+ writeln_docs_impl(w, attrs, prefix, None::<(_, _, std::vec::Drain<'_, (String, &syn::Type)>, _, _)>);
+}
+
+pub fn writeln_arg_docs<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, args: I, ret: Option<&syn::Type>) where I: Iterator<Item = (String, &'a syn::Type)> {
+ writeln_docs_impl(w, attrs, prefix, Some((types, generics, args, ret, None)))
+}
+
+pub fn writeln_field_docs<W: std::io::Write>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, field: &syn::Type) {
+ writeln_docs_impl(w, attrs, prefix, Some((types, generics, vec![].drain(..), None, Some(field))))
+}
+
+/// Prints the docs from a given attribute list unless its tagged no export
+fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, method_args_ret: Option<(&mut TypeResolver, Option<&GenericTypes>, I, Option<&syn::Type>, Option<&syn::Type>)>) where I: Iterator<Item = (String, &'a syn::Type)> {
for attr in attrs.iter() {
let tokens_clone = attr.tokens.clone();
let mut token_iter = tokens_clone.into_iter();
match token_iter.next().unwrap() {
TokenTree::Literal(lit) => {
// Drop the first and last chars from lit as they are always "
- let doc = format!("{}", lit);
+ let doc = format!("{}", lit).trim().replace("\n", &format!("\n{}//!", prefix));
writeln!(w, "{}//!{}", prefix, &doc[1..doc.len() - 1]).unwrap();
},
_ => unimplemented!(),
match token_iter.next().unwrap() {
TokenTree::Literal(lit) => {
// Drop the first and last chars from lit as they are always "
- let doc = format!("{}", lit);
+ let doc = format!("{}", lit).trim().replace("\n", &format!("\n{}///", prefix));
writeln!(w, "{}///{}", prefix, &doc[1..doc.len() - 1]).unwrap();
},
_ => unimplemented!(),
},
}
}
+ if let Some((types, generics, inp, outp, field_ty)) = method_args_ret {
+ let mut nullable_found = false;
+ for (name, inp) in inp {
+ if types.skip_arg(inp, generics) { continue; }
+ if if let syn::Type::Reference(syn::TypeReference { elem, .. }) = inp {
+ if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem {
+ types.is_path_transparent_container(path, generics, true)
+ } else { false }
+ } else if let syn::Type::Path(syn::TypePath { ref path, .. }) = inp {
+ types.is_path_transparent_container(path, generics, true)
+ } else { false } {
+ // Note downstream clients match this text exactly so any changes may require
+ // changes in the Java and Swift bindings, at least.
+ if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); }
+ nullable_found = true;
+ writeln!(w, "{}/// Note that {} (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix, name).unwrap();
+ }
+ }
+ if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = outp {
+ if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem {
+ types.is_path_transparent_container(path, generics, true)
+ } else { false }
+ } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = outp {
+ types.is_path_transparent_container(path, generics, true)
+ } else { false } {
+ // Note downstream clients match this text exactly so any changes may require
+ // changes in the Java and Swift bindings, at least.
+ if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); }
+ nullable_found = true;
+ writeln!(w, "{}/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap();
+ }
+ let field = field_ty.map(|ty| generics.resolve_type(ty));
+ if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = field {
+ if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem {
+ let resolved_path = types.resolve_path(path, generics);
+ if types.crate_types.opaques.get(&resolved_path).is_some() {
+ writeln!(w, "{}/// Note that this field is expected to be a reference.", prefix).unwrap();
+ }
+ types.is_path_transparent_container(path, generics, true)
+ } else { false }
+ } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = field {
+ types.is_path_transparent_container(path, generics, true)
+ } else { false } {
+ // Note downstream clients match this text exactly so any changes may require
+ // changes in the Java and Swift bindings, at least.
+ if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); }
+ writeln!(w, "{}/// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap();
+ }
+ }
+
}
/// Print the parameters in a method declaration, starting after the open parenthesis, through and
let mut first_arg = true;
let mut num_unused = 0;
for inp in sig.inputs.iter() {
+ let mut handle_self = |is_ref: bool, is_mut: bool| {
+ write!(w, "{}this_arg: {}{}", if !is_ref { "mut " } else { "" },
+ if is_ref {
+ match (self_ptr, is_mut) {
+ (true, true) => "*mut ",
+ (true, false) => "*const ",
+ (false, true) => "&mut ",
+ (false, false) => "&",
+ }
+ } else { "" }, this_param).unwrap();
+ assert!(first_arg);
+ first_arg = false;
+ };
match inp {
syn::FnArg::Receiver(recv) => {
if !recv.attrs.is_empty() { unimplemented!(); }
- write!(w, "{}this_arg: {}{}", if recv.reference.is_none() { "mut " } else { "" },
- if recv.reference.is_some() {
- match (self_ptr, recv.mutability.is_some()) {
- (true, true) => "*mut ",
- (true, false) => "*const ",
- (false, true) => "&mut ",
- (false, false) => "&",
- }
- } else { "" }, this_param).unwrap();
- assert!(first_arg);
- first_arg = false;
+ handle_self(recv.reference.is_some(), recv.mutability.is_some());
},
syn::FnArg::Typed(arg) => {
+ if let syn::Pat::Ident(id) = &*arg.pat {
+ if format!("{}", id.ident) == "self" {
+ handle_self(id.by_ref.is_some(), id.mutability.is_some());
+ continue;
+ }
+ }
+
if types.skip_arg(&*arg.ty, generics) { continue; }
if !arg.attrs.is_empty() { unimplemented!(); }
// First get the c type so that we can check if it ends up being a reference:
},
_ => unimplemented!(),
}
- w.write(&c_type).unwrap();
+ w.write_all(&c_type).unwrap();
}
}
}
write!(w, ")").unwrap();
match &sig.output {
syn::ReturnType::Type(_, rtype) => {
- write!(w, " -> ").unwrap();
- if let Some(mut remaining_path) = first_seg_self(&*rtype) {
- if remaining_path.next().is_none() {
- write!(w, "{}", this_param).unwrap();
- return;
+ let mut ret_ty = Vec::new();
+ types.write_c_type(&mut ret_ty, &*rtype, generics, true);
+
+ if !ret_ty.is_empty() {
+ write!(w, " -> ").unwrap();
+ if let Some(mut remaining_path) = first_seg_self(&*rtype) {
+ if remaining_path.next().is_none() {
+ write!(w, "{}", this_param).unwrap();
+ return;
+ }
}
+ w.write_all(&ret_ty).unwrap();
}
- types.write_c_type(w, &*rtype, generics, true);
},
_ => {},
}
match inp {
syn::FnArg::Receiver(_) => {},
syn::FnArg::Typed(arg) => {
+ if let syn::Pat::Ident(id) = &*arg.pat {
+ if format!("{}", id.ident) == "self" {
+ continue;
+ }
+ }
+
if types.skip_arg(&*arg.ty, generics) { continue; }
if !arg.attrs.is_empty() { unimplemented!(); }
macro_rules! write_new_var {
}
},
syn::FnArg::Typed(arg) => {
+ if let syn::Pat::Ident(id) = &*arg.pat {
+ if format!("{}", id.ident) == "self" {
+ if to_c {
+ if id.by_ref.is_none() && !matches!(&*arg.ty, syn::Type::Reference(_)) { unimplemented!(); }
+ write!(w, "self.this_arg").unwrap();
+ first_arg = false;
+ }
+ continue;
+ }
+ }
+
if types.skip_arg(&*arg.ty, generics) {
if !to_c {
if !first_arg {
write!(w, "ret").unwrap();
} else if !to_c && self_segs_iter.is_some() && self_segs_iter.unwrap().next().is_none() {
// If we're returning "Self" (and not "Self::X"), just do it manually
- write!(w, "{} {{ inner: Box::into_raw(Box::new(ret)), is_owned: true }}", this_type).unwrap();
+ write!(w, "{} {{ inner: ObjOps::heap_alloc(ret), is_owned: true }}", this_type).unwrap();
} else if to_c {
let new_var = types.write_from_c_conversion_new_var(w, &format_ident!("ret"), rtype, generics);
if new_var {
/// Prints concrete generic parameters for a struct/trait/function, including the less-than and
/// greater-than symbols, if any generic parameters are defined.
-pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, types: &TypeResolver, concrete_lifetimes: bool) {
+pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver, concrete_lifetimes: bool) {
+ maybe_write_generics_intern(w, generics, Some(generics_impld), types, concrete_lifetimes, false);
+}
+
+pub fn maybe_write_non_lifetime_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver) {
+ maybe_write_generics_intern(w, generics, Some(generics_impld), types, false, true);
+}
+
+pub fn maybe_write_type_non_lifetime_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, types: &TypeResolver) {
+ maybe_write_generics_intern(w, generics, None, types, false, true);
+}
+
+fn maybe_write_generics_intern<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: Option<&syn::PathArguments>, types: &TypeResolver, concrete_lifetimes: bool, dummy_lifetimes: bool) {
let mut gen_types = GenericTypes::new(None);
assert!(gen_types.learn_generics(generics, types));
- if !generics.params.is_empty() {
- write!(w, "<").unwrap();
- for (idx, generic) in generics.params.iter().enumerate() {
- match generic {
- syn::GenericParam::Type(type_param) => {
- let mut printed_param = false;
- for bound in type_param.bounds.iter() {
- if let syn::TypeParamBound::Trait(trait_bound) = bound {
- assert_simple_bound(&trait_bound);
- write!(w, "{}{}", if idx != 0 { ", " } else { "" }, gen_types.maybe_resolve_ident(&type_param.ident).unwrap()).unwrap();
- if printed_param {
- unimplemented!("Can't print generic params that have multiple non-lifetime bounds");
+ if generics.params.is_empty() { return; }
+ for generic in generics.params.iter() {
+ match generic {
+ syn::GenericParam::Type(type_param) => {
+ for bound in type_param.bounds.iter() {
+ match bound {
+ syn::TypeParamBound::Trait(t) => {
+ if let Some(trait_bound) = types.maybe_resolve_path(&t.path, None) {
+ if types.skip_path(&trait_bound) {
+ // Just hope rust deduces generic params if some bounds are skipable.
+ return;
+ }
}
- printed_param = true;
}
+ _ => {},
}
- },
- syn::GenericParam::Lifetime(lt) => {
- if concrete_lifetimes {
- write!(w, "'static").unwrap();
- } else {
- write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap();
+ }
+ }
+ _ => {},
+ }
+ }
+
+ write!(w, "<").unwrap();
+ for (idx, generic) in generics.params.iter().enumerate() {
+ match generic {
+ syn::GenericParam::Type(type_param) => {
+ let mut out = Vec::new();
+ let type_ident = &type_param.ident;
+ if types.understood_c_type(&syn::parse_quote!(#type_ident), Some(&gen_types)) {
+ types.write_c_type_in_generic_param(&mut out, &syn::parse_quote!(#type_ident), Some(&gen_types), false);
+ } else {
+ if let Some(syn::PathArguments::AngleBracketed(args)) = generics_impld {
+ if let syn::GenericArgument::Type(ty) = &args.args[idx] {
+ types.write_c_type_in_generic_param(&mut out, &ty, Some(&gen_types), false);
+ }
}
+ }
+ if !out.is_empty() {
+ write!(w, "{}, ", String::from_utf8(out).unwrap()).unwrap();
+ }
+ },
+ syn::GenericParam::Lifetime(lt) => {
+ if dummy_lifetimes {
+ write!(w, "'_, ").unwrap();
+ } else if concrete_lifetimes {
+ write!(w, "'static, ").unwrap();
+ } else {
+ write!(w, "'{}, ", lt.lifetime.ident).unwrap();
+ }
+ },
+ _ => unimplemented!(),
+ }
+ }
+ write!(w, ">").unwrap();
+}
+
+pub fn maybe_write_lifetime_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, types: &TypeResolver) {
+ let mut gen_types = GenericTypes::new(None);
+ assert!(gen_types.learn_generics(generics, types));
+ if generics.params.iter().any(|param| if let syn::GenericParam::Lifetime(_) = param { true } else { false }) {
+ write!(w, "<").unwrap();
+ for (idx, generic) in generics.params.iter().enumerate() {
+ match generic {
+ syn::GenericParam::Type(_) => {},
+ syn::GenericParam::Lifetime(lt) => {
+ write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap();
},
_ => unimplemented!(),
}
write!(w, ">").unwrap();
}
}
-
-
projects / ldk-c-bindings / blobdiff