Improve panics/traps from imported functions (#857)

* Improve panics/traps from imported functions

This commit performs a few refactorings and fixes a bug as well. The
changes here are:

* The `thread_local!` in the `wasmtime` crate for trap information is
  removed. The thread local in the `wasmtime_runtime` crate is now
  leveraged to transmit trap information.

* Panics in user-provided functions are now caught explicitly to be
  carried across JIT code manually. Getting Rust panics unwinding
  through JIT code is pretty likely to be super tricky and difficult to
  do, so in the meantime we can get by with catching panics and resuming
  the panic once we've resumed in Rust code.

* Various take/record trap apis have all been removed in favor of
  working directly with `Trap` objects, where the internal trap object
  has been expanded slightly to encompass user-provided errors as well.

This borrows a bit #839 and otherwise will...

Closes #848

* Rename `r#return` to `ret`

crates/api/tests/traps.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use std::panic::{self, AssertUnwindSafe};
 use std::rc::Rc;
 use wasmtime::*;
 
@@ -215,3 +216,95 @@ wasm backtrace:
     );
     Ok(())
 }
+
+#[test]
+fn trap_start_function_import() -> Result<()> {
+    struct ReturnTrap;
+
+    impl Callable for ReturnTrap {
+        fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+            Err(Trap::new("user trap"))
+        }
+    }
+
+    let store = Store::default();
+    let binary = wat::parse_str(
+        r#"
+            (module $a
+                (import "" "" (func $foo))
+                (start $foo)
+            )
+        "#,
+    )?;
+
+    let module = Module::new(&store, &binary)?;
+    let sig = FuncType::new(Box::new([]), Box::new([]));
+    let func = Func::new(&store, sig, Rc::new(ReturnTrap));
+    let err = Instance::new(&module, &[func.into()]).err().unwrap();
+    assert_eq!(err.downcast_ref::<Trap>().unwrap().message(), "user trap");
+    Ok(())
+}
+
+#[test]
+fn rust_panic_import() -> Result<()> {
+    struct Panic;
+
+    impl Callable for Panic {
+        fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+            panic!("this is a panic");
+        }
+    }
+
+    let store = Store::default();
+    let binary = wat::parse_str(
+        r#"
+            (module $a
+                (import "" "" (func $foo))
+                (func (export "foo") call $foo)
+            )
+        "#,
+    )?;
+
+    let module = Module::new(&store, &binary)?;
+    let sig = FuncType::new(Box::new([]), Box::new([]));
+    let func = Func::new(&store, sig, Rc::new(Panic));
+    let instance = Instance::new(&module, &[func.into()])?;
+    let func = instance.exports()[0].func().unwrap().clone();
+    let err = panic::catch_unwind(AssertUnwindSafe(|| {
+        drop(func.call(&[]));
+    }))
+    .unwrap_err();
+    assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
+    Ok(())
+}
+
+#[test]
+fn rust_panic_start_function() -> Result<()> {
+    struct Panic;
+
+    impl Callable for Panic {
+        fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), Trap> {
+            panic!("this is a panic");
+        }
+    }
+
+    let store = Store::default();
+    let binary = wat::parse_str(
+        r#"
+            (module $a
+                (import "" "" (func $foo))
+                (start $foo)
+            )
+        "#,
+    )?;
+
+    let module = Module::new(&store, &binary)?;
+    let sig = FuncType::new(Box::new([]), Box::new([]));
+    let func = Func::new(&store, sig, Rc::new(Panic));
+    let err = panic::catch_unwind(AssertUnwindSafe(|| {
+        drop(Instance::new(&module, &[func.into()]));
+    }))
+    .unwrap_err();
+    assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
+    Ok(())
+}