X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fblocks.rs;h=e97fb65e88e4c0a58dfcf82e959e48515aecbc9f;hb=76eed6fb43c1d675195aff896efb325828c76498;hp=643a8be7c3c1fdb5052dde93872d3b14456c3e95;hpb=75e8cf5acf256d8ecaf0c68e60997f6423e83c04;p=ldk-c-bindings diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 643a8be..e97fb65 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -61,7 +61,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -69,7 +69,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -97,7 +97,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -117,13 +117,19 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -150,22 +156,22 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -183,7 +189,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -191,7 +197,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); @@ -200,7 +206,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, 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(); } } @@ -220,13 +226,13 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in 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(); @@ -244,7 +250,7 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in 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\tunsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); if clonable { @@ -252,7 +258,7 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in 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(); @@ -301,7 +307,7 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, 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(); @@ -309,7 +315,7 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, 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(); @@ -340,24 +346,38 @@ pub fn write_option_block(w: &mut W, mangled_container: &str, 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(); @@ -373,12 +393,38 @@ pub fn write_option_block(w: &mut W, mangled_container: &str, 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 { + 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: &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 { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, args, ret, None))) +} + +pub fn writeln_field_docs(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 { for attr in attrs.iter() { let tokens_clone = attr.tokens.clone(); let mut token_iter = tokens_clone.into_iter(); @@ -414,6 +460,51 @@ pub fn writeln_docs(w: &mut W, attrs: &[syn::Attribute], pref }, } } + if let Some((types, generics, inp, outp, field)) = 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(); + } + if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = field { + 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, .. })) = 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 @@ -626,7 +717,7 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu 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 { @@ -654,29 +745,59 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu pub fn maybe_write_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver, concrete_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; } + _ => {}, } - }, + } + } + _ => {}, + } + } + + write!(w, "<").unwrap(); + for (idx, generic) in generics.params.iter().enumerate() { + match generic { + syn::GenericParam::Type(type_param) => { + write!(w, "{}", if idx != 0 { ", " } else { "" }).unwrap(); + let type_ident = &type_param.ident; + types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false); + }, + syn::GenericParam::Lifetime(lt) => { + if concrete_lifetimes { + write!(w, "'static").unwrap(); + } else { + write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); + } + }, + _ => unimplemented!(), + } + } + write!(w, ">").unwrap(); +} + +pub fn maybe_write_lifetime_generics(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) => { - if concrete_lifetimes { - write!(w, "'static").unwrap(); - } else { - write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); - } + write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); }, _ => unimplemented!(), } @@ -684,5 +805,3 @@ pub fn maybe_write_generics(w: &mut W, generics: &syn::Generi write!(w, ">").unwrap(); } } - -