Update no_std support for Rust 2018 Edition.

With Rust 2018 Edition, the `mod std` trick to alias `core` names to
`std` no longer works, so switch to just having the code use `core`
explicitly.

So instead, switch to just using `core::*` for things that in core.
This is more consistent with other Rust no_std code. And it allows
us to enable `no_std` mode unconditionally in the crates that support
it, which makes testing a little easier.

There actually three cases:

 - For things in std and also in core, like `cmp`: Just use them via
   `core::*`.

 - For things in std and also in alloc, like `Vec`: Import alloc as std, as
   use them from std. This allows them to work on both stable (which
   doesn't provide alloc, but we don't support no_std mode anyway) and
   nightly.

 - For HashMap and similar which are not in core or alloc, import them in
   the top-level lib.rs files from either std or the third-party hashmap_core
   crate, and then have the code use super::hashmap_core.

Also, no_std support continues to be "best effort" at this time and not
something most people need to be testing.

lib/module/Cargo.toml

@@ -14,7 +14,7 @@ edition = "2018"
 cranelift-codegen = { path = "../codegen", version = "0.26.0", default-features = false }
 cranelift-entity = { path = "../entity", version = "0.26.0", default-features = false }
 hashmap_core = { version = "0.1.9", optional = true }
-failure = "0.1.1"
+failure = { version = "0.1.1", default-features = false }
 log = { version = "0.4.6", default-features = false }
 
 [features]

lib/module/src/backend.rs

@@ -4,10 +4,10 @@ use crate::DataContext;
 use crate::Linkage;
 use crate::ModuleNamespace;
 use crate::ModuleResult;
+use core::marker;
 use cranelift_codegen::isa::TargetIsa;
 use cranelift_codegen::Context;
 use cranelift_codegen::{binemit, ir};
-use std::marker;
 
 /// A `Backend` implements the functionality needed to support a `Module`.
 ///

lib/module/src/data_context.rs

@@ -61,8 +61,8 @@ impl DataContext {
                 init: Init::Uninitialized,
                 function_decls: PrimaryMap::new(),
                 data_decls: PrimaryMap::new(),
-                function_relocs: Vec::new(),
-                data_relocs: Vec::new(),
+                function_relocs: vec![],
+                data_relocs: vec![],
             },
         }
     }

lib/module/src/lib.rs

@@ -18,13 +18,20 @@
         clippy::use_self
     )
 )]
-// Turns on no_std and alloc features if std is not available.
-#![cfg_attr(not(feature = "std"), no_std)]
+#![no_std]
 #![cfg_attr(not(feature = "std"), feature(alloc))]
 
 #[cfg(not(feature = "std"))]
-#[cfg_attr(test, macro_use)]
-extern crate alloc;
+#[macro_use]
+extern crate alloc as std;
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+
+#[cfg(not(feature = "std"))]
+use hashmap_core::{map as hash_map, HashMap};
+#[cfg(feature = "std")]
+use std::collections::{hash_map, HashMap};
 
 mod backend;
 mod data_context;
@@ -36,19 +43,5 @@ pub use crate::module::{
     DataId, FuncId, FuncOrDataId, Linkage, Module, ModuleError, ModuleNamespace, ModuleResult,
 };
 
-/// This replaces `std` in builds with `core`.
-#[cfg(not(feature = "std"))]
-mod std {
-    pub use alloc::{borrow, boxed, string, vec};
-    pub use core::*;
-    pub mod collections {
-        #[allow(unused_extern_crates)]
-        extern crate hashmap_core;
-
-        pub use self::hashmap_core::map as hash_map;
-        pub use self::hashmap_core::{HashMap, HashSet};
-    }
-}
-
 /// Version number of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");

lib/module/src/module.rs

@@ -5,6 +5,7 @@
 // TODO: Factor out `ir::Function`'s `ext_funcs` and `global_values` into a struct
 // shared with `DataContext`?
 
+use super::HashMap;
 use crate::data_context::DataContext;
 use crate::Backend;
 use cranelift_codegen::entity::{entity_impl, PrimaryMap};
@@ -12,7 +13,6 @@ use cranelift_codegen::{binemit, ir, isa, CodegenError, Context};
 use failure::Fail;
 use log::info;
 use std::borrow::ToOwned;
-use std::collections::HashMap;
 use std::string::String;
 use std::vec::Vec;
 
@@ -398,7 +398,7 @@ where
         signature: &ir::Signature,
     ) -> ModuleResult<FuncId> {
         // TODO: Can we avoid allocating names so often?
-        use std::collections::hash_map::Entry::*;
+        use super::hash_map::Entry::*;
         match self.names.entry(name.to_owned()) {
             Occupied(entry) => match *entry.get() {
                 FuncOrDataId::Func(id) => {
@@ -435,7 +435,7 @@ where
         writable: bool,
     ) -> ModuleResult<DataId> {
         // TODO: Can we avoid allocating names so often?
-        use std::collections::hash_map::Entry::*;
+        use super::hash_map::Entry::*;
         match self.names.entry(name.to_owned()) {
             Occupied(entry) => match *entry.get() {
                 FuncOrDataId::Data(id) => {