chore(evm): make Executor fields private (foundry-rs#8233)

Author: DaniPopes

crates/chisel/src/runner.rs

@@ -125,19 +125,20 @@ impl ChiselRunner {
         value: U256,
         commit: bool,
     ) -> eyre::Result<ChiselResult> {
-        let fs_commit_changed = if let Some(cheatcodes) = &mut self.executor.inspector.cheatcodes {
-            let original_fs_commit = cheatcodes.fs_commit;
-            cheatcodes.fs_commit = false;
-            original_fs_commit != cheatcodes.fs_commit
-        } else {
-            false
-        };
+        let fs_commit_changed =
+            if let Some(cheatcodes) = &mut self.executor.inspector_mut().cheatcodes {
+                let original_fs_commit = cheatcodes.fs_commit;
+                cheatcodes.fs_commit = false;
+                original_fs_commit != cheatcodes.fs_commit
+            } else {
+                false
+            };
 
         let mut res = self.executor.call_raw(from, to, calldata.clone(), value)?;
         let mut gas_used = res.gas_used;
         if matches!(res.exit_reason, return_ok!()) {
             // store the current gas limit and reset it later
-            let init_gas_limit = self.executor.env.tx.gas_limit;
+            let init_gas_limit = self.executor.env().tx.gas_limit;
 
             // the executor will return the _exact_ gas value this transaction consumed, setting
             // this value as gas limit will result in `OutOfGas` so to come up with a
@@ -148,7 +149,7 @@ impl ChiselRunner {
             let mut last_highest_gas_limit = highest_gas_limit;
             while (highest_gas_limit - lowest_gas_limit) > 1 {
                 let mid_gas_limit = (highest_gas_limit + lowest_gas_limit) / 2;
-                self.executor.env.tx.gas_limit = mid_gas_limit;
+                self.executor.env_mut().tx.gas_limit = mid_gas_limit;
                 let res = self.executor.call_raw(from, to, calldata.clone(), value)?;
                 match res.exit_reason {
                     InstructionResult::Revert |
@@ -174,13 +175,13 @@ impl ChiselRunner {
                 }
             }
             // reset gas limit in the
-            self.executor.env.tx.gas_limit = init_gas_limit;
+            self.executor.env_mut().tx.gas_limit = init_gas_limit;
         }
 
         // if we changed `fs_commit` during gas limit search, re-execute the call with original
         // value
         if fs_commit_changed {
-            if let Some(cheatcodes) = &mut self.executor.inspector.cheatcodes {
+            if let Some(cheatcodes) = &mut self.executor.inspector_mut().cheatcodes {
                 cheatcodes.fs_commit = !cheatcodes.fs_commit;
             }
 

crates/evm/core/src/backend/cow.rs

@@ -51,7 +51,7 @@ pub struct CowBackend<'a> {
 
 impl<'a> CowBackend<'a> {
     /// Creates a new `CowBackend` with the given `Backend`.
-    pub fn new(backend: &'a Backend) -> Self {
+    pub fn new_borrowed(backend: &'a Backend) -> Self {
         Self { backend: Cow::Borrowed(backend), is_initialized: false, spec_id: SpecId::LATEST }
     }
 

crates/evm/evm/src/executors/fuzz/mod.rs

@@ -234,10 +234,10 @@ impl FuzzedExecutor {
 
     /// Stores fuzz state for use with [fuzz_calldata_from_state]
     pub fn build_fuzz_state(&self) -> EvmFuzzState {
-        if let Some(fork_db) = self.executor.backend.active_fork_db() {
+        if let Some(fork_db) = self.executor.backend().active_fork_db() {
             EvmFuzzState::new(fork_db, self.config.dictionary)
         } else {
-            EvmFuzzState::new(self.executor.backend.mem_db(), self.config.dictionary)
+            EvmFuzzState::new(self.executor.backend().mem_db(), self.config.dictionary)
         }
     }
 }

crates/evm/evm/src/executors/invariant/mod.rs

@@ -364,7 +364,8 @@ impl<'a> InvariantExecutor<'a> {
             self.select_contracts_and_senders(invariant_contract.address)?;
 
         // Stores fuzz state for use with [fuzz_calldata_from_state].
-        let fuzz_state = EvmFuzzState::new(self.executor.backend.mem_db(), self.config.dictionary);
+        let fuzz_state =
+            EvmFuzzState::new(self.executor.backend().mem_db(), self.config.dictionary);
 
         // Creates the invariant strategy.
         let strat = invariant_strat(
@@ -395,7 +396,7 @@ impl<'a> InvariantExecutor<'a> {
             ));
         }
 
-        self.executor.inspector.fuzzer =
+        self.executor.inspector_mut().fuzzer =
             Some(Fuzzer { call_generator, fuzz_state: fuzz_state.clone(), collect: true });
 
         Ok((fuzz_state, targeted_contracts, strat))

crates/evm/evm/src/executors/invariant/replay.rs

@@ -138,7 +138,7 @@ pub fn replay_error(
 
 /// Sets up the calls generated by the internal fuzzer, if they exist.
 fn set_up_inner_replay(executor: &mut Executor, inner_sequence: &[Option<BasicTxDetails>]) {
-    if let Some(fuzzer) = &mut executor.inspector.fuzzer {
+    if let Some(fuzzer) = &mut executor.inspector_mut().fuzzer {
         if let Some(call_generator) = &mut fuzzer.call_generator {
             call_generator.last_sequence = Arc::new(RwLock::new(inner_sequence.to_owned()));
             call_generator.set_replay(true);

crates/evm/evm/src/executors/invariant/result.rs

@@ -56,7 +56,7 @@ pub(crate) fn assert_invariants(
 ) -> Result<Option<RawCallResult>> {
     let mut inner_sequence = vec![];
 
-    if let Some(fuzzer) = &executor.inspector.fuzzer {
+    if let Some(fuzzer) = &executor.inspector().fuzzer {
         if let Some(call_generator) = &fuzzer.call_generator {
             inner_sequence.extend(call_generator.last_sequence.read().iter().cloned());
         }

crates/evm/evm/src/executors/mod.rs

@@ -72,11 +72,11 @@ pub struct Executor {
     // only interested in the database. REVM's `EVM` is a thin
     // wrapper around spawning a new EVM on every call anyway,
     // so the performance difference should be negligible.
-    pub backend: Backend,
+    backend: Backend,
     /// The EVM environment.
-    pub env: EnvWithHandlerCfg,
+    env: EnvWithHandlerCfg,
     /// The Revm inspector stack.
-    pub inspector: InspectorStack,
+    inspector: InspectorStack,
     /// The gas limit for calls and deployments. This is different from the gas limit imposed by
     /// the passed in environment, as those limits are used by the EVM for certain opcodes like
     /// `gaslimit`.
@@ -99,7 +99,7 @@ impl Executor {
         gas_limit: u64,
     ) -> Self {
         // Need to create a non-empty contract on the cheatcodes address so `extcodesize` checks
-        // does not fail
+        // do not fail.
         backend.insert_account_info(
             CHEATCODE_ADDRESS,
             revm::primitives::AccountInfo {
@@ -114,16 +114,51 @@ impl Executor {
         Self { backend, env, inspector, gas_limit }
     }
 
-    /// Returns the spec ID of the executor.
+    fn clone_with_backend(&self, backend: Backend) -> Self {
+        let env = EnvWithHandlerCfg::new_with_spec_id(Box::new(self.env().clone()), self.spec_id());
+        Self::new(backend, env, self.inspector().clone(), self.gas_limit)
+    }
+
+    /// Returns a reference to the EVM backend.
+    pub fn backend(&self) -> &Backend {
+        &self.backend
+    }
+
+    /// Returns a mutable reference to the EVM backend.
+    pub fn backend_mut(&mut self) -> &mut Backend {
+        &mut self.backend
+    }
+
+    /// Returns a reference to the EVM environment.
+    pub fn env(&self) -> &Env {
+        &self.env.env
+    }
+
+    /// Returns a mutable reference to the EVM environment.
+    pub fn env_mut(&mut self) -> &mut Env {
+        &mut self.env.env
+    }
+
+    /// Returns a reference to the EVM inspector.
+    pub fn inspector(&self) -> &InspectorStack {
+        &self.inspector
+    }
+
+    /// Returns a mutable reference to the EVM inspector.
+    pub fn inspector_mut(&mut self) -> &mut InspectorStack {
+        &mut self.inspector
+    }
+
+    /// Returns the EVM spec ID.
     pub fn spec_id(&self) -> SpecId {
-        self.env.handler_cfg.spec_id
+        self.env.spec_id()
     }
 
     /// Creates the default CREATE2 Contract Deployer for local tests and scripts.
     pub fn deploy_create2_deployer(&mut self) -> eyre::Result<()> {
         trace!("deploying local create2 deployer");
         let create2_deployer_account = self
-            .backend
+            .backend()
             .basic_ref(DEFAULT_CREATE2_DEPLOYER)?
             .ok_or_else(|| DatabaseError::MissingAccount(DEFAULT_CREATE2_DEPLOYER))?;
 
@@ -145,53 +180,52 @@ impl Executor {
     }
 
     /// Set the balance of an account.
-    pub fn set_balance(&mut self, address: Address, amount: U256) -> DatabaseResult<&mut Self> {
+    pub fn set_balance(&mut self, address: Address, amount: U256) -> DatabaseResult<()> {
         trace!(?address, ?amount, "setting account balance");
-        let mut account = self.backend.basic_ref(address)?.unwrap_or_default();
+        let mut account = self.backend().basic_ref(address)?.unwrap_or_default();
         account.balance = amount;
-
-        self.backend.insert_account_info(address, account);
-        Ok(self)
+        self.backend_mut().insert_account_info(address, account);
+        Ok(())
     }
 
     /// Gets the balance of an account
     pub fn get_balance(&self, address: Address) -> DatabaseResult<U256> {
-        Ok(self.backend.basic_ref(address)?.map(|acc| acc.balance).unwrap_or_default())
+        Ok(self.backend().basic_ref(address)?.map(|acc| acc.balance).unwrap_or_default())
     }
 
     /// Set the nonce of an account.
-    pub fn set_nonce(&mut self, address: Address, nonce: u64) -> DatabaseResult<&mut Self> {
-        let mut account = self.backend.basic_ref(address)?.unwrap_or_default();
+    pub fn set_nonce(&mut self, address: Address, nonce: u64) -> DatabaseResult<()> {
+        let mut account = self.backend().basic_ref(address)?.unwrap_or_default();
         account.nonce = nonce;
-        self.backend.insert_account_info(address, account);
-        Ok(self)
+        self.backend_mut().insert_account_info(address, account);
+        Ok(())
     }
 
     /// Returns the nonce of an account.
     pub fn get_nonce(&self, address: Address) -> DatabaseResult<u64> {
-        Ok(self.backend.basic_ref(address)?.map(|acc| acc.nonce).unwrap_or_default())
+        Ok(self.backend().basic_ref(address)?.map(|acc| acc.nonce).unwrap_or_default())
     }
 
     /// Returns `true` if the account has no code.
     pub fn is_empty_code(&self, address: Address) -> DatabaseResult<bool> {
-        Ok(self.backend.basic_ref(address)?.map(|acc| acc.is_empty_code_hash()).unwrap_or(true))
+        Ok(self.backend().basic_ref(address)?.map(|acc| acc.is_empty_code_hash()).unwrap_or(true))
     }
 
     #[inline]
     pub fn set_tracing(&mut self, tracing: bool) -> &mut Self {
-        self.inspector.tracing(tracing);
+        self.inspector_mut().tracing(tracing);
         self
     }
 
     #[inline]
     pub fn set_debugger(&mut self, debugger: bool) -> &mut Self {
-        self.inspector.enable_debugger(debugger);
+        self.inspector_mut().enable_debugger(debugger);
         self
     }
 
     #[inline]
     pub fn set_trace_printer(&mut self, trace_printer: bool) -> &mut Self {
-        self.inspector.print(trace_printer);
+        self.inspector_mut().print(trace_printer);
         self
     }
 
@@ -242,7 +276,7 @@ impl Executor {
 
         // also mark this library as persistent, this will ensure that the state of the library is
         // persistent across fork swaps in forking mode
-        self.backend.add_persistent_account(address);
+        self.backend_mut().add_persistent_account(address);
 
         debug!(%address, "deployed contract");
 
@@ -264,15 +298,15 @@ impl Executor {
         trace!(?from, ?to, "setting up contract");
 
         let from = from.unwrap_or(CALLER);
-        self.backend.set_test_contract(to).set_caller(from);
+        self.backend_mut().set_test_contract(to).set_caller(from);
         let calldata = Bytes::from_static(&ITest::setUpCall::SELECTOR);
         let mut res = self.transact_raw(from, to, calldata, U256::ZERO)?;
         res = res.into_result(rd)?;
 
         // record any changes made to the block's environment during setup
-        self.env.block = res.env.block.clone();
+        self.env_mut().block = res.env.block.clone();
         // and also the chainid, which can be set manually
-        self.env.cfg.chain_id = res.env.cfg.chain_id;
+        self.env_mut().cfg.chain_id = res.env.cfg.chain_id;
 
         let success =
             self.is_raw_call_success(to, Cow::Borrowed(&res.state_changeset), &res, false);
@@ -356,16 +390,16 @@ impl Executor {
     ///
     /// The state after the call is **not** persisted.
     pub fn call_with_env(&self, mut env: EnvWithHandlerCfg) -> eyre::Result<RawCallResult> {
-        let mut inspector = self.inspector.clone();
-        let mut backend = CowBackend::new(&self.backend);
+        let mut inspector = self.inspector().clone();
+        let mut backend = CowBackend::new_borrowed(self.backend());
         let result = backend.inspect(&mut env, &mut inspector)?;
         convert_executed_result(env, inspector, result, backend.has_snapshot_failure())
     }
 
     /// Execute the transaction configured in `env.tx`.
     pub fn transact_with_env(&mut self, mut env: EnvWithHandlerCfg) -> eyre::Result<RawCallResult> {
-        let mut inspector = self.inspector.clone();
-        let backend = &mut self.backend;
+        let mut inspector = self.inspector().clone();
+        let backend = self.backend_mut();
         let result = backend.inspect(&mut env, &mut inspector)?;
         let mut result =
             convert_executed_result(env, inspector, result, backend.has_snapshot_failure())?;
@@ -379,11 +413,11 @@ impl Executor {
     /// This should not be exposed to the user, as it should be called only by `transact*`.
     fn commit(&mut self, result: &mut RawCallResult) {
         // Persist changes to db.
-        self.backend.commit(result.state_changeset.clone());
+        self.backend_mut().commit(result.state_changeset.clone());
 
         // Persist cheatcode state.
-        self.inspector.cheatcodes = result.cheatcodes.take();
-        if let Some(cheats) = self.inspector.cheatcodes.as_mut() {
+        self.inspector_mut().cheatcodes = result.cheatcodes.take();
+        if let Some(cheats) = self.inspector_mut().cheatcodes.as_mut() {
             // Clear broadcastable transactions
             cheats.broadcastable_transactions.clear();
             debug!(target: "evm::executors", "cleared broadcastable transactions");
@@ -393,7 +427,7 @@ impl Executor {
         }
 
         // Persist the changed environment.
-        self.inspector.set_env(&result.env);
+        self.inspector_mut().set_env(&result.env);
     }
 
     /// Checks if a call to a test contract was successful.
@@ -474,20 +508,20 @@ impl Executor {
         reverted: bool,
         state_changeset: Cow<'_, StateChangeset>,
     ) -> bool {
-        if self.backend.has_snapshot_failure() {
+        if self.backend().has_snapshot_failure() {
             // a failure occurred in a reverted snapshot, which is considered a failed test
             return false;
         }
 
         let mut success = !reverted;
         if success {
             // Construct a new bare-bones backend to evaluate success.
-            let mut backend = self.backend.clone_empty();
+            let mut backend = self.backend().clone_empty();
 
             // We only clone the test contract and cheatcode accounts,
             // that's all we need to evaluate success.
             for address in [address, CHEATCODE_ADDRESS] {
-                let Ok(acc) = self.backend.basic_ref(address) else { return false };
+                let Ok(acc) = self.backend().basic_ref(address) else { return false };
                 backend.insert_account_info(address, acc.unwrap_or_default());
             }
 
@@ -498,8 +532,7 @@ impl Executor {
             backend.commit(state_changeset.into_owned());
 
             // Check if a DSTest assertion failed
-            let executor =
-                Self::new(backend, self.env.clone(), self.inspector.clone(), self.gas_limit);
+            let executor = self.clone_with_backend(backend);
             let call = executor.call_sol(CALLER, address, &ITest::failedCall {}, U256::ZERO, None);
             match call {
                 Ok(CallResult { raw: _, decoded_result: ITest::failedReturn { failed } }) => {
@@ -526,14 +559,14 @@ impl Executor {
         value: U256,
     ) -> EnvWithHandlerCfg {
         let env = Env {
-            cfg: self.env.cfg.clone(),
+            cfg: self.env().cfg.clone(),
             // We always set the gas price to 0 so we can execute the transaction regardless of
             // network conditions - the actual gas price is kept in `self.block` and is applied by
             // the cheatcode handler if it is enabled
             block: BlockEnv {
                 basefee: U256::ZERO,
                 gas_limit: U256::from(self.gas_limit),
-                ..self.env.block.clone()
+                ..self.env().block.clone()
             },
             tx: TxEnv {
                 caller,
@@ -544,11 +577,11 @@ impl Executor {
                 gas_price: U256::ZERO,
                 gas_priority_fee: None,
                 gas_limit: self.gas_limit,
-                ..self.env.tx.clone()
+                ..self.env().tx.clone()
             },
         };
 
-        EnvWithHandlerCfg::new_with_spec_id(Box::new(env), self.env.handler_cfg.spec_id)
+        EnvWithHandlerCfg::new_with_spec_id(Box::new(env), self.spec_id())
     }
 }