Merge remote-tracking branch 'origin/master' into webidl_partial_mixins

Author: ohanar

crates/backend/src/ast.rs

@@ -42,6 +42,7 @@ pub enum ImportKind {
     Static(ImportStatic),
     Type(ImportType),
     Enum(ImportEnum),
+    Const(Const),
 }
 
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
@@ -174,6 +175,24 @@ pub struct TypeAlias {
     pub src: syn::Type,
 }
 
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+pub struct Const {
+    pub vis: syn::Visibility,
+    pub name: Ident,
+    pub interface_name: Ident,
+    pub ty: syn::Type,
+    pub value: ConstValue,
+}
+
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+/// same as webidl::ast::ConstValue
+pub enum ConstValue {
+    BooleanLiteral(bool),
+    FloatLiteral(f64),
+    IntegerLiteral(i64),
+    Null,
+}
+
 impl Program {
     pub(crate) fn shared(&self) -> shared::Program {
         shared::Program {
@@ -293,6 +312,7 @@ impl ImportKind {
             ImportKind::Static(_) => false,
             ImportKind::Type(_) => false,
             ImportKind::Enum(_) => false,
+            ImportKind::Const(_) => false,
         }
     }
 
@@ -302,6 +322,7 @@ impl ImportKind {
             ImportKind::Static(ref f) => shared::ImportKind::Static(f.shared()),
             ImportKind::Type(ref f) => shared::ImportKind::Type(f.shared()),
             ImportKind::Enum(ref f) => shared::ImportKind::Enum(f.shared()),
+            ImportKind::Const(ref f) => shared::ImportKind::Const(f.shared()),
         }
     }
 }
@@ -404,3 +425,9 @@ impl StructField {
         }
     }
 }
+
+impl Const {
+    fn shared(&self) -> shared::Const {
+        shared::Const {}
+    }
+}

crates/backend/src/codegen.rs

@@ -501,6 +501,7 @@ impl ToTokens for ast::ImportKind {
             ast::ImportKind::Static(ref s) => s.to_tokens(tokens),
             ast::ImportKind::Type(ref t) => t.to_tokens(tokens),
             ast::ImportKind::Enum(ref e) => e.to_tokens(tokens),
+            ast::ImportKind::Const(ref c) => c.to_tokens(tokens),
         }
     }
 }
@@ -842,6 +843,7 @@ impl<'a> ToTokens for DescribeImport<'a> {
             ast::ImportKind::Static(_) => return,
             ast::ImportKind::Type(_) => return,
             ast::ImportKind::Enum(_) => return,
+            ast::ImportKind::Const(_) => return,
         };
         let describe_name = format!("__wbindgen_describe_{}", f.shim);
         let describe_name = Ident::new(&describe_name, Span::call_site());
@@ -958,3 +960,41 @@ impl ToTokens for ast::TypeAlias {
         }).to_tokens(into);
     }
 }
+
+impl ToTokens for ast::Const {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        use ast::ConstValue::*;
+
+        let vis = &self.vis;
+        let name = &self.name;
+        let interface_name = &self.interface_name;
+        let ty = &self.ty;
+
+        let value: TokenStream = match self.value {
+            BooleanLiteral(false) => quote!(false),
+            BooleanLiteral(true) => quote!(true),
+            // the actual type is unknown because of typedefs
+            // so we cannot use std::fxx::INFINITY
+            // but we can use type inference
+            FloatLiteral(f) if f.is_infinite() && f.is_sign_positive() => quote!(1.0 / 0.0),
+            FloatLiteral(f) if f.is_infinite() && f.is_sign_negative() => quote!(-1.0 / 0.0),
+            FloatLiteral(f) if f.is_nan() => quote!(0.0 / 0.0),
+            // again no suffix
+            // panics on +-inf, nan
+            FloatLiteral(f) => {
+                let f = Literal::f64_unsuffixed(f);
+                quote!(#f)
+            },
+            IntegerLiteral(i) => {
+                let i = Literal::i64_unsuffixed(i);
+                quote!(#i)
+            },
+            Null => unimplemented!(),
+        };
+        (quote! {
+            impl #interface_name {
+                #vis const #name: #ty = #value;
+            }
+        }).to_tokens(tokens);
+    }
+}

crates/backend/src/defined.rs

@@ -106,6 +106,7 @@ impl ImportedTypes for ast::ImportKind {
             ast::ImportKind::Function(fun) => fun.imported_types(f),
             ast::ImportKind::Type(ty) => ty.imported_types(f),
             ast::ImportKind::Enum(enm) => enm.imported_types(f),
+            ast::ImportKind::Const(c) => c.imported_types(f),
         }
     }
 }
@@ -229,6 +230,15 @@ impl ImportedTypes for ast::TypeAlias {
     }
 }
 
+impl ImportedTypes for ast::Const {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.ty.imported_types(f);
+    }
+}
+
 /// Remove any methods, statics, &c, that reference types that are *not*
 /// defined.
 pub trait RemoveUndefinedImports {

crates/cli-support/Cargo.toml

@@ -19,5 +19,5 @@ serde_derive = "1.0"
 serde_json = "1.0"
 tempfile = "3.0"
 wasm-bindgen-shared = { path = "../shared", version = '=0.2.11' }
-wasm-gc-api = "0.1"
+wasm-gc-api = "0.1.8"
 wasmi = "0.3"

crates/cli-support/src/js/mod.rs

@@ -1580,6 +1580,7 @@ impl<'a> Context<'a> {
         let wasm_bytes = parity_wasm::serialize(module)?;
         let bytes = wasm_gc::Config::new()
             .demangle(self.config.demangle)
+            .keep_debug(self.config.keep_debug || self.config.debug)
             .gc(&wasm_bytes)?;
         *self.module = deserialize_buffer(&bytes)?;
         Ok(())
@@ -1757,6 +1758,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
             }
             shared::ImportKind::Type(_) => {}
             shared::ImportKind::Enum(_) => {}
+            shared::ImportKind::Const(_) => {}
         }
         Ok(())
     }

crates/cli-support/src/lib.rs

@@ -31,6 +31,7 @@ pub struct Bindgen {
     debug: bool,
     typescript: bool,
     demangle: bool,
+    keep_debug: bool,
 }
 
 impl Bindgen {
@@ -45,6 +46,7 @@ impl Bindgen {
             debug: false,
             typescript: false,
             demangle: true,
+            keep_debug: false,
         }
     }
 
@@ -93,6 +95,11 @@ impl Bindgen {
         self
     }
 
+    pub fn keep_debug(&mut self, keep_debug: bool) -> &mut Bindgen {
+        self.keep_debug = keep_debug;
+        self
+    }
+
     pub fn generate<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Error> {
         self._generate(path.as_ref())
     }

crates/cli/src/bin/wasm-bindgen.rs

@@ -32,6 +32,7 @@ Options:
     --no-typescript          Don't emit a *.d.ts file
     --debug                  Include otherwise-extraneous debug checks in output
     --no-demangle            Don't demangle Rust symbol names
+    --keep-debug             Keep debug sections in wasm files
     -V --version             Print the version number of wasm-bindgen
 ";
 
@@ -47,6 +48,7 @@ struct Args {
     flag_version: bool,
     flag_no_demangle: bool,
     flag_no_modules_global: Option<String>,
+    flag_keep_debug: bool,
     arg_input: Option<PathBuf>,
 }
 
@@ -85,6 +87,7 @@ fn rmain(args: &Args) -> Result<(), Error> {
         .no_modules(args.flag_no_modules)
         .debug(args.flag_debug)
         .demangle(!args.flag_no_demangle)
+        .keep_debug(args.flag_keep_debug)
         .typescript(typescript);
     if let Some(ref name) = args.flag_no_modules_global {
         b.no_modules_global(name);

crates/shared/src/lib.rs

@@ -34,6 +34,7 @@ pub enum ImportKind {
     Static(ImportStatic),
     Type(ImportType),
     Enum(ImportEnum),
+    Const(Const)
 }
 
 #[derive(Deserialize, Serialize)]
@@ -124,6 +125,9 @@ pub struct StructField {
     pub comments: Vec<String>,
 }
 
+#[derive(Deserialize, Serialize)]
+pub struct Const {}
+
 pub fn new_function(struct_name: &str) -> String {
     let mut name = format!("__wbg_");
     name.extend(struct_name.chars().flat_map(|s| s.to_lowercase()));

crates/web-sys/tests/all/headers.rs

@@ -0,0 +1,33 @@
+use super::websys_project;
+
+#[test]
+fn headers() {
+    websys_project()
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section)]
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+                extern crate web_sys;
+
+                #[wasm_bindgen]
+                pub fn test_headers(_headers: &web_sys::Headers) {
+                    // empty for now...
+                }
+            "#,
+        )
+        .file(
+            "test.js",
+            r#"
+                import * as assert from "assert";
+                import * as wasm from "./out";
+
+                export function test() {
+                    let headers = new Headers({'Content-Type': 'text/plain'});
+                    wasm.test_headers(headers);
+                }
+            "#,
+        )
+        .test();
+}

crates/web-sys/tests/all/main.rs

@@ -2,6 +2,7 @@ extern crate wasm_bindgen_test_project_builder as project_builder;
 use project_builder::{project, Project};
 
 mod event;
+mod headers;
 mod response;
 
 fn websys_project() -> Project {

crates/web-sys/webidls/available/Headers.webidl renamed to crates/web-sys/webidls/enabled/Headers.webidl

@@ -30,11 +30,11 @@ use std::path::Path;
 use backend::defined::{ImportedTypeDefinitions, RemoveUndefinedImports};
 use backend::util::{ident_ty, rust_ident, wrap_import_function};
 use failure::ResultExt;
-use heck::CamelCase;
+use heck::{CamelCase, ShoutySnakeCase};
 use quote::ToTokens;
 
 use first_pass::{FirstPass, FirstPassRecord};
-use util::{public, TypePosition};
+use util::{public, webidl_const_ty_to_syn_ty, webidl_const_v_to_backend_const_v, TypePosition};
 
 /// Either `Ok(t)` or `Err(failure::Error)`.
 pub type Result<T> = ::std::result::Result<T, failure::Error>;
@@ -250,7 +250,7 @@ impl WebidlParse<()> for webidl::ast::NonPartialInterface {
             js_namespace: None,
             kind: backend::ast::ImportKind::Type(backend::ast::ImportType {
                 vis: public(),
-                name: rust_ident(&self.name),
+                name: rust_ident(self.name.to_camel_case().as_str()),
                 attrs: Vec::new(),
             }),
         });
@@ -343,7 +343,8 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
         match self {
             webidl::ast::ExtendedAttribute::ArgumentList(
                 webidl::ast::ArgumentListExtendedAttribute { arguments, name },
-            ) if name == "Constructor" =>
+            )
+                if name == "Constructor" =>
             {
                 add_constructor(arguments, &interface.name)
             }
@@ -358,7 +359,8 @@ 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)
             }
@@ -389,9 +391,11 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
             webidl::ast::InterfaceMember::Operation(op) => {
                 op.webidl_parse(program, first_pass, self_name)
             }
+            webidl::ast::InterfaceMember::Const(cnst) => {
+                cnst.webidl_parse(program, first_pass, self_name)
+            }
             // TODO
-            webidl::ast::InterfaceMember::Const(_)
-            | webidl::ast::InterfaceMember::Iterable(_)
+            webidl::ast::InterfaceMember::Iterable(_)
             | webidl::ast::InterfaceMember::Maplike(_)
             | webidl::ast::InterfaceMember::Setlike(_) => {
                 warn!("Unsupported WebIDL interface member: {:?}", self);
@@ -637,3 +641,29 @@ impl<'a> WebidlParse<()> for webidl::ast::Enum {
         Ok(())
     }
 }
+
+impl<'a> WebidlParse<&'a str> for webidl::ast::Const {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        _: &FirstPassRecord<'_>,
+        interface_name: &'a str,
+    ) -> Result<()> {
+        let syn_ty = webidl_const_ty_to_syn_ty(&self.type_);
+        program.imports.push(backend::ast::Import {
+            module: None,
+            version: None,
+            js_namespace: None,
+            kind: backend::ast::ImportKind::Const(backend::ast::Const {
+                vis: syn::Visibility::Public(syn::VisPublic {
+                    pub_token: Default::default(),
+                }),
+                name: rust_ident(self.name.to_shouty_snake_case().as_str()),
+                interface_name: rust_ident(interface_name.to_camel_case().as_str()),
+                ty: syn_ty,
+                value: webidl_const_v_to_backend_const_v(&self.value),
+            }),
+        });
+        Ok(())
+    }
+}

crates/webidl/src/lib.rs

@@ -19,6 +19,35 @@ fn shared_ref(ty: syn::Type) -> syn::Type {
     }.into()
 }
 
+pub fn webidl_const_ty_to_syn_ty(ty: &webidl::ast::ConstType) -> syn::Type {
+    use webidl::ast::ConstType::*;
+
+    // similar to webidl_ty_to_syn_ty
+    match ty {
+        Boolean => ident_ty(raw_ident("bool")),
+        Byte => ident_ty(raw_ident("i8")),
+        Octet => ident_ty(raw_ident("u8")),
+        RestrictedDouble | UnrestrictedDouble => ident_ty(raw_ident("f64")),
+        RestrictedFloat | UnrestrictedFloat => ident_ty(raw_ident("f32")),
+        SignedLong => ident_ty(raw_ident("i32")),
+        SignedLongLong => ident_ty(raw_ident("i64")),
+        SignedShort => ident_ty(raw_ident("i16")),
+        UnsignedLong => ident_ty(raw_ident("u32")),
+        UnsignedLongLong => ident_ty(raw_ident("u64")),
+        UnsignedShort => ident_ty(raw_ident("u16")),
+        Identifier(ref id) => ident_ty(rust_ident(id)),
+    }
+}
+
+pub fn webidl_const_v_to_backend_const_v(v: &webidl::ast::ConstValue) -> backend::ast::ConstValue {
+    match *v {
+        webidl::ast::ConstValue::BooleanLiteral(b) => backend::ast::ConstValue::BooleanLiteral(b),
+        webidl::ast::ConstValue::FloatLiteral(f) => backend::ast::ConstValue::FloatLiteral(f),
+        webidl::ast::ConstValue::IntegerLiteral(i) => backend::ast::ConstValue::IntegerLiteral(i),
+        webidl::ast::ConstValue::Null => backend::ast::ConstValue::Null,
+    }
+}
+
 fn simple_fn_arg(ident: Ident, ty: syn::Type) -> syn::ArgCaptured {
     syn::ArgCaptured {
         pat: syn::Pat::Ident(syn::PatIdent {