From 20b91a6601df31d604358ca0aa5aea406c2c5817 Mon Sep 17 00:00:00 2001 From: Edward Chen Date: Sun, 29 Jan 2023 21:05:15 -0500 Subject: [PATCH] Clippy: uninlined_format_args (#141) --- examples/circ.rs | 10 +-- examples/zxc.rs | 2 +- src/circify/mod.rs | 28 +++---- src/front/c/mod.rs | 28 +++---- src/front/c/term.rs | 24 +++--- src/front/c/types.rs | 12 +-- src/front/datalog/error.rs | 2 +- src/front/datalog/mod.rs | 4 +- src/front/datalog/term.rs | 2 +- src/front/datalog/ty.rs | 4 +- src/front/mod.rs | 4 +- src/front/zsharp/mod.rs | 47 +++++------ src/front/zsharp/term.rs | 75 ++++++++--------- src/front/zsharp/zvisit/eqtype.rs | 8 +- src/front/zsharp/zvisit/zgenericinf.rs | 16 ++-- src/front/zsharp/zvisit/zstmtwalker/mod.rs | 8 +- .../zsharp/zvisit/zstmtwalker/zexprtyper.rs | 8 +- src/ir/opt/cfold.rs | 6 +- src/ir/opt/inline.rs | 28 +++---- src/ir/opt/mem/lin.rs | 2 +- src/ir/opt/mem/obliv.rs | 2 +- src/ir/opt/mod.rs | 2 +- src/ir/opt/scalarize_vars.rs | 4 +- src/ir/opt/sha.rs | 2 +- src/ir/term/dist.rs | 4 +- src/ir/term/extras.rs | 2 +- src/ir/term/fmt.rs | 80 +++++++++---------- src/ir/term/mod.rs | 4 +- src/ir/term/text/mod.rs | 13 ++- src/ir/term/ty.rs | 20 ++--- src/target/aby/trans.rs | 78 +++++++----------- src/target/aby/utils.rs | 6 +- src/target/ilp/trans.rs | 2 +- src/target/r1cs/bellman.rs | 9 +-- src/target/r1cs/mod.rs | 3 +- src/target/r1cs/opt.rs | 2 +- src/target/r1cs/spartan.rs | 6 +- src/target/r1cs/trans.rs | 2 +- src/target/smt/mod.rs | 16 ++-- 39 files changed, 259 insertions(+), 316 deletions(-) diff --git a/examples/circ.rs b/examples/circ.rs index 417a52a6..08494bef 100644 --- a/examples/circ.rs +++ b/examples/circ.rs @@ -149,7 +149,7 @@ fn determine_language(l: &Language, input_path: &Path) -> DeterminedLanguage { } else if p.ends_with(".c") || p.ends_with(".cpp") || p.ends_with(".cc") { DeterminedLanguage::C } else { - println!("Could not deduce the input language from path '{}', please set the language manually", p); + println!("Could not deduce the input language from path '{p}', please set the language manually"); std::process::exit(2) } } @@ -165,7 +165,7 @@ fn main() { let options = Options::parse(); circ::cfg::set(&options.circ); let path_buf = options.path.clone(); - println!("{:?}", options); + println!("{options:?}"); let mode = match options.backend { Backend::R1cs { .. } => match options.frontend.value_threshold { Some(t) => Mode::ProofOfHighValue(t), @@ -321,8 +321,8 @@ fn main() { DeterminedLanguage::Zsharp => "zok".to_string(), _ => panic!("Language isn't supported by MPC backend: {:#?}", language), }; - println!("Cost model: {}", cost_model); - println!("Selection scheme: {}", selection_scheme); + println!("Cost model: {cost_model}"); + println!("Selection scheme: {selection_scheme}"); to_aby(cs, &path_buf, &lang_str, &cost_model, &selection_scheme); } #[cfg(not(feature = "aby"))] @@ -368,7 +368,7 @@ fn main() { Some(m) => { println!("Not primitive recursive!"); for (var, val) in m { - println!("{} -> {}", var, val); + println!("{var} -> {val}"); } std::process::exit(1) } diff --git a/examples/zxc.rs b/examples/zxc.rs index de0b94e4..a5b7c61b 100644 --- a/examples/zxc.rs +++ b/examples/zxc.rs @@ -84,7 +84,7 @@ fn main() { .init(); let options = Options::parse(); circ::cfg::set(&options.circ); - println!("{:?}", options); + println!("{options:?}"); let cs = { let inputs = zsharp::Inputs { diff --git a/src/circify/mod.rs b/src/circify/mod.rs index c136ee0b..ba4f0876 100644 --- a/src/circify/mod.rs +++ b/src/circify/mod.rs @@ -62,8 +62,8 @@ pub type Result = std::result::Result; impl Display for Val { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { - Val::Term(t) => write!(f, "{}", t), - Val::Ref(l) => write!(f, "&{}", l), + Val::Term(t) => write!(f, "{t}"), + Val::Ref(l) => write!(f, "&{l}"), } } } @@ -160,9 +160,7 @@ impl LexScope { fn declare(&mut self, name: VarName, ty: Ty) -> Result<&SsaName> { let p = &self.prefix; match self.entries.entry(name.clone()) { - Entry::Vacant(v) => Ok(&v - .insert(LexEntry::new(format!("{}_{}", p, name), ty)) - .ssa_name), + Entry::Vacant(v) => Ok(&v.insert(LexEntry::new(format!("{p}_{name}"), ty)).ssa_name), Entry::Occupied(o) => Err(CircError::Rebind(name, format!("{}", o.get().ty))), } } @@ -595,8 +593,8 @@ impl Circify { let new_ty = new.type_(); assert_eq!( ty, new_ty, - "Term {} has type {} but was assigned to {} of type {}", - new, new_ty, loc, ty + "{}", + "Term {new} has type {new_ty} but was assigned to {loc} of type {ty}", ); // get condition under which assignment happens let guard = self.condition.clone(); @@ -617,9 +615,9 @@ impl Circify { Ok(v) } (_, v) => Err(CircError::MisTypedAssign( - format!("{}", v), - format!("{}", loc), - format!("{}", old_val), + format!("{v}"), + format!("{loc}"), + format!("{old_val}"), )), } } @@ -879,8 +877,8 @@ mod test { impl Display for T { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { - T::Base(t) => write!(f, "{}", t), - T::Pair(a, b) => write!(f, "({}, {})", a, b), + T::Base(t) => write!(f, "{t}"), + T::Pair(a, b) => write!(f, "({a}, {b})"), } } } @@ -895,7 +893,7 @@ mod test { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { Ty::Bool => write!(f, "bool"), - Ty::Pair(a, b) => write!(f, "({}, {})", a, b), + Ty::Pair(a, b) => write!(f, "({a}, {b})"), } } } @@ -968,14 +966,14 @@ mod test { Box::new(self.declare_input( ctx, a, - format!("{}.0", name), + format!("{name}.0"), visibility, p_1, )), Box::new(self.declare_input( ctx, b, - format!("{}.1", name), + format!("{name}.1"), visibility, p_2, )), diff --git a/src/front/c/mod.rs b/src/front/c/mod.rs index 648d3593..c12839be 100644 --- a/src/front/c/mod.rs +++ b/src/front/c/mod.rs @@ -131,7 +131,7 @@ impl CGen { /// Unwrap a result of an error and abort fn err(&self, e: E) -> ! { - println!("Error: {}", e); + println!("Error: {e}"); std::process::exit(1) } @@ -366,10 +366,10 @@ impl CGen { if let Some((_, term_)) = fs.search(field) { Ok(term_.clone()) } else { - Err(format!("No field '{}'", field)) + Err(format!("No field '{field}'")) } } else { - Err(format!("{} is not a struct", struct_)) + Err(format!("{struct_} is not a struct")) } } @@ -381,10 +381,10 @@ impl CGen { let res = cterm(CTermData::CStruct(struct_ty.clone(), new_fs.clone())); Ok(res) } else { - Err(format!("No field '{}'", field)) + Err(format!("No field '{field}'")) } } else { - Err(format!("{} is not a struct", struct_)) + Err(format!("{struct_} is not a struct")) } } @@ -409,7 +409,7 @@ impl CGen { _ => unimplemented!(), })) } - (a, b) => Err(format!("[Array Select] cannot index {} by {}", a, b)), + (a, b) => Err(format!("[Array Select] cannot index {a} by {b}")), } } @@ -447,7 +447,7 @@ impl CGen { Ok(val.clone()) } } - (a, b) => Err(format!("[Array Store] cannot index {} by {}", a, b)), + (a, b) => Err(format!("[Array Store] cannot index {a} by {b}")), } } @@ -530,7 +530,7 @@ impl CGen { CLoc::Var(l) => { let org_type = self .circ_get_value(l.clone()) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term() .term .type_(); @@ -542,26 +542,26 @@ impl CGen { }; Ok(self .circ_assign(l, Val::Term(new_val)) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term()) } CLoc::Idx(l, idx) => { let old_inner: CTerm = match *l { CLoc::Var(inner_loc) => self .circ_get_value(inner_loc) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term(), CLoc::Member(inner_loc, field) => { let base = self .circ_get_value(inner_loc.loc().clone()) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term(); self.field_select(&base, &field).unwrap() } CLoc::Idx(inner_loc, idx) => { let base = self .circ_get_value(inner_loc.loc().clone()) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term(); self.array_select(&base, &idx).unwrap() } @@ -572,14 +572,14 @@ impl CGen { let inner_loc = l.loc().clone(); let base = self .circ_get_value(inner_loc.clone()) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term(); let old_inner = self.field_select(&base, &field)?; let new_inner = self.rebuild_lval(old_inner, *l, val)?; let res = self.field_store(&base, &field, &new_inner); Ok(self .circ_assign(inner_loc, Val::Term(res.unwrap())) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term()) } } diff --git a/src/front/c/term.rs b/src/front/c/term.rs index d512e784..4d97c010 100644 --- a/src/front/c/term.rs +++ b/src/front/c/term.rs @@ -98,18 +98,18 @@ impl CTermData { impl Display for CTermData { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { - CTermData::CBool(x) => write!(f, "Bool({})", x), - CTermData::CInt(_, _, x) => write!(f, "Int({})", x), - CTermData::CArray(t, _) => write!(f, "Array({:#?})", t), - CTermData::CStackPtr(t, s, _) => write!(f, "Ptr{:#?}({:#?})", s, t), - CTermData::CStruct(t, _) => write!(f, "Struct({})", t), + CTermData::CBool(x) => write!(f, "Bool({x})"), + CTermData::CInt(_, _, x) => write!(f, "Int({x})"), + CTermData::CArray(t, _) => write!(f, "Array({t:#?})"), + CTermData::CStackPtr(t, s, _) => write!(f, "Ptr{s:#?}({t:#?})"), + CTermData::CStruct(t, _) => write!(f, "Struct({t})"), } } } impl fmt::Debug for CTermData { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "{}", self) + write!(f, "{self}") } } @@ -126,7 +126,7 @@ impl Display for CTerm { } fn field_name(struct_name: &str, field_name: &str) -> String { - format!("{}.{}", struct_name, field_name) + format!("{struct_name}.{field_name}") } pub fn cterm(data: CTermData) -> CTerm { @@ -334,7 +334,7 @@ fn wrap_bin_arith( }) } - (x, y, _, _) => Err(format!("Cannot perform op '{}' on {} and {}", name, x, y)), + (x, y, _, _) => Err(format!("Cannot perform op '{name}' on {x} and {y}")), } } @@ -416,7 +416,7 @@ fn wrap_bin_logical( term: CTermData::CBool(fb(a, b)), udef: false, }), - (x, y, _, _) => Err(format!("Cannot perform op '{}' on {} and {}", name, x, y)), + (x, y, _, _) => Err(format!("Cannot perform op '{name}' on {x} and {y}")), } } @@ -455,7 +455,7 @@ fn wrap_bin_cmp( term: CTermData::CBool(fb(x, y)), udef: false, }), - (x, y, _, _) => Err(format!("Cannot perform op '{}' on {} and {}", name, x, y)), + (x, y, _, _) => Err(format!("Cannot perform op '{name}' on {x} and {y}")), } } @@ -533,7 +533,7 @@ fn wrap_shift(name: &str, op: BvBinOp, a: CTerm, b: CTerm) -> Result Err(format!("Cannot perform op '{}' on {} and {}", name, x, bc)), + x => Err(format!("Cannot perform op '{name}' on {x} and {bc}")), } } @@ -548,7 +548,7 @@ pub fn shr(a: CTerm, b: CTerm) -> Result { pub struct Ct {} fn idx_name(struct_name: &str, idx: usize) -> String { - format!("{}.{}", struct_name, idx) + format!("{struct_name}.{idx}") } impl Ct { diff --git a/src/front/c/types.rs b/src/front/c/types.rs index f992105a..3cd927bc 100644 --- a/src/front/c/types.rs +++ b/src/front/c/types.rs @@ -41,9 +41,9 @@ impl Display for Ty { Ty::Bool => write!(f, "bool"), Ty::Int(s, w) => { if *s { - write!(f, "s{}", w) + write!(f, "s{w}") } else { - write!(f, "u{}", w) + write!(f, "u{w}") } } Ty::Struct(n, fields) => { @@ -60,11 +60,11 @@ impl Display for Ty { bb = b.as_ref(); dims.push(n); } - write!(f, "{}", bb)?; - dims.iter().try_for_each(|d| write!(f, "[{}]", d)) + write!(f, "{bb}")?; + dims.iter().try_for_each(|d| write!(f, "[{d}]")) } Ty::Ptr(s, t) => { - write!(f, "ptr{}({})", s, t) + write!(f, "ptr{s}({t})") } } } @@ -72,7 +72,7 @@ impl Display for Ty { impl fmt::Debug for Ty { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "{}", self) + write!(f, "{self}") } } diff --git a/src/front/datalog/error.rs b/src/front/datalog/error.rs index 264edc88..a9b423a1 100644 --- a/src/front/datalog/error.rs +++ b/src/front/datalog/error.rs @@ -40,7 +40,7 @@ impl<'ast> Display for Error<'ast> { if let Some(s) = &self.span { writeln!(f, "\nLocation:")?; for l in s.lines() { - writeln!(f, " {}", l)?; + writeln!(f, " {l}")?; } } Ok(()) diff --git a/src/front/datalog/mod.rs b/src/front/datalog/mod.rs index 607c9e60..a94af71f 100644 --- a/src/front/datalog/mod.rs +++ b/src/front/datalog/mod.rs @@ -385,7 +385,7 @@ impl FrontEnd for Datalog { let ast = match ast { Ok(ast) => ast, Err(e) => { - println!("{}", e); + println!("{e}"); panic!("parse error!") } }; @@ -397,7 +397,7 @@ impl FrontEnd for Datalog { g.entry_rule("main") }; if let Err(e) = r { - eprintln!("{}", e); + eprintln!("{e}"); panic!() } let mut cs = Computations::new(); diff --git a/src/front/datalog/term.rs b/src/front/datalog/term.rs index 6f772670..b7226016 100644 --- a/src/front/datalog/term.rs +++ b/src/front/datalog/term.rs @@ -328,7 +328,7 @@ pub fn uint_to_field(s: &T) -> Result { /// Uint to field pub fn array_idx(a: &T, i: &T) -> Result { match (&a.ty, &i.ty) { - (&Ty::Array(_, ref elem_ty), &Ty::Field) => Ok(T::new( + (Ty::Array(_, elem_ty), &Ty::Field) => Ok(T::new( term![Op::Select; a.ir.clone(), i.ir.clone()], (**elem_ty).clone(), )), diff --git a/src/front/datalog/ty.rs b/src/front/datalog/ty.rs index d0be6e89..551dc0f3 100644 --- a/src/front/datalog/ty.rs +++ b/src/front/datalog/ty.rs @@ -20,8 +20,8 @@ impl Display for Ty { match &self { Ty::Bool => write!(f, "bool"), Ty::Field => write!(f, "field"), - Ty::Uint(w) => write!(f, "u{}", w), - Ty::Array(l, t) => write!(f, "{}[{}]", t, l), + Ty::Uint(w) => write!(f, "u{w}"), + Ty::Array(l, t) => write!(f, "{t}[{l}]"), } } } diff --git a/src/front/mod.rs b/src/front/mod.rs index ea9be5ea..6d55d29e 100644 --- a/src/front/mod.rs +++ b/src/front/mod.rs @@ -44,10 +44,10 @@ pub enum Mode { impl Display for Mode { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match *self { - Mode::Mpc(n) => write!(f, "{}-pc", n), + Mode::Mpc(n) => write!(f, "{n}-pc"), Mode::Proof => write!(f, "proof"), Mode::Opt => write!(f, "opt"), - Mode::ProofOfHighValue(v) => write!(f, "proof_of_high_value({})", v), + Mode::ProofOfHighValue(v) => write!(f, "proof_of_high_value({v})"), } } } diff --git a/src/front/zsharp/mod.rs b/src/front/zsharp/mod.rs index ee0f56af..49a433bd 100644 --- a/src/front/zsharp/mod.rs +++ b/src/front/zsharp/mod.rs @@ -180,9 +180,9 @@ impl<'ast> ZGen<'ast> { /// Unwrap a result with a span-dependent error fn err(&self, e: E, s: &ast::Span) -> ! { - println!("Error: {}", e); + println!("Error: {e}"); println!("In: {}", self.cur_path().canonicalize().unwrap().display()); - s.lines().for_each(|l| print!(" {}", l)); + s.lines().for_each(|l| print!(" {l}")); std::process::exit(1) } @@ -329,7 +329,7 @@ impl<'ast> ZGen<'ast> { Ok(uint_lit(cfg().field().modulus().significant_bits(), 32)) } } - _ => Err(format!("Unknown or unimplemented builtin '{}'", f_name)), + _ => Err(format!("Unknown or unimplemented builtin '{f_name}'")), } } @@ -343,10 +343,10 @@ impl<'ast> ZGen<'ast> { let zaccs = self.zaccs_impl_::(accs)?; let old = if IS_CNST { self.cvar_lookup(name) - .ok_or_else(|| format!("Assignment failed: no const variable {}", name))? + .ok_or_else(|| format!("Assignment failed: no const variable {name}"))? } else { self.circ_get_value(Loc::local(name.to_string())) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? .unwrap_term() }; let new = @@ -357,7 +357,7 @@ impl<'ast> ZGen<'ast> { self.cvar_assign(name, new) } else { self.circ_assign(Loc::local(name.to_string()), Val::Term(new)) - .map_err(|e| format!("{}", e)) + .map_err(|e| format!("{e}")) .map(|_| ()) } } @@ -580,7 +580,7 @@ impl<'ast> ZGen<'ast> { self.cvar_declare_init(p.id.value, &ty, a)?; } else { self.circ_declare_init(p.id.value, ty, Val::Term(a)) - .map_err(|e| format!("{}", e))?; + .map_err(|e| format!("{e}"))?; } } @@ -776,15 +776,14 @@ impl<'ast> ZGen<'ast> { let num_val = num_str.value[1..num_str.value.len() - 1] .parse::() .unwrap_or_else(|e| { - self.err(format!("Bad party number: {}", e), &private.span) + self.err(format!("Bad party number: {e}"), &private.span) }); if num_val <= n_parties { Some(num_val - 1) } else { self.err( format!( - "Party number {} greater than the number of parties ({})", - num_val, n_parties + "Party number {num_val} greater than the number of parties ({n_parties})" ), &private.span, ) @@ -867,7 +866,7 @@ impl<'ast> ZGen<'ast> { }), _ => match self .circ_get_value(Loc::local(i.value.clone())) - .map_err(|e| format!("{}", e))? + .map_err(|e| format!("{e}"))? { Val::Term(t) => Ok(t), _ => Err(format!("Non-Term identifier {}", &i.value)), @@ -1039,13 +1038,13 @@ impl<'ast> ZGen<'ast> { fn canon_struct(&self, id: &str) -> Result { match self .get_struct_or_type(id) - .ok_or_else(|| format!("No such struct or type {} canonicalizing InlineStruct", id))? + .ok_or_else(|| format!("No such struct or type {id} canonicalizing InlineStruct"))? .0 { Ok(_) => Ok(id.to_string()), Err(t) => match &t.ty { ast::Type::Struct(s) => self.canon_struct(&s.id.value), - _ => Err(format!("Found non-Struct canonicalizing struct {}", id,)), + _ => Err(format!("Found non-Struct canonicalizing struct {id}")), }, } } @@ -1066,7 +1065,7 @@ impl<'ast> ZGen<'ast> { self.circ .borrow_mut() .declare_uninit(name, ty) - .map_err(|e| format!("{}", e)) + .map_err(|e| format!("{e}")) } } @@ -1081,7 +1080,7 @@ impl<'ast> ZGen<'ast> { } else { self.circ_declare_init(name, ty, Val::Term(val)) .map(|_| ()) - .map_err(|e| format!("{}", e)) + .map_err(|e| format!("{e}")) } } @@ -1103,7 +1102,7 @@ impl<'ast> ZGen<'ast> { } else { self.ret_impl_::(None) } - .map_err(|e| format!("{}", e)) + .map_err(|e| format!("{e}")) } ast::Statement::Assertion(e) => { match self.expr_impl_::(&e.expression).and_then(|v| { @@ -1141,8 +1140,7 @@ impl<'ast> ZGen<'ast> { Ty::Uint(64) => T::new_u64, _ => { return Err(format!( - "Iteration variable must be Field or Uint, got {:?}", - ty + "Iteration variable must be Field or Uint, got {ty}" )); } }; @@ -1186,8 +1184,7 @@ impl<'ast> ZGen<'ast> { let ty = e.type_(); if &decl_ty != ty { return Err(format!( - "Assignment type mismatch: {} annotated vs {} actual", - decl_ty, ty, + "Assignment type mismatch: {decl_ty} annotated vs {ty} actual", )); } self.declare_init_impl_::( @@ -1249,16 +1246,16 @@ impl<'ast> ZGen<'ast> { ast::RangeOrExpression::Expression(_) => Ok(*ity), ast::RangeOrExpression::Range(_) => Ok(Ty::Array(sz, ity)), }, - ty => Err(format!("Attempted array access on non-Array type {}", ty)), + ty => Err(format!("Attempted array access on non-Array type {ty}")), }, ast::AssigneeAccess::Member(sa) => match ty { Ty::Struct(nm, map) => map .search(&sa.id.value) .map(|r| r.1.clone()) .ok_or_else(|| { - format!("No such member {} of struct {}", &sa.id.value, nm) + format!("No such member {} of struct {nm}", &sa.id.value) }), - ty => Err(format!("Attempted member access on non-Struct type {}", ty)), + ty => Err(format!("Attempted member access on non-Struct type {ty}")), }, }) }) @@ -1326,7 +1323,7 @@ impl<'ast> ZGen<'ast> { .map(|old_val| { *old_val = val; }) - .ok_or_else(|| format!("Const assign failed: no variable {} in scope", name)) + .ok_or_else(|| format!("Const assign failed: no variable {name} in scope")) } fn cvar_declare_init(&self, name: String, ty: &Ty, val: T) -> Result<(), String> { @@ -1592,7 +1589,7 @@ impl<'ast> ZGen<'ast> { .zip(dst_names.into_iter()) .for_each(|(sn, dn)| { if imap.contains_key(&dn) { - self.err(format!("Import {} redeclared", dn), i_span); + self.err(format!("Import {dn} redeclared"), i_span); } assert!(imap.insert(dn, (abs_src_path.clone(), sn)).is_none()); }); diff --git a/src/front/zsharp/term.rs b/src/front/zsharp/term.rs index 6ed9a3fa..c2e12f62 100644 --- a/src/front/zsharp/term.rs +++ b/src/front/zsharp/term.rs @@ -23,7 +23,7 @@ impl Display for Ty { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { Ty::Bool => write!(f, "bool"), - Ty::Uint(w) => write!(f, "u{}", w), + Ty::Uint(w) => write!(f, "u{w}"), Ty::Field => write!(f, "field"), Ty::Struct(n, fields) => { let mut o = f.debug_struct(n); @@ -39,8 +39,8 @@ impl Display for Ty { bb = b.as_ref(); dims.push(n); } - write!(f, "{}", bb)?; - dims.iter().try_for_each(|d| write!(f, "[{}]", d)) + write!(f, "{bb}")?; + dims.iter().try_for_each(|d| write!(f, "[{d}]")) } } } @@ -48,7 +48,7 @@ impl Display for Ty { impl fmt::Debug for Ty { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "{}", self) + write!(f, "{self}") } } @@ -130,7 +130,7 @@ impl T { Ty::Array(size, _sort) => Ok((0..*size) .map(|i| term![Op::Select; self.term.clone(), pf_lit_ir(i)]) .collect()), - s => Err(format!("Not an array: {}", s)), + s => Err(format!("Not an array: {s}")), } } pub fn unwrap_array(self) -> Result, String> { @@ -143,7 +143,7 @@ impl T { .map(|t| T::new(sort.clone(), t)) .collect()) } - s => Err(format!("Not an array: {}", s)), + s => Err(format!("Not an array: {s}")), } } pub fn new_array(v: Vec) -> Result { @@ -209,7 +209,7 @@ impl T { _ => Err(Error::new(ErrorKind::Other, "not a const val")), }?; match val { - Value::Bool(b) => write!(f, "{}", b), + Value::Bool(b) => write!(f, "{b}"), Value::Field(fe) => write!(f, "{}f", fe.i()), Value::BitVector(bv) => match bv.width() { 8 => write!(f, "0x{:02x}", bv.uint()), @@ -227,9 +227,9 @@ impl T { "expected struct, got something else", )) }?; - write!(f, "{} {{ ", n)?; + write!(f, "{n} {{ ")?; fl.fields().zip(vs.iter()).try_for_each(|((n, ty), v)| { - write!(f, "{}: ", n)?; + write!(f, "{n}: ")?; T::new(ty.clone(), leaf_term(Op::Const(v.clone()))).pretty(f)?; write!(f, ", ") })?; @@ -287,7 +287,7 @@ fn wrap_bin_op( (Ty::Field, Ty::Field, _, Some(ff), _) => { Ok(T::new(Ty::Field, ff(a.term.clone(), b.term.clone()))) } - (x, y, _, _, _) => Err(format!("Cannot perform op '{}' on {} and {}", name, x, y)), + (x, y, _, _, _) => Err(format!("Cannot perform op '{name}' on {x} and {y}")), } } @@ -309,7 +309,7 @@ fn wrap_bin_pred( (Ty::Field, Ty::Field, _, Some(ff), _) => { Ok(T::new(Ty::Bool, ff(a.term.clone(), b.term.clone()))) } - (x, y, _, _, _) => Err(format!("Cannot perform op '{}' on {} and {}", name, x, y)), + (x, y, _, _, _) => Err(format!("Cannot perform op '{name}' on {x} and {y}")), } } @@ -495,10 +495,7 @@ pub fn uge(a: T, b: T) -> Result { pub fn pow(a: T, b: T) -> Result { if a.ty != Ty::Field || b.ty != Ty::Uint(32) { - return Err(format!( - "Cannot compute {} ** {} : must be Field ** U32", - a, b - )); + return Err(format!("Cannot compute {a} ** {b} : must be Field ** U32")); } let a = a.term; @@ -531,7 +528,7 @@ fn wrap_un_op( (Ty::Uint(_), Some(fu), _, _) => Ok(T::new(a.ty.clone(), fu(a.term.clone()))), (Ty::Bool, _, _, Some(fb)) => Ok(T::new(Ty::Bool, fb(a.term.clone()))), (Ty::Field, _, Some(ff), _) => Ok(T::new(Ty::Field, ff(a.term.clone()))), - (x, _, _, _) => Err(format!("Cannot perform op '{}' on {}", name, x)), + (x, _, _, _) => Err(format!("Cannot perform op '{name}' on {x}")), } } @@ -564,7 +561,7 @@ pub fn const_int(a: T) -> Result { match const_value(&a.term) { Some(Value::Field(f)) => Ok(f.i()), Some(Value::BitVector(f)) => Ok(f.uint().clone()), - _ => Err(format!("{} is not a constant integer", a)), + _ => Err(format!("{a} is not a constant integer")), } } @@ -593,7 +590,7 @@ fn const_value(t: &Term) -> Option { pub fn bool(a: T) -> Result { match &a.ty { Ty::Bool => Ok(a.term), - a => Err(format!("{} is not a boolean", a)), + a => Err(format!("{a} is not a boolean")), } } @@ -601,7 +598,7 @@ fn wrap_shift(name: &str, op: BvBinOp, a: T, b: T) -> Result { let bc = const_int(b)?; match &a.ty { &Ty::Uint(na) => Ok(T::new(a.ty, term![Op::BvBinOp(op); a.term, bv_lit(bc, na)])), - x => Err(format!("Cannot perform op '{}' on {} and {}", name, x, bc)), + x => Err(format!("Cannot perform op '{name}' on {x} and {bc}")), } } @@ -615,7 +612,7 @@ pub fn shr(a: T, b: T) -> Result { fn ite(c: Term, a: T, b: T) -> Result { if a.ty != b.ty { - Err(format!("Cannot perform ITE on {} and {}", a, b)) + Err(format!("Cannot perform ITE on {a} and {b}")) } else { Ok(T::new(a.ty.clone(), term![Op::Ite; c, a.term, b.term])) } @@ -664,7 +661,7 @@ pub fn slice(arr: T, start: Option, end: Option) -> Result Err(format!("Cannot slice {}", a)), + a => Err(format!("Cannot slice {a}")), } } @@ -677,10 +674,10 @@ pub fn field_select(struct_: &T, field: &str) -> Result { term![Op::Field(idx); struct_.term.clone()], )) } else { - Err(format!("No field '{}'", field)) + Err(format!("No field '{field}'")) } } - a => Err(format!("{} is not a struct", a)), + a => Err(format!("{a} is not a struct")), } } @@ -695,17 +692,15 @@ pub fn field_store(struct_: T, field: &str, val: T) -> Result { )) } else { Err(format!( - "term {} assigned to field {} of type {}", - val, - field, + "term {val} assigned to field {field} of type {}", map.get(idx).1 )) } } else { - Err(format!("No field '{}'", field)) + Err(format!("No field '{field}'")) } } - a => Err(format!("{} is not a struct", a)), + a => Err(format!("{a} is not a struct")), } } @@ -792,15 +787,15 @@ pub fn uint_to_field(u: T) -> Result { Ty::Field, term![Op::UbvToPf(cfg().field().clone()); u.term], )), - u => Err(format!("Cannot do uint-to-field on {}", u)), + u => Err(format!("Cannot do uint-to-field on {u}")), } } pub fn uint_to_uint(u: T, w: usize) -> Result { match &u.ty { Ty::Uint(n) if *n <= w => Ok(T::new(Ty::Uint(w), term![Op::BvUext(w - n); u.term])), - Ty::Uint(n) => Err(format!("Tried narrowing uint{}-to-uint{} attempted", n, w)), - u => Err(format!("Cannot do uint-to-uint on {}", u)), + Ty::Uint(n) => Err(format!("Tried narrowing uint{n}-to-uint{w} attempted")), + u => Err(format!("Cannot do uint-to-uint on {u}")), } } @@ -813,7 +808,7 @@ pub fn uint_to_bits(u: T) -> Result { (0..*n).rev().map(|i| term![Op::BvBit(i); u.term.clone()]), ), )), - u => Err(format!("Cannot do uint-to-bits on {}", u)), + u => Err(format!("Cannot do uint-to-bits on {u}")), } } @@ -831,16 +826,16 @@ pub fn uint_from_bits(u: T) -> Result { .collect(), ), )), - l => Err(format!("Cannot do uint-from-bits on len {} array", l,)), + l => Err(format!("Cannot do uint-from-bits on len {l} array")), }, - u => Err(format!("Cannot do uint-from-bits on {}", u)), + u => Err(format!("Cannot do uint-from-bits on {u}")), } } pub fn field_to_bits(f: T, n: usize) -> Result { match &f.ty { Ty::Field => uint_to_bits(T::new(Ty::Uint(n), term![Op::PfToBv(n); f.term])), - u => Err(format!("Cannot do uint-to-bits on {}", u)), + u => Err(format!("Cannot do uint-to-bits on {u}")), } } @@ -860,13 +855,11 @@ pub fn bit_array_le(a: T, b: T, n: usize) -> Result { Err("bit-array-le must be called on arrays of Bools".to_string()) } else if la != lb { Err(format!( - "bit-array-le called on arrays with lengths {} != {}", - la, lb + "bit-array-le called on arrays with lengths {la} != {lb}" )) } else if *la != n { Err(format!( - "bit-array-le::<{}> called on arrays with length {}", - n, la + "bit-array-le::<{n}> called on arrays with length {la}" )) } else { Ok(()) @@ -886,11 +879,11 @@ pub fn bit_array_le(a: T, b: T, n: usize) -> Result { pub struct ZSharp {} fn field_name(struct_name: &str, field_name: &str) -> String { - format!("{}.{}", struct_name, field_name) + format!("{struct_name}.{field_name}") } fn idx_name(struct_name: &str, idx: usize) -> String { - format!("{}.{}", struct_name, idx) + format!("{struct_name}.{idx}") } impl ZSharp { diff --git a/src/front/zsharp/zvisit/eqtype.rs b/src/front/zsharp/zvisit/eqtype.rs index cf51258e..c9c7f2a8 100644 --- a/src/front/zsharp/zvisit/eqtype.rs +++ b/src/front/zsharp/zvisit/eqtype.rs @@ -16,8 +16,7 @@ pub(super) fn eq_type<'ast>( (Array(aty), Array(aty2)) => eq_array_type(aty, aty2, zgen), (Struct(sty), Struct(sty2)) => eq_struct_type(sty, sty2, zgen), _ => Err(ZVisitorError(format!( - "type mismatch: expected {:?}, found {:?}", - ty, ty2, + "type mismatch: expected {ty:?}, found {ty2:?}" ))), } } @@ -32,8 +31,7 @@ fn eq_basic_type<'ast>(ty: &ast::BasicType<'ast>, ty2: &ast::BasicType<'ast>) -> (U32(_), U32(_)) => Ok(()), (U64(_), U64(_)) => Ok(()), _ => Err(ZVisitorError(format!( - "basic type mismatch: expected {:?}, found {:?}", - ty, ty2, + "basic type mismatch: expected {ty:?}, found {ty2:?}" ))), } } @@ -79,7 +77,7 @@ fn eq_struct_type<'ast>( } } -fn is_struct<'ast>(id: &str, zgen: &ZGen<'ast>) -> bool { +fn is_struct(id: &str, zgen: &ZGen<'_>) -> bool { zgen.get_struct_or_type(id) .map(|(s, _)| s.is_ok()) .unwrap_or(false) diff --git a/src/front/zsharp/zvisit/zgenericinf.rs b/src/front/zsharp/zvisit/zgenericinf.rs index ce1fd7a0..b6e7ee41 100644 --- a/src/front/zsharp/zvisit/zgenericinf.rs +++ b/src/front/zsharp/zvisit/zgenericinf.rs @@ -215,8 +215,7 @@ impl<'ast, 'gen, const IS_CNST: bool> ZGenericInf<'ast, 'gen, IS_CNST> { .type_impl_::(&ast::Type::Basic(bas_ty.clone()))? { Err(format!( - "Type mismatch unifying generics: got {}, decl was {:?}", - arg_ty, bas_ty + "Type mismatch unifying generics: got {arg_ty}, decl was {bas_ty:?}" )) } else { Ok(()) @@ -230,8 +229,7 @@ impl<'ast, 'gen, const IS_CNST: bool> ZGenericInf<'ast, 'gen, IS_CNST> { ) -> Result<(), String> { if !matches!(arg_ty, Ty::Array(_, _)) { return Err(format!( - "Type mismatch unifying generics: got {}, decl was Array", - arg_ty + "Type mismatch unifying generics: got {arg_ty}, decl was Array", )); } @@ -359,12 +357,11 @@ impl<'ast, 'gen, const IS_CNST: bool> ZGenericInf<'ast, 'gen, IS_CNST> { Ok(aty_map.into_map()) } Ty::Struct(aty_n, _) => Err(format!( - "Type mismatch: got struct {}, decl was struct {}", - &aty_n, &def_ty.id.value + "Type mismatch: got struct {aty_n}, decl was struct {}", + &def_ty.id.value )), arg_ty => Err(format!( - "Type mismatch unifying generics: got {}, decl was Struct", - arg_ty + "Type mismatch unifying generics: got {arg_ty}, decl was Struct", )), }?; for ast::StructField { ty, id, .. } in strdef.fields.iter() { @@ -452,8 +449,7 @@ fn u32_term(t: T) -> Result { match t.ty { Ty::Uint(32) => Ok(t.term), ty => Err(format!( - "ZGenericInf: got {} for expr, expected T::Uint(32)", - ty + "ZGenericInf: got {ty} for expr, expected T::Uint(32)" )), } } diff --git a/src/front/zsharp/zvisit/zstmtwalker/mod.rs b/src/front/zsharp/zvisit/zstmtwalker/mod.rs index 040db110..d561a53c 100644 --- a/src/front/zsharp/zvisit/zstmtwalker/mod.rs +++ b/src/front/zsharp/zvisit/zstmtwalker/mod.rs @@ -625,7 +625,7 @@ impl<'ast, 'ret> ZStatementWalker<'ast, 'ret> { fn get_function(&self, id: &str) -> ZResult<&ast::FunctionDefinition<'ast>> { self.zgen .get_function(id) - .ok_or_else(|| ZVisitorError(format!("ZStatementWalker: undeclared function {}", id))) + .ok_or_else(|| ZVisitorError(format!("ZStatementWalker: undeclared function {id}"))) } fn get_struct_or_type( @@ -682,13 +682,11 @@ impl<'ast, 'ret> ZStatementWalker<'ast, 'ret> { { if self.generic_defined(nm) { Err(ZVisitorError(format!( - "ZStatementWalker: attempted to shadow generic {}", - nm, + "ZStatementWalker: attempted to shadow generic {nm}" ))) } else if self.const_defined(nm) { Err(ZVisitorError(format!( - "ZStatementWalker: attempted to shadow const {}", - nm, + "ZStatementWalker: attempted to shadow const {nm}" ))) } else { Ok(f(self, nm)) diff --git a/src/front/zsharp/zvisit/zstmtwalker/zexprtyper.rs b/src/front/zsharp/zvisit/zstmtwalker/zexprtyper.rs index 7700fc6f..d21917a0 100644 --- a/src/front/zsharp/zvisit/zstmtwalker/zexprtyper.rs +++ b/src/front/zsharp/zvisit/zstmtwalker/zexprtyper.rs @@ -273,8 +273,7 @@ impl<'ast, 'ret, 'wlk> ZVisitorMut<'ast> for ZExpressionTyper<'ast, 'ret, 'wlk> } } else { Err(format!( - "ZExpressionTyper: Spread expression: expected array, got {:?}", - ty + "ZExpressionTyper: Spread expression: expected array, got {ty:?}" )) }?; @@ -291,8 +290,7 @@ impl<'ast, 'ret, 'wlk> ZVisitorMut<'ast> for ZExpressionTyper<'ast, 'ret, 'wlk> Ok(()) } else { Err(ZVisitorError(format!( - "ZExpressionTyper: Could not type SpreadOrExpression::Spread {:#?}", - soe + "ZExpressionTyper: Could not type SpreadOrExpression::Spread {soe:#?}", ))) } })?; @@ -303,7 +301,7 @@ impl<'ast, 'ret, 'wlk> ZVisitorMut<'ast> for ZExpressionTyper<'ast, 'ret, 'wlk> ast::Expression::Literal(ast::LiteralExpression::HexLiteral( ast::HexLiteralExpression { value: ast::HexNumberExpression::U32(ast::U32NumberExpression { - value: format!("{:04x}", acc_len), + value: format!("{acc_len:04x}"), span: iae.span, }), span: iae.span, diff --git a/src/ir/opt/cfold.rs b/src/ir/opt/cfold.rs index e5cdce68..f097c318 100644 --- a/src/ir/opt/cfold.rs +++ b/src/ir/opt/cfold.rs @@ -123,8 +123,8 @@ pub fn fold_cache(node: &Term, cache: &mut TermCache, ignore: &[Op]) -> T if let FieldToBv::Panic = cfg().ir.field_to_bv { assert!( (i.significant_bits() as usize) <= *w, - "oversized input to Op::PfToBv({})", - w + "{}", + "oversized input to Op::PfToBv({w})", ); } bv_lit(i % (Integer::from(1) << *w), *w) @@ -614,7 +614,7 @@ mod test { let tt = fold(&t, &[]); let orig = eval(&t, &vs); let new = eval(&tt, &vs); - assert!(orig == new, "{} ({}) vs {} ({})", t, orig, tt, new); + assert!(orig == new, "{}", "{t} ({orig}) vs {tt} ({new})"); } #[test] diff --git a/src/ir/opt/inline.rs b/src/ir/opt/inline.rs index 1b9947f1..702ebda0 100644 --- a/src/ir/opt/inline.rs +++ b/src/ir/opt/inline.rs @@ -47,43 +47,35 @@ impl<'a> Inliner<'a> { for child in PostOrderIter::new(value.clone()) { assert!( !keys.contains(&child), - "Substituted variable {} is in the substitution for {}, {}", - child, - key, - value + "{}", + "Substituted variable {child} is in the substitution for {key}, {value}" ); if child.is_var() { assert!( self.stale_vars.contains(&child), - "Variable {} in the substitution for {}, {} is not marked stale", - child, - key, - value + "{}", + "Variable {child} in the substitution for {key}, {value} is not marked stale" ); } } assert!( self.stale_vars.contains(key), - "Variable {}, which is being susbstituted", - key + "{}", + "Variable {key}, which is being susbstituted", ); } for (key, value) in &self.subst_cache { for child in PostOrderIter::new(value.clone()) { assert!( !keys.contains(&child), - "Substituted variable {} is in the cache for {}, {}", - child, - key, - value + "{}", + format!("Substituted variable {child} is in the cache for {key}, {value}"), ); if child.is_var() { assert!( self.stale_vars.contains(&child), - "Variable {} in the substitution cache for {}, {} is not marked stale", - child, - key, - value + "{}", + format!("Variable {child} in the substitution cache for {key}, {value} is not marked stale") ); } } diff --git a/src/ir/opt/mem/lin.rs b/src/ir/opt/mem/lin.rs index c1885665..42996ead 100644 --- a/src/ir/opt/mem/lin.rs +++ b/src/ir/opt/mem/lin.rs @@ -32,7 +32,7 @@ impl RewritePass for Linearizer { Op::Const(v @ Value::Array(..)) => Some(leaf_term(Op::Const(arr_val_to_tup(v)))), Op::Var(name, Sort::Array(..)) => { let precomp = extras::array_to_tuple(orig); - let new_name = format!("{}.tup", name); + let new_name = format!("{name}.tup"); let new_sort = check(&precomp); computation.extend_precomputation(new_name.clone(), precomp); Some(leaf_term(Op::Var(new_name, new_sort))) diff --git a/src/ir/opt/mem/obliv.rs b/src/ir/opt/mem/obliv.rs index 5de878bc..873da8c5 100644 --- a/src/ir/opt/mem/obliv.rs +++ b/src/ir/opt/mem/obliv.rs @@ -240,7 +240,7 @@ impl RewritePass for Replacer { Op::Var(name, Sort::Array(..)) => { if self.should_replace(orig) { let precomp = extras::array_to_tuple(orig); - let new_name = format!("{}.tup", name); + let new_name = format!("{name}.tup"); let new_sort = check(&precomp); computation.extend_precomputation(new_name.clone(), precomp); Some(leaf_term(Op::Var(new_name, new_sort))) diff --git a/src/ir/opt/mod.rs b/src/ir/opt/mod.rs index cc880227..e8548fc6 100644 --- a/src/ir/opt/mod.rs +++ b/src/ir/opt/mod.rs @@ -72,7 +72,7 @@ pub fn opt>(mut cs: Computations, optimizations: I) Opt::FlattenAssertions => { let mut new_outputs = Vec::new(); for a in std::mem::take(&mut c.outputs) { - assert_eq!(check(&a), Sort::Bool, "Non-bool in {:?}", i); + assert_eq!(check(&a), Sort::Bool, "Non-bool in {i:?}"); if a.op() == &Op::BoolNaryOp(BoolNaryOp::And) { new_outputs.extend(a.cs().iter().cloned()); } else { diff --git a/src/ir/opt/scalarize_vars.rs b/src/ir/opt/scalarize_vars.rs index 58108715..14644a20 100644 --- a/src/ir/opt/scalarize_vars.rs +++ b/src/ir/opt/scalarize_vars.rs @@ -21,7 +21,7 @@ fn create_vars( .enumerate() .map(|(i, sort)| { create_vars( - &format!("{}.{}", prefix, i), + &format!("{prefix}.{i}"), term![Op::Field(i); prefix_term.clone()], sort, new_var_requests, @@ -39,7 +39,7 @@ fn create_vars( .zip(array_elements) .map(|(i, element)| { create_vars( - &format!("{}.{}", prefix, i), + &format!("{prefix}.{i}"), element, val_s, new_var_requests, diff --git a/src/ir/opt/sha.rs b/src/ir/opt/sha.rs index 7b9be9f9..59f5027b 100644 --- a/src/ir/opt/sha.rs +++ b/src/ir/opt/sha.rs @@ -227,7 +227,7 @@ mod test { fn catch_all_case() { let abc_term_rewrites = |t: &str| -> bool { contains_ite(&sha_rewrites(&parse_term( - format!("(declare ((a (bv 4))(b (bv 4))(c (bv 4))) {})", t).as_bytes(), + format!("(declare ((a (bv 4))(b (bv 4))(c (bv 4))) {t})").as_bytes(), ))) }; assert!(abc_term_rewrites("(bvor (bvand a b) (bvand (bvnot a) c))")); diff --git a/src/ir/term/dist.rs b/src/ir/term/dist.rs index 04e62dfe..232db973 100644 --- a/src/ir/term/dist.rs +++ b/src/ir/term/dist.rs @@ -120,7 +120,7 @@ impl FixedSizeDist { } Sort::BitVector(w) => vec![ self.sample_value(sort, rng), - Op::Var(self.sample_ident(&format!("bv{}", w), rng), sort.clone()), + Op::Var(self.sample_ident(&format!("bv{w}"), rng), sort.clone()), Op::BvUnOp(BvUnOp::Neg), Op::BvUnOp(BvUnOp::Not), Op::BvUext(rng.gen_range(0..*w)), @@ -152,7 +152,7 @@ impl FixedSizeDist { // No variables! Op::Var( self.sample_ident( - &format!("tp_{}", sort) + &format!("tp_{sort}") .replace('(', "[") .replace(')', "]") .replace(' ', "_"), diff --git a/src/ir/term/extras.rs b/src/ir/term/extras.rs index c5caa896..5fba4ab2 100644 --- a/src/ir/term/extras.rs +++ b/src/ir/term/extras.rs @@ -124,7 +124,7 @@ pub fn assert_all_vars_declared(c: &Computation) { let vars: FxHashSet = c.metadata.vars.iter().map(|p| p.0.clone()).collect(); for o in &c.outputs { for v in free_variables(o.clone()) { - assert!(vars.contains(&v), "Variable {} is not declared", v); + assert!(vars.contains(&v), "{}", "Variable {v} is not declared"); } } } diff --git a/src/ir/term/fmt.rs b/src/ir/term/fmt.rs index 99edf783..62be3107 100644 --- a/src/ir/term/fmt.rs +++ b/src/ir/term/fmt.rs @@ -89,7 +89,7 @@ impl<'a, 'b> IrFormatter<'a, 'b> { } } fn write_def(&mut self, id: usize) -> FmtResult { - write!(self.writer, "'{}", id) + write!(self.writer, "'{id}") } /// returns whether the term was def'd and written. fn term_write_if_def(&mut self, t: &Term) -> Result { @@ -121,7 +121,7 @@ impl DisplayIr for Sort { fn ir_fmt(&self, f: &mut IrFormatter) -> FmtResult { match self { Sort::Bool => write!(f, "bool"), - Sort::BitVector(n) => write!(f, "(bv {})", n), + Sort::BitVector(n) => write!(f, "(bv {n})"), Sort::Int => write!(f, "int"), Sort::F32 => write!(f, "f32"), Sort::F64 => write!(f, "f64"), @@ -132,7 +132,7 @@ impl DisplayIr for Sort { k.ir_fmt(f)?; write!(f, " ")?; v.ir_fmt(f)?; - write!(f, " {})", n) + write!(f, " {n})") } Sort::Tuple(fields) => { write!(f, "(tuple")?; @@ -151,48 +151,48 @@ impl DisplayIr for Op { match self { Op::Ite => write!(f, "ite"), Op::Eq => write!(f, "="), - Op::Var(n, _) => write!(f, "{}", n), + Op::Var(n, _) => write!(f, "{n}"), Op::Const(c) => c.ir_fmt(f), - Op::BvBinOp(a) => write!(f, "{}", a), - Op::BvBinPred(a) => write!(f, "{}", a), - Op::BvNaryOp(a) => write!(f, "{}", a), - Op::BvUnOp(a) => write!(f, "{}", a), + Op::BvBinOp(a) => write!(f, "{a}"), + Op::BvBinPred(a) => write!(f, "{a}"), + Op::BvNaryOp(a) => write!(f, "{a}"), + Op::BvUnOp(a) => write!(f, "{a}"), Op::BoolToBv => write!(f, "bool2bv"), - Op::BvExtract(a, b) => write!(f, "(extract {} {})", a, b), + Op::BvExtract(a, b) => write!(f, "(extract {a} {b})"), Op::BvConcat => write!(f, "concat"), - Op::BvUext(a) => write!(f, "(uext {})", a), - Op::BvSext(a) => write!(f, "(sext {})", a), - Op::PfToBv(a) => write!(f, "(pf2bv {})", a), + Op::BvUext(a) => write!(f, "(uext {a})"), + Op::BvSext(a) => write!(f, "(sext {a})"), + Op::PfToBv(a) => write!(f, "(pf2bv {a})"), Op::Implies => write!(f, "=>"), - Op::BoolNaryOp(a) => write!(f, "{}", a), + Op::BoolNaryOp(a) => write!(f, "{a}"), Op::Not => write!(f, "not"), - Op::BvBit(a) => write!(f, "(bit {})", a), + Op::BvBit(a) => write!(f, "(bit {a})"), Op::BoolMaj => write!(f, "maj"), - Op::FpBinOp(a) => write!(f, "{}", a), - Op::FpBinPred(a) => write!(f, "{}", a), - Op::FpUnPred(a) => write!(f, "{}", a), - Op::FpUnOp(a) => write!(f, "{}", a), + Op::FpBinOp(a) => write!(f, "{a}"), + Op::FpBinPred(a) => write!(f, "{a}"), + Op::FpUnPred(a) => write!(f, "{a}"), + Op::FpUnOp(a) => write!(f, "{a}"), Op::BvToFp => write!(f, "bv2fp"), - Op::UbvToFp(a) => write!(f, "(ubv2fp {})", a), - Op::SbvToFp(a) => write!(f, "(sbv2fp {})", a), - Op::FpToFp(a) => write!(f, "(fp2fp {})", a), - Op::PfUnOp(a) => write!(f, "{}", a), - Op::PfNaryOp(a) => write!(f, "{}", a), - Op::IntNaryOp(a) => write!(f, "{}", a), - Op::IntBinPred(a) => write!(f, "{}", a), + Op::UbvToFp(a) => write!(f, "(ubv2fp {a})"), + Op::SbvToFp(a) => write!(f, "(sbv2fp {a})"), + Op::FpToFp(a) => write!(f, "(fp2fp {a})"), + Op::PfUnOp(a) => write!(f, "{a}"), + Op::PfNaryOp(a) => write!(f, "{a}"), + Op::IntNaryOp(a) => write!(f, "{a}"), + Op::IntBinPred(a) => write!(f, "{a}"), Op::UbvToPf(a) => write!(f, "(bv2pf {})", a.modulus()), Op::Select => write!(f, "select"), Op::Store => write!(f, "store"), Op::Tuple => write!(f, "tuple"), - Op::Field(i) => write!(f, "(field {})", i), - Op::Update(i) => write!(f, "(update {})", i), + Op::Field(i) => write!(f, "(field {i})"), + Op::Update(i) => write!(f, "(update {i})"), Op::Map(op) => { write!(f, "(map(")?; op.ir_fmt(f)?; write!(f, "))") } - Op::Call(name, _, _) => write!(f, "fn:{}", name), - Op::Rot(i) => write!(f, "(rot {})", i), + Op::Call(name, _, _) => write!(f, "fn:{name}"), + Op::Rot(i) => write!(f, "(rot {i})"), } } } @@ -200,12 +200,12 @@ impl DisplayIr for Op { impl DisplayIr for Value { fn ir_fmt(&self, f: &mut IrFormatter) -> FmtResult { match self { - Value::Bool(b) => write!(f, "{}", b), - Value::F32(b) => write!(f, "{}", b), - Value::F64(b) => write!(f, "{}", b), - Value::Int(b) => write!(f, "{}", b), + Value::Bool(b) => write!(f, "{b}"), + Value::F32(b) => write!(f, "{b}"), + Value::F64(b) => write!(f, "{b}"), + Value::Int(b) => write!(f, "{b}"), Value::Field(b) => b.ir_fmt(f), - Value::BitVector(b) => write!(f, "{}", b), + Value::BitVector(b) => write!(f, "{b}"), Value::Tuple(fields) => { write!(f, "(#t ")?; for field in fields.iter() { @@ -253,7 +253,7 @@ impl DisplayIr for FieldV { if i.significant_bits() + 1 >= mod_bits { i -= self.modulus(); } - write!(f, "#f{}", i)?; + write!(f, "#f{i}")?; if !omit_field { write!(f, "m{}", self.modulus())?; } @@ -286,7 +286,7 @@ impl DisplayIr for VariableMetadata { write!(f, "({} ", self.name)?; self.sort.ir_fmt(f)?; if let Some(v) = self.vis.as_ref() { - write!(f, " (party {})", v)?; + write!(f, " (party {v})")?; } if 0 != self.round { write!(f, " (round {})", self.round)?; @@ -308,7 +308,7 @@ impl DisplayIr for ComputationMetadata { .collect(); for id in 0..self.party_ids.len() as u8 { let party = ids_to_parties.get(&id).unwrap(); - write!(f, " {}", party)?; + write!(f, " {party}")?; } writeln!(f, ")")?; write!(f, "\n (inputs")?; @@ -353,7 +353,7 @@ fn fmt_term_with_bindings(t: &Term, f: &mut IrFormatter) -> FmtResult { *parent_counts.entry(c).or_insert(0) += 1; } if let Op::Var(name, sort) = &t.op() { - write!(f, " ({} ", name)?; + write!(f, " ({name} ")?; sort.ir_fmt(f)?; writeln!(f, ")")?; } @@ -382,7 +382,7 @@ fn fmt_term_with_bindings(t: &Term, f: &mut IrFormatter) -> FmtResult { impl<'a> Display for IrWrapper<'a, Term> { fn fmt(&self, f: &mut Formatter) -> FmtResult { - write!(f, "{:?}", self) + write!(f, "{self:?}") } } @@ -404,7 +404,7 @@ impl Debug for Term { impl Display for Term { fn fmt(&self, f: &mut Formatter) -> FmtResult { - write!(f, "{:?}", self) + write!(f, "{self:?}") } } diff --git a/src/ir/term/mod.rs b/src/ir/term/mod.rs index 3d64840c..e358ae40 100644 --- a/src/ir/term/mod.rs +++ b/src/ir/term/mod.rs @@ -1300,8 +1300,8 @@ fn eval_value(vs: &mut TermMap, h: &FxHashMap, c: Term) -> if let FieldToBv::Panic = cfg().ir.field_to_bv { assert!( (i.significant_bits() as usize) <= *w, - "oversized input to Op::PfToBv({})", - w + "{}", + "oversized input to Op::PfToBv({w})", ); } BitVector::new(i % (Integer::from(1) << *w), *w) diff --git a/src/ir/term/text/mod.rs b/src/ir/term/text/mod.rs index 4fc2b3a0..c1fd2f40 100644 --- a/src/ir/term/text/mod.rs +++ b/src/ir/term/text/mod.rs @@ -92,7 +92,7 @@ impl<'src> Display for TokTree<'src> { } else { write!(f, " ")?; } - write!(f, "{}", tt)?; + write!(f, "{tt}")?; } write!(f, ")") } @@ -460,8 +460,7 @@ impl<'src> IrInterp<'src> { assert_eq!( tts.len(), 3, - "A decl should have 2 arguments: (declare ((v1 s1) ... (vn sn)) t), found {:#?}", - tts + "A decl should have 2 arguments: (declare ((v1 s1) ... (vn sn)) t), found {tts:#?}", ); let bindings = self.decl_list(&tts[1]); let t = self.term(&tts[2]); @@ -756,7 +755,7 @@ pub fn serialize_value_map(src: &HashMap) -> String { let mut out = String::new(); writeln!(&mut out, "(let (").unwrap(); for (var, val) in src { - writeln!(&mut out, " ({} {})", var, val).unwrap(); + writeln!(&mut out, " ({var} {val})").unwrap(); } writeln!(&mut out, ") true;ignored \n)").unwrap(); out @@ -786,11 +785,11 @@ pub fn serialize_precompute(p: &precomp::PreComp) -> String { let mut out = String::new(); writeln!(&mut out, "(precompute (").unwrap(); for (name, sort) in p.inputs() { - writeln!(&mut out, " ({} {})", name, sort).unwrap(); + writeln!(&mut out, " ({name} {sort})").unwrap(); } writeln!(&mut out, ")(").unwrap(); for (name, sort) in p.sequence() { - writeln!(&mut out, " ({} {})", name, sort).unwrap(); + writeln!(&mut out, " ({name} {sort})").unwrap(); } writeln!(&mut out, ")").unwrap(); writeln!(&mut out, "\n {}", serialize_term(&p.tuple())).unwrap(); @@ -880,7 +879,7 @@ mod test { ((field 0) (#t false false #b0000 true)))))", ); let s = serialize_term(&t); - println!("{}", s); + println!("{s}"); let t2 = parse_term(s.as_bytes()); assert_eq!(t, t2); } diff --git a/src/ir/term/ty.rs b/src/ir/term/ty.rs index 9cde849c..d9dd3a59 100644 --- a/src/ir/term/ty.rs +++ b/src/ir/term/ty.rs @@ -113,8 +113,7 @@ fn check_raw_step(t: &Term, tys: &TypeTable) -> Result { Ok(Sort::BitVector(32)) => Ok(Sort::F32), Ok(Sort::BitVector(64)) => Ok(Sort::F64), Ok(s) => Err(TypeErrorReason::Custom(format!( - "Cannot convert {} to floating-point", - s + "Cannot convert {s} to floating-point" ))), Err(e) => Err(e), }, @@ -139,8 +138,7 @@ fn check_raw_step(t: &Term, tys: &TypeTable) -> Result { Ok(sorts[*i].clone()) } else { Err(TypeErrorReason::OutOfBounds(format!( - "index {} in tuple of sort {}", - i, sort + "index {i} in tuple of sort {sort}" ))) } } @@ -183,7 +181,7 @@ fn check_raw_step(t: &Term, tys: &TypeTable) -> Result { } Op::Call(_, _, ret) => Ok(ret.clone()), Op::Rot(_) => Ok(get_ty(&t.cs()[0]).clone()), - o => Err(TypeErrorReason::Custom(format!("other operator: {}", o))), + o => Err(TypeErrorReason::Custom(format!("other operator: {o}"))), } } @@ -263,8 +261,7 @@ pub fn rec_check_raw_helper(oper: &Op, a: &[&Sort]) -> Result Result Result Result ToABY<'a> { Op::Const(Value::BitVector(b)) => { let value = b.as_sint(); let bitlen = 32; - let line = format!("2 1 {} {} {} {}\n", value, bitlen, output_share, op); + let line = format!("2 1 {value} {bitlen} {output_share} {op}\n"); self.const_output.push(line); } Op::Const(Value::Bool(b)) => { let value = *b as i32; let bitlen = 1; - let line = format!("2 1 {} {} {} {}\n", value, bitlen, output_share, op); + let line = format!("2 1 {value} {bitlen} {output_share} {op}\n"); self.const_output.push(line); } _ => todo!(), @@ -206,7 +206,7 @@ impl<'a> ToABY<'a> { fn write_share(&mut self, t: &Term, s: i32) { let share_type = self.get_term_share_type(t).char(); - let line = format!("{} {}\n", s, share_type); + let line = format!("{s} {share_type}\n"); self.share_output.push(line); } @@ -269,7 +269,7 @@ impl<'a> ToABY<'a> { let s = self.get_share(t, to_share_type); if let std::collections::hash_map::Entry::Vacant(e) = self.cache.entry(key.clone()) { e.insert(s); - let line = format!("2 1 {} {} {} {}\n", a, b, s, op); + let line = format!("2 1 {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -289,10 +289,10 @@ impl<'a> ToABY<'a> { if vis == PUBLIC { let bitlen = 1; - let line = format!("3 1 {} {} {} {} {}\n", name, vis, bitlen, s, op); + let line = format!("3 1 {name} {vis} {bitlen} {s} {op}\n"); self.bytecode_input.push(line); } else { - let line = format!("2 1 {} {} {} {}\n", name, vis, s, op); + let line = format!("2 1 {name} {vis} {s} {op}\n"); self.bytecode_input.push(line); } self.inputs.push(t.clone()); @@ -316,7 +316,7 @@ impl<'a> ToABY<'a> { if let std::collections::hash_map::Entry::Vacant(e) = self.cache.entry(key.clone()) { e.insert(s); - let line = format!("3 1 {} {} {} {} {}\n", sel, a, b, s, op); + let line = format!("3 1 {sel} {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -332,7 +332,7 @@ impl<'a> ToABY<'a> { if let std::collections::hash_map::Entry::Vacant(e) = self.cache.entry(key.clone()) { e.insert(s); - let line = format!("1 1 {} {} {}\n", a, s, op); + let line = format!("1 1 {a} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -368,7 +368,7 @@ impl<'a> ToABY<'a> { self.cache.entry(key.clone()) { e.insert(s); - let line = format!("2 1 {} {} {} {}\n", a, b, s, op); + let line = format!("2 1 {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -393,7 +393,7 @@ impl<'a> ToABY<'a> { if let std::collections::hash_map::Entry::Vacant(e) = self.cache.entry(key.clone()) { e.insert(s); - let line = format!("2 1 {} {} {} {}\n", a, b, s, op); + let line = format!("2 1 {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -416,10 +416,10 @@ impl<'a> ToABY<'a> { if vis == PUBLIC { let bitlen = 32; - let line = format!("3 1 {} {} {} {} {}\n", name, vis, bitlen, s, op); + let line = format!("3 1 {name} {vis} {bitlen} {s} {op}\n"); self.bytecode_input.push(line); } else { - let line = format!("2 1 {} {} {} {}\n", name, vis, s, op); + let line = format!("2 1 {name} {vis} {s} {op}\n"); self.bytecode_input.push(line); } self.inputs.push(t.clone()); @@ -440,7 +440,7 @@ impl<'a> ToABY<'a> { if let std::collections::hash_map::Entry::Vacant(e) = self.cache.entry(key.clone()) { e.insert(s); - let line = format!("3 1 {} {} {} {} {}\n", sel, a, b, s, op); + let line = format!("3 1 {sel} {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -463,7 +463,7 @@ impl<'a> ToABY<'a> { if let std::collections::hash_map::Entry::Vacant(e) = self.cache.entry(key.clone()) { e.insert(s); - let line = format!("2 1 {} {} {} {}\n", a, b, s, op); + let line = format!("2 1 {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -491,7 +491,7 @@ impl<'a> ToABY<'a> { self.cache.entry(key.clone()) { e.insert(s); - let line = format!("2 1 {} {} {} {}\n", a, b, s, op); + let line = format!("2 1 {a} {b} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -513,7 +513,7 @@ impl<'a> ToABY<'a> { self.cache.entry(key.clone()) { e.insert(s); - let line = format!("2 1 {} {} {} {}\n", a, const_shift_amount, s, op); + let line = format!("2 1 {a} {const_shift_amount} {s} {op}\n"); self.bytecode_output.push(line); } else { let s = *self.cache.get(&key).unwrap(); @@ -528,7 +528,7 @@ impl<'a> ToABY<'a> { let tuple_share = self.get_share(&t.cs()[0], to_share_type); let field_share = self.get_share(&t, to_share_type); let op = "FIELD"; - let line = format!("2 1 {} {} {} {}\n", tuple_share, i, field_share, op); + let line = format!("2 1 {tuple_share} {i} {field_share} {op}\n"); self.bytecode_output.push(line); self.term_to_shares.insert(t.clone(), field_share); } @@ -541,15 +541,12 @@ impl<'a> ToABY<'a> { let op = "SELECT_CONS"; let idx = bv.uint().to_usize().unwrap(); let len = self.get_sort_len(&check(&t.cs()[0])); - assert!(idx < len, "idx: {}, len: {}", idx, len); - format!("2 1 {} {} {} {}\n", array_share, idx, select_share, op) + assert!(idx < len, "{}", "idx: {idx}, len: {len}"); + format!("2 1 {array_share} {idx} {select_share} {op}\n") } else { let op = "SELECT"; let idx_share = self.get_share(&t.cs()[1], to_share_type); - format!( - "2 1 {} {} {} {}\n", - array_share, idx_share, select_share, op - ) + format!("2 1 {array_share} {idx_share} {select_share} {op}\n",) }; self.bytecode_output.push(line); self.term_to_shares.insert(t.clone(), select_share); @@ -639,7 +636,7 @@ impl<'a> ToABY<'a> { let a = self.get_share(&t.cs()[1], to_share_type); let b = self.get_share(&t.cs()[2], to_share_type); - let line = format!("3 1 {} {} {} {} {}\n", sel, a, b, mux_share, op); + let line = format!("3 1 {sel} {a} {b} {mux_share} {op}\n"); self.bytecode_output.push(line); self.term_to_shares.insert(t.clone(), mux_share); } @@ -655,18 +652,12 @@ impl<'a> ToABY<'a> { let op = "STORE_CONS"; let idx = bv.uint().to_usize().unwrap(); let len = self.get_sort_len(&check(&t.cs()[0])); - assert!(idx < len, "idx: {}, len: {}", idx, len); - format!( - "3 1 {} {} {} {} {}\n", - array_share, idx, value_share, store_share, op - ) + assert!(idx < len, "{}", "idx: {idx}, len: {len}"); + format!("3 1 {array_share} {idx} {value_share} {store_share} {op}\n",) } else { let op = "STORE"; let index_share = self.get_share(&t.cs()[1], to_share_type); - format!( - "3 1 {} {} {} {} {}\n", - array_share, index_share, value_share, store_share, op - ) + format!("3 1 {array_share} {index_share} {value_share} {store_share} {op}\n",) }; self.bytecode_output.push(line); self.term_to_shares.insert(t.clone(), store_share); @@ -699,10 +690,7 @@ impl<'a> ToABY<'a> { _ => panic!("Field op on non-tuple"), }; - let line = format!( - "3 1 {} {} {} {} {}\n", - tuple_share, offset, len, field_share, op - ); + let line = format!("3 1 {tuple_share} {offset} {len} {field_share} {op}\n"); self.bytecode_output.push(line); self.term_to_shares.insert(t.clone(), field_share); } @@ -714,10 +702,7 @@ impl<'a> ToABY<'a> { let update_share = self.get_share(&t, to_share_type); let op = "UPDATE"; - let line = format!( - "3 1 {} {} {} {} {}\n", - tuple_share, i, value_share, update_share, op - ); + let line = format!("3 1 {tuple_share} {i} {value_share} {update_share} {op}\n",); self.bytecode_output.push(line); self.term_to_shares.insert(t.clone(), update_share); } @@ -742,7 +727,7 @@ impl<'a> ToABY<'a> { } Op::Call(name, ..) => { let call_share = self.get_share(&t, to_share_type); - let op = format!("CALL({})", name); + let op = format!("CALL({name})"); let mut arg_shares: Vec = Vec::new(); for c in t.cs().iter() { @@ -806,7 +791,7 @@ impl<'a> ToABY<'a> { get_path( self.path, &self.lang, - &format!("{}_bytecode_output", name), + &format!("{name}_bytecode_output"), true, ); @@ -816,7 +801,7 @@ impl<'a> ToABY<'a> { let op = "OUT"; let to_share_type = self.get_term_share_type(t); let share = self.get_share(t, to_share_type); - let line = format!("1 0 {} {}\n", share, op); + let line = format!("1 0 {share} {op}\n"); outputs.push(line); } self.bytecode_output.append(&mut outputs); @@ -845,15 +830,14 @@ impl<'a> ToABY<'a> { self.bytecode_input = inputs; // write input bytecode - let bytecode_path = - get_path(self.path, &self.lang, &format!("{}_bytecode", name), true); + let bytecode_path = get_path(self.path, &self.lang, &format!("{name}_bytecode"), true); write_lines(&bytecode_path, &self.bytecode_input); // write output bytecode let bytecode_output_path = get_path( self.path, &self.lang, - &format!("{}_bytecode_output", name), + &format!("{name}_bytecode_output"), false, ); write_lines(&bytecode_output_path, &self.bytecode_output); diff --git a/src/target/aby/utils.rs b/src/target/aby/utils.rs index ead41de6..83ac4a08 100644 --- a/src/target/aby/utils.rs +++ b/src/target/aby/utils.rs @@ -23,14 +23,14 @@ pub fn get_path(path: &Path, lang: &str, t: &str, create: bool) -> String { .into_string() .unwrap(); - let name = format!("{}_{}", filename, lang); - let dir_path = format!("scripts/aby_tests/tests/{}", name); + let name = format!("{filename}_{lang}"); + let dir_path = format!("scripts/aby_tests/tests/{name}"); match fs::create_dir_all(&dir_path) { Err(why) => panic!("couldn't create {}: {}", dir_path, why), Ok(file) => file, }; - let file_path = format!("{}/{}_{}.txt", dir_path, name, t); + let file_path = format!("{dir_path}/{name}_{t}.txt"); if create { match File::create(&file_path) { Err(why) => panic!("couldn't create {}: {}", file_path, why), diff --git a/src/target/ilp/trans.rs b/src/target/ilp/trans.rs index 55a90ee7..16563131 100644 --- a/src/target/ilp/trans.rs +++ b/src/target/ilp/trans.rs @@ -151,7 +151,7 @@ impl ToMilp { /// Returns a bit decomposition of e, with the ones place in index 0. fn bit_decomp(&mut self, e: &Expression, n_bits: usize) -> Vec { let bits: Vec<_> = (0..n_bits) - .map(|i| self.fresh_bit(&format!("bit{}", i))) + .map(|i| self.fresh_bit(&format!("bit{i}"))) .collect(); let sum = bits .iter() diff --git a/src/target/r1cs/bellman.rs b/src/target/r1cs/bellman.rs index 86f9230c..dbbf99ae 100644 --- a/src/target/r1cs/bellman.rs +++ b/src/target/r1cs/bellman.rs @@ -136,7 +136,7 @@ impl<'a, F: PrimeField> Circuit for SynthInput<'a> { } for (i, (a, b, c)) in self.0.constraints.iter().enumerate() { cs.enforce( - || format!("con{}", i), + || format!("con{i}"), |z| lc_to_bellman::(&vars, a, z), |z| lc_to_bellman::(&vars, b, z), |z| lc_to_bellman::(&vars, c, z), @@ -300,8 +300,7 @@ where let sort2 = value.sort(); assert_eq!( sort, &sort2, - "Sort mismatch for {}. Expected\n\t{} but got\n\t{}", - input, sort, sort2 + "Sort mismatch for {input}. Expected\n\t{sort} but got\n\t{sort2}", ); } let new_map = prover_data.precompute.eval(inputs_map); @@ -362,13 +361,13 @@ mod test { #[quickcheck] fn int_to_ff_random(BlsScalar(i): BlsScalar) -> bool { let by_fn = int_to_ff::(i.clone()); - let by_str = Scalar::from_str_vartime(&format!("{}", i)).unwrap(); + let by_str = Scalar::from_str_vartime(&format!("{i}")).unwrap(); by_fn == by_str } fn convert(i: Integer) { let by_fn = int_to_ff::(i.clone()); - let by_str = Scalar::from_str_vartime(&format!("{}", i)).unwrap(); + let by_str = Scalar::from_str_vartime(&format!("{i}")).unwrap(); assert_eq!(by_fn, by_str); } diff --git a/src/target/r1cs/mod.rs b/src/target/r1cs/mod.rs index 4fd13c29..c9c15ec4 100644 --- a/src/target/r1cs/mod.rs +++ b/src/target/r1cs/mod.rs @@ -472,8 +472,7 @@ impl VerifierData { let sort2 = value.sort(); assert_eq!( sort, &sort2, - "Sort mismatch for {}. Expected\n\t{} but got\n\t{}", - input, sort, sort2 + "Sort mismatch for {input}. Expected\n\t{sort} but got\n\t{sort2}", ); } let new_map = self.precompute.eval(value_map); diff --git a/src/target/r1cs/opt.rs b/src/target/r1cs/opt.rs index 916693bf..ca5069ac 100644 --- a/src/target/r1cs/opt.rs +++ b/src/target/r1cs/opt.rs @@ -206,7 +206,7 @@ mod test { let m = 101; let field = FieldT::from(Integer::from(m)); let n_vars = g.size() + 1; - let vars: Vec<_> = (0..n_vars).map(|i| format!("v{}", i)).collect(); + let vars: Vec<_> = (0..n_vars).map(|i| format!("v{i}")).collect(); let mut values: FxHashMap = Default::default(); let mut r1cs = R1cs::new(field.clone()); let mut rng = rand::rngs::StdRng::seed_from_u64(u64::arbitrary(g)); diff --git a/src/target/r1cs/spartan.rs b/src/target/r1cs/spartan.rs index 794e7928..53de2088 100644 --- a/src/target/r1cs/spartan.rs +++ b/src/target/r1cs/spartan.rs @@ -90,8 +90,7 @@ pub fn r1cs_to_spartan( .unwrap(); assert_eq!( &s_mod, f_mod, - "\nR1CS has modulus \n{},\n but Spartan CS expects \n{}", - s_mod, f_mod + "\nR1CS has modulus \n{s_mod},\n but Spartan CS expects \n{f_mod}", ); let values = eval_inputs(inputs_map, prover_data); @@ -195,8 +194,7 @@ fn eval_inputs( let sort2 = value.sort(); assert_eq!( sort, &sort2, - "Sort mismatch for {}. Expected\n\t{} but got\n\t{}", - input, sort, sort2 + "Sort mismatch for {input}. Expected\n\t{sort} but got\n\t{sort2}", ); } let new_map = prover_data.precompute.eval(inputs_map); diff --git a/src/target/r1cs/trans.rs b/src/target/r1cs/trans.rs index 782d0a60..83126cce 100644 --- a/src/target/r1cs/trans.rs +++ b/src/target/r1cs/trans.rs @@ -146,7 +146,7 @@ impl<'cfg> ToR1cs<'cfg> { .map(|i| { self.fresh_bit( // We get the right repr here because of infinite two's complement. - &format!("{}_b{}", d, i), + &format!("{d}_b{i}"), term![Op::BvBit(i); term![Op::PfToBv(n); x.0.clone()]], ) }) diff --git a/src/target/smt/mod.rs b/src/target/smt/mod.rs index 59187ec7..54b97311 100644 --- a/src/target/smt/mod.rs +++ b/src/target/smt/mod.rs @@ -43,11 +43,11 @@ impl<'a, T: Sort2Smt + 'a> Display for SmtSortDisp<'a, T> { impl Expr2Smt<()> for Value { fn expr_to_smt2(&self, w: &mut W, (): ()) -> SmtRes<()> { match self { - Value::Bool(b) => write!(w, "{}", b)?, + Value::Bool(b) => write!(w, "{b}")?, Value::Field(f) => write!(w, "#f{}m{}", f.i(), f.modulus())?, - Value::Int(i) if i >= &Integer::new() => write!(w, "{}", i)?, + Value::Int(i) if i >= &Integer::new() => write!(w, "{i}")?, Value::Int(i) => write!(w, "(- 0 {})", *i.as_neg())?, - Value::BitVector(b) => write!(w, "{}", b)?, + Value::BitVector(b) => write!(w, "{b}")?, Value::F32(f) => { let (sign, exp, mant) = f.decompose_raw(); write!(w, "(fp #b{} #b", sign as u8)?; @@ -109,7 +109,7 @@ impl Expr2Smt<()> for Term { fn expr_to_smt2(&self, w: &mut W, (): ()) -> SmtRes<()> { let s_expr_children = match &self.op() { Op::Var(n, _) => { - write!(w, "{}", n)?; + write!(w, "{n}")?; false } Op::Eq => { @@ -133,7 +133,7 @@ impl Expr2Smt<()> for Term { true } Op::BvUext(s) => { - write!(w, "((_ zero_extend {})", s)?; + write!(w, "((_ zero_extend {s})")?; true } Op::Const(c) => { @@ -153,7 +153,7 @@ impl Expr2Smt<()> for Term { true } Op::Field(i) => { - write!(w, "((_ tupSel {})", i)?; + write!(w, "((_ tupSel {i})")?; true } Op::PfNaryOp(PfNaryOp::Mul) => { @@ -177,7 +177,7 @@ impl Expr2Smt<()> for Term { true } Op::IntBinPred(o) => { - write!(w, "({}", o)?; + write!(w, "({o}")?; true } o => panic!("Cannot give {} to SMT solver", o), @@ -195,7 +195,7 @@ impl Expr2Smt<()> for Term { impl Sort2Smt for Sort { fn sort_to_smt2(&self, w: &mut W) -> SmtRes<()> { match self { - Sort::BitVector(b) => write!(w, "(_ BitVec {})", b)?, + Sort::BitVector(b) => write!(w, "(_ BitVec {b})")?, Sort::Array(k, v, _size) => { write!(w, "(Array {} {})", SmtSortDisp(&**k), SmtSortDisp(&**v))?; }