Migrate back to std:: stylistically (#554)

* Migrate back to `std::` stylistically

This commit moves away from idioms such as `alloc::` and `core::` as
imports of standard data structures and types. Instead it migrates all
crates to uniformly use `std::` for importing standard data structures
and types. This also removes the `std` and `core` features from all
crates to and removes any conditional checking for `feature = "std"`

All of this support was previously added in #407 in an effort to make
wasmtime/cranelift "`no_std` compatible". Unfortunately though this
change comes at a cost:

* The usage of `alloc` and `core` isn't idiomatic. Especially trying to
  dual between types like `HashMap` from `std` as well as from
  `hashbrown` causes imports to be surprising in some cases.
* Unfortunately there was no CI check that crates were `no_std`, so none
  of them actually were. Many crates still imported from `std` or
  depended on crates that used `std`.

It's important to note, however, that **this does not mean that wasmtime
will not run in embedded environments**. The style of the code today and
idioms aren't ready in Rust to support this degree of multiplexing and
makes it somewhat difficult to keep up with the style of `wasmtime`.
Instead it's intended that embedded runtime support will be added as
necessary. Currently only `std` is necessary to build `wasmtime`, and
platforms that natively need to execute `wasmtime` will need to use a
Rust target that supports `std`. Note though that not all of `std` needs
to be supported, but instead much of it could be configured off to
return errors, and `wasmtime` would be configured to gracefully handle
errors.

The goal of this PR is to move `wasmtime` back to idiomatic usage of
features/`std`/imports/etc and help development in the short-term.
Long-term when platform concerns arise (if any) they can be addressed by
moving back to `no_std` crates (but fixing the issues mentioned above)
or ensuring that the target in Rust has `std` available.

* Start filling out platform support doc

crates/api/src/callable.rs

@@ -4,8 +4,8 @@ use crate::trampoline::generate_func_export;
 use crate::trap::Trap;
 use crate::types::FuncType;
 use crate::values::Val;
-use alloc::{rc::Rc, vec::Vec};
 use cranelift_codegen::ir;
+use std::rc::Rc;
 use wasmtime_jit::InstanceHandle;
 use wasmtime_runtime::Export;
 
@@ -43,8 +43,8 @@ impl WasmtimeFn {
 
 impl WrappedCallable for WasmtimeFn {
     fn call(&self, params: &[Val], results: &mut [Val]) -> Result<(), HostRef<Trap>> {
-        use core::cmp::max;
-        use core::{mem, ptr};
+        use std::cmp::max;
+        use std::{mem, ptr};
 
         let (vmctx, body, signature) = match self.wasmtime_export() {
             Export::Function {

crates/api/src/context.rs

@@ -1,7 +1,7 @@
 use crate::Config;
-use alloc::rc::Rc;
-use core::cell::{RefCell, RefMut};
-use core::hash::{Hash, Hasher};
+use std::cell::{RefCell, RefMut};
+use std::hash::{Hash, Hasher};
+use std::rc::Rc;
 use wasmtime_jit::{Compiler, Features};
 
 #[derive(Clone)]

crates/api/src/externals.rs

@@ -5,10 +5,9 @@ use crate::trampoline::{generate_global_export, generate_memory_export, generate
 use crate::trap::Trap;
 use crate::types::{ExternType, FuncType, GlobalType, MemoryType, TableType, ValType};
 use crate::values::{from_checked_anyfunc, into_checked_anyfunc, Val};
-use alloc::boxed::Box;
-use alloc::rc::Rc;
-use core::result::Result;
-use core::slice;
+use std::fmt;
+use std::rc::Rc;
+use std::slice;
 use wasmtime_runtime::InstanceHandle;
 
 // Externals
@@ -172,8 +171,8 @@ impl Func {
     }
 }
 
-impl core::fmt::Debug for Func {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+impl fmt::Debug for Func {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Func")
     }
 }

crates/api/src/instance.rs

@@ -4,11 +4,10 @@ use crate::module::Module;
 use crate::r#ref::HostRef;
 use crate::runtime::Store;
 use crate::types::{ExportType, ExternType, Name};
-use crate::{HashMap, HashSet};
-use alloc::string::{String, ToString};
-use alloc::{boxed::Box, rc::Rc, vec::Vec};
 use anyhow::Result;
-use core::cell::RefCell;
+use std::cell::RefCell;
+use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
 use wasmtime_jit::{instantiate, Resolver};
 use wasmtime_runtime::{Export, InstanceHandle};
 

crates/api/src/lib.rs

@@ -1,7 +1,6 @@
 //! Wasmtime embed API. Based on wasm-c-api.
 
 #![allow(improper_ctypes)]
-#![cfg_attr(not(feature = "std"), no_std)]
 
 mod callable;
 mod context;
@@ -17,8 +16,6 @@ mod values;
 
 pub mod wasm;
 
-extern crate alloc;
-
 pub use crate::callable::Callable;
 pub use crate::externals::*;
 pub use crate::instance::Instance;
@@ -28,8 +25,3 @@ pub use crate::runtime::{Config, Engine, Store};
 pub use crate::trap::Trap;
 pub use crate::types::*;
 pub use crate::values::*;
-
-#[cfg(not(feature = "std"))]
-use hashbrown::{hash_map, HashMap, HashSet};
-#[cfg(feature = "std")]
-use std::collections::{hash_map, HashMap, HashSet};

crates/api/src/module.rs

@@ -4,7 +4,6 @@ use crate::types::{
     ExportType, ExternType, FuncType, GlobalType, ImportType, Limits, MemoryType, Mutability,
     TableType, ValType,
 };
-use alloc::{boxed::Box, string::String, vec::Vec};
 use anyhow::Result;
 use wasmparser::{validate, ExternalKind, ImportSectionEntryType, ModuleReader, SectionCode};
 
@@ -12,7 +11,7 @@ fn into_memory_type(mt: wasmparser::MemoryType) -> MemoryType {
     assert!(!mt.shared);
     MemoryType::new(Limits::new(
         mt.limits.initial,
-        mt.limits.maximum.unwrap_or(::core::u32::MAX),
+        mt.limits.maximum.unwrap_or(std::u32::MAX),
     ))
 }
 
@@ -53,7 +52,7 @@ fn into_table_type(tt: wasmparser::TableType) -> TableType {
     let ty = into_valtype(&tt.element_type);
     let limits = Limits::new(
         tt.limits.initial,
-        tt.limits.maximum.unwrap_or(::core::u32::MAX),
+        tt.limits.maximum.unwrap_or(std::u32::MAX),
     );
     TableType::new(ty, limits)
 }

crates/api/src/ref.rs

@@ -1,8 +1,7 @@
-use alloc::boxed::Box;
-use alloc::rc::{Rc, Weak};
-use core::any::Any;
-use core::cell::{self, RefCell};
-use core::fmt;
+use std::any::Any;
+use std::cell::{self, RefCell};
+use std::fmt;
+use std::rc::{Rc, Weak};
 
 pub trait HostInfo {
     fn finalize(&mut self) {}

crates/api/src/runtime.rs

@@ -1,9 +1,9 @@
 use crate::context::Context;
 use crate::r#ref::HostRef;
-use crate::HashMap;
-use alloc::{rc::Rc, string::String};
-use core::cell::RefCell;
 use cranelift_codegen::{ir, settings};
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
 use wasmtime_jit::{CompilationStrategy, Features};
 
 // Runtime Environment
@@ -143,7 +143,7 @@ impl Store {
         &mut self,
         signature: &ir::Signature,
     ) -> wasmtime_runtime::VMSharedSignatureIndex {
-        use crate::hash_map::Entry;
+        use std::collections::hash_map::Entry;
         let index = self.context().compiler().signatures().register(signature);
         match self.signature_cache.entry(index) {
             Entry::Vacant(v) => {

crates/api/src/trampoline/create_handle.rs

@@ -1,16 +1,13 @@
 //! Support for a calling of an imported function.
 
 use crate::runtime::Store;
-use crate::{HashMap, HashSet};
-use alloc::boxed::Box;
-use alloc::rc::Rc;
-use alloc::string::String;
-use alloc::vec::Vec;
 use anyhow::Result;
-use core::any::Any;
-use core::cell::{RefCell, RefMut};
 use cranelift_entity::PrimaryMap;
 use cranelift_wasm::DefinedFuncIndex;
+use std::any::Any;
+use std::cell::{RefCell, RefMut};
+use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
 use wasmtime_environ::Module;
 use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody};
 

crates/api/src/trampoline/func.rs

@@ -3,15 +3,15 @@
 use super::create_handle::create_handle;
 use crate::r#ref::HostRef;
 use crate::{Callable, FuncType, Store, Trap, Val};
-use alloc::{boxed::Box, rc::Rc, string::ToString, vec::Vec};
 use anyhow::Result;
-use core::cmp;
 use cranelift_codegen::ir::{types, InstBuilder, StackSlotData, StackSlotKind, TrapCode};
 use cranelift_codegen::print_errors::pretty_error;
 use cranelift_codegen::{binemit, ir, isa, Context};
 use cranelift_entity::{EntityRef, PrimaryMap};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use cranelift_wasm::{DefinedFuncIndex, FuncIndex};
+use std::cmp;
+use std::rc::Rc;
 use wasmtime_environ::{CompiledFunction, Export, Module};
 use wasmtime_jit::CodeMemory;
 use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};

crates/api/src/trampoline/global.rs

@@ -1,6 +1,5 @@
 use super::create_handle::create_handle;
 use crate::{GlobalType, Mutability, Val};
-use alloc::boxed::Box;
 use anyhow::Result;
 use cranelift_entity::PrimaryMap;
 use wasmtime_environ::Module;

crates/api/src/trampoline/memory.rs

@@ -1,7 +1,5 @@
 use super::create_handle::create_handle;
 use crate::MemoryType;
-use alloc::boxed::Box;
-use alloc::string::ToString;
 use anyhow::Result;
 use cranelift_entity::PrimaryMap;
 use wasmtime_environ::Module;
@@ -14,7 +12,7 @@ pub fn create_handle_with_memory(memory: &MemoryType) -> Result<InstanceHandle>
 
     let memory = cranelift_wasm::Memory {
         minimum: memory.limits().min(),
-        maximum: if memory.limits().max() == core::u32::MAX {
+        maximum: if memory.limits().max() == std::u32::MAX {
             None
         } else {
             Some(memory.limits().max())

crates/api/src/trampoline/mod.rs

@@ -12,8 +12,8 @@ use self::memory::create_handle_with_memory;
 use self::table::create_handle_with_table;
 use super::{Callable, FuncType, GlobalType, MemoryType, Store, TableType, Val};
 use crate::r#ref::HostRef;
-use alloc::rc::Rc;
 use anyhow::Result;
+use std::rc::Rc;
 
 pub use self::global::GlobalState;
 

crates/api/src/trampoline/table.rs

@@ -1,7 +1,5 @@
 use super::create_handle::create_handle;
 use crate::{TableType, ValType};
-use alloc::boxed::Box;
-use alloc::string::ToString;
 use anyhow::Result;
 use cranelift_entity::PrimaryMap;
 use cranelift_wasm::TableElementType;
@@ -13,7 +11,7 @@ pub fn create_handle_with_table(table: &TableType) -> Result<InstanceHandle> {
 
     let table = cranelift_wasm::Table {
         minimum: table.limits().min(),
-        maximum: if table.limits().max() == core::u32::MAX {
+        maximum: if table.limits().max() == std::u32::MAX {
             None
         } else {
             Some(table.limits().max())

crates/api/src/trap.rs

@@ -1,4 +1,3 @@
-use alloc::string::{String, ToString};
 use thiserror::Error;
 
 #[derive(Error, Debug)]

crates/api/src/types.rs

@@ -1,7 +1,3 @@
-use alloc::borrow::ToOwned;
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
 use cranelift_codegen::ir;
 
 // Type Representations
@@ -28,7 +24,7 @@ impl Limits {
     pub fn at_least(min: u32) -> Limits {
         Limits {
             min,
-            max: ::core::u32::MAX,
+            max: ::std::u32::MAX,
         }
     }
 
@@ -277,7 +273,7 @@ impl TableType {
             false
         });
         let ty = ValType::FuncRef;
-        let limits = Limits::new(table.minimum, table.maximum.unwrap_or(::core::u32::MAX));
+        let limits = Limits::new(table.minimum, table.maximum.unwrap_or(::std::u32::MAX));
         TableType::new(ty, limits)
     }
 }
@@ -300,7 +296,7 @@ impl MemoryType {
     pub(crate) fn from_cranelift_memory(memory: &cranelift_wasm::Memory) -> MemoryType {
         MemoryType::new(Limits::new(
             memory.minimum,
-            memory.maximum.unwrap_or(::core::u32::MAX),
+            memory.maximum.unwrap_or(::std::u32::MAX),
         ))
     }
 }
@@ -326,7 +322,7 @@ impl From<String> for Name {
     }
 }
 
-impl ::alloc::string::ToString for Name {
+impl ToString for Name {
     fn to_string(&self) -> String {
         self.0.to_owned()
     }

crates/api/src/values.rs

@@ -2,8 +2,8 @@ use crate::externals::Func;
 use crate::r#ref::{AnyRef, HostRef};
 use crate::runtime::Store;
 use crate::types::ValType;
-use core::ptr;
 use cranelift_codegen::ir;
+use std::ptr;
 use wasmtime_jit::RuntimeValue;
 
 #[derive(Debug, Clone)]

crates/api/src/wasm.rs

@@ -10,9 +10,8 @@ use super::{
     HostInfo, HostRef, ImportType, Instance, Limits, Memory, MemoryType, Module, Name, Store,
     Table, TableType, Trap, Val, ValType,
 };
-use alloc::boxed::Box;
-use alloc::rc::Rc;
-use core::{mem, ptr, slice};
+use std::rc::Rc;
+use std::{mem, ptr, slice};
 
 macro_rules! declare_vec {
     ($name:ident, $elem_ty:path) => {
@@ -343,12 +342,12 @@ pub struct wasm_func_t {
     func: HostRef<Func>,
     ext: Option<Box<wasm_extern_t>>,
 }
-pub type wasm_func_callback_t = ::core::option::Option<
+pub type wasm_func_callback_t = std::option::Option<
     unsafe extern "C" fn(args: *const wasm_val_t, results: *mut wasm_val_t) -> *mut wasm_trap_t,
 >;
-pub type wasm_func_callback_with_env_t = ::core::option::Option<
+pub type wasm_func_callback_with_env_t = std::option::Option<
     unsafe extern "C" fn(
-        env: *mut ::core::ffi::c_void,
+        env: *mut std::ffi::c_void,
         args: *const wasm_val_t,
         results: *mut wasm_val_t,
     ) -> *mut wasm_trap_t,
@@ -567,8 +566,8 @@ impl Into<HostRef<Trap>> for wasm_trap_t {
 
 struct CallbackWithEnv {
     callback: wasm_func_callback_with_env_t,
-    env: *mut ::core::ffi::c_void,
-    finalizer: ::core::option::Option<unsafe extern "C" fn(env: *mut ::core::ffi::c_void)>,
+    env: *mut std::ffi::c_void,
+    finalizer: std::option::Option<unsafe extern "C" fn(env: *mut std::ffi::c_void)>,
 }
 
 impl Callable for CallbackWithEnv {
@@ -799,8 +798,8 @@ pub unsafe extern "C" fn wasm_func_new_with_env(
     store: *mut wasm_store_t,
     ty: *const wasm_functype_t,
     callback: wasm_func_callback_with_env_t,
-    env: *mut ::core::ffi::c_void,
-    finalizer: ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>,
+    env: *mut std::ffi::c_void,
+    finalizer: std::option::Option<unsafe extern "C" fn(arg1: *mut std::ffi::c_void)>,
 ) -> *mut wasm_func_t {
     let store = &(*store).store;
     let ty = (*ty).functype.clone();
@@ -1614,8 +1613,8 @@ pub unsafe extern "C" fn wasm_tabletype_new(
 }
 
 struct HostInfoState {
-    info: *mut ::core::ffi::c_void,
-    finalizer: ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>,
+    info: *mut std::ffi::c_void,
+    finalizer: std::option::Option<unsafe extern "C" fn(arg1: *mut std::ffi::c_void)>,
 }
 
 impl HostInfo for HostInfoState {
@@ -1631,8 +1630,8 @@ impl HostInfo for HostInfoState {
 #[no_mangle]
 pub unsafe extern "C" fn wasm_instance_set_host_info_with_finalizer(
     instance: *mut wasm_instance_t,
-    info: *mut ::core::ffi::c_void,
-    finalizer: ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>,
+    info: *mut std::ffi::c_void,
+    finalizer: std::option::Option<unsafe extern "C" fn(arg1: *mut std::ffi::c_void)>,
 ) {
     let info = if info.is_null() && finalizer.is_none() {
         None