macro-support: Run rustfmt on src/parser.rs

crates/macro-support/src/parser.rs

@@ -1,7 +1,7 @@
 use backend::ast;
-use backend::Diagnostic;
 use backend::util::{ident_ty, ShortHash};
-use proc_macro2::{Ident, Span, TokenStream, TokenTree, Delimiter};
+use backend::Diagnostic;
+use proc_macro2::{Delimiter, Ident, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use shared;
 use syn;
@@ -49,8 +49,7 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::Module(s) => Some(&s[..]),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Whether the catch attribute is present
@@ -76,8 +75,7 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::StaticMethodOf(c) => Some(c),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Whether the method attributes is present
@@ -95,8 +93,7 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::JsNamespace(s) => Some(s),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Get the first getter attribute
@@ -106,8 +103,7 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::Getter(g) => Some(g.clone()),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Get the first setter attribute
@@ -117,8 +113,7 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::Setter(s) => Some(s.clone()),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Whether the indexing getter attributes is present
@@ -168,8 +163,7 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::JsName(s) => Some(&s[..]),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Get the first js_name attribute
@@ -179,18 +173,15 @@ impl BindgenAttrs {
             .filter_map(|a| match a {
                 BindgenAttr::JsClass(s) => Some(&s[..]),
                 _ => None,
-            })
+            }).next()
-            .next()
     }
 
     /// Return the list of classes that a type extends
     fn extends(&self) -> impl Iterator<Item = &Ident> {
-        self.attrs
+        self.attrs.iter().filter_map(|a| match a {
-            .iter()
+            BindgenAttr::Extends(s) => Some(s),
-            .filter_map(|a| match a {
+            _ => None,
-                BindgenAttr::Extends(s) => Some(s),
+        })
-                _ => None,
-            })
     }
 }
 
@@ -398,9 +389,10 @@ impl<'a> ConvertToAst<()> for &'a mut syn::ItemStruct {
 impl<'a> ConvertToAst<(BindgenAttrs, &'a Option<String>)> for syn::ForeignItemFn {
     type Target = ast::ImportKind;
 
-    fn convert(self, (opts, module): (BindgenAttrs, &'a Option<String>))
+    fn convert(
-        -> Result<Self::Target, Diagnostic>
+        self,
-    {
+        (opts, module): (BindgenAttrs, &'a Option<String>),
+    ) -> Result<Self::Target, Diagnostic> {
         let default_name = self.ident.to_string();
         let js_name = opts.js_name().unwrap_or(&default_name);
         let wasm = function_from_decl(
@@ -443,21 +435,19 @@ impl<'a> ConvertToAst<(BindgenAttrs, &'a Option<String>)> for syn::ForeignItemFn
         }
 
         let kind = if opts.method() {
-            let class = wasm
+            let class = wasm.arguments.get(0).ok_or_else(|| {
-                .arguments
+                err_span!(self, "imported methods must have at least one argument")
-                .get(0)
+            })?;
-                .ok_or_else(|| {
-                    err_span!(self, "imported methods must have at least one argument")
-                })?;
             let class = match class.ty {
                 syn::Type::Reference(syn::TypeReference {
                     mutability: None,
                     ref elem,
                     ..
                 }) => &**elem,
-                _ => {
+                _ => bail_span!(
-                    bail_span!(class.ty, "first argument of method must be a shared reference")
+                    class.ty,
-                }
+                    "first argument of method must be a shared reference"
+                ),
             };
             let class_name = match *class {
                 syn::Type::Path(syn::TypePath {
@@ -521,9 +511,14 @@ impl<'a> ConvertToAst<(BindgenAttrs, &'a Option<String>)> for syn::ForeignItemFn
                 ast::ImportFunctionKind::Method { ref class, .. } => (1, &class[..]),
             };
             let data = (ns, &self.ident, module);
-            format!("__wbg_{}_{}",
+            format!(
-                    js_name.chars().filter(|c| c.is_ascii_alphanumeric()).collect::<String>(),
+                "__wbg_{}_{}",
-                    ShortHash(data))
+                js_name
+                    .chars()
+                    .filter(|c| c.is_ascii_alphanumeric())
+                    .collect::<String>(),
+                ShortHash(data)
+            )
         };
         Ok(ast::ImportKind::Function(ast::ImportFunction {
             function: wasm,
@@ -567,9 +562,14 @@ impl ConvertToAst<BindgenAttrs> for syn::ForeignItemStatic {
         }
         let default_name = self.ident.to_string();
         let js_name = opts.js_name().unwrap_or(&default_name);
-        let shim = format!("__wbg_static_accessor_{}_{}",
+        let shim = format!(
-                           js_name.chars().filter(|c| c.is_ascii_alphanumeric()).collect::<String>(),
+            "__wbg_static_accessor_{}_{}",
-                           self.ident);
+            js_name
+                .chars()
+                .filter(|c| c.is_ascii_alphanumeric())
+                .collect::<String>(),
+            self.ident
+        );
         Ok(ast::ImportKind::Static(ast::ImportStatic {
             ty: *self.ty,
             vis: self.vis,
@@ -589,7 +589,10 @@ impl ConvertToAst<BindgenAttrs> for syn::ItemFn {
             _ => bail_span!(self, "can only #[wasm_bindgen] public functions"),
         }
         if self.constness.is_some() {
-            bail_span!(self.constness, "can only #[wasm_bindgen] non-const functions");
+            bail_span!(
+                self.constness,
+                "can only #[wasm_bindgen] non-const functions"
+            );
         }
         if self.unsafety.is_some() {
             bail_span!(self.unsafety, "can only #[wasm_bindgen] safe functions");
@@ -633,8 +636,7 @@ fn function_from_decl(
             syn::Type::Path(syn::TypePath { qself: None, path }) => path,
             other => return other,
         };
-        let new_path = if path.segments.len() == 1 &&
+        let new_path = if path.segments.len() == 1 && path.segments[0].ident == "Self" {
-            path.segments[0].ident == "Self" {
             self_ty.clone().into()
         } else {
             path
@@ -668,8 +670,7 @@ fn function_from_decl(
                 None
             }
             _ => panic!("arguments cannot be `self` or ignored"),
-        })
+        }).collect::<Vec<_>>();
-        .collect::<Vec<_>>();
 
     let ret = match output {
         syn::ReturnType::Default => None,
@@ -693,8 +694,7 @@ pub(crate) trait MacroParse<Ctx> {
     ///
     /// The context is used to have access to the attributes on `#[wasm_bindgen]`, and to allow
     /// writing to the output `TokenStream`.
-    fn macro_parse(self, program: &mut ast::Program, context: Ctx)
+    fn macro_parse(self, program: &mut ast::Program, context: Ctx) -> Result<(), Diagnostic>;
-        -> Result<(), Diagnostic>;
 }
 
 impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
@@ -747,13 +747,11 @@ impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
                 e.to_tokens(tokens);
                 e.macro_parse(program, ())?;
             }
-            _ => {
+            _ => bail_span!(
-                bail_span!(
+                self,
-                    self,
+                "#[wasm_bindgen] can only be applied to a function, \
-                    "#[wasm_bindgen] can only be applied to a function, \
+                 struct, enum, impl, or extern block"
-                     struct, enum, impl, or extern block"
+            ),
-                )
-            }
         }
 
         Ok(())
@@ -761,27 +759,37 @@ impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
 }
 
 impl<'a> MacroParse<()> for &'a mut syn::ItemImpl {
-    fn macro_parse(self, program: &mut ast::Program, (): ())
+    fn macro_parse(self, program: &mut ast::Program, (): ()) -> Result<(), Diagnostic> {
-        -> Result<(), Diagnostic>
-    {
         if self.defaultness.is_some() {
-            bail_span!(self.defaultness, "#[wasm_bindgen] default impls are not supported");
+            bail_span!(
+                self.defaultness,
+                "#[wasm_bindgen] default impls are not supported"
+            );
         }
         if self.unsafety.is_some() {
-            bail_span!(self.unsafety, "#[wasm_bindgen] unsafe impls are not supported");
+            bail_span!(
+                self.unsafety,
+                "#[wasm_bindgen] unsafe impls are not supported"
+            );
         }
         if let Some((_, path, _)) = &self.trait_ {
             bail_span!(path, "#[wasm_bindgen] trait impls are not supported");
         }
         if self.generics.params.len() > 0 {
-            bail_span!(self.generics, "#[wasm_bindgen] generic impls aren't supported");
+            bail_span!(
+                self.generics,
+                "#[wasm_bindgen] generic impls aren't supported"
+            );
         }
         let name = match *self.self_ty {
             syn::Type::Path(syn::TypePath {
                 qself: None,
                 ref path,
             }) => extract_path_ident(path)?,
-            _ => bail_span!(self.self_ty, "unsupported self type in #[wasm_bindgen] impl"),
+            _ => bail_span!(
+                self.self_ty,
+                "unsupported self type in #[wasm_bindgen] impl"
+            ),
         };
         let mut errors = Vec::new();
         for item in self.items.iter_mut() {
@@ -794,18 +802,20 @@ impl<'a> MacroParse<()> for &'a mut syn::ItemImpl {
 }
 
 impl<'a, 'b> MacroParse<()> for (&'a Ident, &'b mut syn::ImplItem) {
-    fn macro_parse(self, program: &mut ast::Program, (): ())
+    fn macro_parse(self, program: &mut ast::Program, (): ()) -> Result<(), Diagnostic> {
-        -> Result<(), Diagnostic>
-    {
         let (class, item) = self;
         let method = match item {
             syn::ImplItem::Method(ref mut m) => m,
             syn::ImplItem::Const(_) => {
-                bail_span!(&*item, "const definitions aren't supported with #[wasm_bindgen]");
+                bail_span!(
-            }
+                    &*item,
-            syn::ImplItem::Type(_) => {
+                    "const definitions aren't supported with #[wasm_bindgen]"
-                bail_span!(&*item, "type definitions in impls aren't supported with #[wasm_bindgen]")
+                );
             }
+            syn::ImplItem::Type(_) => bail_span!(
+                &*item,
+                "type definitions in impls aren't supported with #[wasm_bindgen]"
+            ),
             syn::ImplItem::Macro(_) => {
                 bail_span!(&*item, "macros in impls aren't supported");
             }
@@ -825,10 +835,7 @@ impl<'a, 'b> MacroParse<()> for (&'a Ident, &'b mut syn::ImplItem) {
             );
         }
         if method.sig.unsafety.is_some() {
-            bail_span!(
+            bail_span!(method.sig.unsafety, "can only bindgen safe functions",);
-                method.sig.unsafety,
-                "can only bindgen safe functions",
-            );
         }
 
         let opts = BindgenAttrs::find(&mut method.attrs)?;
@@ -862,9 +869,7 @@ impl<'a, 'b> MacroParse<()> for (&'a Ident, &'b mut syn::ImplItem) {
 }
 
 impl MacroParse<()> for syn::ItemEnum {
-    fn macro_parse(self, program: &mut ast::Program, (): ())
+    fn macro_parse(self, program: &mut ast::Program, (): ()) -> Result<(), Diagnostic> {
-        -> Result<(), Diagnostic>
-    {
         match self.vis {
             syn::Visibility::Public(_) => {}
             _ => bail_span!(self, "only public enums are allowed with #[wasm_bindgen]"),
@@ -897,21 +902,18 @@ impl MacroParse<()> for syn::ItemEnum {
                         int_lit.value() as u32
                     }
                     None => i as u32,
-                    Some((_, ref expr)) => {
+                    Some((_, ref expr)) => bail_span!(
-                        bail_span!(
+                        expr,
-                            expr,
+                        "enums with #[wasm_bidngen] may only have \
-                            "enums with #[wasm_bidngen] may only have \
+                         number literal values",
-                             number literal values",
+                    ),
-                        )
-                    }
                 };
 
                 Ok(ast::Variant {
                     name: v.ident.clone(),
                     value,
                 })
-            })
+            }).collect::<Result<_, Diagnostic>>()?;
-            .collect::<Result<_, Diagnostic>>()?;
         let comments = extract_doc_comments(&self.attrs);
         program.enums.push(ast::Enum {
             name: self.ident,
@@ -923,15 +925,16 @@ impl MacroParse<()> for syn::ItemEnum {
 }
 
 impl MacroParse<BindgenAttrs> for syn::ItemForeignMod {
-    fn macro_parse(self, program: &mut ast::Program, opts: BindgenAttrs)
+    fn macro_parse(self, program: &mut ast::Program, opts: BindgenAttrs) -> Result<(), Diagnostic> {
-        -> Result<(), Diagnostic>
-    {
         let mut errors = Vec::new();
         match self.abi.name {
             Some(ref l) if l.value() == "C" => {}
             None => {}
             Some(ref other) => {
-                errors.push(err_span!(other, "only foreign mods with the `C` ABI are allowed"));
+                errors.push(err_span!(
+                    other,
+                    "only foreign mods with the `C` ABI are allowed"
+                ));
             }
         }
         for mut item in self.items.into_iter() {
@@ -944,9 +947,11 @@ impl MacroParse<BindgenAttrs> for syn::ItemForeignMod {
 }
 
 impl<'a> MacroParse<&'a BindgenAttrs> for syn::ForeignItem {
-    fn macro_parse(mut self, program: &mut ast::Program, opts: &'a BindgenAttrs)
+    fn macro_parse(
-        -> Result<(), Diagnostic>
+        mut self,
-    {
+        program: &mut ast::Program,
+        opts: &'a BindgenAttrs,
+    ) -> Result<(), Diagnostic> {
         let item_opts = {
             let attrs = match self {
                 syn::ForeignItem::Fn(ref mut f) => &mut f.attrs,
@@ -988,14 +993,18 @@ fn extract_first_ty_param(ty: Option<&syn::Type>) -> Result<Option<syn::Type>, D
         }) => path,
         _ => bail_span!(t, "must be Result<...>"),
     };
-    let seg = path.segments.last()
+    let seg = path
+        .segments
+        .last()
         .ok_or_else(|| err_span!(t, "must have at least one segment"))?
         .into_value();
     let generics = match seg.arguments {
         syn::PathArguments::AngleBracketed(ref t) => t,
         _ => bail_span!(t, "must be Result<...>"),
     };
-    let generic = generics.args.first()
+    let generic = generics
+        .args
+        .first()
         .ok_or_else(|| err_span!(t, "must have at least one generic parameter"))?
         .into_value();
     let ty = match generic {
@@ -1051,7 +1060,9 @@ fn assert_no_lifetimes(decl: &syn::FnDecl) -> Result<(), Diagnostic> {
             ));
         }
     }
-    let mut walk = Walk { diagnostics: Vec::new() };
+    let mut walk = Walk {
+        diagnostics: Vec::new(),
+    };
     syn::visit::Visit::visit_fn_decl(&mut walk, decl);
     Diagnostic::from_vec(walk.diagnostics)
 }