Bump clap to 4.0.x and adjust to best practices (#12381)

* Bump clap to 3.2.22

* Replace `from_os_str` with `value_parser`

* Replace `from_str` and `try_from_str` with `value_parser`

* Move possible_values to the new format

* Remove unwanted print

* Add missing match branch

* Update clap to 4.0.9 and make it compile

* Replace deprecated `clap` macro with `command` and `value`

* Move remaining `clap` attributes to `arg`

* Remove no-op value_parsers

* Adjust value_parser for state_version

* Remove "deprecated" feature flag and bump to 4.0.11

* Improve range

Co-authored-by: Bastian Köcher <git@kchr.de>

* Apply suggestions

* Trigger CI

* Fix unused error warning

* Fix doc errors

* Fix ArgGroup naming conflict

* Change default_value to default_value_t

* Use 1.. instead of 0..

Co-authored-by: Bastian Köcher <git@kchr.de>

substrate/utils/frame/benchmarking-cli/Cargo.toml

@@ -15,7 +15,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 array-bytes = "4.1"
 chrono = "0.4"
-clap = { version = "3.1.18", features = ["derive"] }
+clap = { version = "4.0.9", features = ["derive"] }
 codec = { package = "parity-scale-codec", version = "3.0.0" }
 comfy-table = { version = "6.0.0", default-features = false }
 handlebars = "4.2.2"

substrate/utils/frame/benchmarking-cli/src/block/bench.rs

@@ -43,15 +43,15 @@ const LOG_TARGET: &'static str = "benchmark::block::weight";
 #[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
 pub struct BenchmarkParams {
 	/// Number of the first block to consider.
-	#[clap(long)]
+	#[arg(long)]
 	pub from: u32,
 
 	/// Last block number to consider.
-	#[clap(long)]
+	#[arg(long)]
 	pub to: u32,
 
 	/// Number of times that the benchmark should be repeated for each block.
-	#[clap(long, default_value = "10")]
+	#[arg(long, default_value_t = 10)]
 	pub repeat: u32,
 }
 

substrate/utils/frame/benchmarking-cli/src/block/cmd.rs

@@ -71,7 +71,7 @@ pub struct BlockCmd {
 	/// Enable the Trie cache.
 	///
 	/// This should only be used for performance analysis and not for final results.
-	#[clap(long)]
+	#[arg(long)]
 	pub enable_trie_cache: bool,
 }
 

substrate/utils/frame/benchmarking-cli/src/extrinsic/bench.rs

@@ -43,17 +43,17 @@ use crate::shared::{StatSelect, Stats};
 #[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
 pub struct BenchmarkParams {
 	/// Rounds of warmups before measuring.
-	#[clap(long, default_value = "10")]
+	#[arg(long, default_value_t = 10)]
 	pub warmup: u32,
 
 	/// How many times the benchmark should be repeated.
-	#[clap(long, default_value = "100")]
+	#[arg(long, default_value_t = 100)]
 	pub repeat: u32,
 
 	/// Maximal number of extrinsics that should be put into a block.
 	///
 	/// Only useful for debugging.
-	#[clap(long)]
+	#[arg(long)]
 	pub max_ext_per_block: Option<u32>,
 }
 

substrate/utils/frame/benchmarking-cli/src/extrinsic/cmd.rs

@@ -62,21 +62,21 @@ pub struct ExtrinsicParams {
 	/// List all available pallets and extrinsics.
 	///
 	/// The format is CSV with header `pallet, extrinsic`.
-	#[clap(long)]
+	#[arg(long)]
 	pub list: bool,
 
 	/// Pallet name of the extrinsic to benchmark.
-	#[clap(long, value_name = "PALLET", required_unless_present = "list")]
+	#[arg(long, value_name = "PALLET", required_unless_present = "list")]
 	pub pallet: Option<String>,
 
 	/// Extrinsic to benchmark.
-	#[clap(long, value_name = "EXTRINSIC", required_unless_present = "list")]
+	#[arg(long, value_name = "EXTRINSIC", required_unless_present = "list")]
 	pub extrinsic: Option<String>,
 
 	/// Enable the Trie cache.
 	///
 	/// This should only be used for performance analysis and not for final results.
-	#[clap(long)]
+	#[arg(long)]
 	pub enable_trie_cache: bool,
 }
 

substrate/utils/frame/benchmarking-cli/src/machine/mod.rs

@@ -53,30 +53,30 @@ pub struct MachineCmd {
 	/// Do not return an error if any check fails.
 	///
 	/// Should only be used for debugging.
-	#[clap(long)]
+	#[arg(long)]
 	pub allow_fail: bool,
 
 	/// Set a fault tolerance for passing a requirement.
 	///
 	/// 10% means that the test would pass even when only 90% score was archived.
 	/// Can be used to mitigate outliers of the benchmarks.
-	#[clap(long, default_value = "10.0", value_name = "PERCENT")]
+	#[arg(long, default_value_t = 10.0, value_name = "PERCENT")]
 	pub tolerance: f64,
 
 	/// Time limit for the verification benchmark.
-	#[clap(long, default_value = "5.0", value_name = "SECONDS")]
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
 	pub verify_duration: f32,
 
 	/// Time limit for the hash function benchmark.
-	#[clap(long, default_value = "5.0", value_name = "SECONDS")]
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
 	pub hash_duration: f32,
 
 	/// Time limit for the memory benchmark.
-	#[clap(long, default_value = "5.0", value_name = "SECONDS")]
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
 	pub memory_duration: f32,
 
 	/// Time limit for each disk benchmark.
-	#[clap(long, default_value = "5.0", value_name = "SECONDS")]
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
 	pub disk_duration: f32,
 }
 

substrate/utils/frame/benchmarking-cli/src/overhead/cmd.rs

@@ -73,13 +73,13 @@ pub struct OverheadParams {
 	/// Add a header to the generated weight output file.
 	///
 	/// Good for adding LICENSE headers.
-	#[clap(long, value_name = "PATH")]
+	#[arg(long, value_name = "PATH")]
 	pub header: Option<PathBuf>,
 
 	/// Enable the Trie cache.
 	///
 	/// This should only be used for performance analysis and not for final results.
-	#[clap(long)]
+	#[arg(long)]
 	pub enable_trie_cache: bool,
 }
 

substrate/utils/frame/benchmarking-cli/src/pallet/mod.rs

@@ -27,69 +27,69 @@ use std::{fmt::Debug, path::PathBuf};
 
 // Add a more relaxed parsing for pallet names by allowing pallet directory names with `-` to be
 // used like crate names with `_`
-fn parse_pallet_name(pallet: &str) -> String {
-	pallet.replace("-", "_")
+fn parse_pallet_name(pallet: &str) -> std::result::Result<String, String> {
+	Ok(pallet.replace("-", "_"))
 }
 
 /// Benchmark the extrinsic weight of FRAME Pallets.
 #[derive(Debug, clap::Parser)]
 pub struct PalletCmd {
 	/// Select a FRAME Pallet to benchmark, or `*` for all (in which case `extrinsic` must be `*`).
-	#[clap(short, long, parse(from_str = parse_pallet_name), required_unless_present_any = ["list", "json-input"])]
+	#[arg(short, long, value_parser = parse_pallet_name, required_unless_present_any = ["list", "json_input"])]
 	pub pallet: Option<String>,
 
 	/// Select an extrinsic inside the pallet to benchmark, or `*` for all.
-	#[clap(short, long, required_unless_present_any = ["list", "json-input"])]
+	#[arg(short, long, required_unless_present_any = ["list", "json_input"])]
 	pub extrinsic: Option<String>,
 
 	/// Select how many samples we should take across the variable components.
-	#[clap(short, long, default_value = "2")]
+	#[arg(short, long, default_value_t = 2)]
 	pub steps: u32,
 
 	/// Indicates lowest values for each of the component ranges.
-	#[clap(long = "low", use_value_delimiter = true)]
+	#[arg(long = "low", value_delimiter = ',')]
 	pub lowest_range_values: Vec<u32>,
 
 	/// Indicates highest values for each of the component ranges.
-	#[clap(long = "high", use_value_delimiter = true)]
+	#[arg(long = "high", value_delimiter = ',')]
 	pub highest_range_values: Vec<u32>,
 
 	/// Select how many repetitions of this benchmark should run from within the wasm.
-	#[clap(short, long, default_value = "1")]
+	#[arg(short, long, default_value_t = 1)]
 	pub repeat: u32,
 
 	/// Select how many repetitions of this benchmark should run from the client.
 	///
 	/// NOTE: Using this alone may give slower results, but will afford you maximum Wasm memory.
-	#[clap(long, default_value = "1")]
+	#[arg(long, default_value_t = 1)]
 	pub external_repeat: u32,
 
 	/// Print the raw results in JSON format.
-	#[clap(long = "json")]
+	#[arg(long = "json")]
 	pub json_output: bool,
 
 	/// Write the raw results in JSON format into the given file.
-	#[clap(long, conflicts_with = "json-output")]
+	#[arg(long, conflicts_with = "json_output")]
 	pub json_file: Option<PathBuf>,
 
 	/// Don't print the median-slopes linear regression analysis.
-	#[clap(long)]
+	#[arg(long)]
 	pub no_median_slopes: bool,
 
 	/// Don't print the min-squares linear regression analysis.
-	#[clap(long)]
+	#[arg(long)]
 	pub no_min_squares: bool,
 
 	/// Output the benchmarks to a Rust file at the given path.
-	#[clap(long)]
+	#[arg(long)]
 	pub output: Option<PathBuf>,
 
 	/// Add a header file to your outputted benchmarks.
-	#[clap(long)]
+	#[arg(long)]
 	pub header: Option<PathBuf>,
 
 	/// Path to Handlebars template file used for outputting benchmark results. (Optional)
-	#[clap(long)]
+	#[arg(long)]
 	pub template: Option<PathBuf>,
 
 	#[allow(missing_docs)]
@@ -100,25 +100,25 @@ pub struct PalletCmd {
 	/// * min-squares (default)
 	/// * median-slopes
 	/// * max (max of min squares and median slopes for each value)
-	#[clap(long)]
+	#[arg(long)]
 	pub output_analysis: Option<String>,
 
 	/// Set the heap pages while running benchmarks. If not set, the default value from the client
 	/// is used.
-	#[clap(long)]
+	#[arg(long)]
 	pub heap_pages: Option<u64>,
 
 	/// Disable verification logic when running benchmarks.
-	#[clap(long)]
+	#[arg(long)]
 	pub no_verify: bool,
 
 	/// Display and run extra benchmarks that would otherwise not be needed for weight
 	/// construction.
-	#[clap(long)]
+	#[arg(long)]
 	pub extra: bool,
 
 	/// Estimate PoV size.
-	#[clap(long)]
+	#[arg(long)]
 	pub record_proof: bool,
 
 	#[allow(missing_docs)]
@@ -126,50 +126,50 @@ pub struct PalletCmd {
 	pub shared_params: sc_cli::SharedParams,
 
 	/// The execution strategy that should be used for benchmarks.
-	#[clap(long, value_name = "STRATEGY", arg_enum, ignore_case = true)]
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true)]
 	pub execution: Option<ExecutionStrategy>,
 
 	/// Method for executing Wasm runtime code.
-	#[clap(
+	#[arg(
 		long = "wasm-execution",
 		value_name = "METHOD",
-		possible_values = WasmExecutionMethod::variants(),
+		value_enum,
 		ignore_case = true,
-		default_value = DEFAULT_WASM_EXECUTION_METHOD,
+		default_value_t = DEFAULT_WASM_EXECUTION_METHOD,
 	)]
 	pub wasm_method: WasmExecutionMethod,
 
 	/// The WASM instantiation method to use.
 	///
 	/// Only has an effect when `wasm-execution` is set to `compiled`.
-	#[clap(
+	#[arg(
 		long = "wasm-instantiation-strategy",
 		value_name = "STRATEGY",
 		default_value_t = DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
-		arg_enum,
+		value_enum,
 	)]
 	pub wasmtime_instantiation_strategy: WasmtimeInstantiationStrategy,
 
 	/// Limit the memory the database cache can use.
-	#[clap(long = "db-cache", value_name = "MiB", default_value = "1024")]
+	#[arg(long = "db-cache", value_name = "MiB", default_value_t = 1024)]
 	pub database_cache_size: u32,
 
 	/// List the benchmarks that match your query rather than running them.
 	///
 	/// When nothing is provided, we list all benchmarks.
-	#[clap(long)]
+	#[arg(long)]
 	pub list: bool,
 
 	/// If enabled, the storage info is not displayed in the output next to the analysis.
 	///
 	/// This is independent of the storage info appearing in the *output file*. Use a Handlebar
 	/// template for that purpose.
-	#[clap(long)]
+	#[arg(long)]
 	pub no_storage_info: bool,
 
 	/// A path to a `.json` file with existing benchmark results generated with `--json` or
 	/// `--json-file`. When specified the benchmarks are not actually executed, and the data for
 	/// the analysis is read from this file.
-	#[clap(long)]
+	#[arg(long)]
 	pub json_input: Option<PathBuf>,
 }

substrate/utils/frame/benchmarking-cli/src/shared/mod.rs

@@ -95,22 +95,22 @@ pub fn check_build_profile() -> Result<(), String> {
 
 /// Parameters to configure how the host info will be determined.
 #[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
-#[clap(rename_all = "kebab-case")]
+#[command(rename_all = "kebab-case")]
 pub struct HostInfoParams {
 	/// Manually override the hostname to use.
-	#[clap(long)]
+	#[arg(long)]
 	pub hostname_override: Option<String>,
 
 	/// Specify a fallback hostname if no-one could be detected automatically.
 	///
 	/// Note: This only exists to make the `hostname` function infallible.
-	#[clap(long, default_value = "<UNKNOWN>")]
+	#[arg(long, default_value = "<UNKNOWN>")]
 	pub hostname_fallback: String,
 
 	/// Specify a fallback CPU name if no-one could be detected automatically.
 	///
 	/// Note: This only exists to make the `cpuname` function infallible.
-	#[clap(long, default_value = "<UNKNOWN>")]
+	#[arg(long, default_value = "<UNKNOWN>")]
 	pub cpuname_fallback: String,
 }
 

substrate/utils/frame/benchmarking-cli/src/shared/weight_params.rs

@@ -31,23 +31,23 @@ pub struct WeightParams {
 	/// File or directory to write the *weight* files to.
 	///
 	/// For Substrate this should be `frame/support/src/weights`.
-	#[clap(long)]
+	#[arg(long)]
 	pub weight_path: Option<PathBuf>,
 
 	/// Select a specific metric to calculate the final weight output.
-	#[clap(long = "metric", default_value = "average")]
+	#[arg(long = "metric", default_value = "average")]
 	pub weight_metric: StatSelect,
 
 	/// Multiply the resulting weight with the given factor. Must be positive.
 	///
 	/// Is applied before `weight_add`.
-	#[clap(long = "mul", default_value = "1")]
+	#[arg(long = "mul", default_value_t = 1.0)]
 	pub weight_mul: f64,
 
 	/// Add the given offset to the resulting weight.
 	///
 	/// Is applied after `weight_mul`.
-	#[clap(long = "add", default_value = "0")]
+	#[arg(long = "add", default_value_t = 0)]
 	pub weight_add: u64,
 }
 

substrate/utils/frame/benchmarking-cli/src/storage/cmd.rs

@@ -68,54 +68,54 @@ pub struct StorageParams {
 	pub hostinfo: HostInfoParams,
 
 	/// Skip the `read` benchmark.
-	#[clap(long)]
+	#[arg(long)]
 	pub skip_read: bool,
 
 	/// Skip the `write` benchmark.
-	#[clap(long)]
+	#[arg(long)]
 	pub skip_write: bool,
 
 	/// Specify the Handlebars template to use for outputting benchmark results.
-	#[clap(long)]
+	#[arg(long)]
 	pub template_path: Option<PathBuf>,
 
 	/// Add a header to the generated weight output file.
 	///
 	/// Good for adding LICENSE headers.
-	#[clap(long, value_name = "PATH")]
+	#[arg(long, value_name = "PATH")]
 	pub header: Option<PathBuf>,
 
 	/// Path to write the raw 'read' results in JSON format to. Can be a file or directory.
-	#[clap(long)]
+	#[arg(long)]
 	pub json_read_path: Option<PathBuf>,
 
 	/// Path to write the raw 'write' results in JSON format to. Can be a file or directory.
-	#[clap(long)]
+	#[arg(long)]
 	pub json_write_path: Option<PathBuf>,
 
 	/// Rounds of warmups before measuring.
-	#[clap(long, default_value = "1")]
+	#[arg(long, default_value_t = 1)]
 	pub warmups: u32,
 
 	/// The `StateVersion` to use. Substrate `--dev` should use `V1` and Polkadot `V0`.
 	/// Selecting the wrong version can corrupt the DB.
-	#[clap(long, possible_values = ["0", "1"])]
+	#[arg(long, value_parser = clap::value_parser!(u8).range(0..=1))]
 	pub state_version: u8,
 
 	/// Trie cache size in bytes.
 	///
 	/// Providing `0` will disable the cache.
-	#[clap(long, value_name = "Bytes", default_value = "67108864")]
+	#[arg(long, value_name = "Bytes", default_value_t = 67108864)]
 	pub trie_cache_size: usize,
 
 	/// Enable the Trie cache.
 	///
 	/// This should only be used for performance analysis and not for final results.
-	#[clap(long)]
+	#[arg(long)]
 	pub enable_trie_cache: bool,
 
 	/// Include child trees in benchmark.
-	#[clap(long)]
+	#[arg(long)]
 	pub include_child_trees: bool,
 }
 

substrate/utils/frame/frame-utilities-cli/Cargo.toml

@@ -11,7 +11,7 @@ documentation = "https://docs.rs/substrate-frame-cli"
 readme = "README.md"
 
 [dependencies]
-clap = { version = "3.1.18", features = ["derive"] }
+clap = { version = "4.0.9", features = ["derive"] }
 frame-support = { version = "4.0.0-dev", path = "../../../frame/support" }
 frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
 sc-cli = { version = "0.10.0-dev", path = "../../../client/cli" }

substrate/utils/frame/frame-utilities-cli/src/pallet_id.rs

@@ -28,31 +28,30 @@ use sp_runtime::traits::AccountIdConversion;
 
 /// The `palletid` command
 #[derive(Debug, Parser)]
-#[clap(name = "palletid", about = "Inspect a module ID address")]
+#[command(name = "palletid", about = "Inspect a module ID address")]
 pub struct PalletIdCmd {
 	/// The module ID used to derive the account
 	id: String,
 
 	/// network address format
-	#[clap(
+	#[arg(
 		long,
 		value_name = "NETWORK",
-		possible_values = &Ss58AddressFormat::all_names()[..],
-		parse(try_from_str = Ss58AddressFormat::try_from),
+		value_parser = sc_cli::parse_ss58_address_format,
 		ignore_case = true,
 	)]
 	pub network: Option<Ss58AddressFormat>,
 
 	#[allow(missing_docs)]
-	#[clap(flatten)]
+	#[command(flatten)]
 	pub output_scheme: OutputTypeFlag,
 
 	#[allow(missing_docs)]
-	#[clap(flatten)]
+	#[command(flatten)]
 	pub crypto_scheme: CryptoSchemeFlag,
 
 	#[allow(missing_docs)]
-	#[clap(flatten)]
+	#[command(flatten)]
 	pub keystore_params: KeystoreParams,
 }
 

substrate/utils/frame/generate-bags/node-runtime/Cargo.toml

@@ -14,4 +14,4 @@ kitchensink-runtime = { version = "3.0.0-dev", path = "../../../../bin/node/runt
 generate-bags = { version = "4.0.0-dev", path = "../" }
 
 # third-party
-clap = { version = "3.1.18", features = ["derive"] }
+clap = { version = "4.0.9", features = ["derive"] }

substrate/utils/frame/generate-bags/node-runtime/src/main.rs

@@ -25,19 +25,19 @@ use std::path::PathBuf;
 // #[clap(author, version, about)]
 struct Opt {
 	/// How many bags to generate.
-	#[clap(long, default_value = "200")]
+	#[arg(long, default_value_t = 200)]
 	n_bags: usize,
 
 	/// Where to write the output.
 	output: PathBuf,
 
 	/// The total issuance of the currency used to create `VoteWeight`.
-	#[clap(short, long)]
+	#[arg(short, long)]
 	total_issuance: u128,
 
 	/// The minimum account balance (i.e. existential deposit) for the currency used to create
 	/// `VoteWeight`.
-	#[clap(short, long)]
+	#[arg(short, long)]
 	minimum_balance: u128,
 }
 

substrate/utils/frame/try-runtime/cli/Cargo.toml

@@ -13,7 +13,7 @@ readme = "README.md"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-clap = { version = "3.1.18", features = ["derive"] }
+clap = { version = "4.0.9", features = ["derive"] }
 log = "0.4.17"
 parity-scale-codec = "3.0.0"
 serde = "1.0.136"

substrate/utils/frame/try-runtime/cli/src/commands/execute_block.rs

@@ -33,11 +33,11 @@ use std::{fmt::Debug, str::FromStr};
 #[derive(Debug, Clone, clap::Parser)]
 pub struct ExecuteBlockCmd {
 	/// Overwrite the wasm code in state or not.
-	#[clap(long)]
+	#[arg(long)]
 	overwrite_wasm_code: bool,
 
 	/// If set the state root check is disabled.
-	#[clap(long)]
+	#[arg(long)]
 	no_state_root_check: bool,
 
 	/// Which try-state targets to execute when running this command.
@@ -49,17 +49,16 @@ pub struct ExecuteBlockCmd {
 	///   `Staking, System`).
 	/// - `rr-[x]` where `[x]` is a number. Then, the given number of pallets are checked in a
 	///   round-robin fashion.
-	#[clap(long, default_value = "none")]
+	#[arg(long, default_value = "none")]
 	try_state: frame_try_runtime::TryStateSelect,
 
 	/// The block hash at which to fetch the block.
 	///
 	/// If the `live` state type is being used, then this can be omitted, and is equal to whatever
 	/// the `state::at` is. Only use this (with care) when combined with a snapshot.
-	#[clap(
+	#[arg(
 		long,
-		multiple_values = false,
-		parse(try_from_str = crate::parse::hash)
+		value_parser = crate::parse::hash
 	)]
 	block_at: Option<String>,
 
@@ -67,10 +66,9 @@ pub struct ExecuteBlockCmd {
 	///
 	/// If the `live` state type is being used, then this can be omitted, and is equal to whatever
 	/// the `state::uri` is. Only use this (with care) when combined with a snapshot.
-	#[clap(
+	#[arg(
 		long,
-		multiple_values = false,
-		parse(try_from_str = crate::parse::url)
+		value_parser = crate::parse::url
 	)]
 	block_ws_uri: Option<String>,
 
@@ -79,7 +77,7 @@ pub struct ExecuteBlockCmd {
 	/// For this command only, if the `live` is used, then state of the parent block is fetched.
 	///
 	/// If `block_at` is provided, then the [`State::Live::at`] is being ignored.
-	#[clap(subcommand)]
+	#[command(subcommand)]
 	state: State,
 }
 

substrate/utils/frame/try-runtime/cli/src/commands/follow_chain.rs

@@ -43,11 +43,11 @@ const UN_SUB: &str = "chain_unsubscribeFinalizedHeads";
 #[derive(Debug, Clone, clap::Parser)]
 pub struct FollowChainCmd {
 	/// The url to connect to.
-	#[clap(short, long, parse(try_from_str = parse::url))]
+	#[arg(short, long, value_parser = parse::url)]
 	uri: String,
 
 	/// If set, then the state root check is enabled.
-	#[clap(long)]
+	#[arg(long)]
 	state_root_check: bool,
 
 	/// Which try-state targets to execute when running this command.
@@ -59,11 +59,11 @@ pub struct FollowChainCmd {
 	///   `Staking, System`).
 	/// - `rr-[x]` where `[x]` is a number. Then, the given number of pallets are checked in a
 	///   round-robin fashion.
-	#[clap(long, default_value = "none")]
+	#[arg(long, default_value = "none")]
 	try_state: frame_try_runtime::TryStateSelect,
 
 	/// If present, a single connection to a node will be kept and reused for fetching blocks.
-	#[clap(long)]
+	#[arg(long)]
 	keep_connection: bool,
 }
 

substrate/utils/frame/try-runtime/cli/src/commands/offchain_worker.rs

@@ -31,17 +31,16 @@ use std::{fmt::Debug, str::FromStr};
 #[derive(Debug, Clone, clap::Parser)]
 pub struct OffchainWorkerCmd {
 	/// Overwrite the wasm code in state or not.
-	#[clap(long)]
+	#[arg(long)]
 	overwrite_wasm_code: bool,
 
 	/// The block hash at which to fetch the header.
 	///
 	/// If the `live` state type is being used, then this can be omitted, and is equal to whatever
 	/// the `state::at` is. Only use this (with care) when combined with a snapshot.
-	#[clap(
+	#[arg(
 		long,
-		multiple_values = false,
-		parse(try_from_str = parse::hash)
+		value_parser = parse::hash
 	)]
 	header_at: Option<String>,
 
@@ -49,15 +48,14 @@ pub struct OffchainWorkerCmd {
 	///
 	/// If the `live` state type is being used, then this can be omitted, and is equal to whatever
 	/// the `state::uri` is. Only use this (with care) when combined with a snapshot.
-	#[clap(
+	#[arg(
 		long,
-		multiple_values = false,
-		parse(try_from_str = parse::url)
+		value_parser = parse::url
 	)]
 	header_ws_uri: Option<String>,
 
 	/// The state type to use.
-	#[clap(subcommand)]
+	#[command(subcommand)]
 	pub state: State,
 }
 

substrate/utils/frame/try-runtime/cli/src/commands/on_runtime_upgrade.rs

@@ -32,7 +32,7 @@ use crate::{
 #[derive(Debug, Clone, clap::Parser)]
 pub struct OnRuntimeUpgradeCmd {
 	/// The state type to use.
-	#[clap(subcommand)]
+	#[command(subcommand)]
 	pub state: State,
 }
 

substrate/utils/frame/try-runtime/cli/src/lib.rs

@@ -385,6 +385,7 @@ pub enum Command {
 
 /// Shared parameters of the `try-runtime` commands
 #[derive(Debug, Clone, clap::Parser)]
+#[group(skip)]
 pub struct SharedParams {
 	/// Shared parameters of substrate cli.
 	#[allow(missing_docs)]
@@ -392,41 +393,41 @@ pub struct SharedParams {
 	pub shared_params: sc_cli::SharedParams,
 
 	/// The execution strategy that should be used.
-	#[clap(long, value_name = "STRATEGY", arg_enum, ignore_case = true, default_value = "wasm")]
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true, default_value_t = ExecutionStrategy::Wasm)]
 	pub execution: ExecutionStrategy,
 
 	/// Type of wasm execution used.
-	#[clap(
+	#[arg(
 		long = "wasm-execution",
 		value_name = "METHOD",
-		possible_values = WasmExecutionMethod::variants(),
+		value_enum,
 		ignore_case = true,
-		default_value = DEFAULT_WASM_EXECUTION_METHOD,
+		default_value_t = DEFAULT_WASM_EXECUTION_METHOD,
 	)]
 	pub wasm_method: WasmExecutionMethod,
 
 	/// The WASM instantiation method to use.
 	///
 	/// Only has an effect when `wasm-execution` is set to `compiled`.
-	#[clap(
+	#[arg(
 		long = "wasm-instantiation-strategy",
 		value_name = "STRATEGY",
 		default_value_t = DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
-		arg_enum,
+		value_enum,
 	)]
 	pub wasmtime_instantiation_strategy: WasmtimeInstantiationStrategy,
 
 	/// The number of 64KB pages to allocate for Wasm execution. Defaults to
 	/// [`sc_service::Configuration.default_heap_pages`].
-	#[clap(long)]
+	#[arg(long)]
 	pub heap_pages: Option<u64>,
 
 	/// When enabled, the spec check will not panic, and instead only show a warning.
-	#[clap(long)]
+	#[arg(long)]
 	pub no_spec_check_panic: bool,
 
 	/// State version that is used by the chain.
-	#[clap(long, default_value = "1", parse(try_from_str = parse::state_version))]
+	#[arg(long, default_value_t = StateVersion::V1, value_parser = parse::state_version)]
 	pub state_version: StateVersion,
 }
 
@@ -438,7 +439,7 @@ pub struct TryRuntimeCmd {
 	#[clap(flatten)]
 	pub shared: SharedParams,
 
-	#[clap(subcommand)]
+	#[command(subcommand)]
 	pub command: Command,
 }
 
@@ -449,17 +450,17 @@ pub enum State {
 	///
 	/// This can be crated by passing a value to [`State::Live::snapshot_path`].
 	Snap {
-		#[clap(short, long)]
+		#[arg(short, long)]
 		snapshot_path: PathBuf,
 	},
 
 	/// Use a live chain as the source of runtime state.
 	Live {
 		/// The url to connect to.
-		#[clap(
+		#[arg(
 			short,
 			long,
-			parse(try_from_str = parse::url),
+			value_parser = parse::url,
 		)]
 		uri: String,
 
@@ -467,21 +468,20 @@ pub enum State {
 		///
 		/// If non provided, then the latest finalized head is used. This is particularly useful
 		/// for [`Command::OnRuntimeUpgrade`].
-		#[clap(
+		#[arg(
 			short,
 			long,
-			multiple_values = false,
-			parse(try_from_str = parse::hash),
+			value_parser = parse::hash,
 		)]
 		at: Option<String>,
 
 		/// An optional state snapshot file to WRITE to. Not written if set to `None`.
-		#[clap(short, long)]
+		#[arg(short, long)]
 		snapshot_path: Option<PathBuf>,
 
 		/// A pallet to scrape. Can be provided multiple times. If empty, entire chain state will
 		/// be scraped.
-		#[clap(short, long, multiple_values = true)]
+		#[arg(short, long, num_args = 1..)]
 		pallet: Vec<String>,
 
 		/// Fetch the child-keys as well.
@@ -489,7 +489,7 @@ pub enum State {
 		/// Default is `false`, if specific `--pallets` are specified, `true` otherwise. In other
 		/// words, if you scrape the whole state the child tree data is included out of the box.
 		/// Otherwise, it must be enabled explicitly using this flag.
-		#[clap(long)]
+		#[arg(long)]
 		child_tree: bool,
 	},
 }