From dae276b54aab6ad3d3ab5649afb6b89db599a04f Mon Sep 17 00:00:00 2001 From: Kevaundray Wedderburn Date: Wed, 12 Apr 2023 19:13:27 +0100 Subject: [PATCH 1/3] add clippy suggestions --- .../codegen/meta/src/cdsl/instructions.rs | 8 +- cranelift/codegen/meta/src/cdsl/operands.rs | 40 ++++---- cranelift/codegen/meta/src/cdsl/settings.rs | 33 +++---- cranelift/codegen/meta/src/cdsl/types.rs | 13 +-- cranelift/codegen/meta/src/cdsl/typevar.rs | 28 +++--- cranelift/codegen/meta/src/constant_hash.rs | 2 +- cranelift/codegen/meta/src/gen_inst.rs | 8 +- cranelift/codegen/meta/src/gen_settings.rs | 14 +-- cranelift/codegen/meta/src/lib.rs | 8 +- cranelift/codegen/meta/src/shared/mod.rs | 4 +- cranelift/codegen/meta/src/srcgen.rs | 4 +- cranelift/control/src/zero_sized.rs | 2 +- cranelift/isle/isle/src/ast.rs | 2 +- cranelift/isle/isle/src/codegen.rs | 12 +-- cranelift/isle/isle/src/error.rs | 4 +- cranelift/isle/isle/src/lexer.rs | 12 +-- cranelift/isle/isle/src/parser.rs | 15 ++- cranelift/isle/isle/src/sema.rs | 94 +++++++++---------- crates/cache/build.rs | 2 +- crates/component-macro/src/bindgen.rs | 6 +- crates/wit-bindgen/src/lib.rs | 12 +-- crates/wit-bindgen/src/rust.rs | 2 +- crates/wit-bindgen/src/types.rs | 2 +- 23 files changed, 144 insertions(+), 183 deletions(-) diff --git a/cranelift/codegen/meta/src/cdsl/instructions.rs b/cranelift/codegen/meta/src/cdsl/instructions.rs index 34961f503447..a0bf34e84932 100644 --- a/cranelift/codegen/meta/src/cdsl/instructions.rs +++ b/cranelift/codegen/meta/src/cdsl/instructions.rs @@ -228,8 +228,8 @@ impl InstructionBuilder { } fn build(self) -> Instruction { - let operands_in = self.operands_in.unwrap_or_else(Vec::new); - let operands_out = self.operands_out.unwrap_or_else(Vec::new); + let operands_in = self.operands_in.unwrap_or_default(); + let operands_out = self.operands_out.unwrap_or_default(); let mut value_opnums = Vec::new(); let mut imm_opnums = Vec::new(); @@ -375,7 +375,7 @@ fn verify_polymorphic( if (free_typevar.is_some() && tv == &free_typevar.unwrap()) || tv.singleton_type().is_some() { - match is_ctrl_typevar_candidate(tv, &operands_in, &operands_out) { + match is_ctrl_typevar_candidate(tv, operands_in, operands_out) { Ok(_other_typevars) => { return Some(PolymorphicInfo { use_typevar_operand: true, @@ -410,7 +410,7 @@ fn verify_polymorphic( // At this point, if the next unwrap() fails, it means the output type couldn't be used as a // controlling type variable either; panicking is the right behavior. - is_ctrl_typevar_candidate(tv, &operands_in, &operands_out).unwrap(); + is_ctrl_typevar_candidate(tv, operands_in, operands_out).unwrap(); Some(PolymorphicInfo { use_typevar_operand: false, diff --git a/cranelift/codegen/meta/src/cdsl/operands.rs b/cranelift/codegen/meta/src/cdsl/operands.rs index 15c10fe4e7e9..f2ec8f9d479c 100644 --- a/cranelift/codegen/meta/src/cdsl/operands.rs +++ b/cranelift/codegen/meta/src/cdsl/operands.rs @@ -50,10 +50,7 @@ impl Operand { } pub fn is_value(&self) -> bool { - match self.kind.fields { - OperandKindFields::TypeVar(_) => true, - _ => false, - } + matches!(self.kind.fields, OperandKindFields::TypeVar(_)) } pub fn type_var(&self) -> Option<&TypeVar> { @@ -64,28 +61,25 @@ impl Operand { } pub fn is_varargs(&self) -> bool { - match self.kind.fields { - OperandKindFields::VariableArgs => true, - _ => false, - } + matches!(self.kind.fields, OperandKindFields::VariableArgs) } /// Returns true if the operand has an immediate kind or is an EntityRef. pub fn is_immediate_or_entityref(&self) -> bool { - match self.kind.fields { + matches!( + self.kind.fields, OperandKindFields::ImmEnum(_) - | OperandKindFields::ImmValue - | OperandKindFields::EntityRef => true, - _ => false, - } + | OperandKindFields::ImmValue + | OperandKindFields::EntityRef + ) } /// Returns true if the operand has an immediate kind. pub fn is_immediate(&self) -> bool { - match self.kind.fields { - OperandKindFields::ImmEnum(_) | OperandKindFields::ImmValue => true, - _ => false, - } + matches!( + self.kind.fields, + OperandKindFields::ImmEnum(_) | OperandKindFields::ImmValue + ) } } @@ -158,18 +152,18 @@ impl OperandKind { } } -impl Into for &TypeVar { - fn into(self) -> OperandKind { +impl From<&TypeVar> for OperandKind { + fn from(type_var: &TypeVar) -> Self { OperandKind { rust_field_name: "value", rust_type: "ir::Value", - fields: OperandKindFields::TypeVar(self.into()), + fields: OperandKindFields::TypeVar(type_var.into()), doc: None, } } } -impl Into for &OperandKind { - fn into(self) -> OperandKind { - self.clone() +impl From<&OperandKind> for OperandKind { + fn from(kind: &OperandKind) -> Self { + kind.clone() } } diff --git a/cranelift/codegen/meta/src/cdsl/settings.rs b/cranelift/codegen/meta/src/cdsl/settings.rs index 358c0879eb6e..a175a6167ef8 100644 --- a/cranelift/codegen/meta/src/cdsl/settings.rs +++ b/cranelift/codegen/meta/src/cdsl/settings.rs @@ -75,14 +75,14 @@ pub(crate) enum PresetType { OtherPreset(PresetIndex), } -impl Into for BoolSettingIndex { - fn into(self) -> PresetType { - PresetType::BoolSetting(self) +impl From for PresetType { + fn from(bool_setting_index: BoolSettingIndex) -> Self { + PresetType::BoolSetting(bool_setting_index) } } -impl Into for PresetIndex { - fn into(self) -> PresetType { - PresetType::OtherPreset(self) +impl From for PresetType { + fn from(value: PresetIndex) -> Self { + PresetType::OtherPreset(value) } } @@ -134,13 +134,7 @@ impl SettingGroup { fn num_bool_settings(&self) -> u8 { self.settings .iter() - .filter(|s| { - if let SpecificSetting::Bool(_) = s.specific { - true - } else { - false - } - }) + .filter(|s| matches!(s.specific, SpecificSetting::Bool(_))) .count() as u8 } @@ -184,14 +178,15 @@ pub(crate) enum PredicateNode { And(Box, Box), } -impl Into for BoolSettingIndex { - fn into(self) -> PredicateNode { - PredicateNode::OwnedBool(self) +impl From for PredicateNode { + fn from(bool_setting_index: BoolSettingIndex) -> Self { + PredicateNode::OwnedBool(bool_setting_index) } } -impl<'a> Into for (BoolSettingIndex, &'a SettingGroup) { - fn into(self) -> PredicateNode { - let (index, group) = (self.0, self.1); + +impl<'a> From<(BoolSettingIndex, &'a SettingGroup)> for PredicateNode { + fn from(val: (BoolSettingIndex, &'a SettingGroup)) -> Self { + let (index, group) = (val.0, val.1); let setting = &group.settings[index.0]; PredicateNode::SharedBool(group.name, setting.name) } diff --git a/cranelift/codegen/meta/src/cdsl/types.rs b/cranelift/codegen/meta/src/cdsl/types.rs index 661ed2c957fe..cfc8c7ed21b0 100644 --- a/cranelift/codegen/meta/src/cdsl/types.rs +++ b/cranelift/codegen/meta/src/cdsl/types.rs @@ -267,12 +267,9 @@ impl Iterator for LaneTypeIterator { type Item = LaneType; fn next(&mut self) -> Option { if let Some(i) = self.int_iter.next() { - Some(LaneType::from(i)) - } else if let Some(f) = self.float_iter.next() { - Some(LaneType::from(f)) - } else { - None + return Some(LaneType::from(i)); } + self.float_iter.next().map(LaneType::from) } } @@ -491,10 +488,6 @@ impl ReferenceTypeIterator { impl Iterator for ReferenceTypeIterator { type Item = ReferenceType; fn next(&mut self) -> Option { - if let Some(r) = self.reference_iter.next() { - Some(ReferenceType::from(r)) - } else { - None - } + self.reference_iter.next().map(ReferenceType::from) } } diff --git a/cranelift/codegen/meta/src/cdsl/typevar.rs b/cranelift/codegen/meta/src/cdsl/typevar.rs index 1d02d8bf7292..fc42f55a36da 100644 --- a/cranelift/codegen/meta/src/cdsl/typevar.rs +++ b/cranelift/codegen/meta/src/cdsl/typevar.rs @@ -279,14 +279,14 @@ impl TypeVar { } } -impl Into for &TypeVar { - fn into(self) -> TypeVar { - self.clone() +impl From<&TypeVar> for TypeVar { + fn from(type_var: &TypeVar) -> Self { + type_var.clone() } } -impl Into for ValueType { - fn into(self) -> TypeVar { - TypeVar::new_singleton(self) +impl From for TypeVar { + fn from(value_type: ValueType) -> Self { + TypeVar::new_singleton(value_type) } } @@ -507,7 +507,7 @@ impl TypeSet { self.dynamic_lanes .iter() .filter(|&&x| x < MAX_LANES) - .map(|&x| x), + .copied(), ); copy.dynamic_lanes = NumSet::new(); copy @@ -660,13 +660,7 @@ pub(crate) enum Interval { impl Interval { fn to_range(&self, full_range: Range, default: Option) -> Option { match self { - Interval::None => { - if let Some(default_val) = default { - Some(default_val..default_val) - } else { - None - } - } + Interval::None => default.map(|default_val| default_val..default_val), Interval::All => Some(full_range), @@ -683,9 +677,9 @@ impl Interval { } } -impl Into for Range { - fn into(self) -> Interval { - Interval::Range(self) +impl From for Interval { + fn from(range: Range) -> Self { + Interval::Range(range) } } diff --git a/cranelift/codegen/meta/src/constant_hash.rs b/cranelift/codegen/meta/src/constant_hash.rs index bb1d4c71f097..a81b0db6f411 100644 --- a/cranelift/codegen/meta/src/constant_hash.rs +++ b/cranelift/codegen/meta/src/constant_hash.rs @@ -30,7 +30,7 @@ pub fn generate_table<'cont, T, I: iter::Iterator, H: Fn(&T) -> let mut table = vec![None; size]; for i in items { - let mut h = hash_function(&i) % size; + let mut h = hash_function(i) % size; let mut s = 0; while table[h].is_some() { s += 1; diff --git a/cranelift/codegen/meta/src/gen_inst.rs b/cranelift/codegen/meta/src/gen_inst.rs index 17aae99915c8..532892248477 100644 --- a/cranelift/codegen/meta/src/gen_inst.rs +++ b/cranelift/codegen/meta/src/gen_inst.rs @@ -700,7 +700,7 @@ fn get_constraint<'entries, 'table>( if let Some(free_typevar) = type_var.free_typevar() { if ctrl_typevar.is_some() && free_typevar != *ctrl_typevar.unwrap() { assert!(type_var.base.is_none()); - return format!("Free({})", type_sets.add(&type_var.get_raw_typeset())); + return format!("Free({})", type_sets.add(type_var.get_raw_typeset())); } } @@ -809,7 +809,7 @@ fn gen_type_constraints(all_inst: &AllInstructions, fmt: &mut Formatter) { fmt.indent(|fmt| { for inst in all_inst.iter() { let (ctrl_typevar, ctrl_typeset) = if let Some(poly) = &inst.polymorphic_info { - let index = type_sets.add(&*poly.ctrl_typevar.get_raw_typeset()); + let index = type_sets.add(poly.ctrl_typevar.get_raw_typeset()); (Some(&poly.ctrl_typevar), index) } else { (None, TYPESET_LIMIT) @@ -857,7 +857,7 @@ fn gen_type_constraints(all_inst: &AllInstructions, fmt: &mut Formatter) { .collect::>() .join(", "))); if let Some(poly) = &inst.polymorphic_info { - fmt.comment(format!("Polymorphic over {}", typeset_to_string(&poly.ctrl_typevar.get_raw_typeset()))); + fmt.comment(format!("Polymorphic over {}", typeset_to_string(poly.ctrl_typevar.get_raw_typeset()))); } // Compute the bit field encoding, c.f. instructions.rs. @@ -1730,7 +1730,7 @@ fn gen_builder( fmt.line("pub trait InstBuilder<'f>: InstBuilderBase<'f> {"); fmt.indent(|fmt| { for inst in instructions.iter() { - gen_inst_builder(inst, &*inst.format, fmt); + gen_inst_builder(inst, &inst.format, fmt); fmt.empty_line(); } for (i, format) in formats.iter().enumerate() { diff --git a/cranelift/codegen/meta/src/gen_settings.rs b/cranelift/codegen/meta/src/gen_settings.rs index d81781ef62c8..097581bef6d8 100644 --- a/cranelift/codegen/meta/src/gen_settings.rs +++ b/cranelift/codegen/meta/src/gen_settings.rs @@ -267,10 +267,10 @@ fn gen_getters(group: &SettingGroup, fmt: &mut Formatter) { } for setting in &group.settings { - gen_getter(&setting, fmt); + gen_getter(setting, fmt); } for predicate in &group.predicates { - gen_pred_getter(&predicate, &group, fmt); + gen_pred_getter(predicate, group, fmt); } }); fmtln!(fmt, "}"); @@ -364,8 +364,8 @@ fn gen_descriptors(group: &SettingGroup, fmt: &mut Formatter) { // Generate hash table. let mut hash_entries: Vec = Vec::new(); - hash_entries.extend(group.settings.iter().map(|x| SettingOrPreset::Setting(x))); - hash_entries.extend(group.presets.iter().map(|x| SettingOrPreset::Preset(x))); + hash_entries.extend(group.settings.iter().map(SettingOrPreset::Setting)); + hash_entries.extend(group.presets.iter().map(SettingOrPreset::Preset)); let hash_table = generate_table(hash_entries.iter(), hash_entries.len(), |entry| { simple_hash(entry.name()) @@ -399,9 +399,9 @@ fn gen_descriptors(group: &SettingGroup, fmt: &mut Formatter) { fmt.comment(format!( "{}: {}", preset.name, - preset.setting_names(&group).collect::>().join(", ") + preset.setting_names(group).collect::>().join(", ") )); - for (mask, value) in preset.layout(&group) { + for (mask, value) in preset.layout(group) { fmtln!(fmt, "(0b{:08b}, 0b{:08b}),", mask, value); } } @@ -502,7 +502,7 @@ pub(crate) fn generate( out_dir: &str, ) -> Result<(), error::Error> { let mut fmt = Formatter::new(); - gen_group(&settings, parent_group, &mut fmt); + gen_group(settings, parent_group, &mut fmt); fmt.update_file(filename, out_dir)?; Ok(()) } diff --git a/cranelift/codegen/meta/src/lib.rs b/cranelift/codegen/meta/src/lib.rs index 764283927f6e..738ead0e93b7 100644 --- a/cranelift/codegen/meta/src/lib.rs +++ b/cranelift/codegen/meta/src/lib.rs @@ -31,9 +31,9 @@ pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(), &shared_defs.settings, gen_settings::ParentGroup::None, "settings.rs", - &out_dir, + out_dir, )?; - gen_types::generate("types.rs", &out_dir)?; + gen_types::generate("types.rs", out_dir)?; // - per ISA definitions. let target_isas = isa::define(isas, &mut shared_defs); @@ -49,7 +49,7 @@ pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(), "inst_builder.rs", "clif_opt.isle", "clif_lower.isle", - &out_dir, + out_dir, isle_dir, )?; @@ -58,7 +58,7 @@ pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(), &isa.settings, gen_settings::ParentGroup::Shared, &format!("settings-{}.rs", isa.name), - &out_dir, + out_dir, )?; } diff --git a/cranelift/codegen/meta/src/shared/mod.rs b/cranelift/codegen/meta/src/shared/mod.rs index 5d530b27a465..cc23063b94b4 100644 --- a/cranelift/codegen/meta/src/shared/mod.rs +++ b/cranelift/codegen/meta/src/shared/mod.rs @@ -58,7 +58,7 @@ impl Definitions { // Check name. if let Some(existing_format) = format_names.get(&inst.format.name) { assert!( - Rc::ptr_eq(&existing_format, &inst.format), + Rc::ptr_eq(existing_format, &inst.format), "formats must uniquely named; there's a\ conflict on the name '{}', please make sure it is used only once.", existing_format.name @@ -80,7 +80,7 @@ impl Definitions { } } - let mut result = Vec::from_iter(format_structures.into_iter().map(|(_, v)| v)); + let mut result = Vec::from_iter(format_structures.into_values()); result.sort_by_key(|format| format.name); result } diff --git a/cranelift/codegen/meta/src/srcgen.rs b/cranelift/codegen/meta/src/srcgen.rs index f229ffe8025d..e19929a869bf 100644 --- a/cranelift/codegen/meta/src/srcgen.rs +++ b/cranelift/codegen/meta/src/srcgen.rs @@ -138,7 +138,7 @@ impl Formatter { pub fn add_match(&mut self, m: Match) { fmtln!(self, "match {} {{", m.expr); self.indent(|fmt| { - for (&(ref fields, ref body), ref names) in m.arms.iter() { + for ((fields, body), names) in m.arms.iter() { // name { fields } | name { fields } => { body } let conditions = names .iter() @@ -189,7 +189,7 @@ fn _indent(s: &str) -> Option { fn parse_multiline(s: &str) -> Vec { // Convert tabs into spaces. let expanded_tab = format!("{:-1$}", " ", SHIFTWIDTH); - let lines: Vec = s.lines().map(|l| l.replace("\t", &expanded_tab)).collect(); + let lines: Vec = s.lines().map(|l| l.replace('\t', &expanded_tab)).collect(); // Determine minimum indentation, ignoring the first line and empty lines. let indent = lines diff --git a/cranelift/control/src/zero_sized.rs b/cranelift/control/src/zero_sized.rs index 73b2c58ec123..c8e2a8c017cb 100644 --- a/cranelift/control/src/zero_sized.rs +++ b/cranelift/control/src/zero_sized.rs @@ -13,7 +13,7 @@ pub struct ControlPlane { /// disabled. It doesn't consume any bytes and always returns a default /// control plane. impl arbitrary::Arbitrary<'_> for ControlPlane { - fn arbitrary<'a>(_u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result { + fn arbitrary(_u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result { Ok(Self::default()) } } diff --git a/cranelift/isle/isle/src/ast.rs b/cranelift/isle/isle/src/ast.rs index a94c85659a6a..81d9f1b580ff 100644 --- a/cranelift/isle/isle/src/ast.rs +++ b/cranelift/isle/isle/src/ast.rs @@ -154,7 +154,7 @@ pub enum Pattern { impl Pattern { pub fn root_term(&self) -> Option<&Ident> { match self { - &Pattern::Term { ref sym, .. } => Some(sym), + Pattern::Term { sym, .. } => Some(sym), _ => None, } } diff --git a/cranelift/isle/isle/src/codegen.rs b/cranelift/isle/isle/src/codegen.rs index 5bc60e341a6e..d55ca3eaa4f6 100644 --- a/cranelift/isle/isle/src/codegen.rs +++ b/cranelift/isle/isle/src/codegen.rs @@ -186,7 +186,7 @@ impl<'a> Codegen<'a> { } fn generate_ctx_trait(&self, code: &mut String) { - writeln!(code, "").unwrap(); + writeln!(code).unwrap(); writeln!( code, "/// Context during lowering: an implementation of this trait" @@ -287,7 +287,7 @@ impl<'a> Codegen<'a> { for field in &variant.fields { let name = &self.typeenv.syms[field.name.index()]; let ty_name = - self.typeenv.types[field.ty.index()].name(&self.typeenv); + self.typeenv.types[field.ty.index()].name(self.typeenv); writeln!(code, " {}: {},", name, ty_name).unwrap(); } writeln!(code, " }},").unwrap(); @@ -301,9 +301,9 @@ impl<'a> Codegen<'a> { } fn type_name(&self, typeid: TypeId, by_ref: bool) -> String { - match &self.typeenv.types[typeid.index()] { - &Type::Primitive(_, sym, _) => self.typeenv.syms[sym.index()].clone(), - &Type::Enum { name, .. } => { + match self.typeenv.types[typeid.index()] { + Type::Primitive(_, sym, _) => self.typeenv.syms[sym.index()].clone(), + Type::Enum { name, .. } => { let r = if by_ref { "&" } else { "" }; format!("{}{}", r, self.typeenv.syms[name.index()]) } @@ -620,7 +620,7 @@ impl<'a> Codegen<'a> { &self.typeenv.syms[field.name.index()], )?; self.emit_expr(ctx, *value)?; - if ctx.is_ref.contains(&value) { + if ctx.is_ref.contains(value) { write!(ctx.out, ".clone()")?; } writeln!(ctx.out, ",")?; diff --git a/cranelift/isle/isle/src/error.rs b/cranelift/isle/isle/src/error.rs index 999821eddee0..3e277cd516cc 100644 --- a/cranelift/isle/isle/src/error.rs +++ b/cranelift/isle/isle/src/error.rs @@ -19,13 +19,13 @@ impl std::fmt::Debug for Errors { } let diagnostics = Vec::from_iter(self.errors.iter().map(|e| { let message = match e { - Error::IoError { context, .. } => format!("{}", context), + Error::IoError { context, .. } => context.to_owned(), Error::ParseError { msg, .. } => format!("parse error: {}", msg), Error::TypeError { msg, .. } => format!("type error: {}", msg), Error::UnreachableError { msg, .. } => format!("unreachable rule: {}", msg), Error::OverlapError { msg, .. } => format!("overlap error: {}", msg), Error::ShadowedError { .. } => { - format!("more general higher-priority rule shadows other rules") + "more general higher-priority rule shadows other rules".to_string() } }; diff --git a/cranelift/isle/isle/src/lexer.rs b/cranelift/isle/isle/src/lexer.rs index f59d9b9d3269..3eb048748125 100644 --- a/cranelift/isle/isle/src/lexer.rs +++ b/cranelift/isle/isle/src/lexer.rs @@ -110,7 +110,7 @@ impl<'a> Lexer<'a> { let mut buf = String::new(); for text in &file_texts { file_starts.push(buf.len()); - buf += &text; + buf += text; buf += "\n"; } @@ -316,18 +316,12 @@ impl<'a> Lexer<'a> { impl Token { /// Is this an `Int` token? pub fn is_int(&self) -> bool { - match self { - Token::Int(_) => true, - _ => false, - } + matches!(self, Token::Int(_)) } /// Is this a `Sym` token? pub fn is_sym(&self) -> bool { - match self { - Token::Symbol(_) => true, - _ => false, - } + matches!(self, Token::Symbol(_)) } } diff --git a/cranelift/isle/isle/src/parser.rs b/cranelift/isle/isle/src/parser.rs index 583f952d7f3b..94909054eb00 100644 --- a/cranelift/isle/isle/src/parser.rs +++ b/cranelift/isle/isle/src/parser.rs @@ -68,7 +68,7 @@ impl<'a> Parser<'a> { } fn is bool>(&self, f: F) -> bool { - if let Some(&(_, ref peek)) = self.lexer.peek() { + if let Some((_, peek)) = self.lexer.peek() { f(peek) } else { false @@ -99,7 +99,7 @@ impl<'a> Parser<'a> { fn is_const(&self) -> bool { self.is(|tok| match tok { - &Token::Symbol(ref tok_s) if tok_s.starts_with("$") => true, + Token::Symbol(tok_s) if tok_s.starts_with('$') => true, _ => false, }) } @@ -123,7 +123,7 @@ impl<'a> Parser<'a> { fn eat_sym_str(&mut self, s: &str) -> Result { self.eat(|tok| match tok { - &Token::Symbol(ref tok_s) if tok_s == s => true, + Token::Symbol(ref tok_s) if tok_s == s => true, _ => false, }) .map(|token| token.is_some()) @@ -202,7 +202,7 @@ impl<'a> Parser<'a> { fn parse_const(&mut self) -> Result { let pos = self.pos(); let ident = self.parse_ident()?; - if ident.0.starts_with("$") { + if ident.0.starts_with('$') { let s = &ident.0[1..]; Ok(Ident(s.to_string(), ident.1)) } else { @@ -216,9 +216,8 @@ impl<'a> Parser<'a> { fn parse_pragma(&mut self) -> Result { let ident = self.parse_ident()?; // currently, no pragmas are defined, but the infrastructure is useful to keep around - match ident.0.as_str() { - pragma => Err(self.error(ident.1, format!("Unknown pragma '{}'", pragma))), - } + let pragma = ident.0.as_str(); + Err(self.error(ident.1, format!("Unknown pragma '{}'", pragma))) } fn parse_type(&mut self) -> Result { @@ -472,7 +471,7 @@ impl<'a> Parser<'a> { self.expect_rparen()?; Ok(ret) } else { - self.parse_expr().map(|expr| IfLetOrExpr::Expr(expr)) + self.parse_expr().map(IfLetOrExpr::Expr) } } diff --git a/cranelift/isle/isle/src/sema.rs b/cranelift/isle/isle/src/sema.rs index bee3891bf8a2..adcae1e8f320 100644 --- a/cranelift/isle/isle/src/sema.rs +++ b/cranelift/isle/isle/src/sema.rs @@ -595,14 +595,14 @@ pub trait PatternVisitor { impl Pattern { /// Get this pattern's type. pub fn ty(&self) -> TypeId { - match self { - &Self::BindPattern(t, ..) => t, - &Self::Var(t, ..) => t, - &Self::ConstInt(t, ..) => t, - &Self::ConstPrim(t, ..) => t, - &Self::Term(t, ..) => t, - &Self::Wildcard(t, ..) => t, - &Self::And(t, ..) => t, + match *self { + Self::BindPattern(t, ..) => t, + Self::Var(t, ..) => t, + Self::ConstInt(t, ..) => t, + Self::ConstPrim(t, ..) => t, + Self::Term(t, ..) => t, + Self::Wildcard(t, ..) => t, + Self::And(t, ..) => t, } } @@ -614,14 +614,14 @@ impl Pattern { termenv: &TermEnv, vars: &mut HashMap, ) { - match self { - &Pattern::BindPattern(_ty, var, ref subpat) => { + match *self { + Pattern::BindPattern(_ty, var, ref subpat) => { // Bind the appropriate variable and recurse. assert!(!vars.contains_key(&var)); vars.insert(var, input); subpat.visit(visitor, input, termenv, vars); } - &Pattern::Var(ty, var) => { + Pattern::Var(ty, var) => { // Assert that the value matches the existing bound var. let var_val = vars .get(&var) @@ -629,9 +629,9 @@ impl Pattern { .expect("Variable should already be bound"); visitor.add_match_equal(input, var_val, ty); } - &Pattern::ConstInt(ty, value) => visitor.add_match_int(input, ty, value), - &Pattern::ConstPrim(ty, value) => visitor.add_match_prim(input, ty, value), - &Pattern::Term(ty, term, ref args) => { + Pattern::ConstInt(ty, value) => visitor.add_match_int(input, ty, value), + Pattern::ConstPrim(ty, value) => visitor.add_match_prim(input, ty, value), + Pattern::Term(ty, term, ref args) => { // Determine whether the term has an external extractor or not. let termdata = &termenv.terms[term.index()]; let arg_values = match &termdata.kind { @@ -673,12 +673,12 @@ impl Pattern { pat.visit(visitor, val, termenv, vars); } } - &Pattern::And(_ty, ref children) => { + Pattern::And(_ty, ref children) => { for child in children { child.visit(visitor, input, termenv, vars); } } - &Pattern::Wildcard(_ty) => { + Pattern::Wildcard(_ty) => { // Nothing! } } @@ -719,12 +719,12 @@ pub trait ExprVisitor { impl Expr { /// Get this expression's type. pub fn ty(&self) -> TypeId { - match self { - &Self::Term(t, ..) => t, - &Self::Var(t, ..) => t, - &Self::ConstInt(t, ..) => t, - &Self::ConstPrim(t, ..) => t, - &Self::Let { ty: t, .. } => t, + match *self { + Self::Term(t, ..) => t, + Self::Var(t, ..) => t, + Self::ConstInt(t, ..) => t, + Self::ConstPrim(t, ..) => t, + Self::Let { ty: t, .. } => t, } } @@ -736,10 +736,10 @@ impl Expr { vars: &HashMap, ) -> V::ExprId { log!("Expr::visit: expr {:?}", self); - match self { - &Expr::ConstInt(ty, val) => visitor.add_const_int(ty, val), - &Expr::ConstPrim(ty, val) => visitor.add_const_prim(ty, val), - &Expr::Let { + match *self { + Expr::ConstInt(ty, val) => visitor.add_const_int(ty, val), + Expr::ConstPrim(ty, val) => visitor.add_const_prim(ty, val), + Expr::Let { ty: _ty, ref bindings, ref body, @@ -751,8 +751,8 @@ impl Expr { } body.visit(visitor, termenv, &vars) } - &Expr::Var(_ty, var_id) => *vars.get(&var_id).unwrap(), - &Expr::Term(ty, term, ref arg_exprs) => { + Expr::Var(_ty, var_id) => *vars.get(&var_id).unwrap(), + Expr::Term(ty, term, ref arg_exprs) => { let termdata = &termenv.terms[term.index()]; let arg_values_tys = arg_exprs .iter() @@ -917,7 +917,7 @@ impl TypeEnv { // in types on a second pass. for def in &defs.defs { match def { - &ast::Def::Type(ref td) => { + ast::Def::Type(td) => { let tid = TypeId(tyenv.type_map.len()); let name = tyenv.intern_mut(&td.name); @@ -945,7 +945,7 @@ impl TypeEnv { // duplicated. for def in &defs.defs { match def { - &ast::Def::Type(ref td) => { + ast::Def::Type(td) => { let tid = tyenv.types.len(); if let Some(ty) = tyenv.type_from_ast(TypeId(tid), td) { tyenv.types.push(ty); @@ -957,23 +957,16 @@ impl TypeEnv { // Now collect types for extern constants. for def in &defs.defs { - match def { - &ast::Def::Extern(ast::Extern::Const { - ref name, - ref ty, - pos, - }) => { - let ty = match tyenv.get_type_by_name(ty) { - Some(ty) => ty, - None => { - tyenv.report_error(pos, "Unknown type for constant"); - continue; - } - }; - let name = tyenv.intern_mut(name); - tyenv.const_types.insert(name, ty); - } - _ => {} + if let ast::Def::Extern(ast::Extern::Const { name, ty, pos }) = def { + let ty = match tyenv.get_type_by_name(ty) { + Some(ty) => ty, + None => { + tyenv.report_error(*pos, "Unknown type for constant"); + continue; + } + }; + let name = tyenv.intern_mut(name); + tyenv.const_types.insert(name, ty); } } @@ -997,7 +990,7 @@ impl TypeEnv { fn type_from_ast(&mut self, tid: TypeId, ty: &ast::Type) -> Option { let name = self.intern(&ty.name).unwrap(); match &ty.ty { - &ast::TypeValue::Primitive(ref id, ..) => { + ast::TypeValue::Primitive(id, ..) => { if ty.is_nodebug { self.report_error(ty.pos, "primitive types cannot be marked `nodebug`"); return None; @@ -1008,7 +1001,7 @@ impl TypeEnv { } Some(Type::Primitive(tid, self.intern_mut(id), ty.pos)) } - &ast::TypeValue::Enum(ref ty_variants, ..) => { + ast::TypeValue::Enum(ty_variants, ..) => { if ty.is_extern && ty.is_nodebug { self.report_error(ty.pos, "external types cannot be marked `nodebug`"); return None; @@ -1195,7 +1188,7 @@ impl TermEnv { fn collect_term_sigs(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) { for def in &defs.defs { match def { - &ast::Def::Decl(ref decl) => { + ast::Def::Decl(decl) => { let name = tyenv.intern_mut(&decl.term); if let Some(tid) = self.term_map.get(&name) { tyenv.report_error( @@ -1221,7 +1214,6 @@ impl TermEnv { .map(|id| { tyenv.get_type_by_name(id).ok_or_else(|| { tyenv.report_error(id.1, format!("Unknown arg type: '{}'", id.0)); - () }) }) .collect::, _>>(); diff --git a/crates/cache/build.rs b/crates/cache/build.rs index 1db75f1c11d5..b57b1ac48833 100644 --- a/crates/cache/build.rs +++ b/crates/cache/build.rs @@ -2,7 +2,7 @@ use std::process::Command; use std::str; fn main() { - let git_rev = match Command::new("git").args(&["rev-parse", "HEAD"]).output() { + let git_rev = match Command::new("git").args(["rev-parse", "HEAD"]).output() { Ok(output) => str::from_utf8(&output.stdout).unwrap().trim().to_string(), Err(_) => env!("CARGO_PKG_VERSION").to_string(), }; diff --git a/crates/component-macro/src/bindgen.rs b/crates/component-macro/src/bindgen.rs index bb82b1750a0b..e2b97c09fa78 100644 --- a/crates/component-macro/src/bindgen.rs +++ b/crates/component-macro/src/bindgen.rs @@ -104,7 +104,7 @@ fn parse_source(source: &Option) -> anyhow::Result<(Resolve, PackageId, let root = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap()); let mut parse = |path: &Path| -> anyhow::Result<_> { if path.is_dir() { - let (pkg, sources) = resolve.push_dir(&path)?; + let (pkg, sources) = resolve.push_dir(path)?; files = sources; Ok(pkg) } else { @@ -115,10 +115,10 @@ fn parse_source(source: &Option) -> anyhow::Result<(Resolve, PackageId, }; let pkg = match source { Some(Source::Inline(s)) => resolve.push( - UnresolvedPackage::parse("macro-input".as_ref(), &s)?, + UnresolvedPackage::parse("macro-input".as_ref(), s)?, &Default::default(), )?, - Some(Source::Path(s)) => parse(&root.join(&s))?, + Some(Source::Path(s)) => parse(&root.join(s))?, None => parse(&root.join("wit"))?, }; diff --git a/crates/wit-bindgen/src/lib.rs b/crates/wit-bindgen/src/lib.rs index 426c0a58ff07..7c41c0b43df2 100644 --- a/crates/wit-bindgen/src/lib.rs +++ b/crates/wit-bindgen/src/lib.rs @@ -107,9 +107,9 @@ impl Wasmtime { let mut gen = InterfaceGenerator::new(self, resolve); let import = match item { WorldItem::Function(func) => { - gen.generate_function_trait_sig(TypeOwner::None, &func); + gen.generate_function_trait_sig(TypeOwner::None, func); let sig = mem::take(&mut gen.src).into(); - gen.generate_add_function_to_linker(TypeOwner::None, &func, "linker"); + gen.generate_add_function_to_linker(TypeOwner::None, func, "linker"); let add_to_linker = gen.src.into(); Import::Function { sig, add_to_linker } } @@ -157,7 +157,7 @@ impl Wasmtime { let (_name, getter) = gen.extract_typed_function(func); assert!(gen.src.is_empty()); self.exports.funcs.push(body); - (format!("wasmtime::component::Func"), getter) + ("wasmtime::component::Func".to_string(), getter) } WorldItem::Type(_) => unreachable!(), WorldItem::Interface(id) => { @@ -999,9 +999,9 @@ impl<'a> InterfaceGenerator<'a> { uwriteln!(self.src, "}}"); let where_clause = if self.gen.opts.async_ { - format!("T: Send, U: Host + Send") + "T: Send, U: Host + Send".to_string() } else { - format!("U: Host") + "U: Host".to_string() }; uwriteln!( self.src, @@ -1184,7 +1184,7 @@ impl<'a> InterfaceGenerator<'a> { let ret = (snake, mem::take(&mut self.src).to_string()); self.src = prev; - return ret; + ret } fn define_rust_guest_export(&mut self, ns: Option<&str>, func: &Function) { diff --git a/crates/wit-bindgen/src/rust.rs b/crates/wit-bindgen/src/rust.rs index bba7df58b779..d94605ab3148 100644 --- a/crates/wit-bindgen/src/rust.rs +++ b/crates/wit-bindgen/src/rust.rs @@ -204,7 +204,7 @@ pub trait RustGenerator<'a> { if info.owned && (!info.borrowed || self.uses_two_names(&info)) { result.push((self.result_name(ty), TypeMode::Owned)); } - return result; + result } /// Writes the camel-cased 'name' of the passed type to `out`, as used to name union variants. diff --git a/crates/wit-bindgen/src/types.rs b/crates/wit-bindgen/src/types.rs index c4a2faeec390..bc119bc8902a 100644 --- a/crates/wit-bindgen/src/types.rs +++ b/crates/wit-bindgen/src/types.rs @@ -95,7 +95,7 @@ impl Types { _ => continue, }; if let Some(Type::Id(id)) = err { - self.type_info.get_mut(&id).unwrap().error = true; + self.type_info.get_mut(id).unwrap().error = true; } } } From 1fc6503fd5bb508647220baed6af89f7ad6ffbdf Mon Sep 17 00:00:00 2001 From: Kevaundray Wedderburn Date: Sat, 15 Apr 2023 18:00:02 +0100 Subject: [PATCH 2/3] revert &/ref change --- cranelift/codegen/meta/src/cdsl/types.rs | 7 +++++-- cranelift/codegen/meta/src/srcgen.rs | 2 +- cranelift/isle/isle/src/ast.rs | 2 +- cranelift/isle/isle/src/error.rs | 2 +- cranelift/isle/isle/src/sema.rs | 19 ++++++++++++------- 5 files changed, 20 insertions(+), 12 deletions(-) diff --git a/cranelift/codegen/meta/src/cdsl/types.rs b/cranelift/codegen/meta/src/cdsl/types.rs index cfc8c7ed21b0..3eb32ebee67a 100644 --- a/cranelift/codegen/meta/src/cdsl/types.rs +++ b/cranelift/codegen/meta/src/cdsl/types.rs @@ -267,9 +267,12 @@ impl Iterator for LaneTypeIterator { type Item = LaneType; fn next(&mut self) -> Option { if let Some(i) = self.int_iter.next() { - return Some(LaneType::from(i)); + Some(LaneType::from(i)) + } else if let Some(f) = self.float_iter.next() { + Some(LaneType::from(f)) + } else { + None } - self.float_iter.next().map(LaneType::from) } } diff --git a/cranelift/codegen/meta/src/srcgen.rs b/cranelift/codegen/meta/src/srcgen.rs index e19929a869bf..b1be70240746 100644 --- a/cranelift/codegen/meta/src/srcgen.rs +++ b/cranelift/codegen/meta/src/srcgen.rs @@ -138,7 +138,7 @@ impl Formatter { pub fn add_match(&mut self, m: Match) { fmtln!(self, "match {} {{", m.expr); self.indent(|fmt| { - for ((fields, body), names) in m.arms.iter() { + for (&(ref fields, ref body), ref names) in m.arms.iter() { // name { fields } | name { fields } => { body } let conditions = names .iter() diff --git a/cranelift/isle/isle/src/ast.rs b/cranelift/isle/isle/src/ast.rs index 81d9f1b580ff..a94c85659a6a 100644 --- a/cranelift/isle/isle/src/ast.rs +++ b/cranelift/isle/isle/src/ast.rs @@ -154,7 +154,7 @@ pub enum Pattern { impl Pattern { pub fn root_term(&self) -> Option<&Ident> { match self { - Pattern::Term { sym, .. } => Some(sym), + &Pattern::Term { ref sym, .. } => Some(sym), _ => None, } } diff --git a/cranelift/isle/isle/src/error.rs b/cranelift/isle/isle/src/error.rs index 3e277cd516cc..f9c8468c8aec 100644 --- a/cranelift/isle/isle/src/error.rs +++ b/cranelift/isle/isle/src/error.rs @@ -19,7 +19,7 @@ impl std::fmt::Debug for Errors { } let diagnostics = Vec::from_iter(self.errors.iter().map(|e| { let message = match e { - Error::IoError { context, .. } => context.to_owned(), + Error::IoError { context, .. } => context.clone(), Error::ParseError { msg, .. } => format!("parse error: {}", msg), Error::TypeError { msg, .. } => format!("type error: {}", msg), Error::UnreachableError { msg, .. } => format!("unreachable rule: {}", msg), diff --git a/cranelift/isle/isle/src/sema.rs b/cranelift/isle/isle/src/sema.rs index adcae1e8f320..11a6a1ad1acb 100644 --- a/cranelift/isle/isle/src/sema.rs +++ b/cranelift/isle/isle/src/sema.rs @@ -917,7 +917,7 @@ impl TypeEnv { // in types on a second pass. for def in &defs.defs { match def { - ast::Def::Type(td) => { + &ast::Def::Type(ref td) => { let tid = TypeId(tyenv.type_map.len()); let name = tyenv.intern_mut(&td.name); @@ -945,7 +945,7 @@ impl TypeEnv { // duplicated. for def in &defs.defs { match def { - ast::Def::Type(td) => { + &ast::Def::Type(ref td) => { let tid = tyenv.types.len(); if let Some(ty) = tyenv.type_from_ast(TypeId(tid), td) { tyenv.types.push(ty); @@ -957,11 +957,16 @@ impl TypeEnv { // Now collect types for extern constants. for def in &defs.defs { - if let ast::Def::Extern(ast::Extern::Const { name, ty, pos }) = def { + if let &ast::Def::Extern(ast::Extern::Const { + ref name, + ref ty, + pos, + }) = def + { let ty = match tyenv.get_type_by_name(ty) { Some(ty) => ty, None => { - tyenv.report_error(*pos, "Unknown type for constant"); + tyenv.report_error(pos, "Unknown type for constant"); continue; } }; @@ -990,7 +995,7 @@ impl TypeEnv { fn type_from_ast(&mut self, tid: TypeId, ty: &ast::Type) -> Option { let name = self.intern(&ty.name).unwrap(); match &ty.ty { - ast::TypeValue::Primitive(id, ..) => { + &ast::TypeValue::Primitive(ref id, ..) => { if ty.is_nodebug { self.report_error(ty.pos, "primitive types cannot be marked `nodebug`"); return None; @@ -1001,7 +1006,7 @@ impl TypeEnv { } Some(Type::Primitive(tid, self.intern_mut(id), ty.pos)) } - ast::TypeValue::Enum(ty_variants, ..) => { + &ast::TypeValue::Enum(ref ty_variants, ..) => { if ty.is_extern && ty.is_nodebug { self.report_error(ty.pos, "external types cannot be marked `nodebug`"); return None; @@ -1188,7 +1193,7 @@ impl TermEnv { fn collect_term_sigs(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) { for def in &defs.defs { match def { - ast::Def::Decl(decl) => { + &ast::Def::Decl(ref decl) => { let name = tyenv.intern_mut(&decl.term); if let Some(tid) = self.term_map.get(&name) { tyenv.report_error( From 91d6700707939e2631408b024dd34596b2a68445 Mon Sep 17 00:00:00 2001 From: kevaundray Date: Sat, 15 Apr 2023 18:05:13 +0100 Subject: [PATCH 3/3] Update cranelift/isle/isle/src/parser.rs Co-authored-by: Jamey Sharp --- cranelift/isle/isle/src/parser.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cranelift/isle/isle/src/parser.rs b/cranelift/isle/isle/src/parser.rs index 94909054eb00..b613e65c5c75 100644 --- a/cranelift/isle/isle/src/parser.rs +++ b/cranelift/isle/isle/src/parser.rs @@ -202,8 +202,7 @@ impl<'a> Parser<'a> { fn parse_const(&mut self) -> Result { let pos = self.pos(); let ident = self.parse_ident()?; - if ident.0.starts_with('$') { - let s = &ident.0[1..]; + if let Some(s) = ident.0.strip_prefix('$') { Ok(Ident(s.to_string(), ident.1)) } else { Err(self.error(