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/debug/src/gc.rs

@@ -1,9 +1,8 @@
 use crate::transform::AddressTransform;
-use crate::{HashMap, HashSet};
-use alloc::vec::Vec;
 use gimli::constants;
 use gimli::read;
 use gimli::{Reader, UnitSectionOffset};
+use std::collections::{HashMap, HashSet};
 
 #[derive(Debug)]
 pub struct Dependencies {
@@ -20,7 +19,7 @@ impl Dependencies {
     }
 
     fn add_edge(&mut self, a: UnitSectionOffset, b: UnitSectionOffset) {
-        use crate::hash_map::Entry;
+        use std::collections::hash_map::Entry;
         match self.edges.entry(a) {
             Entry::Occupied(mut o) => {
                 o.get_mut().insert(b);

crates/debug/src/lib.rs

@@ -2,16 +2,10 @@
 
 #![allow(clippy::cast_ptr_alignment)]
 
-use alloc::string::String;
-use alloc::vec::Vec;
 use anyhow::Error;
 use cranelift_codegen::isa::TargetFrontendConfig;
 use faerie::{Artifact, Decl};
-#[cfg(not(feature = "std"))]
-use hashbrown::{hash_map, HashMap, HashSet};
 use more_asserts::assert_gt;
-#[cfg(feature = "std")]
-use std::collections::{hash_map, HashMap, HashSet};
 use target_lexicon::{BinaryFormat, Triple};
 use wasmtime_environ::{ModuleAddressMap, ModuleVmctxInfo, ValueLabelsRanges};
 
@@ -24,8 +18,6 @@ mod read_debuginfo;
 mod transform;
 mod write_debuginfo;
 
-extern crate alloc;
-
 struct FunctionRelocResolver {}
 impl SymbolResolver for FunctionRelocResolver {
     fn resolve_symbol(&self, symbol: usize, addend: i64) -> ResolvedSymbol {
@@ -80,12 +72,12 @@ pub fn emit_debugsections_image(
     assert_gt!(funcs.len(), 0);
     let mut segment_body: (usize, usize) = (!0, 0);
     for (body_ptr, body_len) in funcs {
-        segment_body.0 = ::core::cmp::min(segment_body.0, *body_ptr as usize);
-        segment_body.1 = ::core::cmp::max(segment_body.1, *body_ptr as usize + body_len);
+        segment_body.0 = std::cmp::min(segment_body.0, *body_ptr as usize);
+        segment_body.1 = std::cmp::max(segment_body.1, *body_ptr as usize + body_len);
     }
     let segment_body = (segment_body.0 as *const u8, segment_body.1 - segment_body.0);
 
-    let body = unsafe { ::core::slice::from_raw_parts(segment_body.0, segment_body.1) };
+    let body = unsafe { std::slice::from_raw_parts(segment_body.0, segment_body.1) };
     obj.declare_with("all", Decl::function(), body.to_vec())?;
 
     emit_dwarf(&mut obj, dwarf, &resolver)?;

crates/debug/src/read_debuginfo.rs

@@ -1,4 +1,3 @@
-use alloc::{boxed::Box, string::String, vec::Vec};
 use gimli::{
     DebugAbbrev, DebugAddr, DebugInfo, DebugLine, DebugLineStr, DebugLoc, DebugLocLists,
     DebugRanges, DebugRngLists, DebugStr, DebugStrOffsets, DebugTypes, EndianSlice, LittleEndian,

crates/debug/src/transform/address_transform.rs

@@ -1,14 +1,12 @@
-use crate::HashMap;
 use crate::WasmFileInfo;
-use alloc::boxed::Box;
-use alloc::collections::BTreeMap;
-use alloc::vec::Vec;
-use core::iter::FromIterator;
 use cranelift_codegen::ir::SourceLoc;
 use cranelift_entity::{EntityRef, PrimaryMap};
 use cranelift_wasm::DefinedFuncIndex;
 use gimli::write;
 use more_asserts::assert_le;
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::iter::FromIterator;
 use wasmtime_environ::{FunctionAddressMap, ModuleAddressMap};
 
 pub type GeneratedAddress = usize;
@@ -163,7 +161,7 @@ fn build_function_lookup(
                 active_ranges.clone().into_boxed_slice(),
             );
         }
-        active_ranges.retain(|r| ranges[*r].wasm_end.cmp(&wasm_start) != core::cmp::Ordering::Less);
+        active_ranges.retain(|r| ranges[*r].wasm_end.cmp(&wasm_start) != std::cmp::Ordering::Less);
         active_ranges.push(range_index);
         last_wasm_pos = Some(wasm_start);
     }
@@ -494,10 +492,10 @@ impl AddressTransform {
 mod tests {
     use super::{build_function_lookup, get_wasm_code_offset, AddressTransform};
     use crate::read_debuginfo::WasmFileInfo;
-    use core::iter::FromIterator;
     use cranelift_codegen::ir::SourceLoc;
     use cranelift_entity::PrimaryMap;
     use gimli::write::Address;
+    use std::iter::FromIterator;
     use wasmtime_environ::{FunctionAddressMap, InstructionAddressMap, ModuleAddressMap};
 
     #[test]

crates/debug/src/transform/attr.rs

@@ -3,12 +3,11 @@ use super::expression::{compile_expression, CompiledExpression, FunctionFrameInf
 use super::range_info_builder::RangeInfoBuilder;
 use super::unit::PendingDieRef;
 use super::{DebugInputContext, Reader, TransformError};
-use crate::HashMap;
-use alloc::vec::Vec;
 use anyhow::Error;
 use gimli::{
     write, AttributeValue, DebugLineOffset, DebugStr, DebuggingInformationEntry, UnitOffset,
 };
+use std::collections::HashMap;
 
 pub(crate) enum FileAttributeContext<'a> {
     Root(Option<DebugLineOffset>),

crates/debug/src/transform/expression.rs

@@ -1,6 +1,4 @@
 use super::address_transform::AddressTransform;
-use crate::{HashMap, HashSet};
-use alloc::vec::Vec;
 use anyhow::Error;
 use cranelift_codegen::ir::{StackSlots, ValueLabel, ValueLoc};
 use cranelift_codegen::isa::RegUnit;
@@ -9,6 +7,7 @@ use cranelift_entity::EntityRef;
 use cranelift_wasm::{get_vmctx_value_label, DefinedFuncIndex};
 use gimli::{self, write, Expression, Operation, Reader, ReaderOffset, Register, X86_64};
 use more_asserts::{assert_le, assert_lt};
+use std::collections::{HashMap, HashSet};
 
 #[derive(Debug)]
 pub struct FunctionFrameInfo<'a> {
@@ -201,7 +200,7 @@ impl CompiledExpression {
         addr_tr: &AddressTransform,
         frame_info: Option<&FunctionFrameInfo>,
         endian: gimli::RunTimeEndian,
-    ) -> alloc::vec::Vec<(write::Address, u64, write::Expression)> {
+    ) -> Vec<(write::Address, u64, write::Expression)> {
         if scope.is_empty() {
             return vec![];
         }

crates/debug/src/transform/line_program.rs

@@ -1,15 +1,14 @@
 use super::address_transform::AddressTransform;
 use super::attr::clone_attr_string;
 use super::{Reader, TransformError};
-use alloc::collections::BTreeMap;
-use alloc::vec::Vec;
 use anyhow::Error;
-use core::iter::FromIterator;
 use cranelift_entity::EntityRef;
 use gimli::{
     write, DebugLine, DebugLineOffset, DebugStr, DebuggingInformationEntry, LineEncoding, Unit,
 };
 use more_asserts::assert_le;
+use std::collections::BTreeMap;
+use std::iter::FromIterator;
 
 #[derive(Debug)]
 enum SavedLineProgramRow {

crates/debug/src/transform/mod.rs

@@ -1,5 +1,5 @@
 use crate::gc::build_dependencies;
-use crate::{DebugInfoData, HashSet};
+use crate::DebugInfoData;
 use anyhow::Error;
 use cranelift_codegen::isa::TargetFrontendConfig;
 use gimli::{
@@ -7,6 +7,7 @@ use gimli::{
     UnitSectionOffset,
 };
 use simulate::generate_simulated_dwarf;
+use std::collections::HashSet;
 use thiserror::Error;
 use unit::clone_unit;
 use wasmtime_environ::{ModuleAddressMap, ModuleVmctxInfo, ValueLabelsRanges};

crates/debug/src/transform/range_info_builder.rs

@@ -1,6 +1,5 @@
 use super::address_transform::AddressTransform;
 use super::{DebugInputContext, Reader};
-use alloc::vec::Vec;
 use anyhow::Error;
 use cranelift_entity::EntityRef;
 use cranelift_wasm::DefinedFuncIndex;

crates/debug/src/transform/simulate.rs

@@ -2,14 +2,12 @@ use super::expression::{CompiledExpression, FunctionFrameInfo};
 use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
 use super::AddressTransform;
 use crate::read_debuginfo::WasmFileInfo;
-use crate::{HashMap, HashSet};
-use alloc::string::String;
-use alloc::vec::Vec;
 use anyhow::Error;
 use cranelift_entity::EntityRef;
 use cranelift_wasm::get_vmctx_value_label;
 use gimli::write;
 use gimli::{self, LineEncoding};
+use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
 

crates/debug/src/transform/unit.rs

@@ -5,12 +5,11 @@ use super::line_program::clone_line_program;
 use super::range_info_builder::RangeInfoBuilder;
 use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
 use super::{DebugInputContext, Reader, TransformError};
-use crate::{HashMap, HashSet};
-use alloc::{string::String, vec::Vec};
 use anyhow::Error;
 use cranelift_entity::EntityRef;
 use gimli::write;
 use gimli::{AttributeValue, DebuggingInformationEntry, Unit, UnitOffset};
+use std::collections::{HashMap, HashSet};
 use wasmtime_environ::{ModuleVmctxInfo, ValueLabelsRanges};
 
 pub(crate) type PendingDieRef = (write::UnitEntryId, gimli::DwAt, UnitOffset);

crates/debug/src/transform/utils.rs

@@ -1,6 +1,5 @@
 use super::address_transform::AddressTransform;
 use super::expression::{CompiledExpression, FunctionFrameInfo};
-use alloc::vec::Vec;
 use anyhow::Error;
 use cranelift_wasm::DefinedFuncIndex;
 use gimli::write;

crates/debug/src/write_debuginfo.rs

@@ -1,8 +1,8 @@
-use alloc::{string::String, vec::Vec};
 use faerie::artifact::{Decl, SectionKind};
 use faerie::*;
 use gimli::write::{Address, Dwarf, EndianVec, Result, Sections, Writer};
 use gimli::{RunTimeEndian, SectionId};
+use std::result;
 
 #[derive(Clone)]
 struct DebugReloc {