From 2d0cdbd33e63a82b5c9215d21a730e3e7a96ee74 Mon Sep 17 00:00:00 2001
From: Matt Corallo <git@bluematt.me>
Date: Thu, 8 Oct 2020 19:35:50 -0400
Subject: [PATCH] [bindings] Un-Box Tuple mapping

Because the C++ wrappers require being able to memset(0) the C
structs to skip free(), we'd previously mapped tuples with two
pointer indirections. However, because all other types already
support memset(0)'ing to disable free() logic, we can skip the
pointer indirections and the behavior is still correct.
---
 c-bindings-gen/src/types.rs             |  6 +--
 lightning-c-bindings/src/c_types/mod.rs | 58 ++++++-------------------
 2 files changed, 17 insertions(+), 47 deletions(-)

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 32036180d..3fc35e8b2 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -1697,11 +1697,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 				assert!(self.write_c_type_intern(w, gen, None, false, false, false));
 			}
 			writeln!(w, ") -> {} {{", mangled_container).unwrap();
-			writeln!(w, "\t{} {{", mangled_container).unwrap();
+			write!(w, "\t{} {{ ", mangled_container).unwrap();
 			for idx in 0..args.len() {
-				writeln!(w, "\t\t{}: Box::into_raw(Box::new({})),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap();
+				write!(w, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
 			}
-			writeln!(w, "\t}}\n}}\n").unwrap();
+			writeln!(w, "}}\n}}\n").unwrap();
 		} else {
 			writeln!(w, "").unwrap();
 		}
diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index 813e401b8..d14fe6fc7 100644
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -326,83 +326,53 @@ impl<T: Clone> Clone for CVecTempl<T> {
 
 #[repr(C)]
 pub struct C2TupleTempl<A, B> {
-	pub a: *mut A,
-	pub b: *mut B,
+	pub a: A,
+	pub b: B,
 }
 impl<A, B> From<(A, B)> for C2TupleTempl<A, B> {
 	fn from(tup: (A, B)) -> Self {
 		Self {
-			a: Box::into_raw(Box::new(tup.0)),
-			b: Box::into_raw(Box::new(tup.1)),
+			a: tup.0,
+			b: tup.1,
 		}
 	}
 }
 impl<A, B> C2TupleTempl<A, B> {
 	pub(crate) fn to_rust(mut self) -> (A, B) {
-		let res = (unsafe { *Box::from_raw(self.a) }, unsafe { *Box::from_raw(self.b) });
-		self.a = std::ptr::null_mut();
-		self.b = std::ptr::null_mut();
-		res
+		(self.a, self.b)
 	}
 }
 pub extern "C" fn C2TupleTempl_free<A, B>(_res: C2TupleTempl<A, B>) { }
-impl<A, B> Drop for C2TupleTempl<A, B> {
-	fn drop(&mut self) {
-		if !self.a.is_null() {
-			unsafe { Box::from_raw(self.a) };
-		}
-		if !self.b.is_null() {
-			unsafe { Box::from_raw(self.b) };
-		}
-	}
-}
 impl <A: Clone, B: Clone> Clone for C2TupleTempl<A, B> {
 	fn clone(&self) -> Self {
 		Self {
-			a: Box::into_raw(Box::new(unsafe { &*self.a }.clone())),
-			b: Box::into_raw(Box::new(unsafe { &*self.b }.clone()))
+			a: self.a.clone(),
+			b: self.b.clone()
 		}
 	}
 }
 
 #[repr(C)]
 pub struct C3TupleTempl<A, B, C> {
-	pub a: *mut A,
-	pub b: *mut B,
-	pub c: *mut C,
+	pub a: A,
+	pub b: B,
+	pub c: C,
 }
 impl<A, B, C> From<(A, B, C)> for C3TupleTempl<A, B, C> {
 	fn from(tup: (A, B, C)) -> Self {
 		Self {
-			a: Box::into_raw(Box::new(tup.0)),
-			b: Box::into_raw(Box::new(tup.1)),
-			c: Box::into_raw(Box::new(tup.2)),
+			a: tup.0,
+			b: tup.1,
+			c: tup.2,
 		}
 	}
 }
 impl<A, B, C> C3TupleTempl<A, B, C> {
 	pub(crate) fn to_rust(mut self) -> (A, B, C) {
-		let res = (unsafe { *Box::from_raw(self.a) }, unsafe { *Box::from_raw(self.b) }, unsafe { *Box::from_raw(self.c) });
-		self.a = std::ptr::null_mut();
-		self.b = std::ptr::null_mut();
-		self.c = std::ptr::null_mut();
-		res
+		(self.a, self.b, self.c)
 	}
 }
 pub extern "C" fn C3TupleTempl_free<A, B, C>(_res: C3TupleTempl<A, B, C>) { }
-impl<A, B, C> Drop for C3TupleTempl<A, B, C> {
-	fn drop(&mut self) {
-		if !self.a.is_null() {
-			unsafe { Box::from_raw(self.a) };
-		}
-		if !self.b.is_null() {
-			unsafe { Box::from_raw(self.b) };
-		}
-		if !self.c.is_null() {
-			unsafe { Box::from_raw(self.c) };
-		}
-	}
-}
 
 /// Utility to make it easy to set a pointer to null and get its original value in line.
 pub(crate) trait TakePointer<T> {
-- 
2.39.5