Fix feature flags for make-build-wasmer-headless

lib/api/src/sys/imports.rs

@@ -174,6 +174,7 @@ impl Imports {
     /// Resolve and return a vector of imports in the order they are defined in the `module`'s source code.
     ///
     /// This means the returned `Vec<Extern>` might be a subset of the imports contained in `self`.
+    #[allow(clippy::result_large_err)]
     pub fn imports_for_module(&self, module: &Module) -> Result<Vec<Extern>, LinkError> {
         let mut ret = vec![];
         for import in module.imports() {

lib/api/src/sys/instance.rs

@@ -111,6 +111,7 @@ impl Instance {
     /// Those are, as defined by the spec:
     ///  * Link errors that happen when plugging the imports into the instance
     ///  * Runtime errors that happen when running the module `start` function.
+    #[allow(clippy::result_large_err)]
     pub fn new(
         store: &mut impl AsStoreMut,
         module: &Module,
@@ -158,6 +159,7 @@ impl Instance {
     /// Those are, as defined by the spec:
     ///  * Link errors that happen when plugging the imports into the instance
     ///  * Runtime errors that happen when running the module `start` function.
+    #[allow(clippy::result_large_err)]
     pub fn new_by_index(
         store: &mut impl AsStoreMut,
         module: &Module,

lib/api/src/sys/module.rs

@@ -311,6 +311,7 @@ impl Module {
         }
     }
 
+    #[allow(clippy::result_large_err)]
     #[cfg(feature = "compiler")]
     pub(crate) fn instantiate(
         &self,

lib/api/src/sys/store.rs

@@ -174,20 +174,19 @@ impl Default for Store {
         fn get_engine() -> Engine {
             cfg_if::cfg_if! {
                 if #[cfg(feature = "compiler")] {
-
-            cfg_if::cfg_if! {
-                    if #[cfg(any(feature = "cranelift", feature = "llvm", feature = "singlepass"))]
-                    {
-                    let config = get_config();
-                    EngineBuilder::new(Box::new(config) as Box<dyn wasmer_compiler::CompilerConfig>)
-                        .engine()
-                    } else {
-                    EngineBuilder::headless()
-                        .engine()
+                    cfg_if::cfg_if! {
+                        if #[cfg(any(feature = "cranelift", feature = "llvm", feature = "singlepass"))]
+                        {
+                            let config = get_config();
+                            EngineBuilder::new(Box::new(config) as Box<dyn wasmer_compiler::CompilerConfig>)
+                                .engine()
+                        } else {
+                            EngineBuilder::headless()
+                                .engine()
+                        }
                     }
-            }
                 } else {
-                    compile_error!("No default engine chosen")
+                    compile_error!("No compiler [cranelift, llvm, singlepass] enabled, use Store::headless() instead of Store::default() for a headless engine")
                 }
             }
         }

lib/c-api/src/wasm_c_api/engine.rs

@@ -117,7 +117,7 @@ pub struct wasm_config_t {
 /// cbindgen:ignore
 #[no_mangle]
 pub extern "C" fn wasm_config_new() -> Box<wasm_config_t> {
-    Box::new(wasm_config_t::default())
+    Box::<wasm_config_t>::default()
 }
 
 /// Delete a Wasmer config object.
@@ -256,11 +256,11 @@ use wasmer_api::CompilerConfig;
 fn get_default_compiler_config() -> Box<dyn CompilerConfig> {
     cfg_if! {
         if #[cfg(feature = "cranelift")] {
-            Box::new(wasmer_compiler_cranelift::Cranelift::default())
+            Box::<wasmer_compiler_cranelift::Cranelift>::default()
         } else if #[cfg(feature = "llvm")] {
-            Box::new(wasmer_compiler_llvm::LLVM::default())
+            Box::<wasmer_compiler_llvm::LLVM>::default()
         } else if #[cfg(feature = "singlepass")] {
-            Box::new(wasmer_compiler_singlepass::Singlepass::default())
+            Box::<wasmer_compiler_singlepass::Singlepass>::default()
         } else {
             compile_error!("Please enable one of the compiler backends")
         }
@@ -368,7 +368,7 @@ pub extern "C" fn wasm_engine_new_with_config(
                 wasmer_compiler_t::CRANELIFT => {
                     cfg_if! {
                         if #[cfg(feature = "cranelift")] {
-                            Box::new(wasmer_compiler_cranelift::Cranelift::default())
+                            Box::<wasmer_compiler_cranelift::Cranelift>::default()
                         } else {
                             return return_with_error("Wasmer has not been compiled with the `cranelift` feature.");
                         }

lib/c-api/src/wasm_c_api/wasi/mod.rs

@@ -342,7 +342,7 @@ pub unsafe extern "C" fn wasi_env_read_stdout(
     buffer: *mut c_char,
     buffer_len: usize,
 ) -> isize {
-    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len as usize);
+    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len);
     let mut store_mut = env.store.store_mut();
     let state = env.inner.data_mut(&mut store_mut).state();
 
@@ -365,7 +365,7 @@ pub unsafe extern "C" fn wasi_env_read_stderr(
     buffer: *mut c_char,
     buffer_len: usize,
 ) -> isize {
-    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len as usize);
+    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len);
     let mut store_mut = env.store.store_mut();
     let state = env.inner.data_mut(&mut store_mut).state();
     if let Ok(mut stderr) = state.stderr() {

lib/cache/src/hash.rs

@@ -31,7 +31,7 @@ impl ToString for Hash {
     /// Create the hexadecimal representation of the
     /// stored hash.
     fn to_string(&self) -> String {
-        hex::encode(&self.to_array())
+        hex::encode(self.to_array())
     }
 }
 

lib/cli/Cargo.toml

@@ -149,14 +149,17 @@ experimental-io-devices = [
 ]
 singlepass = [
     "wasmer-compiler-singlepass",
+    "wasmer/singlepass",
     "compiler",
 ]
 cranelift = [
     "wasmer-compiler-cranelift",
+    "wasmer/cranelift",
     "compiler",
 ]
 llvm = [
     "wasmer-compiler-llvm",
+    "wasmer/llvm",
     "compiler",
 ]
 debug = ["fern", "wasmer-wasi/logging"]

lib/cli/build.rs

@@ -4,7 +4,7 @@ use std::process::Command;
 pub fn main() {
     // Set WASMER_GIT_HASH
     let git_hash = Command::new("git")
-        .args(&["rev-parse", "HEAD"])
+        .args(["rev-parse", "HEAD"])
         .output()
         .ok()
         .and_then(|output| String::from_utf8(output.stdout).ok())

lib/cli/src/cli.rs

@@ -6,14 +6,13 @@ use crate::commands::Binfmt;
 use crate::commands::Compile;
 #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
 use crate::commands::CreateExe;
-#[cfg(feature = "static-artifact-create")]
-use crate::commands::CreateObj;
 #[cfg(feature = "wast")]
 use crate::commands::Wast;
 use crate::commands::{
-    Add, Cache, Config, GenCHeader, Init, Inspect, List, Login, Publish, Run, SelfUpdate, Validate,
-    Whoami,
+    Add, Cache, Config, Init, Inspect, List, Login, Publish, Run, SelfUpdate, Validate, Whoami,
 };
+#[cfg(feature = "static-artifact-create")]
+use crate::commands::{CreateObj, GenCHeader};
 use crate::error::PrettyError;
 use clap::{CommandFactory, ErrorKind, Parser};
 
@@ -130,6 +129,7 @@ enum WasmerCLIOptions {
     CreateObj(CreateObj),
 
     /// Generate the C static_defs.h header file for the input .wasm module
+    #[cfg(feature = "static-artifact-create")]
     GenCHeader(GenCHeader),
 
     /// Get various configuration information needed
@@ -181,6 +181,7 @@ impl WasmerCLIOptions {
             Self::List(list) => list.execute(),
             Self::Login(login) => login.execute(),
             Self::Publish(publish) => publish.execute(),
+            #[cfg(feature = "static-artifact-create")]
             Self::GenCHeader(gen_heder) => gen_heder.execute(),
             #[cfg(feature = "wast")]
             Self::Wast(wast) => wast.execute(),

lib/cli/src/commands.rs

@@ -10,6 +10,7 @@ mod config;
 mod create_exe;
 #[cfg(feature = "static-artifact-create")]
 mod create_obj;
+#[cfg(feature = "static-artifact-create")]
 mod gen_c_header;
 mod init;
 mod inspect;
@@ -29,19 +30,18 @@ pub use binfmt::*;
 pub use compile::*;
 #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
 pub use create_exe::*;
-#[cfg(feature = "static-artifact-create")]
-pub use create_obj::*;
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "wast")]
 pub use wast::*;
 pub use {
-    add::*, cache::*, config::*, gen_c_header::*, init::*, inspect::*, list::*, login::*,
-    publish::*, run::*, self_update::*, validate::*, whoami::*,
+    add::*, cache::*, config::*, init::*, inspect::*, list::*, login::*, publish::*, run::*,
+    self_update::*, validate::*, whoami::*,
 };
+#[cfg(feature = "static-artifact-create")]
+pub use {create_obj::*, gen_c_header::*};
 
 /// The kind of object format to emit.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, clap::Parser, Serialize, Deserialize)]
-#[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
 pub enum ObjectFormat {
     /// Serialize the entire module into an object file.
     Serialized,

lib/cli/src/commands/create_exe.rs

@@ -1,6 +1,7 @@
 //! Create a standalone native executable for a given Wasm file.
 
 use super::ObjectFormat;
+use crate::common::normalize_path;
 use crate::store::CompilerOptions;
 use anyhow::{Context, Result};
 use clap::Parser;
@@ -866,7 +867,7 @@ fn write_volume_obj(
         object_name,
     )?;
 
-    let mut writer = BufWriter::new(File::create(&output_path)?);
+    let mut writer = BufWriter::new(File::create(output_path)?);
     volumes_object
         .write_stream(&mut writer)
         .map_err(|err| anyhow::anyhow!(err.to_string()))?;
@@ -1049,7 +1050,7 @@ pub(crate) fn create_header_files_in_dir(
             &ModuleMetadataSymbolRegistry {
                 prefix: prefix.clone(),
             },
-            metadata_length as usize,
+            metadata_length,
         );
 
         std::fs::write(&header_file_path, &header_file_src).map_err(|e| {
@@ -1194,7 +1195,7 @@ fn link_exe_from_dir(
         .as_ref()
         .ok_or_else(|| anyhow::anyhow!("could not find zig in $PATH {}", directory.display()))?;
 
-    let mut cmd = Command::new(&zig_binary_path);
+    let mut cmd = Command::new(zig_binary_path);
     cmd.arg("build-exe");
     cmd.arg("--verbose-cc");
     cmd.arg("--verbose-link");
@@ -1319,10 +1320,6 @@ fn link_exe_from_dir(
     Ok(())
 }
 
-pub(crate) fn normalize_path(s: &str) -> String {
-    s.strip_prefix(r"\\?\").unwrap_or(s).to_string()
-}
-
 /// Link compiled objects using the system linker
 #[allow(clippy::too_many_arguments)]
 fn link_objects_system_linker(
@@ -1875,7 +1872,7 @@ pub(super) mod utils {
         let path_var = std::env::var("PATH").unwrap_or_default();
         #[cfg(unix)]
         let system_path_var = std::process::Command::new("getconf")
-            .args(&["PATH"])
+            .args(["PATH"])
             .output()
             .map(|output| output.stdout)
             .unwrap_or_default();
@@ -2268,7 +2265,7 @@ mod http_fetch {
 
     pub(crate) fn list_dir(target: &Path) -> Vec<PathBuf> {
         use walkdir::WalkDir;
-        WalkDir::new(&target)
+        WalkDir::new(target)
             .into_iter()
             .filter_map(|e| e.ok())
             .map(|entry| entry.path().to_path_buf())

lib/cli/src/commands/create_obj.rs

@@ -11,9 +11,6 @@ use std::path::PathBuf;
 
 use wasmer::*;
 
-#[cfg(feature = "webc_runner")]
-use webc::{ParseOptions, WebCMmap};
-
 #[derive(Debug, Parser)]
 /// The options for the `wasmer create-exe` subcommand
 pub struct CreateObj {
@@ -73,7 +70,7 @@ pub struct CreateObj {
 impl CreateObj {
     /// Runs logic for the `create-obj` subcommand
     pub fn execute(&self) -> Result<()> {
-        let path = crate::commands::create_exe::normalize_path(&format!("{}", self.path.display()));
+        let path = crate::common::normalize_path(&format!("{}", self.path.display()));
         let target_triple = self.target_triple.clone().unwrap_or_else(Triple::host);
         let starting_cd = env::current_dir()?;
         let input_path = starting_cd.join(&path);
@@ -98,31 +95,32 @@ impl CreateObj {
         println!("Target: {}", target.triple());
         println!("Format: {:?}", object_format);
 
-        let atoms =
-            if let Ok(pirita) = WebCMmap::parse(input_path.clone(), &ParseOptions::default()) {
-                crate::commands::create_exe::compile_pirita_into_directory(
-                    &pirita,
-                    &output_directory_path,
-                    &self.compiler,
-                    &self.cpu_features,
-                    &target_triple,
-                    object_format,
-                    &prefix,
-                    crate::commands::AllowMultiWasm::Reject(self.atom.clone()),
-                    self.debug_dir.is_some(),
-                )
-            } else {
-                crate::commands::create_exe::prepare_directory_from_single_wasm_file(
-                    &input_path,
-                    &output_directory_path,
-                    &self.compiler,
-                    &target_triple,
-                    &self.cpu_features,
-                    object_format,
-                    &prefix,
-                    self.debug_dir.is_some(),
-                )
-            }?;
+        let atoms = if let Ok(pirita) =
+            webc::WebCMmap::parse(input_path.clone(), &webc::ParseOptions::default())
+        {
+            crate::commands::create_exe::compile_pirita_into_directory(
+                &pirita,
+                &output_directory_path,
+                &self.compiler,
+                &self.cpu_features,
+                &target_triple,
+                object_format,
+                &prefix,
+                crate::commands::AllowMultiWasm::Reject(self.atom.clone()),
+                self.debug_dir.is_some(),
+            )
+        } else {
+            crate::commands::create_exe::prepare_directory_from_single_wasm_file(
+                &input_path,
+                &output_directory_path,
+                &self.compiler,
+                &target_triple,
+                &self.cpu_features,
+                object_format,
+                &prefix,
+                self.debug_dir.is_some(),
+            )
+        }?;
 
         // Copy output files into target path, depending on whether
         // there are one or many files being compiled

lib/cli/src/commands/gen_c_header.rs

@@ -7,8 +7,6 @@ use wasmer_types::compilation::symbols::ModuleMetadataSymbolRegistry;
 use wasmer_types::{CpuFeature, MetadataHeader, Triple};
 use webc::WebC;
 
-use super::normalize_path;
-
 #[derive(Debug, Parser)]
 /// The options for the `wasmer gen-c-header` subcommand
 pub struct GenCHeader {
@@ -50,7 +48,7 @@ pub struct GenCHeader {
 impl GenCHeader {
     /// Runs logic for the `gen-c-header` subcommand
     pub fn execute(&self) -> Result<(), anyhow::Error> {
-        let path = crate::commands::normalize_path(&format!("{}", self.path.display()));
+        let path = crate::common::normalize_path(&format!("{}", self.path.display()));
         let mut file = std::fs::read(&path)
             .map_err(|e| anyhow::anyhow!("{e}"))
             .with_context(|| anyhow::anyhow!("{path}"))?;
@@ -126,7 +124,7 @@ impl GenCHeader {
             metadata_length,
         );
 
-        let output = normalize_path(&self.output.display().to_string());
+        let output = crate::common::normalize_path(&self.output.display().to_string());
 
         std::fs::write(&output, &header_file_src)
             .map_err(|e| anyhow::anyhow!("{e}"))