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/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;