Migrate wasm-bindgen to using walrus

This commit moves `wasm-bindgen` the CLI tool from internally using
`parity-wasm` for wasm parsing/serialization to instead use `walrus`.
The `walrus` crate is something we've been working on recently with an
aim to replace the usage of `parity-wasm` in `wasm-bindgen` to make the
current CLI tool more maintainable as well as more future-proof.

The `walrus` crate provides a much nicer AST to work with as well as a
structured `Module`, whereas `parity-wasm` provides a very raw interface
to the wasm module which isn't really appropriate for our use case. The
many transformations and tweaks that wasm-bindgen does have a huge
amount of ad-hoc index management to carefully craft a final wasm
binary, but this is all entirely taken care for us with the `walrus`
crate.

Additionally, `wasm-bindgen` will ingest and rewrite the wasm file,
often changing the binary offsets of functions. Eventually with DWARF
debug information we'll need to be sure to preserve the debug
information throughout the transformations that `wasm-bindgen` does
today. This is practically impossible to do with the `parity-wasm`
architecture, but `walrus` was designed from the get-go to solve this
problem transparently in the `walrus` crate itself. (it doesn't today,
but this is planned work)

It is the intention that this does not end up regressing any
`wasm-bindgen` use cases, neither in functionality or in speed. As a
large change and refactoring, however, it's likely that at least
something will arise! We'll want to continue to remain vigilant to any
issues that come up with this commit.

Note that the `gc` crate has been deleted as part of this change, as the
`gc` crate is no longer necessary since `walrus` does it automatically.
Additionally the `gc` crate was one of the main problems with preserving
debug information as it often deletes wasm items!

Finally, this also starts moving crates to the 2018 edition where
necessary since `walrus` requires the 2018 edition, and in general it's
more pleasant to work within the 2018 edition!

crates/macro-support/src/lib.rs

@@ -13,11 +13,11 @@ extern crate wasm_bindgen_shared as shared;
 
 use backend::{Diagnostic, TryToTokens};
 pub use parser::BindgenAttrs;
-use quote::ToTokens;
 use parser::MacroParse;
 use proc_macro2::TokenStream;
-use syn::parse::{Parse, ParseStream, Result as SynResult};
+use quote::ToTokens;
 use quote::TokenStreamExt;
+use syn::parse::{Parse, ParseStream, Result as SynResult};
 
 mod parser;
 
@@ -41,7 +41,10 @@ pub fn expand(attr: TokenStream, input: TokenStream) -> Result<TokenStream, Diag
 }
 
 /// Takes the parsed input from a `#[wasm_bindgen]` macro and returns the generated bindings
-pub fn expand_class_marker(attr: TokenStream, input: TokenStream) -> Result<TokenStream, Diagnostic> {
+pub fn expand_class_marker(
+    attr: TokenStream,
+    input: TokenStream,
+) -> Result<TokenStream, Diagnostic> {
     parser::reset_attrs_used();
     let mut item = syn::parse2::<syn::ImplItemMethod>(input)?;
     let opts: ClassMarker = syn::parse2(attr)?;
@@ -62,11 +65,9 @@ pub fn expand_class_marker(attr: TokenStream, input: TokenStream) -> Result<Toke
     // We manually implement `ToTokens for ImplItemMethod` here, injecting our
     // program's tokens before the actual method's inner body tokens.
     let mut tokens = proc_macro2::TokenStream::new();
-    tokens.append_all(item.attrs.iter().filter(|attr| {
-        match attr.style {
-            syn::AttrStyle::Outer => true,
-            _ => false,
-        }
+    tokens.append_all(item.attrs.iter().filter(|attr| match attr.style {
+        syn::AttrStyle::Outer => true,
+        _ => false,
     }));
     item.vis.to_tokens(&mut tokens);
     item.sig.to_tokens(&mut tokens);
@@ -75,17 +76,15 @@ pub fn expand_class_marker(attr: TokenStream, input: TokenStream) -> Result<Toke
         if let Err(e) = program.try_to_tokens(tokens) {
             err = Some(e);
         }
-        tokens.append_all(item.attrs.iter().filter(|attr| {
-            match attr.style {
-                syn::AttrStyle::Inner(_) => true,
-                _ => false,
-            }
+        tokens.append_all(item.attrs.iter().filter(|attr| match attr.style {
+            syn::AttrStyle::Inner(_) => true,
+            _ => false,
         }));
         tokens.append_all(&item.block.stmts);
     });
 
     if let Some(err) = err {
-        return Err(err)
+        return Err(err);
     }
 
     Ok(tokens)

crates/macro-support/src/parser.rs

@@ -796,7 +796,11 @@ impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
 }
 
 impl<'a> MacroParse<BindgenAttrs> for &'a mut syn::ItemImpl {
-    fn macro_parse(self, _program: &mut ast::Program, opts: BindgenAttrs) -> Result<(), Diagnostic> {
+    fn macro_parse(
+        self,
+        _program: &mut ast::Program,
+        opts: BindgenAttrs,
+    ) -> Result<(), Diagnostic> {
         if self.defaultness.is_some() {
             bail_span!(
                 self.defaultness,
@@ -851,7 +855,7 @@ impl<'a> MacroParse<BindgenAttrs> for &'a mut syn::ItemImpl {
 fn prepare_for_impl_recursion(
     item: &mut syn::ImplItem,
     class: &Ident,
-    impl_opts: &BindgenAttrs
+    impl_opts: &BindgenAttrs,
 ) -> Result<(), Diagnostic> {
     let method = match item {
         syn::ImplItem::Method(m) => m,
@@ -884,13 +888,16 @@ fn prepare_for_impl_recursion(
         .map(|s| s.0.to_string())
         .unwrap_or(class.to_string());
 
-    method.attrs.insert(0, syn::Attribute {
-        pound_token: Default::default(),
-        style: syn::AttrStyle::Outer,
-        bracket_token: Default::default(),
-        path: syn::Ident::new("__wasm_bindgen_class_marker", Span::call_site()).into(),
-        tts: quote::quote! { (#class = #js_class) }.into(),
-    });
+    method.attrs.insert(
+        0,
+        syn::Attribute {
+            pound_token: Default::default(),
+            style: syn::AttrStyle::Outer,
+            bracket_token: Default::default(),
+            path: syn::Ident::new("__wasm_bindgen_class_marker", Span::call_site()).into(),
+            tts: quote::quote! { (#class = #js_class) }.into(),
+        },
+    );
 
     Ok(())
 }
@@ -973,7 +980,10 @@ impl MacroParse<()> for syn::ItemEnum {
                 // We don't really want to get in the business of emulating how
                 // rustc assigns values to enums.
                 if v.discriminant.is_some() != has_discriminant {
-                    bail_span!(v, "must either annotate discriminant of all variants or none");
+                    bail_span!(
+                        v,
+                        "must either annotate discriminant of all variants or none"
+                    );
                 }
 
                 let value = match v.discriminant {
@@ -1010,7 +1020,8 @@ impl MacroParse<()> for syn::ItemEnum {
 
         let mut values = variants.iter().map(|v| v.value).collect::<Vec<_>>();
         values.sort();
-        let hole = values.windows(2)
+        let hole = values
+            .windows(2)
             .filter_map(|window| {
                 if window[0] + 1 != window[1] {
                     Some(window[0] + 1)