chore: standardize use of opts / args (#9629)

* globalopts -> globalargs

* consistently use opts for configurations, args for command line arguments

Author: zerosnacks

crates/anvil/src/anvil.rs

@@ -3,7 +3,7 @@
 use anvil::cmd::NodeArgs;
 use clap::{CommandFactory, Parser, Subcommand};
 use eyre::Result;
-use foundry_cli::{opts::GlobalOpts, utils};
+use foundry_cli::{opts::GlobalArgs, utils};
 
 #[cfg(all(feature = "jemalloc", unix))]
 #[global_allocator]
@@ -13,9 +13,9 @@ static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 #[derive(Parser)]
 #[command(name = "anvil", version = anvil::VERSION_MESSAGE, next_display_order = None)]
 pub struct Anvil {
-    /// Include the global options.
+    /// Include the global arguments.
     #[command(flatten)]
-    pub global: GlobalOpts,
+    pub global: GlobalArgs,
 
     #[command(flatten)]
     pub node: NodeArgs,
@@ -50,7 +50,7 @@ fn run() -> Result<()> {
 
     let mut args = Anvil::parse();
     args.global.init()?;
-    args.node.evm_opts.resolve_rpc_alias();
+    args.node.evm.resolve_rpc_alias();
 
     if let Some(cmd) = &args.cmd {
         match cmd {

crates/anvil/src/cmd.rs

@@ -185,7 +185,7 @@ pub struct NodeArgs {
     pub transaction_block_keeper: Option<usize>,
 
     #[command(flatten)]
-    pub evm_opts: AnvilEvmArgs,
+    pub evm: AnvilEvmArgs,
 
     #[command(flatten)]
     pub server_config: ServerConfig,
@@ -209,15 +209,12 @@ const DEFAULT_DUMP_INTERVAL: Duration = Duration::from_secs(60);
 impl NodeArgs {
     pub fn into_node_config(self) -> eyre::Result<NodeConfig> {
         let genesis_balance = Unit::ETHER.wei().saturating_mul(U256::from(self.balance));
-        let compute_units_per_second = if self.evm_opts.no_rate_limit {
-            Some(u64::MAX)
-        } else {
-            self.evm_opts.compute_units_per_second
-        };
+        let compute_units_per_second =
+            if self.evm.no_rate_limit { Some(u64::MAX) } else { self.evm.compute_units_per_second };
 
         let hardfork = match &self.hardfork {
             Some(hf) => {
-                if self.evm_opts.optimism {
+                if self.evm.optimism {
                     Some(OptimismHardfork::from_str(hf)?.into())
                 } else {
                     Some(EthereumHardfork::from_str(hf)?.into())
@@ -227,9 +224,9 @@ impl NodeArgs {
         };
 
         Ok(NodeConfig::default()
-            .with_gas_limit(self.evm_opts.gas_limit)
-            .disable_block_gas_limit(self.evm_opts.disable_block_gas_limit)
-            .with_gas_price(self.evm_opts.gas_price)
+            .with_gas_limit(self.evm.gas_limit)
+            .disable_block_gas_limit(self.evm.disable_block_gas_limit)
+            .with_gas_price(self.evm.gas_price)
             .with_hardfork(hardfork)
             .with_blocktime(self.block_time)
             .with_no_mining(self.no_mining)
@@ -238,54 +235,50 @@ impl NodeArgs {
             .with_genesis_balance(genesis_balance)
             .with_genesis_timestamp(self.timestamp)
             .with_port(self.port)
-            .with_fork_choice(
-                match (self.evm_opts.fork_block_number, self.evm_opts.fork_transaction_hash) {
-                    (Some(block), None) => Some(ForkChoice::Block(block)),
-                    (None, Some(hash)) => Some(ForkChoice::Transaction(hash)),
-                    _ => {
-                        self.evm_opts.fork_url.as_ref().and_then(|f| f.block).map(ForkChoice::Block)
-                    }
-                },
-            )
-            .with_fork_headers(self.evm_opts.fork_headers)
-            .with_fork_chain_id(self.evm_opts.fork_chain_id.map(u64::from).map(U256::from))
-            .fork_request_timeout(self.evm_opts.fork_request_timeout.map(Duration::from_millis))
-            .fork_request_retries(self.evm_opts.fork_request_retries)
-            .fork_retry_backoff(self.evm_opts.fork_retry_backoff.map(Duration::from_millis))
+            .with_fork_choice(match (self.evm.fork_block_number, self.evm.fork_transaction_hash) {
+                (Some(block), None) => Some(ForkChoice::Block(block)),
+                (None, Some(hash)) => Some(ForkChoice::Transaction(hash)),
+                _ => self.evm.fork_url.as_ref().and_then(|f| f.block).map(ForkChoice::Block),
+            })
+            .with_fork_headers(self.evm.fork_headers)
+            .with_fork_chain_id(self.evm.fork_chain_id.map(u64::from).map(U256::from))
+            .fork_request_timeout(self.evm.fork_request_timeout.map(Duration::from_millis))
+            .fork_request_retries(self.evm.fork_request_retries)
+            .fork_retry_backoff(self.evm.fork_retry_backoff.map(Duration::from_millis))
             .fork_compute_units_per_second(compute_units_per_second)
-            .with_eth_rpc_url(self.evm_opts.fork_url.map(|fork| fork.url))
-            .with_base_fee(self.evm_opts.block_base_fee_per_gas)
-            .disable_min_priority_fee(self.evm_opts.disable_min_priority_fee)
-            .with_storage_caching(self.evm_opts.no_storage_caching)
+            .with_eth_rpc_url(self.evm.fork_url.map(|fork| fork.url))
+            .with_base_fee(self.evm.block_base_fee_per_gas)
+            .disable_min_priority_fee(self.evm.disable_min_priority_fee)
+            .with_storage_caching(self.evm.no_storage_caching)
             .with_server_config(self.server_config)
             .with_host(self.host)
             .set_silent(shell::is_quiet())
             .set_config_out(self.config_out)
-            .with_chain_id(self.evm_opts.chain_id)
+            .with_chain_id(self.evm.chain_id)
             .with_transaction_order(self.order)
             .with_genesis(self.init)
-            .with_steps_tracing(self.evm_opts.steps_tracing)
-            .with_print_logs(!self.evm_opts.disable_console_log)
-            .with_auto_impersonate(self.evm_opts.auto_impersonate)
+            .with_steps_tracing(self.evm.steps_tracing)
+            .with_print_logs(!self.evm.disable_console_log)
+            .with_auto_impersonate(self.evm.auto_impersonate)
             .with_ipc(self.ipc)
-            .with_code_size_limit(self.evm_opts.code_size_limit)
-            .disable_code_size_limit(self.evm_opts.disable_code_size_limit)
+            .with_code_size_limit(self.evm.code_size_limit)
+            .disable_code_size_limit(self.evm.disable_code_size_limit)
             .set_pruned_history(self.prune_history)
             .with_init_state(self.load_state.or_else(|| self.state.and_then(|s| s.state)))
             .with_transaction_block_keeper(self.transaction_block_keeper)
             .with_max_persisted_states(self.max_persisted_states)
-            .with_optimism(self.evm_opts.optimism)
-            .with_odyssey(self.evm_opts.odyssey)
-            .with_disable_default_create2_deployer(self.evm_opts.disable_default_create2_deployer)
+            .with_optimism(self.evm.optimism)
+            .with_odyssey(self.evm.odyssey)
+            .with_disable_default_create2_deployer(self.evm.disable_default_create2_deployer)
             .with_slots_in_an_epoch(self.slots_in_an_epoch)
-            .with_memory_limit(self.evm_opts.memory_limit)
+            .with_memory_limit(self.evm.memory_limit)
             .with_cache_path(self.cache_path))
     }
 
     fn account_generator(&self) -> AccountGenerator {
         let mut gen = AccountGenerator::new(self.accounts as usize)
             .phrase(DEFAULT_MNEMONIC)
-            .chain_id(self.evm_opts.chain_id.unwrap_or_else(|| CHAIN_ID.into()));
+            .chain_id(self.evm.chain_id.unwrap_or_else(|| CHAIN_ID.into()));
         if let Some(ref mnemonic) = self.mnemonic {
             gen = gen.phrase(mnemonic);
         } else if let Some(count) = self.mnemonic_random {
@@ -845,10 +838,7 @@ mod tests {
             "--fork-header",
             "Referrer: example.com",
         ]);
-        assert_eq!(
-            args.evm_opts.fork_headers,
-            vec!["User-Agent: test-agent", "Referrer: example.com"]
-        );
+        assert_eq!(args.evm.fork_headers, vec!["User-Agent: test-agent", "Referrer: example.com"]);
     }
 
     #[test]
@@ -869,7 +859,7 @@ mod tests {
     #[test]
     fn can_parse_disable_block_gas_limit() {
         let args: NodeArgs = NodeArgs::parse_from(["anvil", "--disable-block-gas-limit"]);
-        assert!(args.evm_opts.disable_block_gas_limit);
+        assert!(args.evm.disable_block_gas_limit);
 
         let args =
             NodeArgs::try_parse_from(["anvil", "--disable-block-gas-limit", "--gas-limit", "100"]);
@@ -879,7 +869,7 @@ mod tests {
     #[test]
     fn can_parse_disable_code_size_limit() {
         let args: NodeArgs = NodeArgs::parse_from(["anvil", "--disable-code-size-limit"]);
-        assert!(args.evm_opts.disable_code_size_limit);
+        assert!(args.evm.disable_code_size_limit);
 
         let args = NodeArgs::try_parse_from([
             "anvil",

crates/cast/bin/args.rs

@@ -9,7 +9,7 @@ use alloy_primitives::{Address, B256, U256};
 use alloy_rpc_types::BlockId;
 use clap::{Parser, Subcommand, ValueHint};
 use eyre::Result;
-use foundry_cli::opts::{EtherscanOpts, GlobalOpts, RpcOpts};
+use foundry_cli::opts::{EtherscanOpts, GlobalArgs, RpcOpts};
 use foundry_common::ens::NameOrAddress;
 use std::{path::PathBuf, str::FromStr};
 
@@ -31,9 +31,9 @@ const VERSION_MESSAGE: &str = concat!(
     next_display_order = None,
 )]
 pub struct Cast {
-    /// Include the global options.
+    /// Include the global arguments.
     #[command(flatten)]
-    pub global: GlobalOpts,
+    pub global: GlobalArgs,
 
     #[command(subcommand)]
     pub cmd: CastSubcommand,

crates/cast/bin/cmd/storage.rs

@@ -10,7 +10,7 @@ use comfy_table::{modifiers::UTF8_ROUND_CORNERS, Cell, Table};
 use eyre::Result;
 use foundry_block_explorers::Client;
 use foundry_cli::{
-    opts::{CoreBuildArgs, EtherscanOpts, RpcOpts},
+    opts::{BuildOpts, EtherscanOpts, RpcOpts},
     utils,
 };
 use foundry_common::{
@@ -64,7 +64,7 @@ pub struct StorageArgs {
     etherscan: EtherscanOpts,
 
     #[command(flatten)]
-    build: CoreBuildArgs,
+    build: BuildOpts,
 }
 
 impl_figment_convert_cast!(StorageArgs);

crates/chisel/bin/main.rs

@@ -11,7 +11,7 @@ use clap::{Parser, Subcommand};
 use eyre::Context;
 use foundry_cli::{
     handler,
-    opts::{CoreBuildArgs, GlobalOpts},
+    opts::{BuildOpts, GlobalArgs},
     utils::{self, LoadConfig},
 };
 use foundry_common::{evm::EvmArgs, fs};
@@ -35,7 +35,7 @@ extern crate foundry_common;
 static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
 // Loads project's figment and merges the build cli arguments into it
-foundry_config::merge_impl_figment_convert!(Chisel, opts, evm_args);
+foundry_config::merge_impl_figment_convert!(Chisel, build, evm);
 
 const VERSION_MESSAGE: &str = concat!(
     env!("CARGO_PKG_VERSION"),
@@ -50,9 +50,9 @@ const VERSION_MESSAGE: &str = concat!(
 #[derive(Debug, Parser)]
 #[command(name = "chisel", version = VERSION_MESSAGE)]
 pub struct Chisel {
-    /// Include the global options.
+    /// Include the global arguments.
     #[command(flatten)]
-    pub global: GlobalOpts,
+    pub global: GlobalArgs,
 
     #[command(subcommand)]
     pub cmd: Option<ChiselSubcommand>,
@@ -73,10 +73,10 @@ pub struct Chisel {
     pub no_vm: bool,
 
     #[command(flatten)]
-    pub opts: CoreBuildArgs,
+    pub build: BuildOpts,
 
     #[command(flatten)]
-    pub evm_args: EvmArgs,
+    pub evm: EvmArgs,
 }
 
 /// Chisel binary subcommands

crates/cli/src/opts/build/core.rs

@@ -1,5 +1,5 @@
-use super::ProjectPathsArgs;
-use crate::{opts::CompilerArgs, utils::LoadConfig};
+use super::ProjectPathOpts;
+use crate::{opts::CompilerOpts, utils::LoadConfig};
 use clap::{Parser, ValueHint};
 use eyre::Result;
 use foundry_compilers::{
@@ -23,7 +23,7 @@ use std::path::PathBuf;
 
 #[derive(Clone, Debug, Default, Serialize, Parser)]
 #[command(next_help_heading = "Build options")]
-pub struct CoreBuildArgs {
+pub struct BuildOpts {
     /// Clear the cache and artifacts folder and recompile.
     #[arg(long, help_heading = "Cache options")]
     #[serde(skip)]
@@ -138,14 +138,14 @@ pub struct CoreBuildArgs {
 
     #[command(flatten)]
     #[serde(flatten)]
-    pub compiler: CompilerArgs,
+    pub compiler: CompilerOpts,
 
     #[command(flatten)]
     #[serde(flatten)]
-    pub project_paths: ProjectPathsArgs,
+    pub project_paths: ProjectPathOpts,
 }
 
-impl CoreBuildArgs {
+impl BuildOpts {
     /// Returns the `Project` for the current workspace
     ///
     /// This loads the `foundry_config::Config` for the current workspace (see
@@ -164,8 +164,8 @@ impl CoreBuildArgs {
 }
 
 // Loads project's figment and merges the build cli arguments into it
-impl<'a> From<&'a CoreBuildArgs> for Figment {
-    fn from(args: &'a CoreBuildArgs) -> Self {
+impl<'a> From<&'a BuildOpts> for Figment {
+    fn from(args: &'a BuildOpts) -> Self {
         let mut figment = if let Some(ref config_path) = args.project_paths.config_path {
             if !config_path.exists() {
                 panic!("error: config-path `{}` does not exist", config_path.display())
@@ -196,8 +196,8 @@ impl<'a> From<&'a CoreBuildArgs> for Figment {
     }
 }
 
-impl<'a> From<&'a CoreBuildArgs> for Config {
-    fn from(args: &'a CoreBuildArgs) -> Self {
+impl<'a> From<&'a BuildOpts> for Config {
+    fn from(args: &'a BuildOpts) -> Self {
         let figment: Figment = args.into();
         let mut config = Self::from_provider(figment).sanitized();
         // if `--config-path` is set we need to adjust the config's root path to the actual root
@@ -209,7 +209,7 @@ impl<'a> From<&'a CoreBuildArgs> for Config {
     }
 }
 
-impl Provider for CoreBuildArgs {
+impl Provider for BuildOpts {
     fn metadata(&self) -> Metadata {
         Metadata::named("Core Build Args Provider")
     }

crates/cli/src/opts/build/mod.rs

@@ -3,18 +3,18 @@ use foundry_compilers::artifacts::{output_selection::ContractOutputSelection, Ev
 use serde::Serialize;
 
 mod core;
-pub use self::core::CoreBuildArgs;
+pub use self::core::BuildOpts;
 
 mod paths;
-pub use self::paths::ProjectPathsArgs;
+pub use self::paths::ProjectPathOpts;
 
 // A set of solc compiler settings that can be set via command line arguments, which are intended
 // to be merged into an existing `foundry_config::Config`.
 //
 // See also `BuildArgs`.
 #[derive(Clone, Debug, Default, Serialize, Parser)]
 #[command(next_help_heading = "Compiler options")]
-pub struct CompilerArgs {
+pub struct CompilerOpts {
     /// Includes the AST as JSON in the compiler output.
     #[arg(long, help_heading = "Compiler options")]
     #[serde(skip)]
@@ -62,15 +62,15 @@ mod tests {
 
     #[test]
     fn can_parse_evm_version() {
-        let args: CompilerArgs =
-            CompilerArgs::parse_from(["foundry-cli", "--evm-version", "london"]);
+        let args: CompilerOpts =
+            CompilerOpts::parse_from(["foundry-cli", "--evm-version", "london"]);
         assert_eq!(args.evm_version, Some(EvmVersion::London));
     }
 
     #[test]
     fn can_parse_extra_output() {
-        let args: CompilerArgs =
-            CompilerArgs::parse_from(["foundry-cli", "--extra-output", "metadata", "ir-optimized"]);
+        let args: CompilerOpts =
+            CompilerOpts::parse_from(["foundry-cli", "--extra-output", "metadata", "ir-optimized"]);
         assert_eq!(
             args.extra_output,
             vec![ContractOutputSelection::Metadata, ContractOutputSelection::IrOptimized]
@@ -79,7 +79,7 @@ mod tests {
 
     #[test]
     fn can_parse_extra_output_files() {
-        let args: CompilerArgs = CompilerArgs::parse_from([
+        let args: CompilerOpts = CompilerOpts::parse_from([
             "foundry-cli",
             "--extra-output-files",
             "metadata",