Skip to content

Commit 4fdcd27

Browse files
TheBlueMattTheBlueMatt
authored
Merge pull request #124 from TheBlueMatt/main
Update to LDK 0.0.123
2 parents 10b9b31 + baec2ef commit 4fdcd27

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

65 files changed

+31782
-15943
lines changed

‎.github/workflows/build.yml

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ jobs:
4646
run: |
4747
git clone https://github.com/rust-bitcoin/rust-lightning
4848
cd rust-lightning
49-
git checkout 0.0.122-bindings
49+
git checkout 0.0.123-bindings
5050
- name: Fix Github Actions to not be broken
5151
run: git config --global --add safe.directory /__w/ldk-c-bindings/ldk-c-bindings
5252
- name: Pin proc-macro and quote to meet MSRV
@@ -106,7 +106,7 @@ jobs:
106106
run: |
107107
git clone https://github.com/rust-bitcoin/rust-lightning
108108
cd rust-lightning
109-
git checkout 0.0.122-bindings
109+
git checkout 0.0.123-bindings
110110
- name: Fix Github Actions to not be broken
111111
run: git config --global --add safe.directory /__w/ldk-c-bindings/ldk-c-bindings
112112
- name: Fetch MacOS SDK
@@ -153,7 +153,7 @@ jobs:
153153
run: |
154154
git clone https://github.com/rust-bitcoin/rust-lightning
155155
cd rust-lightning
156-
git checkout 0.0.122-bindings
156+
git checkout 0.0.123-bindings
157157
- name: Rebuild bindings using Apple clang, and check the sample app builds + links
158158
run: ./genbindings.sh ./rust-lightning true
159159
- name: Rebuild bindings using upstream clang, and check the sample app builds + links

‎c-bindings-gen/src/blocks.rs

Lines changed: 66 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -540,22 +540,32 @@ pub fn write_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, t
540540
let mut first_arg = true;
541541
let mut num_unused = 0;
542542
for inp in sig.inputs.iter() {
543+
let mut handle_self = |is_ref: bool, is_mut: bool| {
544+
write!(w, "{}this_arg: {}{}", if !is_ref { "mut " } else { "" },
545+
if is_ref {
546+
match (self_ptr, is_mut) {
547+
(true, true) => "*mut ",
548+
(true, false) => "*const ",
549+
(false, true) => "&mut ",
550+
(false, false) => "&",
551+
}
552+
} else { "" }, this_param).unwrap();
553+
assert!(first_arg);
554+
first_arg = false;
555+
};
543556
match inp {
544557
syn::FnArg::Receiver(recv) => {
545558
if !recv.attrs.is_empty() { unimplemented!(); }
546-
write!(w, "{}this_arg: {}{}", if recv.reference.is_none() { "mut " } else { "" },
547-
if recv.reference.is_some() {
548-
match (self_ptr, recv.mutability.is_some()) {
549-
(true, true) => "*mut ",
550-
(true, false) => "*const ",
551-
(false, true) => "&mut ",
552-
(false, false) => "&",
553-
}
554-
} else { "" }, this_param).unwrap();
555-
assert!(first_arg);
556-
first_arg = false;
559+
handle_self(recv.reference.is_some(), recv.mutability.is_some());
557560
},
558561
syn::FnArg::Typed(arg) => {
562+
if let syn::Pat::Ident(id) = &*arg.pat {
563+
if format!("{}", id.ident) == "self" {
564+
handle_self(id.by_ref.is_some(), id.mutability.is_some());
565+
continue;
566+
}
567+
}
568+
559569
if types.skip_arg(&*arg.ty, generics) { continue; }
560570
if !arg.attrs.is_empty() { unimplemented!(); }
561571
// First get the c type so that we can check if it ends up being a reference:
@@ -583,14 +593,19 @@ pub fn write_method_params<W: std::io::Write>(w: &mut W, sig: &syn::Signature, t
583593
write!(w, ")").unwrap();
584594
match &sig.output {
585595
syn::ReturnType::Type(_, rtype) => {
586-
write!(w, " -> ").unwrap();
587-
if let Some(mut remaining_path) = first_seg_self(&*rtype) {
588-
if remaining_path.next().is_none() {
589-
write!(w, "{}", this_param).unwrap();
590-
return;
596+
let mut ret_ty = Vec::new();
597+
types.write_c_type(&mut ret_ty, &*rtype, generics, true);
598+
599+
if !ret_ty.is_empty() {
600+
write!(w, " -> ").unwrap();
601+
if let Some(mut remaining_path) = first_seg_self(&*rtype) {
602+
if remaining_path.next().is_none() {
603+
write!(w, "{}", this_param).unwrap();
604+
return;
605+
}
591606
}
607+
w.write_all(&ret_ty).unwrap();
592608
}
593-
types.write_c_type(w, &*rtype, generics, true);
594609
},
595610
_ => {},
596611
}
@@ -606,6 +621,12 @@ pub fn write_method_var_decl_body<W: std::io::Write>(w: &mut W, sig: &syn::Signa
606621
match inp {
607622
syn::FnArg::Receiver(_) => {},
608623
syn::FnArg::Typed(arg) => {
624+
if let syn::Pat::Ident(id) = &*arg.pat {
625+
if format!("{}", id.ident) == "self" {
626+
continue;
627+
}
628+
}
629+
609630
if types.skip_arg(&*arg.ty, generics) { continue; }
610631
if !arg.attrs.is_empty() { unimplemented!(); }
611632
macro_rules! write_new_var {
@@ -666,6 +687,17 @@ pub fn write_method_call_params<W: std::io::Write>(w: &mut W, sig: &syn::Signatu
666687
}
667688
},
668689
syn::FnArg::Typed(arg) => {
690+
if let syn::Pat::Ident(id) = &*arg.pat {
691+
if format!("{}", id.ident) == "self" {
692+
if to_c {
693+
if id.by_ref.is_none() && !matches!(&*arg.ty, syn::Type::Reference(_)) { unimplemented!(); }
694+
write!(w, "self.this_arg").unwrap();
695+
first_arg = false;
696+
}
697+
continue;
698+
}
699+
}
700+
669701
if types.skip_arg(&*arg.ty, generics) {
670702
if !to_c {
671703
if !first_arg {
@@ -748,14 +780,18 @@ pub fn write_method_call_params<W: std::io::Write>(w: &mut W, sig: &syn::Signatu
748780
/// Prints concrete generic parameters for a struct/trait/function, including the less-than and
749781
/// greater-than symbols, if any generic parameters are defined.
750782
pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver, concrete_lifetimes: bool) {
751-
maybe_write_generics_intern(w, generics, generics_impld, types, concrete_lifetimes, false);
783+
maybe_write_generics_intern(w, generics, Some(generics_impld), types, concrete_lifetimes, false);
752784
}
753785

754786
pub fn maybe_write_non_lifetime_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver) {
755-
maybe_write_generics_intern(w, generics, generics_impld, types, false, true);
787+
maybe_write_generics_intern(w, generics, Some(generics_impld), types, false, true);
756788
}
757789

758-
fn maybe_write_generics_intern<W: std::io::Write>(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver, concrete_lifetimes: bool, dummy_lifetimes: bool) {
790+
pub fn maybe_write_type_non_lifetime_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generics, types: &TypeResolver) {
791+
maybe_write_generics_intern(w, generics, None, types, false, true);
792+
}
793+
794+
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) {
759795
let mut gen_types = GenericTypes::new(None);
760796
assert!(gen_types.learn_generics(generics, types));
761797
if generics.params.is_empty() { return; }
@@ -784,25 +820,28 @@ fn maybe_write_generics_intern<W: std::io::Write>(w: &mut W, generics: &syn::Gen
784820
for (idx, generic) in generics.params.iter().enumerate() {
785821
match generic {
786822
syn::GenericParam::Type(type_param) => {
787-
write!(w, "{}", if idx != 0 { ", " } else { "" }).unwrap();
823+
let mut out = Vec::new();
788824
let type_ident = &type_param.ident;
789825
if types.understood_c_type(&syn::parse_quote!(#type_ident), Some(&gen_types)) {
790-
types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false);
826+
types.write_c_type_in_generic_param(&mut out, &syn::parse_quote!(#type_ident), Some(&gen_types), false);
791827
} else {
792-
if let syn::PathArguments::AngleBracketed(args) = generics_impld {
828+
if let Some(syn::PathArguments::AngleBracketed(args)) = generics_impld {
793829
if let syn::GenericArgument::Type(ty) = &args.args[idx] {
794-
types.write_c_type_in_generic_param(w, &ty, Some(&gen_types), false);
830+
types.write_c_type_in_generic_param(&mut out, &ty, Some(&gen_types), false);
795831
}
796832
}
797833
}
834+
if !out.is_empty() {
835+
write!(w, "{}, ", String::from_utf8(out).unwrap()).unwrap();
836+
}
798837
},
799838
syn::GenericParam::Lifetime(lt) => {
800839
if dummy_lifetimes {
801-
write!(w, "'_").unwrap();
840+
write!(w, "'_, ").unwrap();
802841
} else if concrete_lifetimes {
803-
write!(w, "'static").unwrap();
842+
write!(w, "'static, ").unwrap();
804843
} else {
805-
write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap();
844+
write!(w, "'{}, ", lt.lifetime.ident).unwrap();
806845
}
807846
},
808847
_ => unimplemented!(),

‎c-bindings-gen/src/main.rs

Lines changed: 35 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1185,28 +1185,29 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
11851185
write_method_var_decl_body(w, &$trait_meth.sig, "", &mut trait_resolver, Some(&meth_gen_types), false);
11861186
let mut takes_self = false;
11871187
for inp in $m.sig.inputs.iter() {
1188-
if let syn::FnArg::Receiver(_) = inp {
1189-
takes_self = true;
1188+
match inp {
1189+
syn::FnArg::Receiver(_) => {
1190+
takes_self = true;
1191+
break;
1192+
},
1193+
syn::FnArg::Typed(ty) => {
1194+
if let syn::Pat::Ident(id) = &*ty.pat {
1195+
if format!("{}", id.ident) == "self" {
1196+
takes_self = true;
1197+
break;
1198+
}
1199+
}
1200+
}
11901201
}
11911202
}
11921203

1193-
let mut t_gen_args = String::new();
1194-
for (idx, _) in $trait.generics.params.iter().enumerate() {
1195-
if idx != 0 { t_gen_args += ", " };
1196-
t_gen_args += "_"
1197-
}
1198-
// rustc doesn't like <_> if the _ is actually a lifetime, so
1199-
// if all the parameters are lifetimes just skip it.
1200-
let mut nonlifetime_param = false;
1201-
for param in $trait.generics.params.iter() {
1202-
if let syn::GenericParam::Lifetime(_) = param {}
1203-
else { nonlifetime_param = true; }
1204-
}
1205-
if !nonlifetime_param { t_gen_args = String::new(); }
1204+
let mut t_gen_args_vec = Vec::new();
1205+
maybe_write_type_non_lifetime_generics(&mut t_gen_args_vec, &$trait.generics, &trait_resolver);
1206+
let t_gen_args = String::from_utf8(t_gen_args_vec).unwrap();
12061207
if takes_self {
1207-
write!(w, "<native{} as {}<{}>>::{}(unsafe {{ &mut *(this_arg as *mut native{}) }}, ", ident, $trait_path, t_gen_args, $m.sig.ident, ident).unwrap();
1208+
write!(w, "<native{} as {}{}>::{}(unsafe {{ &mut *(this_arg as *mut native{}) }}, ", ident, $trait_path, t_gen_args, $m.sig.ident, ident).unwrap();
12081209
} else {
1209-
write!(w, "<native{} as {}<{}>>::{}(", ident, $trait_path, t_gen_args, $m.sig.ident).unwrap();
1210+
write!(w, "<native{} as {}{}>::{}(", ident, $trait_path, t_gen_args, $m.sig.ident).unwrap();
12101211
}
12111212

12121213
let mut real_type = "".to_string();
@@ -1456,10 +1457,23 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, w_uses: &mut HashSet<String, NonRa
14561457
let mut takes_mut_self = false;
14571458
let mut takes_owned_self = false;
14581459
for inp in m.sig.inputs.iter() {
1459-
if let syn::FnArg::Receiver(r) = inp {
1460-
takes_self = true;
1461-
if r.mutability.is_some() { takes_mut_self = true; }
1462-
if r.reference.is_none() { takes_owned_self = true; }
1460+
match inp {
1461+
syn::FnArg::Receiver(r) => {
1462+
takes_self = true;
1463+
if r.mutability.is_some() { takes_mut_self = true; }
1464+
if r.reference.is_none() { takes_owned_self = true; }
1465+
break;
1466+
},
1467+
syn::FnArg::Typed(ty) => {
1468+
if let syn::Pat::Ident(id) = &*ty.pat {
1469+
if format!("{}", id.ident) == "self" {
1470+
takes_self = true;
1471+
if id.mutability.is_some() { takes_mut_self = true; }
1472+
if id.by_ref.is_none() { takes_owned_self = true; }
1473+
break;
1474+
}
1475+
}
1476+
}
14631477
}
14641478
}
14651479
if !takes_mut_self && !takes_self {

0 commit comments

Comments
 (0)