fix more clippy warning from toolchain upgrade

Author: mriise

actors/account/tests/account_actor_test.rs

@@ -68,11 +68,8 @@ fn token_receiver() {
     rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]);
 
     let param = Address::new_secp256k1(&[2; fvm_shared::address::SECP_PUB_LEN]).unwrap();
-    rt.call::<AccountActor>(
-        Method::Constructor as MethodNum,
-        &RawBytes::serialize(&param).unwrap(),
-    )
-    .unwrap();
+    rt.call::<AccountActor>(Method::Constructor as MethodNum, &RawBytes::serialize(param).unwrap())
+        .unwrap();
 
     rt.expect_validate_caller_any();
     let ret = rt.call::<AccountActor>(

actors/cron/tests/cron_actor_test.rs

@@ -115,7 +115,7 @@ fn epoch_tick_with_entries() {
 
 fn construct_and_verify(rt: &mut MockRuntime, params: &ConstructorParams) {
     rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]);
-    let ret = rt.call::<CronActor>(1, &RawBytes::serialize(&params).unwrap()).unwrap();
+    let ret = rt.call::<CronActor>(1, &RawBytes::serialize(params).unwrap()).unwrap();
     assert_eq!(RawBytes::default(), ret);
     rt.verify();
 }

actors/datacap/tests/datacap_actor_test.rs

@@ -47,17 +47,17 @@ mod mint {
         let (mut rt, h) = make_harness();
 
         let amt = TokenAmount::from_whole(1);
-        let ret = h.mint(&mut rt, &*ALICE, &amt, vec![]).unwrap();
+        let ret = h.mint(&mut rt, &ALICE, &amt, vec![]).unwrap();
         assert_eq!(amt, ret.supply);
         assert_eq!(amt, ret.balance);
         assert_eq!(amt, h.get_supply(&rt));
-        assert_eq!(amt, h.get_balance(&rt, &*ALICE));
+        assert_eq!(amt, h.get_balance(&rt, &ALICE));
 
-        let ret = h.mint(&mut rt, &*BOB, &amt, vec![]).unwrap();
+        let ret = h.mint(&mut rt, &BOB, &amt, vec![]).unwrap();
         assert_eq!(&amt * 2, ret.supply);
         assert_eq!(amt, ret.balance);
         assert_eq!(&amt * 2, h.get_supply(&rt));
-        assert_eq!(amt, h.get_balance(&rt, &*BOB));
+        assert_eq!(amt, h.get_balance(&rt, &BOB));
 
         h.check_state(&rt);
     }
@@ -85,7 +85,7 @@ mod mint {
         expect_abort_contains_message(
             ExitCode::USR_ILLEGAL_ARGUMENT,
             "must be a multiple of 1000000000000000000",
-            h.mint(&mut rt, &*ALICE, &amt, vec![]),
+            h.mint(&mut rt, &ALICE, &amt, vec![]),
         );
         h.check_state(&rt);
     }
@@ -94,25 +94,25 @@ mod mint {
     fn auto_allowance_on_mint() {
         let (mut rt, h) = make_harness();
         let amt = TokenAmount::from_whole(42);
-        h.mint(&mut rt, &*ALICE, &amt, vec![*BOB]).unwrap();
-        let allowance = h.get_allowance_between(&rt, &*ALICE, &*BOB);
+        h.mint(&mut rt, &ALICE, &amt, vec![*BOB]).unwrap();
+        let allowance = h.get_allowance_between(&rt, &ALICE, &BOB);
         assert!(allowance.eq(&INFINITE_ALLOWANCE));
 
         // mint again
-        h.mint(&mut rt, &*ALICE, &amt, vec![*BOB]).unwrap();
-        let allowance2 = h.get_allowance_between(&rt, &*ALICE, &*BOB);
+        h.mint(&mut rt, &ALICE, &amt, vec![*BOB]).unwrap();
+        let allowance2 = h.get_allowance_between(&rt, &ALICE, &BOB);
         assert!(allowance2.eq(&INFINITE_ALLOWANCE));
 
         // transfer of an allowance *does* deduct allowance even though it is too small to matter in practice
         let operator_data = RawBytes::new(vec![1, 2, 3, 4]);
-        h.transfer_from(&mut rt, &*BOB, &*ALICE, &h.governor, &(2 * amt.clone()), operator_data)
+        h.transfer_from(&mut rt, &BOB, &ALICE, &h.governor, &(2 * amt.clone()), operator_data)
             .unwrap();
-        let allowance3 = h.get_allowance_between(&rt, &*ALICE, &*BOB);
+        let allowance3 = h.get_allowance_between(&rt, &ALICE, &BOB);
         assert!(allowance3.eq(&INFINITE_ALLOWANCE.clone().sub(2 * amt.clone())));
 
         // minting any amount to this address at the same operator resets at infinite
-        h.mint(&mut rt, &*ALICE, &TokenAmount::from_whole(1), vec![*BOB]).unwrap();
-        let allowance = h.get_allowance_between(&rt, &*ALICE, &*BOB);
+        h.mint(&mut rt, &ALICE, &TokenAmount::from_whole(1), vec![*BOB]).unwrap();
+        let allowance = h.get_allowance_between(&rt, &ALICE, &BOB);
         assert!(allowance.eq(&INFINITE_ALLOWANCE));
 
         h.check_state(&rt);
@@ -134,20 +134,20 @@ mod transfer {
         let operator_data = RawBytes::new(vec![1, 2, 3, 4]);
 
         let amt = TokenAmount::from_whole(1);
-        h.mint(&mut rt, &*ALICE, &amt, vec![]).unwrap();
+        h.mint(&mut rt, &ALICE, &amt, vec![]).unwrap();
 
         expect_abort_contains_message(
             ExitCode::USR_FORBIDDEN,
             "transfer not allowed",
-            h.transfer(&mut rt, &*ALICE, &*BOB, &amt, operator_data.clone()),
+            h.transfer(&mut rt, &ALICE, &BOB, &amt, operator_data.clone()),
         );
         rt.reset();
 
         // Transfer to governor is allowed.
-        h.transfer(&mut rt, &*ALICE, &h.governor, &amt, operator_data.clone()).unwrap();
+        h.transfer(&mut rt, &ALICE, &h.governor, &amt, operator_data.clone()).unwrap();
 
         // The governor can transfer out.
-        h.transfer(&mut rt, &h.governor, &*BOB, &amt, operator_data).unwrap();
+        h.transfer(&mut rt, &h.governor, &BOB, &amt, operator_data).unwrap();
     }
 
     #[test]
@@ -156,21 +156,21 @@ mod transfer {
         let operator_data = RawBytes::new(vec![1, 2, 3, 4]);
 
         let amt = TokenAmount::from_whole(1);
-        h.mint(&mut rt, &*ALICE, &amt, vec![*BOB]).unwrap();
+        h.mint(&mut rt, &ALICE, &amt, vec![*BOB]).unwrap();
 
         // operator can't transfer out to third address
         expect_abort_contains_message(
             ExitCode::USR_FORBIDDEN,
             "transfer not allowed",
-            h.transfer_from(&mut rt, &*BOB, &*ALICE, &*CARLA, &amt, operator_data.clone()),
+            h.transfer_from(&mut rt, &BOB, &ALICE, &CARLA, &amt, operator_data.clone()),
         );
         rt.reset();
 
         // operator can't transfer out to self
         expect_abort_contains_message(
             ExitCode::USR_FORBIDDEN,
             "transfer not allowed",
-            h.transfer_from(&mut rt, &*BOB, &*ALICE, &*BOB, &amt, operator_data.clone()),
+            h.transfer_from(&mut rt, &BOB, &ALICE, &BOB, &amt, operator_data.clone()),
         );
         rt.reset();
         // even if governor has a delegate operator and enough tokens, delegated transfer
@@ -179,7 +179,7 @@ mod transfer {
         expect_abort_contains_message(
             ExitCode::USR_FORBIDDEN,
             "transfer not allowed",
-            h.transfer_from(&mut rt, &*BOB, &h.governor, &*ALICE, &amt, operator_data),
+            h.transfer_from(&mut rt, &BOB, &h.governor, &ALICE, &amt, operator_data),
         );
         rt.reset();
     }
@@ -202,7 +202,7 @@ mod destroy {
         let (mut rt, h) = make_harness();
 
         let amt = TokenAmount::from_whole(1);
-        h.mint(&mut rt, &*ALICE, &(2 * amt.clone()), vec![*BOB]).unwrap();
+        h.mint(&mut rt, &ALICE, &(2 * amt.clone()), vec![*BOB]).unwrap();
 
         // destroying from operator does not work
         let params = DestroyParams { owner: *ALICE, amount: amt.clone() };
@@ -216,8 +216,8 @@ mod destroy {
         );
 
         // Destroying from 0 allowance having governor works
-        assert!(h.get_allowance_between(&rt, &*ALICE, &h.governor).is_zero());
-        let ret = h.destroy(&mut rt, &*ALICE, &amt).unwrap();
+        assert!(h.get_allowance_between(&rt, &ALICE, &h.governor).is_zero());
+        let ret = h.destroy(&mut rt, &ALICE, &amt).unwrap();
         assert_eq!(ret.balance, amt); // burned 2 amt - amt = amt
         h.check_state(&rt)
     }

actors/evm/src/interpreter/instructions/ext.rs

@@ -60,13 +60,12 @@ pub fn extcodecopy(
 ) -> Result<(), StatusCode> {
     let bytecode = match get_cid_type(system.rt, addr) {
         CodeCid::EVM(addr) => get_evm_bytecode(system.rt, &addr)?,
-        CodeCid::NotFound |
-        CodeCid::Account => Vec::new(),
+        CodeCid::NotFound | CodeCid::Account => Vec::new(),
         // calling EXTCODECOPY on native actors results with a single byte 0xFE which solidtiy uses for its `assert`/`throw` methods
         // and in general invalid EVM bytecode
-        _ => vec![0xFE]
+        _ => vec![0xFE],
     };
-    
+
     copy_to_memory(&mut state.memory, dest_offset, size, data_offset, bytecode.as_slice(), true)
 }
 
@@ -95,30 +94,27 @@ pub fn get_cid_type(rt: &impl Runtime, addr: U256) -> CodeCid {
 
     if let Ok(addr) = addr.try_into() {
         rt.resolve_address(&addr)
-        .and_then(|id| {
-            rt.get_actor_code_cid(&id).map(|cid| {
-                let code_cid = rt
-                    .resolve_builtin_actor_type(&cid)
-                    .map(|t| {
-                        match t {
-                            Type::Account => CodeCid::Account,
-                            // TODO part of current account abstraction hack where emryos are accounts
-                            Type::Embryo => CodeCid::Account,
-                            Type::EVM => CodeCid::EVM(addr),
-                            // remaining builtin actors are native
-                            _ => CodeCid::Native(cid),
-                        }
-                        // not a builtin actor, so it is probably a native actor
-                    })
-                    .unwrap_or(CodeCid::Native(cid));
-                code_cid
+            .and_then(|id| {
+                rt.get_actor_code_cid(&id).map(|cid| {
+                    rt.resolve_builtin_actor_type(&cid)
+                        .map(|t| {
+                            match t {
+                                Type::Account => CodeCid::Account,
+                                // TODO part of current account abstraction hack where emryos are accounts
+                                Type::Embryo => CodeCid::Account,
+                                Type::EVM => CodeCid::EVM(addr),
+                                // remaining builtin actors are native
+                                _ => CodeCid::Native(cid),
+                            }
+                            // not a builtin actor, so it is probably a native actor
+                        })
+                        .unwrap_or(CodeCid::Native(cid))
+                })
             })
-        })
-        .unwrap_or(CodeCid::NotFound)
+            .unwrap_or(CodeCid::NotFound)
     } else {
         CodeCid::NotFound
     }
-    
 }
 
 pub fn get_evm_bytecode(rt: &impl Runtime, addr: &Address) -> Result<Vec<u8>, StatusCode> {

actors/evm/tests/ext_opcodes.rs

@@ -98,7 +98,7 @@ native_account:
             evm::Method::GetBytecode as u64,
             Default::default(),
             TokenAmount::zero(),
-            RawBytes::serialize(&bytecode_cid).unwrap(),
+            RawBytes::serialize(bytecode_cid).unwrap(),
             ExitCode::OK,
         );
 
@@ -187,7 +187,7 @@ native_actor:
         evm::Method::GetBytecode as u64,
         Default::default(),
         TokenAmount::zero(),
-        RawBytes::serialize(&bytecode_cid).unwrap(),
+        RawBytes::serialize(bytecode_cid).unwrap(),
         ExitCode::OK,
     );
 
@@ -278,7 +278,7 @@ invalid_address:
         evm::Method::GetBytecode as u64,
         Default::default(),
         TokenAmount::zero(),
-        RawBytes::serialize(&bytecode_cid).unwrap(),
+        RawBytes::serialize(bytecode_cid).unwrap(),
         ExitCode::OK,
     );
 

actors/market/tests/market_actor_test.rs

@@ -517,7 +517,7 @@ fn fail_when_balance_is_zero() {
         ExitCode::USR_ILLEGAL_ARGUMENT,
         rt.call::<MarketActor>(
             Method::AddBalance as u64,
-            &RawBytes::serialize(&PROVIDER_ADDR).unwrap(),
+            &RawBytes::serialize(PROVIDER_ADDR).unwrap(),
         ),
     );
 

actors/miner/tests/aggregate_network_fee_test.rs

@@ -24,7 +24,7 @@ fn fee_increases_if_basefee_crosses_threshold() {
         let at_no_base_fee = fee_func(10, &zero());
         let at_balance_minus_one_base_fee =
             fee_func(10, &(&*BATCH_BALANCER - TokenAmount::from_atto(1)));
-        let at_balance_base_fee = fee_func(10, &*BATCH_BALANCER);
+        let at_balance_base_fee = fee_func(10, &BATCH_BALANCER);
         let at_balance_plus_one_base_fee =
             fee_func(10, &(&*BATCH_BALANCER + TokenAmount::from_nano(1)));
         let at_balance_plus_two_base_fee =

actors/miner/tests/repay_debts.rs

@@ -88,9 +88,9 @@ fn pay_debt_partially_from_vested_funds() {
     // send 1 FIL and repay all debt from vesting funds and balance
     h.repay_debts(
         &mut rt,
-        &*BIG_BALANCE,  // send 1 FIL
+        &BIG_BALANCE,   // send 1 FIL
         &amount_locked, // 3 FIL comes from vesting funds
-        &*BIG_BALANCE,  // 1 FIL sent from balance
+        &BIG_BALANCE,   // 1 FIL sent from balance
     )
     .unwrap();
 

actors/miner/tests/withdraw_balance.rs

@@ -45,8 +45,8 @@ fn fails_if_miner_cant_repay_fee_debt() {
         h.withdraw_funds(
             &mut rt,
             h.owner,
-            &*ONE_PERCENT_BALANCE,
-            &*ONE_PERCENT_BALANCE,
+            &ONE_PERCENT_BALANCE,
+            &ONE_PERCENT_BALANCE,
             &TokenAmount::zero(),
         ),
     );

actors/power/tests/power_actor_tests.rs

@@ -596,7 +596,7 @@ fn given_no_miner_claim_update_pledge_total_should_abort() {
     h.create_miner_basic(&mut rt, *OWNER, *OWNER, *MINER).unwrap();
 
     // explicitly delete miner claim
-    h.delete_claim(&mut rt, &*MINER);
+    h.delete_claim(&mut rt, &MINER);
 
     rt.set_caller(*MINER_ACTOR_CODE_ID, *MINER);
     rt.expect_validate_caller_type(vec![Type::Miner]);

actors/verifreg/tests/harness/mod.rs

@@ -102,7 +102,7 @@ impl Harness {
         rt.expect_send(
             DATACAP_TOKEN_ACTOR_ADDR,
             ext::datacap::Method::BalanceOf as MethodNum,
-            RawBytes::serialize(&verifier_resolved).unwrap(),
+            RawBytes::serialize(verifier_resolved).unwrap(),
             TokenAmount::zero(),
             serialize(&BigIntSer(&(cap * TOKEN_PRECISION)), "").unwrap(),
             ExitCode::OK,