diff --git a/cli/build/main.rs b/cli/build/main.rs index 612553e..a03229a 100644 --- a/cli/build/main.rs +++ b/cli/build/main.rs @@ -28,12 +28,12 @@ pub enum Error { impl std::fmt::Display for Error { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { use self::Error::*; - match *self { - Io(ref io) => write!(f, "Generic i/o error: {}", io), - FailedToCopy(ref msg) => write!(f, "{}. Have you tried to run \"cargo build\"?", msg), - Decoding(ref err, ref file) => write!(f, "Decoding error ({}). Must be a valid wasm file {}. Pointed wrong file?", err, file), - Encoding(ref err) => write!(f, "Encoding error ({}). Almost impossible to happen, no free disk space?", err), - Build(ref err) => write!(f, "Build error: {}", err) + match self { + Io(io) => write!(f, "Generic i/o error: {}", io), + FailedToCopy(msg) => write!(f, "{}. Have you tried to run \"cargo build\"?", msg), + Decoding(err, file) => write!(f, "Decoding error ({}). Must be a valid wasm file {}. Pointed wrong file?", err, file), + Encoding(err) => write!(f, "Encoding error ({}). Almost impossible to happen, no free disk space?", err), + Build(err) => write!(f, "Build error: {}", err) } } } @@ -163,9 +163,9 @@ fn do_main() -> Result<(), Error> { None }; - let public_api_entries = matches.value_of("public_api") - .map(|val| val.split(",").collect()) - .unwrap_or(Vec::new()); + let public_api_entries: Vec<_> = matches.value_of("public_api") + .map(|val| val.split(',').collect()) + .unwrap_or_default(); let target_runtime = match matches.value_of("target-runtime").expect("target-runtime has a default value; qed") { "pwasm" => TargetRuntime::pwasm(), diff --git a/cli/build/source.rs b/cli/build/source.rs index adaa927..5583da9 100644 --- a/cli/build/source.rs +++ b/cli/build/source.rs @@ -17,8 +17,8 @@ pub struct SourceInput<'a> { impl<'a> SourceInput<'a> { pub fn new<'b>(target_dir: &'b str, bin_name: &'b str) -> SourceInput<'b> { SourceInput { - target_dir: target_dir, - bin_name: bin_name, + target_dir, + bin_name, final_name: bin_name, target: SourceTarget::Emscripten, } diff --git a/cli/check/main.rs b/cli/check/main.rs index 5d85b74..d3d7a3b 100644 --- a/cli/check/main.rs +++ b/cli/check/main.rs @@ -11,7 +11,7 @@ fn fail(msg: &str) -> ! { std::process::exit(1) } -const ALLOWED_IMPORTS: &'static [&'static str] = &[ +const ALLOWED_IMPORTS: &[&str] = &[ "ret", "storage_read", "storage_write", @@ -54,14 +54,14 @@ fn main() { let module = parity_wasm::deserialize_file(&input).expect("Input module deserialization failed"); for section in module.sections() { - match *section { - elements::Section::Import(ref import_section) => { + match section { + elements::Section::Import(import_section) => { let mut has_imported_memory_properly_named = false; for entry in import_section.entries() { if entry.module() != "env" { fail("All imports should be from env"); } - match *entry.external() { + match entry.external() { elements::External::Function(_) => { if !ALLOWED_IMPORTS.contains(&entry.field()) { fail(&format!("'{}' is not supported by the runtime", entry.field())); diff --git a/src/build.rs b/src/build.rs index e19f30d..e79b72d 100644 --- a/src/build.rs +++ b/src/build.rs @@ -41,22 +41,23 @@ pub enum SourceTarget { impl std::fmt::Display for Error { fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { use self::Error::*; - match *self { - Encoding(ref err) => write!(f, "Encoding error ({})", err), + match self { + Encoding(err) => write!(f, "Encoding error ({})", err), Optimizer => write!(f, "Optimization error due to missing export section. Pointed wrong file?"), - Packing(ref e) => write!(f, "Packing failed due to module structure error: {}. Sure used correct libraries for building contracts?", e), + Packing(e) => write!(f, "Packing failed due to module structure error: {}. Sure used correct libraries for building contracts?", e), } } } fn has_ctor(module: &elements::Module, target_runtime: &TargetRuntime) -> bool { - if let Some(ref section) = module.export_section() { + if let Some(section) = module.export_section() { section.entries().iter().any(|e| target_runtime.symbols().create == e.field()) } else { false } } +#[allow(clippy::too_many_arguments)] pub fn build( mut module: elements::Module, source_target: SourceTarget, diff --git a/src/export_globals.rs b/src/export_globals.rs index 565cb67..0214b51 100644 --- a/src/export_globals.rs +++ b/src/export_globals.rs @@ -22,9 +22,8 @@ pub fn export_mutable_globals( module.sections_mut().push(elements::Section::Export(elements::ExportSection::default())); } - let mut symbol_index = 0usize; let prefix: String = prefix.into(); - for export in exports { + for (symbol_index, export) in exports.into_iter().enumerate() { let new_entry = elements::ExportEntry::new( format!("{}_{}", prefix, symbol_index), elements::Internal::Global( @@ -35,7 +34,6 @@ pub fn export_mutable_globals( .expect("added above if does not exists") .entries_mut() .push(new_entry); - symbol_index += 1; } } diff --git a/src/ext.rs b/src/ext.rs index b13029a..5dc1489 100644 --- a/src/ext.rs +++ b/src/ext.rs @@ -11,7 +11,7 @@ type Insertion = (usize, u32, u32, String); pub fn update_call_index(instructions: &mut elements::Instructions, original_imports: usize, inserts: &[Insertion]) { use parity_wasm::elements::Instruction::*; for instruction in instructions.elements_mut().iter_mut() { - if let &mut Call(ref mut call_index) = instruction { + if let Call(call_index) = instruction { if let Some(pos) = inserts.iter().position(|x| x.1 == *call_index) { *call_index = (original_imports + pos) as u32; } else if *call_index as usize > original_imports { @@ -21,9 +21,9 @@ pub fn update_call_index(instructions: &mut elements::Instructions, original_imp } } -pub fn memory_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::MemorySection> { +pub fn memory_section(module: &mut elements::Module) -> Option<&mut elements::MemorySection> { for section in module.sections_mut() { - if let &mut elements::Section::Memory(ref mut sect) = section { + if let elements::Section::Memory(sect) = section { return Some(sect); } } @@ -61,21 +61,21 @@ pub fn externalize_mem(mut module: elements::Module, adjust_pages: Option, fn foreach_public_func_name(mut module: elements::Module, f: F) -> elements::Module where F: Fn(&mut String) { - import_section(&mut module).map(|is| { - for entry in is.entries_mut() { + if let Some(section) = import_section(&mut module) { + for entry in section.entries_mut() { if let elements::External::Function(_) = *entry.external() { f(entry.field_mut()) } } - }); + } - export_section(&mut module).map(|es| { - for entry in es.entries_mut() { + if let Some(section) = export_section(&mut module) { + for entry in section.entries_mut() { if let elements::Internal::Function(_) = *entry.internal() { f(entry.field_mut()) } } - }); + } module } @@ -96,13 +96,13 @@ pub fn shrink_unknown_stack( let mut new_stack_top = 0; for section in module.sections_mut() { match section { - &mut elements::Section::Data(ref mut data_section) => { - for ref mut data_segment in data_section.entries_mut() { - if data_segment + elements::Section::Data(data_section) => { + for data_segment in data_section.entries_mut() { + if *data_segment .offset() .as_ref() .expect("parity-wasm is compiled without bulk-memory operations") - .code() == &[elements::Instruction::I32Const(4), elements::Instruction::End] + .code() == [elements::Instruction::I32Const(4), elements::Instruction::End] { assert_eq!(data_segment.value().len(), 4); let current_val = LittleEndian::read_u32(data_segment.value()); @@ -127,7 +127,7 @@ pub fn externalize( .import_section().expect("Import section to exist") .entries() .iter() - .filter(|e| if let &elements::External::Function(_) = e.external() { true } else { false }) + .filter(|e| matches!(e.external(), &elements::External::Function(_))) .count(); // First, we find functions indices that are to be rewired to externals @@ -141,7 +141,7 @@ pub fn externalize( .find(|&(_, entry)| entry.field() == f) .expect("All functions of interest to exist"); - if let &elements::Internal::Function(func_idx) = export.1.internal() { + if let elements::Internal::Function(func_idx) = *export.1.internal() { let type_ref = module .function_section().expect("Functions section to exist") .entries()[func_idx as usize - import_funcs_total] @@ -158,12 +158,12 @@ pub fn externalize( // Second, we duplicate them as import definitions let mut mbuilder = builder::from_module(module); - for &(_, _, type_ref, ref field) in replaces.iter() { + for (_, _, type_ref, field) in replaces.iter() { mbuilder.push_import( builder::import() .module("env") .field(field) - .external().func(type_ref) + .external().func(*type_ref) .build() ); } @@ -174,20 +174,20 @@ pub fn externalize( // Third, rewire all calls to imported functions and update all other calls indices for section in module.sections_mut() { match section { - &mut elements::Section::Code(ref mut code_section) => { - for ref mut func_body in code_section.bodies_mut() { + elements::Section::Code(code_section) => { + for func_body in code_section.bodies_mut() { update_call_index(func_body.code_mut(), import_funcs_total, &replaces); } }, - &mut elements::Section::Export(ref mut export_section) => { - for ref mut export in export_section.entries_mut() { - if let &mut elements::Internal::Function(ref mut func_index) = export.internal_mut() { + elements::Section::Export(export_section) => { + for export in export_section.entries_mut() { + if let elements::Internal::Function(func_index) = export.internal_mut() { if *func_index >= import_funcs_total as u32 { *func_index += replaces.len() as u32; } } } }, - &mut elements::Section::Element(ref mut elements_section) => { - for ref mut segment in elements_section.entries_mut() { + elements::Section::Element(elements_section) => { + for segment in elements_section.entries_mut() { // update all indirect call addresses initial values for func_index in segment.members_mut() { if *func_index >= import_funcs_total as u32 { *func_index += replaces.len() as u32; } diff --git a/src/gas/mod.rs b/src/gas/mod.rs index d162291..6f1c1c7 100644 --- a/src/gas/mod.rs +++ b/src/gas/mod.rs @@ -17,7 +17,7 @@ use rules; pub fn update_call_index(instructions: &mut elements::Instructions, inserted_index: u32) { use parity_wasm::elements::Instruction::*; for instruction in instructions.elements_mut().iter_mut() { - if let &mut Call(ref mut call_index) = instruction { + if let Call(call_index) = instruction { if *call_index >= inserted_index { *call_index += 1} } } @@ -273,7 +273,7 @@ pub(crate) fn determine_metered_blocks( for cursor in 0..instructions.elements().len() { let instruction = &instructions.elements()[cursor]; let instruction_cost = rules.process(instruction)?; - match *instruction { + match instruction { Block(_) => { counter.increment(instruction_cost)?; @@ -303,10 +303,10 @@ pub(crate) fn determine_metered_blocks( // Label is a relative index into the control stack. let active_index = counter.active_control_block_index().ok_or_else(|| ())?; - let target_index = active_index.checked_sub(label as usize).ok_or_else(|| ())?; + let target_index = active_index.checked_sub(*label as usize).ok_or_else(|| ())?; counter.branch(cursor, &[target_index])?; } - BrTable(ref br_table_data) => { + BrTable(br_table_data) => { counter.increment(instruction_cost)?; let active_index = counter.active_control_block_index().ok_or_else(|| ())?; @@ -363,7 +363,7 @@ fn insert_metering_calls( let mut block_iter = blocks.into_iter().peekable(); for (original_pos, instr) in original_instrs.into_iter().enumerate() { // If there the next block starts at this position, inject metering instructions. - let used_block = if let Some(ref block) = block_iter.peek() { + let used_block = if let Some(block) = block_iter.peek() { if block.start_pos == original_pos { new_instrs.push(I32Const(block.cost as i32)); new_instrs.push(Call(gas_func)); @@ -453,38 +453,36 @@ pub fn inject_gas_counter(module: elements::Module, rules: &rules::Set, gas_modu // Updating calling addresses (all calls to function index >= `gas_func` should be incremented) for section in module.sections_mut() { match section { - &mut elements::Section::Code(ref mut code_section) => { - for ref mut func_body in code_section.bodies_mut() { + elements::Section::Code(code_section) => { + for func_body in code_section.bodies_mut() { update_call_index(func_body.code_mut(), gas_func); - if let Err(_) = inject_counter(func_body.code_mut(), rules, gas_func) { + if inject_counter(func_body.code_mut(), rules, gas_func).is_err() { error = true; break; } - if rules.grow_cost() > 0 { - if inject_grow_counter(func_body.code_mut(), total_func) > 0 { - need_grow_counter = true; - } + if rules.grow_cost() > 0 && inject_grow_counter(func_body.code_mut(), total_func) > 0 { + need_grow_counter = true; } } }, - &mut elements::Section::Export(ref mut export_section) => { - for ref mut export in export_section.entries_mut() { - if let &mut elements::Internal::Function(ref mut func_index) = export.internal_mut() { + elements::Section::Export(export_section) => { + for export in export_section.entries_mut() { + if let elements::Internal::Function(func_index) = export.internal_mut() { if *func_index >= gas_func { *func_index += 1} } } }, - &mut elements::Section::Element(ref mut elements_section) => { + elements::Section::Element(elements_section) => { // Note that we do not need to check the element type referenced because in the // WebAssembly 1.0 spec, the only allowed element type is funcref. - for ref mut segment in elements_section.entries_mut() { + for segment in elements_section.entries_mut() { // update all indirect call addresses initial values for func_index in segment.members_mut() { if *func_index >= gas_func { *func_index += 1} } } }, - &mut elements::Section::Start(ref mut start_idx) => { + elements::Section::Start(start_idx) => { if *start_idx >= gas_func { *start_idx += 1} }, _ => { } @@ -685,9 +683,10 @@ mod tests { let rules = rules::Set::default().with_forbidden_floats(); - if let Err(_) = inject_gas_counter(module, &rules, "env") { } - else { panic!("Should be error because of the forbidden operation")} + if inject_gas_counter(module, &rules, "env").is_ok() { + panic!("Should be error because of the forbidden operation") + } } fn parse_wat(source: &str) -> elements::Module { diff --git a/src/gas/validation.rs b/src/gas/validation.rs index 18dc101..9bf1eb8 100644 --- a/src/gas/validation.rs +++ b/src/gas/validation.rs @@ -168,7 +168,7 @@ fn build_control_flow_graph( } let instruction_cost = rules.process(instruction)?; - match *instruction { + match instruction { Instruction::Block(_) => { graph.increment_actual_cost(active_node_id, instruction_cost); @@ -221,7 +221,7 @@ fn build_control_flow_graph( graph.increment_actual_cost(active_node_id, instruction_cost); let active_frame_idx = stack.len() - 1; - let target_frame_idx = active_frame_idx - (label as usize); + let target_frame_idx = active_frame_idx - (*label as usize); graph.new_edge(active_node_id, &stack[target_frame_idx]); // Next instruction is unreachable, but carry on anyway. @@ -233,7 +233,7 @@ fn build_control_flow_graph( graph.increment_actual_cost(active_node_id, instruction_cost); let active_frame_idx = stack.len() - 1; - let target_frame_idx = active_frame_idx - (label as usize); + let target_frame_idx = active_frame_idx - (*label as usize); graph.new_edge(active_node_id, &stack[target_frame_idx]); let new_node_id = graph.add_node(); @@ -241,7 +241,7 @@ fn build_control_flow_graph( graph.new_forward_edge(active_node_id, new_node_id); graph.set_first_instr_pos(new_node_id, cursor + 1); } - Instruction::BrTable(ref br_table_data) => { + Instruction::BrTable(br_table_data) => { graph.increment_actual_cost(active_node_id, instruction_cost); let active_frame_idx = stack.len() - 1; @@ -303,7 +303,7 @@ fn validate_graph_gas_costs(graph: &ControlFlowGraph) -> bool { } for loop_node_id in node.loopback_edges.iter() { - let (ref mut loop_actual, ref mut loop_charged) = loop_costs.get_mut(loop_node_id) + let (loop_actual, loop_charged) = loop_costs.get_mut(loop_node_id) .expect("cannot arrive at loopback edge without visiting loop entry node"); if loop_actual != loop_charged { return false; diff --git a/src/graph.rs b/src/graph.rs index ad10598..956cc7f 100644 --- a/src/graph.rs +++ b/src/graph.rs @@ -238,12 +238,10 @@ impl Module { /// Initialize module from parity-wasm `Module`. pub fn from_elements(module: &elements::Module) -> Result { - let mut idx = 0; let mut res = Module::default(); - let mut imported_functions = 0; - for section in module.sections() { + for (idx, section) in module.sections().iter().enumerate() { match section { elements::Section::Type(type_section) => { res.types = RefList::from_slice(type_section.types()); @@ -260,7 +258,7 @@ impl Module { }, elements::External::Memory(m) => { res.memory.push(Memory { - limits: m.limits().clone(), + limits: *m.limits(), origin: entry.into(), }); }, @@ -273,7 +271,7 @@ impl Module { }, elements::External::Table(t) => { res.tables.push(Table { - limits: t.limits().clone(), + limits: *t.limits(), origin: entry.into(), }); }, @@ -296,7 +294,7 @@ impl Module { elements::Section::Table(table_section) => { for t in table_section.entries() { res.tables.push(Table { - limits: t.limits().clone(), + limits: *t.limits(), origin: ImportedOrDeclared::Declared(()), }); } @@ -304,7 +302,7 @@ impl Module { elements::Section::Memory(table_section) => { for t in table_section.entries() { res.memory.push(Memory { - limits: t.limits().clone(), + limits: *t.limits(), origin: ImportedOrDeclared::Declared(()), }); } @@ -322,21 +320,21 @@ impl Module { elements::Section::Export(export_section) => { for e in export_section.entries() { let local = match e.internal() { - &elements::Internal::Function(func_idx) => { - ExportLocal::Func(res.funcs.clone_ref(func_idx as usize)) + elements::Internal::Function(func_idx) => { + ExportLocal::Func(res.funcs.clone_ref(*func_idx as usize)) }, - &elements::Internal::Global(global_idx) => { - ExportLocal::Global(res.globals.clone_ref(global_idx as usize)) + elements::Internal::Global(global_idx) => { + ExportLocal::Global(res.globals.clone_ref(*global_idx as usize)) }, - &elements::Internal::Memory(mem_idx) => { - ExportLocal::Memory(res.memory.clone_ref(mem_idx as usize)) + elements::Internal::Memory(mem_idx) => { + ExportLocal::Memory(res.memory.clone_ref(*mem_idx as usize)) }, - &elements::Internal::Table(table_idx) => { - ExportLocal::Table(res.tables.clone_ref(table_idx as usize)) + elements::Internal::Table(table_idx) => { + ExportLocal::Table(res.tables.clone_ref(*table_idx as usize)) }, }; - res.exports.push(Export { local: local, name: e.field().to_owned() }) + res.exports.push(Export { local, name: e.field().to_owned() }) } }, elements::Section::Start(start_func) => { @@ -368,25 +366,21 @@ impl Module { res.elements.push(ElementSegment { value: funcs_map, - location: location, + location, }); } }, elements::Section::Code(code_section) => { - let mut idx = 0; - for func_body in code_section.bodies() { + for (idx, func_body) in code_section.bodies().iter().enumerate() { let code = res.map_instructions(func_body.code().elements()); - let mut func = res.funcs.get_ref(imported_functions + idx).write(); - match func.origin { - ImportedOrDeclared::Declared(ref mut body) => { + match &mut func.origin { + ImportedOrDeclared::Declared(body) => { body.code = code; - body.locals = func_body.locals().iter().cloned().collect(); + body.locals = func_body.locals().to_vec(); }, _ => { return Err(Error::InconsistentSource); } } - - idx += 1; } }, elements::Section::Data(data_section) => { @@ -402,7 +396,7 @@ impl Module { res.data.push(DataSegment { value: data_segment.value().to_vec(), - location: location, + location, }); } }, @@ -410,7 +404,6 @@ impl Module { res.other.insert(idx, section.clone()); } } - idx += 1; } Ok(res) @@ -425,7 +418,7 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); - if self.types.len() > 0 { + if !self.types.is_empty() { // TYPE SECTION (1) let mut type_section = elements::TypeSection::default(); { @@ -447,8 +440,8 @@ impl Module { let add = { let imports = import_section.entries_mut(); for func in self.funcs.iter() { - match func.read().origin { - Imported(ref module, ref field) => { + match &func.read().origin { + Imported(module, field) => { imports.push( elements::ImportEntry::new( module.to_owned(), @@ -464,8 +457,8 @@ impl Module { } for global in self.globals.iter() { - match global.read().origin { - Imported(ref module, ref field) => { + match &global.read().origin { + Imported(module, field) => { imports.push( elements::ImportEntry::new( module.to_owned(), @@ -484,8 +477,8 @@ impl Module { } for memory in self.memory.iter() { - match memory.read().origin { - Imported(ref module, ref field) => { + match &memory.read().origin { + Imported(module, field) => { imports.push( elements::ImportEntry::new( module.to_owned(), @@ -504,8 +497,8 @@ impl Module { } for table in self.tables.iter() { - match table.read().origin { - Imported(ref module, ref field) => { + match &table.read().origin { + Imported(module, field) => { imports.push( elements::ImportEntry::new( module.to_owned(), @@ -522,7 +515,7 @@ impl Module { _ => continue, } } - imports.len() > 0 + !imports.is_empty() }; if add { @@ -531,7 +524,7 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if self.funcs.len() > 0 { + if !self.funcs.is_empty() { // FUNC SECTION (3) let mut func_section = elements::FunctionSection::default(); { @@ -554,7 +547,7 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if self.tables.len() > 0 { + if !self.tables.is_empty() { // TABLE SECTION (4) let mut table_section = elements::TableSection::default(); { @@ -578,7 +571,7 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if self.memory.len() > 0 { + if !self.memory.is_empty() { // MEMORY SECTION (5) let mut memory_section = elements::MemorySection::default(); { @@ -602,15 +595,15 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if self.globals.len() > 0 { + if !self.globals.is_empty() { // GLOBAL SECTION (6) let mut global_section = elements::GlobalSection::default(); { let globals = global_section.entries_mut(); for global in self.globals.iter() { - match global.read().origin { - Declared(ref init_code) => { + match &global.read().origin { + Declared(init_code) => { globals.push(elements::GlobalEntry::new( elements::GlobalType::new(global.read().content, global.read().is_mut), elements::InitExpr::new(self.generate_instructions(&init_code[..])), @@ -626,24 +619,24 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if self.exports.len() > 0 { + if !self.exports.is_empty() { // EXPORT SECTION (7) let mut export_section = elements::ExportSection::default(); { let exports = export_section.entries_mut(); for export in self.exports.iter() { - let internal = match export.local { - ExportLocal::Func(ref func_ref) => { + let internal = match &export.local { + ExportLocal::Func(func_ref) => { elements::Internal::Function(func_ref.order().ok_or(Error::DetachedEntry)? as u32) }, - ExportLocal::Global(ref global_ref) => { + ExportLocal::Global(global_ref) => { elements::Internal::Global(global_ref.order().ok_or(Error::DetachedEntry)? as u32) }, - ExportLocal::Table(ref table_ref) => { + ExportLocal::Table(table_ref) => { elements::Internal::Table(table_ref.order().ok_or(Error::DetachedEntry)? as u32) }, - ExportLocal::Memory(ref memory_ref) => { + ExportLocal::Memory(memory_ref) => { elements::Internal::Memory(memory_ref.order().ok_or(Error::DetachedEntry)? as u32) }, }; @@ -657,22 +650,22 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if let Some(ref func_ref) = self.start { + if let Some(func_ref) = &self.start { // START SECTION (8) sections.push(elements::Section::Start( func_ref.order().ok_or(Error::DetachedEntry)? as u32 )); } - if self.elements.len() > 0 { + if !self.elements.is_empty() { // START SECTION (9) let mut element_section = elements::ElementSection::default(); { let element_segments = element_section.entries_mut(); for element in self.elements.iter() { - match element.location { - SegmentLocation::Default(ref offset_expr) => { + match &element.location { + SegmentLocation::Default(offset_expr) => { let mut elements_map = Vec::new(); for f in element.value.iter() { elements_map.push(f.order().ok_or(Error::DetachedEntry)? as u32); @@ -697,15 +690,15 @@ impl Module { custom_round(&self.other, &mut idx, &mut sections); } - if self.funcs.len() > 0 { + if !self.funcs.is_empty() { // CODE SECTION (10) let mut code_section = elements::CodeSection::default(); { let funcs = code_section.bodies_mut(); for func in self.funcs.iter() { - match func.read().origin { - Declared(ref body) => { + match &func.read().origin { + Declared(body) => { funcs.push(elements::FuncBody::new( body.locals.clone(), elements::Instructions::new(self.generate_instructions(&body.code[..])), @@ -722,15 +715,15 @@ impl Module { } - if self.data.len() > 0 { + if !self.data.is_empty() { // DATA SECTION (11) let mut data_section = elements::DataSection::default(); { let data_segments = data_section.entries_mut(); for data_entry in self.data.iter() { - match data_entry.location { - SegmentLocation::Default(ref offset_expr) => { + match &data_entry.location { + SegmentLocation::Default(offset_expr) => { data_segments.push( elements::DataSegment::new( 0, @@ -843,7 +836,7 @@ mod tests { let element_func = &sample.elements[0].value[1]; let rfunc = element_func.read(); let rtype = &**rfunc.type_ref.read(); - let elements::Type::Function(ref ftype) = rtype; + let elements::Type::Function(ftype) = rtype; // it's func#1 in the function space assert_eq!(rfunc.order(), Some(1)); @@ -857,7 +850,7 @@ mod tests { let element_func = &sample.elements[0].value[1]; let rfunc = element_func.read(); let rtype = &**rfunc.type_ref.read(); - let elements::Type::Function(ref ftype) = rtype; + let elements::Type::Function(ftype) = rtype; // import deleted so now it's func #0 assert_eq!(rfunc.order(), Some(0)); @@ -891,10 +884,7 @@ mod tests { let declared_func_2 = sample.funcs.clone_ref(2); let mut tx = sample.funcs.begin_insert_not_until( - |f| match f.origin { - super::ImportedOrDeclared::Imported(_, _) => true, - _ => false, - } + |f| matches!(f.origin, super::ImportedOrDeclared::Imported(_, _)) ); let new_import_func = tx.push(super::Func { @@ -908,9 +898,9 @@ mod tests { assert_eq!(declared_func_2.order(), Some(3)); assert_eq!( match &declared_func_2.read().origin { - super::ImportedOrDeclared::Declared(ref body) => { - match body.code[1] { - super::Instruction::Call(ref called_func) => called_func.order(), + super::ImportedOrDeclared::Declared(body) => { + match &body.code[1] { + super::Instruction::Call(called_func) => called_func.order(), _ => panic!("instruction #2 should be a call!"), } }, @@ -975,10 +965,10 @@ mod tests { let declared_func_2 = sample.funcs.clone_ref(2); assert_eq!( match &declared_func_2.read().origin { - super::ImportedOrDeclared::Declared(ref body) => { - match body.code[0] { - super::Instruction::Call(ref called_func) => called_func.order(), - ref wrong_instruction => panic!("instruction #2 should be a call but got {:?}!", wrong_instruction), + super::ImportedOrDeclared::Declared(body) => { + match &body.code[0] { + super::Instruction::Call(called_func) => called_func.order(), + wrong_instruction => panic!("instruction #2 should be a call but got {:?}!", wrong_instruction), } }, _ => panic!("func #0 should be declared!"), diff --git a/src/optimizer.rs b/src/optimizer.rs index f3e2e9b..1497544 100644 --- a/src/optimizer.rs +++ b/src/optimizer.rs @@ -25,7 +25,7 @@ pub fn optimize( // which in turn compile in unused imports and leaves unused functions // try to parse name section - let module_temp = mem::replace(module, elements::Module::default()); + let module_temp = mem::take(module); let module_temp = module_temp .parse_names() .unwrap_or_else(|(_err, module)| module); @@ -34,7 +34,7 @@ pub fn optimize( // Algo starts from the top, listing all items that should stay let mut stay = Set::new(); for (index, entry) in module.export_section().ok_or(Error::NoExportSection)?.entries().iter().enumerate() { - if used_exports.iter().find(|e| **e == entry.field()).is_some() { + if used_exports.iter().any(|e| *e == entry.field()) { stay.insert(Symbol::Export(index)); } } @@ -119,7 +119,7 @@ pub fn optimize( loop { let mut remove = false; match imports.entries()[index].external() { - &elements::External::Function(_) => { + elements::External::Function(_) => { if stay.contains(&Symbol::Import(old_index)) { index += 1; } else { @@ -129,7 +129,7 @@ pub fn optimize( } top_funcs += 1; }, - &elements::External::Global(_) => { + elements::External::Global(_) => { if stay.contains(&Symbol::Import(old_index)) { index += 1; } else { @@ -210,54 +210,55 @@ pub fn optimize( } } - if eliminated_globals.len() > 0 || eliminated_funcs.len() > 0 || eliminated_types.len() > 0 { + if !eliminated_globals.is_empty() || !eliminated_funcs.is_empty() || !eliminated_types.is_empty() { // Finaly, rewire all calls, globals references and types to the new indices // (only if there is anything to do) - eliminated_globals.sort(); - eliminated_funcs.sort(); - eliminated_types.sort(); + // When sorting primitives sorting unstable is faster without any difference in result. + eliminated_globals.sort_unstable(); + eliminated_funcs.sort_unstable(); + eliminated_types.sort_unstable(); for section in module.sections_mut() { match section { - &mut elements::Section::Start(ref mut func_index) if eliminated_funcs.len() > 0 => { + elements::Section::Start(func_index) if !eliminated_funcs.is_empty() => { let totalle = eliminated_funcs.iter().take_while(|i| (**i as u32) < *func_index).count(); *func_index -= totalle as u32; }, - &mut elements::Section::Function(ref mut function_section) if eliminated_types.len() > 0 => { - for ref mut func_signature in function_section.entries_mut() { + elements::Section::Function(function_section) if !eliminated_types.is_empty() => { + for func_signature in function_section.entries_mut() { let totalle = eliminated_types.iter().take_while(|i| (**i as u32) < func_signature.type_ref()).count(); *func_signature.type_ref_mut() -= totalle as u32; } }, - &mut elements::Section::Import(ref mut import_section) if eliminated_types.len() > 0 => { - for ref mut import_entry in import_section.entries_mut() { - if let &mut elements::External::Function(ref mut type_ref) = import_entry.external_mut() { + elements::Section::Import(import_section) if !eliminated_types.is_empty() => { + for import_entry in import_section.entries_mut() { + if let elements::External::Function(type_ref) = import_entry.external_mut() { let totalle = eliminated_types.iter().take_while(|i| (**i as u32) < *type_ref).count(); *type_ref -= totalle as u32; } } }, - &mut elements::Section::Code(ref mut code_section) if eliminated_globals.len() > 0 || eliminated_funcs.len() > 0 => { - for ref mut func_body in code_section.bodies_mut() { - if eliminated_funcs.len() > 0 { + elements::Section::Code(code_section) if !eliminated_globals.is_empty() || !eliminated_funcs.is_empty() => { + for func_body in code_section.bodies_mut() { + if !eliminated_funcs.is_empty() { update_call_index(func_body.code_mut(), &eliminated_funcs); } - if eliminated_globals.len() > 0 { + if !eliminated_globals.is_empty() { update_global_index(func_body.code_mut().elements_mut(), &eliminated_globals) } - if eliminated_types.len() > 0 { + if !eliminated_types.is_empty() { update_type_index(func_body.code_mut(), &eliminated_types) } } }, - &mut elements::Section::Export(ref mut export_section) => { - for ref mut export in export_section.entries_mut() { + elements::Section::Export(export_section) => { + for export in export_section.entries_mut() { match export.internal_mut() { - &mut elements::Internal::Function(ref mut func_index) => { + elements::Internal::Function(func_index) => { let totalle = eliminated_funcs.iter().take_while(|i| (**i as u32) < *func_index).count(); *func_index -= totalle as u32; }, - &mut elements::Internal::Global(ref mut global_index) => { + elements::Internal::Global(global_index) => { let totalle = eliminated_globals.iter().take_while(|i| (**i as u32) < *global_index).count(); *global_index -= totalle as u32; }, @@ -265,13 +266,13 @@ pub fn optimize( } } }, - &mut elements::Section::Global(ref mut global_section) => { - for ref mut global_entry in global_section.entries_mut() { + elements::Section::Global(global_section) => { + for global_entry in global_section.entries_mut() { update_global_index(global_entry.init_expr_mut().code_mut(), &eliminated_globals) } }, - &mut elements::Section::Data(ref mut data_section) => { - for ref mut segment in data_section.entries_mut() { + elements::Section::Data(data_section) => { + for segment in data_section.entries_mut() { update_global_index( segment .offset_mut() @@ -282,8 +283,8 @@ pub fn optimize( ) } }, - &mut elements::Section::Element(ref mut elements_section) => { - for ref mut segment in elements_section.entries_mut() { + elements::Section::Element(elements_section) => { + for segment in elements_section.entries_mut() { update_global_index( segment .offset_mut() @@ -299,9 +300,9 @@ pub fn optimize( } } }, - &mut elements::Section::Name(ref mut name_section) => { - if let Some(ref mut func_name) = name_section.functions_mut() { - let mut func_name_map = mem::replace(func_name.names_mut(), elements::IndexMap::default()); + elements::Section::Name(name_section) => { + if let Some(func_name) = name_section.functions_mut() { + let mut func_name_map = mem::take(func_name.names_mut()); for index in &eliminated_funcs { func_name_map.remove(*index as u32); } @@ -312,8 +313,8 @@ pub fn optimize( *func_name.names_mut() = updated_map; } - if let Some(ref mut local_name) = name_section.locals_mut() { - let mut local_names_map = mem::replace(local_name.local_names_mut(), elements::IndexMap::default()); + if let Some(local_name) = name_section.locals_mut() { + let mut local_names_map = mem::take(local_name.local_names_mut()); for index in &eliminated_funcs { local_names_map.remove(*index as u32); } @@ -336,7 +337,7 @@ pub fn optimize( pub fn update_call_index(instructions: &mut elements::Instructions, eliminated_indices: &[usize]) { use parity_wasm::elements::Instruction::*; for instruction in instructions.elements_mut().iter_mut() { - if let &mut Call(ref mut call_index) = instruction { + if let Call(call_index) = instruction { let totalle = eliminated_indices.iter().take_while(|i| (**i as u32) < *call_index).count(); trace!("rewired call {} -> call {}", *call_index, *call_index - totalle as u32); *call_index -= totalle as u32; @@ -349,7 +350,7 @@ pub fn update_global_index(instructions: &mut Vec, elimin use parity_wasm::elements::Instruction::*; for instruction in instructions.iter_mut() { match instruction { - &mut GetGlobal(ref mut index) | &mut SetGlobal(ref mut index) => { + GetGlobal(index) | SetGlobal(index) => { let totalle = eliminated_indices.iter().take_while(|i| (**i as u32) < *index).count(); trace!("rewired global {} -> global {}", *index, *index - totalle as u32); *index -= totalle as u32; @@ -363,7 +364,7 @@ pub fn update_global_index(instructions: &mut Vec, elimin pub fn update_type_index(instructions: &mut elements::Instructions, eliminated_indices: &[usize]) { use parity_wasm::elements::Instruction::*; for instruction in instructions.elements_mut().iter_mut() { - if let &mut CallIndirect(ref mut call_index, _) = instruction { + if let CallIndirect(call_index, _) = instruction { let totalle = eliminated_indices.iter().take_while(|i| (**i as u32) < *call_index).count(); trace!("rewired call_indrect {} -> call_indirect {}", *call_index, *call_index - totalle as u32); *call_index -= totalle as u32; @@ -371,54 +372,54 @@ pub fn update_type_index(instructions: &mut elements::Instructions, eliminated_i } } -pub fn import_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::ImportSection> { +pub fn import_section(module: &mut elements::Module) -> Option<&mut elements::ImportSection> { for section in module.sections_mut() { - if let &mut elements::Section::Import(ref mut sect) = section { + if let elements::Section::Import(sect) = section { return Some(sect); } } None } -pub fn global_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::GlobalSection> { +pub fn global_section(module: &mut elements::Module) -> Option<&mut elements::GlobalSection> { for section in module.sections_mut() { - if let &mut elements::Section::Global(ref mut sect) = section { + if let elements::Section::Global(sect) = section { return Some(sect); } } None } -pub fn function_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::FunctionSection> { +pub fn function_section(module: &mut elements::Module) -> Option<&mut elements::FunctionSection> { for section in module.sections_mut() { - if let &mut elements::Section::Function(ref mut sect) = section { + if let elements::Section::Function(sect) = section { return Some(sect); } } None } -pub fn code_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::CodeSection> { +pub fn code_section(module: &mut elements::Module) -> Option<&mut elements::CodeSection> { for section in module.sections_mut() { - if let &mut elements::Section::Code(ref mut sect) = section { + if let elements::Section::Code(sect) = section { return Some(sect); } } None } -pub fn export_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::ExportSection> { +pub fn export_section(module: &mut elements::Module) -> Option<&mut elements::ExportSection> { for section in module.sections_mut() { - if let &mut elements::Section::Export(ref mut sect) = section { + if let elements::Section::Export(sect) = section { return Some(sect); } } None } -pub fn type_section<'a>(module: &'a mut elements::Module) -> Option<&'a mut elements::TypeSection> { +pub fn type_section(module: &mut elements::Module) -> Option<&mut elements::TypeSection> { for section in module.sections_mut() { - if let &mut elements::Section::Type(ref mut sect) = section { + if let elements::Section::Type(sect) = section { return Some(sect); } } diff --git a/src/pack.rs b/src/pack.rs index 946074f..0816b5f 100644 --- a/src/pack.rs +++ b/src/pack.rs @@ -56,7 +56,7 @@ pub fn pack_instance(raw_module: Vec, mut ctor_module: elements::Module, tar .find(|entry| target.symbols().create == entry.field()).ok_or_else(|| Error::NoCreateSymbol(target.symbols().create))?; let function_index: usize = match found_entry.internal() { - &Internal::Function(index) => index as usize, + Internal::Function(index) => *index as usize, _ => { return Err(Error::InvalidCreateMember(target.symbols().create)) }, }; @@ -68,7 +68,7 @@ pub fn pack_instance(raw_module: Vec, mut ctor_module: elements::Module, tar .entries().get(function_index - ctor_import_functions).ok_or(Error::MalformedModule)? .type_ref(); - let &elements::Type::Function(ref func) = ctor_module.type_section().ok_or(Error::NoTypeSection)? + let elements::Type::Function(func) = ctor_module.type_section().ok_or(Error::NoTypeSection)? .types().get(type_id as usize).ok_or(Error::MalformedModule)?; // Deploy should have no arguments and also should return nothing @@ -112,21 +112,21 @@ pub fn pack_instance(raw_module: Vec, mut ctor_module: elements::Module, tar let ret_func = ctor_module.import_count(ImportCountType::Function) as u32 - 1; for section in ctor_module.sections_mut() { - match *section { - elements::Section::Code(ref mut code_section) => { - for ref mut func_body in code_section.bodies_mut() { + match section { + elements::Section::Code(code_section) => { + for func_body in code_section.bodies_mut() { update_call_index(func_body.code_mut(), ret_func); } }, - elements::Section::Export(ref mut export_section) => { - for ref mut export in export_section.entries_mut() { - if let &mut elements::Internal::Function(ref mut func_index) = export.internal_mut() { + elements::Section::Export(export_section) => { + for export in export_section.entries_mut() { + if let elements::Internal::Function(func_index) = export.internal_mut() { if *func_index >= ret_func { *func_index += 1} } } }, - elements::Section::Element(ref mut elements_section) => { - for ref mut segment in elements_section.entries_mut() { + elements::Section::Element(elements_section) => { + for segment in elements_section.entries_mut() { // update all indirect call addresses initial values for func_index in segment.members_mut() { if *func_index >= ret_func { *func_index += 1} @@ -150,7 +150,7 @@ pub fn pack_instance(raw_module: Vec, mut ctor_module: elements::Module, tar if ctor_module .sections() .iter() - .find(|section| match **section { Section::Data(ref _d) => true, _ => false }) + .find(|section| matches!(**section, Section::Data(_))) .is_none() { // DataSection has to be the last non-custom section according the to the spec ctor_module.sections_mut().push(Section::Data(DataSection::with_entries(vec![]))); @@ -160,8 +160,8 @@ pub fn pack_instance(raw_module: Vec, mut ctor_module: elements::Module, tar let mut code_data_address = 0i32; for section in ctor_module.sections_mut() { - if let &mut Section::Data(ref mut data_section) = section { - let (index, offset) = if let Some(ref entry) = data_section.entries().iter().last() { + if let Section::Data(data_section) = section { + let (index, offset) = if let Some(entry) = data_section.entries().iter().last() { let init_expr = entry .offset() .as_ref() @@ -202,7 +202,7 @@ pub fn pack_instance(raw_module: Vec, mut ctor_module: elements::Module, tar .build(); for section in new_module.sections_mut() { - if let &mut Section::Export(ref mut export_section) = section { + if let Section::Export(export_section) = section { for entry in export_section.entries_mut().iter_mut() { if target.symbols().create == entry.field() { // change `create` symbol export name into default `call` symbol name. diff --git a/src/ref_list.rs b/src/ref_list.rs index 9e281cc..376486d 100644 --- a/src/ref_list.rs +++ b/src/ref_list.rs @@ -28,7 +28,7 @@ impl Entry { /// New entity. pub fn new(val: T, index: usize) -> Entry { Entry { - val: val, + val, index: EntryOrigin::Index(index), } } @@ -36,7 +36,7 @@ impl Entry { /// New detached entry. pub fn new_detached(val: T) -> Entry { Entry { - val: val, + val, index: EntryOrigin::Detached, } } @@ -152,7 +152,7 @@ impl RefList { /// internal indices of other entries might be updated. pub fn begin_insert(&mut self, at: usize) -> InsertTransaction { InsertTransaction { - at: at, + at, list: self, items: Vec::new(), } @@ -201,17 +201,15 @@ impl RefList { let total_less = indices.iter() .take_while(|x| **x < entry.order().expect("Items in the list always have order; qed")) .count(); - match entry.index { + match &mut entry.index { EntryOrigin::Detached => unreachable!("Items in the list always have order!"), - EntryOrigin::Index(ref mut idx) => { *idx -= total_less; }, + EntryOrigin::Index(idx) => { *idx -= total_less; }, }; } - let mut total_removed = 0; - for idx in indices { + for (total_removed, idx) in indices.iter().enumerate() { let detached = self.items.remove(*idx - total_removed); detached.write().index = EntryOrigin::Detached; - total_removed += 1; } } @@ -258,6 +256,11 @@ impl RefList { self.items.len() } + /// Returns true iff len == 0. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + /// Clone entry (reference counting object to item) by index. /// /// Will panic if index out of bounds. diff --git a/src/rules.rs b/src/rules.rs index f011fc8..93b0d26 100644 --- a/src/rules.rs +++ b/src/rules.rs @@ -285,11 +285,11 @@ impl Default for Set { impl Set { pub fn new(regular: u32, entries: Map) -> Self { - Set { regular: regular, entries: entries, grow: 0 } + Set { regular, entries, grow: 0 } } pub fn process(&self, instruction: &elements::Instruction) -> Result { - match self.entries.get(&InstructionType::op(instruction)).map(|x| *x) { + match self.entries.get(&InstructionType::op(instruction)).cloned() { None | Some(Metering::Regular) => Ok(self.regular), Some(Metering::Forbidden) => Err(()), Some(Metering::Fixed(val)) => Ok(val), diff --git a/src/runtime_type.rs b/src/runtime_type.rs index 8fe8d7d..4b70554 100644 --- a/src/runtime_type.rs +++ b/src/runtime_type.rs @@ -5,14 +5,15 @@ use byteorder::{ LittleEndian, ByteOrder }; pub fn inject_runtime_type(module: Module, runtime_type: [u8; 4], runtime_version: u32) -> Module { let runtime_type: u32 = LittleEndian::read_u32(&runtime_type); let globals_count: u32 = match module.global_section() { - Some(ref section) => section.entries().len() as u32, + Some(section) => section.entries().len() as u32, None => 0 }; let imported_globals_count: u32 = match module.import_section() { - Some(ref section) => section.entries().iter().filter(|e| match *e.external() { - External::Global(ref _a) => true, - _ => false - }).count() as u32, + Some(section) => section + .entries() + .iter() + .filter(|e| matches!(*e.external(), External::Global(_))) + .count() as u32, None => 0 }; let total_globals_count: u32 = globals_count + imported_globals_count; @@ -39,7 +40,7 @@ mod tests { let global_section = module.global_section().expect("Global section expected"); assert_eq!(3, global_section.entries().len()); let export_section = module.export_section().expect("Export section expected"); - assert!(export_section.entries().iter().find(|e| e.field() == "RUNTIME_TYPE" ).is_some()); - assert!(export_section.entries().iter().find(|e| e.field() == "RUNTIME_VERSION" ).is_some()); + assert!(export_section.entries().iter().any(|e| e.field() == "RUNTIME_TYPE")); + assert!(export_section.entries().iter().any(|e| e.field() == "RUNTIME_VERSION")); } } diff --git a/src/stack_height/max_height.rs b/src/stack_height/max_height.rs index d74928d..23c7ea1 100644 --- a/src/stack_height/max_height.rs +++ b/src/stack_height/max_height.rs @@ -157,7 +157,7 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result Result {} Block(ty) | Loop(ty) | If(ty) => { - let end_arity = if ty == BlockType::NoResult { 0 } else { 1 }; + let end_arity = if *ty == BlockType::NoResult { 0 } else { 1 }; let branch_arity = if let Loop(_) = *opcode { 0 } else { end_arity }; let height = stack.height(); stack.push_frame(Frame { @@ -227,7 +227,7 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result { // Pop values for the destination block result. - let target_arity = stack.frame(target)?.branch_arity; + let target_arity = stack.frame(*target)?.branch_arity; stack.pop_values(target_arity)?; // This instruction unconditionally transfers control to the specified block, @@ -236,7 +236,7 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result { // Pop values for the destination block result. - let target_arity = stack.frame(target)?.branch_arity; + let target_arity = stack.frame(*target)?.branch_arity; stack.pop_values(target_arity)?; // Pop condition value. @@ -245,7 +245,7 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result { + BrTable(br_table_data) => { let arity_of_default = stack.frame(br_table_data.default)?.branch_arity; // Check that all jump targets have an equal arities. @@ -273,7 +273,7 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result { - let ty = resolve_func_type(idx, module)?; + let ty = resolve_func_type(*idx, module)?; // Pop values for arguments of the function. stack.pop_values(ty.params().len() as u32)?; @@ -283,9 +283,9 @@ pub(crate) fn compute(func_idx: u32, module: &elements::Module) -> Result { - let Type::Function(ref ty) = *type_section + let Type::Function(ty) = type_section .types() - .get(x as usize) + .get(*x as usize) .ok_or_else(|| Error("Type not found".into()))?; // Pop the offset into the function table. @@ -496,7 +496,7 @@ mod tests { #[test] fn yet_another_test() { - const SOURCE: &'static str = r#" + const SOURCE: &str = r#" (module (memory 0) (func diff --git a/src/stack_height/mod.rs b/src/stack_height/mod.rs index 0f53394..737d84a 100644 --- a/src/stack_height/mod.rs +++ b/src/stack_height/mod.rs @@ -149,7 +149,7 @@ fn generate_stack_height_global(module: &mut elements::Module) -> u32 { // Try to find an existing global section. for section in module.sections_mut() { - if let elements::Section::Global(ref mut gs) = *section { + if let elements::Section::Global(gs) = section { gs.entries_mut().push(global_entry); return (gs.entries().len() as u32) - 1; } @@ -212,7 +212,7 @@ fn compute_stack_cost(func_idx: u32, module: &elements::Module) -> Result Result<(), Error> { for section in module.sections_mut() { - if let elements::Section::Code(ref mut code_section) = *section { + if let elements::Section::Code(code_section) = section { for func_body in code_section.bodies_mut() { let opcodes = func_body.code_mut(); instrument_function(ctx, opcodes)?; @@ -270,8 +270,8 @@ fn instrument_function( let action: Action = { let instruction = &instructions.elements()[cursor]; - match *instruction { - Call(ref callee_idx) => { + match instruction { + Call(callee_idx) => { let callee_stack_cost = ctx .stack_cost(*callee_idx) .ok_or_else(|| @@ -347,8 +347,8 @@ fn resolve_func_type( .expect("function import count is not zero; import section must exists; qed") .entries() .iter() - .filter_map(|entry| match *entry.external() { - elements::External::Function(ref idx) => Some(*idx), + .filter_map(|entry| match entry.external() { + elements::External::Function(idx) => Some(*idx), _ => None, }) .nth(func_idx as usize) @@ -363,7 +363,7 @@ fn resolve_func_type( .ok_or_else(|| Error(format!("Function at index {} is not defined", func_idx)))? .type_ref() }; - let Type::Function(ref ty) = *types.get(sig_idx as usize).ok_or_else(|| { + let Type::Function(ty) = types.get(sig_idx as usize).ok_or_else(|| { Error(format!( "Signature {} (specified by func {}) isn't defined", sig_idx, func_idx diff --git a/src/stack_height/thunk.rs b/src/stack_height/thunk.rs index 2bad3fe..aaa02ee 100644 --- a/src/stack_height/thunk.rs +++ b/src/stack_height/thunk.rs @@ -34,8 +34,8 @@ pub(crate) fn generate_thunks( let start_func_idx = module .start_section(); - let exported_func_indices = exports.iter().filter_map(|entry| match *entry.internal() { - Internal::Function(ref function_idx) => Some(*function_idx), + let exported_func_indices = exports.iter().filter_map(|entry| match entry.internal() { + Internal::Function(function_idx) => Some(*function_idx), _ => None, }); let table_func_indices = elem_segments @@ -119,7 +119,7 @@ pub(crate) fn generate_thunks( let fixup = |function_idx: &mut u32| { // Check whether this function is in replacement_map, since // we can skip thunk generation (e.g. if stack_cost of function is 0). - if let Some(ref thunk) = replacement_map.get(function_idx) { + if let Some(thunk) = replacement_map.get(function_idx) { *function_idx = thunk .idx .expect("At this point an index must be assigned to each thunk"); @@ -127,22 +127,22 @@ pub(crate) fn generate_thunks( }; for section in module.sections_mut() { - match *section { - elements::Section::Export(ref mut export_section) => { + match section { + elements::Section::Export(export_section) => { for entry in export_section.entries_mut() { - if let Internal::Function(ref mut function_idx) = *entry.internal_mut() { + if let Internal::Function(function_idx) = entry.internal_mut() { fixup(function_idx) } } } - elements::Section::Element(ref mut elem_section) => { + elements::Section::Element(elem_section) => { for segment in elem_section.entries_mut() { for function_idx in segment.members_mut() { fixup(function_idx) } } } - elements::Section::Start(ref mut start_idx) => { + elements::Section::Start(start_idx) => { fixup(start_idx) } _ => {} diff --git a/src/symbols.rs b/src/symbols.rs index a15fcfa..60b6ef1 100644 --- a/src/symbols.rs +++ b/src/symbols.rs @@ -19,7 +19,7 @@ pub fn resolve_function(module: &elements::Module, index: u32) -> Symbol { let mut functions = 0; if let Some(import_section) = module.import_section() { for (item_index, item) in import_section.entries().iter().enumerate() { - if let &elements::External::Function(_) = item.external() { + if let elements::External::Function(_) = item.external() { if functions == index { return Symbol::Import(item_index as usize); } @@ -35,7 +35,7 @@ pub fn resolve_global(module: &elements::Module, index: u32) -> Symbol { let mut globals = 0; if let Some(import_section) = module.import_section() { for (item_index, item) in import_section.entries().iter().enumerate() { - if let &elements::External::Global(_) = item.external() { + if let elements::External::Global(_) = item.external() { if globals == index { return Symbol::Import(item_index as usize); } @@ -84,15 +84,15 @@ pub fn expand_symbols(module: &elements::Module, set: &mut Set) { Export(idx) => { let entry = &module.export_section().expect("Export section to exist").entries()[idx]; match entry.internal() { - &elements::Internal::Function(func_idx) => { - let symbol = resolve_function(module, func_idx); + elements::Internal::Function(func_idx) => { + let symbol = resolve_function(module, *func_idx); if !stop.contains(&symbol) { fringe.push(symbol); } set.insert(symbol); }, - &elements::Internal::Global(global_idx) => { - let symbol = resolve_global(module, global_idx); + elements::Internal::Global(global_idx) => { + let symbol = resolve_global(module, *global_idx); if !stop.contains(&symbol) { fringe.push(symbol); } @@ -103,8 +103,8 @@ pub fn expand_symbols(module: &elements::Module, set: &mut Set) { }, Import(idx) => { let entry = &module.import_section().expect("Import section to exist").entries()[idx]; - if let &elements::External::Function(type_idx) = entry.external() { - let type_symbol = Symbol::Type(type_idx as usize); + if let elements::External::Function(type_idx) = entry.external() { + let type_symbol = Symbol::Type(*type_idx as usize); if !stop.contains(&type_symbol) { fringe.push(type_symbol); }