Bindings updates for 789

c-bindings-gen/src/main.rs

@@ -1076,6 +1076,17 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 				writeln!(w, ",").unwrap();
 			}
 			write!(w, "\t}}").unwrap();
+		} else if let syn::Fields::Unnamed(fields) = &var.fields {
+			needs_free = true;
+			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);
+				if idx != fields.unnamed.len() - 1 {
+					write!(w, ",").unwrap();
+				}
+			}
+			write!(w, ")").unwrap();
 		}
 		if var.discriminant.is_some() { unimplemented!(); }
 		writeln!(w, ",").unwrap();
@@ -1094,60 +1105,94 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 						write!(w, "{}{}, ", if $ref { "ref " } else { "mut " }, field.ident.as_ref().unwrap()).unwrap();
 					}
 					write!(w, "}} ").unwrap();
+				} else if let syn::Fields::Unnamed(fields) = &var.fields {
+					write!(w, "(").unwrap();
+					for (idx, field) in fields.unnamed.iter().enumerate() {
+						if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
+						write!(w, "{}{}, ", if $ref { "ref " } else { "mut " }, ('a' as u8 + idx as u8) as char).unwrap();
+					}
+					write!(w, ") ").unwrap();
 				}
 				write!(w, "=>").unwrap();
-				if let syn::Fields::Named(fields) = &var.fields {
-					write!(w, " {{\n\t\t\t\t").unwrap();
-					for field in fields.named.iter() {
-						if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
+
+				macro_rules! handle_field_a {
+					($field: expr, $field_ident: expr) => { {
+						if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
 						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.as_ref().unwrap(), &field.ty, None, false)
+							types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None, false)
 						} else {
-							types.write_from_c_conversion_new_var(&mut out, field.ident.as_ref().unwrap(), &field.ty, None)
+							types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, None)
 						};
 						if $ref || new_var {
 							if $ref {
-								write!(w, "let mut {}_nonref = (*{}).clone();\n\t\t\t\t", field.ident.as_ref().unwrap(), field.ident.as_ref().unwrap()).unwrap();
+								write!(w, "let mut {}_nonref = (*{}).clone();\n\t\t\t\t", $field_ident, $field_ident).unwrap();
 								if new_var {
-									let nonref_ident = syn::Ident::new(&format!("{}_nonref", field.ident.as_ref().unwrap()), Span::call_site());
+									let nonref_ident = syn::Ident::new(&format!("{}_nonref", $field_ident), Span::call_site());
 									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, None, 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, None);
 									}
 									write!(w, "\n\t\t\t\t").unwrap();
 								}
 							} else {
 								write!(w, "\n\t\t\t\t").unwrap();
 							}
 						}
+					} }
+				}
+				if let syn::Fields::Named(fields) = &var.fields {
+					write!(w, " {{\n\t\t\t\t").unwrap();
+					for field in fields.named.iter() {
+						handle_field_a!(field, field.ident.as_ref().unwrap());
+					}
+				} else if let syn::Fields::Unnamed(fields) = &var.fields {
+					write!(w, " {{\n\t\t\t\t").unwrap();
+					for (idx, field) in fields.unnamed.iter().enumerate() {
+						handle_field_a!(field, &syn::Ident::new(&(('a' as u8 + idx as u8) as char).to_string(), Span::call_site()));
 					}
 				} else { write!(w, " ").unwrap(); }
+
 				write!(w, "{}{}::{}", if $to_c { "" } else { "native" }, e.ident, var.ident).unwrap();
-				if let syn::Fields::Named(fields) = &var.fields {
-					write!(w, " {{").unwrap();
-					for field in fields.named.iter() {
-						if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
-						write!(w, "\n\t\t\t\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
+
+				macro_rules! handle_field_b {
+					($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, None, false);
 						} else {
-							types.write_from_c_conversion_prefix(w, &field.ty, None);
+							types.write_from_c_conversion_prefix(w, &$field.ty, None);
 						}
-						write!(w, "{}{}",
-							field.ident.as_ref().unwrap(),
+						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, None, false);
 						} else {
-							types.write_from_c_conversion_suffix(w, &field.ty, None);
+							types.write_from_c_conversion_suffix(w, &$field.ty, None);
 						}
 						write!(w, ",").unwrap();
+					} }
+				}
+
+				if let syn::Fields::Named(fields) = &var.fields {
+					write!(w, " {{").unwrap();
+					for field in fields.named.iter() {
+						if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
+						write!(w, "\n\t\t\t\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
+						handle_field_b!(field, field.ident.as_ref().unwrap());
 					}
 					writeln!(w, "\n\t\t\t\t}}").unwrap();
 					write!(w, "\t\t\t}}").unwrap();
+				} else if let syn::Fields::Unnamed(fields) = &var.fields {
+					write!(w, " (").unwrap();
+					for (idx, field) in fields.unnamed.iter().enumerate() {
+						write!(w, "\n\t\t\t\t\t").unwrap();
+						handle_field_b!(field, &syn::Ident::new(&(('a' as u8 + idx as u8) as char).to_string(), Span::call_site()));
+					}
+					writeln!(w, "\n\t\t\t\t)").unwrap();
+					write!(w, "\t\t\t}}").unwrap();
 				}
 				writeln!(w, ",").unwrap();
 			}

c-bindings-gen/src/types.rs

@@ -114,16 +114,20 @@ pub fn assert_simple_bound(bound: &syn::TraitBound) {
 /// type), otherwise it is mapped into a transparent, C-compatible version of itself.
 pub fn is_enum_opaque(e: &syn::ItemEnum) -> bool {
 	for var in e.variants.iter() {
-		if let syn::Fields::Unit = var.fields {
-		} else if let syn::Fields::Named(fields) = &var.fields {
+		if let syn::Fields::Named(fields) = &var.fields {
 			for field in fields.named.iter() {
 				match export_status(&field.attrs) {
 					ExportStatus::Export|ExportStatus::TestOnly => {},
 					ExportStatus::NoExport => return true,
 				}
 			}
-		} else {
-			return true;
+		} else if let syn::Fields::Unnamed(fields) = &var.fields {
+			for field in fields.unnamed.iter() {
+				match export_status(&field.attrs) {
+					ExportStatus::Export|ExportStatus::TestOnly => {},
+					ExportStatus::NoExport => return true,
+				}
+			}
 		}
 	}
 	false
@@ -963,7 +967,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 						").into() }"))
 			},
 			"Vec" if !is_ref => {
-				Some(("Vec::new(); for item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }"))
+				Some(("Vec::new(); for mut item in ", vec![(format!(".drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }"))
 			},
 			"Slice" => {
 				Some(("Vec::new(); for item in ", vec![(format!(".iter() {{ local_{}.push(", var_name), "**item".to_string())], "); }"))
@@ -1004,8 +1008,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 		match full_path {
 			"Result" if !is_ref => {
 				Some(("match ",
-						vec![(".result_ok { true => Ok(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.result)) }})", var_name)),
-						     ("), false => Err(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.err)) }})", var_name))],
+						vec![(".result_ok { true => Ok(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.result)) }})", var_access)),
+						     ("), false => Err(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.err)) }})", var_access))],
 						")}"))
 			},
 			"Vec"|"Slice" if !is_ref => {
@@ -1018,9 +1022,9 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 				if let Some(syn::Type::Path(p)) = single_contained {
 					if self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)) {
 						if is_ref {
-							return Some(("if ", vec![(".inner.is_null() { None } else { Some((*".to_string(), format!("{}", var_name))], ").clone()) }"))
+							return Some(("if ", vec![(".inner.is_null() { None } else { Some((*".to_string(), format!("{}", var_access))], ").clone()) }"))
 						} else {
-							return Some(("if ", vec![(".inner.is_null() { None } else { Some(".to_string(), format!("{}", var_name))], ") }"));
+							return Some(("if ", vec![(".inner.is_null() { None } else { Some(".to_string(), format!("{}", var_access))], ") }"));
 						}
 					}
 				}

lightning-c-bindings/demo.c

@@ -68,7 +68,7 @@ int main() {
 		.free = NULL,
 	};
 
-	LDKKeysManager keys = KeysManager_new(&node_seed, net, 0, 0);
+	LDKKeysManager keys = KeysManager_new(&node_seed, 0, 0);
 	LDKKeysInterface keys_source = KeysManager_as_KeysInterface(&keys);
 
 	LDKUserConfig config = UserConfig_default();

lightning-c-bindings/demo.cpp

@@ -348,7 +348,7 @@ int main() {
 		// Instantiate classes for node 1:
 		uint8_t node_seed[32];
 		memset(&node_seed, 0, 32);
-		LDK::KeysManager keys1 = KeysManager_new(&node_seed, network, 0, 0);
+		LDK::KeysManager keys1 = KeysManager_new(&node_seed, 0, 0);
 		LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 		node_secret1 = keys_source1->get_node_secret(keys_source1->this_arg);
 
@@ -370,7 +370,7 @@ int main() {
 
 		// Instantiate classes for node 2:
 		memset(&node_seed, 1, 32);
-		LDK::KeysManager keys2 = KeysManager_new(&node_seed, network, 0, 0);
+		LDK::KeysManager keys2 = KeysManager_new(&node_seed, 0, 0);
 		LDK::KeysInterface keys_source2 = KeysManager_as_KeysInterface(&keys2);
 		node_secret2 = keys_source2->get_node_secret(keys_source2->this_arg);
 
@@ -567,7 +567,7 @@ int main() {
 	mons_list1->data[0].is_owned = false; // XXX: God this sucks
 	uint8_t node_seed[32];
 	memset(&node_seed, 0, 32);
-	LDK::KeysManager keys1 = KeysManager_new(&node_seed, network, 1, 0);
+	LDK::KeysManager keys1 = KeysManager_new(&node_seed, 1, 0);
 	LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 
 	LDK::ChannelManagerReadArgs cm1_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys1), fee_est, mon1, broadcast, logger1, UserConfig_default(), std::move(mons_list1));
@@ -581,7 +581,7 @@ int main() {
 	mons_list2->data[0] = *& std::get<1>(mons2.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 	mons_list2->data[0].is_owned = false; // XXX: God this sucks
 	memset(&node_seed, 1, 32);
-	LDK::KeysManager keys2 = KeysManager_new(&node_seed, network, 1, 0);
+	LDK::KeysManager keys2 = KeysManager_new(&node_seed, 1, 0);
 
 	LDK::ChannelManagerReadArgs cm2_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys2), fee_est, mon2, broadcast, logger2, UserConfig_default(), std::move(mons_list2));
 	LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm2_read =