Shared tree-sitter extractor: run clippy

redsun82 · redsun82 · commit 911d6f07b6ed · 2025-08-11T17:04:22.000+02:00
diff --git a/shared/tree-sitter-extractor/src/autobuilder.rs b/shared/tree-sitter-extractor/src/autobuilder.rs
@@ -57,23 +57,23 @@ impl Autobuilder {
         let verbosity = env::var("CODEQL_VERBOSITY");
 
         if let Ok(verbosity) = verbosity {
-            cmd.arg(format!("--verbosity={}", verbosity));
+            cmd.arg(format!("--verbosity={verbosity}"));
         }
 
         for ext in &self.include_extensions {
-            cmd.arg(format!("--include-extension={}", ext));
+            cmd.arg(format!("--include-extension={ext}"));
         }
 
         for glob in &self.include_globs {
-            cmd.arg(format!("--include={}", glob));
+            cmd.arg(format!("--include={glob}"));
         }
 
         for glob in &self.exclude_globs {
-            cmd.arg(format!("--exclude={}", glob));
+            cmd.arg(format!("--exclude={glob}"));
         }
 
         if let Some(limit) = &self.size_limit {
-            cmd.arg(format!("--size-limit={}", limit));
+            cmd.arg(format!("--size-limit={limit}"));
         }
 
         cmd.arg(format!("--language={}", &self.language));
diff --git a/shared/tree-sitter-extractor/src/diagnostics.rs b/shared/tree-sitter-extractor/src/diagnostics.rs
@@ -194,7 +194,7 @@ impl DiagnosticLoggers {
             path: self
                 .root
                 .as_ref()
-                .map(|root| root.to_owned().join(format!("extractor_{}.jsonl", n))),
+                .map(|root| root.to_owned().join(format!("extractor_{n}.jsonl"))),
         })
     }
 }
diff --git a/shared/tree-sitter-extractor/src/extractor/mod.rs b/shared/tree-sitter-extractor/src/extractor/mod.rs
@@ -230,7 +230,7 @@ pub fn extract(
     parser.set_language(language).unwrap();
     parser.set_included_ranges(ranges).unwrap();
     let tree = parser.parse(source, None).expect("Failed to parse file");
-    trap_writer.comment(format!("Auto-generated TRAP file for {}", path_str));
+    trap_writer.comment(format!("Auto-generated TRAP file for {path_str}"));
     let file_label = populate_file(trap_writer, path, transformer);
     let mut visitor = Visitor::new(
         source,
@@ -298,9 +298,9 @@ impl<'a> Visitor<'a> {
             source,
             diagnostics_writer,
             trap_writer,
-            ast_node_location_table_name: format!("{}_ast_node_location", language_prefix),
-            ast_node_parent_table_name: format!("{}_ast_node_parent", language_prefix),
-            tokeninfo_table_name: format!("{}_tokeninfo", language_prefix),
+            ast_node_location_table_name: format!("{language_prefix}_ast_node_location"),
+            ast_node_parent_table_name: format!("{language_prefix}_ast_node_parent"),
+            tokeninfo_table_name: format!("{language_prefix}_tokeninfo"),
             schema,
             stack: Vec::new(),
         }
diff --git a/shared/tree-sitter-extractor/src/extractor/simple.rs b/shared/tree-sitter-extractor/src/extractor/simple.rs
@@ -80,7 +80,7 @@ impl Extractor {
             .iter()
             .map(|file_list| {
                 File::open(file_list)
-                    .unwrap_or_else(|_| panic!("Unable to open file list at {:?}", file_list))
+                    .unwrap_or_else(|_| panic!("Unable to open file list at {file_list:?}"))
             })
             .collect();
 
diff --git a/shared/tree-sitter-extractor/src/generator/dbscheme.rs b/shared/tree-sitter-extractor/src/generator/dbscheme.rs
@@ -53,7 +53,7 @@ impl fmt::Display for Case<'_> {
         writeln!(f, "case @{}.{} of", &self.name, &self.column)?;
         let mut sep = " ";
         for (c, tp) in &self.branches {
-            writeln!(f, "{} {} = @{}", sep, c, tp)?;
+            writeln!(f, "{sep} {c} = @{tp}")?;
             sep = "|";
         }
         writeln!(f, ";")
@@ -68,7 +68,7 @@ impl fmt::Display for Table<'_> {
                 if key_index > 0 {
                     write!(f, ", ")?;
                 }
-                write!(f, "{}", key)?;
+                write!(f, "{key}")?;
             }
             writeln!(f, "]")?;
         }
@@ -112,7 +112,7 @@ impl fmt::Display for Union<'_> {
             } else {
                 write!(f, " | ")?;
             }
-            write!(f, "@{}", member)?;
+            write!(f, "@{member}")?;
         }
         Ok(())
     }
@@ -122,9 +122,9 @@ impl fmt::Display for Union<'_> {
 pub fn write(file: &mut dyn std::io::Write, entries: &[Entry]) -> std::io::Result<()> {
     for entry in entries {
         match entry {
-            Entry::Case(case) => write!(file, "{}\n\n", case)?,
-            Entry::Table(table) => write!(file, "{}\n\n", table)?,
-            Entry::Union(union) => write!(file, "{}\n\n", union)?,
+            Entry::Case(case) => write!(file, "{case}\n\n")?,
+            Entry::Table(table) => write!(file, "{table}\n\n")?,
+            Entry::Union(union) => write!(file, "{union}\n\n")?,
         }
     }
 
diff --git a/shared/tree-sitter-extractor/src/generator/ql.rs b/shared/tree-sitter-extractor/src/generator/ql.rs
@@ -12,10 +12,10 @@ pub enum TopLevel<'a> {
 impl fmt::Display for TopLevel<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            TopLevel::Import(imp) => write!(f, "{}", imp),
-            TopLevel::Class(cls) => write!(f, "{}", cls),
-            TopLevel::Module(m) => write!(f, "{}", m),
-            TopLevel::Predicate(pred) => write!(f, "{}", pred),
+            TopLevel::Import(imp) => write!(f, "{imp}"),
+            TopLevel::Class(cls) => write!(f, "{cls}"),
+            TopLevel::Module(m) => write!(f, "{m}"),
+            TopLevel::Predicate(pred) => write!(f, "{pred}"),
         }
     }
 }
@@ -30,7 +30,7 @@ impl fmt::Display for Import<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "import {}", &self.module)?;
         if let Some(name) = &self.alias {
-            write!(f, " as {}", name)?;
+            write!(f, " as {name}")?;
         }
         Ok(())
     }
@@ -48,7 +48,7 @@ pub struct Class<'a> {
 impl fmt::Display for Class<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(qldoc) = &self.qldoc {
-            write!(f, "/** {} */", qldoc)?;
+            write!(f, "/** {qldoc} */")?;
         }
         if self.is_abstract {
             write!(f, "abstract ")?;
@@ -58,7 +58,7 @@ impl fmt::Display for Class<'_> {
             if index > 0 {
                 write!(f, ", ")?;
             }
-            write!(f, "{}", supertype)?;
+            write!(f, "{supertype}")?;
         }
         writeln!(f, " {{ ")?;
 
@@ -81,7 +81,7 @@ impl fmt::Display for Class<'_> {
         }
 
         for predicate in &self.predicates {
-            writeln!(f, "  {}", predicate)?;
+            writeln!(f, "  {predicate}")?;
         }
 
         write!(f, "}}")?;
@@ -101,7 +101,7 @@ pub struct Module<'a> {
 impl fmt::Display for Module<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(qldoc) = &self.qldoc {
-            write!(f, "/** {} */", qldoc)?;
+            write!(f, "/** {qldoc} */")?;
         }
         if let Some(overlay_annotation) = &self.overlay {
             write!(f, "overlay[")?;
@@ -113,7 +113,7 @@ impl fmt::Display for Module<'_> {
         }
         writeln!(f, "module {} {{ ", self.name)?;
         for decl in &self.body {
-            writeln!(f, "  {}", decl)?;
+            writeln!(f, "  {decl}")?;
         }
         write!(f, "}}")?;
         Ok(())
@@ -140,8 +140,8 @@ impl fmt::Display for Type<'_> {
         match self {
             Type::Int => write!(f, "int"),
             Type::String => write!(f, "string"),
-            Type::Normal(name) => write!(f, "{}", name),
-            Type::At(name) => write!(f, "@{}", name),
+            Type::Normal(name) => write!(f, "{name}"),
+            Type::At(name) => write!(f, "@{name}"),
         }
     }
 }
@@ -169,16 +169,16 @@ pub enum Expression<'a> {
 impl fmt::Display for Expression<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Expression::Var(x) => write!(f, "{}", x),
-            Expression::String(s) => write!(f, "\"{}\"", s),
-            Expression::Integer(n) => write!(f, "{}", n),
+            Expression::Var(x) => write!(f, "{x}"),
+            Expression::String(s) => write!(f, "\"{s}\""),
+            Expression::Integer(n) => write!(f, "{n}"),
             Expression::Pred(n, args) => {
-                write!(f, "{}(", n)?;
+                write!(f, "{n}(")?;
                 for (index, arg) in args.iter().enumerate() {
                     if index > 0 {
                         write!(f, ", ")?;
                     }
-                    write!(f, "{}", arg)?;
+                    write!(f, "{arg}")?;
                 }
                 write!(f, ")")
             }
@@ -190,7 +190,7 @@ impl fmt::Display for Expression<'_> {
                         if index > 0 {
                             write!(f, " and ")?;
                         }
-                        write!(f, "({})", conjunct)?;
+                        write!(f, "({conjunct})")?;
                     }
                     Ok(())
                 }
@@ -203,19 +203,19 @@ impl fmt::Display for Expression<'_> {
                         if index > 0 {
                             write!(f, " or ")?;
                         }
-                        write!(f, "({})", disjunct)?;
+                        write!(f, "({disjunct})")?;
                     }
                     Ok(())
                 }
             }
-            Expression::Equals(a, b) => write!(f, "{} = {}", a, b),
+            Expression::Equals(a, b) => write!(f, "{a} = {b}"),
             Expression::Dot(x, member_pred, args) => {
-                write!(f, "{}.{}(", x, member_pred)?;
+                write!(f, "{x}.{member_pred}(")?;
                 for (index, arg) in args.iter().enumerate() {
                     if index > 0 {
                         write!(f, ", ")?;
                     }
-                    write!(f, "{}", arg)?;
+                    write!(f, "{arg}")?;
                 }
                 write!(f, ")")
             }
@@ -226,26 +226,26 @@ impl fmt::Display for Expression<'_> {
                 expr,
                 second_expr,
             } => {
-                write!(f, "{}(", name)?;
+                write!(f, "{name}(")?;
                 if !vars.is_empty() {
                     for (index, var) in vars.iter().enumerate() {
                         if index > 0 {
                             write!(f, ", ")?;
                         }
-                        write!(f, "{}", var)?;
+                        write!(f, "{var}")?;
                     }
                     write!(f, " | ")?;
                 }
                 if let Some(range) = range {
-                    write!(f, "{} | ", range)?;
+                    write!(f, "{range} | ")?;
                 }
-                write!(f, "{}", expr)?;
+                write!(f, "{expr}")?;
                 if let Some(second_expr) = second_expr {
-                    write!(f, ", {}", second_expr)?;
+                    write!(f, ", {second_expr}")?;
                 }
                 write!(f, ")")
             }
-            Expression::Negation(e) => write!(f, "not ({})", e),
+            Expression::Negation(e) => write!(f, "not ({e})"),
         }
     }
 }
@@ -272,7 +272,7 @@ pub struct Predicate<'a> {
 impl fmt::Display for Predicate<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(qldoc) = &self.qldoc {
-            write!(f, "/** {} */", qldoc)?;
+            write!(f, "/** {qldoc} */")?;
         }
         if let Some(overlay_annotation) = &self.overlay {
             write!(f, "overlay[")?;
@@ -293,14 +293,14 @@ impl fmt::Display for Predicate<'_> {
         }
         match &self.return_type {
             None => write!(f, "predicate ")?,
-            Some(return_type) => write!(f, "{} ", return_type)?,
+            Some(return_type) => write!(f, "{return_type} ")?,
         }
         write!(f, "{}(", self.name)?;
         for (index, param) in self.formal_parameters.iter().enumerate() {
             if index > 0 {
                 write!(f, ", ")?;
             }
-            write!(f, "{}", param)?;
+            write!(f, "{param}")?;
         }
         write!(f, ") {{ {} }}", self.body)?;
 
diff --git a/shared/tree-sitter-extractor/src/generator/ql_gen.rs b/shared/tree-sitter-extractor/src/generator/ql_gen.rs
@@ -666,7 +666,7 @@ fn create_field_getters<'a>(
         }
     };
     let qldoc = match &field.name {
-        Some(name) => format!("Gets the node corresponding to the field `{}`.", name),
+        Some(name) => format!("Gets the node corresponding to the field `{name}`."),
         None => {
             if formal_parameters.is_empty() {
                 "Gets the child of this node.".to_owned()
diff --git a/shared/tree-sitter-extractor/src/node_types.rs b/shared/tree-sitter-extractor/src/node_types.rs
@@ -326,7 +326,7 @@ fn node_type_name(kind: &str, named: bool) -> String {
     if named {
         kind.to_string()
     } else {
-        format!("{}_unnamed", kind)
+        format!("{kind}_unnamed")
     }
 }
 
diff --git a/shared/tree-sitter-extractor/src/trap.rs b/shared/tree-sitter-extractor/src/trap.rs
@@ -112,7 +112,7 @@ impl Writer {
 
     fn write_trap_entries<W: Write>(&self, file: &mut W) -> std::io::Result<()> {
         for trap_entry in &self.trap_output {
-            writeln!(file, "{}", trap_entry)?;
+            writeln!(file, "{trap_entry}")?;
         }
         Ok(())
     }
@@ -131,21 +131,21 @@ pub enum Entry {
 impl fmt::Display for Entry {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Entry::FreshId(label) => write!(f, "{}=*", label),
+            Entry::FreshId(label) => write!(f, "{label}=*"),
             Entry::MapLabelToKey(label, key) => {
                 write!(f, "{}=@\"{}\"", label, key.replace('"', "\"\""))
             }
             Entry::GenericTuple(name, args) => {
-                write!(f, "{}(", name)?;
+                write!(f, "{name}(")?;
                 for (index, arg) in args.iter().enumerate() {
                     if index > 0 {
                         write!(f, ",")?;
                     }
-                    write!(f, "{}", arg)?;
+                    write!(f, "{arg}")?;
                 }
                 write!(f, ")")
             }
-            Entry::Comment(line) => write!(f, "// {}", line),
+            Entry::Comment(line) => write!(f, "// {line}"),
         }
     }
 }
@@ -179,8 +179,8 @@ const MAX_STRLEN: usize = 1048576;
 impl fmt::Display for Arg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Arg::Label(x) => write!(f, "{}", x),
-            Arg::Int(x) => write!(f, "{}", x),
+            Arg::Label(x) => write!(f, "{x}"),
+            Arg::Int(x) => write!(f, "{x}"),
             Arg::String(x) => write!(
                 f,
                 "\"{}\"",
@@ -220,9 +220,9 @@ impl fmt::Display for Program {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut text = String::new();
         for trap_entry in &self.0 {
-            text.push_str(&format!("{}\n", trap_entry));
+            text.push_str(&format!("{trap_entry}\n"));
         }
-        write!(f, "{}", text)
+        write!(f, "{text}")
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -57,23 +57,23 @@ impl Autobuilder {`
`57`	`57`	`let verbosity = env::var("CODEQL_VERBOSITY");`
`58`	`58`
`59`	`59`	`if let Ok(verbosity) = verbosity {`
`60`		`- cmd.arg(format!("--verbosity={}", verbosity));`
	`60`	`+ cmd.arg(format!("--verbosity={verbosity}"));`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`for ext in &self.include_extensions {`
`64`		`- cmd.arg(format!("--include-extension={}", ext));`
	`64`	`+ cmd.arg(format!("--include-extension={ext}"));`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`for glob in &self.include_globs {`
`68`		`- cmd.arg(format!("--include={}", glob));`
	`68`	`+ cmd.arg(format!("--include={glob}"));`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`for glob in &self.exclude_globs {`
`72`		`- cmd.arg(format!("--exclude={}", glob));`
	`72`	`+ cmd.arg(format!("--exclude={glob}"));`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`if let Some(limit) = &self.size_limit {`
`76`		`- cmd.arg(format!("--size-limit={}", limit));`
	`76`	`+ cmd.arg(format!("--size-limit={limit}"));`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`cmd.arg(format!("--language={}", &self.language));`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ impl DiagnosticLoggers {`
`194`	`194`	`path: self`
`195`	`195`	`.root`
`196`	`196`	`.as_ref()`
`197`		`- .map(\|root\| root.to_owned().join(format!("extractor_{}.jsonl", n))),`
	`197`	`+ .map(\|root\| root.to_owned().join(format!("extractor_{n}.jsonl"))),`
`198`	`198`	`})`
`199`	`199`	`}`
`200`	`200`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl fmt::Display for Case<'_> {`
`53`	`53`	`writeln!(f, "case @{}.{} of", &self.name, &self.column)?;`
`54`	`54`	`let mut sep = " ";`
`55`	`55`	`for (c, tp) in &self.branches {`
`56`		`- writeln!(f, "{} {} = @{}", sep, c, tp)?;`
	`56`	`+ writeln!(f, "{sep} {c} = @{tp}")?;`
`57`	`57`	`sep = "\|";`
`58`	`58`	`}`
`59`	`59`	`writeln!(f, ";")`
`@@ -68,7 +68,7 @@ impl fmt::Display for Table<'_> {`
`68`	`68`	`if key_index > 0 {`
`69`	`69`	`write!(f, ", ")?;`
`70`	`70`	`}`
`71`		`- write!(f, "{}", key)?;`
	`71`	`+ write!(f, "{key}")?;`
`72`	`72`	`}`
`73`	`73`	`writeln!(f, "]")?;`
`74`	`74`	`}`
`@@ -112,7 +112,7 @@ impl fmt::Display for Union<'_> {`
`112`	`112`	`} else {`
`113`	`113`	`write!(f, " \| ")?;`
`114`	`114`	`}`
`115`		`- write!(f, "@{}", member)?;`
	`115`	`+ write!(f, "@{member}")?;`
`116`	`116`	`}`
`117`	`117`	`Ok(())`
`118`	`118`	`}`
`@@ -122,9 +122,9 @@ impl fmt::Display for Union<'_> {`
`122`	`122`	`pub fn write(file: &mut dyn std::io::Write, entries: &[Entry]) -> std::io::Result<()> {`
`123`	`123`	`for entry in entries {`
`124`	`124`	`match entry {`
`125`		`- Entry::Case(case) => write!(file, "{}\n\n", case)?,`
`126`		`- Entry::Table(table) => write!(file, "{}\n\n", table)?,`
`127`		`- Entry::Union(union) => write!(file, "{}\n\n", union)?,`
	`125`	`+ Entry::Case(case) => write!(file, "{case}\n\n")?,`
	`126`	`+ Entry::Table(table) => write!(file, "{table}\n\n")?,`
	`127`	`+ Entry::Union(union) => write!(file, "{union}\n\n")?,`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,10 @@ pub enum TopLevel<'a> {`
`12`	`12`	`impl fmt::Display for TopLevel<'_> {`
`13`	`13`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`14`	`14`	`match self {`
`15`		`- TopLevel::Import(imp) => write!(f, "{}", imp),`
`16`		`- TopLevel::Class(cls) => write!(f, "{}", cls),`
`17`		`- TopLevel::Module(m) => write!(f, "{}", m),`
`18`		`- TopLevel::Predicate(pred) => write!(f, "{}", pred),`
	`15`	`+ TopLevel::Import(imp) => write!(f, "{imp}"),`
	`16`	`+ TopLevel::Class(cls) => write!(f, "{cls}"),`
	`17`	`+ TopLevel::Module(m) => write!(f, "{m}"),`
	`18`	`+ TopLevel::Predicate(pred) => write!(f, "{pred}"),`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`	`}`
`@@ -30,7 +30,7 @@ impl fmt::Display for Import<'_> {`
`30`	`30`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`31`	`31`	`write!(f, "import {}", &self.module)?;`
`32`	`32`	`if let Some(name) = &self.alias {`
`33`		`- write!(f, " as {}", name)?;`
	`33`	`+ write!(f, " as {name}")?;`
`34`	`34`	`}`
`35`	`35`	`Ok(())`
`36`	`36`	`}`
`@@ -48,7 +48,7 @@ pub struct Class<'a> {`
`48`	`48`	`impl fmt::Display for Class<'_> {`
`49`	`49`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`50`	`50`	`if let Some(qldoc) = &self.qldoc {`
`51`		`- write!(f, "/** {} */", qldoc)?;`
	`51`	`+ write!(f, "/** {qldoc} */")?;`
`52`	`52`	`}`
`53`	`53`	`if self.is_abstract {`
`54`	`54`	`write!(f, "abstract ")?;`
`@@ -58,7 +58,7 @@ impl fmt::Display for Class<'_> {`
`58`	`58`	`if index > 0 {`
`59`	`59`	`write!(f, ", ")?;`
`60`	`60`	`}`
`61`		`- write!(f, "{}", supertype)?;`
	`61`	`+ write!(f, "{supertype}")?;`
`62`	`62`	`}`
`63`	`63`	`writeln!(f, " {{ ")?;`
`64`	`64`
`@@ -81,7 +81,7 @@ impl fmt::Display for Class<'_> {`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`for predicate in &self.predicates {`
`84`		`- writeln!(f, " {}", predicate)?;`
	`84`	`+ writeln!(f, " {predicate}")?;`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`write!(f, "}}")?;`
`@@ -101,7 +101,7 @@ pub struct Module<'a> {`
`101`	`101`	`impl fmt::Display for Module<'_> {`
`102`	`102`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`103`	`103`	`if let Some(qldoc) = &self.qldoc {`
`104`		`- write!(f, "/** {} */", qldoc)?;`
	`104`	`+ write!(f, "/** {qldoc} */")?;`
`105`	`105`	`}`
`106`	`106`	`if let Some(overlay_annotation) = &self.overlay {`
`107`	`107`	`write!(f, "overlay[")?;`
`@@ -113,7 +113,7 @@ impl fmt::Display for Module<'_> {`
`113`	`113`	`}`
`114`	`114`	`writeln!(f, "module {} {{ ", self.name)?;`
`115`	`115`	`for decl in &self.body {`
`116`		`- writeln!(f, " {}", decl)?;`
	`116`	`+ writeln!(f, " {decl}")?;`
`117`	`117`	`}`
`118`	`118`	`write!(f, "}}")?;`
`119`	`119`	`Ok(())`
`@@ -140,8 +140,8 @@ impl fmt::Display for Type<'_> {`
`140`	`140`	`match self {`
`141`	`141`	`Type::Int => write!(f, "int"),`
`142`	`142`	`Type::String => write!(f, "string"),`
`143`		`- Type::Normal(name) => write!(f, "{}", name),`
`144`		`- Type::At(name) => write!(f, "@{}", name),`
	`143`	`+ Type::Normal(name) => write!(f, "{name}"),`
	`144`	`+ Type::At(name) => write!(f, "@{name}"),`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`}`
`@@ -169,16 +169,16 @@ pub enum Expression<'a> {`
`169`	`169`	`impl fmt::Display for Expression<'_> {`
`170`	`170`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`171`	`171`	`match self {`
`172`		`- Expression::Var(x) => write!(f, "{}", x),`
`173`		`- Expression::String(s) => write!(f, "\"{}\"", s),`
`174`		`- Expression::Integer(n) => write!(f, "{}", n),`
	`172`	`+ Expression::Var(x) => write!(f, "{x}"),`
	`173`	`+ Expression::String(s) => write!(f, "\"{s}\""),`
	`174`	`+ Expression::Integer(n) => write!(f, "{n}"),`
`175`	`175`	`Expression::Pred(n, args) => {`
`176`		`- write!(f, "{}(", n)?;`
	`176`	`+ write!(f, "{n}(")?;`
`177`	`177`	`for (index, arg) in args.iter().enumerate() {`
`178`	`178`	`if index > 0 {`
`179`	`179`	`write!(f, ", ")?;`
`180`	`180`	`}`
`181`		`- write!(f, "{}", arg)?;`
	`181`	`+ write!(f, "{arg}")?;`
`182`	`182`	`}`
`183`	`183`	`write!(f, ")")`
`184`	`184`	`}`
`@@ -190,7 +190,7 @@ impl fmt::Display for Expression<'_> {`
`190`	`190`	`if index > 0 {`
`191`	`191`	`write!(f, " and ")?;`
`192`	`192`	`}`
`193`		`- write!(f, "({})", conjunct)?;`
	`193`	`+ write!(f, "({conjunct})")?;`
`194`	`194`	`}`
`195`	`195`	`Ok(())`
`196`	`196`	`}`
`@@ -203,19 +203,19 @@ impl fmt::Display for Expression<'_> {`
`203`	`203`	`if index > 0 {`
`204`	`204`	`write!(f, " or ")?;`
`205`	`205`	`}`
`206`		`- write!(f, "({})", disjunct)?;`
	`206`	`+ write!(f, "({disjunct})")?;`
`207`	`207`	`}`
`208`	`208`	`Ok(())`
`209`	`209`	`}`
`210`	`210`	`}`
`211`		`- Expression::Equals(a, b) => write!(f, "{} = {}", a, b),`
	`211`	`+ Expression::Equals(a, b) => write!(f, "{a} = {b}"),`
`212`	`212`	`Expression::Dot(x, member_pred, args) => {`
`213`		`- write!(f, "{}.{}(", x, member_pred)?;`
	`213`	`+ write!(f, "{x}.{member_pred}(")?;`
`214`	`214`	`for (index, arg) in args.iter().enumerate() {`
`215`	`215`	`if index > 0 {`
`216`	`216`	`write!(f, ", ")?;`
`217`	`217`	`}`
`218`		`- write!(f, "{}", arg)?;`
	`218`	`+ write!(f, "{arg}")?;`
`219`	`219`	`}`
`220`	`220`	`write!(f, ")")`
`221`	`221`	`}`
`@@ -226,26 +226,26 @@ impl fmt::Display for Expression<'_> {`
`226`	`226`	`expr,`
`227`	`227`	`second_expr,`
`228`	`228`	`} => {`
`229`		`- write!(f, "{}(", name)?;`
	`229`	`+ write!(f, "{name}(")?;`
`230`	`230`	`if !vars.is_empty() {`
`231`	`231`	`for (index, var) in vars.iter().enumerate() {`
`232`	`232`	`if index > 0 {`
`233`	`233`	`write!(f, ", ")?;`
`234`	`234`	`}`
`235`		`- write!(f, "{}", var)?;`
	`235`	`+ write!(f, "{var}")?;`
`236`	`236`	`}`
`237`	`237`	`write!(f, " \| ")?;`
`238`	`238`	`}`
`239`	`239`	`if let Some(range) = range {`
`240`		`- write!(f, "{} \| ", range)?;`
	`240`	`+ write!(f, "{range} \| ")?;`
`241`	`241`	`}`
`242`		`- write!(f, "{}", expr)?;`
	`242`	`+ write!(f, "{expr}")?;`
`243`	`243`	`if let Some(second_expr) = second_expr {`
`244`		`- write!(f, ", {}", second_expr)?;`
	`244`	`+ write!(f, ", {second_expr}")?;`
`245`	`245`	`}`
`246`	`246`	`write!(f, ")")`
`247`	`247`	`}`
`248`		`- Expression::Negation(e) => write!(f, "not ({})", e),`
	`248`	`+ Expression::Negation(e) => write!(f, "not ({e})"),`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`	`}`
`@@ -272,7 +272,7 @@ pub struct Predicate<'a> {`
`272`	`272`	`impl fmt::Display for Predicate<'_> {`
`273`	`273`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`274`	`274`	`if let Some(qldoc) = &self.qldoc {`
`275`		`- write!(f, "/** {} */", qldoc)?;`
	`275`	`+ write!(f, "/** {qldoc} */")?;`
`276`	`276`	`}`
`277`	`277`	`if let Some(overlay_annotation) = &self.overlay {`
`278`	`278`	`write!(f, "overlay[")?;`
`@@ -293,14 +293,14 @@ impl fmt::Display for Predicate<'_> {`
`293`	`293`	`}`
`294`	`294`	`match &self.return_type {`
`295`	`295`	`None => write!(f, "predicate ")?,`
`296`		`- Some(return_type) => write!(f, "{} ", return_type)?,`
	`296`	`+ Some(return_type) => write!(f, "{return_type} ")?,`
`297`	`297`	`}`
`298`	`298`	`write!(f, "{}(", self.name)?;`
`299`	`299`	`for (index, param) in self.formal_parameters.iter().enumerate() {`
`300`	`300`	`if index > 0 {`
`301`	`301`	`write!(f, ", ")?;`
`302`	`302`	`}`
`303`		`- write!(f, "{}", param)?;`
	`303`	`+ write!(f, "{param}")?;`
`304`	`304`	`}`
`305`	`305`	`write!(f, ") {{ {} }}", self.body)?;`
`306`	`306`
Original file line number	Diff line number	Diff line change
`@@ -666,7 +666,7 @@ fn create_field_getters<'a>(`
`666`	`666`	`}`
`667`	`667`	`};`
`668`	`668`	`let qldoc = match &field.name {`
`669`		- Some(name) => format!("Gets the node corresponding to the field `{}`.", name),
	`669`	+ Some(name) => format!("Gets the node corresponding to the field `{name}`."),
`670`	`670`	`None => {`
`671`	`671`	`if formal_parameters.is_empty() {`
`672`	`672`	`"Gets the child of this node.".to_owned()`
Original file line number	Diff line number	Diff line change
`@@ -326,7 +326,7 @@ fn node_type_name(kind: &str, named: bool) -> String {`
`326`	`326`	`if named {`
`327`	`327`	`kind.to_string()`
`328`	`328`	`} else {`
`329`		`- format!("{}_unnamed", kind)`
	`329`	`+ format!("{kind}_unnamed")`
`330`	`330`	`}`
`331`	`331`	`}`
`332`	`332`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ impl Writer {`
`112`	`112`
`113`	`113`	`fn write_trap_entries<W: Write>(&self, file: &mut W) -> std::io::Result<()> {`
`114`	`114`	`for trap_entry in &self.trap_output {`
`115`		`- writeln!(file, "{}", trap_entry)?;`
	`115`	`+ writeln!(file, "{trap_entry}")?;`
`116`	`116`	`}`
`117`	`117`	`Ok(())`
`118`	`118`	`}`
`@@ -131,21 +131,21 @@ pub enum Entry {`
`131`	`131`	`impl fmt::Display for Entry {`
`132`	`132`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`133`	`133`	`match self {`
`134`		`- Entry::FreshId(label) => write!(f, "{}=*", label),`
	`134`	`+ Entry::FreshId(label) => write!(f, "{label}=*"),`
`135`	`135`	`Entry::MapLabelToKey(label, key) => {`
`136`	`136`	`write!(f, "{}=@\"{}\"", label, key.replace('"', "\"\""))`
`137`	`137`	`}`
`138`	`138`	`Entry::GenericTuple(name, args) => {`
`139`		`- write!(f, "{}(", name)?;`
	`139`	`+ write!(f, "{name}(")?;`
`140`	`140`	`for (index, arg) in args.iter().enumerate() {`
`141`	`141`	`if index > 0 {`
`142`	`142`	`write!(f, ",")?;`
`143`	`143`	`}`
`144`		`- write!(f, "{}", arg)?;`
	`144`	`+ write!(f, "{arg}")?;`
`145`	`145`	`}`
`146`	`146`	`write!(f, ")")`
`147`	`147`	`}`
`148`		`- Entry::Comment(line) => write!(f, "// {}", line),`
	`148`	`+ Entry::Comment(line) => write!(f, "// {line}"),`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`	`}`
`@@ -179,8 +179,8 @@ const MAX_STRLEN: usize = 1048576;`
`179`	`179`	`impl fmt::Display for Arg {`
`180`	`180`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`181`	`181`	`match self {`
`182`		`- Arg::Label(x) => write!(f, "{}", x),`
`183`		`- Arg::Int(x) => write!(f, "{}", x),`
	`182`	`+ Arg::Label(x) => write!(f, "{x}"),`
	`183`	`+ Arg::Int(x) => write!(f, "{x}"),`
`184`	`184`	`Arg::String(x) => write!(`
`185`	`185`	`f,`
`186`	`186`	`"\"{}\"",`
`@@ -220,9 +220,9 @@ impl fmt::Display for Program {`
`220`	`220`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`221`	`221`	`let mut text = String::new();`
`222`	`222`	`for trap_entry in &self.0 {`
`223`		`- text.push_str(&format!("{}\n", trap_entry));`
	`223`	`+ text.push_str(&format!("{trap_entry}\n"));`
`224`	`224`	`}`
`225`		`- write!(f, "{}", text)`
	`225`	`+ write!(f, "{text}")`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`