diff --git a/crates/backend/Cargo.toml b/crates/backend/Cargo.toml index 587f4ac8..263256fb 100644 --- a/crates/backend/Cargo.toml +++ b/crates/backend/Cargo.toml @@ -14,8 +14,8 @@ Backend code generation of the wasm-bindgen tool spans = [] [dependencies] -quote = '0.5' -proc-macro2 = "0.3" +quote = '0.6' +proc-macro2 = "0.4" wasm-bindgen-shared = { path = "../shared", version = "=0.2.10" } -syn = { version = '0.13', features = ['full', 'visit-mut'] } +syn = { version = '0.14', features = ['full', 'visit-mut'] } serde_json = "1.0" diff --git a/crates/backend/src/ast.rs b/crates/backend/src/ast.rs index e82d8717..d493ec5b 100644 --- a/crates/backend/src/ast.rs +++ b/crates/backend/src/ast.rs @@ -1,5 +1,5 @@ -use proc_macro2::TokenTree; -use quote::{ToTokens, Tokens}; +use proc_macro2::{TokenTree, TokenStream, Ident, Span}; +use quote::ToTokens; use shared; use syn; @@ -12,7 +12,7 @@ pub struct Program { } pub struct Export { - pub class: Option, + pub class: Option, pub method: bool, pub mutable: bool, pub constructor: Option, @@ -22,7 +22,7 @@ pub struct Export { pub struct Import { pub module: Option, pub version: Option, - pub js_namespace: Option, + pub js_namespace: Option, pub kind: ImportKind, } @@ -34,9 +34,9 @@ pub enum ImportKind { pub struct ImportFunction { pub function: Function, - pub rust_name: syn::Ident, + pub rust_name: Ident, pub kind: ImportFunctionKind, - pub shim: syn::Ident, + pub shim: Ident, } pub enum ImportFunctionKind { @@ -48,18 +48,18 @@ pub enum ImportFunctionKind { pub struct ImportStatic { pub vis: syn::Visibility, pub ty: syn::Type, - pub shim: syn::Ident, - pub rust_name: syn::Ident, - pub js_name: syn::Ident, + pub shim: Ident, + pub rust_name: Ident, + pub js_name: Ident, } pub struct ImportType { pub vis: syn::Visibility, - pub name: syn::Ident, + pub name: Ident, } pub struct Function { - pub name: syn::Ident, + pub name: Ident, pub arguments: Vec, pub ret: Option, pub opts: BindgenAttrs, @@ -69,26 +69,26 @@ pub struct Function { } pub struct Struct { - pub name: syn::Ident, + pub name: Ident, pub fields: Vec, } pub struct StructField { pub opts: BindgenAttrs, - pub name: syn::Ident, - pub struct_name: syn::Ident, + pub name: Ident, + pub struct_name: Ident, pub ty: syn::Type, - pub getter: syn::Ident, - pub setter: syn::Ident, + pub getter: Ident, + pub setter: Ident, } pub struct Enum { - pub name: syn::Ident, + pub name: Ident, pub variants: Vec, } pub struct Variant { - pub name: syn::Ident, + pub name: Ident, pub value: u32, } @@ -108,7 +108,7 @@ pub enum TypeLocation { } impl Program { - pub fn push_item(&mut self, item: syn::Item, opts: Option, tokens: &mut Tokens) { + pub fn push_item(&mut self, item: syn::Item, opts: Option, tokens: &mut TokenStream) { match item { syn::Item::Fn(mut f) => { let opts = opts.unwrap_or_else(|| BindgenAttrs::find(&mut f.attrs)); @@ -183,11 +183,11 @@ impl Program { _ => panic!("unsupported self type in impl"), }; for item in item.items.iter_mut() { - self.push_impl_item(name, item); + self.push_impl_item(&name, item); } } - fn push_impl_item(&mut self, class: syn::Ident, item: &mut syn::ImplItem) { + fn push_impl_item(&mut self, class: &Ident, item: &mut syn::ImplItem) { replace_self(class, item); let method = match item { syn::ImplItem::Const(_) => panic!("const definitions aren't supported"), @@ -219,7 +219,7 @@ impl Program { }; let (function, mutable) = Function::from_decl( - method.sig.ident, + &method.sig.ident, Box::new(method.sig.decl.clone()), method.attrs.clone(), opts, @@ -228,7 +228,7 @@ impl Program { ); self.exports.push(Export { - class: Some(class), + class: Some(class.clone()), method: mutable.is_some(), mutable: mutable.unwrap_or(false), constructor, @@ -268,7 +268,7 @@ impl Program { }; Variant { - name: v.ident, + name: v.ident.clone(), value, } }) @@ -297,7 +297,7 @@ impl Program { }; let module = item_opts.module().or(opts.module()).map(|s| s.to_string()); let version = item_opts.version().or(opts.version()).map(|s| s.to_string()); - let js_namespace = item_opts.js_namespace().or(opts.js_namespace()); + let js_namespace = item_opts.js_namespace().or(opts.js_namespace()).cloned(); let mut kind = match item { syn::ForeignItem::Fn(f) => self.push_foreign_fn(f, item_opts), syn::ForeignItem::Type(t) => self.push_foreign_ty(t), @@ -315,9 +315,9 @@ impl Program { } pub fn push_foreign_fn(&mut self, f: syn::ForeignItemFn, opts: BindgenAttrs) -> ImportKind { - let js_name = opts.js_name().unwrap_or(f.ident); + let js_name = opts.js_name().unwrap_or(&f.ident).clone(); let mut wasm = Function::from_decl( - js_name, + &js_name, f.decl, f.attrs, opts, @@ -359,7 +359,7 @@ impl Program { .expect("first argument of method must be a bare type"); ImportFunctionKind::Method { - class: class_name.as_ref().to_string(), + class: class_name.to_string(), ty: class.clone(), } } else if wasm.opts.constructor() { @@ -378,7 +378,7 @@ impl Program { .expect("first argument of method must be a bare type"); ImportFunctionKind::JsConstructor { - class: class_name.as_ref().to_string(), + class: class_name.to_string(), ty: class.clone(), } } else { @@ -396,8 +396,8 @@ impl Program { ImportKind::Function(ImportFunction { function: wasm, kind, - rust_name: f.ident, - shim: shim.into(), + rust_name: f.ident.clone(), + shim: Ident::new(&shim, Span::call_site()), }) } @@ -416,14 +416,14 @@ impl Program { if f.mutability.is_some() { panic!("cannot import mutable globals yet") } - let js_name = opts.js_name().unwrap_or(f.ident); + let js_name = opts.js_name().unwrap_or(&f.ident); let shim = format!("__wbg_static_accessor_{}_{}", js_name, f.ident); ImportKind::Static(ImportStatic { ty: *f.ty, vis: f.vis, - rust_name: f.ident, - js_name, - shim: shim.into(), + rust_name: f.ident.clone(), + js_name: js_name.clone(), + shim: Ident::new(&shim, Span::call_site()), }) } @@ -453,7 +453,7 @@ impl Function { } Function::from_decl( - input.ident, + &input.ident, input.decl, input.attrs, opts, @@ -463,7 +463,7 @@ impl Function { } pub fn from_decl( - name: syn::Ident, + name: &Ident, mut decl: Box, attrs: Vec, opts: BindgenAttrs, @@ -504,7 +504,7 @@ impl Function { ( Function { - name, + name: name.clone(), arguments, ret, opts, @@ -518,12 +518,12 @@ impl Function { fn shared(&self) -> shared::Function { shared::Function { - name: self.name.as_ref().to_string(), + name: self.name.to_string(), } } } -pub fn extract_path_ident(path: &syn::Path) -> Option { +pub fn extract_path_ident(path: &syn::Path) -> Option { if path.leading_colon.is_some() { return None; } @@ -534,33 +534,34 @@ pub fn extract_path_ident(path: &syn::Path) -> Option { syn::PathArguments::None => {} _ => return None, } - path.segments.first().map(|v| v.value().ident) + path.segments.first().map(|v| v.value().ident.clone()) } impl Export { - pub fn rust_symbol(&self) -> syn::Ident { + pub fn rust_symbol(&self) -> Ident { let mut generated_name = format!("__wasm_bindgen_generated"); - if let Some(class) = self.class { + if let Some(class) = &self.class { generated_name.push_str("_"); - generated_name.push_str(class.as_ref()); + generated_name.push_str(&class.to_string()); } generated_name.push_str("_"); - generated_name.push_str(self.function.name.as_ref()); - syn::Ident::from(generated_name) + generated_name.push_str(&self.function.name.to_string()); + Ident::new(&generated_name, Span::call_site()) } pub fn export_name(&self) -> String { - match self.class { + let fn_name = self.function.name.to_string(); + match &self.class { Some(class) => { - shared::struct_function_export_name(class.as_ref(), self.function.name.as_ref()) + shared::struct_function_export_name(&class.to_string(), &fn_name) } - None => shared::free_function_export_name(self.function.name.as_ref()), + None => shared::free_function_export_name(&fn_name), } } fn shared(&self) -> shared::Export { shared::Export { - class: self.class.map(|s| s.as_ref().to_string()), + class: self.class.as_ref().map(|s| s.to_string()), method: self.method, constructor: self.constructor.clone(), function: self.function.shared(), @@ -571,7 +572,7 @@ impl Export { impl Enum { fn shared(&self) -> shared::Enum { shared::Enum { - name: self.name.as_ref().to_string(), + name: self.name.to_string(), variants: self.variants.iter().map(|v| v.shared()).collect(), } } @@ -580,7 +581,7 @@ impl Enum { impl Variant { fn shared(&self) -> shared::EnumVariant { shared::EnumVariant { - name: self.name.as_ref().to_string(), + name: self.name.to_string(), value: self.value, } } @@ -611,7 +612,7 @@ impl Import { shared::Import { module: self.module.clone(), version: self.version.clone(), - js_namespace: self.js_namespace.map(|s| s.as_ref().to_string()), + js_namespace: self.js_namespace.as_ref().map(|s| s.to_string()), kind: self.kind.shared(), } } @@ -637,11 +638,11 @@ impl ImportKind { impl ImportFunction { pub fn infer_getter_property(&self) -> String { - self.function.name.as_ref().to_string() + self.function.name.to_string() } pub fn infer_setter_property(&self) -> String { - let name = self.function.name.as_ref(); + let name = self.function.name.to_string(); assert!(name.starts_with("set_"), "setters must start with `set_`"); name[4..].to_string() } @@ -673,7 +674,7 @@ impl ImportFunction { setter = Some(s.unwrap_or_else(|| self.infer_setter_property())); } shared::ImportFunction { - shim: self.shim.as_ref().to_string(), + shim: self.shim.to_string(), catch: self.function.opts.catch(), method, js_new, @@ -689,8 +690,8 @@ impl ImportFunction { impl ImportStatic { fn shared(&self) -> shared::ImportStatic { shared::ImportStatic { - name: self.js_name.as_ref().to_string(), - shim: self.shim.as_ref().to_string(), + name: self.js_name.to_string(), + shim: self.shim.to_string(), } } } @@ -710,32 +711,34 @@ impl Struct { syn::Visibility::Public(..) => {} _ => continue, } - let name = match field.ident { + let name = match &field.ident { Some(n) => n, None => continue, }; - let getter = shared::struct_field_get(s.ident.as_ref(), name.as_ref()); - let setter = shared::struct_field_set(s.ident.as_ref(), name.as_ref()); + let ident = s.ident.to_string(); + let name_str = name.to_string(); + let getter = shared::struct_field_get(&ident, &name_str); + let setter = shared::struct_field_set(&ident, &name_str); let opts = BindgenAttrs::find(&mut field.attrs); fields.push(StructField { opts, - name, - struct_name: s.ident, + name: name.clone(), + struct_name: s.ident.clone(), ty: field.ty.clone(), - getter: getter.into(), - setter: setter.into(), + getter: Ident::new(&getter, Span::call_site()), + setter: Ident::new(&setter, Span::call_site()), }); } } Struct { - name: s.ident, + name: s.ident.clone(), fields, } } fn shared(&self) -> shared::Struct { shared::Struct { - name: self.name.as_ref().to_string(), + name: self.name.to_string(), fields: self.fields.iter().map(|s| s.shared()).collect(), } } @@ -744,7 +747,7 @@ impl Struct { impl StructField { fn shared(&self) -> shared::StructField { shared::StructField { - name: self.name.as_ref().to_string(), + name: self.name.to_string(), readonly: self.opts.readonly(), } } @@ -781,9 +784,11 @@ impl BindgenAttrs { fn module(&self) -> Option<&str> { self.attrs .iter() - .filter_map(|a| match *a { - BindgenAttr::Module(ref s) => Some(&s[..]), - _ => None, + .filter_map(|a| { + match a { + BindgenAttr::Module(s) => Some(&s[..]), + _ => None, + } }) .next() } @@ -791,84 +796,104 @@ impl BindgenAttrs { fn version(&self) -> Option<&str> { self.attrs .iter() - .filter_map(|a| match *a { - BindgenAttr::Version(ref s) => Some(&s[..]), - _ => None, + .filter_map(|a| { + match a { + BindgenAttr::Version(s) => Some(&s[..]), + _ => None, + } }) .next() } pub fn catch(&self) -> bool { - self.attrs.iter().any(|a| match *a { - BindgenAttr::Catch => true, - _ => false, + self.attrs.iter().any(|a| { + match a { + BindgenAttr::Catch => true, + _ => false, + } }) } fn constructor(&self) -> bool { - self.attrs.iter().any(|a| match *a { - BindgenAttr::Constructor => true, - _ => false, + self.attrs.iter().any(|a| { + match a { + BindgenAttr::Constructor => true, + _ => false, + } }) } fn method(&self) -> bool { - self.attrs.iter().any(|a| match *a { - BindgenAttr::Method => true, - _ => false, + self.attrs.iter().any(|a| { + match a { + BindgenAttr::Method => true, + _ => false, + } }) } - fn js_namespace(&self) -> Option { + fn js_namespace(&self) -> Option<&Ident> { self.attrs .iter() - .filter_map(|a| match *a { - BindgenAttr::JsNamespace(s) => Some(s), - _ => None, + .filter_map(|a| { + match a { + BindgenAttr::JsNamespace(s) => Some(s), + _ => None, + } }) .next() } - pub fn getter(&self) -> Option> { + pub fn getter(&self) -> Option> { self.attrs .iter() - .filter_map(|a| match *a { - BindgenAttr::Getter(s) => Some(s), - _ => None, + .filter_map(|a| { + match a { + BindgenAttr::Getter(s) => Some(s.as_ref()), + _ => None, + } }) .next() } - pub fn setter(&self) -> Option> { + pub fn setter(&self) -> Option> { self.attrs .iter() - .filter_map(|a| match *a { - BindgenAttr::Setter(s) => Some(s), - _ => None, + .filter_map(|a| { + match a { + BindgenAttr::Setter(s) => Some(s.as_ref()), + _ => None, + } }) .next() } pub fn structural(&self) -> bool { - self.attrs.iter().any(|a| match *a { - BindgenAttr::Structural => true, - _ => false, + self.attrs.iter().any(|a| { + match *a { + BindgenAttr::Structural => true, + _ => false, + } }) } pub fn readonly(&self) -> bool { - self.attrs.iter().any(|a| match *a { - BindgenAttr::Readonly => true, - _ => false, + self.attrs.iter().any(|a| { + match *a { + BindgenAttr::Readonly => true, + _ => false, + } }) } - pub fn js_name(&self) -> Option { + pub fn js_name(&self) -> Option<&Ident> { self.attrs .iter() - .filter_map(|a| match *a { - BindgenAttr::JsName(s) => Some(s), - _ => None, + .filter_map(|a| { + match a { + BindgenAttr::JsName(s) => Some(s), + _ => None, + } }) .next() } @@ -894,14 +919,14 @@ enum BindgenAttr { Catch, Constructor, Method, - JsNamespace(syn::Ident), + JsNamespace(Ident), Module(String), Version(String), - Getter(Option), - Setter(Option), + Getter(Option), + Setter(Option), Structural, Readonly, - JsName(syn::Ident), + JsName(Ident), } impl syn::synom::Synom for BindgenAttr { @@ -995,8 +1020,8 @@ fn extract_first_ty_param(ty: Option<&syn::Type>) -> Option> { } fn term<'a>(cursor: syn::buffer::Cursor<'a>, name: &str) -> syn::synom::PResult<'a, ()> { - if let Some((term, next)) = cursor.term() { - if term.as_str() == name { + if let Some((ident, next)) = cursor.ident() { + if ident == name { return Ok(((), next)); } } @@ -1004,16 +1029,12 @@ fn term<'a>(cursor: syn::buffer::Cursor<'a>, name: &str) -> syn::synom::PResult< } fn term2ident<'a>(cursor: syn::buffer::Cursor<'a>) - -> syn::synom::PResult<'a, syn::Ident> + -> syn::synom::PResult<'a, Ident> { - if let Some((term, next)) = cursor.term() { - let n = term.to_string(); - if !n.starts_with("'") { - let i = syn::Ident::new(&n, term.span()); - return Ok((i, next)); - } + match cursor.ident() { + Some(pair) => Ok(pair), + None => syn::parse_error() } - syn::parse_error() } fn assert_no_lifetimes(decl: &mut syn::FnDecl) { @@ -1029,13 +1050,13 @@ fn assert_no_lifetimes(decl: &mut syn::FnDecl) { syn::visit_mut::VisitMut::visit_fn_decl_mut(&mut Walk, decl); } -fn replace_self(name: syn::Ident, item: &mut syn::ImplItem) { - struct Walk(syn::Ident); +fn replace_self(name: &Ident, item: &mut syn::ImplItem) { + struct Walk<'a>(&'a Ident); - impl syn::visit_mut::VisitMut for Walk { - fn visit_ident_mut(&mut self, i: &mut syn::Ident) { - if i.as_ref() == "Self" { - *i = self.0; + impl<'a> syn::visit_mut::VisitMut for Walk<'a> { + fn visit_ident_mut(&mut self, i: &mut Ident) { + if i == "Self" { + *i = self.0.clone(); } } } diff --git a/crates/backend/src/codegen.rs b/crates/backend/src/codegen.rs index 0bffb2c8..de63b78f 100644 --- a/crates/backend/src/codegen.rs +++ b/crates/backend/src/codegen.rs @@ -4,8 +4,8 @@ use std::env; use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering}; use ast; -use proc_macro2::Span; -use quote::{ToTokens, Tokens}; +use proc_macro2::{Span, Ident, TokenStream}; +use quote::ToTokens; use serde_json; use shared; use syn; @@ -30,7 +30,7 @@ fn to_ident_name(s: &str) -> Cow { impl ToTokens for ast::Program { // Generate wrappers for all the items that we've found - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { for export in self.exports.iter() { export.to_tokens(tokens); } @@ -39,15 +39,15 @@ impl ToTokens for ast::Program { } let mut types = HashSet::new(); for i in self.imports.iter() { - if let ast::ImportKind::Type(ref t) = i.kind { - types.insert(t.name); + if let ast::ImportKind::Type(t) = &i.kind { + types.insert(t.name.clone()); } } for i in self.imports.iter() { DescribeImport(&i.kind).to_tokens(tokens); - if let Some(ns) = i.js_namespace { - if types.contains(&ns) && i.kind.fits_on_impl() { + if let Some(ns) = &i.js_namespace { + if types.contains(ns) && i.kind.fits_on_impl() { let kind = &i.kind; (quote! { impl #ns { #kind } }).to_tokens(tokens); continue @@ -76,7 +76,7 @@ impl ToTokens for ast::Program { to_ident_name(&crate_vers), CNT.fetch_add(1, Ordering::SeqCst) ); - let generated_static_name = syn::Ident::from(generated_static_name); + let generated_static_name = Ident::new(&generated_static_name, Span::call_site()); let description = serde_json::to_string(&self.shared()).unwrap(); @@ -103,12 +103,13 @@ impl ToTokens for ast::Program { } impl ToTokens for ast::Struct { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let name = &self.name; - let name_len = name.as_ref().len() as u32; - let name_chars = name.as_ref().chars().map(|c| c as u32); - let new_fn = syn::Ident::from(shared::new_function(self.name.as_ref())); - let free_fn = syn::Ident::from(shared::free_function(self.name.as_ref())); + let name_str = name.to_string(); + let name_len = name_str.len() as u32; + let name_chars = name_str.chars().map(|c| c as u32); + let new_fn = Ident::new(&shared::new_function(&name_str), Span::call_site()); + let free_fn = Ident::new(&shared::free_function(&name_str), Span::call_site()); (quote! { impl ::wasm_bindgen::describe::WasmDescribe for #name { fn describe() { @@ -230,13 +231,13 @@ impl ToTokens for ast::Struct { } impl ToTokens for ast::StructField { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let name = &self.name; let struct_name = &self.struct_name; let ty = &self.ty; let getter = &self.getter; let setter = &self.setter; - let desc = syn::Ident::from(format!("__wbindgen_describe_{}", getter)); + let desc = Ident::new(&format!("__wbindgen_describe_{}", getter), Span::call_site()); (quote! { #[no_mangle] #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))] @@ -292,17 +293,17 @@ impl ToTokens for ast::StructField { } impl ToTokens for ast::Export { - fn to_tokens(self: &ast::Export, into: &mut Tokens) { + fn to_tokens(self: &ast::Export, into: &mut TokenStream) { let generated_name = self.rust_symbol(); let export_name = self.export_name(); let mut args = vec![]; let mut arg_conversions = vec![]; let mut converted_arguments = vec![]; - let ret = syn::Ident::from("_ret"); + let ret = Ident::new("_ret", Span::call_site()); let mut offset = 0; if self.method { - let class = self.class.unwrap(); + let class = self.class.as_ref().unwrap(); args.push(quote! { me: *mut ::wasm_bindgen::__rt::WasmRefCell<#class> }); arg_conversions.push(quote! { ::wasm_bindgen::__rt::assert_not_null(me); @@ -313,7 +314,7 @@ impl ToTokens for ast::Export { for (i, ty) in self.function.arguments.iter().enumerate() { let i = i + offset; - let ident = syn::Ident::from(format!("arg{}", i)); + let ident = Ident::new(&format!("arg{}", i), Span::call_site()); match *ty { syn::Type::Reference(syn::TypeReference { mutability: Some(_), @@ -359,9 +360,9 @@ impl ToTokens for ast::Export { } let ret_ty; let convert_ret; - match self.function.ret { + match &self.function.ret { Some(syn::Type::Reference(_)) => panic!("can't return a borrowed ref"), - Some(ref ty) => { + Some(ty) => { ret_ty = quote! { -> <#ty as ::wasm_bindgen::convert::IntoWasmAbi>::Abi }; @@ -377,8 +378,8 @@ impl ToTokens for ast::Export { convert_ret = quote!{}; } } - let describe_ret = match self.function.ret { - Some(ref ty) => { + let describe_ret = match &self.function.ret { + Some(ty) => { quote! { inform(1); <#ty as WasmDescribe>::describe(); @@ -387,8 +388,8 @@ impl ToTokens for ast::Export { None => quote! { inform(0); }, }; - let name = self.function.name; - let receiver = match self.class { + let name = &self.function.name; + let receiver = match &self.class { Some(_) if self.method => { if self.mutable { quote! { me.borrow_mut().#name } @@ -400,7 +401,7 @@ impl ToTokens for ast::Export { None => quote!{ #name }, }; let descriptor_name = format!("__wbindgen_describe_{}", export_name); - let descriptor_name = syn::Ident::from(descriptor_name); + let descriptor_name = Ident::new(&descriptor_name, Span::call_site()); let nargs = self.function.arguments.len() as u32; let argtys = self.function.arguments.iter(); @@ -451,7 +452,7 @@ impl ToTokens for ast::Export { } impl ToTokens for ast::ImportKind { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { match *self { ast::ImportKind::Function(ref f) => f.to_tokens(tokens), ast::ImportKind::Static(ref s) => s.to_tokens(tokens), @@ -461,7 +462,7 @@ impl ToTokens for ast::ImportKind { } impl ToTokens for ast::ImportType { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let vis = &self.vis; let name = &self.name; (quote! { @@ -541,7 +542,7 @@ impl ToTokens for ast::ImportType { } impl ToTokens for ast::ImportFunction { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let mut class_ty = None; let mut is_method = false; match self.kind { @@ -561,28 +562,32 @@ impl ToTokens for ast::ImportFunction { let mut abi_argument_names = Vec::new(); let mut abi_arguments = Vec::new(); let mut arg_conversions = Vec::new(); - let ret_ident = syn::Ident::from("_ret"); + let ret_ident = Ident::new("_ret", Span::call_site()); let names = self.function .rust_decl .inputs .iter() - .map(|arg| match *arg { - syn::FnArg::Captured(ref c) => c, - _ => panic!("arguments cannot be `self` or ignored"), + .map(|arg| { + match arg { + syn::FnArg::Captured(c) => c, + _ => panic!("arguments cannot be `self` or ignored"), + } }) - .map(|arg| match arg.pat { - syn::Pat::Ident(syn::PatIdent { - by_ref: None, - ident, - subpat: None, - .. - }) => ident, - _ => panic!("unsupported pattern in foreign function"), + .map(|arg| { + match &arg.pat { + syn::Pat::Ident(syn::PatIdent { + by_ref: None, + ident, + subpat: None, + .. + }) => ident.clone(), + _ => panic!("unsupported pattern in foreign function"), + } }); for (i, (ty, name)) in self.function.arguments.iter().zip(names).enumerate() { - abi_argument_names.push(name); + abi_argument_names.push(name.clone()); abi_arguments.push(quote! { #name: <#ty as ::wasm_bindgen::convert::IntoWasmAbi>::Abi }); @@ -622,9 +627,9 @@ impl ToTokens for ast::ImportFunction { let mut exceptional_ret = quote!{}; let exn_data = if self.function.opts.catch() { - let exn_data = syn::Ident::from("exn_data"); - let exn_data_ptr = syn::Ident::from("exn_data_ptr"); - abi_argument_names.push(exn_data_ptr); + let exn_data = Ident::new("exn_data", Span::call_site()); + let exn_data_ptr = Ident::new("exn_data_ptr", Span::call_site()); + abi_argument_names.push(exn_data_ptr.clone()); abi_arguments.push(quote! { #exn_data_ptr: *mut u32 }); convert_ret = quote! { Ok(#convert_ret) }; exceptional_ret = quote! { @@ -644,8 +649,8 @@ impl ToTokens for ast::ImportFunction { quote! {} }; - let rust_name = self.rust_name; - let import_name = self.shim; + let rust_name = &self.rust_name; + let import_name = &self.shim; let attrs = &self.function.rust_attrs; let arguments = self.function @@ -710,14 +715,14 @@ impl ToTokens for ast::ImportFunction { struct DescribeImport<'a>(&'a ast::ImportKind); impl<'a> ToTokens for DescribeImport<'a> { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let f = match *self.0 { ast::ImportKind::Function(ref f) => f, ast::ImportKind::Static(_) => return, ast::ImportKind::Type(_) => return, }; let describe_name = format!("__wbindgen_describe_{}", f.shim); - let describe_name = syn::Ident::from(describe_name); + let describe_name = Ident::new(&describe_name, Span::call_site()); let argtys = f.function.arguments.iter(); let nargs = f.function.arguments.len() as u32; let inform_ret = match f.function.ret { @@ -739,7 +744,7 @@ impl<'a> ToTokens for DescribeImport<'a> { } impl ToTokens for ast::Enum { - fn to_tokens(&self, into: &mut Tokens) { + fn to_tokens(&self, into: &mut TokenStream) { let enum_name = &self.name; let cast_clauses = self.variants.iter().map(|variant| { let variant_name = &variant.name; @@ -782,10 +787,10 @@ impl ToTokens for ast::Enum { } impl ToTokens for ast::ImportStatic { - fn to_tokens(&self, into: &mut Tokens) { - let name = self.rust_name; + fn to_tokens(&self, into: &mut TokenStream) { + let name = &self.rust_name; let ty = &self.ty; - let shim_name = self.shim; + let shim_name = &self.shim; let vis = &self.vis; (quote! { #[allow(bad_style)] diff --git a/crates/macro/Cargo.toml b/crates/macro/Cargo.toml index 12faf3fb..92a6a18c 100644 --- a/crates/macro/Cargo.toml +++ b/crates/macro/Cargo.toml @@ -17,9 +17,7 @@ proc-macro = true spans = ["wasm-bindgen-backend/spans"] [dependencies] -syn = { version = '0.13', features = ['full'] } -quote = '0.5' -proc-macro2 = "0.3" -serde_json = "1" -wasm-bindgen-shared = { path = "../shared", version = "=0.2.10" } +syn = { version = '0.14', features = ['full'] } +quote = '0.6' +proc-macro2 = "0.4" wasm-bindgen-backend = { path = "../backend", version = "=0.2.10" } diff --git a/crates/macro/src/lib.rs b/crates/macro/src/lib.rs index 7b8eb874..772abd7c 100644 --- a/crates/macro/src/lib.rs +++ b/crates/macro/src/lib.rs @@ -4,12 +4,10 @@ extern crate syn; extern crate quote; extern crate proc_macro; extern crate proc_macro2; -extern crate serde_json; extern crate wasm_bindgen_backend as backend; -extern crate wasm_bindgen_shared as shared; use proc_macro::TokenStream; -use quote::{ToTokens, Tokens}; +use quote::ToTokens; #[proc_macro_attribute] pub fn wasm_bindgen(attr: TokenStream, input: TokenStream) -> TokenStream { @@ -17,7 +15,7 @@ pub fn wasm_bindgen(attr: TokenStream, input: TokenStream) -> TokenStream { let opts = syn::parse::(attr) .expect("invalid arguments to #[wasm_bindgen]"); - let mut ret = Tokens::new(); + let mut ret = proc_macro2::TokenStream::empty(); let mut program = backend::ast::Program::default(); program.push_item(item, Some(opts), &mut ret); program.to_tokens(&mut ret);