rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix clippy::uninlined_format_args

Browse Source
This commit is contained in:
Bennet Bleßmann
2025-07-31 21:26:08 +02:00
parent 7199e9a2db
commit 8cc74b2af7
10 changed files with 35 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
build/instructions_template.rs
View File

@@ -3262,14 +3262,14 @@ where
let disc = match DiscriminantT::from_str(id.to_string().as_str()) { let disc = match DiscriminantT::from_str(id.to_string().as_str()) {
Ok(disc) => disc, Ok(disc) => disc,
Err(_) => { Err(_) => {
panic!("can't generate discriminant {}", id); panic!("can't generate discriminant {id}");
} }
}; };
match disc.get_str(key) { match disc.get_str(key) {
Some(prop) => prop, Some(prop) => prop,
None => { None => {
panic!("can't find property {} of discriminant {:?}", key, disc); panic!("can't find property {key} of discriminant {disc:?}");
} }
} }
} }
@@ -3387,7 +3387,7 @@ impl InstructionData {
(name, arity, CountableInference::HasDefault) (name, arity, CountableInference::HasDefault)
} else { } else {
panic!("type ID is: {}", id); panic!("type ID is: {id}");
}; };
let v_ident = variant let v_ident = variant

4
build/static_string_indexing.rs
View File

@@ -126,14 +126,14 @@ pub fn index_static_strings(instruction_rs_path: &std::path::Path) -> TokenStrea
match file.read_to_string(&mut src) { match file.read_to_string(&mut src) {
Ok(_) => {} Ok(_) => {}
Err(e) => { Err(e) => {
panic!("error reading file: {:?}", e); panic!("error reading file: {e:?}");
} }
} }
let syntax = match syn::parse_file(&src) { let syntax = match syn::parse_file(&src) {
Ok(s) => s, Ok(s) => s,
Err(e) => { Err(e) => {
panic!("parse error: {} in file {:?}", e, path); panic!("parse error: {e} in file {path:?}");
} }
}; };
Ok(syntax) Ok(syntax)

6
src/forms.rs
View File

@@ -627,9 +627,9 @@ impl Default for Number {
impl fmt::Display for Number { impl fmt::Display for Number {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
Number::Float(fl) => write!(f, "{}", fl), Number::Float(fl) => write!(f, "{fl}"),
Number::Integer(n) => write!(f, "{}", n), Number::Integer(n) => write!(f, "{n}"),
Number::Rational(r) => write!(f, "{}", r), Number::Rational(r) => write!(f, "{r}"),
Number::Fixnum(n) => write!(f, "{}", n.get_num()), Number::Fixnum(n) => write!(f, "{}", n.get_num()),
} }
} }

4
src/functor_macro.rs
View File

@@ -739,12 +739,12 @@ mod tests {
] ]
); );
println!("{:?}", stub); println!("{stub:?}");
// now the error form // now the error form
let lineless_error_form = functor!(atom!("error"), [functor(stub), functor(culprit)]); let lineless_error_form = functor!(atom!("error"), [functor(stub), functor(culprit)]);
println!("{:?}", lineless_error_form); println!("{lineless_error_form:?}");
let mut heap = Heap::new(); let mut heap = Heap::new();
let mut functor_writer = Heap::functor_writer(lineless_error_form); let mut functor_writer = Heap::functor_writer(lineless_error_form);

12
src/heap_print.rs
View File

@@ -831,13 +831,13 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
read_heap_cell!(cell, read_heap_cell!(cell,
(HeapCellValueTag::Lis | HeapCellValueTag::Str, h) => { (HeapCellValueTag::Lis | HeapCellValueTag::Str, h) => {
Some(format!("{}", h)) Some(format!("{h}"))
} }
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar, h) => { (HeapCellValueTag::Var | HeapCellValueTag::AttrVar, h) => {
Some(format!("_{}", h)) Some(format!("_{h}"))
} }
(HeapCellValueTag::StackVar, h) => { (HeapCellValueTag::StackVar, h) => {
Some(format!("_s_{}", h)) Some(format!("_s_{h}"))
} }
_ => { _ => {
None None
@@ -1002,7 +1002,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
#[inline] #[inline]
fn print_ip_addr(&mut self, ip: IpAddr) { fn print_ip_addr(&mut self, ip: IpAddr) {
push_char!(self, '\''); push_char!(self, '\'');
append_str!(self, &format!("{}", ip)); append_str!(self, &format!("{ip}"));
push_char!(self, '\''); push_char!(self, '\'');
} }
@@ -1039,7 +1039,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
self.print_rational(max_depth, r, *op); self.print_rational(max_depth, r, *op);
} }
n => { n => {
let output_str = format!("{}", n); let output_str = format!("{n}");
push_space_if_amb!(self, &output_str, { push_space_if_amb!(self, &output_str, {
append_str!(self, &output_str); append_str!(self, &output_str);
@@ -1086,7 +1086,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
match self.op_dir.get(&(atom!("rdiv"), Fixity::In)) { match self.op_dir.get(&(atom!("rdiv"), Fixity::In)) {
Some(op_desc) => { Some(op_desc) => {
if r.is_int() { if r.is_int() {
let output_str = format!("{}", r); let output_str = format!("{r}");
push_space_if_amb!(self, &output_str, { push_space_if_amb!(self, &output_str, {
append_str!(self, &output_str); append_str!(self, &output_str);

4
src/machine/loader.rs
View File

@@ -1407,10 +1407,10 @@ impl MachineState {
term_stack.push(Term::Literal(Cell::default(), Literal::try_from(addr).unwrap())); term_stack.push(Term::Literal(Cell::default(), Literal::try_from(addr).unwrap()));
} }
(HeapCellValueTag::StackVar, h) => { (HeapCellValueTag::StackVar, h) => {
term_stack.push(Term::Var(Cell::default(), VarPtr::from(format!("s_{}", h)))); term_stack.push(Term::Var(Cell::default(), VarPtr::from(format!("s_{h}"))));
} }
(HeapCellValueTag::Var | HeapCellValueTag::AttrVar, h) => { (HeapCellValueTag::Var | HeapCellValueTag::AttrVar, h) => {
term_stack.push(Term::Var(Cell::default(), VarPtr::from(format!("_{}", h)))); term_stack.push(Term::Var(Cell::default(), VarPtr::from(format!("_{h}"))));
} }
(HeapCellValueTag::Atom, (name, arity)) => { (HeapCellValueTag::Atom, (name, arity)) => {
let h = iter.focus().value() as usize; let h = iter.focus().value() as usize;

2
src/machine/machine_indices.rs
View File

@@ -206,7 +206,7 @@ impl VarKey {
#[inline] #[inline]
pub(crate) fn to_string(&self) -> String { pub(crate) fn to_string(&self) -> String {
match self { match self {
VarKey::AnonVar(h) => format!("_{}", h), VarKey::AnonVar(h) => format!("_{h}"),
VarKey::VarPtr(var) => var.borrow().to_string(), VarKey::VarPtr(var) => var.borrow().to_string(),
} }
} }

12
src/machine/mock_wam.rs
View File

@@ -195,15 +195,11 @@ pub fn all_cells_marked_and_unforwarded(heap: &Heap, offset: usize) {
assert!( assert!(
cell.get_mark_bit(), cell.get_mark_bit(),
"cell {:?} at index {} is not marked", "cell {cell:?} at index {curr_idx} is not marked"
cell,
curr_idx
); );
assert!( assert!(
!cell.get_forwarding_bit(), !cell.get_forwarding_bit(),
"cell {:?} at index {} is forwarded", "cell {cell:?} at index {curr_idx} is forwarded"
cell,
curr_idx
); );
} }
} }
@@ -227,9 +223,7 @@ pub fn all_cells_unmarked(iter: &impl SizedHeap) {
assert!( assert!(
!cell.get_mark_bit(), !cell.get_mark_bit(),
"cell {:?} at index {} is still marked", "cell {cell:?} at index {curr_idx} is still marked"
cell,
curr_idx
); );
} }
} }

12
src/machine/system_calls.rs
View File

@@ -2916,7 +2916,7 @@ impl Machine {
let string = match Number::try_from((n, &self.machine_st.arena.f64_tbl)) { let string = match Number::try_from((n, &self.machine_st.arena.f64_tbl)) {
Ok(Number::Float(OrderedFloat(n))) => { Ok(Number::Float(OrderedFloat(n))) => {
format!("{0:<20?}", n) format!("{n:<20?}")
} }
Ok(Number::Fixnum(n)) => n.get_num().to_string(), Ok(Number::Fixnum(n)) => n.get_num().to_string(),
Ok(Number::Integer(n)) => n.to_string(), Ok(Number::Integer(n)) => n.to_string(),
@@ -3245,7 +3245,7 @@ impl Machine {
let n: u32 = (&*n).try_into().unwrap(); let n: u32 = (&*n).try_into().unwrap();
let n = char::try_from(n); let n = char::try_from(n);
if let Ok(c) = n { if let Ok(c) = n {
write!(&mut stream, "{}", c).unwrap(); write!(&mut stream, "{c}").unwrap();
return Ok(()); return Ok(());
} }
} }
@@ -3253,7 +3253,7 @@ impl Machine {
let n = n.get_num(); let n = n.get_num();
if let Some(c) = u32::try_from(n).ok().and_then(char::from_u32) { if let Some(c) = u32::try_from(n).ok().and_then(char::from_u32) {
write!(&mut stream, "{}", c).unwrap(); write!(&mut stream, "{c}").unwrap();
return Ok(()); return Ok(());
} }
} }
@@ -3295,13 +3295,13 @@ impl Machine {
read_heap_cell!(addr, read_heap_cell!(addr,
(HeapCellValueTag::Atom, (name, _arity)) => { (HeapCellValueTag::Atom, (name, _arity)) => {
if let Some(c) = name.as_char() { if let Some(c) = name.as_char() {
write!(&mut stream, "{}", c).unwrap(); write!(&mut stream, "{c}").unwrap();
return Ok(()); return Ok(());
} }
} }
/* /*
(HeapCellValueTag::Char, c) => { (HeapCellValueTag::Char, c) => {
write!(&mut stream, "{}", c).unwrap(); write!(&mut stream, "{c}").unwrap();
return Ok(()); return Ok(());
} }
*/ */
@@ -8622,7 +8622,7 @@ impl Machine {
]; ];
for spec in SPECIFIERS { for spec in SPECIFIERS {
fstr.push_str(&format!("'{}'=\"%{}\", ", spec, spec).to_string()); fstr.push_str(&format!("'{spec}'=\"%{spec}\", "));
} }
fstr.push_str("finis]."); fstr.push_str("finis].");

14
src/parser/ast.rs
View File

@@ -268,8 +268,8 @@ impl RegType {
impl fmt::Display for RegType { impl fmt::Display for RegType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
RegType::Perm(val) => write!(f, "Y{}", val), RegType::Perm(val) => write!(f, "Y{val}"),
RegType::Temp(val) => write!(f, "X{}", val), RegType::Temp(val) => write!(f, "X{val}"),
} }
} }
} }
@@ -291,10 +291,10 @@ impl VarReg {
impl fmt::Display for VarReg { impl fmt::Display for VarReg {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg), VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{reg}"),
VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg), VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{reg}"),
VarReg::ArgAndNorm(RegType::Perm(reg), arg) => write!(f, "Y{} A{}", reg, arg), VarReg::ArgAndNorm(RegType::Perm(reg), arg) => write!(f, "Y{reg} A{arg}"),
VarReg::ArgAndNorm(RegType::Temp(reg), arg) => write!(f, "X{} A{}", reg, arg), VarReg::ArgAndNorm(RegType::Temp(reg), arg) => write!(f, "X{reg} A{arg}"),
} }
} }
} }
@@ -830,7 +830,7 @@ impl Var {
#[inline(always)] #[inline(always)]
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
match self { match self {
Var::InSitu(n) | Var::Generated(n) => format!("_{}", n), Var::InSitu(n) | Var::Generated(n) => format!("_{n}"),
Var::Named(value) => value.as_ref().clone(), Var::Named(value) => value.as_ref().clone(),
} }
} }