might Rust 1.22 finally work? Rearranged a lot of borrowing locations and macro behavior and definition locations

Author: arik-so

lightning/src/ln/peer_handler.rs

@@ -465,44 +465,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 					peer.pending_read_buffer.extend_from_slice(&data);
 					while peer.pending_read_buffer.len() > 0 {
 
-						macro_rules! encode_and_send_msg {
-							($msg: expr) => {
-								{
-									log_trace!(self, "Encoding and sending message of type {} to {}", $msg.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
-									if let PeerState::Connected(ref mut conduit) = peer.encryptor {
-										peer.pending_outbound_buffer.push_back(conduit.encrypt(&encode_msg!(&$msg)[..]));
-									}
-									peers.peers_needing_send.insert(peer_descriptor.clone());
-								}
-							}
-						}
-
-						macro_rules! try_potential_handleerror {
-							($thing: expr) => {
-								match $thing {
-									Ok(x) => x,
-									Err(e) => {
-										match e.action {
-											msgs::ErrorAction::DisconnectPeer { msg: _ } => {
-												//TODO: Try to push msg
-												log_trace!(self, "Got Err handling message, disconnecting peer because {}", e.err);
-												return Err(PeerHandleError{ no_connection_possible: false });
-											},
-											msgs::ErrorAction::IgnoreError => {
-												log_trace!(self, "Got Err handling message, ignoring because {}", e.err);
-												continue;
-											},
-											msgs::ErrorAction::SendErrorMessage { msg } => {
-												log_trace!(self, "Got Err handling message, sending Error message because {}", e.err);
-												encode_and_send_msg!(msg);
-												continue;
-											},
-										}
-									}
-								};
-							}
-						}
-
 						macro_rules! insert_node_id {
 							() => {
 								match peers.node_id_to_descriptor.entry(peer.their_node_id.unwrap()) {
@@ -519,17 +481,62 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 							}
 						}
 
+						let mut conduit_option = None;
+
 						if let &mut PeerState::Handshake(ref mut handshake) = &mut peer.encryptor {
 							let (response, conduit, remote_pubkey) = handshake.process_act(&peer.pending_read_buffer, None).unwrap();
 							peer.pending_read_buffer.drain(..); // we read it all
 
 							peer.pending_outbound_buffer.push_back(response);
 							if let Some(conduit) = conduit {
-								peer.encryptor = PeerState::Connected(conduit);
+								conduit_option = Some(conduit);
 							}
 						}
 
+						if let Some(conduit) = conduit_option {
+							// Rust 1.22 does not allow assignment in a borrowed context, even if mutable
+							peer.encryptor = PeerState::Connected(conduit);
+						}
+
 						if let &mut PeerState::Connected(ref mut conduit) = &mut peer.encryptor {
+
+							macro_rules! encode_and_send_msg {
+								($msg: expr) => {
+									{
+										log_trace!(self, "Encoding and sending message of type {} to {}", $msg.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
+										// we are in a context where conduit is known
+										peer.pending_outbound_buffer.push_back(conduit.encrypt(&encode_msg!(&$msg)[..]));
+										peers.peers_needing_send.insert(peer_descriptor.clone());
+									}
+								}
+							}
+
+							macro_rules! try_potential_handleerror {
+								($thing: expr) => {
+									match $thing {
+										Ok(x) => x,
+										Err(e) => {
+											match e.action {
+												msgs::ErrorAction::DisconnectPeer { msg: _ } => {
+													//TODO: Try to push msg
+													log_trace!(self, "Got Err handling message, disconnecting peer because {}", e.err);
+													return Err(PeerHandleError{ no_connection_possible: false });
+												},
+												msgs::ErrorAction::IgnoreError => {
+													log_trace!(self, "Got Err handling message, ignoring because {}", e.err);
+													continue;
+												},
+												msgs::ErrorAction::SendErrorMessage { msg } => {
+													log_trace!(self, "Got Err handling message, sending Error message because {}", e.err);
+													encode_and_send_msg!(msg);
+													continue;
+												},
+											}
+										}
+									};
+								}
+							}
+
 							let mut messages = conduit.decrypt_message_stream(Some(&peer.pending_read_buffer));
 
 							if messages.len() != 1 {

lightning/src/ln/peers/conduit.rs

@@ -127,6 +127,7 @@ impl Conduit {
 
 #[cfg(test)]
 mod tests {
+	use hex;
 	use ln::peers::conduit::Conduit;
 
 	#[test]

lightning/src/ln/peers/handshake/acts.rs

@@ -23,14 +23,14 @@ pub enum Act {
 impl Act {
 	/// Convert any act into a byte vector
 	pub fn serialize(&self) -> Vec<u8> {
-		match &self {
-			Act::One(ref act) => {
+		match self {
+			&Act::One(ref act) => {
 				act.0.to_vec()
 			}
-			Act::Two(ref act) => {
+			&Act::Two(ref act) => {
 				act.0.to_vec()
 			}
-			Act::Three(ref act) => {
+			&Act::Three(ref act) => {
 				act.0.to_vec()
 			}
 		}

lightning/src/ln/peers/handshake/mod.rs

@@ -2,6 +2,8 @@
 //! Handshake states can be advanced automatically, or by manually calling the appropriate step.
 //! Once complete, returns an instance of Conduit.
 
+use secp256k1;
+
 use bitcoin_hashes::{Hash, HashEngine};
 use bitcoin_hashes::sha256::Hash as Sha256;
 use secp256k1::{PublicKey, SecretKey};

lightning/src/ln/peers/handshake/tests.rs

@@ -1,5 +1,6 @@
 #![cfg(test)]
 
+use secp256k1;
 use secp256k1::key::{PublicKey, SecretKey};
 
 use ln::peers::handshake::PeerHandshake;