Remove the need for HostRef<Module> (#778)

* Remove the need for `HostRef<Module>`

This commit continues previous work and also #708 by removing the need
to use `HostRef<Module>` in the API of the `wasmtime` crate. The API
changes performed here are:

* The `Module` type is now itself internally reference counted.
* The `Module::store` function now returns the `Store` that was used to
  create a `Module`
* Documentation for `Module` and its methods have been expanded.

* Fix compliation of test programs harness

* Fix the python extension

* Update `CodeMemory` to be `Send + Sync`

This commit updates the `CodeMemory` type in wasmtime to be both `Send`
and `Sync` by updating the implementation of `Mmap` to not store raw
pointers. This avoids the need for an `unsafe impl` and leaves the
unsafety as it is currently.

* Fix a typo

crates/api/src/instance.rs

@@ -1,7 +1,6 @@
 use crate::context::Context;
 use crate::externals::Extern;
 use crate::module::Module;
-use crate::r#ref::HostRef;
 use crate::runtime::Store;
 use crate::trampoline::take_api_trap;
 use crate::trap::Trap;
@@ -60,7 +59,7 @@ pub fn instantiate_in_context(
 pub struct Instance {
     instance_handle: InstanceHandle,
 
-    module: HostRef<Module>,
+    module: Module,
 
     // We need to keep CodeMemory alive.
     contexts: HashSet<Context>,
@@ -69,29 +68,19 @@ pub struct Instance {
 }
 
 impl Instance {
-    pub fn new(
-        store: &Store,
-        module: &HostRef<Module>,
-        externs: &[Extern],
-    ) -> Result<Instance, Error> {
+    pub fn new(store: &Store, module: &Module, externs: &[Extern]) -> Result<Instance, Error> {
         let context = store.context().clone();
         let exports = store.global_exports().clone();
         let imports = module
-            .borrow()
             .imports()
             .iter()
             .zip(externs.iter())
             .map(|(i, e)| (i.module().to_string(), i.name().to_string(), e.clone()))
             .collect::<Vec<_>>();
-        let (mut instance_handle, contexts) = instantiate_in_context(
-            module.borrow().binary().expect("binary"),
-            imports,
-            context,
-            exports,
-        )?;
+        let (mut instance_handle, contexts) =
+            instantiate_in_context(module.binary().expect("binary"), imports, context, exports)?;
 
         let exports = {
-            let module = module.borrow();
             let mut exports = Vec::with_capacity(module.exports().len());
             for export in module.exports() {
                 let name = export.name().to_string();
@@ -116,14 +105,13 @@ impl Instance {
         &self.exports
     }
 
-    pub fn module(&self) -> &HostRef<Module> {
+    pub fn module(&self) -> &Module {
         &self.module
     }
 
     pub fn find_export_by_name(&self, name: &str) -> Option<&Extern> {
         let (i, _) = self
             .module
-            .borrow()
             .exports()
             .iter()
             .enumerate()
@@ -154,10 +142,7 @@ impl Instance {
             ));
         }
 
-        let module = HostRef::new(Module::from_exports(
-            store,
-            exports_types.into_boxed_slice(),
-        ));
+        let module = Module::from_exports(store, exports_types.into_boxed_slice());
 
         Instance {
             instance_handle,