From 48f4adfa8c09c16b2ecd9fac2242448ec3ae6aeb Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 27 Nov 2018 12:07:59 -0800 Subject: [PATCH] Run rustfmt over everything --- crates/backend/src/ast.rs | 2 +- crates/backend/src/codegen.rs | 61 +++-- crates/backend/src/encode.rs | 102 ++++---- crates/backend/src/lib.rs | 7 +- crates/backend/src/util.rs | 6 +- crates/cli-support/src/decode.rs | 6 +- crates/cli-support/src/js/closures.rs | 10 +- crates/cli-support/src/js/js2rust.rs | 17 +- crates/cli-support/src/js/mod.rs | 232 +++++++++++------- crates/cli-support/src/js/rust2js.rs | 38 ++- crates/cli-support/src/lib.rs | 19 +- .../bin/wasm-bindgen-test-runner/server.rs | 3 +- crates/futures/tests/tests.rs | 10 +- crates/gc/src/bitvec.rs | 4 +- crates/gc/src/lib.rs | 145 ++++++----- crates/gc/tests/all.rs | 30 ++- crates/js-sys/tests/wasm/DataView.rs | 10 +- crates/js-sys/tests/wasm/Iterator.rs | 24 +- crates/js-sys/tests/wasm/WebAssembly.rs | 11 +- crates/macro-support/src/parser.rs | 66 +++-- crates/shared/src/lib.rs | 183 +++++++------- crates/test-macro/src/lib.rs | 3 +- crates/threads-xform/src/lib.rs | 149 +++++------ crates/typescript/src/parser.rs | 3 +- crates/wasm-interpreter/src/lib.rs | 9 +- crates/web-sys/build.rs | 3 +- crates/web-sys/tests/wasm/element.rs | 98 ++++---- crates/web-sys/tests/wasm/html_element.rs | 12 +- crates/web-sys/tests/wasm/input_element.rs | 132 +++++----- crates/web-sys/tests/wasm/main.rs | 2 +- crates/web-sys/tests/wasm/option_element.rs | 3 +- crates/webidl/src/first_pass.rs | 4 +- crates/webidl/src/idl_type.rs | 19 +- crates/webidl/src/lib.rs | 28 ++- crates/webidl/src/util.rs | 42 ++-- examples/fetch/src/lib.rs | 9 +- examples/paint/src/lib.rs | 15 +- examples/raytrace-parallel/src/lib.rs | 57 ++--- examples/webaudio/src/lib.rs | 1 - examples/webgl/src/lib.rs | 15 +- src/lib.rs | 33 +-- tests/wasm/classes.rs | 10 +- tests/wasm/closures.rs | 28 ++- tests/wasm/imports.rs | 8 +- tests/wasm/js_objects.rs | 3 +- 45 files changed, 872 insertions(+), 800 deletions(-) diff --git a/crates/backend/src/ast.rs b/crates/backend/src/ast.rs index 51d968a4..15433041 100644 --- a/crates/backend/src/ast.rs +++ b/crates/backend/src/ast.rs @@ -1,7 +1,7 @@ -use Diagnostic; use proc_macro2::{Ident, Span}; use shared; use syn; +use Diagnostic; /// An abstract syntax tree representing a rust program. Contains /// extra information for joining up this rust code with javascript. diff --git a/crates/backend/src/codegen.rs b/crates/backend/src/codegen.rs index b812ce24..a90a09cc 100644 --- a/crates/backend/src/codegen.rs +++ b/crates/backend/src/codegen.rs @@ -1,6 +1,6 @@ use std::collections::HashSet; -use std::sync::Mutex; use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; +use std::sync::Mutex; use proc_macro2::{Ident, Literal, Span, TokenStream}; use quote::ToTokens; @@ -89,9 +89,11 @@ impl TryToTokens for ast::Program { // See comments in `crates/cli-support/src/lib.rs` about what this // `schema_version` is. - let prefix_json = format!(r#"{{"schema_version":"{}","version":"{}"}}"#, - shared::SCHEMA_VERSION, - shared::version()); + let prefix_json = format!( + r#"{{"schema_version":"{}","version":"{}"}}"#, + shared::SCHEMA_VERSION, + shared::version() + ); let mut bytes = Vec::new(); bytes.push((prefix_json.len() >> 0) as u8); bytes.push((prefix_json.len() >> 8) as u8); @@ -110,7 +112,8 @@ impl TryToTokens for ast::Program { #[doc(hidden)] pub static #generated_static_name: [u8; #generated_static_length] = *#generated_static_value; - }).to_tokens(tokens); + }) + .to_tokens(tokens); Ok(()) } @@ -237,7 +240,8 @@ impl ToTokens for ast::Struct { (*js).borrow_mut() } } - }).to_tokens(tokens); + }) + .to_tokens(tokens); for field in self.fields.iter() { field.to_tokens(tokens); @@ -273,14 +277,16 @@ impl ToTokens for ast::StructField { &mut GlobalStack::new(), ) } - }).to_tokens(tokens); + }) + .to_tokens(tokens); Descriptor( &getter, quote! { <#ty as WasmDescribe>::describe(); }, - ).to_tokens(tokens); + ) + .to_tokens(tokens); if self.readonly { return; @@ -305,7 +311,8 @@ impl ToTokens for ast::StructField { ); (*js).borrow_mut().#name = val; } - }).to_tokens(tokens); + }) + .to_tokens(tokens); } } @@ -461,7 +468,8 @@ impl TryToTokens for ast::Export { }; #convert_ret } - }).to_tokens(into); + }) + .to_tokens(into); // In addition to generating the shim function above which is what // our generated JS will invoke, we *also* generate a "descriptor" @@ -488,7 +496,8 @@ impl TryToTokens for ast::Export { #(<#argtys as WasmDescribe>::describe();)* #describe_ret }, - ).to_tokens(into); + ) + .to_tokens(into); Ok(()) } @@ -670,7 +679,8 @@ impl ToTokens for ast::ImportType { self.as_ref() } } - }).to_tokens(tokens); + }) + .to_tokens(tokens); for superclass in self.extends.iter() { (quote! { impl From<#rust_name> for #superclass { @@ -688,7 +698,8 @@ impl ToTokens for ast::ImportType { #superclass::unchecked_from_js_ref(self.as_ref()) } } - }).to_tokens(tokens); + }) + .to_tokens(tokens); } } } @@ -709,7 +720,8 @@ impl ToTokens for ast::ImportEnum { let this_index = current_idx; current_idx += 1; Literal::usize_unsuffixed(this_index) - }).collect(); + }) + .collect(); // Borrow variant_indexes because we need to use it multiple times inside the quote! macro let variant_indexes_ref = &variant_indexes; @@ -946,7 +958,8 @@ impl TryToTokens for ast::ImportFunction { impl #class { #invocation } - }).to_tokens(tokens); + }) + .to_tokens(tokens); } else { invocation.to_tokens(tokens); } @@ -981,7 +994,8 @@ impl<'a> ToTokens for DescribeImport<'a> { #(<#argtys as WasmDescribe>::describe();)* #inform_ret }, - ).to_tokens(tokens); + ) + .to_tokens(tokens); } } @@ -1025,7 +1039,8 @@ impl ToTokens for ast::Enum { inform(ENUM); } } - }).to_tokens(into); + }) + .to_tokens(into); } } @@ -1061,7 +1076,8 @@ impl ToTokens for ast::ImportStatic { __inner: &_VAL, } }; - }).to_tokens(into); + }) + .to_tokens(into); } } @@ -1106,7 +1122,8 @@ impl ToTokens for ast::Const { impl #class { #declaration } - }).to_tokens(tokens); + }) + .to_tokens(tokens); } else { declaration.to_tokens(tokens); } @@ -1247,7 +1264,8 @@ impl ToTokens for ast::Dictionary { } } }; - }).to_tokens(tokens); + }) + .to_tokens(tokens); } } @@ -1309,6 +1327,7 @@ impl<'a, T: ToTokens> ToTokens for Descriptor<'a, T> { ::wasm_bindgen::__rt::link_mem_intrinsics(); #inner } - }).to_tokens(tokens); + }) + .to_tokens(tokens); } } diff --git a/crates/backend/src/encode.rs b/crates/backend/src/encode.rs index 525b704a..0f8512f5 100644 --- a/crates/backend/src/encode.rs +++ b/crates/backend/src/encode.rs @@ -3,8 +3,8 @@ use std::collections::HashMap; use proc_macro2::{Ident, Span}; -use Diagnostic; use ast; +use Diagnostic; pub fn encode(program: &ast::Program) -> Result, Diagnostic> { let mut e = Encoder::new(); @@ -19,13 +19,15 @@ struct Interner { impl Interner { fn new() -> Interner { - Interner { map: RefCell::new(HashMap::new()) } + Interner { + map: RefCell::new(HashMap::new()), + } } fn intern(&self, s: &Ident) -> &str { let mut map = self.map.borrow_mut(); if let Some(s) = map.get(s) { - return unsafe { &*(&**s as *const str) } + return unsafe { &*(&**s as *const str) }; } map.insert(s.clone(), s.to_string()); unsafe { &*(&*map[s] as *const str) } @@ -36,17 +38,32 @@ impl Interner { } } -fn shared_program<'a>(prog: &'a ast::Program, intern: &'a Interner) - -> Result, Diagnostic> -{ +fn shared_program<'a>( + prog: &'a ast::Program, + intern: &'a Interner, +) -> Result, Diagnostic> { Ok(Program { - exports: prog.exports.iter().map(|a| shared_export(a, intern)).collect(), - structs: prog.structs.iter().map(|a| shared_struct(a, intern)).collect(), + exports: prog + .exports + .iter() + .map(|a| shared_export(a, intern)) + .collect(), + structs: prog + .structs + .iter() + .map(|a| shared_struct(a, intern)) + .collect(), enums: prog.enums.iter().map(|a| shared_enum(a, intern)).collect(), - imports: prog.imports.iter() + imports: prog + .imports + .iter() .map(|a| shared_import(a, intern)) .collect::, _>>()?, - typescript_custom_sections: prog.typescript_custom_sections.iter().map(|x| -> &'a str { &x }).collect(), + typescript_custom_sections: prog + .typescript_custom_sections + .iter() + .map(|x| -> &'a str { &x }) + .collect(), // version: shared::version(), // schema_version: shared::SCHEMA_VERSION.to_string(), }) @@ -69,15 +86,17 @@ fn shared_export<'a>(export: &'a ast::Export, intern: &'a Interner) -> Export<'a } fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Function<'a> { - Function { - name: &func.name, - } + Function { name: &func.name } } fn shared_enum<'a>(e: &'a ast::Enum, intern: &'a Interner) -> Enum<'a> { Enum { name: intern.intern(&e.name), - variants: e.variants.iter().map(|v| shared_variant(v, intern)).collect(), + variants: e + .variants + .iter() + .map(|v| shared_variant(v, intern)) + .collect(), comments: e.comments.iter().map(|s| &**s).collect(), } } @@ -89,9 +108,7 @@ fn shared_variant<'a>(v: &'a ast::Variant, intern: &'a Interner) -> EnumVariant< } } -fn shared_import<'a>(i: &'a ast::Import, intern: &'a Interner) - -> Result, Diagnostic> -{ +fn shared_import<'a>(i: &'a ast::Import, intern: &'a Interner) -> Result, Diagnostic> { Ok(Import { module: i.module.as_ref().map(|s| &**s), js_namespace: i.js_namespace.as_ref().map(|s| intern.intern(s)), @@ -99,9 +116,10 @@ fn shared_import<'a>(i: &'a ast::Import, intern: &'a Interner) }) } -fn shared_import_kind<'a>(i: &'a ast::ImportKind, intern: &'a Interner) - -> Result, Diagnostic> -{ +fn shared_import_kind<'a>( + i: &'a ast::ImportKind, + intern: &'a Interner, +) -> Result, Diagnostic> { Ok(match i { ast::ImportKind::Function(f) => ImportKind::Function(shared_import_function(f, intern)?), ast::ImportKind::Static(f) => ImportKind::Static(shared_import_static(f, intern)), @@ -110,11 +128,12 @@ fn shared_import_kind<'a>(i: &'a ast::ImportKind, intern: &'a Interner) }) } -fn shared_import_function<'a>(i: &'a ast::ImportFunction, intern: &'a Interner) - -> Result, Diagnostic> -{ +fn shared_import_function<'a>( + i: &'a ast::ImportFunction, + intern: &'a Interner, +) -> Result, Diagnostic> { let method = match &i.kind { - ast::ImportFunctionKind::Method { class, kind, .. } => { + ast::ImportFunctionKind::Method { class, kind, .. } => { let kind = match kind { ast::MethodKind::Constructor => MethodKind::Constructor, ast::MethodKind::Operation(ast::Operation { is_static, kind }) => { @@ -123,9 +142,7 @@ fn shared_import_function<'a>(i: &'a ast::ImportFunction, intern: &'a Interner) ast::OperationKind::Regular => OperationKind::Regular, ast::OperationKind::Getter(g) => { let g = g.as_ref().map(|g| intern.intern(g)); - OperationKind::Getter( - g.unwrap_or_else(|| i.infer_getter_property()), - ) + OperationKind::Getter(g.unwrap_or_else(|| i.infer_getter_property())) } ast::OperationKind::Setter(s) => { let s = s.as_ref().map(|s| intern.intern(s)); @@ -141,10 +158,7 @@ fn shared_import_function<'a>(i: &'a ast::ImportFunction, intern: &'a Interner) MethodKind::Operation(Operation { is_static, kind }) } }; - Some(MethodData { - class, - kind, - }) + Some(MethodData { class, kind }) } ast::ImportFunctionKind::Normal => None, }; @@ -159,44 +173,38 @@ fn shared_import_function<'a>(i: &'a ast::ImportFunction, intern: &'a Interner) }) } -fn shared_import_static<'a>(i: &'a ast::ImportStatic, intern: &'a Interner) - -> ImportStatic<'a> -{ +fn shared_import_static<'a>(i: &'a ast::ImportStatic, intern: &'a Interner) -> ImportStatic<'a> { ImportStatic { name: &i.js_name, shim: intern.intern(&i.shim), } } -fn shared_import_type<'a>(i: &'a ast::ImportType, intern: &'a Interner) - -> ImportType<'a> -{ +fn shared_import_type<'a>(i: &'a ast::ImportType, intern: &'a Interner) -> ImportType<'a> { ImportType { name: &i.js_name, instanceof_shim: &i.instanceof_shim, - vendor_prefixes: i.vendor_prefixes.iter() - .map(|x| intern.intern(x)) - .collect(), + vendor_prefixes: i.vendor_prefixes.iter().map(|x| intern.intern(x)).collect(), } } -fn shared_import_enum<'a>(_i: &'a ast::ImportEnum, _intern: &'a Interner) - -> ImportEnum -{ +fn shared_import_enum<'a>(_i: &'a ast::ImportEnum, _intern: &'a Interner) -> ImportEnum { ImportEnum {} } fn shared_struct<'a>(s: &'a ast::Struct, intern: &'a Interner) -> Struct<'a> { Struct { name: &s.js_name, - fields: s.fields.iter().map(|s| shared_struct_field(s, intern)).collect(), + fields: s + .fields + .iter() + .map(|s| shared_struct_field(s, intern)) + .collect(), comments: s.comments.iter().map(|s| &**s).collect(), } } -fn shared_struct_field<'a>(s: &'a ast::StructField, intern: &'a Interner) - -> StructField<'a> -{ +fn shared_struct_field<'a>(s: &'a ast::StructField, intern: &'a Interner) -> StructField<'a> { StructField { name: intern.intern(&s.name), readonly: s.readonly, diff --git a/crates/backend/src/lib.rs b/crates/backend/src/lib.rs index 50388188..325cd795 100755 --- a/crates/backend/src/lib.rs +++ b/crates/backend/src/lib.rs @@ -1,8 +1,5 @@ #![recursion_limit = "256"] -#![cfg_attr( - feature = "extra-traits", - deny(missing_debug_implementations) -)] +#![cfg_attr(feature = "extra-traits", deny(missing_debug_implementations))] #![doc(html_root_url = "https://docs.rs/wasm-bindgen-backend/0.2")] #[macro_use] @@ -25,6 +22,6 @@ mod error; pub mod ast; mod codegen; -mod encode; pub mod defined; +mod encode; pub mod util; diff --git a/crates/backend/src/util.rs b/crates/backend/src/util.rs index 0495f4c9..c2c18558 100644 --- a/crates/backend/src/util.rs +++ b/crates/backend/src/util.rs @@ -71,7 +71,8 @@ where .map(|i| syn::PathSegment { ident: i, arguments: syn::PathArguments::None, - }).collect(); + }) + .collect(); syn::TypePath { qself: None, @@ -83,7 +84,8 @@ where }, segments: syn::punctuated::Punctuated::from_iter(segments), }, - }.into() + } + .into() } pub fn ident_ty(ident: Ident) -> syn::Type { diff --git a/crates/cli-support/src/decode.rs b/crates/cli-support/src/decode.rs index 9d4fdc03..d6dfb6b2 100644 --- a/crates/cli-support/src/decode.rs +++ b/crates/cli-support/src/decode.rs @@ -6,14 +6,14 @@ pub trait Decode<'src>: Sized { fn decode_all(mut data: &'src [u8]) -> Self { let ret = Self::decode(&mut data); assert!(data.len() == 0); - return ret + return ret; } } fn get<'a>(b: &mut &'a [u8]) -> u8 { let r = b[0]; *b = &b[1..]; - return r + return r; } impl<'src> Decode<'src> for bool { @@ -30,7 +30,7 @@ impl<'src> Decode<'src> for u32 { let byte = get(data); cur |= ((byte & 0x7f) as u32) << offset; if byte & 0x80 == 0 { - break cur + break cur; } offset += 7; } diff --git a/crates/cli-support/src/js/closures.rs b/crates/cli-support/src/js/closures.rs index f5969980..377bd5aa 100644 --- a/crates/cli-support/src/js/closures.rs +++ b/crates/cli-support/src/js/closures.rs @@ -44,7 +44,8 @@ pub fn rewrite(input: &mut Context) -> Result<(), Error> { .import_section() .map(|s| s.functions()) .unwrap_or(0) as u32, - }.remap_module(input.module); + } + .remap_module(input.module); info.delete_function_table_entries(input); info.inject_imports(input)?; @@ -236,13 +237,10 @@ impl ClosureDescriptors { .rust_argument("b") .finally("this.a = a;\n"); } else { - builder.rust_argument("this.a") - .rust_argument("b"); + builder.rust_argument("this.a").rust_argument("b"); } builder.finally("if (this.cnt-- == 1) d(this.a, b);"); - builder - .process(&closure.function)? - .finish("function", "f") + builder.process(&closure.function)?.finish("function", "f") }; input.expose_add_heap_object(); input.function_table_needed = true; diff --git a/crates/cli-support/src/js/js2rust.rs b/crates/cli-support/src/js/js2rust.rs index 0243d605..0d01e048 100644 --- a/crates/cli-support/src/js/js2rust.rs +++ b/crates/cli-support/src/js/js2rust.rs @@ -329,8 +329,8 @@ impl<'a, 'b> Js2Rust<'a, 'b> { } else { self.prelude(&format!( "\ - const ptr{i} = {arg}.ptr;\n\ - ", + const ptr{i} = {arg}.ptr;\n\ + ", i = i, arg = name )); @@ -346,8 +346,8 @@ impl<'a, 'b> Js2Rust<'a, 'b> { } self.prelude(&format!( "\ - {arg}.ptr = 0;\n\ - ", + {arg}.ptr = 0;\n\ + ", arg = name )); self.rust_arguments.push(format!("ptr{}", i)); @@ -549,7 +549,8 @@ impl<'a, 'b> Js2Rust<'a, 'b> { self.ret_expr = " const ret = RET; return ret === 0xFFFFFF ? undefined : ret; - ".to_string(); + " + .to_string(); return Ok(self); } @@ -583,7 +584,8 @@ impl<'a, 'b> Js2Rust<'a, 'b> { self.ret_expr = " const ret = RET; return ret === 0xFFFFFF ? undefined : ret !== 0; - ".to_string(); + " + .to_string(); return Ok(self); } Descriptor::Char => { @@ -597,7 +599,8 @@ impl<'a, 'b> Js2Rust<'a, 'b> { const present = getUint32Memory()[retptr / 4]; const value = getUint32Memory()[retptr / 4 + 1]; return present === 0 ? undefined : String.fromCodePoint(value); - ".to_string(); + " + .to_string(); return Ok(self); } _ => bail!( diff --git a/crates/cli-support/src/js/mod.rs b/crates/cli-support/src/js/mod.rs index 3466024e..d4850484 100644 --- a/crates/cli-support/src/js/mod.rs +++ b/crates/cli-support/src/js/mod.rs @@ -3,10 +3,10 @@ use std::mem; use decode; use failure::{Error, ResultExt}; -use parity_wasm::elements::*; -use parity_wasm::elements::Error as ParityError; -use shared; use gc; +use parity_wasm::elements::Error as ParityError; +use parity_wasm::elements::*; +use shared; use super::Bindgen; use descriptor::{Descriptor, VectorKind}; @@ -438,8 +438,10 @@ impl<'a> Context<'a> { self.bind("__wbindgen_module", &|me| { if !me.config.no_modules { - bail!("`wasm_bindgen::module` is currently only supported with \ - --no-modules"); + bail!( + "`wasm_bindgen::module` is currently only supported with \ + --no-modules" + ); } me.expose_add_heap_object(); Ok(format!( @@ -504,7 +506,7 @@ impl<'a> Context<'a> { memory.push_str("})"); format!( - "\ + "\ (function() {{ var wasm; var memory; @@ -539,17 +541,19 @@ impl<'a> Context<'a> { }}; self.{global_name} = Object.assign(init, __exports); }})();", - globals = self.globals, - module = module_name, - global_name = self.config.no_modules_global - .as_ref() - .map(|s| &**s) - .unwrap_or("wasm_bindgen"), - init_memory = memory, + globals = self.globals, + module = module_name, + global_name = self + .config + .no_modules_global + .as_ref() + .map(|s| &**s) + .unwrap_or("wasm_bindgen"), + init_memory = memory, ) } else if self.config.no_modules { format!( - "\ + "\ (function() {{ var wasm; const __exports = {{}}; @@ -579,12 +583,14 @@ impl<'a> Context<'a> { }}; self.{global_name} = Object.assign(init, __exports); }})();", - globals = self.globals, - module = module_name, - global_name = self.config.no_modules_global - .as_ref() - .map(|s| &**s) - .unwrap_or("wasm_bindgen"), + globals = self.globals, + module = module_name, + global_name = self + .config + .no_modules_global + .as_ref() + .map(|s| &**s) + .unwrap_or("wasm_bindgen"), ) } else { let import_wasm = if self.globals.len() == 0 { @@ -787,7 +793,8 @@ impl<'a> Context<'a> { .filter_map(|s| match *s { Section::Import(ref mut s) => Some(s), _ => None, - }).flat_map(|s| s.entries_mut()); + }) + .flat_map(|s| s.entries_mut()); for import in imports { if import.module() == "__wbindgen_placeholder__" { @@ -1172,18 +1179,20 @@ impl<'a> Context<'a> { fn expose_text_processor(&mut self, s: &str) { if self.config.nodejs_experimental_modules { - self.imports.push_str(&format!("import {{ {} }} from 'util';\n", s)); + self.imports + .push_str(&format!("import {{ {} }} from 'util';\n", s)); self.global(&format!("let cached{0} = new {0}('utf-8');", s)); } else if self.config.nodejs { self.global(&format!("const {0} = require('util').{0};", s)); self.global(&format!("let cached{0} = new {0}('utf-8');", s)); } else if !(self.config.browser || self.config.no_modules) { - self.global( - &format!(" + self.global(&format!( + " const l{0} = typeof {0} === 'undefined' ? \ require('util').{0} : {0};\ - ", s) - ); + ", + s + )); self.global(&format!("let cached{0} = new l{0}('utf-8');", s)); } else { self.global(&format!("let cached{0} = new {0}('utf-8');", s)); @@ -1770,11 +1779,9 @@ impl<'a> Context<'a> { let module = module.parse_names().unwrap_or_else(|p| p.1); *self.module = module; if self.config.remove_name_section { - self.module.sections_mut().retain(|s| { - match s { - Section::Name(_) => false, - _ => true, - } + self.module.sections_mut().retain(|s| match s { + Section::Name(_) => false, + _ => true, }); } } @@ -1815,7 +1822,8 @@ impl<'a> Context<'a> { .filter_map(|i| match i.external() { External::Memory(m) => Some((i, m)), _ => None, - }).next() + }) + .next() .expect("must import memory"); assert_eq!(entry.field(), "memory"); self.memory_init = Some(mem.limits().clone()); @@ -1857,14 +1865,19 @@ impl<'a> Context<'a> { if use_node_require { imports.push_str(&format!( "const {} = require(String.raw`{}`).{};\n", - name, module, import.name() + name, + module, + import.name() )); } else if import.name() == name { - imports.push_str(&format!("import {{ {} }} from '{}';\n", name, module)); + imports + .push_str(&format!("import {{ {} }} from '{}';\n", name, module)); } else { imports.push_str(&format!( "import {{ {} as {} }} from '{}';\n", - import.name(), name, module + import.name(), + name, + module )); } name @@ -1923,11 +1936,11 @@ impl<'a> Context<'a> { None => { let name = self.import_identifier(name); if import.structural || !name.contains(".") { - return Ok(ImportTarget::Function(name)) + return Ok(ImportTarget::Function(name)); } self.global(&format!("const {}_target = {};", import.shim, name)); let target = format!("{}_target", import.shim); - return Ok(ImportTarget::Function(target)) + return Ok(ImportTarget::Function(target)); } }; @@ -1939,7 +1952,11 @@ impl<'a> Context<'a> { decode::MethodKind::Operation(op) => op, }; if import.structural { - let class = if op.is_static { Some(class.clone()) } else { None }; + let class = if op.is_static { + Some(class.clone()) + } else { + None + }; return Ok(match &op.kind { decode::OperationKind::Regular => { @@ -1964,43 +1981,51 @@ impl<'a> Context<'a> { decode::OperationKind::IndexingDeleter => { ImportTarget::StructuralIndexingDeleter(class) } - }) + }); } - let target = format!("typeof {0} === 'undefined' ? null : {}{}", - class, - if op.is_static { "" } else { ".prototype" }); + let target = format!( + "typeof {0} === 'undefined' ? null : {}{}", + class, + if op.is_static { "" } else { ".prototype" } + ); let (mut target, name) = match &op.kind { - decode::OperationKind::Regular => { - (format!("{}.{}", target, import.function.name), &import.function.name) - } + decode::OperationKind::Regular => ( + format!("{}.{}", target, import.function.name), + &import.function.name, + ), decode::OperationKind::Getter(g) => { self.expose_get_inherited_descriptor(); - (format!( - "GetOwnOrInheritedPropertyDescriptor({}, '{}').get", - target, g, - ), g) + ( + format!( + "GetOwnOrInheritedPropertyDescriptor({}, '{}').get", + target, g, + ), + g, + ) } decode::OperationKind::Setter(s) => { self.expose_get_inherited_descriptor(); - (format!( - "GetOwnOrInheritedPropertyDescriptor({}, '{}').set", - target, s, - ), s) - } - decode::OperationKind::IndexingGetter => { - panic!("indexing getter should be structural") - } - decode::OperationKind::IndexingSetter => { - panic!("indexing setter should be structural") + ( + format!( + "GetOwnOrInheritedPropertyDescriptor({}, '{}').set", + target, s, + ), + s, + ) } + decode::OperationKind::IndexingGetter => panic!("indexing getter should be structural"), + decode::OperationKind::IndexingSetter => panic!("indexing setter should be structural"), decode::OperationKind::IndexingDeleter => { panic!("indexing deleter should be structural") } }; - target.push_str(&format!(" || function() {{ + target.push_str(&format!( + " || function() {{ throw new Error(`wasm-bindgen: {}.{} does not exist`); - }}", class, name)); + }}", + class, name + )); if op.is_static { target.insert(0, '('); target.push_str(").bind("); @@ -2028,10 +2053,10 @@ impl<'a> Context<'a> { _ => continue, }; if section.name() != "producers" { - return + return; } drop(update(section)); - return + return; } // `CustomSection::new` added in paritytech/parity-wasm#244 which isn't @@ -2039,7 +2064,15 @@ impl<'a> Context<'a> { let data = [ ("producers".len() + 2) as u8, "producers".len() as u8, - b'p', b'r', b'o', b'd', b'u', b'c', b'e', b'r', b's', + b'p', + b'r', + b'o', + b'd', + b'u', + b'c', + b'e', + b'r', + b's', 0, ]; let mut section = CustomSection::deserialize(&mut &data[..]).unwrap(); @@ -2058,11 +2091,9 @@ impl<'a> Context<'a> { version: String, } - let wasm_bindgen = || { - FieldValue { - name: "wasm-bindgen".to_string(), - version: shared::version(), - } + let wasm_bindgen = || FieldValue { + name: "wasm-bindgen".to_string(), + version: shared::version(), }; let mut fields = Vec::new(); @@ -2090,7 +2121,7 @@ impl<'a> Context<'a> { fields.push(Field { name, values }); } if data.len() != 0 { - return Err(ParityError::InconsistentCode) + return Err(ParityError::InconsistentCode); } if !found_processed_by { @@ -2199,7 +2230,8 @@ impl<'a, 'b> SubContext<'a, 'b> { Some(class_name) } else { None - }).process(descriptor.unwrap_function())? + }) + .process(descriptor.unwrap_function())? .finish("", &format!("wasm.{}", wasm_name)); let class = self @@ -2323,9 +2355,14 @@ impl<'a, 'b> SubContext<'a, 'b> { // up the wasm import directly to the destination. We don't actually // wire up anything here, but we record it to get wired up later. if import.method.is_none() && shim.is_noop() { - if let Import::Module { module, name, field: None } = name { + if let Import::Module { + module, + name, + field: None, + } = name + { shim.cx.direct_imports.insert(import.shim, (module, name)); - return Ok(()) + return Ok(()); } } @@ -2439,12 +2476,9 @@ impl<'a, 'b> SubContext<'a, 'b> { Ok(()) } - fn register_vendor_prefix( - &mut self, - info: &decode::ImportType<'b>, - ) { + fn register_vendor_prefix(&mut self, info: &decode::ImportType<'b>) { if info.vendor_prefixes.len() == 0 { - return + return; } self.vendor_prefixes .entry(info.name) @@ -2452,9 +2486,11 @@ impl<'a, 'b> SubContext<'a, 'b> { .extend(info.vendor_prefixes.iter().cloned()); } - fn determine_import(&self, import: &decode::Import<'b>, item: &'b str) - -> Result, Error> - { + fn determine_import( + &self, + import: &decode::Import<'b>, + item: &'b str, + ) -> Result, Error> { // First up, imports don't work at all in `--no-modules` mode as we're // not sure how to import them. if self.cx.config.no_modules { @@ -2484,29 +2520,37 @@ impl<'a, 'b> SubContext<'a, 'b> { ); } if let Some(ns) = &import.js_namespace { - bail!("import of `{}` through js namespace `{}` isn't supported \ - right now when it lists a polyfill", - item, - ns); + bail!( + "import of `{}` through js namespace `{}` isn't supported \ + right now when it lists a polyfill", + item, + ns + ); } return Ok(Import::VendorPrefixed { name: item, prefixes: vendor_prefixes.clone(), - }) + }); } let name = import.js_namespace.as_ref().map(|s| &**s).unwrap_or(item); - let field = if import.js_namespace.is_some() { Some(item) } else { None }; + let field = if import.js_namespace.is_some() { + Some(item) + } else { + None + }; Ok(match import.module { - Some(module) => Import::Module { module, name, field }, + Some(module) => Import::Module { + module, + name, + field, + }, None => Import::Global { name, field }, }) } - fn import_name(&mut self, import: &decode::Import<'b>, item: &'b str) - -> Result - { + fn import_name(&mut self, import: &decode::Import<'b>, item: &'b str) -> Result { let import = self.determine_import(import, item)?; Ok(self.cx.import_identifier(import)) } @@ -2529,9 +2573,9 @@ impl<'a> Import<'a> { fn name(&self) -> &'a str { match self { - Import::Module { name, .. } | - Import::Global { name, .. } | - Import::VendorPrefixed { name, .. } => *name, + Import::Module { name, .. } + | Import::Global { name, .. } + | Import::VendorPrefixed { name, .. } => *name, } } } diff --git a/crates/cli-support/src/js/rust2js.rs b/crates/cli-support/src/js/rust2js.rs index 7bb42384..254733e7 100644 --- a/crates/cli-support/src/js/rust2js.rs +++ b/crates/cli-support/src/js/rust2js.rs @@ -1,6 +1,6 @@ use failure::Error; -use super::{Context, Js2Rust, ImportTarget}; +use super::{Context, ImportTarget, Js2Rust}; use descriptor::{Descriptor, Function}; /// Helper struct for manufacturing a shim in JS used to translate Rust types to @@ -345,7 +345,8 @@ impl<'a, 'b> Rust2Js<'a, 'b> { self.ret_expr = " const val = JS; return isLikeNone(val) ? 0 : addHeapObject(val); - ".to_string(); + " + .to_string(); } else { self.ret_expr = "return addHeapObject(JS);".to_string() } @@ -392,7 +393,8 @@ impl<'a, 'b> Rust2Js<'a, 'b> { self.ret_expr = " const val = JS; return isLikeNone(val) ? 0xFFFFFF : val; - ".to_string(); + " + .to_string(); return Ok(()); } @@ -424,7 +426,8 @@ impl<'a, 'b> Rust2Js<'a, 'b> { self.ret_expr = " const val = JS; return isLikeNone(val) ? 0xFFFFFF : val ? 1 : 0; - ".to_string(); + " + .to_string(); return Ok(()); } Descriptor::Char => { @@ -435,7 +438,8 @@ impl<'a, 'b> Rust2Js<'a, 'b> { const val = JS; getUint32Memory()[ret / 4] = !isLikeNone(val); getUint32Memory()[ret / 4 + 1] = isLikeNone(val) ? 0 : val.codePointAt(0); - ".to_string(); + " + .to_string(); return Ok(()); } _ => bail!( @@ -561,16 +565,12 @@ impl<'a, 'b> Rust2Js<'a, 'b> { &format!("{}({}, ...{})", invoc, args.join(", "), last_arg), ) } else { - self.ret_expr.replace( - "JS", - &format!("{}(...{})", invoc, last_arg), - ) + self.ret_expr + .replace("JS", &format!("{}(...{})", invoc, last_arg)) } } else { - self.ret_expr.replace( - "JS", - &format!("{}({})", invoc, js_arguments.join(", ")), - ) + self.ret_expr + .replace("JS", &format!("{}({})", invoc, js_arguments.join(", "))) }; Ok(ret) }; @@ -584,23 +584,17 @@ impl<'a, 'b> Rust2Js<'a, 'b> { Ok((self.js_arguments[0].clone(), &self.js_arguments[1..])) } (None, _) => bail!("setters must have {} arguments", amt + 1), - (Some(class), n) if n == amt => { - Ok((class.clone(), &self.js_arguments[..])) - } + (Some(class), n) if n == amt => Ok((class.clone(), &self.js_arguments[..])), (Some(_), _) => bail!("static setters must have {} arguments", amt), } }; let mut invoc = match invoc { - ImportTarget::Function(f) => { - handle_variadic(&f, &self.js_arguments)? - } + ImportTarget::Function(f) => handle_variadic(&f, &self.js_arguments)?, ImportTarget::Constructor(c) => { handle_variadic(&format!("new {}", c), &self.js_arguments)? } - ImportTarget::Method(f) => { - handle_variadic(&format!("{}.call", f), &self.js_arguments)? - } + ImportTarget::Method(f) => handle_variadic(&format!("{}.call", f), &self.js_arguments)?, ImportTarget::StructuralMethod(f) => { let (receiver, args) = match self.js_arguments.split_first() { Some(pair) => pair, diff --git a/crates/cli-support/src/lib.rs b/crates/cli-support/src/lib.rs index 90723f98..e71dbd41 100644 --- a/crates/cli-support/src/lib.rs +++ b/crates/cli-support/src/lib.rs @@ -6,8 +6,8 @@ extern crate wasm_bindgen_shared as shared; extern crate wasm_bindgen_gc as gc; #[macro_use] extern crate failure; -extern crate wasm_bindgen_wasm_interpreter as wasm_interpreter; extern crate wasm_bindgen_threads_xform as threads_xform; +extern crate wasm_bindgen_wasm_interpreter as wasm_interpreter; use std::collections::BTreeSet; use std::env; @@ -201,7 +201,8 @@ impl Bindgen { program, cx: &mut cx, vendor_prefixes: Default::default(), - }.generate()?; + } + .generate()?; } cx.finalize(stem)? }; @@ -390,7 +391,7 @@ to open an issue at https://github.com/rustwasm/wasm-bindgen/issues! fn get_remaining<'a>(data: &mut &'a [u8]) -> Option<&'a [u8]> { if data.len() == 0 { - return None + return None; } let len = ((data[0] as usize) << 0) | ((data[1] as usize) << 8) @@ -401,11 +402,11 @@ fn get_remaining<'a>(data: &mut &'a [u8]) -> Option<&'a [u8]> { Some(a) } -fn verify_schema_matches<'a>(data: &'a [u8]) - -> Result, Error> -{ +fn verify_schema_matches<'a>(data: &'a [u8]) -> Result, Error> { macro_rules! bad { - () => (bail!("failed to decode what looked like wasm-bindgen data")) + () => { + bail!("failed to decode what looked like wasm-bindgen data") + }; } let data = match str::from_utf8(data) { Ok(s) => s, @@ -424,7 +425,7 @@ fn verify_schema_matches<'a>(data: &'a [u8]) None => bad!(), }; if their_schema_version == shared::SCHEMA_VERSION { - return Ok(None) + return Ok(None); } let needle = "\"version\":\""; let rest = match data.find(needle) { @@ -471,7 +472,7 @@ fn reset_indentation(s: &str) -> String { // backwards-compatibility with these options. fn threads_config() -> Option { if env::var("WASM_BINDGEN_THREADS").is_err() { - return None + return None; } let mut cfg = threads_xform::Config::new(); if let Ok(s) = env::var("WASM_BINDGEN_THREADS_MAX_MEMORY") { diff --git a/crates/cli/src/bin/wasm-bindgen-test-runner/server.rs b/crates/cli/src/bin/wasm-bindgen-test-runner/server.rs index ab548cfb..12294b8a 100644 --- a/crates/cli/src/bin/wasm-bindgen-test-runner/server.rs +++ b/crates/cli/src/bin/wasm-bindgen-test-runner/server.rs @@ -98,7 +98,8 @@ pub fn spawn( // header?) response.headers.retain(|(k, _)| k != "Cache-Control"); return response; - }).map_err(|e| format_err!("{}", e))?; + }) + .map_err(|e| format_err!("{}", e))?; return Ok(srv); fn try_asset(request: &Request, dir: &Path) -> Response { diff --git a/crates/futures/tests/tests.rs b/crates/futures/tests/tests.rs index 2303d855..87d8a1f4 100644 --- a/crates/futures/tests/tests.rs +++ b/crates/futures/tests/tests.rs @@ -6,8 +6,8 @@ extern crate wasm_bindgen; extern crate wasm_bindgen_futures; extern crate wasm_bindgen_test; -use futures::Future; use futures::unsync::oneshot; +use futures::Future; use wasm_bindgen::prelude::*; use wasm_bindgen_futures::{future_to_promise, JsFuture}; use wasm_bindgen_test::*; @@ -18,7 +18,8 @@ fn promise_resolve_is_ok_future() -> impl Future { JsFuture::from(p) .map(|x| { assert_eq!(x, 42); - }).map_err(|_| unreachable!()) + }) + .map_err(|_| unreachable!()) } #[wasm_bindgen_test(async)] @@ -37,7 +38,8 @@ fn ok_future_is_resolved_promise() -> impl Future { JsFuture::from(p) .map(|x| { assert_eq!(x, 42); - }).map_err(|_| unreachable!()) + }) + .map_err(|_| unreachable!()) } #[wasm_bindgen_test(async)] @@ -51,7 +53,7 @@ fn error_future_is_rejected_promise() -> impl Future } #[wasm_bindgen] -extern { +extern "C" { fn setTimeout(c: &Closure); } diff --git a/crates/gc/src/bitvec.rs b/crates/gc/src/bitvec.rs index 98cdee83..b3585466 100644 --- a/crates/gc/src/bitvec.rs +++ b/crates/gc/src/bitvec.rs @@ -42,9 +42,7 @@ impl BitSet { let i = *i as usize; let idx = i / BITS; let bit = 1 << (i % BITS); - self.bits.get(idx) - .map(|x| *x & bit != 0) - .unwrap_or(false) + self.bits.get(idx).map(|x| *x & bit != 0).unwrap_or(false) } } diff --git a/crates/gc/src/lib.rs b/crates/gc/src/lib.rs index 4ce1fb7f..ec4a459c 100644 --- a/crates/gc/src/lib.rs +++ b/crates/gc/src/lib.rs @@ -8,7 +8,7 @@ extern crate parity_wasm; extern crate log; extern crate rustc_demangle; -use std::collections::{HashSet, HashMap}; +use std::collections::{HashMap, HashSet}; use std::iter; use std::mem; @@ -66,7 +66,7 @@ fn run(config: &mut Config, module: &mut Module) { if let Some(section) = module.export_section() { for (i, entry) in section.entries().iter().enumerate() { if cx.blacklist.contains(entry.field()) { - continue + continue; } cx.add_export_entry(entry, i as u32); } @@ -85,19 +85,19 @@ fn run(config: &mut Config, module: &mut Module) { let retain = match module.sections_mut()[i] { Section::Unparsed { .. } => { info!("unparsed section"); - continue + continue; } Section::Custom(ref s) => { if !cx.config.keep_debug && s.name().starts_with(".debug_") { false } else { info!("skipping custom section: {}", s.name()); - continue + continue; } } Section::Reloc(..) => { info!("skipping reloc section"); - continue + continue; } Section::Type(ref mut s) => cx.remap_type_section(s), Section::Import(ref mut s) => cx.remap_import_section(s), @@ -106,11 +106,17 @@ fn run(config: &mut Config, module: &mut Module) { Section::Memory(ref mut s) => cx.remap_memory_section(s), Section::Global(ref mut s) => cx.remap_global_section(s), Section::Export(ref mut s) => cx.remap_export_section(s), - Section::Start(ref mut i) => { cx.remap_function_idx(i); true } + Section::Start(ref mut i) => { + cx.remap_function_idx(i); + true + } Section::Element(ref mut s) => cx.remap_element_section(s), Section::Code(ref mut s) => cx.remap_code_section(s), Section::Data(ref mut s) => cx.remap_data_section(s), - Section::Name(ref mut s) => { cx.remap_name_section(s); true } + Section::Name(ref mut s) => { + cx.remap_name_section(s); + true + } }; if !retain { debug!("remove empty section"); @@ -187,20 +193,19 @@ impl<'a> LiveContext<'a> { fn add_function(&mut self, idx: u32) { if !self.analysis.functions.insert(idx) { - return + return; } debug!("adding function: {}", idx); if idx < self.analysis.imported_functions { let imports = self.import_section.unwrap(); - let (i, import) = imports.entries() + let (i, import) = imports + .entries() .iter() .enumerate() - .filter(|&(_, i)| { - match *i.external() { - External::Function(_) => true, - _ => false, - } + .filter(|&(_, i)| match *i.external() { + External::Function(_) => true, + _ => false, }) .skip(idx as usize) .next() @@ -217,13 +222,14 @@ impl<'a> LiveContext<'a> { fn add_table(&mut self, idx: u32) { if !self.analysis.tables.insert(idx) { - return + return; } debug!("adding table: {}", idx); // Add all element segments that initialize this table if let Some(elements) = self.element_section { - let iter = elements.entries() + let iter = elements + .entries() .iter() .enumerate() .filter(|(_, d)| !d.passive() && d.index() == idx); @@ -234,14 +240,13 @@ impl<'a> LiveContext<'a> { if idx < self.analysis.imported_tables { let imports = self.import_section.unwrap(); - let (i, import) = imports.entries() + let (i, import) = imports + .entries() .iter() .enumerate() - .filter(|&(_, i)| { - match *i.external() { - External::Table(_) => true, - _ => false, - } + .filter(|&(_, i)| match *i.external() { + External::Table(_) => true, + _ => false, }) .skip(idx as usize) .next() @@ -257,13 +262,14 @@ impl<'a> LiveContext<'a> { fn add_memory(&mut self, idx: u32) { if !self.analysis.memories.insert(idx) { - return + return; } debug!("adding memory: {}", idx); // Add all data segments that initialize this memory if let Some(data) = self.data_section { - let iter = data.entries() + let iter = data + .entries() .iter() .enumerate() .filter(|(_, d)| !d.passive() && d.index() == idx); @@ -275,14 +281,13 @@ impl<'a> LiveContext<'a> { // ... and add the import if it's an imported memory .. if idx < self.analysis.imported_memories { let imports = self.import_section.unwrap(); - let (i, import) = imports.entries() + let (i, import) = imports + .entries() .iter() .enumerate() - .filter(|&(_, i)| { - match *i.external() { - External::Memory(_) => true, - _ => false, - } + .filter(|&(_, i)| match *i.external() { + External::Memory(_) => true, + _ => false, }) .skip(idx as usize) .next() @@ -296,20 +301,19 @@ impl<'a> LiveContext<'a> { fn add_global(&mut self, idx: u32) { if !self.analysis.globals.insert(idx) { - return + return; } debug!("adding global: {}", idx); if idx < self.analysis.imported_globals { let imports = self.import_section.unwrap(); - let (i, import) = imports.entries() + let (i, import) = imports + .entries() .iter() .enumerate() - .filter(|&(_, i)| { - match *i.external() { - External::Global(_) => true, - _ => false, - } + .filter(|&(_, i)| match *i.external() { + External::Global(_) => true, + _ => false, }) .skip(idx as usize) .next() @@ -337,7 +341,7 @@ impl<'a> LiveContext<'a> { fn add_type(&mut self, idx: u32) { if !self.analysis.types.insert(idx) { - return + return; } let types = self.type_section.expect("no types section"); match types.types()[idx as usize] { @@ -377,23 +381,20 @@ impl<'a> LiveContext<'a> { fn add_opcode(&mut self, code: &Instruction) { match *code { - Instruction::Block(ref b) | - Instruction::Loop(ref b) | - Instruction::If(ref b) => self.add_block_type(b), + Instruction::Block(ref b) | Instruction::Loop(ref b) | Instruction::If(ref b) => { + self.add_block_type(b) + } Instruction::Call(f) => self.add_function(f), Instruction::CallIndirect(t, _) => { self.add_type(t); self.add_table(0); } - Instruction::GetGlobal(i) | - Instruction::SetGlobal(i) => self.add_global(i), - Instruction::MemoryInit(i) | - Instruction::MemoryDrop(i) => { + Instruction::GetGlobal(i) | Instruction::SetGlobal(i) => self.add_global(i), + Instruction::MemoryInit(i) | Instruction::MemoryDrop(i) => { self.add_memory(0); self.add_data_segment(i); } - Instruction::TableInit(i) | - Instruction::TableDrop(i) => { + Instruction::TableInit(i) | Instruction::TableDrop(i) => { self.add_table(0); self.add_element_segment(i); } @@ -410,7 +411,7 @@ impl<'a> LiveContext<'a> { fn add_export_entry(&mut self, entry: &ExportEntry, idx: u32) { if !self.analysis.exports.insert(idx) { - return + return; } match *entry.internal() { Internal::Function(i) => self.add_function(i), @@ -422,7 +423,7 @@ impl<'a> LiveContext<'a> { fn add_import_entry(&mut self, entry: &ImportEntry, idx: u32) { if !self.analysis.imports.insert(idx) { - return + return; } debug!("adding import: {}", idx); match *entry.external() { @@ -435,7 +436,7 @@ impl<'a> LiveContext<'a> { fn add_data_segment(&mut self, idx: u32) { if !self.analysis.data_segments.insert(idx) { - return + return; } let data = &self.data_section.unwrap().entries()[idx as usize]; if !data.passive() { @@ -448,7 +449,7 @@ impl<'a> LiveContext<'a> { fn add_element_segment(&mut self, idx: u32) { if !self.analysis.elements.insert(idx) { - return + return; } let seg = &self.element_section.unwrap().entries()[idx as usize]; for member in seg.members() { @@ -495,7 +496,7 @@ impl<'a> RemapContext<'a> { if let Some(prev) = map.get(&ty) { types.push(*prev); analysis.types.remove(&(i as u32)); - continue + continue; } map.insert(ty, ntypes); types.push(ntypes); @@ -525,7 +526,10 @@ impl<'a> RemapContext<'a> { } if let Some(s) = m.function_section() { for i in 0..(s.entries().len() as u32) { - if analysis.functions.contains(&(i + analysis.imported_functions)) { + if analysis + .functions + .contains(&(i + analysis.imported_functions)) + { functions.push(nfunctions); nfunctions += 1; } else { @@ -558,7 +562,10 @@ impl<'a> RemapContext<'a> { } if let Some(s) = m.memory_section() { for i in 0..(s.entries().len() as u32) { - if analysis.memories.contains(&(i + analysis.imported_memories)) { + if analysis + .memories + .contains(&(i + analysis.imported_memories)) + { memories.push(nmemories); nmemories += 1; } else { @@ -804,17 +811,20 @@ impl<'a> RemapContext<'a> { fn remap_instruction(&self, i: &mut Instruction) { match *i { - Instruction::Block(ref mut b) | - Instruction::Loop(ref mut b) | - Instruction::If(ref mut b) => self.remap_block_type(b), + Instruction::Block(ref mut b) + | Instruction::Loop(ref mut b) + | Instruction::If(ref mut b) => self.remap_block_type(b), Instruction::Call(ref mut f) => self.remap_function_idx(f), Instruction::CallIndirect(ref mut t, _) => self.remap_type_idx(t), - Instruction::GetGlobal(ref mut i) | - Instruction::SetGlobal(ref mut i) => self.remap_global_idx(i), - Instruction::TableInit(ref mut i) | - Instruction::TableDrop(ref mut i) => self.remap_element_idx(i), - Instruction::MemoryInit(ref mut i) | - Instruction::MemoryDrop(ref mut i) => self.remap_data_idx(i), + Instruction::GetGlobal(ref mut i) | Instruction::SetGlobal(ref mut i) => { + self.remap_global_idx(i) + } + Instruction::TableInit(ref mut i) | Instruction::TableDrop(ref mut i) => { + self.remap_element_idx(i) + } + Instruction::MemoryInit(ref mut i) | Instruction::MemoryDrop(ref mut i) => { + self.remap_data_idx(i) + } _ => {} } } @@ -984,7 +994,7 @@ fn gc_body( let mut next = ty.params().len() as u32; for i in ty.params().len()..used.len() { if !used[i] { - continue + continue; } // We're using this local, so map it to the next index (the lowest). // Find all other locals with the same type and lump then into our @@ -999,13 +1009,12 @@ fn gc_body( next += 1; } } - body.locals_mut().push(Local::new((next - before) as u32, local_tys[i])); + body.locals_mut() + .push(Local::new((next - before) as u32, local_tys[i])); } for instr in body.code_mut().elements_mut() { - let get = |i: &u32| { - map[*i as usize].unwrap() - }; + let get = |i: &u32| map[*i as usize].unwrap(); match instr { Instruction::GetLocal(i) => *i = get(i), Instruction::SetLocal(i) => *i = get(i), diff --git a/crates/gc/tests/all.rs b/crates/gc/tests/all.rs index b7ed038b..9f016775 100644 --- a/crates/gc/tests/all.rs +++ b/crates/gc/tests/all.rs @@ -10,8 +10,8 @@ use std::io; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; -use rayon::prelude::*; use parity_wasm::elements::Module; +use rayon::prelude::*; use tempfile::NamedTempFile; struct Test { @@ -31,13 +31,11 @@ fn find_tests(tests: &mut Vec, path: &Path) { let path = entry.path(); if entry.file_type().unwrap().is_dir() { find_tests(tests, &path); - continue + continue; } if path.extension().and_then(|s| s.to_str()) == Some("wat") { - tests.push(Test { - input: path, - }); + tests.push(Test { input: path }); } } } @@ -45,10 +43,9 @@ fn find_tests(tests: &mut Vec, path: &Path) { fn run_tests(tests: &[Test]) { println!(""); - let results = tests.par_iter() - .map(|test| { - run_test(test).map_err(|e| (test, e.to_string())) - }) + let results = tests + .par_iter() + .map(|test| run_test(test).map_err(|e| (test, e.to_string()))) .collect::>(); let mut bad = false; @@ -81,7 +78,7 @@ fn run_test(test: &Test) -> Result<(), Box> { .arg(f.path()) .status()?; if !status.success() { - return Err(io::Error::new(io::ErrorKind::Other, "failed to run wat2wasm").into()) + return Err(io::Error::new(io::ErrorKind::Other, "failed to run wat2wasm").into()); } let wasm = fs::read(f.path())?; @@ -100,7 +97,7 @@ fn run_test(test: &Test) -> Result<(), Box> { .stderr(Stdio::inherit()) .output()?; if !status.status.success() { - return Err(io::Error::new(io::ErrorKind::Other, "failed to run wasm2wat").into()) + return Err(io::Error::new(io::ErrorKind::Other, "failed to run wasm2wat").into()); } let actual = String::from_utf8(status.stdout)?; let actual = actual.trim(); @@ -110,8 +107,7 @@ fn run_test(test: &Test) -> Result<(), Box> { } else { if actual != expected { println!("{:?} {:?}", actual, expected); - return Err(io::Error::new(io::ErrorKind::Other, - "test failed").into()) + return Err(io::Error::new(io::ErrorKind::Other, "test failed").into()); } } @@ -119,7 +115,8 @@ fn run_test(test: &Test) -> Result<(), Box> { } fn extract_expected(input: &str) -> String { - input.lines() + input + .lines() .filter(|l| l.starts_with(";; ")) .skip_while(|l| !l.contains("STDOUT")) .skip(1) @@ -130,7 +127,8 @@ fn extract_expected(input: &str) -> String { } fn generate_blesssed(input: &str, actual: &str) -> String { - let mut input = input.lines() + let mut input = input + .lines() .filter(|l| !l.starts_with(";;")) .collect::>() .join("\n") @@ -144,5 +142,5 @@ fn generate_blesssed(input: &str, actual: &str) -> String { input.push_str("\n"); } input.push_str(";; STDOUT\n"); - return input + return input; } diff --git a/crates/js-sys/tests/wasm/DataView.rs b/crates/js-sys/tests/wasm/DataView.rs index 565f67ec..7747019a 100644 --- a/crates/js-sys/tests/wasm/DataView.rs +++ b/crates/js-sys/tests/wasm/DataView.rs @@ -52,8 +52,14 @@ fn test() { v.set_float64(0, 123456789.123456); assert_eq!(v.get_float64(0), 123456789.123456); v.set_float64_endian(0, f64::from_bits(0x1122334411223344), true); - assert_eq!(v.get_float64_endian(0, true), f64::from_bits(0x1122334411223344)); - assert_eq!(v.get_float64_endian(0, false), f64::from_bits(0x4433221144332211)); + assert_eq!( + v.get_float64_endian(0, true), + f64::from_bits(0x1122334411223344) + ); + assert_eq!( + v.get_float64_endian(0, false), + f64::from_bits(0x4433221144332211) + ); v.set_int8(0, 42); diff --git a/crates/js-sys/tests/wasm/Iterator.rs b/crates/js-sys/tests/wasm/Iterator.rs index 94fe14c5..f06c58b5 100644 --- a/crates/js-sys/tests/wasm/Iterator.rs +++ b/crates/js-sys/tests/wasm/Iterator.rs @@ -30,19 +30,13 @@ fn try_iter_handles_iteration_protocol() { assert!(try_iter(&get_not_iterable()).unwrap().is_none()); assert!(try_iter(&get_symbol_iterator_throws()).is_err()); - assert!( - try_iter(&get_symbol_iterator_not_function()) - .unwrap() - .is_none() - ); - assert!( - try_iter(&get_symbol_iterator_returns_not_object()) - .unwrap() - .is_none() - ); - assert!( - try_iter(&get_symbol_iterator_returns_object_without_next()) - .unwrap() - .is_none() - ); + assert!(try_iter(&get_symbol_iterator_not_function()) + .unwrap() + .is_none()); + assert!(try_iter(&get_symbol_iterator_returns_not_object()) + .unwrap() + .is_none()); + assert!(try_iter(&get_symbol_iterator_returns_object_without_next()) + .unwrap() + .is_none()); } diff --git a/crates/js-sys/tests/wasm/WebAssembly.rs b/crates/js-sys/tests/wasm/WebAssembly.rs index 301ba164..a662f9f0 100644 --- a/crates/js-sys/tests/wasm/WebAssembly.rs +++ b/crates/js-sys/tests/wasm/WebAssembly.rs @@ -62,7 +62,8 @@ fn compile_valid() -> impl Future { JsFuture::from(p) .map(|module| { assert!(module.is_instance_of::()); - }).map_err(|_| unreachable!()) + }) + .map_err(|_| unreachable!()) } #[wasm_bindgen_test] @@ -197,11 +198,9 @@ fn instantiate_streaming() -> impl Future { let imports = get_imports(); let p = WebAssembly::instantiate_streaming(&response, &imports); JsFuture::from(p).map(|obj| { - assert!( - Reflect::get(obj.as_ref(), &"instance".into()) - .unwrap() - .is_instance_of::() - ); + assert!(Reflect::get(obj.as_ref(), &"instance".into()) + .unwrap() + .is_instance_of::()); }) } diff --git a/crates/macro-support/src/parser.rs b/crates/macro-support/src/parser.rs index 75963987..64925010 100644 --- a/crates/macro-support/src/parser.rs +++ b/crates/macro-support/src/parser.rs @@ -50,7 +50,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::Module(s) => Some(&s[..]), _ => None, - }).next() + }) + .next() } /// Whether the catch attribute is present @@ -76,7 +77,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::StaticMethodOf(c) => Some(c), _ => None, - }).next() + }) + .next() } /// Whether the method attributes is present @@ -94,7 +96,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::JsNamespace(s) => Some(s), _ => None, - }).next() + }) + .next() } /// Get the first getter attribute @@ -104,7 +107,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::Getter(g) => Some(g.clone()), _ => None, - }).next() + }) + .next() } /// Get the first setter attribute @@ -114,7 +118,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::Setter(s) => Some(s.clone()), _ => None, - }).next() + }) + .next() } /// Whether the indexing getter attributes is present @@ -151,10 +156,13 @@ impl BindgenAttrs { /// Whether the `final` attribute is present fn final_(&self) -> Option<&Ident> { - self.attrs.iter().filter_map(|a| match a { - BindgenAttr::Final(i) => Some(i), - _ => None, - }).next() + self.attrs + .iter() + .filter_map(|a| match a { + BindgenAttr::Final(i) => Some(i), + _ => None, + }) + .next() } /// Whether the readonly attributes is present @@ -172,7 +180,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::JsName(s, span) => Some((&s[..], *span)), _ => None, - }).next() + }) + .next() } /// Get the first js_class attribute @@ -182,7 +191,8 @@ impl BindgenAttrs { .filter_map(|a| match a { BindgenAttr::JsClass(s) => Some(&s[..]), _ => None, - }).next() + }) + .next() } /// Return the list of classes that a type extends @@ -281,7 +291,7 @@ impl Parse for BindgenAttr { return Ok(BindgenAttr::Structural); } if attr == "final" { - return Ok(BindgenAttr::Final(attr)) + return Ok(BindgenAttr::Final(attr)); } if attr == "readonly" { return Ok(BindgenAttr::Readonly); @@ -386,7 +396,8 @@ impl<'a> ConvertToAst for &'a mut syn::ItemStruct { ); } let mut fields = Vec::new(); - let js_name = opts.js_name() + let js_name = opts + .js_name() .map(|s| s.0.to_string()) .unwrap_or(self.ident.to_string()); if let syn::Fields::Named(names) = &mut self.fields { @@ -441,7 +452,8 @@ impl<'a> ConvertToAst<(BindgenAttrs, &'a Option)> for syn::ForeignItemFn self.vis.clone(), false, None, - )?.0; + )? + .0; let catch = opts.catch(); let variadic = opts.variadic(); let js_ret = if catch { @@ -664,7 +676,8 @@ impl ConvertToAst for syn::ItemFn { self.vis, false, None, - )?.0) + )? + .0) } } @@ -735,7 +748,8 @@ fn function_from_decl( None } _ => panic!("arguments cannot be `self` or ignored"), - }).collect::>(); + }) + .collect::>(); let ret = match output { syn::ReturnType::Default => None, @@ -832,7 +846,7 @@ impl<'a> MacroParse<(Option, &'a mut TokenStream)> for syn::Item { bail_span!( self, "#[wasm_bindgen] can only be applied to a function, \ - struct, enum, impl, or extern block", + struct, enum, impl, or extern block", ); } } @@ -885,9 +899,11 @@ impl<'a> MacroParse for &'a mut syn::ItemImpl { } impl<'a, 'b> MacroParse<&'a BindgenAttrs> for (&'a Ident, &'b mut syn::ImplItem) { - fn macro_parse(self, program: &mut ast::Program, impl_opts: &'a BindgenAttrs) - -> Result<(), Diagnostic> - { + fn macro_parse( + self, + program: &mut ast::Program, + impl_opts: &'a BindgenAttrs, + ) -> Result<(), Diagnostic> { let (class, item) = self; let method = match item { syn::ImplItem::Method(ref mut m) => m, @@ -939,7 +955,8 @@ impl<'a, 'b> MacroParse<&'a BindgenAttrs> for (&'a Ident, &'b mut syn::ImplItem) true, Some(class), )?; - let js_class = impl_opts.js_class() + let js_class = impl_opts + .js_class() .map(|s| s.to_string()) .unwrap_or(class.to_string()); @@ -1001,7 +1018,8 @@ impl MacroParse<()> for syn::ItemEnum { name: v.ident.clone(), value, }) - }).collect::>()?; + }) + .collect::>()?; let comments = extract_doc_comments(&self.attrs); program.enums.push(ast::Enum { name: self.ident, @@ -1025,10 +1043,10 @@ impl MacroParse for syn::ItemConst { .. }) => { program.typescript_custom_sections.push(litstr.value()); - }, + } _ => { bail_span!(self, "Expected a string literal to be used with #[wasm_bindgen(typescript_custom_section)]."); - }, + } } Ok(()) diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs index 7dd02340..5cb245c6 100644 --- a/crates/shared/src/lib.rs +++ b/crates/shared/src/lib.rs @@ -6,113 +6,114 @@ pub const SCHEMA_VERSION: &str = env!("CARGO_PKG_VERSION"); #[macro_export] macro_rules! shared_api { - ($mac:ident) => ($mac! { -struct Program<'a> { - exports: Vec>, - enums: Vec>, - imports: Vec>, - structs: Vec>, - typescript_custom_sections: Vec<&'a str>, - // version: &'a str, - // schema_version: &'a str, -} + ($mac:ident) => { + $mac! { + struct Program<'a> { + exports: Vec>, + enums: Vec>, + imports: Vec>, + structs: Vec>, + typescript_custom_sections: Vec<&'a str>, + // version: &'a str, + // schema_version: &'a str, + } -struct Import<'a> { - module: Option<&'a str>, - js_namespace: Option<&'a str>, - kind: ImportKind<'a>, -} + struct Import<'a> { + module: Option<&'a str>, + js_namespace: Option<&'a str>, + kind: ImportKind<'a>, + } -enum ImportKind<'a> { - Function(ImportFunction<'a>), - Static(ImportStatic<'a>), - Type(ImportType<'a>), - Enum(ImportEnum), -} + enum ImportKind<'a> { + Function(ImportFunction<'a>), + Static(ImportStatic<'a>), + Type(ImportType<'a>), + Enum(ImportEnum), + } -struct ImportFunction<'a> { - shim: &'a str, - catch: bool, - variadic: bool, - method: Option>, - structural: bool, - function: Function<'a>, -} + struct ImportFunction<'a> { + shim: &'a str, + catch: bool, + variadic: bool, + method: Option>, + structural: bool, + function: Function<'a>, + } -struct MethodData<'a> { - class: &'a str, - kind: MethodKind<'a>, -} + struct MethodData<'a> { + class: &'a str, + kind: MethodKind<'a>, + } -enum MethodKind<'a> { - Constructor, - Operation(Operation<'a>), -} + enum MethodKind<'a> { + Constructor, + Operation(Operation<'a>), + } -struct Operation<'a> { - is_static: bool, - kind: OperationKind<'a>, -} + struct Operation<'a> { + is_static: bool, + kind: OperationKind<'a>, + } -enum OperationKind<'a> { - Regular, - Getter(&'a str), - Setter(&'a str), - IndexingGetter, - IndexingSetter, - IndexingDeleter, -} + enum OperationKind<'a> { + Regular, + Getter(&'a str), + Setter(&'a str), + IndexingGetter, + IndexingSetter, + IndexingDeleter, + } -struct ImportStatic<'a> { - name: &'a str, - shim: &'a str, -} + struct ImportStatic<'a> { + name: &'a str, + shim: &'a str, + } -struct ImportType<'a> { - name: &'a str, - instanceof_shim: &'a str, - vendor_prefixes: Vec<&'a str>, -} + struct ImportType<'a> { + name: &'a str, + instanceof_shim: &'a str, + vendor_prefixes: Vec<&'a str>, + } -struct ImportEnum {} + struct ImportEnum {} -struct Export<'a> { - class: Option<&'a str>, - method: bool, - consumed: bool, - is_constructor: bool, - function: Function<'a>, - comments: Vec<&'a str>, -} + struct Export<'a> { + class: Option<&'a str>, + method: bool, + consumed: bool, + is_constructor: bool, + function: Function<'a>, + comments: Vec<&'a str>, + } -struct Enum<'a> { - name: &'a str, - variants: Vec>, - comments: Vec<&'a str>, -} + struct Enum<'a> { + name: &'a str, + variants: Vec>, + comments: Vec<&'a str>, + } -struct EnumVariant<'a> { - name: &'a str, - value: u32, -} + struct EnumVariant<'a> { + name: &'a str, + value: u32, + } -struct Function<'a> { - name: &'a str, -} + struct Function<'a> { + name: &'a str, + } -struct Struct<'a> { - name: &'a str, - fields: Vec>, - comments: Vec<&'a str>, -} - -struct StructField<'a> { - name: &'a str, - readonly: bool, - comments: Vec<&'a str>, -} -}) // end of mac case + struct Struct<'a> { + name: &'a str, + fields: Vec>, + comments: Vec<&'a str>, + } + struct StructField<'a> { + name: &'a str, + readonly: bool, + comments: Vec<&'a str>, + } + } + }; // end of mac case } // end of mac definition pub fn new_function(struct_name: &str) -> String { diff --git a/crates/test-macro/src/lib.rs b/crates/test-macro/src/lib.rs index 9f64413a..582d3199 100644 --- a/crates/test-macro/src/lib.rs +++ b/crates/test-macro/src/lib.rs @@ -74,7 +74,8 @@ pub fn wasm_bindgen_test( #test_body } } - }).into_iter(), + }) + .into_iter(), ); tokens.extend(leading_tokens); diff --git a/crates/threads-xform/src/lib.rs b/crates/threads-xform/src/lib.rs index 51806100..1fbede76 100644 --- a/crates/threads-xform/src/lib.rs +++ b/crates/threads-xform/src/lib.rs @@ -21,7 +21,7 @@ impl Config { /// Create a new configuration with default settings. pub fn new() -> Config { Config { - maximum_memory: 1 << 30, // 1GB + maximum_memory: 1 << 30, // 1GB thread_stack_size: 1 << 20, // 1MB } } @@ -103,9 +103,7 @@ struct PassiveSegment { len: u32, } -fn switch_data_segments_to_passive(module: &mut Module) - -> Result, Error> -{ +fn switch_data_segments_to_passive(module: &mut Module) -> Result, Error> { // If there's no data, nothing to make passive! let section = match module.data_section_mut() { Some(section) => section, @@ -147,9 +145,7 @@ fn get_offset(offset: &mut InitExpr) -> Result<&mut i32, Error> { } } -fn import_memory_zero(module: &mut Module) - -> Result<(), Error> -{ +fn import_memory_zero(module: &mut Module) -> Result<(), Error> { // If memory is exported, let's switch it to imported. If memory isn't // exported then there's nothing to do as we'll deal with importing it // later. @@ -170,18 +166,14 @@ fn import_memory_zero(module: &mut Module) // Remove all memory sections as well as exported memory, we're switching to // an import - module.sections_mut().retain(|s| { - match s { - Section::Memory(_) => false, - _ => true, - } + module.sections_mut().retain(|s| match s { + Section::Memory(_) => false, + _ => true, }); if let Some(s) = module.export_section_mut() { - s.entries_mut().retain(|s| { - match s.internal() { - Internal::Memory(_) => false, - _ => true, - } + s.entries_mut().retain(|s| match s.internal() { + Internal::Memory(_) => false, + _ => true, }); } @@ -215,14 +207,14 @@ fn maybe_add_import_section(module: &mut Module) -> usize { _ => {} } pos = Some(i); - break + break; } let empty = ImportSection::with_entries(Vec::new()); let section = Section::Import(empty); let len = module.sections().len(); let pos = pos.unwrap_or_else(|| len - 1); module.sections_mut().insert(pos, section); - return pos + return pos; } fn share_imported_memory_zero(module: &mut Module, memory_max: u32) -> Result<(), Error> { @@ -245,7 +237,7 @@ fn share_imported_memory_zero(module: &mut Module, memory_max: u32) -> Result<() Some(mem.limits().maximum().unwrap_or(memory_max / PAGE_SIZE)), true, ); - return Ok(()) + return Ok(()); } panic!("failed to find an imported memory") } @@ -293,23 +285,23 @@ fn maybe_add_global_section(module: &mut Module) -> usize { // https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#high-level-structure for i in 0..module.sections().len() { match &mut module.sections_mut()[i] { - Section::Type(_) | - Section::Import(_) | - Section::Function(_) | - Section::Table(_) | - Section::Memory(_) => continue, + Section::Type(_) + | Section::Import(_) + | Section::Function(_) + | Section::Table(_) + | Section::Memory(_) => continue, Section::Global(_) => return i, _ => {} } pos = Some(i); - break + break; } let empty = GlobalSection::with_entries(Vec::new()); let section = Section::Global(empty); let len = module.sections().len(); let pos = pos.unwrap_or_else(|| len - 1); module.sections_mut().insert(pos, section); - return pos + return pos; } fn inject_thread_id_counter(module: &mut Module) -> Result { @@ -323,14 +315,13 @@ fn inject_thread_id_counter(module: &mut Module) -> Result { None => bail!("failed to find `__heap_base` for injecting thread id"), }; - exports.entries() + exports + .entries() .iter() .filter(|e| e.field() == "__heap_base") - .filter_map(|e| { - match e.internal() { - Internal::Global(idx) => Some(*idx), - _ => None, - } + .filter_map(|e| match e.internal() { + Internal::Global(idx) => Some(*idx), + _ => None, }) .next() }; @@ -414,7 +405,8 @@ fn find_stack_pointer(module: &mut Module) -> Result, Error> { Some(s) => s, None => bail!("failed to find the stack pointer"), }; - let candidates = globals.entries() + let candidates = globals + .entries() .iter() .enumerate() .filter(|(_, g)| g.global_type().content_type() == ValueType::I32) @@ -424,17 +416,19 @@ fn find_stack_pointer(module: &mut Module) -> Result, Error> { // If there are no mutable i32 globals, assume this module doesn't even need // a stack pointer! if candidates.len() == 0 { - return Ok(None) + return Ok(None); } // Currently LLVM/LLD always use global 0 as the stack pointer, let's just // blindly assume that. if candidates[0].0 == 0 { - return Ok(Some(0)) + return Ok(Some(0)); } - bail!("the first global wasn't a mutable i32, has LLD changed or was \ - this wasm file not produced by LLD?") + bail!( + "the first global wasn't a mutable i32, has LLD changed or was \ + this wasm file not produced by LLD?" + ) } fn start_with_init_memory( @@ -451,7 +445,10 @@ fn start_with_init_memory( // Execute an atomic add to learn what our thread ID is instrs.push(Instruction::I32Const(addr as i32)); instrs.push(Instruction::I32Const(1)); - let mem = parity_wasm::elements::MemArg { align: 2, offset: 0 }; + let mem = parity_wasm::elements::MemArg { + align: 2, + offset: 0, + }; instrs.push(Instruction::I32AtomicRmwAdd(mem)); // Store this thread ID into our thread ID global @@ -500,7 +497,7 @@ fn start_with_init_memory( instrs.push(Instruction::I32Const(segment.offset as i32)); // offset into segment instrs.push(Instruction::I32Const(0)); // offset into segment - // amount to copy + // amount to copy instrs.push(Instruction::I32Const(segment.len as i32)); instrs.push(Instruction::MemoryInit(segment.idx)); } @@ -531,13 +528,14 @@ fn start_with_init_memory( }; // ... and also be sure to add its signature to the function section ... let type_idx = { - let section = module.type_section_mut().expect("module has no type section"); - let pos = section.types() + let section = module + .type_section_mut() + .expect("module has no type section"); + let pos = section + .types() .iter() - .map(|t| { - match t { - Type::Function(t) => t, - } + .map(|t| match t { + Type::Function(t) => t, }) .position(|t| t.params().is_empty() && t.return_type().is_none()); match pos { @@ -549,7 +547,8 @@ fn start_with_init_memory( } } }; - module.function_section_mut() + module + .function_section_mut() .expect("module has no function section") .entries_mut() .push(Func::new(type_idx)); @@ -566,21 +565,21 @@ fn update_start_section(module: &mut Module, start: u32) { let mut pos = None; for i in 0..module.sections().len() { match &mut module.sections_mut()[i] { - Section::Type(_) | - Section::Import(_) | - Section::Function(_) | - Section::Table(_) | - Section::Memory(_) | - Section::Global(_) | - Section::Export(_) => continue, + Section::Type(_) + | Section::Import(_) + | Section::Function(_) + | Section::Table(_) + | Section::Memory(_) + | Section::Global(_) + | Section::Export(_) => continue, Section::Start(start_idx) => { *start_idx = start; - return + return; } _ => {} } pos = Some(i); - break + break; } let section = Section::Start(start); let len = module.sections().len(); @@ -588,28 +587,22 @@ fn update_start_section(module: &mut Module, start: u32) { module.sections_mut().insert(pos, section); } -fn implement_thread_intrinsics( - module: &mut Module, - globals: &Globals, -) -> Result<(), Error> { +fn implement_thread_intrinsics(module: &mut Module, globals: &Globals) -> Result<(), Error> { let mut map = HashMap::new(); { let imports = match module.import_section() { Some(i) => i, None => return Ok(()), }; - let entries = imports.entries() + let entries = imports + .entries() .iter() - .filter(|i| { - match i.external() { - External::Function(_) => true, - _ => false, - } + .filter(|i| match i.external() { + External::Function(_) => true, + _ => false, }) .enumerate() - .filter(|(_, entry)| { - entry.module() == "__wbindgen_thread_xform__" - }); + .filter(|(_, entry)| entry.module() == "__wbindgen_thread_xform__"); for (idx, entry) in entries { let type_idx = match entry.external() { External::Function(i) => *i, @@ -622,17 +615,13 @@ fn implement_thread_intrinsics( // Validate the type for this intrinsic match entry.field() { "__wbindgen_thread_id" => { - if !fty.params().is_empty() || - fty.return_type() != Some(ValueType::I32) - { + if !fty.params().is_empty() || fty.return_type() != Some(ValueType::I32) { bail!("__wbindgen_thread_id intrinsic has the wrong signature"); } map.insert(idx as u32, Instruction::GetGlobal(globals.thread_id)); } "__wbindgen_tcb_get" => { - if !fty.params().is_empty() || - fty.return_type() != Some(ValueType::I32) - { + if !fty.params().is_empty() || fty.return_type() != Some(ValueType::I32) { bail!("__wbindgen_tcb_get intrinsic has the wrong signature"); } map.insert(idx as u32, Instruction::GetGlobal(globals.thread_tcb)); @@ -653,12 +642,10 @@ fn implement_thread_intrinsics( for body in module.code_section_mut().unwrap().bodies_mut() { for instr in body.code_mut().elements_mut() { let other = match instr { - Instruction::Call(idx) => { - match map.get(idx) { - Some(other) => other, - None => continue, - } - } + Instruction::Call(idx) => match map.get(idx) { + Some(other) => other, + None => continue, + }, _ => continue, }; *instr = other.clone(); diff --git a/crates/typescript/src/parser.rs b/crates/typescript/src/parser.rs index 24fc3834..0421e551 100644 --- a/crates/typescript/src/parser.rs +++ b/crates/typescript/src/parser.rs @@ -93,7 +93,8 @@ fn build_function( segments, }, }) - }).collect::>(); + }) + .collect::>(); let mut ret_segments = syn::punctuated::Punctuated::new(); ret_segments.push(syn::PathSegment { diff --git a/crates/wasm-interpreter/src/lib.rs b/crates/wasm-interpreter/src/lib.rs index 6a8627e0..387a2371 100644 --- a/crates/wasm-interpreter/src/lib.rs +++ b/crates/wasm-interpreter/src/lib.rs @@ -262,10 +262,12 @@ impl Interpreter { Instruction::I32Const(x) => Some((i, x as u32, entry)), _ => None, } - }).find(|(_i, offset, entry)| { + }) + .find(|(_i, offset, entry)| { *offset <= descriptor_table_idx && descriptor_table_idx < (*offset + entry.members().len() as u32) - }).expect("failed to find index in table elements"); + }) + .expect("failed to find index in table elements"); let idx = (descriptor_table_idx - offset) as usize; let descriptor_idx = entry.members()[idx]; @@ -300,7 +302,8 @@ impl Interpreter { .map(|i| { assert_eq!(i.value_type(), ValueType::I32); i.count() - }).unwrap_or(0); + }) + .unwrap_or(0); let code_sig = sections.functions.entries()[code_idx].type_ref(); let function_ty = match §ions.types.types()[code_sig as usize] { diff --git a/crates/web-sys/build.rs b/crates/web-sys/build.rs index 2bac1ecc..d14dd161 100644 --- a/crates/web-sys/build.rs +++ b/crates/web-sys/build.rs @@ -59,7 +59,8 @@ fn try_main() -> Result<(), failure::Error> { .map(|mut p| { p.drain(0.."CARGO_FEATURE_".len()); p - }).collect::>(); + }) + .collect::>(); let mut allowed = Vec::new(); for feature in features.filter(|f| !f.starts_with("#") && !f.starts_with("[")) { diff --git a/crates/web-sys/tests/wasm/element.rs b/crates/web-sys/tests/wasm/element.rs index 041d9d0c..1d1148b3 100644 --- a/crates/web-sys/tests/wasm/element.rs +++ b/crates/web-sys/tests/wasm/element.rs @@ -10,8 +10,8 @@ extern "C" { #[wasm_bindgen_test] fn element() { /* Tests needed for: - namespace_uri -*/ + namespace_uri + */ let element = new_div(); assert_eq!(element.prefix(), None, "Shouldn't have a prefix"); @@ -52,17 +52,17 @@ fn element() { "Should return nothing if removed" ); /* Tests needed for: -get_attribute_ns -*/ + get_attribute_ns + */ /*TODO should we enable toggle_attribute tests? (Firefox Nightly + Chrome canary only) - // TODO toggle_attribute should permit a single argument when optional arguments are supported - assert!(!element.has_attribute("disabled"), "Should not be disabled"); - assert!(element.toggle_attribute("disabled", true).unwrap(), "Should return true when attribute is set"); - assert!(element.has_attribute("disabled"), "Should be disabled"); - assert!(!element.toggle_attribute("disabled", false).unwrap(), "Should return false when attribute is not set"); - assert!(!element.has_attribute("disabled"), "Should not be disabled"); -*/ + // TODO toggle_attribute should permit a single argument when optional arguments are supported + assert!(!element.has_attribute("disabled"), "Should not be disabled"); + assert!(element.toggle_attribute("disabled", true).unwrap(), "Should return true when attribute is set"); + assert!(element.has_attribute("disabled"), "Should be disabled"); + assert!(!element.toggle_attribute("disabled", false).unwrap(), "Should return false when attribute is not set"); + assert!(!element.has_attribute("disabled"), "Should not be disabled"); + */ assert!(!element.has_attribute("title"), "Should not have a title"); assert_eq!( @@ -79,8 +79,8 @@ get_attribute_ns ); assert!(!element.has_attribute("title"), "Should not have a title"); /* Tests needed for: -set_attribute_ns -*/ + set_attribute_ns + */ assert!(!element.has_attributes(), "Should not have any attributes"); assert_eq!( @@ -95,10 +95,10 @@ set_attribute_ns "Should return nothing if removed" ); /* Tests needed for: -remove_attribute_ns -has_attribure_ns -closest -*/ + remove_attribute_ns + has_attribure_ns + closest + */ assert_eq!( element.matches(".this-is-a-thing").unwrap(), @@ -130,29 +130,29 @@ closest // TODO non standard moz_matches_selector should we even support? /* Tests needed for: -insert_adjacent_element -insert_adjacent_text -set_pointer_capture -release_pointer_capture -has_pointer_capture -set_capture -release_capture -scroll_top -set_scroll_top -scroll_left -set_scroll_left -scroll_width -scroll_height -scroll, -scroll_to -scroll_by -client_top -client_left -client_width -client_height -scroll_top_max -scroll_left_max -*/ + insert_adjacent_element + insert_adjacent_text + set_pointer_capture + release_pointer_capture + has_pointer_capture + set_capture + release_capture + scroll_top + set_scroll_top + scroll_left + set_scroll_left + scroll_width + scroll_height + scroll, + scroll_to + scroll_by + client_top + client_left + client_width + client_height + scroll_top_max + scroll_left_max + */ assert_eq!(element.inner_html(), "", "Should return no content"); element.set_inner_html("Hey!Web!"); assert_eq!( @@ -173,10 +173,10 @@ scroll_left_max assert_eq!(element.inner_html(), "", "Should return no content"); /* Tests needed for: -outer_html -set_outer_html -insert_adjacent_html -*/ + outer_html + set_outer_html + insert_adjacent_html + */ assert!( element.query_selector(".none-existant").unwrap().is_none(), @@ -191,9 +191,9 @@ insert_adjacent_html "Should return no results" ); /* Tests needed for: - slot - set_slot - request_fullscreen - request_pointer_lock -*/ + slot + set_slot + request_fullscreen + request_pointer_lock + */ } diff --git a/crates/web-sys/tests/wasm/html_element.rs b/crates/web-sys/tests/wasm/html_element.rs index 00490750..6456835b 100644 --- a/crates/web-sys/tests/wasm/html_element.rs +++ b/crates/web-sys/tests/wasm/html_element.rs @@ -70,12 +70,12 @@ fn test_html_element() { assert!(element.is_content_editable(), "Should be content_editable"); /*TODO doesn't work in Chrome - // TODO verify case where menu is passed - match element.context_menu() { - None => assert!(true, "Shouldn't have a custom menu set"), - _ => assert!(false, "Shouldn't have a custom menu set") - }; -*/ + // TODO verify case where menu is passed + match element.context_menu() { + None => assert!(true, "Shouldn't have a custom menu set"), + _ => assert!(false, "Shouldn't have a custom menu set") + }; + */ // TODO: This test is also broken in Chrome (but not Firefox). // assert!(!element.spellcheck(), "Shouldn't be spellchecked"); diff --git a/crates/web-sys/tests/wasm/input_element.rs b/crates/web-sys/tests/wasm/input_element.rs index 21583f99..a77cd021 100644 --- a/crates/web-sys/tests/wasm/input_element.rs +++ b/crates/web-sys/tests/wasm/input_element.rs @@ -53,10 +53,10 @@ fn test_input_element() { assert!(element.default_checked(), "Should have an default_checked"); /*TODO fix - assert!(!element.checked(), "Shouldn't be checked"); - element.set_checked(true); - assert!(element.checked(), "Should be checked"); -*/ + assert!(!element.checked(), "Shouldn't be checked"); + element.set_checked(true); + assert!(element.checked(), "Should be checked"); + */ assert!(!element.disabled(), "Shouldn't be disabled"); element.set_disabled(true); @@ -114,29 +114,29 @@ fn test_input_element() { assert!(!element.indeterminate(), "Shouldn't be indeterminate"); */ /*TODO add tests -pub fn indeterminate(&self) -> bool -pub fn set_indeterminate(&self, indeterminate: bool) -pub fn input_mode(&self) -> String -pub fn set_input_mode(&self, input_mode: &str) -pub fn list(&self) -> Option -pub fn max(&self) -> String -pub fn set_max(&self, max: &str) -pub fn max_length(&self) -> i32 -pub fn set_max_length(&self, max_length: i32) -pub fn min(&self) -> String -pub fn set_min(&self, min: &str) -pub fn min_length(&self) -> i32 -pub fn set_min_length(&self, min_length: i32) -pub fn multiple(&self) -> bool -pub fn set_multiple(&self, multiple: bool) -*/ + pub fn indeterminate(&self) -> bool + pub fn set_indeterminate(&self, indeterminate: bool) + pub fn input_mode(&self) -> String + pub fn set_input_mode(&self, input_mode: &str) + pub fn list(&self) -> Option + pub fn max(&self) -> String + pub fn set_max(&self, max: &str) + pub fn max_length(&self) -> i32 + pub fn set_max_length(&self, max_length: i32) + pub fn min(&self) -> String + pub fn set_min(&self, min: &str) + pub fn min_length(&self) -> i32 + pub fn set_min_length(&self, min_length: i32) + pub fn multiple(&self) -> bool + pub fn set_multiple(&self, multiple: bool) + */ assert_eq!(element.name(), "", "Should not have a name"); element.set_name("namey"); assert_eq!(element.name(), "namey", "Should have a name"); /*TODO add tests -pub fn pattern(&self) -> String -pub fn set_pattern(&self, pattern: &str) -*/ + pub fn pattern(&self) -> String + pub fn set_pattern(&self, pattern: &str) + */ assert_eq!(element.placeholder(), "", "Should not have a placeholder"); element.set_placeholder("some text"); assert_eq!( @@ -153,30 +153,30 @@ pub fn set_pattern(&self, pattern: &str) element.set_required(true); assert!(element.required(), "Should be required"); /*TODO add tests -pub fn size(&self) -> u32 -pub fn set_size(&self, size: u32) -*/ + pub fn size(&self) -> u32 + pub fn set_size(&self, size: u32) + */ /*TODO fails in chrome - element.set_type("image"); - assert_eq!(element.src(), "", "Should have no src"); - element.set_value("hey.png"); - assert_eq!(element.src(), "hey.png", "Should have a src"); -*/ + element.set_type("image"); + assert_eq!(element.src(), "", "Should have no src"); + element.set_value("hey.png"); + assert_eq!(element.src(), "hey.png", "Should have a src"); + */ /*TODO add tests -pub fn src(&self) -> String -pub fn set_src(&self, src: &str) -pub fn step(&self) -> String -pub fn set_step(&self, step: &str) -pub fn type_(&self) -> String -pub fn set_type(&self, type_: &str) -pub fn default_value(&self) -> String -pub fn set_default_value(&self, default_value: &str) -*/ + pub fn src(&self) -> String + pub fn set_src(&self, src: &str) + pub fn step(&self) -> String + pub fn set_step(&self, step: &str) + pub fn type_(&self) -> String + pub fn set_type(&self, type_: &str) + pub fn default_value(&self) -> String + pub fn set_default_value(&self, default_value: &str) + */ /*TODO fails in chrome - assert_eq!(element.value(), "", "Should have no value"); - element.set_value("hey!"); - assert_eq!(element.value(), "hey!", "Should have a value"); -*/ + assert_eq!(element.value(), "", "Should have no value"); + element.set_value("hey!"); + assert_eq!(element.value(), "hey!", "Should have a value"); + */ element.set_type("number"); element.set_value("1"); assert_eq!(element.value_as_number(), 1.0, "Should have value 1"); @@ -199,31 +199,31 @@ pub fn set_default_value(&self, default_value: &str) assert_eq!(element.check_validity(), true, "Should be valid"); assert_eq!(element.report_validity(), true, "Should be valid"); /*TODO add tests -pub fn labels(&self) -> Option -pub fn select(&self) -pub fn selection_direction(&self) -> Result, JsValue> -pub fn set_selection_direction( - &self, - selection_direction: Option<&str> -) -> Result<(), JsValue> -pub fn set_range_text(&self, replacement: &str) -> Result<(), JsValue> -pub fn set_selection_range( - &self, - start: u32, - end: u32, - direction: &str -) -> Result<(), JsValue> -*/ + pub fn labels(&self) -> Option + pub fn select(&self) + pub fn selection_direction(&self) -> Result, JsValue> + pub fn set_selection_direction( + &self, + selection_direction: Option<&str> + ) -> Result<(), JsValue> + pub fn set_range_text(&self, replacement: &str) -> Result<(), JsValue> + pub fn set_selection_range( + &self, + start: u32, + end: u32, + direction: &str + ) -> Result<(), JsValue> + */ assert_eq!(element.align(), "", "Should have no align"); element.set_align("left"); assert_eq!(element.align(), "left", "Should have an align"); /*TODO add tests -pub fn use_map(&self) -> String -pub fn set_use_map(&self, use_map: &str) -pub fn text_length(&self) -> i32 -pub fn webkitdirectory(&self) -> bool -pub fn set_webkitdirectory(&self, webkitdirectory: bool) -pub fn set_focus_state(&self, a_is_focused: bool) -*/ + pub fn use_map(&self) -> String + pub fn set_use_map(&self, use_map: &str) + pub fn text_length(&self) -> i32 + pub fn webkitdirectory(&self) -> bool + pub fn set_webkitdirectory(&self, webkitdirectory: bool) + pub fn set_focus_state(&self, a_is_focused: bool) + */ } diff --git a/crates/web-sys/tests/wasm/main.rs b/crates/web-sys/tests/wasm/main.rs index 0845e3fb..8f2fd5ff 100644 --- a/crates/web-sys/tests/wasm/main.rs +++ b/crates/web-sys/tests/wasm/main.rs @@ -31,6 +31,7 @@ pub mod input_element; //pub mod menu_element; //pub mod menu_item_element; pub mod dom_point; +pub mod indexeddb; pub mod location; pub mod meta_element; pub mod meter_element; @@ -55,7 +56,6 @@ pub mod style_element; pub mod table_element; pub mod title_element; pub mod xpath_result; -pub mod indexeddb; #[wasm_bindgen_test] fn deref_works() { diff --git a/crates/web-sys/tests/wasm/option_element.rs b/crates/web-sys/tests/wasm/option_element.rs index 826375b7..10661b29 100644 --- a/crates/web-sys/tests/wasm/option_element.rs +++ b/crates/web-sys/tests/wasm/option_element.rs @@ -8,7 +8,8 @@ fn test_option_element() { "option_value", false, true, - ).unwrap(); + ) + .unwrap(); option.set_disabled(true); assert_eq!( diff --git a/crates/webidl/src/first_pass.rs b/crates/webidl/src/first_pass.rs index 663c726f..79b5a2da 100644 --- a/crates/webidl/src/first_pass.rs +++ b/crates/webidl/src/first_pass.rs @@ -312,8 +312,8 @@ impl<'src> FirstPass<'src, ()> for weedle::InterfaceDefinition<'src> { interface_data.partial = false; interface_data.superclass = self.inheritance.map(|s| s.identifier.0); interface_data.definition_attributes = self.attributes.as_ref(); - interface_data.deprecated = util::get_rust_deprecated(&self.attributes) - .map(|s| s.to_string()); + interface_data.deprecated = + util::get_rust_deprecated(&self.attributes).map(|s| s.to_string()); } if let Some(attrs) = &self.attributes { for attr in attrs.body.list.iter() { diff --git a/crates/webidl/src/idl_type.rs b/crates/webidl/src/idl_type.rs index 6d3847d3..2aae8b5e 100644 --- a/crates/webidl/src/idl_type.rs +++ b/crates/webidl/src/idl_type.rs @@ -527,12 +527,13 @@ impl<'a> IdlType<'a> { // it's up to users to dispatch and/or create instances // appropriately. if let syn::Type::Path(path) = &inner { - if path.qself.is_none() && path - .path - .segments - .last() - .map(|p| p.value().ident == "JsValue") - .unwrap_or(false) + if path.qself.is_none() + && path + .path + .segments + .last() + .map(|p| p.value().ident == "JsValue") + .unwrap_or(false) { return Some(inner.clone()); } @@ -678,7 +679,8 @@ fn idl_type_flatten_test() { Sequence(Box::new(Double),), Interface("NodeList"), ])),), - ]).flatten(), + ]) + .flatten(), vec![ Interface("Node"), Sequence(Box::new(Long)), @@ -710,5 +712,6 @@ fn clamped(t: syn::Type) -> syn::Type { .into_iter() .collect(), }, - }.into() + } + .into() } diff --git a/crates/webidl/src/lib.rs b/crates/webidl/src/lib.rs index 0c1bd020..1eecf9f8 100644 --- a/crates/webidl/src/lib.rs +++ b/crates/webidl/src/lib.rs @@ -128,8 +128,7 @@ fn parse(webidl_source: &str, allowed_types: Option<&[&str]>) -> Result if let backend::ast::ImportKind::Type(t) = &mut import.kind { t.extends.retain(|n| { let ident = &n.segments.last().unwrap().value().ident; - first_pass_record.builtin_idents.contains(ident) || - filter(&ident.to_string()) + first_pass_record.builtin_idents.contains(ident) || filter(&ident.to_string()) }); } } @@ -176,7 +175,8 @@ fn builtin_idents() -> BTreeSet { "Promise", "Function", "Clamped", - ].into_iter() + ] + .into_iter() .map(|id| proc_macro2::Ident::new(id, proc_macro2::Span::call_site())), ) } @@ -240,7 +240,8 @@ fn compile_ast(mut ast: Program) -> String { (quote! { pub mod #name { #m_tokens } - }).to_tokens(&mut tokens); + }) + .to_tokens(&mut tokens); } tokens.to_string() } @@ -266,7 +267,8 @@ impl<'src> FirstPassRecord<'src> { } else { rust_ident("None") } - }).collect(), + }) + .collect(), variant_values: variants.iter().map(|v| v.0.to_string()).collect(), rust_attrs: vec![parse_quote!(#[derive(Copy, Clone, PartialEq, Debug)])], }), @@ -505,7 +507,9 @@ impl<'src> FirstPassRecord<'src> { // whitelist a few names that have known polyfills match name { "AudioContext" => { - import_type.vendor_prefixes.push(Ident::new("webkit", Span::call_site())); + import_type + .vendor_prefixes + .push(Ident::new("webkit", Span::call_site())); } _ => {} } @@ -657,12 +661,12 @@ impl<'src> FirstPassRecord<'src> { }; let doc = match id { OperationId::Operation(None) => Some(String::new()), - OperationId::Constructor(_) => { - Some(format!("The `new {}(..)` constructor, creating a new \ - instance of `{0}`\n\n{}", - self_name, - mdn_doc(self_name, Some(self_name)))) - } + OperationId::Constructor(_) => Some(format!( + "The `new {}(..)` constructor, creating a new \ + instance of `{0}`\n\n{}", + self_name, + mdn_doc(self_name, Some(self_name)) + )), OperationId::Operation(Some(name)) => Some(format!( "The `{}()` method\n\n{}", name, diff --git a/crates/webidl/src/util.rs b/crates/webidl/src/util.rs index 2acee7d6..6da1c3d4 100644 --- a/crates/webidl/src/util.rs +++ b/crates/webidl/src/util.rs @@ -30,7 +30,8 @@ pub(crate) fn shared_ref(ty: syn::Type, mutable: bool) -> syn::Type { None }, elem: Box::new(ty), - }.into() + } + .into() } /// Fix case of identifiers like `HTMLBRElement` or `texImage2D` @@ -174,7 +175,8 @@ pub(crate) fn slice_ty(t: syn::Type) -> syn::Type { syn::TypeSlice { bracket_token: Default::default(), elem: Box::new(t), - }.into() + } + .into() } /// From `T` create `Vec`. @@ -571,12 +573,13 @@ impl<'src> FirstPassRecord<'src> { let structural = force_structural || is_structural(signature.orig.attrs.as_ref(), container_attrs); let catch = force_throws || throws(&signature.orig.attrs); - let variadic = signature.args.len() == signature.orig.args.len() && signature - .orig - .args - .last() - .map(|arg| arg.variadic) - .unwrap_or(false); + let variadic = signature.args.len() == signature.orig.args.len() + && signature + .orig + .args + .last() + .map(|arg| arg.variadic) + .unwrap_or(false); ret.extend( self.create_one_function( name, @@ -660,25 +663,20 @@ pub fn is_no_interface_object(ext_attrs: &Option) -> bool has_named_attribute(ext_attrs.as_ref(), "NoInterfaceObject") } -pub fn get_rust_deprecated<'a>(ext_attrs: &Option>) - -> Option<&'a str> -{ - ext_attrs.as_ref()? +pub fn get_rust_deprecated<'a>(ext_attrs: &Option>) -> Option<&'a str> { + ext_attrs + .as_ref()? .body .list .iter() - .filter_map(|attr| { - match attr { - ExtendedAttribute::Ident(id) => Some(id), - _ => None, - } + .filter_map(|attr| match attr { + ExtendedAttribute::Ident(id) => Some(id), + _ => None, }) .filter(|attr| attr.lhs_identifier.0 == "RustDeprecated") - .filter_map(|ident| { - match ident.rhs { - IdentifierOrString::String(s) => Some(s), - IdentifierOrString::Identifier(_) => None, - } + .filter_map(|ident| match ident.rhs { + IdentifierOrString::String(s) => Some(s), + IdentifierOrString::Identifier(_) => None, }) .next() .map(|s| s.0) diff --git a/examples/fetch/src/lib.rs b/examples/fetch/src/lib.rs index eb16781d..30588954 100644 --- a/examples/fetch/src/lib.rs +++ b/examples/fetch/src/lib.rs @@ -51,7 +51,8 @@ pub fn run() -> Promise { let request = Request::new_with_str_and_init( "https://api.github.com/repos/rustwasm/wasm-bindgen/branches/master", &opts, - ).unwrap(); + ) + .unwrap(); request .headers() @@ -67,10 +68,12 @@ pub fn run() -> Promise { assert!(resp_value.is_instance_of::()); let resp: Response = resp_value.dyn_into().unwrap(); resp.json() - }).and_then(|json_value: Promise| { + }) + .and_then(|json_value: Promise| { // Convert this other `Promise` into a rust `Future`. JsFuture::from(json_value) - }).and_then(|json| { + }) + .and_then(|json| { // Use serde to parse the JSON into a struct. let branch_info: Branch = json.into_serde().unwrap(); diff --git a/examples/paint/src/lib.rs b/examples/paint/src/lib.rs index 67910de9..c69a9b67 100644 --- a/examples/paint/src/lib.rs +++ b/examples/paint/src/lib.rs @@ -31,10 +31,7 @@ pub fn main() -> Result<(), JsValue> { context.move_to(event.offset_x() as f64, event.offset_y() as f64); pressed.set(true); }) as Box); - canvas.add_event_listener_with_callback( - "mousedown", - closure.as_ref().unchecked_ref(), - )?; + canvas.add_event_listener_with_callback("mousedown", closure.as_ref().unchecked_ref())?; closure.forget(); } { @@ -48,10 +45,7 @@ pub fn main() -> Result<(), JsValue> { context.move_to(event.offset_x() as f64, event.offset_y() as f64); } }) as Box); - canvas.add_event_listener_with_callback( - "mousemove", - closure.as_ref().unchecked_ref(), - )?; + canvas.add_event_listener_with_callback("mousemove", closure.as_ref().unchecked_ref())?; closure.forget(); } { @@ -62,10 +56,7 @@ pub fn main() -> Result<(), JsValue> { context.line_to(event.offset_x() as f64, event.offset_y() as f64); context.stroke(); }) as Box); - canvas.add_event_listener_with_callback( - "mouseup", - closure.as_ref().unchecked_ref(), - )?; + canvas.add_event_listener_with_callback("mouseup", closure.as_ref().unchecked_ref())?; closure.forget(); } diff --git a/examples/raytrace-parallel/src/lib.rs b/examples/raytrace-parallel/src/lib.rs index db4ca103..708d27ce 100644 --- a/examples/raytrace-parallel/src/lib.rs +++ b/examples/raytrace-parallel/src/lib.rs @@ -7,16 +7,16 @@ extern crate web_sys; use std::cell::RefCell; use std::cmp; use std::rc::Rc; -use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering::SeqCst}; use std::sync::atomic::ATOMIC_USIZE_INIT; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst}; use std::sync::{Arc, Mutex, MutexGuard}; -use futures::Future; use futures::sync::oneshot; -use js_sys::{Promise, Error, WebAssembly, Uint8ClampedArray, Array}; -use wasm_bindgen::JsCast; +use futures::Future; +use js_sys::{Array, Error, Promise, Uint8ClampedArray, WebAssembly}; use wasm_bindgen::prelude::*; -use web_sys::{CanvasRenderingContext2d, Worker, Event, ErrorEvent}; +use wasm_bindgen::JsCast; +use web_sys::{CanvasRenderingContext2d, ErrorEvent, Event, Worker}; use web_sys::{DedicatedWorkerGlobalScope, MessageEvent}; macro_rules! console_log { @@ -42,7 +42,8 @@ impl Scene { pub fn new(object: &JsValue) -> Result { console_error_panic_hook::set_once(); Ok(Scene { - inner: object.into_serde() + inner: object + .into_serde() .map_err(|e| JsValue::from(e.to_string()))?, }) } @@ -82,7 +83,7 @@ impl Scene { Ok(false) => *slot = Some(data), Err(e) => { *slot = Some(data); - return Err(e) + return Err(e); } } } @@ -145,10 +146,7 @@ impl WorkerPool { workers.push(worker); } - Ok(WorkerPool { - workers, - callback, - }) + Ok(WorkerPool { workers, callback }) } } @@ -211,7 +209,7 @@ struct Shared { } #[wasm_bindgen] -extern { +extern "C" { type ImageData; #[wasm_bindgen(constructor, catch)] @@ -234,12 +232,12 @@ impl Render { if let Some(id) = id.as_f64() { if id == self.shared.id as f64 { self.ctx.put_image_data(image.unchecked_ref(), 0.0, 0.0)?; - return Ok(done.as_bool() == Some(true)) + return Ok(done.as_bool() == Some(true)); } } } console_log!("unhandled message: {:?}", data); - return Ok(false) + return Ok(false); } console_log!("unhandled event: {}", event.type_()); @@ -250,13 +248,10 @@ impl Render { #[wasm_bindgen] pub fn child_entry_point(ptr: u32) -> Result<(), JsValue> { - let ptr = unsafe { - Arc::from_raw(ptr as *const Shared) - }; + let ptr = unsafe { Arc::from_raw(ptr as *const Shared) }; assert_send(&ptr); - let global = js_sys::global() - .unchecked_into::(); + let global = js_sys::global().unchecked_into::(); ptr.work(&global)?; return Ok(()); @@ -288,7 +283,7 @@ impl Shared { // If we're beyond the end then we're done! let start = self.next_pixel.fetch_add(BLOCK, SeqCst); if start >= end { - break + break; } // Raytrace all our pixels synchronously, writing all the results @@ -308,8 +303,7 @@ impl Shared { // Ok, time to synchronize and commit this data back into the main // image buffer for other threads and the main thread to see. let mut data = self.rgb_data.lock().unwrap(); - data[start * 4..(start + len) * 4] - .copy_from_slice(&mut local_rgb[..len * 4]); + data[start * 4..(start + len) * 4].copy_from_slice(&mut local_rgb[..len * 4]); // As a "nifty feature" we try to have a live progressive rendering. // That means that we need to periodically send an `ImageData` to @@ -319,7 +313,6 @@ impl Shared { } } - // If we're the last thread out, be sure to update the main thread's // image as this is the last chance we'll get! if self.remaining.fetch_sub(1, SeqCst) == 1 { @@ -341,19 +334,13 @@ impl Shared { // JS array using `slice`. This means we can't use // `web_sys::ImageData` right now but rather we have to use our own // binding. - let mem = wasm_bindgen::memory() - .unchecked_into::(); - let mem = Uint8ClampedArray::new(&mem.buffer()) - .slice( - data.as_ptr() as u32, - data.as_ptr() as u32 + data.len() as u32, - ); + let mem = wasm_bindgen::memory().unchecked_into::(); + let mem = Uint8ClampedArray::new(&mem.buffer()).slice( + data.as_ptr() as u32, + data.as_ptr() as u32 + data.len() as u32, + ); drop(data); // unlock the lock, we've copied the data now - let data = ImageData::new( - &mem, - self.scene.width as f64, - self.scene.height as f64, - )?; + let data = ImageData::new(&mem, self.scene.width as f64, self.scene.height as f64)?; let arr = Array::new(); arr.push(&data); arr.push(&JsValue::from(done)); diff --git a/examples/webaudio/src/lib.rs b/examples/webaudio/src/lib.rs index fa283192..0926ef21 100644 --- a/examples/webaudio/src/lib.rs +++ b/examples/webaudio/src/lib.rs @@ -74,7 +74,6 @@ impl FmOsc { // control the amount of modulation. fm_osc.connect_with_audio_node(&fm_gain)?; - // Connect the FM oscillator to the frequency parameter of the main // oscillator, so that the FM node can modulate its frequency. fm_gain.connect_with_audio_param(&primary.frequency())?; diff --git a/examples/webgl/src/lib.rs b/examples/webgl/src/lib.rs index f65b8d59..16bcf557 100644 --- a/examples/webgl/src/lib.rs +++ b/examples/webgl/src/lib.rs @@ -2,17 +2,16 @@ extern crate js_sys; extern crate wasm_bindgen; extern crate web_sys; +use js_sys::WebAssembly; use wasm_bindgen::prelude::*; use wasm_bindgen::JsCast; use web_sys::{WebGlProgram, WebGlRenderingContext, WebGlShader}; -use js_sys::{WebAssembly}; #[wasm_bindgen] pub fn draw() -> Result<(), JsValue> { let document = web_sys::window().unwrap().document().unwrap(); let canvas = document.get_element_by_id("canvas").unwrap(); - let canvas: web_sys::HtmlCanvasElement = canvas - .dyn_into::()?; + let canvas: web_sys::HtmlCanvasElement = canvas.dyn_into::()?; let context = canvas .get_context("webgl")? @@ -42,12 +41,12 @@ pub fn draw() -> Result<(), JsValue> { context.use_program(Some(&program)); let vertices: [f32; 9] = [-0.7, -0.7, 0.0, 0.7, -0.7, 0.0, 0.0, 0.7, 0.0]; - let memory_buffer = wasm_bindgen::memory().dyn_into::()?.buffer(); + let memory_buffer = wasm_bindgen::memory() + .dyn_into::()? + .buffer(); let vertices_location = vertices.as_ptr() as u32 / 4; - let vert_array = js_sys::Float32Array::new(&memory_buffer).subarray( - vertices_location, - vertices_location + vertices.len() as u32, - ); + let vert_array = js_sys::Float32Array::new(&memory_buffer) + .subarray(vertices_location, vertices_location + vertices.len() as u32); let buffer = context.create_buffer().ok_or("failed to create buffer")?; context.bind_buffer(WebGlRenderingContext::ARRAY_BUFFER, Some(&buffer)); diff --git a/src/lib.rs b/src/lib.rs index cbb71f2e..ce041aaa 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -86,7 +86,6 @@ impl JsValue { _marker: marker::PhantomData, }; - /// The `true` JS value constant. pub const TRUE: JsValue = JsValue { idx: JSIDX_TRUE, @@ -113,9 +112,7 @@ impl JsValue { /// be owned by the JS garbage collector. #[inline] pub fn from_str(s: &str) -> JsValue { - unsafe { - JsValue::_new(__wbindgen_string_new(s.as_ptr(), s.len())) - } + unsafe { JsValue::_new(__wbindgen_string_new(s.as_ptr(), s.len())) } } /// Creates a new JS value which is a number. @@ -124,9 +121,7 @@ impl JsValue { /// allocated number) and returns a handle to the JS version of it. #[inline] pub fn from_f64(n: f64) -> JsValue { - unsafe { - JsValue::_new(__wbindgen_number_new(n)) - } + unsafe { JsValue::_new(__wbindgen_number_new(n)) } } /// Creates a new JS value which is a boolean. @@ -135,7 +130,11 @@ impl JsValue { /// allocated boolean) and returns a handle to the JS version of it. #[inline] pub fn from_bool(b: bool) -> JsValue { - if b { JsValue::TRUE } else { JsValue::FALSE } + if b { + JsValue::TRUE + } else { + JsValue::FALSE + } } /// Creates a new JS value representing `undefined`. @@ -183,9 +182,7 @@ impl JsValue { T: serde::ser::Serialize + ?Sized, { let s = serde_json::to_string(t)?; - unsafe { - Ok(JsValue::_new(__wbindgen_json_parse(s.as_ptr(), s.len()))) - } + unsafe { Ok(JsValue::_new(__wbindgen_json_parse(s.as_ptr(), s.len()))) } } /// Invokes `JSON.stringify` on this value and then parses the resulting @@ -351,7 +348,7 @@ if_std! { } impl<'a> From<&'a str> for JsValue { - #[inline] + #[inline] fn from(s: &'a str) -> JsValue { JsValue::from_str(s) } @@ -588,9 +585,7 @@ impl Deref for JsStatic { // wasm, as the pointer will eventually be invalidated but you can get // `&'static T` from this interface. We... probably need to deprecate // and/or remove this interface nowadays. - unsafe { - self.__inner.with(|ptr| &*(ptr as *const T)) - } + unsafe { self.__inner.with(|ptr| &*(ptr as *const T)) } } } @@ -648,16 +643,12 @@ pub fn throw_val(s: JsValue) -> ! { /// may prevent your wasm module from building down the road. #[doc(hidden)] pub fn module() -> JsValue { - unsafe { - JsValue::_new(__wbindgen_module()) - } + unsafe { JsValue::_new(__wbindgen_module()) } } /// Returns a handle to this wasm instance's `WebAssembly.Memory` pub fn memory() -> JsValue { - unsafe { - JsValue::_new(__wbindgen_memory()) - } + unsafe { JsValue::_new(__wbindgen_memory()) } } #[doc(hidden)] diff --git a/tests/wasm/classes.rs b/tests/wasm/classes.rs index 10b14009..ba64a105 100644 --- a/tests/wasm/classes.rs +++ b/tests/wasm/classes.rs @@ -354,7 +354,6 @@ impl JsRename { #[wasm_bindgen(js_name = classes_foo)] pub fn foo() {} - #[wasm_bindgen] pub struct AccessFieldFoo { pub bar: AccessFieldBar, @@ -389,13 +388,10 @@ pub struct RenamedExport { #[wasm_bindgen(js_class = JsRenamedExport)] impl RenamedExport { #[wasm_bindgen(constructor)] - pub fn new() -> RenamedExport{ - RenamedExport { - x: 3, - } - } - pub fn foo(&self) { + pub fn new() -> RenamedExport { + RenamedExport { x: 3 } } + pub fn foo(&self) {} pub fn bar(&self, other: &RenamedExport) { drop(other); diff --git a/tests/wasm/closures.rs b/tests/wasm/closures.rs index f5e1b9c2..443d270e 100644 --- a/tests/wasm/closures.rs +++ b/tests/wasm/closures.rs @@ -218,13 +218,17 @@ fn drop_drops() { impl Drop for A { fn drop(&mut self) { - unsafe { HIT = true; } + unsafe { + HIT = true; + } } } let a = A; let x: Closure = Closure::new(move || drop(&a)); drop(x); - unsafe { assert!(HIT); } + unsafe { + assert!(HIT); + } } #[wasm_bindgen_test] @@ -233,7 +237,9 @@ fn drop_during_call_ok() { struct A; impl Drop for A { fn drop(&mut self) { - unsafe { HIT = true; } + unsafe { + HIT = true; + } } } @@ -246,7 +252,9 @@ fn drop_during_call_ok() { drop(rc2.borrow_mut().take().unwrap()); // `A` should not have been destroyed as a result - unsafe { assert!(!HIT); } + unsafe { + assert!(!HIT); + } // allocate some heap memory to try to paper over our `3` drop(String::from("1234567890")); @@ -256,12 +264,18 @@ fn drop_during_call_ok() { // make sure `A` is bound to our closure environment. drop(&a); - unsafe { assert!(!HIT); } + unsafe { + assert!(!HIT); + } }); drop_during_call_save(&x); *rc.borrow_mut() = Some(x); drop(rc); - unsafe { assert!(!HIT); } + unsafe { + assert!(!HIT); + } drop_during_call_call(); - unsafe { assert!(HIT); } + unsafe { + assert!(HIT); + } } diff --git a/tests/wasm/imports.rs b/tests/wasm/imports.rs index 15a6c4c2..5c5d35b5 100644 --- a/tests/wasm/imports.rs +++ b/tests/wasm/imports.rs @@ -181,7 +181,7 @@ fn dead_imports_not_generated() { #[cfg(feature = "nightly")] fn import_inside_function_works() { #[wasm_bindgen(module = "tests/wasm/imports.js")] - extern { + extern "C" { fn import_inside_function_works(); } import_inside_function_works(); @@ -199,7 +199,7 @@ mod private { pub fn foo() { #[wasm_bindgen(module = "tests/wasm/imports.js")] - extern { + extern "C" { fn import_inside_private_module(); } import_inside_private_module(); @@ -207,7 +207,7 @@ mod private { } #[wasm_bindgen] -extern { +extern "C" { fn something_not_defined_in_the_environment(); type TypeThatIsNotDefined; @@ -224,7 +224,7 @@ extern { #[wasm_bindgen_test] fn undefined_function_is_ok() { if !should_call_undefined_functions() { - return + return; } something_not_defined_in_the_environment(); diff --git a/tests/wasm/js_objects.rs b/tests/wasm/js_objects.rs index 7cf8c162..85f03c6c 100644 --- a/tests/wasm/js_objects.rs +++ b/tests/wasm/js_objects.rs @@ -132,7 +132,8 @@ fn serde() { b: "foo".to_string(), c: None, d: Bar { a: 1 }, - }).unwrap(), + }) + .unwrap(), ); let foo = ret.into_serde::().unwrap();