Improve no_std imports for the entire workspace (#944)

* improve no_std import structure in the workspace

* re-export alloc as std in no_std mode

* fix new clippy warnings for tests

crates/arena/src/component_vec.rs

@@ -1,10 +1,10 @@
 use crate::ArenaIndex;
-use alloc::vec::Vec;
 use core::{
     fmt::{self, Debug},
     marker::PhantomData,
     ops::{Index, IndexMut},
 };
+use std::vec::Vec;
 
 /// Stores components for entities backed by a [`Vec`].
 pub struct ComponentVec<Idx, T> {
@@ -153,6 +153,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::{format, string::String};
 
     /// Add `n` components and perform checks along the way.
     fn add_components(vec: &mut ComponentVec<usize, String>, n: usize) {

crates/arena/src/dedup.rs

@@ -1,6 +1,6 @@
 use super::{Arena, ArenaIndex, Iter, IterMut};
-use alloc::collections::BTreeMap;
 use core::ops::{Index, IndexMut};
+use std::collections::BTreeMap;
 
 /// A deduplicating arena allocator with a given index and entity type.
 ///

crates/arena/src/lib.rs

@@ -4,7 +4,7 @@
 //! These allocators mainly serve as the backbone for an efficient Wasm store
 //! implementation.
 
-#![cfg_attr(not(feature = "std"), no_std)]
+#![no_std]
 #![warn(
     clippy::cast_lossless,
     clippy::missing_errors_doc,
@@ -16,10 +16,12 @@
     clippy::map_unwrap_or,
     clippy::items_after_statements
 )]
+
 #[cfg(not(feature = "std"))]
-extern crate alloc;
+extern crate alloc as std;
+
 #[cfg(feature = "std")]
-extern crate std as alloc;
+extern crate std;
 
 mod component_vec;
 mod dedup;
@@ -29,13 +31,13 @@ mod guarded;
 mod tests;
 
 pub use self::{component_vec::ComponentVec, dedup::DedupArena, guarded::GuardedEntity};
-use alloc::vec::Vec;
 use core::{
-    iter::{DoubleEndedIterator, Enumerate, ExactSizeIterator},
+    iter::Enumerate,
     marker::PhantomData,
     ops::{Index, IndexMut},
     slice,
 };
+use std::vec::Vec;
 
 /// Types that can be used as indices for arenas.
 pub trait ArenaIndex: Copy {

crates/core/src/lib.rs

@@ -1,4 +1,4 @@
-#![cfg_attr(not(feature = "std"), no_std)]
+#![no_std]
 #![warn(
     clippy::cast_lossless,
     clippy::missing_errors_doc,
@@ -19,10 +19,10 @@ mod untyped;
 mod value;
 
 #[cfg(not(feature = "std"))]
-extern crate alloc;
+extern crate alloc as std;
 
 #[cfg(feature = "std")]
-extern crate std as alloc;
+extern crate std;
 
 use self::value::{
     ArithmeticOps,

crates/core/src/trap.rs

@@ -1,6 +1,6 @@
 use crate::HostError;
-use alloc::{boxed::Box, string::String};
 use core::fmt::{self, Display};
+use std::{boxed::Box, string::String};
 
 #[cfg(feature = "std")]
 use std::error::Error as StdError;

crates/wasmi/src/engine/bytecode/provider.rs

@@ -1,6 +1,6 @@
 use super::{AnyConst32, Register};
 use crate::{engine::translator::TranslationError, Error};
-use alloc::vec::{Drain, Vec};
+use std::vec::{Drain, Vec};
 use wasmi_core::UntypedValue;
 
 #[cfg(doc)]

crates/wasmi/src/engine/code_map.rs

@@ -13,7 +13,6 @@ use crate::{
     store::{Fuel, FuelError},
     Error,
 };
-use alloc::boxed::Box;
 use core::{
     cell::UnsafeCell,
     fmt,
@@ -23,6 +22,7 @@ use core::{
     slice,
     sync::atomic::{AtomicU8, Ordering},
 };
+use std::boxed::Box;
 use wasmi_arena::{Arena, ArenaIndex};
 use wasmi_core::TrapCode;
 use wasmparser::{FuncToValidate, ValidatorResources};

crates/wasmi/src/engine/executor/stack/calls.rs

@@ -3,7 +3,7 @@ use crate::{
     engine::{bytecode::RegisterSpan, code_map::InstructionPtr},
     Instance,
 };
-use alloc::vec::Vec;
+use std::vec::Vec;
 use wasmi_core::TrapCode;
 
 #[cfg(doc)]

crates/wasmi/src/engine/executor/stack/values.rs

@@ -3,8 +3,8 @@ use crate::{
     core::UntypedValue,
     engine::{bytecode::Register, CompiledFuncEntity},
 };
-use alloc::vec::Vec;
 use core::{fmt, fmt::Debug, iter, mem, ptr};
+use std::{vec, vec::Vec};
 use wasmi_core::TrapCode;
 
 #[cfg(doc)]

crates/wasmi/src/engine/mod.rs

@@ -54,12 +54,12 @@ use crate::{
     FuncType,
     StoreContextMut,
 };
-use alloc::{
+use core::sync::atomic::{AtomicU32, Ordering};
+use spin::{Mutex, RwLock};
+use std::{
     sync::{Arc, Weak},
     vec::Vec,
 };
-use core::sync::atomic::{AtomicU32, Ordering};
-use spin::{Mutex, RwLock};
 use wasmi_arena::{ArenaIndex, GuardedEntity};
 use wasmparser::{FuncToValidate, FuncValidatorAllocations, ValidatorResources};
 

crates/wasmi/src/engine/translator/control_stack.rs

@@ -3,7 +3,7 @@ use crate::{
     engine::bytecode::{Provider, ProviderSliceStack},
     Error,
 };
-use alloc::vec::{Drain, Vec};
+use std::vec::{Drain, Vec};
 
 /// An acquired branch target.
 #[derive(Debug)]

crates/wasmi/src/engine/translator/instr_encoder.rs

@@ -28,8 +28,8 @@ use crate::{
     module::ModuleHeader,
     Error,
 };
-use alloc::vec::{Drain, Vec};
 use core::mem;
+use std::vec::{Drain, Vec};
 use wasmi_core::{UntypedValue, ValueType, F32};
 
 /// A reference to an instruction of the partially
@@ -1404,7 +1404,7 @@ impl Instruction {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::engine::{bytecode::RegisterSpan, translator::typed_value::TypedValue};
+    use crate::engine::translator::typed_value::TypedValue;
 
     #[test]
     fn has_overlapping_copies_works() {

crates/wasmi/src/engine/translator/labels.rs

@@ -1,10 +1,10 @@
 use super::Instr;
 use crate::{engine::bytecode::BranchOffset, Error};
-use alloc::vec::Vec;
 use core::{
     fmt::{self, Display},
     slice::Iter as SliceIter,
 };
+use std::vec::Vec;
 
 /// A label during the Wasmi compilation process.
 #[derive(Debug, Copy, Clone)]

crates/wasmi/src/engine/translator/mod.rs

@@ -61,8 +61,8 @@ use crate::{
     Error,
     FuncType,
 };
-use alloc::vec::Vec;
 use core::fmt;
+use std::vec::Vec;
 use wasmi_core::{TrapCode, UntypedValue, ValueType};
 use wasmparser::{
     BinaryReaderError,

crates/wasmi/src/engine/translator/stack/consts.rs

@@ -1,10 +1,10 @@
 use super::Register;
 use crate::{core::UntypedValue, engine::TranslationError, Error};
-use alloc::{
+use core::{iter::Rev, slice::Iter as SliceIter};
+use std::{
     collections::{btree_map, BTreeMap},
     vec::Vec,
 };
-use core::{iter::Rev, slice::Iter as SliceIter};
 
 /// A pool of deduplicated function local constant values.
 ///

crates/wasmi/src/engine/translator/stack/mod.rs

@@ -16,7 +16,7 @@ use crate::{
     Error,
     FuncType,
 };
-use alloc::vec::Vec;
+use std::vec::Vec;
 use wasmi_core::UntypedValue;
 
 /// Typed inputs to Wasmi bytecode instructions.

crates/wasmi/src/engine/translator/stack/provider.rs

@@ -2,8 +2,8 @@ use ::core::iter;
 
 use super::{RegisterAlloc, TypedValue};
 use crate::{engine::bytecode::Register, Error};
-use alloc::vec::Vec;
 use smallvec::SmallVec;
+use std::vec::Vec;
 
 #[cfg(doc)]
 use wasmi_core::UntypedValue;

crates/wasmi/src/engine/translator/stack/register_alloc.rs

@@ -6,12 +6,12 @@ use crate::{
     },
     Error,
 };
-use alloc::collections::BTreeSet;
 use core::{
     cmp::{max, min},
     num::NonZeroUsize,
 };
 use multi_stash::{Key, Key as StashKey, MultiStash};
+use std::collections::BTreeSet;
 
 #[cfg(doc)]
 use crate::engine::translator::InstrEncoder;

crates/wasmi/src/engine/translator/tests/driver.rs

@@ -6,7 +6,7 @@ use crate::{
     Module,
 };
 use core::sync::atomic::Ordering;
-use std::sync::atomic::AtomicBool;
+use std::{boxed::Box, sync::atomic::AtomicBool, vec::Vec};
 use wasmi_core::UntypedValue;
 
 /// A test driver for translation tests.

crates/wasmi/src/engine/translator/tests/mod.rs

@@ -17,7 +17,7 @@ use crate::{
     Engine,
     Module,
 };
-use std::fmt::Display;
+use std::{fmt::Display, format, vec::Vec};
 
 /// Converts the `wat` string source into `wasm` encoded byte.
 fn wat2wasm(wat: &str) -> Vec<u8> {

crates/wasmi/src/engine/translator/tests/op/binary/i64_rem_u.rs

@@ -1,5 +1,4 @@
 use super::*;
-use core::num::NonZeroU64;
 use wasmi_core::TrapCode;
 
 const WASM_OP: WasmOp = WasmOp::binary(WasmType::I64, "rem_u");

crates/wasmi/src/engine/translator/tests/op/block.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::engine::{
     bytecode::{BranchOffset, BranchOffset16, RegisterSpan},
-    translator::tests::{display_wasm::DisplayValueType, wasm_type::WasmType},
+    translator::tests::wasm_type::WasmType,
 };
 use std::fmt::Display;
 

crates/wasmi/src/engine/translator/tests/op/br.rs

@@ -1,14 +1,7 @@
 use super::*;
 use crate::{
     core::UntypedValue,
-    engine::{
-        bytecode::BranchOffset,
-        translator::tests::{
-            display_wasm::DisplayValueType,
-            driver::ExpectedFunc,
-            wasm_type::WasmType,
-        },
-    },
+    engine::{bytecode::BranchOffset, translator::tests::wasm_type::WasmType},
 };
 use core::fmt::Display;
 

crates/wasmi/src/engine/translator/tests/op/br_if.rs

@@ -1,13 +1,10 @@
 use super::*;
 use crate::engine::{
     bytecode::{BranchOffset, BranchOffset16, RegisterSpan},
-    translator::tests::{
-        display_wasm::DisplayValueType,
-        driver::ExpectedFunc,
-        wasm_type::WasmType,
-    },
+    translator::tests::wasm_type::WasmType,
 };
 use core::fmt::Display;
+use std::vec::Vec;
 use wasmi_core::UntypedValue;
 
 #[test]

crates/wasmi/src/engine/translator/tests/op/cmp_br.rs

@@ -1,10 +1,7 @@
 use super::{wasm_type::WasmType, *};
 use crate::{
     core::ValueType,
-    engine::{
-        bytecode::{BranchOffset, BranchOffset16, GlobalIdx},
-        translator::tests::display_wasm::DisplayValueType,
-    },
+    engine::bytecode::{BranchOffset, BranchOffset16, GlobalIdx},
 };
 use std::fmt::{Debug, Display};
 

crates/wasmi/src/engine/translator/tests/op/global_set.rs

@@ -1,9 +1,6 @@
 use super::*;
 
-use crate::engine::{
-    bytecode::GlobalIdx,
-    translator::tests::{display_wasm::DisplayValueType, driver::ExpectedFunc},
-};
+use crate::engine::bytecode::GlobalIdx;
 use core::fmt::Display;
 use wasm_type::WasmType;
 use wasmi_core::ValueType;

crates/wasmi/src/engine/translator/tests/op/mod.rs

@@ -50,6 +50,7 @@ use super::{
     WasmOp,
     WasmType,
 };
+use std::format;
 
 /// Creates an [`Const32<i32>`] from the given `i32` value.
 ///

crates/wasmi/src/engine/translator/tests/op/return_.rs

@@ -1,12 +1,5 @@
 use super::*;
-use crate::engine::{
-    bytecode::RegisterSpan,
-    translator::tests::{
-        display_wasm::DisplayValueType,
-        driver::ExpectedFunc,
-        wasm_type::WasmType,
-    },
-};
+use crate::engine::{bytecode::RegisterSpan, translator::tests::wasm_type::WasmType};
 use core::fmt::Display;
 
 #[test]

crates/wasmi/src/engine/translator/tests/op/select.rs

@@ -1,12 +1,5 @@
 use super::*;
-use crate::{
-    core::ValueType,
-    engine::translator::tests::{
-        display_wasm::DisplayValueType,
-        driver::ExpectedFunc,
-        wasm_type::WasmType,
-    },
-};
+use crate::{core::ValueType, engine::translator::tests::wasm_type::WasmType};
 use core::{fmt, fmt::Display};
 
 /// Tells which kind of `select` instruction to test.

crates/wasmi/src/engine/translator/tests/op/unary/mod.rs

@@ -4,8 +4,7 @@ mod conversion;
 mod op;
 
 use super::*;
-use crate::engine::translator::tests::driver::{ExpectedFunc, TranslationTest};
-use std::fmt::Display;
+use std::{fmt::Display, vec::Vec};
 use wasm_type::WasmType;
 use wasmi_core::{TrapCode, UntypedValue};
 

crates/wasmi/src/engine/translator/tests/op/unary/op.rs

@@ -194,7 +194,6 @@ mod f32_trunc {
 
 mod f32_nearest {
     use super::*;
-    use wasmi_core::UntypedValue;
 
     const OP_NAME: &str = "nearest";
 
@@ -343,7 +342,6 @@ mod f64_trunc {
 
 mod f64_nearest {
     use super::*;
-    use wasmi_core::UntypedValue;
 
     const OP_NAME: &str = "nearest";