rustwasm#2806 bugfix: Added checks for JS keywords in signatures.

Author: petrstudynka

crates/macro-support/src/parser.rs

@@ -9,12 +9,35 @@ use backend::Diagnostic;
 use proc_macro2::{Delimiter, Ident, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use shared;
-use syn;
 use syn::parse::{Parse, ParseStream, Result as SynResult};
 use syn::spanned::Spanned;
+use syn::{self, FnArg, Pat, Signature};
 
 thread_local!(static ATTRS: AttributeParseState = Default::default());
 
+/// Javascript keywords which are not keywords in Rust.
+const JS_KEYWORDS: [&str; 19] = [
+    "class",
+    "case",
+    "catch",
+    "debugger",
+    "default",
+    "delete",
+    "export",
+    "extends",
+    "finally",
+    "function",
+    "import",
+    "instaceof",
+    "new",
+    "switch",
+    "this",
+    "throw",
+    "var",
+    "void",
+    "with",
+];
+
 #[derive(Default)]
 struct AttributeParseState {
     parsed: Cell<usize>,
@@ -815,6 +838,30 @@ fn function_from_decl(
     ))
 }
 
+/// Checks if `keyword` is keyword in javascript.
+pub(crate) fn is_js_keyword<T: ToString>(keyword: T) -> bool {
+    let keyword = keyword.to_string();
+    JS_KEYWORDS.contains(&keyword.as_str())
+}
+
+/// Maps signatures's arguments to idents.
+pub(crate) fn sign_args_to_idents(sig: &Signature) -> Vec<Ident> {
+    sig.inputs
+        .to_owned()
+        .into_iter()
+        .filter_map(|arg| match arg {
+            FnArg::Typed(t) => {
+                if let Pat::Ident(ident) = *t.pat {
+                    Some(ident.ident)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        })
+        .collect()
+}
+
 pub(crate) trait MacroParse<Ctx> {
     /// Parse the contents of an object into our AST, with a context if necessary.
     ///
@@ -854,6 +901,19 @@ impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
                         bail_span!(&f.sig.inputs, "the start function cannot have arguments",);
                     }
                 }
+                let fn_name_as_ident = if let Some((js_name, span)) = opts.js_name() {
+                    Ident::new(js_name, span)
+                } else {
+                    f.sig.ident.clone()
+                };
+                if is_js_keyword(fn_name_as_ident) {
+                    bail_span!(&f.sig.ident, "function name cannot be js keyword",);
+                }
+                let fn_args = sign_args_to_idents(&f.sig);
+                if let Some(ident) = fn_args.into_iter().find(|inpt| is_js_keyword(inpt)) {
+                    bail_span!(ident, "function argument name cannot be js keyword",);
+                }
+
                 let method_kind = ast::MethodKind::Operation(ast::Operation {
                     is_static: true,
                     kind: operation_kind(&opts),
@@ -978,7 +1038,13 @@ fn prepare_for_impl_recursion(
     impl_opts: &BindgenAttrs,
 ) -> Result<(), Diagnostic> {
     let method = match item {
-        syn::ImplItem::Method(m) => m,
+        syn::ImplItem::Method(m) => {
+            let fn_args = sign_args_to_idents(&m.sig);
+            if let Some(ident) = fn_args.into_iter().find(|inpt| is_js_keyword(inpt)) {
+                bail_span!(ident, "method argument name cannot be js keyword",);
+            }
+            m
+        }
         syn::ImplItem::Const(_) => {
             bail_span!(
                 &*item,

crates/macro/ui-tests/compiles-to-js-keyword.rs

@@ -0,0 +1,24 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn class(arg: u8) {}
+
+#[wasm_bindgen(js_name = class)]
+pub fn parsed_to_class(arg: u8) {}
+
+#[wasm_bindgen(js_name = classy)]
+pub fn arg_is_class(class: u8) {}
+
+#[wasm_bindgen]
+struct Class {
+    name: String,
+}
+
+#[wasm_bindgen]
+impl Class {
+    pub fn class(void: String) -> Self {
+        Class { name: void }
+    }
+}
+
+fn main() {}

crates/macro/ui-tests/compiles-to-js-keyword.stderr

@@ -0,0 +1,23 @@
+error: function name cannot be js keyword
+ --> ui-tests/compiles-to-js-keyword.rs:4:8
+  |
+4 | pub fn class(arg: u8) {}
+  |        ^^^^^
+
+error: function name cannot be js keyword
+ --> ui-tests/compiles-to-js-keyword.rs:7:8
+  |
+7 | pub fn parsed_to_class(arg: u8) {}
+  |        ^^^^^^^^^^^^^^^
+
+error: function argument name cannot be js keyword
+  --> ui-tests/compiles-to-js-keyword.rs:10:21
+   |
+10 | pub fn arg_is_class(class: u8) {}
+   |                     ^^^^^
+
+error: method argument name cannot be js keyword
+  --> ui-tests/compiles-to-js-keyword.rs:19:18
+   |
+19 |     pub fn class(void: String) -> Self {
+   |                  ^^^^