Refactor (#1524)

* Compute instance exports on demand.

Instead having instances eagerly compute a Vec of Externs, and bumping
the refcount for each Extern, compute Externs on demand.

This also enables `Instance::get_export` to avoid doing a linear search.

This also means that the closure returned by `get0` and friends now
holds an `InstanceHandle` to dynamically hold the instance live rather
than being scoped to a lifetime.

* Compute module imports and exports on demand too.

And compute Extern::ty on demand too.

* Add a utility function for computing an ExternType.

* Add a utility function for looking up a function's signature.

* Add a utility function for computing the ValType of a Global.

* Rename wasmtime_environ::Export to EntityIndex.

This helps differentiate it from other Export types in the tree, and
describes what it is.

* Fix a typo in a comment.

* Simplify module imports and exports.

* Make `Instance::exports` return the export names.

This significantly simplifies the public API, as it's relatively common
to need the names, and this avoids the need to do a zip with
`Module::exports`.

This also changes `ImportType` and `ExportType` to have public members
instead of private members and accessors, as I find that simplifies the
usage particularly in cases where there are temporary instances.

* Remove `Instance::module`.

This doesn't quite remove `Instance`'s `module` member, it gets a step
closer.

* Use a InstanceHandle utility function.

* Don't consume self in the `Func::get*` methods.

Instead, just create a closure containing the instance handle and the
export for them to call.

* Use `ExactSizeIterator` to avoid needing separate `num_*` methods.

* Rename `Extern::func()` etc. to `into_func()` etc.

* Revise examples to avoid using `nth`.

* Add convenience methods to instance for getting specific extern types.

* Use the convenience functions in more tests and examples.

* Avoid cloning strings for `ImportType` and `ExportType`.

* Remove more obviated clone() calls.

* Simplify `Func`'s closure state.

* Make wasmtime::Export's fields private.

This makes them more consistent with ExportType.

* Fix compilation error.

* Make a lifetime parameter explicit, and use better lifetime names.

Instead of 'me, use 'instance and 'module to make it clear what the
lifetime is.

* More lifetime cleanups.

tests/all/custom_signal_handler.rs

@@ -38,18 +38,13 @@ mod tests {
 "#;
 
     fn invoke_export(instance: &Instance, func_name: &str) -> Result<Box<[Val]>> {
-        let ret = instance
-            .get_export(func_name)
-            .unwrap()
-            .func()
-            .unwrap()
-            .call(&[])?;
+        let ret = instance.get_func(func_name).unwrap().call(&[])?;
         Ok(ret)
     }
 
     // Locate "memory" export, get base address and size and set memory protection to PROT_NONE
     fn set_up_memory(instance: &Instance) -> (*mut u8, usize) {
-        let mem_export = instance.get_export("memory").unwrap().memory().unwrap();
+        let mem_export = instance.get_memory("memory").unwrap();
         let base = mem_export.data_ptr();
         let length = mem_export.data_size();
 
@@ -105,9 +100,6 @@ mod tests {
             });
         }
 
-        let exports = instance.exports();
-        assert!(!exports.is_empty());
-
         // these invoke wasmtime_call_trampoline from action.rs
         {
             println!("calling read...");
@@ -130,8 +122,8 @@ mod tests {
 
         // these invoke wasmtime_call_trampoline from callable.rs
         {
-            let read_func = exports[0]
-                .func()
+            let read_func = instance
+                .get_func("read")
                 .expect("expected a 'read' func in the module");
             println!("calling read...");
             let result = read_func.call(&[]).expect("expected function not to trap");
@@ -139,8 +131,8 @@ mod tests {
         }
 
         {
-            let read_out_of_bounds_func = exports[1]
-                .func()
+            let read_out_of_bounds_func = instance
+                .get_func("read_out_of_bounds")
                 .expect("expected a 'read_out_of_bounds' func in the module");
             println!("calling read_out_of_bounds...");
             let trap = read_out_of_bounds_func
@@ -216,8 +208,8 @@ mod tests {
 
         // First instance1
         {
-            let exports1 = instance1.exports();
-            assert!(!exports1.is_empty());
+            let mut exports1 = instance1.exports();
+            assert!(exports1.next().is_some());
 
             println!("calling instance1.read...");
             let result = invoke_export(&instance1, "read").expect("read succeeded");
@@ -231,8 +223,8 @@ mod tests {
 
         // And then instance2
         {
-            let exports2 = instance2.exports();
-            assert!(!exports2.is_empty());
+            let mut exports2 = instance2.exports();
+            assert!(exports2.next().is_some());
 
             println!("calling instance2.read...");
             let result = invoke_export(&instance2, "read").expect("read succeeded");
@@ -262,13 +254,12 @@ mod tests {
             });
         }
 
-        let instance1_exports = instance1.exports();
-        assert!(!instance1_exports.is_empty());
-        let instance1_read = instance1_exports[0].clone();
+        let mut instance1_exports = instance1.exports();
+        let instance1_read = instance1_exports.next().unwrap();
 
-        // instance2 wich calls 'instance1.read'
+        // instance2 which calls 'instance1.read'
         let module2 = Module::new(&store, WAT2)?;
-        let instance2 = Instance::new(&module2, &[instance1_read])?;
+        let instance2 = Instance::new(&module2, &[instance1_read.into_extern()])?;
         // since 'instance2.run' calls 'instance1.read' we need to set up the signal handler to handle
         // SIGSEGV originating from within the memory of instance1
         unsafe {