Merge branch 'master' into variadic_js_functions

crates/webidl/Cargo.toml

@@ -19,5 +19,5 @@ log = "0.4.1"
 proc-macro2 = "0.4.8"
 quote = '0.6'
 syn = { version = '0.14', features = ['full'] }
-wasm-bindgen-backend = { version = "=0.2.17", path = "../backend" }
+wasm-bindgen-backend = { version = "=0.2.19", path = "../backend" }
 weedle = "0.6"

crates/webidl/src/idl_type.rs

@@ -348,13 +348,13 @@ impl<'a> IdlType<'a> {
             IdlType::UnsignedLong => dst.push_str("u32"),
             IdlType::LongLong => dst.push_str("i64"),
             IdlType::UnsignedLongLong => dst.push_str("u64"),
-            IdlType::Float => dst.push_str("f32"),
-            IdlType::UnrestrictedFloat => dst.push_str("unrestricted_f32"),
-            IdlType::Double => dst.push_str("f64"),
-            IdlType::UnrestrictedDouble => dst.push_str("unrestricted_f64"),
-            IdlType::DomString => dst.push_str("dom_str"),
-            IdlType::ByteString => dst.push_str("byte_str"),
-            IdlType::UsvString => dst.push_str("usv_str"),
+            IdlType::Float |
+            IdlType::UnrestrictedFloat => dst.push_str("f32"),
+            IdlType::Double |
+            IdlType::UnrestrictedDouble => dst.push_str("f64"),
+            IdlType::DomString |
+            IdlType::ByteString |
+            IdlType::UsvString => dst.push_str("str"),
             IdlType::Object => dst.push_str("object"),
             IdlType::Symbol => dst.push_str("symbol"),
             IdlType::Error => dst.push_str("error"),
@@ -459,7 +459,7 @@ impl<'a> IdlType<'a> {
             IdlType::DataView => None,
             IdlType::Int8Array => Some(array("i8", pos)),
             IdlType::Uint8Array => Some(array("u8", pos)),
-            IdlType::Uint8ClampedArray => Some(array("u8", pos)),
+            IdlType::Uint8ClampedArray => None, // FIXME(#421)
             IdlType::Int16Array => Some(array("i16", pos)),
             IdlType::Uint16Array => Some(array("u16", pos)),
             IdlType::Int32Array => Some(array("i32", pos)),

crates/webidl/src/lib.rs

@@ -591,6 +591,11 @@ fn member_attribute<'src>(
 
     let is_structural = util::is_structural(attrs);
     let throws = util::throws(attrs);
+    let global = first_pass
+        .interfaces
+        .get(self_name)
+        .map(|interface_data| interface_data.global)
+        .unwrap_or(false);
 
     for import_function in first_pass.create_getter(
         identifier,
@@ -599,6 +604,7 @@ fn member_attribute<'src>(
         is_static,
         is_structural,
         throws,
+        global,
     ) {
         program.imports.push(wrap_import_function(import_function));
     }
@@ -611,6 +617,7 @@ fn member_attribute<'src>(
             is_static,
             is_structural,
             throws,
+            global,
         ) {
             program.imports.push(wrap_import_function(import_function));
         }
@@ -712,6 +719,12 @@ fn member_operation<'src>(
         operation_ids.push(id);
     }
 
+    let global = first_pass
+        .interfaces
+        .get(self_name)
+        .map(|interface_data| interface_data.global)
+        .unwrap_or(false);
+
     for id in operation_ids {
         let methods = first_pass
             .create_basic_method(
@@ -724,15 +737,10 @@ fn member_operation<'src>(
                     OperationId::IndexingGetter |
                     OperationId::IndexingSetter |
                     OperationId::IndexingDeleter => true,
-                    _ => {
-                        first_pass
-                            .interfaces
-                            .get(self_name)
-                            .map(|interface_data| interface_data.global)
-                            .unwrap_or(false)
-                    }
+                    _ => false,
                 },
                 util::throws(attrs),
+                global,
             );
 
         for method in methods {

crates/webidl/src/util.rs

@@ -273,9 +273,13 @@ impl<'src> FirstPassRecord<'src> {
             let rust_name = if possibilities.len() > 1 {
                 let mut rust_name = rust_name.clone();
                 let mut first = true;
-                for ((argument_name, _, _), idl_type) in arguments.iter().zip(idl_types) {
+                let iter = arguments.iter().zip(idl_types).enumerate();
+                for (i, ((argument_name, _, _), idl_type)) in iter {
+                    if possibilities.iter().all(|p| p.get(i) == Some(idl_type)) {
+                        continue
+                    }
                     if first {
-                        rust_name.push_str("_using_");
+                        rust_name.push_str("_with_");
                         first = false;
                     } else {
                         rust_name.push_str("_and_");
@@ -293,6 +297,7 @@ impl<'src> FirstPassRecord<'src> {
             let rust_name = rust_ident(&rust_name);
             let shim = {
                 let ns = match kind {
+                    backend::ast::ImportFunctionKind::ScopedMethod { .. } |
                     backend::ast::ImportFunctionKind::Normal => "",
                     backend::ast::ImportFunctionKind::Method { ref class, .. } => class,
                 };
@@ -386,6 +391,7 @@ impl<'src> FirstPassRecord<'src> {
         is_static: bool,
         structural: bool,
         catch: bool,
+        global: bool,
     ) -> Vec<backend::ast::ImportFunction> {
         let (overloaded, same_argument_names) = self.get_operation_overloading(
             arguments,
@@ -407,20 +413,26 @@ impl<'src> FirstPassRecord<'src> {
             first_pass::OperationId::IndexingSetter => "set",
             first_pass::OperationId::IndexingDeleter => "delete",
         };
-
-        let kind = backend::ast::ImportFunctionKind::Method {
-            class: self_name.to_string(),
-            ty: ident_ty(rust_ident(camel_case_ident(&self_name).as_str())),
-            kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
-                is_static,
-                kind: match &operation_id {
-                    first_pass::OperationId::Constructor => panic!("constructors are unsupported"),
-                    first_pass::OperationId::Operation(_) => backend::ast::OperationKind::Regular,
-                    first_pass::OperationId::IndexingGetter => backend::ast::OperationKind::IndexingGetter,
-                    first_pass::OperationId::IndexingSetter => backend::ast::OperationKind::IndexingSetter,
-                    first_pass::OperationId::IndexingDeleter => backend::ast::OperationKind::IndexingDeleter,
-                },
-            }),
+        let operation_kind = match &operation_id {
+            first_pass::OperationId::Constructor => panic!("constructors are unsupported"),
+            first_pass::OperationId::Operation(_) => backend::ast::OperationKind::Regular,
+            first_pass::OperationId::IndexingGetter => backend::ast::OperationKind::IndexingGetter,
+            first_pass::OperationId::IndexingSetter => backend::ast::OperationKind::IndexingSetter,
+            first_pass::OperationId::IndexingDeleter => backend::ast::OperationKind::IndexingDeleter,
+        };
+        let operation = backend::ast::Operation { is_static, kind: operation_kind };
+        let ty = ident_ty(rust_ident(camel_case_ident(&self_name).as_str()));
+        let kind = if global {
+            backend::ast::ImportFunctionKind::ScopedMethod {
+                ty,
+                operation,
+            }
+        } else {
+            backend::ast::ImportFunctionKind::Method {
+                class: self_name.to_string(),
+                ty,
+                kind: backend::ast::MethodKind::Operation(operation),
+            }
         };
 
         let ret = match return_type.to_idl_type(self) {
@@ -588,19 +600,29 @@ impl<'src> FirstPassRecord<'src> {
         is_static: bool,
         is_structural: bool,
         catch: bool,
+        global: bool,
     ) -> Vec<backend::ast::ImportFunction> {
         let ret = match ty.to_idl_type(self) {
             None => return Vec::new(),
             Some(idl_type) => idl_type,
         };
+        let operation = backend::ast::Operation {
+            is_static,
+            kind: backend::ast::OperationKind::Getter(Some(raw_ident(name))),
+        };
+        let ty = ident_ty(rust_ident(camel_case_ident(&self_name).as_str()));
 
-        let kind = backend::ast::ImportFunctionKind::Method {
-            class: self_name.to_string(),
-            ty: ident_ty(rust_ident(camel_case_ident(&self_name).as_str())),
-            kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
-                is_static,
-                kind: backend::ast::OperationKind::Getter(Some(raw_ident(name))),
-            }),
+        let kind = if global {
+            backend::ast::ImportFunctionKind::ScopedMethod {
+                ty,
+                operation,
+            }
+        } else {
+            backend::ast::ImportFunctionKind::Method {
+                class: self_name.to_string(),
+                ty,
+                kind: backend::ast::MethodKind::Operation(operation),
+            }
         };
         let doc_comment = Some(format!("The `{}` getter\n\n{}", name, mdn_doc(self_name, Some(name))));
 
@@ -611,19 +633,30 @@ impl<'src> FirstPassRecord<'src> {
     pub fn create_setter(
         &self,
         name: &str,
-        ty: weedle::types::Type,
+        field_ty: weedle::types::Type,
         self_name: &str,
         is_static: bool,
         is_structural: bool,
         catch: bool,
+        global: bool,
     ) -> Vec<backend::ast::ImportFunction> {
-        let kind = backend::ast::ImportFunctionKind::Method {
-            class: self_name.to_string(),
-            ty: ident_ty(rust_ident(camel_case_ident(&self_name).as_str())),
-            kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
-                is_static,
-                kind: backend::ast::OperationKind::Setter(Some(raw_ident(name))),
-            }),
+        let operation = backend::ast::Operation {
+            is_static,
+            kind: backend::ast::OperationKind::Setter(Some(raw_ident(name))),
+        };
+        let ty = ident_ty(rust_ident(camel_case_ident(&self_name).as_str()));
+
+        let kind = if global {
+            backend::ast::ImportFunctionKind::ScopedMethod {
+                ty,
+                operation,
+            }
+        } else {
+            backend::ast::ImportFunctionKind::Method {
+                class: self_name.to_string(),
+                ty,
+                kind: backend::ast::MethodKind::Operation(operation),
+            }
         };
         let doc_comment = Some(format!("The `{}` setter\n\n{}", name, mdn_doc(self_name, Some(name))));
 
@@ -633,7 +666,7 @@ impl<'src> FirstPassRecord<'src> {
             false,
             &[(
                 name,
-                match ty.to_idl_type(self) {
+                match field_ty.to_idl_type(self) {
                     None => return Vec::new(),
                     Some(idl_type) => idl_type,
                 },