Use VTables for callback interfaces

Instead of registering a single method to implement a callback
interface, foreign code now registers a VTable.  VTable sounds fancy,
but it's just a repr(C) struct where each field is a callback function.

This gives us some more flexibility with the method signatures.
Before, all arguments were passed using a RustBuffer, but not all FFI
types can be written to a RustBuffer.  In particular, I want to be able
to pass callback function pointers.

This also makes the callback interface FFI closer to the Rust one.  I
wanted to make it match exactly, but it didn't work out.  Unfortunately,
we can't directly return the return value on Python because of an old
ctypes bug (https://bugs.python.org/issue5710). Instead, input an out
param for the return type.  The other main possibility would be to
change `RustBuffer` to be a simple `*mut u8` (mozilla#1779), which would then
be returnable by Python.  However, it seems bad to restrict ourselves
from ever returning a struct in the future. Eventually, we want to stop
using `RustBuffer` for all complex data types and that probably means
using a struct instead in some cases.

Renamed `CALL_PANIC` to `CALL_UNEXPECTED_ERROR` in the foreign bindings
templates.  This matches the name in the Rust code and makes more sense
for foreign trait implementations.

Switched the keywords fixture tests to use traits rather than callback
interfaces.  The old tests were testing unsupported things like
returning callback interfaces which just happened to pass.

Removed the reexport-scaffolding-macro fixture. I don't think this one
is giving us a lot of value anymore and I don't want to keep updating it
when the FFI changes.

Cargo.toml

@@ -37,7 +37,6 @@ members = [
   "fixtures/keywords/swift",
   "fixtures/metadata",
   "fixtures/proc-macro",
-  "fixtures/reexport-scaffolding-macro",
   "fixtures/regressions/enum-without-i32-helpers",
   "fixtures/regressions/fully-qualified-types",
   "fixtures/regressions/kotlin-experimental-unsigned-types",

fixtures/keywords/kotlin/src/keywords.udl

@@ -7,7 +7,8 @@ interface break {
     void object(u8? class);
 };
 
-callback interface continue {
+[Trait]
+interface continue {
     return return(return v);
     continue? continue();
     record<u8, break> break(break? v);

fixtures/keywords/kotlin/src/lib.rs

@@ -15,9 +15,9 @@ impl r#break {
 }
 
 #[allow(non_camel_case_types)]
-trait r#continue {
+trait r#continue: Send + Sync {
     fn r#return(&self, v: r#return) -> r#return;
-    fn r#continue(&self) -> Option<Box<dyn r#continue>>;
+    fn r#continue(&self) -> Option<Arc<dyn r#continue>>;
     fn r#break(&self, _v: Option<Arc<r#break>>) -> HashMap<u8, Arc<r#break>>;
     fn r#while(&self, _v: Vec<r#while>) -> r#while;
     fn class(&self, _v: HashMap<u8, Vec<class>>) -> Option<HashMap<u8, Vec<class>>>;

fixtures/keywords/rust/src/keywords.udl

@@ -13,7 +13,8 @@ interface break {
     void async(u8? yield);
 };
 
-callback interface continue {
+[Trait]
+interface continue {
     return return(return v);
     continue? continue();
     record<u8, break> break(break? v);

fixtures/keywords/rust/src/lib.rs

@@ -16,15 +16,15 @@ impl r#break {
     pub fn r#break(&self, v: HashMap<u8, Arc<r#break>>) -> Option<HashMap<u8, Arc<r#break>>> {
         Some(v)
     }
-    fn r#continue(&self, _v: Vec<Box<dyn r#continue>>) {}
+    fn r#continue(&self, _v: Vec<Arc<dyn r#continue>>) {}
     pub fn r#yield(&self, _async: u8) {}
     pub fn r#async(&self, _yield: Option<u8>) {}
 }
 
 #[allow(non_camel_case_types)]
-pub trait r#continue {
+pub trait r#continue: Send + Sync {
     fn r#return(&self, v: r#return) -> r#return;
-    fn r#continue(&self) -> Option<Box<dyn r#continue>>;
+    fn r#continue(&self) -> Option<Arc<dyn r#continue>>;
     fn r#break(&self, _v: Option<Arc<r#break>>) -> HashMap<u8, Arc<r#break>>;
     fn r#while(&self, _v: Vec<r#while>) -> r#while;
     fn r#yield(&self, _v: HashMap<u8, Vec<r#yield>>) -> Option<HashMap<u8, Vec<r#yield>>>;

fixtures/proc-macro/tests/bindings/test_proc_macro.swift

@@ -79,8 +79,7 @@ class SwiftTestCallbackInterface : TestCallbackInterface {
     }
 
     func callbackHandler(h: Object) -> UInt32 {
-        var v = h.takeError(e: BasicError.InvalidInput)
-        return v
+        return h.takeError(e: BasicError.InvalidInput)
     }
 }