Migrate to clap from structopt

lib/cli-compiler/Cargo.toml

@@ -23,7 +23,7 @@ wasmer-types = { version = "=3.0.0-alpha.4", path = "../types" }
 atty = "0.2"
 colored = "2.0"
 anyhow = "1.0"
-structopt = { version = "0.3", features = ["suggestions"] }
+clap = { version = "3.1", features = ["derive"] }
 # For the function names autosuggestion
 distance = "0.4"
 # For the inspect subcommand
@@ -32,6 +32,7 @@ cfg-if = "1.0"
 # For debug feature
 fern = { version = "0.6", features = ["colored"], optional = true }
 log = { version = "0.4", optional = true }
+target-lexicon = { version = "0.12", features = ["std"] }
 tempfile = "3"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

lib/cli-compiler/src/cli.rs

@@ -5,27 +5,27 @@ use crate::commands::{Config, Validate};
 use crate::error::PrettyError;
 use anyhow::Result;
 
-use structopt::{clap::ErrorKind, StructOpt};
+use clap::{ErrorKind, Parser};
 
-#[derive(StructOpt)]
-#[structopt(
+#[derive(Parser)]
+#[clap(
     name = "wasmer-compiler",
     about = "WebAssembly standalone Compiler.",
     author
 )]
 /// The options for the wasmer Command Line Interface
 enum WasmerCLIOptions {
     /// Validate a WebAssembly binary
-    #[structopt(name = "validate")]
+    #[clap(name = "validate")]
     Validate(Validate),
 
     /// Compile a WebAssembly binary
-    #[structopt(name = "compile")]
+    #[clap(name = "compile")]
     Compile(Compile),
 
     /// Get various configuration information needed
     /// to compile programs which use Wasmer
-    #[structopt(name = "config")]
+    #[clap(name = "config")]
     Config(Config),
 }
 
@@ -56,15 +56,15 @@ pub fn wasmer_main() {
     let command = args.get(1);
     let options = {
         match command.unwrap_or(&"".to_string()).as_ref() {
-            "compile" | "config" | "help" | "inspect" | "validate" => WasmerCLIOptions::from_args(),
+            "compile" | "config" | "help" | "inspect" | "validate" => WasmerCLIOptions::parse(),
             _ => {
-                WasmerCLIOptions::from_iter_safe(args.iter()).unwrap_or_else(|e| {
-                    match e.kind {
+                WasmerCLIOptions::try_parse_from(args.iter()).unwrap_or_else(|e| {
+                    match e.kind() {
                         // This fixes a issue that:
                         // 1. Shows the version twice when doing `wasmer -V`
                         // 2. Shows the run help (instead of normal help) when doing `wasmer --help`
-                        ErrorKind::VersionDisplayed | ErrorKind::HelpDisplayed => e.exit(),
-                        _ => WasmerCLIOptions::Compile(Compile::from_args()),
+                        ErrorKind::DisplayVersion | ErrorKind::DisplayHelp => e.exit(),
+                        _ => WasmerCLIOptions::Compile(Compile::parse()),
                     }
                 })
             }

lib/cli-compiler/src/commands/compile.rs

@@ -1,34 +1,36 @@
 use crate::store::StoreOptions;
 use crate::warning;
 use anyhow::{Context, Result};
+use clap::Parser;
 use std::path::{Path, PathBuf};
-use structopt::StructOpt;
-use wasmer_compiler::ModuleEnvironment;
-use wasmer_compiler::{ArtifactBuild, ArtifactCreate};
+use wasmer_compiler::{ArtifactBuild, ArtifactCreate, ModuleEnvironment};
 use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
     CompileError, CpuFeature, MemoryIndex, MemoryStyle, TableIndex, TableStyle, Target, Triple,
 };
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 /// The options for the `wasmer compile` subcommand
 pub struct Compile {
     /// Input file
-    #[structopt(name = "FILE", parse(from_os_str))]
+    #[clap(name = "FILE", parse(from_os_str))]
     path: PathBuf,
 
     /// Output file
-    #[structopt(name = "OUTPUT PATH", short = "o", parse(from_os_str))]
+    #[clap(name = "OUTPUT PATH", short = 'o', parse(from_os_str))]
     output: PathBuf,
 
     /// Compilation Target triple
-    #[structopt(long = "target")]
+    #[clap(long = "target")]
     target_triple: Option<Triple>,
 
-    #[structopt(flatten)]
+    #[clap(flatten)]
     store: StoreOptions,
 
-    #[structopt(short = "m", multiple = true, number_of_values = 1)]
+    // TODO: multiple_values or multiple_occurrences, or both?
+    // TODO: number_of_values = 1 required? need to read some more documentation
+    // before I can be sure
+    #[clap(short = 'm', multiple_occurrences = true, number_of_values = 1)]
     cpu_features: Vec<CpuFeature>,
 }
 

lib/cli-compiler/src/commands/config.rs

@@ -1,39 +1,39 @@
 use crate::VERSION;
 use anyhow::{Context, Result};
+use clap::Parser;
 use std::env;
 use std::path::PathBuf;
-use structopt::StructOpt;
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 /// The options for the `wasmer config` subcommand
 pub struct Config {
     /// Print the installation prefix.
-    #[structopt(long, conflicts_with = "pkg-config")]
+    #[clap(long, conflicts_with = "pkg-config")]
     prefix: bool,
 
     /// Directory containing Wasmer executables.
-    #[structopt(long, conflicts_with = "pkg-config")]
+    #[clap(long, conflicts_with = "pkg-config")]
     bindir: bool,
 
     /// Directory containing Wasmer headers.
-    #[structopt(long, conflicts_with = "pkg-config")]
+    #[clap(long, conflicts_with = "pkg-config")]
     includedir: bool,
 
     /// Directory containing Wasmer libraries.
-    #[structopt(long, conflicts_with = "pkg-config")]
+    #[clap(long, conflicts_with = "pkg-config")]
     libdir: bool,
 
     /// Libraries needed to link against Wasmer components.
-    #[structopt(long, conflicts_with = "pkg-config")]
+    #[clap(long, conflicts_with = "pkg-config")]
     libs: bool,
 
     /// C compiler flags for files that include Wasmer headers.
-    #[structopt(long, conflicts_with = "pkg-config")]
+    #[clap(long, conflicts_with = "pkg-config")]
     cflags: bool,
 
     /// It outputs the necessary details for compiling
     /// and linking a program to Wasmer, using the `pkg-config` format.
-    #[structopt(long)]
+    #[clap(long)]
     pkg_config: bool,
 }
 

lib/cli-compiler/src/commands/validate.rs

@@ -1,18 +1,18 @@
 use crate::store::StoreOptions;
 use anyhow::{bail, Context, Result};
+use clap::Parser;
 use std::path::PathBuf;
 use std::str::FromStr;
-use structopt::StructOpt;
 use wasmer_types::{is_wasm, CpuFeature, Target, Triple};
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Parser)]
 /// The options for the `wasmer validate` subcommand
 pub struct Validate {
     /// File to validate as WebAssembly
-    #[structopt(name = "FILE", parse(from_os_str))]
+    #[clap(name = "FILE", parse(from_os_str))]
     path: PathBuf,
 
-    #[structopt(flatten)]
+    #[clap(flatten)]
     store: StoreOptions,
 }
 

lib/cli-compiler/src/common.rs

@@ -1,36 +1,36 @@
 //! Common module with common used structures across different
 //! commands.
 use crate::VERSION;
+use clap::Parser;
 use std::env;
 use std::path::PathBuf;
-use structopt::StructOpt;
 
-#[derive(Debug, StructOpt, Clone, Default)]
+#[derive(Debug, Parser, Clone, Default)]
 /// The WebAssembly features that can be passed through the
 /// Command Line args.
 pub struct WasmFeatures {
     /// Enable support for the SIMD proposal.
-    #[structopt(long = "enable-simd")]
+    #[clap(long = "enable-simd")]
     pub simd: bool,
 
     /// Enable support for the threads proposal.
-    #[structopt(long = "enable-threads")]
+    #[clap(long = "enable-threads")]
     pub threads: bool,
 
     /// Enable support for the reference types proposal.
-    #[structopt(long = "enable-reference-types")]
+    #[clap(long = "enable-reference-types")]
     pub reference_types: bool,
 
     /// Enable support for the multi value proposal.
-    #[structopt(long = "enable-multi-value")]
+    #[clap(long = "enable-multi-value")]
     pub multi_value: bool,
 
     /// Enable support for the bulk memory proposal.
-    #[structopt(long = "enable-bulk-memory")]
+    #[clap(long = "enable-bulk-memory")]
     pub bulk_memory: bool,
 
     /// Enable support for all pre-standard proposals.
-    #[structopt(long = "enable-all")]
+    #[clap(long = "enable-all")]
     pub all: bool,
 }