fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-04-03 19:01:06 +00:00
Code Issues Projects Releases Wiki Activity

Upgrade to new versions of proc-macro2

Browse Source 
Gonna get some nice spans back!
This commit is contained in:
Alex Crichton 2018-05-21 07:29:34 -07:00
parent 627ca1d638
commit e76f5537e0
5 changed files with 212 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crates/backend/Cargo.toml
View File

@ -14,8 +14,8 @@ Backend code generation of the wasm-bindgen tool
spans = [] spans = []
[dependencies] [dependencies]
quote = '0.5' quote = '0.6'
proc-macro2 = "0.3" proc-macro2 = "0.4"
wasm-bindgen-shared = { path = "../shared", version = "=0.2.10" } 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" serde_json = "1.0"

235
crates/backend/src/ast.rs
View File

@ -1,5 +1,5 @@
use proc_macro2::TokenTree; use proc_macro2::{TokenTree, TokenStream, Ident, Span};
use quote::{ToTokens, Tokens}; use quote::ToTokens;
use shared; use shared;
use syn; use syn;
@ -12,7 +12,7 @@ pub struct Program {
} }
pub struct Export { pub struct Export {
pub class: Option<syn::Ident>, pub class: Option<Ident>,
pub method: bool, pub method: bool,
pub mutable: bool, pub mutable: bool,
pub constructor: Option<String>, pub constructor: Option<String>,
@ -22,7 +22,7 @@ pub struct Export {
pub struct Import { pub struct Import {
pub module: Option<String>, pub module: Option<String>,
pub version: Option<String>, pub version: Option<String>,
pub js_namespace: Option<syn::Ident>, pub js_namespace: Option<Ident>,
pub kind: ImportKind, pub kind: ImportKind,
} }
@ -34,9 +34,9 @@ pub enum ImportKind {
pub struct ImportFunction { pub struct ImportFunction {
pub function: Function, pub function: Function,
pub rust_name: syn::Ident, pub rust_name: Ident,
pub kind: ImportFunctionKind, pub kind: ImportFunctionKind,
pub shim: syn::Ident, pub shim: Ident,
} }
pub enum ImportFunctionKind { pub enum ImportFunctionKind {
@ -48,18 +48,18 @@ pub enum ImportFunctionKind {
pub struct ImportStatic { pub struct ImportStatic {
pub vis: syn::Visibility, pub vis: syn::Visibility,
pub ty: syn::Type, pub ty: syn::Type,
pub shim: syn::Ident, pub shim: Ident,
pub rust_name: syn::Ident, pub rust_name: Ident,
pub js_name: syn::Ident, pub js_name: Ident,
} }
pub struct ImportType { pub struct ImportType {
pub vis: syn::Visibility, pub vis: syn::Visibility,
pub name: syn::Ident, pub name: Ident,
} }
pub struct Function { pub struct Function {
pub name: syn::Ident, pub name: Ident,
pub arguments: Vec<syn::Type>, pub arguments: Vec<syn::Type>,
pub ret: Option<syn::Type>, pub ret: Option<syn::Type>,
pub opts: BindgenAttrs, pub opts: BindgenAttrs,
@ -69,26 +69,26 @@ pub struct Function {
} }
pub struct Struct { pub struct Struct {
pub name: syn::Ident, pub name: Ident,
pub fields: Vec<StructField>, pub fields: Vec<StructField>,
} }
pub struct StructField { pub struct StructField {
pub opts: BindgenAttrs, pub opts: BindgenAttrs,
pub name: syn::Ident, pub name: Ident,
pub struct_name: syn::Ident, pub struct_name: Ident,
pub ty: syn::Type, pub ty: syn::Type,
pub getter: syn::Ident, pub getter: Ident,
pub setter: syn::Ident, pub setter: Ident,
} }
pub struct Enum { pub struct Enum {
pub name: syn::Ident, pub name: Ident,
pub variants: Vec<Variant>, pub variants: Vec<Variant>,
} }
pub struct Variant { pub struct Variant {
pub name: syn::Ident, pub name: Ident,
pub value: u32, pub value: u32,
} }
@ -108,7 +108,7 @@ pub enum TypeLocation {
} }
impl Program { impl Program {
pub fn push_item(&mut self, item: syn::Item, opts: Option<BindgenAttrs>, tokens: &mut Tokens) { pub fn push_item(&mut self, item: syn::Item, opts: Option<BindgenAttrs>, tokens: &mut TokenStream) {
match item { match item {
syn::Item::Fn(mut f) => { syn::Item::Fn(mut f) => {
let opts = opts.unwrap_or_else(|| BindgenAttrs::find(&mut f.attrs)); let opts = opts.unwrap_or_else(|| BindgenAttrs::find(&mut f.attrs));
@ -183,11 +183,11 @@ impl Program {
_ => panic!("unsupported self type in impl"), _ => panic!("unsupported self type in impl"),
}; };
for item in item.items.iter_mut() { 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); replace_self(class, item);
let method = match item { let method = match item {
syn::ImplItem::Const(_) => panic!("const definitions aren't supported"), syn::ImplItem::Const(_) => panic!("const definitions aren't supported"),
@ -219,7 +219,7 @@ impl Program {
}; };
let (function, mutable) = Function::from_decl( let (function, mutable) = Function::from_decl(
method.sig.ident, &method.sig.ident,
Box::new(method.sig.decl.clone()), Box::new(method.sig.decl.clone()),
method.attrs.clone(), method.attrs.clone(),
opts, opts,
@ -228,7 +228,7 @@ impl Program {
); );
self.exports.push(Export { self.exports.push(Export {
class: Some(class), class: Some(class.clone()),
method: mutable.is_some(), method: mutable.is_some(),
mutable: mutable.unwrap_or(false), mutable: mutable.unwrap_or(false),
constructor, constructor,
@ -268,7 +268,7 @@ impl Program {
}; };
Variant { Variant {
name: v.ident, name: v.ident.clone(),
value, value,
} }
}) })
@ -297,7 +297,7 @@ impl Program {
}; };
let module = item_opts.module().or(opts.module()).map(|s| s.to_string()); 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 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 { let mut kind = match item {
syn::ForeignItem::Fn(f) => self.push_foreign_fn(f, item_opts), syn::ForeignItem::Fn(f) => self.push_foreign_fn(f, item_opts),
syn::ForeignItem::Type(t) => self.push_foreign_ty(t), 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 { 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( let mut wasm = Function::from_decl(
js_name, &js_name,
f.decl, f.decl,
f.attrs, f.attrs,
opts, opts,
@ -359,7 +359,7 @@ impl Program {
.expect("first argument of method must be a bare type"); .expect("first argument of method must be a bare type");
ImportFunctionKind::Method { ImportFunctionKind::Method {
class: class_name.as_ref().to_string(), class: class_name.to_string(),
ty: class.clone(), ty: class.clone(),
} }
} else if wasm.opts.constructor() { } else if wasm.opts.constructor() {
@ -378,7 +378,7 @@ impl Program {
.expect("first argument of method must be a bare type"); .expect("first argument of method must be a bare type");
ImportFunctionKind::JsConstructor { ImportFunctionKind::JsConstructor {
class: class_name.as_ref().to_string(), class: class_name.to_string(),
ty: class.clone(), ty: class.clone(),
} }
} else { } else {
@ -396,8 +396,8 @@ impl Program {
ImportKind::Function(ImportFunction { ImportKind::Function(ImportFunction {
function: wasm, function: wasm,
kind, kind,
rust_name: f.ident, rust_name: f.ident.clone(),
shim: shim.into(), shim: Ident::new(&shim, Span::call_site()),
}) })
} }
@ -416,14 +416,14 @@ impl Program {
if f.mutability.is_some() { if f.mutability.is_some() {
panic!("cannot import mutable globals yet") 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); let shim = format!("__wbg_static_accessor_{}_{}", js_name, f.ident);
ImportKind::Static(ImportStatic { ImportKind::Static(ImportStatic {
ty: *f.ty, ty: *f.ty,
vis: f.vis, vis: f.vis,
rust_name: f.ident, rust_name: f.ident.clone(),
js_name, js_name: js_name.clone(),
shim: shim.into(), shim: Ident::new(&shim, Span::call_site()),
}) })
} }
@ -453,7 +453,7 @@ impl Function {
} }
Function::from_decl( Function::from_decl(
input.ident, &input.ident,
input.decl, input.decl,
input.attrs, input.attrs,
opts, opts,
@ -463,7 +463,7 @@ impl Function {
} }
pub fn from_decl( pub fn from_decl(
name: syn::Ident, name: &Ident,
mut decl: Box<syn::FnDecl>, mut decl: Box<syn::FnDecl>,
attrs: Vec<syn::Attribute>, attrs: Vec<syn::Attribute>,
opts: BindgenAttrs, opts: BindgenAttrs,
@ -504,7 +504,7 @@ impl Function {
( (
Function { Function {
name, name: name.clone(),
arguments, arguments,
ret, ret,
opts, opts,
@ -518,12 +518,12 @@ impl Function {
fn shared(&self) -> shared::Function { fn shared(&self) -> shared::Function {
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<syn::Ident> { pub fn extract_path_ident(path: &syn::Path) -> Option<Ident> {
if path.leading_colon.is_some() { if path.leading_colon.is_some() {
return None; return None;
} }
@ -534,33 +534,34 @@ pub fn extract_path_ident(path: &syn::Path) -> Option<syn::Ident> {
syn::PathArguments::None => {} syn::PathArguments::None => {}
_ => return None, _ => return None,
} }
path.segments.first().map(|v| v.value().ident) path.segments.first().map(|v| v.value().ident.clone())
} }
impl Export { impl Export {
pub fn rust_symbol(&self) -> syn::Ident { pub fn rust_symbol(&self) -> Ident {
let mut generated_name = format!("__wasm_bindgen_generated"); 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("_");
generated_name.push_str(class.as_ref()); generated_name.push_str(&class.to_string());
} }
generated_name.push_str("_"); generated_name.push_str("_");
generated_name.push_str(self.function.name.as_ref()); generated_name.push_str(&self.function.name.to_string());
syn::Ident::from(generated_name) Ident::new(&generated_name, Span::call_site())
} }
pub fn export_name(&self) -> String { pub fn export_name(&self) -> String {
match self.class { let fn_name = self.function.name.to_string();
match &self.class {
Some(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 { fn shared(&self) -> shared::Export {
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, method: self.method,
constructor: self.constructor.clone(), constructor: self.constructor.clone(),
function: self.function.shared(), function: self.function.shared(),
@ -571,7 +572,7 @@ impl Export {
impl Enum { impl Enum {
fn shared(&self) -> shared::Enum { fn shared(&self) -> shared::Enum {
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(), variants: self.variants.iter().map(|v| v.shared()).collect(),
} }
} }
@ -580,7 +581,7 @@ impl Enum {
impl Variant { impl Variant {
fn shared(&self) -> shared::EnumVariant { fn shared(&self) -> shared::EnumVariant {
shared::EnumVariant { shared::EnumVariant {
name: self.name.as_ref().to_string(), name: self.name.to_string(),
value: self.value, value: self.value,
} }
} }
@ -611,7 +612,7 @@ impl Import {
shared::Import { shared::Import {
module: self.module.clone(), module: self.module.clone(),
version: self.version.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(), kind: self.kind.shared(),
} }
} }
@ -637,11 +638,11 @@ impl ImportKind {
impl ImportFunction { impl ImportFunction {
pub fn infer_getter_property(&self) -> String { 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 { 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_`"); assert!(name.starts_with("set_"), "setters must start with `set_`");
name[4..].to_string() name[4..].to_string()
} }
@ -673,7 +674,7 @@ impl ImportFunction {
setter = Some(s.unwrap_or_else(|| self.infer_setter_property())); setter = Some(s.unwrap_or_else(|| self.infer_setter_property()));
} }
shared::ImportFunction { shared::ImportFunction {
shim: self.shim.as_ref().to_string(), shim: self.shim.to_string(),
catch: self.function.opts.catch(), catch: self.function.opts.catch(),
method, method,
js_new, js_new,
@ -689,8 +690,8 @@ impl ImportFunction {
impl ImportStatic { impl ImportStatic {
fn shared(&self) -> shared::ImportStatic { fn shared(&self) -> shared::ImportStatic {
shared::ImportStatic { shared::ImportStatic {
name: self.js_name.as_ref().to_string(), name: self.js_name.to_string(),
shim: self.shim.as_ref().to_string(), shim: self.shim.to_string(),
} }
} }
} }
@ -710,32 +711,34 @@ impl Struct {
syn::Visibility::Public(..) => {} syn::Visibility::Public(..) => {}
_ => continue, _ => continue,
} }
let name = match field.ident { let name = match &field.ident {
Some(n) => n, Some(n) => n,
None => continue, None => continue,
}; };
let getter = shared::struct_field_get(s.ident.as_ref(), name.as_ref()); let ident = s.ident.to_string();
let setter = shared::struct_field_set(s.ident.as_ref(), name.as_ref()); 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); let opts = BindgenAttrs::find(&mut field.attrs);
fields.push(StructField { fields.push(StructField {
opts, opts,
name, name: name.clone(),
struct_name: s.ident, struct_name: s.ident.clone(),
ty: field.ty.clone(), ty: field.ty.clone(),
getter: getter.into(), getter: Ident::new(&getter, Span::call_site()),
setter: setter.into(), setter: Ident::new(&setter, Span::call_site()),
}); });
} }
} }
Struct { Struct {
name: s.ident, name: s.ident.clone(),
fields, fields,
} }
} }
fn shared(&self) -> shared::Struct { fn shared(&self) -> shared::Struct {
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(), fields: self.fields.iter().map(|s| s.shared()).collect(),
} }
} }
@ -744,7 +747,7 @@ impl Struct {
impl StructField { impl StructField {
fn shared(&self) -> shared::StructField { fn shared(&self) -> shared::StructField {
shared::StructField { shared::StructField {
name: self.name.as_ref().to_string(), name: self.name.to_string(),
readonly: self.opts.readonly(), readonly: self.opts.readonly(),
} }
} }
@ -781,9 +784,11 @@ impl BindgenAttrs {
fn module(&self) -> Option<&str> { fn module(&self) -> Option<&str> {
self.attrs self.attrs
.iter() .iter()
.filter_map(|a| match *a { .filter_map(|a| {
BindgenAttr::Module(ref s) => Some(&s[..]), match a {
BindgenAttr::Module(s) => Some(&s[..]),
_ => None, _ => None,
}
}) })
.next() .next()
} }
@ -791,84 +796,104 @@ impl BindgenAttrs {
fn version(&self) -> Option<&str> { fn version(&self) -> Option<&str> {
self.attrs self.attrs
.iter() .iter()
.filter_map(|a| match *a { .filter_map(|a| {
BindgenAttr::Version(ref s) => Some(&s[..]), match a {
BindgenAttr::Version(s) => Some(&s[..]),
_ => None, _ => None,
}
}) })
.next() .next()
} }
pub fn catch(&self) -> bool { pub fn catch(&self) -> bool {
self.attrs.iter().any(|a| match *a { self.attrs.iter().any(|a| {
match a {
BindgenAttr::Catch => true, BindgenAttr::Catch => true,
_ => false, _ => false,
}
}) })
} }
fn constructor(&self) -> bool { fn constructor(&self) -> bool {
self.attrs.iter().any(|a| match *a { self.attrs.iter().any(|a| {
match a {
BindgenAttr::Constructor => true, BindgenAttr::Constructor => true,
_ => false, _ => false,
}
}) })
} }
fn method(&self) -> bool { fn method(&self) -> bool {
self.attrs.iter().any(|a| match *a { self.attrs.iter().any(|a| {
match a {
BindgenAttr::Method => true, BindgenAttr::Method => true,
_ => false, _ => false,
}
}) })
} }
fn js_namespace(&self) -> Option<syn::Ident> { fn js_namespace(&self) -> Option<&Ident> {
self.attrs self.attrs
.iter() .iter()
.filter_map(|a| match *a { .filter_map(|a| {
match a {
BindgenAttr::JsNamespace(s) => Some(s), BindgenAttr::JsNamespace(s) => Some(s),
_ => None, _ => None,
}
}) })
.next() .next()
} }
pub fn getter(&self) -> Option<Option<syn::Ident>> { pub fn getter(&self) -> Option<Option<&Ident>> {
self.attrs self.attrs
.iter() .iter()
.filter_map(|a| match *a { .filter_map(|a| {
BindgenAttr::Getter(s) => Some(s), match a {
BindgenAttr::Getter(s) => Some(s.as_ref()),
_ => None, _ => None,
}
}) })
.next() .next()
} }
pub fn setter(&self) -> Option<Option<syn::Ident>> { pub fn setter(&self) -> Option<Option<&Ident>> {
self.attrs self.attrs
.iter() .iter()
.filter_map(|a| match *a { .filter_map(|a| {
BindgenAttr::Setter(s) => Some(s), match a {
BindgenAttr::Setter(s) => Some(s.as_ref()),
_ => None, _ => None,
}
}) })
.next() .next()
} }
pub fn structural(&self) -> bool { pub fn structural(&self) -> bool {
self.attrs.iter().any(|a| match *a { self.attrs.iter().any(|a| {
match *a {
BindgenAttr::Structural => true, BindgenAttr::Structural => true,
_ => false, _ => false,
}
}) })
} }
pub fn readonly(&self) -> bool { pub fn readonly(&self) -> bool {
self.attrs.iter().any(|a| match *a { self.attrs.iter().any(|a| {
match *a {
BindgenAttr::Readonly => true, BindgenAttr::Readonly => true,
_ => false, _ => false,
}
}) })
} }
pub fn js_name(&self) -> Option<syn::Ident> { pub fn js_name(&self) -> Option<&Ident> {
self.attrs self.attrs
.iter() .iter()
.filter_map(|a| match *a { .filter_map(|a| {
match a {
BindgenAttr::JsName(s) => Some(s), BindgenAttr::JsName(s) => Some(s),
_ => None, _ => None,
}
}) })
.next() .next()
} }
@ -894,14 +919,14 @@ enum BindgenAttr {
Catch, Catch,
Constructor, Constructor,
Method, Method,
JsNamespace(syn::Ident), JsNamespace(Ident),
Module(String), Module(String),
Version(String), Version(String),
Getter(Option<syn::Ident>), Getter(Option<Ident>),
Setter(Option<syn::Ident>), Setter(Option<Ident>),
Structural, Structural,
Readonly, Readonly,
JsName(syn::Ident), JsName(Ident),
} }
impl syn::synom::Synom for BindgenAttr { impl syn::synom::Synom for BindgenAttr {
@ -995,8 +1020,8 @@ fn extract_first_ty_param(ty: Option<&syn::Type>) -> Option<Option<syn::Type>> {
} }
fn term<'a>(cursor: syn::buffer::Cursor<'a>, name: &str) -> syn::synom::PResult<'a, ()> { fn term<'a>(cursor: syn::buffer::Cursor<'a>, name: &str) -> syn::synom::PResult<'a, ()> {
if let Some((term, next)) = cursor.term() { if let Some((ident, next)) = cursor.ident() {
if term.as_str() == name { if ident == name {
return Ok(((), next)); return Ok(((), next));
} }
} }
@ -1004,17 +1029,13 @@ fn term<'a>(cursor: syn::buffer::Cursor<'a>, name: &str) -> syn::synom::PResult<
} }
fn term2ident<'a>(cursor: syn::buffer::Cursor<'a>) 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() { match cursor.ident() {
let n = term.to_string(); Some(pair) => Ok(pair),
if !n.starts_with("'") { None => syn::parse_error()
let i = syn::Ident::new(&n, term.span());
return Ok((i, next));
} }
} }
syn::parse_error()
}
fn assert_no_lifetimes(decl: &mut syn::FnDecl) { fn assert_no_lifetimes(decl: &mut syn::FnDecl) {
struct Walk; struct Walk;
@ -1029,13 +1050,13 @@ fn assert_no_lifetimes(decl: &mut syn::FnDecl) {
syn::visit_mut::VisitMut::visit_fn_decl_mut(&mut Walk, decl); syn::visit_mut::VisitMut::visit_fn_decl_mut(&mut Walk, decl);
} }
fn replace_self(name: syn::Ident, item: &mut syn::ImplItem) { fn replace_self(name: &Ident, item: &mut syn::ImplItem) {
struct Walk(syn::Ident); struct Walk<'a>(&'a Ident);
impl syn::visit_mut::VisitMut for Walk { impl<'a> syn::visit_mut::VisitMut for Walk<'a> {
fn visit_ident_mut(&mut self, i: &mut syn::Ident) { fn visit_ident_mut(&mut self, i: &mut Ident) {
if i.as_ref() == "Self" { if i == "Self" {
*i = self.0; *i = self.0.clone();
} }
} }
} }

97
crates/backend/src/codegen.rs
View File

@ -4,8 +4,8 @@ use std::env;
use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering}; use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering};
use ast; use ast;
use proc_macro2::Span; use proc_macro2::{Span, Ident, TokenStream};
use quote::{ToTokens, Tokens}; use quote::ToTokens;
use serde_json; use serde_json;
use shared; use shared;
use syn; use syn;
@ -30,7 +30,7 @@ fn to_ident_name(s: &str) -> Cow<str> {
impl ToTokens for ast::Program { impl ToTokens for ast::Program {
// Generate wrappers for all the items that we've found // 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() { for export in self.exports.iter() {
export.to_tokens(tokens); export.to_tokens(tokens);
} }
@ -39,15 +39,15 @@ impl ToTokens for ast::Program {
} }
let mut types = HashSet::new(); let mut types = HashSet::new();
for i in self.imports.iter() { for i in self.imports.iter() {
if let ast::ImportKind::Type(ref t) = i.kind { if let ast::ImportKind::Type(t) = &i.kind {
types.insert(t.name); types.insert(t.name.clone());
} }
} }
for i in self.imports.iter() { for i in self.imports.iter() {
DescribeImport(&i.kind).to_tokens(tokens); DescribeImport(&i.kind).to_tokens(tokens);
if let Some(ns) = i.js_namespace { if let Some(ns) = &i.js_namespace {
if types.contains(&ns) && i.kind.fits_on_impl() { if types.contains(ns) && i.kind.fits_on_impl() {
let kind = &i.kind; let kind = &i.kind;
(quote! { impl #ns { #kind } }).to_tokens(tokens); (quote! { impl #ns { #kind } }).to_tokens(tokens);
continue continue
@ -76,7 +76,7 @@ impl ToTokens for ast::Program {
to_ident_name(&crate_vers), to_ident_name(&crate_vers),
CNT.fetch_add(1, Ordering::SeqCst) 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(); let description = serde_json::to_string(&self.shared()).unwrap();
@ -103,12 +103,13 @@ impl ToTokens for ast::Program {
} }
impl ToTokens for ast::Struct { 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 = &self.name;
let name_len = name.as_ref().len() as u32; let name_str = name.to_string();
let name_chars = name.as_ref().chars().map(|c| c as u32); let name_len = name_str.len() as u32;
let new_fn = syn::Ident::from(shared::new_function(self.name.as_ref())); let name_chars = name_str.chars().map(|c| c as u32);
let free_fn = syn::Ident::from(shared::free_function(self.name.as_ref())); 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! { (quote! {
impl ::wasm_bindgen::describe::WasmDescribe for #name { impl ::wasm_bindgen::describe::WasmDescribe for #name {
fn describe() { fn describe() {
@ -230,13 +231,13 @@ impl ToTokens for ast::Struct {
} }
impl ToTokens for ast::StructField { impl ToTokens for ast::StructField {
fn to_tokens(&self, tokens: &mut Tokens) { fn to_tokens(&self, tokens: &mut TokenStream) {
let name = &self.name; let name = &self.name;
let struct_name = &self.struct_name; let struct_name = &self.struct_name;
let ty = &self.ty; let ty = &self.ty;
let getter = &self.getter; let getter = &self.getter;
let setter = &self.setter; 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! { (quote! {
#[no_mangle] #[no_mangle]
#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))] #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
@ -292,17 +293,17 @@ impl ToTokens for ast::StructField {
} }
impl ToTokens for ast::Export { 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 generated_name = self.rust_symbol();
let export_name = self.export_name(); let export_name = self.export_name();
let mut args = vec![]; let mut args = vec![];
let mut arg_conversions = vec![]; let mut arg_conversions = vec![];
let mut converted_arguments = vec![]; let mut converted_arguments = vec![];
let ret = syn::Ident::from("_ret"); let ret = Ident::new("_ret", Span::call_site());
let mut offset = 0; let mut offset = 0;
if self.method { 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> }); args.push(quote! { me: *mut ::wasm_bindgen::__rt::WasmRefCell<#class> });
arg_conversions.push(quote! { arg_conversions.push(quote! {
::wasm_bindgen::__rt::assert_not_null(me); ::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() { for (i, ty) in self.function.arguments.iter().enumerate() {
let i = i + offset; let i = i + offset;
let ident = syn::Ident::from(format!("arg{}", i)); let ident = Ident::new(&format!("arg{}", i), Span::call_site());
match *ty { match *ty {
syn::Type::Reference(syn::TypeReference { syn::Type::Reference(syn::TypeReference {
mutability: Some(_), mutability: Some(_),
@ -359,9 +360,9 @@ impl ToTokens for ast::Export {
} }
let ret_ty; let ret_ty;
let convert_ret; let convert_ret;
match self.function.ret { match &self.function.ret {
Some(syn::Type::Reference(_)) => panic!("can't return a borrowed ref"), Some(syn::Type::Reference(_)) => panic!("can't return a borrowed ref"),
Some(ref ty) => { Some(ty) => {
ret_ty = quote! { ret_ty = quote! {
-> <#ty as ::wasm_bindgen::convert::IntoWasmAbi>::Abi -> <#ty as ::wasm_bindgen::convert::IntoWasmAbi>::Abi
}; };
@ -377,8 +378,8 @@ impl ToTokens for ast::Export {
convert_ret = quote!{}; convert_ret = quote!{};
} }
} }
let describe_ret = match self.function.ret { let describe_ret = match &self.function.ret {
Some(ref ty) => { Some(ty) => {
quote! { quote! {
inform(1); inform(1);
<#ty as WasmDescribe>::describe(); <#ty as WasmDescribe>::describe();
@ -387,8 +388,8 @@ impl ToTokens for ast::Export {
None => quote! { inform(0); }, None => quote! { inform(0); },
}; };
let name = self.function.name; let name = &self.function.name;
let receiver = match self.class { let receiver = match &self.class {
Some(_) if self.method => { Some(_) if self.method => {
if self.mutable { if self.mutable {
quote! { me.borrow_mut().#name } quote! { me.borrow_mut().#name }
@ -400,7 +401,7 @@ impl ToTokens for ast::Export {
None => quote!{ #name }, None => quote!{ #name },
}; };
let descriptor_name = format!("__wbindgen_describe_{}", export_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 nargs = self.function.arguments.len() as u32;
let argtys = self.function.arguments.iter(); let argtys = self.function.arguments.iter();
@ -451,7 +452,7 @@ impl ToTokens for ast::Export {
} }
impl ToTokens for ast::ImportKind { impl ToTokens for ast::ImportKind {
fn to_tokens(&self, tokens: &mut Tokens) { fn to_tokens(&self, tokens: &mut TokenStream) {
match *self { match *self {
ast::ImportKind::Function(ref f) => f.to_tokens(tokens), ast::ImportKind::Function(ref f) => f.to_tokens(tokens),
ast::ImportKind::Static(ref s) => s.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 { impl ToTokens for ast::ImportType {
fn to_tokens(&self, tokens: &mut Tokens) { fn to_tokens(&self, tokens: &mut TokenStream) {
let vis = &self.vis; let vis = &self.vis;
let name = &self.name; let name = &self.name;
(quote! { (quote! {
@ -541,7 +542,7 @@ impl ToTokens for ast::ImportType {
} }
impl ToTokens for ast::ImportFunction { 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 class_ty = None;
let mut is_method = false; let mut is_method = false;
match self.kind { match self.kind {
@ -561,28 +562,32 @@ impl ToTokens for ast::ImportFunction {
let mut abi_argument_names = Vec::new(); let mut abi_argument_names = Vec::new();
let mut abi_arguments = Vec::new(); let mut abi_arguments = Vec::new();
let mut arg_conversions = 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 let names = self.function
.rust_decl .rust_decl
.inputs .inputs
.iter() .iter()
.map(|arg| match *arg { .map(|arg| {
syn::FnArg::Captured(ref c) => c, match arg {
syn::FnArg::Captured(c) => c,
_ => panic!("arguments cannot be `self` or ignored"), _ => panic!("arguments cannot be `self` or ignored"),
}
}) })
.map(|arg| match arg.pat { .map(|arg| {
match &arg.pat {
syn::Pat::Ident(syn::PatIdent { syn::Pat::Ident(syn::PatIdent {
by_ref: None, by_ref: None,
ident, ident,
subpat: None, subpat: None,
.. ..
}) => ident, }) => ident.clone(),
_ => panic!("unsupported pattern in foreign function"), _ => panic!("unsupported pattern in foreign function"),
}
}); });
for (i, (ty, name)) in self.function.arguments.iter().zip(names).enumerate() { 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! { abi_arguments.push(quote! {
#name: <#ty as ::wasm_bindgen::convert::IntoWasmAbi>::Abi #name: <#ty as ::wasm_bindgen::convert::IntoWasmAbi>::Abi
}); });
@ -622,9 +627,9 @@ impl ToTokens for ast::ImportFunction {
let mut exceptional_ret = quote!{}; let mut exceptional_ret = quote!{};
let exn_data = if self.function.opts.catch() { let exn_data = if self.function.opts.catch() {
let exn_data = syn::Ident::from("exn_data"); let exn_data = Ident::new("exn_data", Span::call_site());
let exn_data_ptr = syn::Ident::from("exn_data_ptr"); let exn_data_ptr = Ident::new("exn_data_ptr", Span::call_site());
abi_argument_names.push(exn_data_ptr); abi_argument_names.push(exn_data_ptr.clone());
abi_arguments.push(quote! { #exn_data_ptr: *mut u32 }); abi_arguments.push(quote! { #exn_data_ptr: *mut u32 });
convert_ret = quote! { Ok(#convert_ret) }; convert_ret = quote! { Ok(#convert_ret) };
exceptional_ret = quote! { exceptional_ret = quote! {
@ -644,8 +649,8 @@ impl ToTokens for ast::ImportFunction {
quote! {} quote! {}
}; };
let rust_name = self.rust_name; let rust_name = &self.rust_name;
let import_name = self.shim; let import_name = &self.shim;
let attrs = &self.function.rust_attrs; let attrs = &self.function.rust_attrs;
let arguments = self.function let arguments = self.function
@ -710,14 +715,14 @@ impl ToTokens for ast::ImportFunction {
struct DescribeImport<'a>(&'a ast::ImportKind); struct DescribeImport<'a>(&'a ast::ImportKind);
impl<'a> ToTokens for DescribeImport<'a> { 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 { let f = match *self.0 {
ast::ImportKind::Function(ref f) => f, ast::ImportKind::Function(ref f) => f,
ast::ImportKind::Static(_) => return, ast::ImportKind::Static(_) => return,
ast::ImportKind::Type(_) => return, ast::ImportKind::Type(_) => return,
}; };
let describe_name = format!("__wbindgen_describe_{}", f.shim); 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 argtys = f.function.arguments.iter();
let nargs = f.function.arguments.len() as u32; let nargs = f.function.arguments.len() as u32;
let inform_ret = match f.function.ret { let inform_ret = match f.function.ret {
@ -739,7 +744,7 @@ impl<'a> ToTokens for DescribeImport<'a> {
} }
impl ToTokens for ast::Enum { 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 enum_name = &self.name;
let cast_clauses = self.variants.iter().map(|variant| { let cast_clauses = self.variants.iter().map(|variant| {
let variant_name = &variant.name; let variant_name = &variant.name;
@ -782,10 +787,10 @@ impl ToTokens for ast::Enum {
} }
impl ToTokens for ast::ImportStatic { impl ToTokens for ast::ImportStatic {
fn to_tokens(&self, into: &mut Tokens) { fn to_tokens(&self, into: &mut TokenStream) {
let name = self.rust_name; let name = &self.rust_name;
let ty = &self.ty; let ty = &self.ty;
let shim_name = self.shim; let shim_name = &self.shim;
let vis = &self.vis; let vis = &self.vis;
(quote! { (quote! {
#[allow(bad_style)] #[allow(bad_style)]

8
crates/macro/Cargo.toml
View File

@ -17,9 +17,7 @@ proc-macro = true
spans = ["wasm-bindgen-backend/spans"] spans = ["wasm-bindgen-backend/spans"]
[dependencies] [dependencies]
syn = { version = '0.13', features = ['full'] } syn = { version = '0.14', features = ['full'] }
quote = '0.5' quote = '0.6'
proc-macro2 = "0.3" proc-macro2 = "0.4"
serde_json = "1"
wasm-bindgen-shared = { path = "../shared", version = "=0.2.10" }
wasm-bindgen-backend = { path = "../backend", version = "=0.2.10" } wasm-bindgen-backend = { path = "../backend", version = "=0.2.10" }

6
crates/macro/src/lib.rs
View File

@ -4,12 +4,10 @@ extern crate syn;
extern crate quote; extern crate quote;
extern crate proc_macro; extern crate proc_macro;
extern crate proc_macro2; extern crate proc_macro2;
extern crate serde_json;
extern crate wasm_bindgen_backend as backend; extern crate wasm_bindgen_backend as backend;
extern crate wasm_bindgen_shared as shared;
use proc_macro::TokenStream; use proc_macro::TokenStream;
use quote::{ToTokens, Tokens}; use quote::ToTokens;
#[proc_macro_attribute] #[proc_macro_attribute]
pub fn wasm_bindgen(attr: TokenStream, input: TokenStream) -> TokenStream { 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::<backend::ast::BindgenAttrs>(attr) let opts = syn::parse::<backend::ast::BindgenAttrs>(attr)
.expect("invalid arguments to #[wasm_bindgen]"); .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(); let mut program = backend::ast::Program::default();
program.push_item(item, Some(opts), &mut ret); program.push_item(item, Some(opts), &mut ret);
program.to_tokens(&mut ret); program.to_tokens(&mut ret);