Drop stale () -> u8 mapping (now) used in Rust-only code

[ldk-c-bindings] / c-bindings-gen / src / main.rs

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 24bcf82f4369ca3d21403ec77bfcc753b92dc925..7f5a3ed4b33c0fa66b213646f8c720189593f330 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -388,7 +388,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
                                                                                                        ident.mutability.is_some() || ident.subpat.is_some() {
                                                                                                unimplemented!();
                                                                                        }
-                                                                                       write!(w, ", {}{}: ", if $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
+                                                                                       write!(w, ", mut {}{}: ", if $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
                                                                                }
                                                                                _ => unimplemented!(),
                                                                        }
@@ -968,20 +968,29 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
                                                        writeln!(w, "pub extern \"C\" fn {}_from_str(s: crate::c_types::Str) -> {} {{", ident, container).unwrap();
                                                        writeln!(w, "\tmatch {}::from_str(s.into()) {{", resolved_path).unwrap();
                                                        writeln!(w, "\t\tOk(r) => {{").unwrap();
-                                                       let new_var = types.write_to_c_conversion_new_var(w, &syn::Ident::new("r", Span::call_site()), &*i.self_ty, Some(&gen_types), false);
+                                                       let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("r"), &*i.self_ty, Some(&gen_types), false);
                                                        write!(w, "\t\t\tcrate::c_types::CResultTempl::ok(\n\t\t\t\t").unwrap();
                                                        types.write_to_c_conversion_inline_prefix(w, &*i.self_ty, Some(&gen_types), false);
                                                        write!(w, "{}r", if new_var { "local_" } else { "" }).unwrap();
                                                        types.write_to_c_conversion_inline_suffix(w, &*i.self_ty, Some(&gen_types), false);
                                                        writeln!(w, "\n\t\t\t)\n\t\t}},").unwrap();
-                                                       writeln!(w, "\t\tErr(e) => crate::c_types::CResultTempl::err(0u8),").unwrap();
+                                                       writeln!(w, "\t\tErr(e) => crate::c_types::CResultTempl::err(()),").unwrap();
                                                        writeln!(w, "\t}}.into()\n}}").unwrap();
                                                }
                                        } else if path_matches_nongeneric(&trait_path.1, &["Display"]) {
                                                writeln!(w, "#[no_mangle]").unwrap();
                                                writeln!(w, "/// Get the string representation of a {} object", ident).unwrap();
-                                               writeln!(w, "pub extern \"C\" fn {}_to_str(o: &{}) -> Str {{", ident, resolved_path).unwrap();
-                                               writeln!(w, "\tformat!(\"{{}}\", o).into()").unwrap();
+                                               writeln!(w, "pub extern \"C\" fn {}_to_str(o: &crate::{}) -> Str {{", ident, resolved_path).unwrap();
+
+                                               let self_ty = &i.self_ty;
+                                               let ref_type: syn::Type = syn::parse_quote!(&#self_ty);
+                                               let new_var = types.write_from_c_conversion_new_var(w, &format_ident!("o"), &ref_type, Some(&gen_types));
+                                               write!(w, "\tformat!(\"{{}}\", ").unwrap();
+                                               types.write_from_c_conversion_prefix(w, &ref_type, Some(&gen_types));
+                                               write!(w, "{}o", if new_var { "local_" } else { "" }).unwrap();
+                                               types.write_from_c_conversion_suffix(w, &ref_type, Some(&gen_types));
+                                               writeln!(w, ").into()").unwrap();
+
                                                writeln!(w, "}}").unwrap();
                                        } else {
                                                //XXX: implement for other things like ToString
@@ -1128,9 +1137,8 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
        }
        writeln_docs(w, &e.attrs, "");
 
-       if e.generics.lt_token.is_some() {
-               unimplemented!();
-       }
+       let mut gen_types = GenericTypes::new(None);
+       assert!(gen_types.learn_generics(&e.generics, types));
 
        let mut needs_free = false;
 
@@ -1146,7 +1154,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
                                if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
                                writeln_docs(w, &field.attrs, "\t\t");
                                write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
-                               types.write_c_type(w, &field.ty, None, false);
+                               types.write_c_type(w, &field.ty, Some(&gen_types), false);
                                writeln!(w, ",").unwrap();
                        }
                        write!(w, "\t}}").unwrap();
@@ -1155,7 +1163,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
                        write!(w, "(").unwrap();
                        for (idx, field) in fields.unnamed.iter().enumerate() {
                                if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
-                               types.write_c_type(w, &field.ty, None, false);
+                               types.write_c_type(w, &field.ty, Some(&gen_types), false);
                                if idx != fields.unnamed.len() - 1 {
                                        write!(w, ",").unwrap();
                                }
@@ -1195,9 +1203,9 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
                                                let mut sink = ::std::io::sink();
                                                let mut out: &mut dyn std::io::Write = if $ref { &mut sink } else { w };
                                                let new_var = if $to_c {
-                                                       types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None, false)
+                                                       types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types), false)
                                                } else {
-                                                       types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None)
+                                                       types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types))
                                                };
                                                if $ref || new_var {
                                                        if $ref {
@@ -1205,9 +1213,9 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
                                                                if new_var {
                                                                        let nonref_ident = format_ident!("{}_nonref", $field_ident);
                                                                        if $to_c {
-                                                                               types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, None, false);
+                                                                               types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types), false);
                                                                        } else {
-                                                                               types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, None);
+                                                                               types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types));
                                                                        }
                                                                        write!(w, "\n\t\t\t\t").unwrap();
                                                                }
@@ -1235,16 +1243,16 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
                                        ($field: expr, $field_ident: expr) => { {
                                                if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
                                                if $to_c {
-                                                       types.write_to_c_conversion_inline_prefix(w, &$field.ty, None, false);
+                                                       types.write_to_c_conversion_inline_prefix(w, &$field.ty, Some(&gen_types), false);
                                                } else {
-                                                       types.write_from_c_conversion_prefix(w, &$field.ty, None);
+                                                       types.write_from_c_conversion_prefix(w, &$field.ty, Some(&gen_types));
                                                }
                                                write!(w, "{}{}", $field_ident,
                                                        if $ref { "_nonref" } else { "" }).unwrap();
                                                if $to_c {
-                                                       types.write_to_c_conversion_inline_suffix(w, &$field.ty, None, false);
+                                                       types.write_to_c_conversion_inline_suffix(w, &$field.ty, Some(&gen_types), false);
                                                } else {
-                                                       types.write_from_c_conversion_suffix(w, &$field.ty, None);
+                                                       types.write_from_c_conversion_suffix(w, &$field.ty, Some(&gen_types));
                                                }
                                                write!(w, ",").unwrap();
                                        } }