Update to Rust 1.56.1

Author: mvines

ci/rust-version.sh

@@ -18,13 +18,13 @@
 if [[ -n $RUST_STABLE_VERSION ]]; then
   stable_version="$RUST_STABLE_VERSION"
 else
-  stable_version=1.54.0
+  stable_version=1.56.1
 fi
 
 if [[ -n $RUST_NIGHTLY_VERSION ]]; then
   nightly_version="$RUST_NIGHTLY_VERSION"
 else
-  nightly_version=2021-08-02
+  nightly_version=2021-11-30
 fi
 
 

stake-pool/program/src/big_vec.rs

@@ -120,8 +120,8 @@ impl<'data> BigVec<'data> {
         if self.data.len() < end_index {
             return Err(ProgramError::AccountDataTooSmall);
         }
-        let mut element_ref = &mut self.data[start_index..start_index + T::LEN];
-        element.pack_into_slice(&mut element_ref);
+        let element_ref = &mut self.data[start_index..start_index + T::LEN];
+        element.pack_into_slice(element_ref);
         Ok(())
     }
 

token-swap/program/fuzz/src/instructions.rs

@@ -245,10 +245,10 @@ fn run_fuzz(fuzz_data: FuzzData) {
     // First, transfer all pool tokens to the fee account to avoid withdrawal
     // fees and a potential crash when withdrawing just 1 pool token.
     let mut fee_account = token_swap.pool_fee_account.clone();
-    for mut pool_account in pool_accounts.values_mut() {
+    for pool_account in pool_accounts.values_mut() {
         let pool_token_amount = get_token_balance(pool_account);
         if pool_token_amount > 0 {
-            transfer(&mut pool_account, &mut fee_account, pool_token_amount);
+            transfer(pool_account, &mut fee_account, pool_token_amount);
         }
     }
     let mut pool_account = token_swap.pool_token_account.clone();
@@ -296,14 +296,14 @@ fn run_fuzz_instruction(
             trade_direction,
             instruction,
         } => {
-            let mut token_a_account = token_a_accounts.get_mut(&token_a_id).unwrap();
-            let mut token_b_account = token_b_accounts.get_mut(&token_b_id).unwrap();
+            let token_a_account = token_a_accounts.get_mut(&token_a_id).unwrap();
+            let token_b_account = token_b_accounts.get_mut(&token_b_id).unwrap();
             match trade_direction {
                 TradeDirection::AtoB => {
-                    token_swap.swap_a_to_b(&mut token_a_account, &mut token_b_account, instruction)
+                    token_swap.swap_a_to_b(token_a_account, token_b_account, instruction)
                 }
                 TradeDirection::BtoA => {
-                    token_swap.swap_b_to_a(&mut token_b_account, &mut token_a_account, instruction)
+                    token_swap.swap_b_to_a(token_b_account, token_a_account, instruction)
                 }
             }
         }
@@ -313,13 +313,13 @@ fn run_fuzz_instruction(
             pool_token_id,
             instruction,
         } => {
-            let mut token_a_account = token_a_accounts.get_mut(&token_a_id).unwrap();
-            let mut token_b_account = token_b_accounts.get_mut(&token_b_id).unwrap();
-            let mut pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
+            let token_a_account = token_a_accounts.get_mut(&token_a_id).unwrap();
+            let token_b_account = token_b_accounts.get_mut(&token_b_id).unwrap();
+            let pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
             token_swap.deposit_all_token_types(
-                &mut token_a_account,
-                &mut token_b_account,
-                &mut pool_account,
+                token_a_account,
+                token_b_account,
+                pool_account,
                 instruction,
             )
         }
@@ -329,13 +329,13 @@ fn run_fuzz_instruction(
             pool_token_id,
             instruction,
         } => {
-            let mut token_a_account = token_a_accounts.get_mut(&token_a_id).unwrap();
-            let mut token_b_account = token_b_accounts.get_mut(&token_b_id).unwrap();
-            let mut pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
+            let token_a_account = token_a_accounts.get_mut(&token_a_id).unwrap();
+            let token_b_account = token_b_accounts.get_mut(&token_b_id).unwrap();
+            let pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
             token_swap.withdraw_all_token_types(
-                &mut pool_account,
-                &mut token_a_account,
-                &mut token_b_account,
+                pool_account,
+                token_a_account,
+                token_b_account,
                 instruction,
             )
         }
@@ -345,14 +345,14 @@ fn run_fuzz_instruction(
             pool_token_id,
             instruction,
         } => {
-            let mut source_token_account = match trade_direction {
+            let source_token_account = match trade_direction {
                 TradeDirection::AtoB => token_a_accounts.get_mut(&token_account_id).unwrap(),
                 TradeDirection::BtoA => token_b_accounts.get_mut(&token_account_id).unwrap(),
             };
-            let mut pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
+            let pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
             token_swap.deposit_single_token_type_exact_amount_in(
-                &mut source_token_account,
-                &mut pool_account,
+                source_token_account,
+                pool_account,
                 instruction,
             )
         }
@@ -362,14 +362,14 @@ fn run_fuzz_instruction(
             pool_token_id,
             instruction,
         } => {
-            let mut destination_token_account = match trade_direction {
+            let destination_token_account = match trade_direction {
                 TradeDirection::AtoB => token_a_accounts.get_mut(&token_account_id).unwrap(),
                 TradeDirection::BtoA => token_b_accounts.get_mut(&token_account_id).unwrap(),
             };
-            let mut pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
+            let pool_account = pool_accounts.get_mut(&pool_token_id).unwrap();
             token_swap.withdraw_single_token_type_exact_amount_out(
-                &mut pool_account,
-                &mut destination_token_account,
+                pool_account,
+                destination_token_account,
                 instruction,
             )
         }

token-swap/program/fuzz/src/native_token_swap.rs

@@ -547,9 +547,9 @@ impl NativeTokenSwap {
 
     pub fn withdraw_all(
         &mut self,
-        mut pool_account: &mut NativeAccountData,
-        mut token_a_account: &mut NativeAccountData,
-        mut token_b_account: &mut NativeAccountData,
+        pool_account: &mut NativeAccountData,
+        token_a_account: &mut NativeAccountData,
+        token_b_account: &mut NativeAccountData,
     ) -> ProgramResult {
         let pool_token_amount = native_token::get_token_balance(pool_account);
         if pool_token_amount > 0 {
@@ -559,9 +559,9 @@ impl NativeTokenSwap {
                 minimum_token_b_amount: 0,
             };
             self.withdraw_all_token_types(
-                &mut pool_account,
-                &mut token_a_account,
-                &mut token_b_account,
+                pool_account,
+                token_a_account,
+                token_b_account,
                 instruction,
             )
         } else {