Move from structopt to clap version 3 (bytecodealliance#435)

* Move from `structopt` to `clap` version 3

A straightforward update!

* More migration

Author: alexcrichton

Cargo.toml

@@ -18,7 +18,7 @@ members = ['fuzz', 'crates/wasm-encoder', 'crates/fuzz-stats', 'crates/wasm-muta
 anyhow = "1.0"
 env_logger = "0.8"
 log = "0.4"
-structopt = "0.3.16"
+clap = { version = "3.0", features = ['derive'] }
 tempfile = "3.2.0"
 wat = { path = "crates/wat", optional = true }
 
@@ -36,11 +36,11 @@ serde_json = { version = "1", optional = true }
 wasm-smith = { path = "crates/wasm-smith", features = ["_internal_cli"], optional = true }
 
 # Dependencies of `shrink`
-wasm-shrink = { path = "crates/wasm-shrink", features = ["structopt"], optional = true}
+wasm-shrink = { path = "crates/wasm-shrink", features = ["clap"], optional = true}
 is_executable = { version = "1.0.1", optional = true }
 
 # Dependencies of `mutate`
-wasm-mutate = { path = "crates/wasm-mutate", features = ["structopt"], optional = true }
+wasm-mutate = { path = "crates/wasm-mutate", features = ["clap"], optional = true }
 
 # Dependencies of `dump`
 wasmparser-dump = { path = "crates/dump", optional = true }

crates/wasm-mutate-stats/Cargo.toml

@@ -15,7 +15,7 @@ wasmparser = { version = "0.81.0", path = "../wasmparser" }
 wasmtime = "0.32.0"
 env_logger = "0.8"
 itertools = "0.10.0"
-structopt = "0.3.16"
+clap = "3.0"
 log = "0.4"
 
 [lib]

crates/wasm-mutate-stats/src/bin/wasm-mutate-stats.rs

@@ -1,4 +1,5 @@
 use anyhow::Context;
+use clap::Parser;
 use core::sync::atomic::Ordering::{Relaxed, SeqCst};
 use rand::Rng;
 use rand::{rngs::SmallRng, SeedableRng};
@@ -12,14 +13,14 @@ use std::sync::Mutex;
 use std::time::Duration;
 use std::{collections::HashMap, sync::Arc};
 use std::{panic, process};
-use structopt::StructOpt;
 use wasm_mutate::WasmMutate;
 use wasmtime::{Config, Engine, OptLevel};
 
 #[derive(Debug)]
 enum ParsingOptLevelError {
     Parsing(String),
 }
+
 impl Display for ParsingOptLevelError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -28,6 +29,8 @@ impl Display for ParsingOptLevelError {
     }
 }
 
+impl std::error::Error for ParsingOptLevelError {}
+
 /// Parses the list of optimizations to set in wasmtime
 fn parse_optimization_types(s: &str) -> Result<OptLevel, ParsingOptLevelError> {
     match s {
@@ -66,25 +69,25 @@ fn parse_optimization_types(s: &str) -> Result<OptLevel, ParsingOptLevelError> {
 /// checking preservation for O0(No optimizations) and O2(size and speed optimization), using architecture
 /// triple `x86_64-apple-darwin`.
 ///
-#[derive(StructOpt)]
+#[derive(Parser)]
 struct Options {
     /// The input folder that contains the Wasm binaries.
     input: PathBuf,
     /// The timeout, 0 to wait for keyboard interrupt
     timeout: u64,
     /// The seed of the random mutation, 0 by default
-    #[structopt(short = "s", long = "seed")]
+    #[clap(short = 's', long = "seed")]
     seed: u64,
     /// List of engine configurations.
     /// Allowed values: [O0, O2, Os]
     /// If it is not set, the default configuration of wasmtime will be used
-    #[structopt(short = "c", long = "compilation-configs", parse(try_from_str=parse_optimization_types) )]
+    #[clap(short = 'c', long = "compilation-configs", parse(try_from_str=parse_optimization_types) )]
     configs: Option<Vec<OptLevel>>,
     /// Target triple during compilation, e.g. "x86_64-apple-darwin"
-    #[structopt(short = "a", long = "triple")]
+    #[clap(short = 'a', long = "triple")]
     triple: Option<String>,
     /// Only generate report, if this option is set, it will skip the generation
-    #[structopt(short = "k", long = "skip")]
+    #[clap(short = 'k', long = "skip")]
     skip_generation: bool,
 }
 
@@ -107,7 +110,7 @@ fn main() -> anyhow::Result<()> {
     // Init logs
     env_logger::init();
 
-    let opts = Options::from_args();
+    let opts = Options::parse();
     let timeout = opts.timeout;
     let seed = opts.seed;
 

crates/wasm-mutate/Cargo.toml

@@ -7,7 +7,7 @@ repository = "https://github.com/bytecodealliance/wasm-tools"
 description = "A WebAssembly test case mutator"
 
 [dependencies]
-structopt = { optional = true, version = "0.3" }
+clap = { optional = true, version = "3.0", features = ['derive'] }
 thiserror = "1.0.28"
 wasmparser = { version = "0.81", path = "../wasmparser" }
 wasm-encoder = { version = "0.8.0", path = "../wasm-encoder"}

crates/wasm-mutate/src/lib.rs

@@ -7,7 +7,7 @@
 //! tool. `wasm-mutate` can serve as a custom mutator for mutation-based
 //! fuzzing.
 
-#![cfg_attr(not(feature = "structopt"), deny(missing_docs))]
+#![cfg_attr(not(feature = "clap"), deny(missing_docs))]
 
 mod error;
 mod info;
@@ -31,8 +31,8 @@ use mutators::Mutator;
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use std::{cell::Cell, sync::Arc};
 
-#[cfg(feature = "structopt")]
-use structopt::StructOpt;
+#[cfg(feature = "clap")]
+use clap::Parser;
 
 macro_rules! define_mutators {
     (@count) => {0};
@@ -104,7 +104,7 @@ macro_rules! define_mutators {
 // NB: only add this doc comment if we are not building the CLI, since otherwise
 // it will override the main CLI's about text.
 #[cfg_attr(
-    not(feature = "structopt"),
+    not(feature = "clap"),
     doc = r###"
 A WebAssembly test case mutator.
 
@@ -149,36 +149,36 @@ for mutated_wasm in mutate.run(&input_wasm)? {
 ```
 "###
 )]
-#[cfg_attr(feature = "structopt", derive(StructOpt))]
+#[cfg_attr(feature = "clap", derive(Parser))]
 #[derive(Clone)]
 pub struct WasmMutate<'wasm> {
     /// The RNG seed used to choose which transformation to apply. Given the
     /// same input Wasm and same seed, `wasm-mutate` will always generate the
     /// same output Wasm.
-    #[cfg_attr(feature = "structopt", structopt(short, long))]
+    #[cfg_attr(feature = "clap", clap(short, long))]
     seed: u64,
 
     /// Only perform semantics-preserving transformations on the Wasm module.
-    #[cfg_attr(feature = "structopt", structopt(long))]
+    #[cfg_attr(feature = "clap", clap(long))]
     preserve_semantics: bool,
 
     /// Fuel to control the time of the mutation.
-    #[cfg_attr(feature = "structopt", structopt(skip = Cell::new(u64::MAX)))]
+    #[cfg_attr(feature = "clap", clap(skip = Cell::new(u64::MAX)))]
     fuel: Cell<u64>,
     /// Only perform size-reducing transformations on the Wasm module. This
     /// allows `wasm-mutate` to be used as a test case reducer.
-    #[cfg_attr(feature = "structopt", structopt(long))]
+    #[cfg_attr(feature = "clap", clap(long))]
     reduce: bool,
 
     // Note: this is only exposed via the programmatic interface, not via the
     // CLI.
-    #[cfg_attr(feature = "structopt", structopt(skip = None))]
+    #[cfg_attr(feature = "clap", clap(skip = None))]
     raw_mutate_func: Option<Arc<dyn Fn(&mut Vec<u8>) -> Result<()>>>,
 
-    #[cfg_attr(feature = "structopt", structopt(skip = None))]
+    #[cfg_attr(feature = "clap", clap(skip = None))]
     rng: Option<SmallRng>,
 
-    #[cfg_attr(feature = "structopt", structopt(skip = None))]
+    #[cfg_attr(feature = "clap", clap(skip = None))]
     info: Option<ModuleInfo<'wasm>>,
 }
 

crates/wasm-shrink/Cargo.toml

@@ -15,7 +15,7 @@ anyhow = "1"
 blake3 = "1.2.0"
 log = "0.4"
 rand = { version = "0.8.4", features = ["small_rng"] }
-structopt = { version = "0.3.25", optional = true }
+clap = { version = "3.0", optional = true, features = ['derive'] }
 wasm-mutate = { version = "0.1.0", path = "../wasm-mutate" }
 wasmparser = { version = "0.81", path = "../wasmparser" }
 

crates/wasm-shrink/src/lib.rs

@@ -18,7 +18,7 @@ static EMPTY_WASM: &'static [u8] = &[
 ];
 
 #[cfg_attr(
-    not(feature = "structopt"),
+    not(feature = "clap"),
     doc = r###"
 Shrink a Wasm file while maintaining a property of interest (such as
 triggering a compiler bug).
@@ -63,22 +63,22 @@ let shrunken_wasm = info.output;
 ```
 "###
 )]
-#[cfg_attr(feature = "structopt", derive(structopt::StructOpt))]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
 pub struct WasmShrink {
     /// The number of shrink attempts to try before considering a Wasm module as
     /// small as it will ever get.
-    #[cfg_attr(feature = "structopt", structopt(short, long, default_value = "1000"))]
+    #[cfg_attr(feature = "clap", clap(short, long, default_value = "1000"))]
     attempts: u32,
 
     /// Allow shrinking the input down to an empty Wasm module.
     ///
     /// This is usually not desired and typically reflects a bug in the
     /// predicate script.
-    #[cfg_attr(feature = "structopt", structopt(long))]
+    #[cfg_attr(feature = "clap", clap(long))]
     allow_empty: bool,
 
     /// The RNG seed for choosing which size-reducing mutation to attempt next.
-    #[cfg_attr(feature = "structopt", structopt(short, long, default_value = "42"))]
+    #[cfg_attr(feature = "clap", clap(short, long, default_value = "42"))]
     seed: u64,
 }
 

src/bin/wasm-tools/dump.rs

@@ -1,12 +1,11 @@
 use anyhow::Result;
 use std::path::PathBuf;
-use structopt::StructOpt;
 
 /// Debugging utility to dump information about a wasm binary.
 ///
 /// This can be useful to figure out precisely how each byte of a wasm binary is
 /// classified or where particular constructs are at particular offsets.
-#[derive(StructOpt)]
+#[derive(clap::Parser)]
 pub struct Opts {
     /// Input WebAssembly file to dump information about.
     input: PathBuf,

src/bin/wasm-tools/main.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use structopt::StructOpt;
+use clap::Parser;
 
 macro_rules! subcommands {
     ($(($name:ident, $string:tt))*) => {
@@ -8,13 +8,13 @@ macro_rules! subcommands {
             mod $name;
         )*
 
-        #[derive(StructOpt)]
-            #[allow(non_camel_case_types)]
+        #[derive(Parser)]
+        #[allow(non_camel_case_types)]
         enum WasmTools {
             $(
                 #[cfg(feature = $string)]
                 $name {
-                    #[structopt(flatten)]
+                    #[clap(flatten)]
                     opts: $name::Opts,
                 },
             )*
@@ -46,5 +46,5 @@ subcommands! {
 
 fn main() -> Result<()> {
     env_logger::init();
-    WasmTools::from_args().run()
+    <WasmTools as Parser>::parse().run()
 }

src/bin/wasm-tools/mutate.rs

@@ -1,8 +1,8 @@
 use anyhow::{Context, Result};
+use clap::Parser;
 use std::fs;
 use std::io::{stdin, stdout, Read, Write};
 use std::path::PathBuf;
-use structopt::StructOpt;
 use wasm_mutate::ErrorKind;
 
 /// A WebAssembly test case mutator.
@@ -38,22 +38,22 @@ use wasm_mutate::ErrorKind;
 ///      supported by `wasm-mutate`.
 ///
 /// * 6: Other error.
-#[derive(StructOpt)]
+#[derive(Parser)]
 pub struct Opts {
     /// The input WebAssembly binary that will be mutated.
     ///
     /// `stdin` is used if this argument is not supplied.
-    #[structopt(parse(from_os_str))]
+    #[clap(parse(from_os_str))]
     input: Option<PathBuf>,
 
     /// The output file path, where the new, mutated WebAssembly module is
     /// placed.
     ///
     /// `stdout` is used if this argument is not supplied.
-    #[structopt(short, long, parse(from_os_str))]
+    #[clap(short, long, parse(from_os_str))]
     output: Option<PathBuf>,
 
-    #[structopt(flatten)]
+    #[clap(flatten)]
     wasm_mutate: wasm_mutate::WasmMutate<'static>,
 }