Clippy fixes

Author: zesterer

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "chumsky"
-version = "0.10.1"
+version = "0.11.0"
 description = "A parser library for humans with powerful error recovery"
 authors = ["Joshua Barretto <[email protected]>", "Elijah Hartvigsen <[email protected]", "Jakob Wiesmore <[email protected]>"]
 repository = "https://github.com/zesterer/chumsky"

Cargo.toml

@@ -68,6 +68,6 @@ fn main() {
 
     match parser().parse(src.trim()).into_result() {
         Ok(ast) => execute(&ast, &mut 0, &mut [0; TAPE_LEN]),
-        Err(errs) => errs.into_iter().for_each(|e| println!("{:?}", e)),
+        Err(errs) => errs.into_iter().for_each(|e| println!("{e:?}")),
     };
 }

examples/brainfuck.rs

@@ -130,7 +130,7 @@ fn eval<'src>(
             if let Some((_, val)) = vars.iter().rev().find(|(var, _)| var == name) {
                 Ok(*val)
             } else {
-                Err(format!("Cannot find variable `{}` in scope", name))
+                Err(format!("Cannot find variable `{name}` in scope"))
             }
         }
         Expr::Let { name, rhs, then } => {
@@ -158,14 +158,13 @@ fn eval<'src>(
                     output
                 } else {
                     Err(format!(
-                        "Wrong number of arguments for function `{}`: expected {}, found {}",
-                        name,
+                        "Wrong number of arguments for function `{name}`: expected {}, found {}",
                         arg_names.len(),
                         args.len(),
                     ))
                 }
             } else {
-                Err(format!("Cannot find function `{}` in scope", name))
+                Err(format!("Cannot find function `{name}` in scope"))
             }
         }
         Expr::Fn {
@@ -188,11 +187,11 @@ fn main() {
 
     match parser().parse(&src).into_result() {
         Ok(ast) => match eval(&ast, &mut Vec::new(), &mut Vec::new()) {
-            Ok(output) => println!("{}", output),
-            Err(eval_err) => println!("Evaluation error: {}", eval_err),
+            Ok(output) => println!("{output}"),
+            Err(eval_err) => println!("Evaluation error: {eval_err}"),
         },
         Err(parse_errs) => parse_errs
             .into_iter()
-            .for_each(|e| println!("Parse error: {}", e)),
+            .for_each(|err| println!("Parse error: {err}")),
     };
 }

examples/foo.rs

@@ -47,5 +47,5 @@ fn main() {
     let json = parser::<extra::Err<Rich<_>>>()
         .parse(IoInput::new(src))
         .into_result();
-    println!("{:#?}", json);
+    println!("{json:#?}");
 }

examples/io.rs

@@ -140,7 +140,7 @@ fn main() {
         .expect("Failed to read file");
 
     let (json, errs) = parser().parse(src.trim()).into_output_errors();
-    println!("{:#?}", json);
+    println!("{json:#?}");
     errs.into_iter().for_each(|e| {
         Report::build(ReportKind::Error, ((), e.span().into_range()))
             .with_config(ariadne::Config::new().with_index_type(ariadne::IndexType::Byte))

examples/json.rs

@@ -73,7 +73,7 @@ fn parser<'a>() -> impl Parser<'a, &'a str, Json> {
             .padded()
             .delimited_by(just('['), just(']'));
 
-        let member = string.clone().then_ignore(just(':').padded()).then(value);
+        let member = string.then_ignore(just(':').padded()).then(value);
         let object = member
             .clone()
             .separated_by(just(',').padded())

examples/json_fast.rs

@@ -38,7 +38,7 @@ enum Token<'a> {
 impl fmt::Display for Token<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::Float(s) => write!(f, "{}", s),
+            Self::Float(s) => write!(f, "{s}"),
             Self::Add => write!(f, "+"),
             Self::Sub => write!(f, "-"),
             Self::Mul => write!(f, "*"),
@@ -148,8 +148,8 @@ fn main() {
     match parser().parse(token_stream).into_result() {
         // If parsing was successful, attempt to evaluate the s-expression
         Ok(sexpr) => match sexpr.eval() {
-            Ok(out) => println!("Result = {}", out),
-            Err(err) => println!("Runtime error: {}", err),
+            Ok(out) => println!("Result = {out}"),
+            Err(err) => println!("Runtime error: {err}"),
         },
         // If parsing was unsuccessful, generate a nice user-friendly diagnostic with ariadne. You could also use
         // codespan, or whatever other diagnostic library you care about. You could even just display-print the errors

examples/logos.rs

@@ -31,12 +31,12 @@ impl fmt::Display for Token<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Token::Null => write!(f, "null"),
-            Token::Bool(x) => write!(f, "{}", x),
-            Token::Num(n) => write!(f, "{}", n),
-            Token::Str(s) => write!(f, "{}", s),
-            Token::Op(s) => write!(f, "{}", s),
-            Token::Ctrl(c) => write!(f, "{}", c),
-            Token::Ident(s) => write!(f, "{}", s),
+            Token::Bool(x) => write!(f, "{x}"),
+            Token::Num(n) => write!(f, "{n}"),
+            Token::Str(s) => write!(f, "{s}"),
+            Token::Op(s) => write!(f, "{s}"),
+            Token::Ctrl(c) => write!(f, "{c}"),
+            Token::Ident(s) => write!(f, "{s}"),
             Token::Fn => write!(f, "fn"),
             Token::Let => write!(f, "let"),
             Token::Print => write!(f, "print"),
@@ -119,7 +119,7 @@ impl Value<'_> {
         } else {
             Err(Error {
                 span,
-                msg: format!("'{}' is not a number", self),
+                msg: format!("'{self}' is not a number"),
             })
         }
     }
@@ -129,9 +129,9 @@ impl std::fmt::Display for Value<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Self::Null => write!(f, "null"),
-            Self::Bool(x) => write!(f, "{}", x),
-            Self::Num(x) => write!(f, "{}", x),
-            Self::Str(x) => write!(f, "{}", x),
+            Self::Bool(x) => write!(f, "{x}"),
+            Self::Num(x) => write!(f, "{x}"),
+            Self::Str(x) => write!(f, "{x}"),
             Self::List(xs) => write!(
                 f,
                 "[{}]",
@@ -140,7 +140,7 @@ impl std::fmt::Display for Value<'_> {
                     .collect::<Vec<_>>()
                     .join(", ")
             ),
-            Self::Func(name) => write!(f, "<function: {}>", name),
+            Self::Func(name) => write!(f, "<function: {name}>"),
         }
     }
 }
@@ -435,7 +435,7 @@ where
                 if funcs.insert(name, f).is_some() {
                     emitter.emit(Rich::custom(
                         name_span,
-                        format!("Function '{}' already exists", name),
+                        format!("Function '{name}' already exists"),
                     ));
                 }
             }
@@ -470,7 +470,7 @@ fn eval_expr<'src>(
             .or_else(|| Some(Value::Func(name)).filter(|_| funcs.contains_key(name)))
             .ok_or_else(|| Error {
                 span: expr.1,
-                msg: format!("No such variable '{}' in scope", name),
+                msg: format!("No such variable '{name}' in scope"),
             })?,
         Expr::Let(local, val, body) => {
             let val = eval_expr(val, funcs, stack)?;
@@ -509,7 +509,7 @@ fn eval_expr<'src>(
                     let mut stack = if f.args.len() != args.0.len() {
                         return Err(Error {
                             span: expr.1,
-                            msg: format!("'{}' called with wrong number of arguments (expected {}, found {})", name, f.args.len(), args.0.len()),
+                            msg: format!("'{}' called with wrong number of arguments (expected {name}, found {})", f.args.len(), args.0.len()),
                         });
                     } else {
                         f.args
@@ -523,7 +523,7 @@ fn eval_expr<'src>(
                 f => {
                     return Err(Error {
                         span: func.1,
-                        msg: format!("'{:?}' is not callable", f),
+                        msg: format!("'{f:?}' is not callable"),
                     })
                 }
             }
@@ -536,14 +536,14 @@ fn eval_expr<'src>(
                 c => {
                     return Err(Error {
                         span: cond.1,
-                        msg: format!("Conditions must be booleans, found '{:?}'", c),
+                        msg: format!("Conditions must be booleans, found '{c:?}'"),
                     })
                 }
             }
         }
         Expr::Print(a) => {
             let val = eval_expr(a, funcs, stack)?;
-            println!("{}", val);
+            println!("{val}");
             val
         }
     })
@@ -574,7 +574,7 @@ fn main() {
                     ))
                 } else {
                     match eval_expr(&main.body, &funcs, &mut Vec::new()) {
-                        Ok(val) => println!("Return value: {}", val),
+                        Ok(val) => println!("Return value: {val}"),
                         Err(e) => errs.push(Rich::custom(e.span, e.msg)),
                     }
                 }
@@ -609,7 +609,7 @@ fn main() {
                 )
                 .with_labels(e.contexts().map(|(label, span)| {
                     Label::new((filename.clone(), span.into_range()))
-                        .with_message(format!("while parsing this {}", label))
+                        .with_message(format!("while parsing this {label}"))
                         .with_color(Color::Yellow)
                 }))
                 .finish()

examples/nano_rust.rs

@@ -526,7 +526,6 @@ where
     go_extra!(I::Span);
 }
 
-
 /// See [`Parser::try_foldl`].
 pub struct TryFoldl<F, A, B, OB, E> {
     pub(crate) parser_a: A,
@@ -579,7 +578,7 @@ where
                         Err(err) => {
                             inp.add_alt_err(&before.inner, err);
                             break Err(());
-                        },
+                        }
                     }
                 }
                 Ok(None) => break Ok(M::bind(|| out)),