pub struct CowBackend<'a, FEN: FoundryEvmNetwork> {
pub backend: Cow<'a, Backend<FEN>>,
pending_init: Option<(Address, TxKind)>,
}Expand description
A clone-on-write Backend.
Reads and executions that discard their state (Backend::create_evm) borrow the wrapped
backend. The first mutable access, such as a
cheatcode that switches forks, clones it and applies the pending test initialization, so the
original backend is never modified.
Entire purpose of this type is for fuzzing. A test function fuzzer will repeatedly execute the function via immutable raw (no state changes) calls.
N.B.: we’re assuming cheatcodes that alter the state (like multi fork swapping) are niche.
If they executed, it will require a clone of the initial input database.
This way we can support these cheatcodes cheaply without adding overhead for tests that
don’t make use of them. Alternatively each test case would require its own Backend clone,
which would add significant overhead for large fuzz sets even if the Database is not big after
setup.
Fields§
§backend: Cow<'a, Backend<FEN>>The underlying Backend.
No calls on the CowBackend will ever persistently modify the backend’s state.
pending_init: Option<(Address, TxKind)>Test initialization applied on first mutable access.
Implementations§
Source§impl<'a, FEN: FoundryEvmNetwork> CowBackend<'a, FEN>
impl<'a, FEN: FoundryEvmNetwork> CowBackend<'a, FEN>
Sourcepub const fn new_borrowed(backend: &'a Backend<FEN>) -> Self
pub const fn new_borrowed(backend: &'a Backend<FEN>) -> Self
Creates a new CowBackend with the given Backend.
Sourcepub const fn initialize(&mut self, caller: Address, kind: TxKind)
pub const fn initialize(&mut self, caller: Address, kind: TxKind)
Records the caller and test contract of the next execution, applied with
Backend::initialize on first mutable access.
Sourcepub fn park_detached(&mut self, evm: FoundryEvmFor<'_, FEN>)
pub fn park_detached(&mut self, evm: FoundryEvmFor<'_, FEN>)
Parks accepted state on owned backends; leaves pending writes uncommitted.
Methods from Deref<Target = Backend<FEN>>§
Sourcepub fn set_bal(&mut self, bal: Arc<Bal>, index: BlockAccessIndex)
pub fn set_bal(&mut self, bal: Arc<Bal>, index: BlockAccessIndex)
Serves reads of state the block wrote before index from bal, and everything else from
the underlying database.
Index 0 holds the pre-block system writes and transaction i is index i + 1, so
positioning the reads at a transaction’s own index yields its prestate without replaying
the earlier transactions. The list applies to EVMs created afterwards; parking an EVM
removes it again, so the backend must not execute further transactions of that block
afterwards.
Sourcepub(super) fn apply_bal(&self, evm: &mut FoundryEvmFor<'_, FEN>)
pub(super) fn apply_bal(&self, evm: &mut FoundryEvmFor<'_, FEN>)
Attaches the pending block access list to a newly created EVM.
Sourcepub fn clone_with_fork_scope(&self) -> Result<Self>
pub fn clone_with_fork_scope(&self) -> Result<Self>
Clones execution state with an independent registry for newly created forks.
Remote caches remain shared, but forks created by this execution are released with it.
Sourcepub fn clone_empty(&self) -> Self
pub fn clone_empty(&self) -> Self
Creates an empty local backend sharing this backend’s fork manager and environment.
Sourcepub fn clone_empty_with_env(&self, env: EvmEnvFor<FEN>) -> Self
pub fn clone_empty_with_env(&self, env: EvmEnvFor<FEN>) -> Self
Creates an empty local backend sharing this backend’s fork manager, with network state
seeded at env.
Network state can depend on the hardfork, such as Tempo’s genesis, so a test contract pinned to another hardfork needs its own seed.
Sourcepub fn replace_fork(
&mut self,
fork: Option<CreateFork>,
local_env: EvmEnvFor<FEN>,
) -> Result<()>
pub fn replace_fork( &mut self, fork: Option<CreateFork>, local_env: EvmEnvFor<FEN>, ) -> Result<()>
Replaces this backend with one starting on fork at its resolved block’s environment, or
locally with local_env, reusing the fork manager’s remote caches.
Sourcepub fn fork(&self) -> Option<RemoteFork>
pub fn fork(&self) -> Option<RemoteFork>
Returns the remote fork of the active context, if execution is forked over RPC.
Sourcepub async fn env(
&self,
opts: &EvmOpts,
) -> Result<(EvmEnvFor<FEN>, TransactionRequestFor<FEN>)>
pub async fn env( &self, opts: &EvmOpts, ) -> Result<(EvmEnvFor<FEN>, TransactionRequestFor<FEN>)>
Builds execution environments from this backend’s selected remote block.
Sourcepub async fn can_use_create2_deployer(&self, deployer: Address) -> Result<bool>
pub async fn can_use_create2_deployer(&self, deployer: Address) -> Result<bool>
Checks library-linking availability against this backend’s remote state.
Sourcepub async fn transaction_count(&self, sender: Address) -> Result<u64>
pub async fn transaction_count(&self, sender: Address) -> Result<u64>
Reads a sender nonce at this backend’s remote block before local execution.
Sourcepub fn networks(&self) -> NetworkConfigs
pub fn networks(&self) -> NetworkConfigs
Returns the active network configuration.
Sourcepub fn set_networks(&mut self, networks: NetworkConfigs)
pub fn set_networks(&mut self, networks: NetworkConfigs)
Sets the active network configuration.
Sourcepub fn set_fork_block_number_override(&mut self, block_number: u64)
pub fn set_fork_block_number_override(&mut self, block_number: u64)
Sets the block number the active fork reports while executing transactions of that block on top of its parent’s state.
Sourcepub fn factory(&self) -> &EvmFactoryFor<FEN>
pub fn factory(&self) -> &EvmFactoryFor<FEN>
Returns the EVM factory.
Sourcepub fn lifecycle(&self) -> &ExecutionLifecycle<EvmFactoryFor<FEN>>
pub fn lifecycle(&self) -> &ExecutionLifecycle<EvmFactoryFor<FEN>>
Returns the execution lifecycle, for read-only inspection of contexts and forks.
Sourcepub fn evm_env(&self) -> EvmEnvFor<FEN>
pub fn evm_env(&self) -> EvmEnvFor<FEN>
Returns the environment of the active context, as of the last park, with a fork’s own chain ID.
Sourcepub fn evm_env_mut(&mut self) -> &mut EvmEnvFor<FEN>
pub fn evm_env_mut(&mut self) -> &mut EvmEnvFor<FEN>
Returns the environment of the active context for modification between executions.
Sourcepub fn set_spec_id(&mut self, spec: impl Into<SpecFor<FEN>>) -> &mut Self
pub fn set_spec_id(&mut self, spec: impl Into<SpecFor<FEN>>) -> &mut Self
Sets the spec of the active context, keeping Foundry’s execution policy.
Sourcepub fn create_evm<'a>(&self) -> FoundryEvmFor<'a, FEN>
pub fn create_evm<'a>(&self) -> FoundryEvmFor<'a, FEN>
Creates an EVM over the active context. See the module documentation.
Sourcepub fn park(&mut self, evm: FoundryEvmFor<'_, FEN>)
pub fn park(&mut self, evm: FoundryEvmFor<'_, FEN>)
Accepts a committed EVM’s state, environment and network state into the active context,
and detaches the block access list set with Self::set_bal.
Sourcepub fn remove_prewarm(&mut self, state: &mut State<'_>, address: &Address)
pub fn remove_prewarm(&mut self, state: &mut State<'_>, address: &Address)
Removes address from the running transaction’s base warmth, see
ExecutionLifecycle::remove_prewarm.
Sourcepub fn take_persistent_warmth(
&mut self,
) -> Vec<(Option<U256>, AddressMap<HashSet<U256>>)>
pub fn take_persistent_warmth( &mut self, ) -> Vec<(Option<U256>, AddressMap<HashSet<U256>>)>
Takes the persistent warmth contexts kept for the running transaction, see
ExecutionLifecycle::take_persistent_warmth.
Sourcepub fn restore_persistent_warmth(
&mut self,
warmth: Vec<(Option<U256>, AddressMap<HashSet<U256>>)>,
)
pub fn restore_persistent_warmth( &mut self, warmth: Vec<(Option<U256>, AddressMap<HashSet<U256>>)>, )
Hands back persistent warmth taken with Self::take_persistent_warmth.
Sourcepub fn inspect_commit<'a>(
&mut self,
tx: &Recovered<TxFor<FEN>>,
inspector: impl Inspector<TypesFor<FEN>> + 'a,
) -> Result<TxResultFor<FEN>>
pub fn inspect_commit<'a>( &mut self, tx: &Recovered<TxFor<FEN>>, inspector: impl Inspector<TypesFor<FEN>> + 'a, ) -> Result<TxResultFor<FEN>>
Executes tx over the active context with inspector and accepts its state.
Sourcepub fn initialize(&mut self, caller: Address, kind: TxKind)
pub fn initialize(&mut self, caller: Address, kind: TxKind)
Records the caller and test contract of the next test execution.
The test contract is the call target, or the address caller creates at its current nonce.
Sourcepub fn basic(&self, address: Address) -> DbResult<Option<AccountInfo>>
pub fn basic(&self, address: Address) -> DbResult<Option<AccountInfo>>
Returns an account of the active context’s accepted state.
Sourcepub fn code_by_hash(&self, code_hash: B256) -> DbResult<Bytecode>
pub fn code_by_hash(&self, code_hash: B256) -> DbResult<Bytecode>
Returns code of the active context’s accepted state.
Sourcepub fn storage(&self, address: Address, slot: U256) -> DbResult<U256>
pub fn storage(&self, address: Address, slot: U256) -> DbResult<U256>
Returns a storage slot of the active context’s accepted state.
Sourcepub fn block_hash(&self, number: U256) -> DbResult<B256>
pub fn block_hash(&self, number: U256) -> DbResult<B256>
Returns a block hash of the active context.
Sourcepub fn insert_account_info(&mut self, address: Address, account: AccountInfo)
pub fn insert_account_info(&mut self, address: Address, account: AccountInfo)
Inserts account info into the active context’s accepted state.
Use this between executions only; a running EVM does not observe it.
Sourcepub fn insert_account_storage(
&mut self,
address: Address,
slot: U256,
value: U256,
)
pub fn insert_account_storage( &mut self, address: Address, slot: U256, value: U256, )
Inserts a value into an account’s storage without overriding account info.
Use this between executions only; a running EVM does not observe it.
Sourcepub fn replace_account_storage(
&mut self,
address: Address,
storage: impl IntoIterator<Item = (U256, U256)>,
)
pub fn replace_account_storage( &mut self, address: Address, storage: impl IntoIterator<Item = (U256, U256)>, )
Replaces an account’s storage without overriding account info.
When forking, every slot not in storage reads as zero instead of being fetched. Use this
between executions only; a running EVM does not observe it.
Sourcepub fn set_env(
&mut self,
evm: &mut FoundryEvmFor<'_, FEN>,
env: EvmEnvFor<FEN>,
phase: ExecutionPhase,
)
pub fn set_env( &mut self, evm: &mut FoundryEvmFor<'_, FEN>, env: EvmEnvFor<FEN>, phase: ExecutionPhase, )
Switches the running evm to env, such as for vm.chainId or vm.setEvmVersion. See
ExecutionLifecycle::set_env.
Sourcepub fn commit_pending(&mut self, pending: &PendingState)
pub fn commit_pending(&mut self, pending: &PendingState)
Accepts a detached transaction’s state, such as a call’s, into the active context’s accepted state.
Use this between executions only; a running EVM does not observe it.
Sourcepub fn set_test_contract(&mut self, account: Address) -> &mut Self
pub fn set_test_contract(&mut self, account: Address) -> &mut Self
Sets the address of the DSTest contract that is being executed.
This marks the contract as persistent and grants it cheatcode access.
Sourcepub fn set_caller(&mut self, account: Address) -> &mut Self
pub fn set_caller(&mut self, account: Address) -> &mut Self
Sets the caller address and grants it cheatcode access.
Sourcepub fn has_state_snapshot_failure(&self) -> bool
pub fn has_state_snapshot_failure(&self) -> bool
Returns whether a reverted state snapshot recorded a test failure.
If an error occurs in a restored state snapshot, the test is considered failed.
Sourcepub fn set_state_snapshot_failure(&mut self, has_state_snapshot_failure: bool)
pub fn set_state_snapshot_failure(&mut self, has_state_snapshot_failure: bool)
Sets the state snapshot failure flag.
Sourcepub fn is_persistent(&self, account: &Address) -> bool
pub fn is_persistent(&self, account: &Address) -> bool
Returns whether account persists across fork switches.
Sourcepub fn add_persistent_account(&mut self, account: Address) -> bool
pub fn add_persistent_account(&mut self, account: Address) -> bool
Marks account as persistent across fork switches. Returns whether it was not yet.
Sourcepub fn remove_persistent_account(&mut self, account: &Address) -> bool
pub fn remove_persistent_account(&mut self, account: &Address) -> bool
Stops account from persisting across fork switches. Returns whether it was persistent.
Sourcepub fn extend_persistent_accounts(
&mut self,
accounts: impl IntoIterator<Item = Address>,
)
pub fn extend_persistent_accounts( &mut self, accounts: impl IntoIterator<Item = Address>, )
Marks all accounts as persistent.
Sourcepub fn allow_cheatcode_access(&mut self, account: Address) -> bool
pub fn allow_cheatcode_access(&mut self, account: Address) -> bool
Grants account cheatcode access. Returns whether it did not have access yet.
Sourcepub fn has_cheatcode_access(&self, account: &Address) -> bool
pub fn has_cheatcode_access(&self, account: &Address) -> bool
Returns whether account has cheatcode access.
Sourcepub fn ensure_cheatcode_access(
&self,
account: &Address,
) -> Result<(), BackendError>
pub fn ensure_cheatcode_access( &self, account: &Address, ) -> Result<(), BackendError>
Ensures that account has cheatcode access.
Sourcepub fn ensure_cheatcode_access_forking_mode(
&self,
account: &Address,
) -> Result<(), BackendError>
pub fn ensure_cheatcode_access_forking_mode( &self, account: &Address, ) -> Result<(), BackendError>
Like Self::ensure_cheatcode_access, but only enforced while forked.
Sourcepub fn active_fork_id(&self) -> Option<LocalForkId>
pub fn active_fork_id(&self) -> Option<LocalForkId>
Returns the active fork, or None for local execution.
Sourcepub fn is_forked_mode(&self) -> bool
pub fn is_forked_mode(&self) -> bool
Returns whether execution is forked.
Sourcepub fn is_active_fork(&self, id: LocalForkId) -> bool
pub fn is_active_fork(&self, id: LocalForkId) -> bool
Returns whether id is the active fork.
Sourcepub fn active_fork_info(&self) -> Option<&ForkInfo>
pub fn active_fork_info(&self) -> Option<&ForkInfo>
Returns the identity of the active fork.
Sourcepub fn active_fork_url(&self) -> Option<String>
pub fn active_fork_url(&self) -> Option<String>
Returns the RPC URL of the active fork.
Sourcepub fn active_fork_options(&self) -> Option<CreateFork>
pub fn active_fork_options(&self) -> Option<CreateFork>
Returns the configuration the active fork was created with.
Sourcepub fn active_fork_source_chain_id(&self) -> Option<u64>
pub fn active_fork_source_chain_id(&self) -> Option<u64>
Returns the source chain ID of the active fork, independent of chain ID overrides.
Sourcepub fn active_fork_block_number(&self) -> Option<u64>
pub fn active_fork_block_number(&self) -> Option<u64>
Returns the RPC block number of the active fork.
Sourcepub fn ensure_fork(&self, id: Option<LocalForkId>) -> Result<LocalForkId>
pub fn ensure_fork(&self, id: Option<LocalForkId>) -> Result<LocalForkId>
Returns id, or the active fork for None, if it exists.
fn fork_info(&self, id: LocalForkId) -> Result<&ForkInfo>
fn set_fork_info(&mut self, id: LocalForkId, info: ForkInfo)
fn fork_options(&self, id: &ForkId) -> Result<CreateFork>
Sourcepub fn create_fork(&mut self, fork: CreateFork) -> Result<LocalForkId>
pub fn create_fork(&mut self, fork: CreateFork) -> Result<LocalForkId>
Creates a fork without selecting it.
Sourcepub fn create_fork_at_transaction(
&mut self,
fork: CreateFork,
transaction: B256,
) -> Result<LocalForkId>
pub fn create_fork_at_transaction( &mut self, fork: CreateFork, transaction: B256, ) -> Result<LocalForkId>
Creates a fork positioned right before transaction without selecting it.
Sourcepub fn create_select_fork(
&mut self,
fork: CreateFork,
evm: &mut FoundryEvmFor<'_, FEN>,
phase: ExecutionPhase,
) -> Result<LocalForkId>
pub fn create_select_fork( &mut self, fork: CreateFork, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<LocalForkId>
Creates a fork and selects it.
Sourcepub fn create_select_fork_at_transaction(
&mut self,
fork: CreateFork,
evm: &mut FoundryEvmFor<'_, FEN>,
phase: ExecutionPhase,
transaction: B256,
) -> Result<LocalForkId>
pub fn create_select_fork_at_transaction( &mut self, fork: CreateFork, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, transaction: B256, ) -> Result<LocalForkId>
Creates a fork positioned right before transaction and selects it.
Sourcepub fn select_fork(
&mut self,
id: LocalForkId,
evm: &mut FoundryEvmFor<'_, FEN>,
phase: ExecutionPhase,
) -> Result<()>
pub fn select_fork( &mut self, id: LocalForkId, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<()>
Makes fork id the running context of evm.
The running spec and fee-charge policy carry over to the fork; persistent accounts carry their state into it.
Sourcepub fn roll_fork(
&mut self,
id: Option<LocalForkId>,
block_number: u64,
evm: &mut FoundryEvmFor<'_, FEN>,
phase: ExecutionPhase,
) -> Result<()>
pub fn roll_fork( &mut self, id: Option<LocalForkId>, block_number: u64, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<()>
Moves fork id, or the active fork for None, to block_number.
Sourcefn roll_lifecycle_fork(
&mut self,
evm: &mut FoundryEvmFor<'_, FEN>,
id: LocalForkId,
db: impl BackingDb,
env: EvmEnvFor<FEN>,
cache: Option<Cache>,
phase: ExecutionPhase,
) -> Result<()>
fn roll_lifecycle_fork( &mut self, evm: &mut FoundryEvmFor<'_, FEN>, id: LocalForkId, db: impl BackingDb, env: EvmEnvFor<FEN>, cache: Option<Cache>, phase: ExecutionPhase, ) -> Result<()>
Moves fork id onto db and env in the lifecycle.
Rolling the active fork keeps the test caller’s state like a persistent
account’s, so a sender that is not persistent keeps changes such as vm.deal.
Sourcepub fn roll_fork_to_transaction(
&mut self,
id: Option<LocalForkId>,
transaction: B256,
evm: &mut FoundryEvmFor<'_, FEN>,
phase: ExecutionPhase,
) -> Result<()>
pub fn roll_fork_to_transaction( &mut self, id: Option<LocalForkId>, transaction: B256, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<()>
Moves fork id, or the active fork for None, to the state right before transaction:
the transaction’s block environment over its parent’s state with the block’s preceding
transactions replayed natively.
Sourcepub fn prepare_transact(
&self,
id: Option<LocalForkId>,
transaction: B256,
evm: &mut FoundryEvmFor<'_, FEN>,
depth: u16,
isolation_env: Option<&EvmEnvFor<FEN>>,
) -> Result<(PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)>
pub fn prepare_transact( &self, id: Option<LocalForkId>, transaction: B256, evm: &mut FoundryEvmFor<'_, FEN>, depth: u16, isolation_env: Option<&EvmEnvFor<FEN>>, ) -> Result<(PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)>
Prepares the mined transaction of fork id, or of the active fork for None, to execute
with its block’s environment, such as for vm.transact, and returns it with the throwaway
backend it executes over. Store the outcome with Self::store_executed.
On the active fork the transaction runs as a nested transaction of the running one, whose
writes are journaled; on another fork it is accepted there and its changes to persistent
accounts are merged into the running transaction. Its root frame runs at depth.
Cheatcodes running in the transaction see the throwaway backend with the target fork active at the transaction’s block; their changes to it are discarded.
isolation_env is the environment of the transaction an isolated call runs in, whose fee
charge and sender balance checks apply on the active fork instead of the isolated call’s.
Sourcepub fn transact_from_tx(
&mut self,
tx: &Recovered<TxFor<FEN>>,
evm: &mut FoundryEvmFor<'_, FEN>,
env: Option<EvmEnvFor<FEN>>,
inspector: Option<&mut dyn Inspector<TypesFor<FEN>>>,
) -> Result<(TxResultFor<FEN>, Vec<PersistentWrite>)>
pub fn transact_from_tx( &mut self, tx: &Recovered<TxFor<FEN>>, evm: &mut FoundryEvmFor<'_, FEN>, env: Option<EvmEnvFor<FEN>>, inspector: Option<&mut dyn Inspector<TypesFor<FEN>>>, ) -> Result<(TxResultFor<FEN>, Vec<PersistentWrite>)>
Executes tx as a nested transaction of the running one, in env or the running
environment for None, and merges its changes into the running transaction so that they
survive reverts of the enclosing calls.
Sourcepub fn prepare_nested(
&self,
tx: Recovered<TxFor<FEN>>,
evm: &mut FoundryEvmFor<'_, FEN>,
env: Option<EvmEnvFor<FEN>>,
) -> (PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)
pub fn prepare_nested( &self, tx: Recovered<TxFor<FEN>>, evm: &mut FoundryEvmFor<'_, FEN>, env: Option<EvmEnvFor<FEN>>, ) -> (PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)
Prepares Self::transact_from_tx, such as for vm.broadcastRawTransaction, and returns
it with the throwaway backend it executes over. Store the outcome with
Self::store_executed.
Cheatcodes running in the transaction see the throwaway backend, a copy-on-write view of this one; their changes to it are discarded.
Sourcepub fn store_executed(
&mut self,
evm: &mut FoundryEvmFor<'_, FEN>,
executed: ExecutedNested<TypesFor<FEN>>,
) -> TxResultFor<FEN>
pub fn store_executed( &mut self, evm: &mut FoundryEvmFor<'_, FEN>, executed: ExecutedNested<TypesFor<FEN>>, ) -> TxResultFor<FEN>
Stores the outcome of a transaction prepared with Self::prepare_transact or
Self::prepare_nested.
A replayed canonical transaction advances its fork’s position; its changes merged into the
running transaction evm are not the running transaction’s execution.
Sourcepub fn diagnose_revert(
&self,
callee: Address,
evm: &mut FoundryEvmFor<'_, FEN>,
) -> Option<RevertDiagnostic>
pub fn diagnose_revert( &self, callee: Address, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Option<RevertDiagnostic>
Explains a revert of a call to callee in multi-fork mode: whether callee has no code on
the active fork, and on which other forks it does.
Handling multiple accounts/new contracts in a multifork environment can be challenging since every fork has its own standalone storage section:
function testCanDeploy() public {
vm.selectFork(mainnetFork);
// contract created while on `mainnetFork`
DummyContract dummy = new DummyContract();
// this will succeed
dummy.hello();
vm.selectFork(optimismFork);
vm.expectRevert();
// this will revert since `dummy` contract only exists on `mainnetFork`
dummy.hello();
}Sourcepub fn load_allocs(
&self,
allocs: &BTreeMap<Address, GenesisAccount>,
evm: &mut FoundryEvmFor<'_, FEN>,
) -> Result<(), BackendError>
pub fn load_allocs( &self, allocs: &BTreeMap<Address, GenesisAccount>, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<(), BackendError>
Loads genesis allocs into the running transaction as journaled writes.
Sourcepub fn clone_account(
&self,
source: &GenesisAccount,
target: &Address,
evm: &mut FoundryEvmFor<'_, FEN>,
) -> Result<(), BackendError>
pub fn clone_account( &self, source: &GenesisAccount, target: &Address, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<(), BackendError>
Writes the code, storage, nonce and balance of source to target in the running
transaction as journaled writes, and warms target. Code is kept when source has none.
Sourcepub fn set_blockhash(
&self,
number: U256,
hash: B256,
evm: &mut FoundryEvmFor<'_, FEN>,
)
pub fn set_blockhash( &self, number: U256, hash: B256, evm: &mut FoundryEvmFor<'_, FEN>, )
Sets the hash of block number in the running context.
Sourcepub fn refresh_fork_account(
&self,
address: Address,
field: ForkAccountField,
evm: &mut FoundryEvmFor<'_, FEN>,
) -> Result<(), BackendError>
pub fn refresh_fork_account( &self, address: Address, field: ForkAccountField, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<(), BackendError>
Refetches field of address from the active fork’s remote, after an out-of-band RPC
mutation, and updates the running context with it.
Balance and nonce are overridden without journaling, so they survive reverts; code is set as a journaled write.
Sourcepub fn refresh_fork_storage(
&mut self,
address: Address,
slot: U256,
evm: &mut FoundryEvmFor<'_, FEN>,
) -> Result<Option<PersistentWrite>, BackendError>
pub fn refresh_fork_storage( &mut self, address: Address, slot: U256, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<Option<PersistentWrite>, BackendError>
Refetches storage slot of address from the active fork’s remote, after an out-of-band
RPC mutation, and updates the running context with it.
A slot the running transaction already loaded takes the refreshed value across reverts of the enclosing calls. Its transaction-start original is kept.
Sourcepub fn prefetch_call(
&self,
caller: Address,
target: Address,
value: U256,
input: Bytes,
top_level: bool,
)
pub fn prefetch_call( &self, caller: Address, target: Address, value: U256, input: Bytes, top_level: bool, )
Prefetches the remote state a call is about to read, if the active context is an RPC fork.
A top_level call is simulated with the local state that differs from the remote, such as
the test contract, as overrides. A nested call is simulated as is.
Sourcepub fn snapshot_state(&mut self, evm: &mut FoundryEvmFor<'_, FEN>) -> U256
pub fn snapshot_state(&mut self, evm: &mut FoundryEvmFor<'_, FEN>) -> U256
Captures the running context and every fork, and returns the snapshot ID.
Sourcepub fn revert_state(
&mut self,
id: U256,
evm: &mut FoundryEvmFor<'_, FEN>,
action: RevertStateSnapshotAction,
phase: ExecutionPhase,
) -> Option<StateSnapshot>
pub fn revert_state( &mut self, id: U256, evm: &mut FoundryEvmFor<'_, FEN>, action: RevertStateSnapshotAction, phase: ExecutionPhase, ) -> Option<StateSnapshot>
Restores snapshot id and returns the running state it replaced, or returns None if it
does not exist.
Logs emitted since the snapshot, persistent accounts and forks created after it survive.
A test failure recorded in the reverted state sets Self::has_state_snapshot_failure.
Sourcepub fn delete_state_snapshot(&mut self, id: U256) -> bool
pub fn delete_state_snapshot(&mut self, id: U256) -> bool
Deletes a snapshot, returning whether it existed.
Sourcepub fn delete_state_snapshots(&mut self)
pub fn delete_state_snapshots(&mut self)
Deletes every snapshot.
Sourcefn insert_fork(
&mut self,
fork: CreateFork,
env: Option<EvmEnvFor<FEN>>,
track: bool,
) -> Result<LocalForkId>
fn insert_fork( &mut self, fork: CreateFork, env: Option<EvmEnvFor<FEN>>, track: bool, ) -> Result<LocalForkId>
Registers an RPC fork, with env or the environment derived from its block, retaining
its block cursor if track.
Sourcefn insert_prepared_fork(
&mut self,
url: String,
resolved: ForkResult,
env: EvmEnvFor<FEN>,
track: bool,
) -> Result<LocalForkId>
fn insert_prepared_fork( &mut self, url: String, resolved: ForkResult, env: EvmEnvFor<FEN>, track: bool, ) -> Result<LocalForkId>
Registers a resolved fork without refetching its block, retaining its block cursor if
track.
Sourcefn tracks_position(&self, fork: &CreateFork) -> bool
fn tracks_position(&self, fork: &CreateFork) -> bool
Returns whether forks created from fork retain their canonical block cursor.
Sourcefn fork_position(&self, id: LocalForkId) -> Result<ForkPosition>
fn fork_position(&self, id: LocalForkId) -> Result<ForkPosition>
Returns the canonical position of fork id: the one retained by a replay, or the end of
its pinned block.
Sourcefn block_end_cursor(
&self,
backend: &SharedBackend<AnyNetwork, BlockEnv>,
remote: &RemoteFork,
env: &EvmEnvFor<FEN>,
) -> Result<(ForkPosition, ChainFor<FEN>)>
fn block_end_cursor( &self, backend: &SharedBackend<AnyNetwork, BlockEnv>, remote: &RemoteFork, env: &EvmEnvFor<FEN>, ) -> Result<(ForkPosition, ChainFor<FEN>)>
Returns the position and block cursor at the end of remote’s pinned block.
Sourcefn retain_cursor(
&mut self,
id: LocalForkId,
position: ForkPosition,
cursor: &ChainFor<FEN>,
evm: Option<&mut FoundryEvmFor<'_, FEN>>,
)
fn retain_cursor( &mut self, id: LocalForkId, position: ForkPosition, cursor: &ChainFor<FEN>, evm: Option<&mut FoundryEvmFor<'_, FEN>>, )
Retains position and its block cursor as fork id’s canonical position.
The active fork’s cursor lives in the running EVM: it moves under the running transaction, whose network state is rebased onto it. Synthetic transactions never call this.
Sourcefn fork_env(
&self,
opts: &EvmOpts,
remote: &RemoteFork,
block: &AnyRpcBlock,
spec: SpecFor<FEN>,
) -> EvmEnvFor<FEN>
fn fork_env( &self, opts: &EvmOpts, remote: &RemoteFork, block: &AnyRpcBlock, spec: SpecFor<FEN>, ) -> EvmEnvFor<FEN>
Returns the environment of remote at block with spec.
fn fork_source_chain_id(&self, id: LocalForkId) -> Result<ChainId>
Sourcefn transaction_target(
&self,
id: LocalForkId,
transaction: B256,
) -> Result<TransactionForkTarget>
fn transaction_target( &self, id: LocalForkId, transaction: B256, ) -> Result<TransactionForkTarget>
Fetches transaction and the block it executes in from fork id.
Sourcefn prepare_roll_to_transaction(
&self,
id: LocalForkId,
transaction: B256,
spec: SpecFor<FEN>,
) -> Result<(RpcForkDb, EvmEnvFor<FEN>, Option<Cache>, ForkInfo, Option<(ForkPosition, ChainFor<FEN>)>, bool)>
fn prepare_roll_to_transaction( &self, id: LocalForkId, transaction: B256, spec: SpecFor<FEN>, ) -> Result<(RpcForkDb, EvmEnvFor<FEN>, Option<Cache>, ForkInfo, Option<(ForkPosition, ChainFor<FEN>)>, bool)>
Resolves the backing database, environment, replayed accepted state, identity, for
networks with block-position state, canonical position and block cursor of fork id
positioned right before transaction, and whether preceding transactions were replayed.
Sourcefn replay_until(
&self,
db: &impl BackingDb,
env: EvmEnvFor<FEN>,
block: &AnyRpcBlock,
index: usize,
context: Option<BlockContext<FEN>>,
source_chain_id: ChainId,
) -> Result<Cache>
fn replay_until( &self, db: &impl BackingDb, env: EvmEnvFor<FEN>, block: &AnyRpcBlock, index: usize, context: Option<BlockContext<FEN>>, source_chain_id: ChainId, ) -> Result<Cache>
Replays the transactions of block before index over db and returns the resulting
accepted state.
context positions network state that depends on the block, such as Monad’s. System
transactions are skipped, except deposits and canonical protocol transactions, which
networks that support them execute natively.
Trait Implementations§
Source§impl<'a, FEN: Clone + FoundryEvmNetwork> Clone for CowBackend<'a, FEN>
impl<'a, FEN: Clone + FoundryEvmNetwork> Clone for CowBackend<'a, FEN>
Source§impl<'a, FEN: Debug + FoundryEvmNetwork> Debug for CowBackend<'a, FEN>
impl<'a, FEN: Debug + FoundryEvmNetwork> Debug for CowBackend<'a, FEN>
Source§impl<FEN: FoundryEvmNetwork> Deref for CowBackend<'_, FEN>
impl<FEN: FoundryEvmNetwork> Deref for CowBackend<'_, FEN>
Source§impl<FEN: FoundryEvmNetwork> DerefMut for CowBackend<'_, FEN>
impl<FEN: FoundryEvmNetwork> DerefMut for CowBackend<'_, FEN>
Auto Trait Implementations§
impl<'a, FEN> !RefUnwindSafe for CowBackend<'a, FEN>
impl<'a, FEN> !UnwindSafe for CowBackend<'a, FEN>
impl<'a, FEN> Freeze for CowBackend<'a, FEN>
impl<'a, FEN> Send for CowBackend<'a, FEN>
impl<'a, FEN> Sync for CowBackend<'a, FEN>
impl<'a, FEN> Unpin for CowBackend<'a, FEN>
impl<'a, FEN> UnsafeUnpin for CowBackend<'a, FEN>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<TxEnv, T> FromRecoveredTx<&T> for TxEnvwhere
TxEnv: FromRecoveredTx<T>,
impl<TxEnv, T> FromRecoveredTx<&T> for TxEnvwhere
TxEnv: FromRecoveredTx<T>,
§fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv
fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv
TxEnv] from a transaction and a sender address.§impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnvwhere
TxEnv: FromTxWithEncoded<T>,
impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnvwhere
TxEnv: FromTxWithEncoded<T>,
§fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv
fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv
TxEnv] from a transaction, its sender, and encoded transaction bytes.§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T in a tonic::Request§impl<L> LayerExt<L> for L
impl<L> LayerExt<L> for L
§fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
Layered].impl<T> MaybeCompact for T
§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere
T: ?Sized,
§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self with the foreground set to
value.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red() and
green(), which have the same functionality but are
pithier.
§Example
Set foreground color to white using fg():
use yansi::{Paint, Color};
painted.fg(Color::White);Set foreground color to white using white().
use yansi::Paint;
painted.white();§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self with the background set to
value.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red() and
on_green(), which have the same functionality but
are pithier.
§Example
Set background color to red using fg():
use yansi::{Paint, Color};
painted.bg(Color::Red);Set background color to red using on_red().
use yansi::Paint;
painted.on_red();§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling [Attribute] value.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold() and
underline(), which have the same functionality
but are pithier.
§Example
Make text bold using attr():
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);Make text bold using using bold().
use yansi::Paint;
painted.bold();§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi [Quirk] value.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask() and
wrap(), which have the same functionality but are
pithier.
§Example
Enable wrapping using .quirk():
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);Enable wrapping using wrap().
use yansi::Paint;
painted.wrap();§fn clear(&self) -> Painted<&T>
👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear().
The clear() method will be removed in a future release.
fn clear(&self) -> Painted<&T>
renamed to resetting() due to conflicts with Vec::clear().
The clear() method will be removed in a future release.
§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the [Condition] value
applies. Replaces any previous condition.
See the crate level docs for more details.
§Example
Enable styling painted only when both stdout and stderr are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.§impl<T> Threaded<T> for T
impl<T> Threaded<T> for T
§impl<T> TryConv for T
impl<T> TryConv for T
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
Layout§
Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.