fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-06-20 08:16:31 +00:00
Code Issues Projects Releases Wiki Activity

webidl: add support for partial interfaces and mixins

Browse Source 
This is a major change to how webidl is processed. This adds
a two phase process, where the first phase records the names of
various types and indexes the mixins (and might do more in the
future). The actual program building happens in the second phase.

As part of this, this also makes it so that interface objects
are passed by reference, rather than by value. The spec isn't
exactly clear on this, but Mozilla's C++ reflection suggestions
seem to indicate that they should be passed by reference (see
https://developer.mozilla.org/en-US/docs/Mozilla/WebIDL_bindings).
This commit is contained in:
R. Andrew Ohana
2018-07-10 22:59:59 -07:00
parent 7a579be629
commit 5b952f2081
3 changed files with 744 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

358
crates/webidl/src/lib.rs
View File

@ -24,6 +24,7 @@ use std::collections::BTreeSet;
use std::fs;
use std::io::{self, Read};
use std::iter::FromIterator;
use std::mem;
use std::path::Path;
use backend::defined::{ImportedTypeDefinitions, RemoveUndefinedImports};
@ -32,10 +33,7 @@ use failure::ResultExt;
use heck::CamelCase;
use quote::ToTokens;
use util::{
create_basic_method, create_function, create_getter, create_setter, webidl_ty_to_syn_ty,
TypePosition,
};
use util::{public, FirstPass, TypePosition};
/// Either `Ok(t)` or `Err(failure::Error)`.
pub type Result<T> = ::std::result::Result<T, failure::Error>;
@ -96,45 +94,137 @@ trait WebidlParse<Ctx> {
fn webidl_parse(&self, program: &mut backend::ast::Program, context: Ctx) -> Result<()>;
}
impl WebidlParse<()> for Vec<webidl::ast::Definition> {
fn first_pass<'a>(definitions: &'a [webidl::ast::Definition]) -> FirstPass<'a> {
use webidl::ast::*;
let mut first_pass = FirstPass::default();
for def in definitions {
if let Definition::Interface(Interface::NonPartial(NonPartialInterface { name, .. })) = def
{
if first_pass.interfaces.insert(name.clone()) {
warn!("Encountered multiple declarations of {}", name);
}
}
if let Definition::Dictionary(Dictionary::NonPartial(NonPartialDictionary {
name, ..
})) = def
{
if first_pass.dictionaries.insert(name.clone()) {
warn!("Encountered multiple declarations of {}", name);
}
}
if let Definition::Enum(Enum { name, .. }) = def {
if first_pass.enums.insert(name.clone()) {
warn!("Encountered multiple declarations of {}", name);
}
}
if let Definition::Mixin(mixin) = def {
match mixin {
Mixin::NonPartial(mixin) => {
let entry = first_pass
.mixins
.entry(mixin.name.clone())
.or_insert(Default::default());
if mem::replace(&mut entry.non_partial, Some(mixin)).is_some() {
warn!(
"Encounterd multiple declarations of {}, using last encountered",
mixin.name
);
}
}
Mixin::Partial(mixin) => {
let entry = first_pass
.mixins
.entry(mixin.name.clone())
.or_insert(Default::default());
entry.partials.push(mixin);
}
}
}
}
first_pass
}
impl WebidlParse<()> for [webidl::ast::Definition] {
fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
let first_pass = first_pass(self);
for def in self {
def.webidl_parse(program, ())?;
def.webidl_parse(program, &first_pass)?;
}
Ok(())
}
}
impl WebidlParse<()> for webidl::ast::Definition {
fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
match *self {
webidl::ast::Definition::Interface(ref interface) => {
interface.webidl_parse(program, ())
impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::Definition {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
first_pass: &'a FirstPass<'b>,
) -> Result<()> {
match self {
webidl::ast::Definition::Enum(enumeration) => enumeration.webidl_parse(program, ())?,
webidl::ast::Definition::Includes(includes) => {
includes.webidl_parse(program, first_pass)?
}
webidl::ast::Definition::Typedef(ref typedef) => typedef.webidl_parse(program, ()),
webidl::ast::Definition::Enum(ref enumeration) => enumeration.webidl_parse(program, ()),
webidl::ast::Definition::Interface(interface) => {
interface.webidl_parse(program, first_pass)?
}
webidl::ast::Definition::Typedef(typedef) => typedef.webidl_parse(program, first_pass)?,
// TODO
webidl::ast::Definition::Callback(..)
| webidl::ast::Definition::Dictionary(..)
| webidl::ast::Definition::Implements(..)
| webidl::ast::Definition::Includes(..)
| webidl::ast::Definition::Mixin(..)
| webidl::ast::Definition::Namespace(..) => {
warn!("Unsupported WebIDL definition: {:?}", self);
warn!("Unsupported WebIDL definition: {:?}", self)
}
webidl::ast::Definition::Mixin(_) => {
// handled in the first pass
}
}
Ok(())
}
}
}
}
impl WebidlParse<()> for webidl::ast::Interface {
fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
match *self {
webidl::ast::Interface::NonPartial(ref interface) => {
interface.webidl_parse(program, ())
impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::Includes {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
first_pass: &'a FirstPass<'b>,
) -> Result<()> {
match first_pass.mixins.get(&self.includee) {
Some(mixin) => {
if let Some(non_partial) = mixin.non_partial {
for member in &non_partial.members {
member.webidl_parse(program, (&self.includer, first_pass))?;
}
}
for partial in &mixin.partials {
for member in &partial.members {
member.webidl_parse(program, (&self.includer, first_pass))?;
}
}
}
None => warn!("Tried to include missing mixin {}", self.includee),
}
Ok(())
}
}
impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::Interface {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
first_pass: &'a FirstPass<'b>,
) -> Result<()> {
match self {
webidl::ast::Interface::NonPartial(interface) => {
interface.webidl_parse(program, first_pass)
}
webidl::ast::Interface::Partial(interface) => {
interface.webidl_parse(program, first_pass)
}
// TODO
webidl::ast::Interface::Callback(..) | webidl::ast::Interface::Partial(..) => {
webidl::ast::Interface::Callback(..) => {
warn!("Unsupported WebIDL interface: {:?}", self);
Ok(())
}
@ -142,14 +232,18 @@ impl WebidlParse<()> for webidl::ast::Interface {
}
}
impl WebidlParse<()> for webidl::ast::Typedef {
fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::Typedef {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
first_pass: &'a FirstPass,
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
let dest = rust_ident(&self.name);
let src = match webidl_ty_to_syn_ty(&self.type_, TypePosition::Return) {
let dest = rust_ident(self.name.to_camel_case().as_str());
let src = match first_pass.webidl_ty_to_syn_ty(&self.type_, TypePosition::Return) {
Some(src) => src,
None => {
warn!(
@ -161,9 +255,7 @@ impl WebidlParse<()> for webidl::ast::Typedef {
};
program.type_aliases.push(backend::ast::TypeAlias {
vis: syn::Visibility::Public(syn::VisPublic {
pub_token: Default::default(),
}),
vis: public(),
dest,
src,
});
@ -172,8 +264,12 @@ impl WebidlParse<()> for webidl::ast::Typedef {
}
}
impl WebidlParse<()> for webidl::ast::NonPartialInterface {
fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::NonPartialInterface {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
first_pass: &'a FirstPass<'b>,
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
@ -183,34 +279,59 @@ impl WebidlParse<()> for webidl::ast::NonPartialInterface {
version: None,
js_namespace: None,
kind: backend::ast::ImportKind::Type(backend::ast::ImportType {
vis: syn::Visibility::Public(syn::VisPublic {
pub_token: Default::default(),
}),
vis: public(),
name: rust_ident(&self.name),
attrs: Vec::new(),
}),
});
for extended_attribute in &self.extended_attributes {
extended_attribute.webidl_parse(program, self)?;
extended_attribute.webidl_parse(program, (self, first_pass))?;
}
for member in &self.members {
member.webidl_parse(program, &self.name)?;
member.webidl_parse(program, (&self.name, first_pass))?;
}
Ok(())
}
}
impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::ExtendedAttribute {
impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::PartialInterface {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
interface: &'a webidl::ast::NonPartialInterface,
first_pass: &'a FirstPass<'b>,
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
if !first_pass.interfaces.contains(&self.name) {
warn!(
"Partial interface {} missing non-partial interface",
self.name
);
}
for member in &self.members {
member.webidl_parse(program, (&self.name, first_pass))?;
}
Ok(())
}
}
impl<'a, 'b, 'c> WebidlParse<(&'a webidl::ast::NonPartialInterface, &'b FirstPass<'c>)>
for webidl::ast::ExtendedAttribute
{
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
(interface, first_pass): (&'a webidl::ast::NonPartialInterface, &'b FirstPass<'c>),
) -> Result<()> {
let mut add_constructor = |arguments: &[webidl::ast::Argument], class: &str| {
let self_ty = ident_ty(rust_ident(&interface.name));
let self_ty = ident_ty(rust_ident(interface.name.to_camel_case().as_str()));
let kind = backend::ast::ImportFunctionKind::Method {
class: class.to_string(),
@ -234,7 +355,8 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
// > exception**.
let throws = true;
create_function(
first_pass
.create_function(
"new",
arguments
.iter()
@ -243,28 +365,22 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
kind,
structural,
throws,
).map(|function| {
program.imports.push(backend::ast::Import {
module: None,
version: None,
js_namespace: None,
kind: backend::ast::ImportKind::Function(function),
})
})
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
};
match self {
webidl::ast::ExtendedAttribute::ArgumentList(
webidl::ast::ArgumentListExtendedAttribute { arguments, name },
)
if name == "Constructor" =>
) if name == "Constructor" =>
{
add_constructor(arguments, &interface.name);
add_constructor(arguments, &interface.name)
}
webidl::ast::ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name))
if name == "Constructor" =>
{
add_constructor(&[], &interface.name);
add_constructor(&[], &interface.name)
}
webidl::ast::ExtendedAttribute::NamedArgumentList(
webidl::ast::NamedArgumentListExtendedAttribute {
@ -272,10 +388,9 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
rhs_arguments,
rhs_name,
},
)
if lhs_name == "NamedConstructor" =>
) if lhs_name == "NamedConstructor" =>
{
add_constructor(rhs_arguments, rhs_name);
add_constructor(rhs_arguments, rhs_name)
}
webidl::ast::ExtendedAttribute::ArgumentList(_)
| webidl::ast::ExtendedAttribute::Identifier(_)
@ -290,13 +405,15 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
match *self {
webidl::ast::InterfaceMember::Attribute(ref attr) => {
attr.webidl_parse(program, self_name)
}
webidl::ast::InterfaceMember::Operation(ref op) => op.webidl_parse(program, self_name),
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::InterfaceMember {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
context: (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
match self {
webidl::ast::InterfaceMember::Attribute(attr) => attr.webidl_parse(program, context),
webidl::ast::InterfaceMember::Operation(op) => op.webidl_parse(program, context),
// TODO
webidl::ast::InterfaceMember::Const(_)
| webidl::ast::InterfaceMember::Iterable(_)
@ -309,11 +426,32 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::MixinMember {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
context: (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
match self {
webidl::ast::Attribute::Regular(attr) => attr.webidl_parse(program, self_name),
webidl::ast::Attribute::Static(attr) => attr.webidl_parse(program, self_name),
webidl::ast::MixinMember::Attribute(attr) => attr.webidl_parse(program, context),
webidl::ast::MixinMember::Operation(op) => op.webidl_parse(program, context),
// TODO
webidl::ast::MixinMember::Const(_) => {
warn!("Unsupported WebIDL interface member: {:?}", self);
Ok(())
}
}
}
}
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::Attribute {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
context: (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
match self {
webidl::ast::Attribute::Regular(attr) => attr.webidl_parse(program, context),
webidl::ast::Attribute::Static(attr) => attr.webidl_parse(program, context),
// TODO
webidl::ast::Attribute::Stringifier(_) => {
warn!("Unsupported WebIDL attribute: {:?}", self);
@ -323,11 +461,15 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::Operation {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::Operation {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
context: (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
match self {
webidl::ast::Operation::Regular(op) => op.webidl_parse(program, self_name),
webidl::ast::Operation::Static(op) => op.webidl_parse(program, self_name),
webidl::ast::Operation::Regular(op) => op.webidl_parse(program, context),
webidl::ast::Operation::Static(op) => op.webidl_parse(program, context),
// TODO
webidl::ast::Operation::Special(_) | webidl::ast::Operation::Stringifier(_) => {
warn!("Unsupported WebIDL operation: {:?}", self);
@ -337,8 +479,12 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Operation {
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::RegularAttribute {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
(self_name, first_pass): (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
@ -346,25 +492,29 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
let is_structural = util::is_structural(&self.extended_attributes);
let throws = util::throws(&self.extended_attributes);
create_getter(
first_pass
.create_getter(
&self.name,
&self.type_,
self_name,
false,
is_structural,
throws,
).map(wrap_import_function)
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
if !self.read_only {
create_setter(
first_pass
.create_setter(
&self.name,
&self.type_,
self_name,
false,
is_structural,
throws,
).map(wrap_import_function)
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
}
@ -372,8 +522,12 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::StaticAttribute {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
(self_name, first_pass): (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
@ -381,25 +535,29 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
let is_structural = util::is_structural(&self.extended_attributes);
let throws = util::throws(&self.extended_attributes);
create_getter(
first_pass
.create_getter(
&self.name,
&self.type_,
self_name,
true,
is_structural,
throws,
).map(wrap_import_function)
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
if !self.read_only {
create_setter(
first_pass
.create_setter(
&self.name,
&self.type_,
self_name,
true,
is_structural,
throws,
).map(wrap_import_function)
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
}
@ -407,44 +565,56 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::RegularOperation {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::RegularOperation {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
(self_name, first_pass): (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
let throws = util::throws(&self.extended_attributes);
create_basic_method(
first_pass
.create_basic_method(
&self.arguments,
self.name.as_ref(),
&self.return_type,
self_name,
false,
throws,
).map(wrap_import_function)
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
Ok(())
}
}
impl<'a> WebidlParse<&'a str> for webidl::ast::StaticOperation {
fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::StaticOperation {
fn webidl_parse(
&self,
program: &mut backend::ast::Program,
(self_name, first_pass): (&'a str, &'b FirstPass<'c>),
) -> Result<()> {
if util::is_chrome_only(&self.extended_attributes) {
return Ok(());
}
let throws = util::throws(&self.extended_attributes);
create_basic_method(
first_pass
.create_basic_method(
&self.arguments,
self.name.as_ref(),
&self.return_type,
self_name,
true,
throws,
).map(wrap_import_function)
)
.map(wrap_import_function)
.map(|import| program.imports.push(import));
Ok(())
@ -458,9 +628,7 @@ impl<'a> WebidlParse<()> for webidl::ast::Enum {
version: None,
js_namespace: None,
kind: backend::ast::ImportKind::Enum(backend::ast::ImportEnum {
vis: syn::Visibility::Public(syn::VisPublic {
pub_token: Default::default(),
}),
vis: public(),
name: rust_ident(self.name.to_camel_case().as_str()),
variants: self
.variants

229
crates/webidl/src/util.rs
View File

@ -1,8 +1,9 @@
use std::collections::{BTreeMap, BTreeSet};
use std::iter::{self, FromIterator};
use backend;
use backend::util::{ident_ty, leading_colon_path_ty, raw_ident, rust_ident, simple_path_ty};
use heck::SnakeCase;
use heck::{CamelCase, SnakeCase};
use proc_macro2::Ident;
use syn;
use webidl;
@ -17,13 +18,72 @@ fn shared_ref(ty: syn::Type) -> syn::Type {
}.into()
}
fn simple_fn_arg(ident: Ident, ty: syn::Type) -> syn::ArgCaptured {
syn::ArgCaptured {
pat: syn::Pat::Ident(syn::PatIdent {
by_ref: None,
mutability: None,
ident,
subpat: None,
}),
colon_token: Default::default(),
ty,
}
}
fn unit_ty() -> syn::Type {
syn::Type::Tuple(syn::TypeTuple {
paren_token: Default::default(),
elems: syn::punctuated::Punctuated::new(),
})
}
fn result_ty(t: syn::Type) -> syn::Type {
let js_value = leading_colon_path_ty(vec![rust_ident("wasm_bindgen"), rust_ident("JsValue")]);
let arguments = syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
colon2_token: None,
lt_token: Default::default(),
args: FromIterator::from_iter(vec![
syn::GenericArgument::Type(t),
syn::GenericArgument::Type(js_value),
]),
gt_token: Default::default(),
});
let ident = raw_ident("Result");
let seg = syn::PathSegment { ident, arguments };
let path: syn::Path = seg.into();
let ty = syn::TypePath { qself: None, path };
ty.into()
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum TypePosition {
Argument,
Return,
}
pub fn webidl_ty_to_syn_ty(ty: &webidl::ast::Type, pos: TypePosition) -> Option<syn::Type> {
#[derive(Default)]
pub struct FirstPass<'a> {
pub interfaces: BTreeSet<String>,
pub dictionaries: BTreeSet<String>,
pub enums: BTreeSet<String>,
pub mixins: BTreeMap<String, MixinData<'a>>,
}
#[derive(Default)]
pub struct MixinData<'a> {
pub non_partial: Option<&'a webidl::ast::NonPartialMixin>,
pub partials: Vec<&'a webidl::ast::PartialMixin>,
}
impl<'a> FirstPass<'a> {
pub fn webidl_ty_to_syn_ty(
&self,
ty: &webidl::ast::Type,
pos: TypePosition,
) -> Option<syn::Type> {
// nullable types are not yet supported (see issue #14)
if ty.nullable {
return None;
@ -36,7 +96,23 @@ pub fn webidl_ty_to_syn_ty(ty: &webidl::ast::Type, pos: TypePosition) -> Option<
// A reference to a type by name becomes the same thing in the
// bindings.
webidl::ast::TypeKind::Identifier(ref id) => ident_ty(rust_ident(id)),
webidl::ast::TypeKind::Identifier(ref id) => {
let ty = ident_ty(rust_ident(id.to_camel_case().as_str()));
if self.interfaces.contains(id) {
if pos == TypePosition::Argument {
shared_ref(ty)
} else {
ty
}
} else if self.dictionaries.contains(id) {
ty
} else if self.enums.contains(id) {
ty
} else {
warn!("unrecognized type {}", id);
ty
}
}
// Scalars.
webidl::ast::TypeKind::Boolean => ident_ty(raw_ident("bool")),
@ -88,28 +164,16 @@ pub fn webidl_ty_to_syn_ty(ty: &webidl::ast::Type, pos: TypePosition) -> Option<
return None;
}
})
}
fn simple_fn_arg(ident: Ident, ty: syn::Type) -> syn::ArgCaptured {
syn::ArgCaptured {
pat: syn::Pat::Ident(syn::PatIdent {
by_ref: None,
mutability: None,
ident,
subpat: None,
}),
colon_token: Default::default(),
ty,
}
}
fn webidl_arguments_to_syn_arg_captured<'a, I>(
fn webidl_arguments_to_syn_arg_captured<'b, I>(
&self,
arguments: I,
kind: &backend::ast::ImportFunctionKind,
) -> Option<Vec<syn::ArgCaptured>>
where
I: Iterator<Item = (&'a str, &'a webidl::ast::Type, bool)>,
{
) -> Option<Vec<syn::ArgCaptured>>
where
I: Iterator<Item = (&'b str, &'b webidl::ast::Type, bool)>,
{
let estimate = arguments.size_hint();
let len = estimate.1.unwrap_or(estimate.0);
let mut res = if let backend::ast::ImportFunctionKind::Method {
@ -134,7 +198,7 @@ where
return None;
}
match webidl_ty_to_syn_ty(ty, TypePosition::Argument) {
match self.webidl_ty_to_syn_ty(ty, TypePosition::Argument) {
None => {
warn!("Argument's type is not yet supported: {:?}", ty);
return None;
@ -144,50 +208,24 @@ where
}
Some(res)
}
}
fn unit_ty() -> syn::Type {
syn::Type::Tuple(syn::TypeTuple {
paren_token: Default::default(),
elems: syn::punctuated::Punctuated::new(),
})
}
fn result_ty(t: syn::Type) -> syn::Type {
let js_value = leading_colon_path_ty(vec![rust_ident("wasm_bindgen"), rust_ident("JsValue")]);
let arguments = syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
colon2_token: None,
lt_token: Default::default(),
args: FromIterator::from_iter(vec![
syn::GenericArgument::Type(t),
syn::GenericArgument::Type(js_value),
]),
gt_token: Default::default(),
});
let ident = raw_ident("Result");
let seg = syn::PathSegment { ident, arguments };
let path: syn::Path = seg.into();
let ty = syn::TypePath { qself: None, path };
ty.into()
}
pub fn create_function<'a, I>(
pub fn create_function<'b, I>(
&self,
name: &str,
arguments: I,
mut ret: Option<syn::Type>,
kind: backend::ast::ImportFunctionKind,
structural: bool,
catch: bool,
) -> Option<backend::ast::ImportFunction>
where
I: Iterator<Item = (&'a str, &'a webidl::ast::Type, bool)>,
{
) -> Option<backend::ast::ImportFunction>
where
I: Iterator<Item = (&'b str, &'b webidl::ast::Type, bool)>,
{
let rust_name = rust_ident(&name.to_snake_case());
let name = raw_ident(name);
let arguments = webidl_arguments_to_syn_arg_captured(arguments, &kind)?;
let arguments = self.webidl_arguments_to_syn_arg_captured(arguments, &kind)?;
let js_ret = ret.clone();
@ -210,9 +248,7 @@ where
arguments,
ret,
rust_attrs: vec![],
rust_vis: syn::Visibility::Public(syn::VisPublic {
pub_token: Default::default(),
}),
rust_vis: public(),
},
rust_name,
js_ret,
@ -221,16 +257,17 @@ where
kind,
shim,
})
}
}
pub fn create_basic_method(
pub fn create_basic_method(
&self,
arguments: &[webidl::ast::Argument],
name: Option<&String>,
return_type: &webidl::ast::ReturnType,
self_name: &str,
is_static: bool,
catch: bool,
) -> Option<backend::ast::ImportFunction> {
) -> Option<backend::ast::ImportFunction> {
let name = match name {
None => {
warn!("Operations without a name are unsupported");
@ -241,7 +278,7 @@ pub fn create_basic_method(
let kind = backend::ast::ImportFunctionKind::Method {
class: self_name.to_string(),
ty: ident_ty(rust_ident(self_name)),
ty: ident_ty(rust_ident(self_name.to_camel_case().as_str())),
kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
is_static,
kind: backend::ast::OperationKind::Regular,
@ -250,17 +287,18 @@ pub fn create_basic_method(
let ret = match return_type {
webidl::ast::ReturnType::Void => None,
webidl::ast::ReturnType::NonVoid(ty) => match webidl_ty_to_syn_ty(ty, TypePosition::Return)
{
webidl::ast::ReturnType::NonVoid(ty) => {
match self.webidl_ty_to_syn_ty(ty, TypePosition::Return) {
None => {
warn!("Operation's return type is not yet supported: {:?}", ty);
return None;
}
Some(ty) => Some(ty),
},
}
}
};
create_function(
self.create_function(
&name,
arguments
.iter()
@ -270,17 +308,18 @@ pub fn create_basic_method(
false,
catch,
)
}
}
pub fn create_getter(
pub fn create_getter(
&self,
name: &str,
ty: &webidl::ast::Type,
self_name: &str,
is_static: bool,
is_structural: bool,
catch: bool,
) -> Option<backend::ast::ImportFunction> {
let ret = match webidl_ty_to_syn_ty(ty, TypePosition::Return) {
) -> Option<backend::ast::ImportFunction> {
let ret = match self.webidl_ty_to_syn_ty(ty, TypePosition::Return) {
None => {
warn!("Attribute's type does not yet support reading: {:?}", ty);
return None;
@ -290,34 +329,35 @@ pub fn create_getter(
let kind = backend::ast::ImportFunctionKind::Method {
class: self_name.to_string(),
ty: ident_ty(rust_ident(self_name)),
ty: ident_ty(rust_ident(self_name.to_camel_case().as_str())),
kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
is_static,
kind: backend::ast::OperationKind::Getter(Some(raw_ident(name))),
}),
};
create_function(name, iter::empty(), ret, kind, is_structural, catch)
}
self.create_function(name, iter::empty(), ret, kind, is_structural, catch)
}
pub fn create_setter(
pub fn create_setter(
&self,
name: &str,
ty: &webidl::ast::Type,
self_name: &str,
is_static: bool,
is_structural: bool,
catch: bool,
) -> Option<backend::ast::ImportFunction> {
) -> Option<backend::ast::ImportFunction> {
let kind = backend::ast::ImportFunctionKind::Method {
class: self_name.to_string(),
ty: ident_ty(rust_ident(self_name)),
ty: ident_ty(rust_ident(self_name.to_camel_case().as_str())),
kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
is_static,
kind: backend::ast::OperationKind::Setter(Some(raw_ident(name))),
}),
};
create_function(
self.create_function(
&format!("set_{}", name),
iter::once((name, ty, false)),
None,
@ -325,40 +365,37 @@ pub fn create_setter(
is_structural,
catch,
)
}
}
/// ChromeOnly is for things that are only exposed to priveleged code in Firefox.
pub fn is_chrome_only(ext_attrs: &[Box<ExtendedAttribute>]) -> bool {
ext_attrs.iter().any(|external_attribute| {
return match &**external_attribute {
ExtendedAttribute::ArgumentList(al) => al.name == "ChromeOnly",
ExtendedAttribute::Identifier(i) => i.lhs == "ChromeOnly",
ExtendedAttribute::IdentifierList(il) => il.lhs == "ChromeOnly",
ExtendedAttribute::NamedArgumentList(nal) => nal.lhs_name == "ChromeOnly",
ext_attrs.iter().any(|attr| match &**attr {
ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => {
name == "ChromeOnly"
}
ExtendedAttribute::NoArguments(_na) => false,
};
_ => false,
})
}
pub fn is_structural(attrs: &[Box<ExtendedAttribute>]) -> bool {
attrs.iter().any(|attr| {
if let ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(ref name)) = **attr {
attrs.iter().any(|attr| match &**attr {
ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => {
name == "Unforgeable"
} else {
false
}
_ => false,
})
}
pub fn throws(attrs: &[Box<ExtendedAttribute>]) -> bool {
attrs.iter().any(|attr| {
if let ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(ref name)) = **attr {
name == "Throws"
} else {
false
}
attrs.iter().any(|attr| match &**attr {
ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => name == "Throws",
_ => false,
})
}
pub fn public() -> syn::Visibility {
syn::Visibility::Public(syn::VisPublic {
pub_token: Default::default(),
})
}

137
crates/webidl/tests/all/simple.rs
View File

@ -44,14 +44,14 @@ fn method() {
let pi = Foo::new(3.14159).unwrap();
let e = Foo::new(2.71828).unwrap();
// TODO: figure out why the following doesn't fail
// assert!(!pi.my_cmp(Foo::new(3.14159).unwrap()));
let tmp = pi.my_cmp(Foo::new(3.14159).unwrap());
// assert!(!pi.my_cmp(&pi));
let tmp = pi.my_cmp(&pi);
assert!(tmp);
let tmp =!pi.my_cmp(Foo::new(2.71828).unwrap());
let tmp =!pi.my_cmp(&e);
assert!(tmp);
let tmp = !e.my_cmp(Foo::new(3.14159).unwrap());
let tmp = !e.my_cmp(&pi);
assert!(tmp);
let tmp = e.my_cmp(Foo::new(2.71828).unwrap());
let tmp = e.my_cmp(&e);
assert!(tmp);
}
"#,
@ -370,3 +370,130 @@ fn unforgeable_is_structural() {
)
.test();
}
#[test]
fn partial_interface() {
project()
.file(
"foo.webidl",
r#"
[Constructor]
interface Foo {
readonly attribute short un;
short deux();
};
partial interface Foo {
readonly attribute short trois;
short quatre();
};
"#,
)
.file(
"foo.js",
r#"
export class Foo {
get un() {
return 1;
}
deux() {
return 2;
}
get trois() {
return 3;
}
quatre() {
return 4;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
#[wasm_bindgen]
pub fn test() {
let f = foo::Foo::new().unwrap();
assert_eq!(f.un(), 1);
assert_eq!(f.deux(), 2);
assert_eq!(f.trois(), 3);
assert_eq!(f.quatre(), 4);
}
"#,
)
.test();
}
#[test]
fn mixin() {
project()
.file(
"foo.webidl",
r#"
[Constructor(short bar)]
interface Foo {
static attribute short defaultBar;
};
interface mixin Bar {
readonly attribute short bar;
};
partial interface mixin Bar {
void addToBar(short other);
};
Foo includes Bar;
"#,
)
.file(
"foo.js",
r#"
export class Foo {
constructor(bar) {
this._bar = bar | Foo.defaultBar;
}
static get defaultBar() {
return Foo._defaultBar;
}
static set defaultBar(defaultBar) {
Foo._defaultBar = defaultBar;
}
get bar() {
return this._bar;
}
addToBar(other) {
this._bar += other;
}
}
"#,
)
.file(
"src/lib.rs",
r#"
#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
extern crate wasm_bindgen;
use wasm_bindgen::prelude::*;
pub mod foo;
use foo::Foo;
#[wasm_bindgen]
pub fn test() {
let f = Foo::new(1).unwrap();
assert_eq!(f.bar(), 1);
Foo::set_default_bar(7);
f.add_to_bar(Foo::default_bar());
assert_eq!(f.bar(), 8);
}
"#,
)
.test();
}