Migrate to Rust 1.88.0

AmrDeveloper · AmrDeveloper · commit d738f8f89957 · 2025-07-12T18:32:48.000+02:00
diff --git a/crates/gitql-ast/src/interval.rs b/crates/gitql-ast/src/interval.rs
@@ -111,7 +111,7 @@ impl Display for Interval {
 
         let (hours, minutes, seconds) = (self.hours, self.minutes, self.seconds);
         if hours != 0 || minutes != 0 || seconds != 0f64 {
-            parts.push(format!("{:02}:{:02}:{:02}", hours, minutes, seconds));
+            parts.push(format!("{hours:02}:{minutes:02}:{seconds:02}"));
         }
 
         if parts.is_empty() {
@@ -127,7 +127,7 @@ fn interval_value_or_error_i64(value: i64) -> Result<i64, String> {
     if (-INTERVAL_MAX_VALUE_I..=INTERVAL_MAX_VALUE_I).contains(&value) {
         return Ok(value);
     }
-    Err(format!("Interval value out of range {}", value))
+    Err(format!("Interval value out of range {value}"))
 }
 
 fn interval_value_or_error_f64(value: f64) -> Result<f64, String> {
diff --git a/crates/gitql-cli/src/arguments.rs b/crates/gitql-cli/src/arguments.rs
@@ -58,14 +58,14 @@ pub fn parse_arguments(args: &[String]) -> Command {
 
         let arg = &args[arg_index];
         if !arg.starts_with('-') {
-            return Command::Error(format!("Unknown argument {}", arg));
+            return Command::Error(format!("Unknown argument {arg}"));
         }
 
         match arg.as_ref() {
             "--repos" | "-r" => {
                 arg_index += 1;
                 if arg_index >= args_len {
-                    let message = format!("Argument {} must be followed by one or more path", arg);
+                    let message = format!("Argument {arg} must be followed by one or more path");
                     return Command::Error(message);
                 }
 
@@ -87,7 +87,7 @@ pub fn parse_arguments(args: &[String]) -> Command {
             "--query" | "-q" => {
                 arg_index += 1;
                 if arg_index >= args_len {
-                    let message = format!("Argument {} must be followed by the query", arg);
+                    let message = format!("Argument {arg} must be followed by the query");
                     return Command::Error(message);
                 }
 
@@ -97,7 +97,7 @@ pub fn parse_arguments(args: &[String]) -> Command {
             "--script" | "-s" => {
                 arg_index += 1;
                 if arg_index >= args_len {
-                    let message = format!("Argument {} must be followed by the file", arg);
+                    let message = format!("Argument {arg} must be followed by the file");
                     return Command::Error(message);
                 }
 
@@ -115,7 +115,7 @@ pub fn parse_arguments(args: &[String]) -> Command {
             "--pagesize" | "-ps" => {
                 arg_index += 1;
                 if arg_index >= args_len {
-                    let message = format!("Argument {} must be followed by the page size", arg);
+                    let message = format!("Argument {arg} must be followed by the page size");
                     return Command::Error(message);
                 }
 
@@ -135,7 +135,7 @@ pub fn parse_arguments(args: &[String]) -> Command {
             "--output" | "-o" => {
                 arg_index += 1;
                 if arg_index >= args_len {
-                    let message = format!("Argument {} must be followed by output format", arg);
+                    let message = format!("Argument {arg} must be followed by output format");
                     return Command::Error(message);
                 }
 
@@ -154,7 +154,7 @@ pub fn parse_arguments(args: &[String]) -> Command {
 
                 arg_index += 1;
             }
-            _ => return Command::Error(format!("Unknown command {}", arg)),
+            _ => return Command::Error(format!("Unknown command {arg}")),
         }
     }
 
diff --git a/crates/gitql-cli/src/diagnostic_reporter.rs b/crates/gitql-cli/src/diagnostic_reporter.rs
@@ -47,17 +47,17 @@ impl DiagnosticReporter {
 
         self.stdout.set_color(Some(Color::Cyan));
         for help in diagnostic.helps() {
-            println!(" = Help: {}", help);
+            println!(" = Help: {help}");
         }
 
         self.stdout.set_color(Some(Color::Yellow));
         for note in diagnostic.notes() {
-            println!(" = Note: {}", note);
+            println!(" = Note: {note}");
         }
 
         self.stdout.set_color(Some(Color::Blue));
         if let Some(docs) = diagnostic.docs() {
-            println!(" = Docs: {}", docs);
+            println!(" = Docs: {docs}");
         }
 
         self.stdout.reset();
diff --git a/crates/gitql-cli/src/printer/csv_printer.rs b/crates/gitql-cli/src/printer/csv_printer.rs
@@ -25,8 +25,8 @@ impl BaseOutputPrinter for CSVPrinter {
 
         if let Ok(writer_content) = writer.into_inner() {
             if let Ok(content) = String::from_utf8(writer_content) {
-                if let Err(error) = writeln!(stdout(), "{}", content) {
-                    eprintln!("{}", error);
+                if let Err(error) = writeln!(stdout(), "{content}") {
+                    eprintln!("{error}");
                     std::process::exit(1);
                 }
             }
diff --git a/crates/gitql-cli/src/printer/json_printer.rs b/crates/gitql-cli/src/printer/json_printer.rs
@@ -26,8 +26,8 @@ impl BaseOutputPrinter for JSONPrinter {
         }
 
         if let Ok(json_str) = serde_json::to_string(&serde_json::Value::Array(elements)) {
-            if let Err(error) = writeln!(stdout(), "{}", json_str) {
-                eprintln!("{}", error);
+            if let Err(error) = writeln!(stdout(), "{json_str}") {
+                eprintln!("{error}");
                 std::process::exit(1);
             }
         }
diff --git a/crates/gitql-cli/src/printer/table_printer.rs b/crates/gitql-cli/src/printer/table_printer.rs
@@ -87,7 +87,7 @@ impl BaseOutputPrinter for TablePrinter {
             let end_index = (start_index + self.page_size).min(group_len);
 
             let current_page_groups = &group.rows[start_index..end_index];
-            println!("Page {}/{}", current_page, number_of_pages);
+            println!("Page {current_page}/{number_of_pages}");
             self.print_group_as_table(titles, table_headers.clone(), current_page_groups);
 
             let pagination_input = self.handle_pagination_input(current_page, number_of_pages);
diff --git a/crates/gitql-cli/src/printer/yaml_printer.rs b/crates/gitql-cli/src/printer/yaml_printer.rs
@@ -33,12 +33,12 @@ impl BaseOutputPrinter for YAMLPrinter {
         }
 
         if let Err(error) = emitter.dump(&Yaml::Array(rows_rows)) {
-            eprintln!("{}", error);
+            eprintln!("{error}");
             std::process::exit(1);
         }
 
-        if let Err(error) = writeln!(stdout(), "{}", out_str) {
-            eprintln!("{}", error);
+        if let Err(error) = writeln!(stdout(), "{out_str}") {
+            eprintln!("{error}");
             std::process::exit(1);
         }
     }
diff --git a/crates/gitql-engine/src/engine_evaluator.rs b/crates/gitql-engine/src/engine_evaluator.rs
@@ -258,8 +258,7 @@ fn evaluate_global_variable(
     }
 
     Err(format!(
-        "The value of `{}` may be not exists or calculated yet",
-        name
+        "The value of `{name}` may be not exists or calculated yet",
     ))
 }
 
diff --git a/crates/gitql-parser/src/parse_comparisons.rs b/crates/gitql-parser/src/parse_comparisons.rs
@@ -128,8 +128,7 @@ pub(crate) fn parse_comparison_expression(
             }
 
             let mut diagnostic = Diagnostic::error(&format!(
-                "Operator `=` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `=` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location);
 
@@ -208,8 +207,7 @@ pub(crate) fn parse_comparison_expression(
             }
 
             let mut diagnostic = Diagnostic::error(&format!(
-                "Operator `!=` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `!=` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location);
 
@@ -290,8 +288,7 @@ pub(crate) fn parse_comparison_expression(
 
             // Return error if this operator can't be performed even with implicit cast
             return Err(Diagnostic::error(&format!(
-                "Operator `>` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `>` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location)
             .as_boxed());
@@ -363,8 +360,7 @@ pub(crate) fn parse_comparison_expression(
 
             // Return error if this operator can't be performed even with implicit cast
             return Err(Diagnostic::error(&format!(
-                "Operator `>=` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `>=` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location)
             .as_boxed());
@@ -436,8 +432,7 @@ pub(crate) fn parse_comparison_expression(
 
             // Return error if this operator can't be performed even with implicit cast
             return Err(Diagnostic::error(&format!(
-                "Operator `<` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `<` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location)
             .as_boxed());
@@ -509,8 +504,7 @@ pub(crate) fn parse_comparison_expression(
 
             // Return error if this operator can't be performed even with implicit cast
             return Err(Diagnostic::error(&format!(
-                "Operator `<=` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `<=` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location)
             .as_boxed());
@@ -582,8 +576,7 @@ pub(crate) fn parse_comparison_expression(
 
             // Return error if this operator can't be performed even with implicit cast
             return Err(Diagnostic::error(&format!(
-                "Operator `<=>` can't be performed between types `{}` and `{}`",
-                lhs_type, rhs_type
+                "Operator `<=>` can't be performed between types `{lhs_type}` and `{rhs_type}`",
             ))
             .with_location(operator.location)
             .as_boxed());
diff --git a/crates/gitql-parser/src/parse_function_call.rs b/crates/gitql-parser/src/parse_function_call.rs
@@ -80,8 +80,7 @@ pub(crate) fn parse_function_call_expression(
 
             // Function has no signature registered on the signature table
             return Err(Diagnostic::error(&format!(
-                "Can't find signature for function with name {}",
-                function_name
+                "Can't find signature for function with name {function_name}",
             ))
             .with_location(function_name_location)
             .as_boxed());
@@ -164,8 +163,7 @@ pub(crate) fn parse_function_call_expression(
 
             // Aggregation Function has no signature registered on the signature table
             return Err(Diagnostic::error(&format!(
-                "Can't find signature for Aggregation function with name {}",
-                function_name
+                "Can't find signature for Aggregation function with name {function_name}",
             ))
             .with_location(function_name_location)
             .as_boxed());
@@ -272,8 +270,7 @@ pub(crate) fn parse_function_call_expression(
 
             // Aggregation Function has no signature registered on the signature table
             return Err(Diagnostic::error(&format!(
-                "Can't find signature for Window function with name {}",
-                function_name
+                "Can't find signature for Window function with name {function_name}",
             ))
             .with_location(function_name_location)
             .as_boxed());
@@ -282,8 +279,7 @@ pub(crate) fn parse_function_call_expression(
         // Report that this function name is not standard or aggregation
         return Err(Diagnostic::error("No such function name")
             .add_help(&format!(
-                "Function `{}` is not an Aggregation or Standard library function name",
-                function_name,
+                "Function `{function_name}` is not an Aggregation or Standard library function name",
             ))
             .with_location(function_name_location)
             .as_boxed());
diff --git a/crates/gitql-parser/src/parse_interval.rs b/crates/gitql-parser/src/parse_interval.rs
@@ -72,8 +72,7 @@ fn parse_interval_literal(
 
             if position >= tokens.len() {
                 return Err(Diagnostic::error(&format!(
-                    "Missing interval unit after value {}",
-                    value
+                    "Missing interval unit after value {value}",
                 ))
                 .with_location(location)
                 .as_boxed());
@@ -103,8 +102,7 @@ fn parse_interval_literal(
             }
 
             return Err(Diagnostic::error(&format!(
-                "Invalid input syntax for interval unit `{}`",
-                maybe_unit
+                "Invalid input syntax for interval unit `{maybe_unit}`",
             ))
             .add_help(
                 "Interval date unit can be `[year | years | mon | mons | months | day or days]`",
@@ -197,17 +195,15 @@ fn check_interval_value_and_unit(
 
     if !(-INTERVAL_MAX_VALUE..=INTERVAL_MAX_VALUE).contains(&interval_value) {
         return Err(Diagnostic::error(&format!(
-            "Interval value for unit `{}` is out of the range",
-            unit_name
+            "Interval value for unit `{unit_name}` is out of the range",
         ))
         .add_help("Interval value must be in range from -170_000_000 to 170_000_000")
         .with_location(location)
         .as_boxed());
     }
 
     Err(Diagnostic::error(&format!(
-        "Can't use the same interval unit `{}` twice",
-        unit_name
+        "Can't use the same interval unit `{unit_name}` twice",
     ))
     .with_location(location)
     .as_boxed())
diff --git a/crates/gitql-parser/src/parse_type.rs b/crates/gitql-parser/src/parse_type.rs
@@ -72,8 +72,7 @@ fn parse_primitive_type(
     }
 
     Err(Diagnostic::error(&format!(
-        "No available type in TypeTable with name `{}`",
-        type_literal
+        "No available type in TypeTable with name `{type_literal}`",
     ))
     .with_location(type_name_token.location)
     .as_boxed())
diff --git a/crates/gitql-parser/src/parser.rs b/crates/gitql-parser/src/parser.rs
diff --git a/crates/gitql-parser/src/type_checker.rs b/crates/gitql-parser/src/type_checker.rs
diff --git a/crates/gitql-std/src/datetime/mod.rs b/crates/gitql-std/src/datetime/mod.rs
diff --git a/crates/gitql-std/src/text/mod.rs b/crates/gitql-std/src/text/mod.rs
diff --git a/src/gitql/gitql_data_provider.rs b/src/gitql/gitql_data_provider.rs
diff --git a/src/main.rs b/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ impl Display for Interval {`
`111`	`111`
`112`	`112`	`let (hours, minutes, seconds) = (self.hours, self.minutes, self.seconds);`
`113`	`113`	`if hours != 0 \|\| minutes != 0 \|\| seconds != 0f64 {`
`114`		`- parts.push(format!("{:02}:{:02}:{:02}", hours, minutes, seconds));`
	`114`	`+ parts.push(format!("{hours:02}:{minutes:02}:{seconds:02}"));`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`if parts.is_empty() {`
`@@ -127,7 +127,7 @@ fn interval_value_or_error_i64(value: i64) -> Result<i64, String> {`
`127`	`127`	`if (-INTERVAL_MAX_VALUE_I..=INTERVAL_MAX_VALUE_I).contains(&value) {`
`128`	`128`	`return Ok(value);`
`129`	`129`	`}`
`130`		`- Err(format!("Interval value out of range {}", value))`
	`130`	`+ Err(format!("Interval value out of range {value}"))`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`fn interval_value_or_error_f64(value: f64) -> Result<f64, String> {`
Original file line number	Diff line number	Diff line change
`@@ -58,14 +58,14 @@ pub fn parse_arguments(args: &[String]) -> Command {`
`58`	`58`
`59`	`59`	`let arg = &args[arg_index];`
`60`	`60`	`if !arg.starts_with('-') {`
`61`		`- return Command::Error(format!("Unknown argument {}", arg));`
	`61`	`+ return Command::Error(format!("Unknown argument {arg}"));`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`match arg.as_ref() {`
`65`	`65`	`"--repos" \| "-r" => {`
`66`	`66`	`arg_index += 1;`
`67`	`67`	`if arg_index >= args_len {`
`68`		`- let message = format!("Argument {} must be followed by one or more path", arg);`
	`68`	`+ let message = format!("Argument {arg} must be followed by one or more path");`
`69`	`69`	`return Command::Error(message);`
`70`	`70`	`}`
`71`	`71`
`@@ -87,7 +87,7 @@ pub fn parse_arguments(args: &[String]) -> Command {`
`87`	`87`	`"--query" \| "-q" => {`
`88`	`88`	`arg_index += 1;`
`89`	`89`	`if arg_index >= args_len {`
`90`		`- let message = format!("Argument {} must be followed by the query", arg);`
	`90`	`+ let message = format!("Argument {arg} must be followed by the query");`
`91`	`91`	`return Command::Error(message);`
`92`	`92`	`}`
`93`	`93`
`@@ -97,7 +97,7 @@ pub fn parse_arguments(args: &[String]) -> Command {`
`97`	`97`	`"--script" \| "-s" => {`
`98`	`98`	`arg_index += 1;`
`99`	`99`	`if arg_index >= args_len {`
`100`		`- let message = format!("Argument {} must be followed by the file", arg);`
	`100`	`+ let message = format!("Argument {arg} must be followed by the file");`
`101`	`101`	`return Command::Error(message);`
`102`	`102`	`}`
`103`	`103`
`@@ -115,7 +115,7 @@ pub fn parse_arguments(args: &[String]) -> Command {`
`115`	`115`	`"--pagesize" \| "-ps" => {`
`116`	`116`	`arg_index += 1;`
`117`	`117`	`if arg_index >= args_len {`
`118`		`- let message = format!("Argument {} must be followed by the page size", arg);`
	`118`	`+ let message = format!("Argument {arg} must be followed by the page size");`
`119`	`119`	`return Command::Error(message);`
`120`	`120`	`}`
`121`	`121`
`@@ -135,7 +135,7 @@ pub fn parse_arguments(args: &[String]) -> Command {`
`135`	`135`	`"--output" \| "-o" => {`
`136`	`136`	`arg_index += 1;`
`137`	`137`	`if arg_index >= args_len {`
`138`		`- let message = format!("Argument {} must be followed by output format", arg);`
	`138`	`+ let message = format!("Argument {arg} must be followed by output format");`
`139`	`139`	`return Command::Error(message);`
`140`	`140`	`}`
`141`	`141`
`@@ -154,7 +154,7 @@ pub fn parse_arguments(args: &[String]) -> Command {`
`154`	`154`
`155`	`155`	`arg_index += 1;`
`156`	`156`	`}`
`157`		`- _ => return Command::Error(format!("Unknown command {}", arg)),`
	`157`	`+ _ => return Command::Error(format!("Unknown command {arg}")),`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
Original file line number	Diff line number	Diff line change
`@@ -47,17 +47,17 @@ impl DiagnosticReporter {`
`47`	`47`
`48`	`48`	`self.stdout.set_color(Some(Color::Cyan));`
`49`	`49`	`for help in diagnostic.helps() {`
`50`		`- println!(" = Help: {}", help);`
	`50`	`+ println!(" = Help: {help}");`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`self.stdout.set_color(Some(Color::Yellow));`
`54`	`54`	`for note in diagnostic.notes() {`
`55`		`- println!(" = Note: {}", note);`
	`55`	`+ println!(" = Note: {note}");`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`self.stdout.set_color(Some(Color::Blue));`
`59`	`59`	`if let Some(docs) = diagnostic.docs() {`
`60`		`- println!(" = Docs: {}", docs);`
	`60`	`+ println!(" = Docs: {docs}");`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`self.stdout.reset();`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ impl BaseOutputPrinter for CSVPrinter {`
`25`	`25`
`26`	`26`	`if let Ok(writer_content) = writer.into_inner() {`
`27`	`27`	`if let Ok(content) = String::from_utf8(writer_content) {`
`28`		`- if let Err(error) = writeln!(stdout(), "{}", content) {`
`29`		`- eprintln!("{}", error);`
	`28`	`+ if let Err(error) = writeln!(stdout(), "{content}") {`
	`29`	`+ eprintln!("{error}");`
`30`	`30`	`std::process::exit(1);`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ impl BaseOutputPrinter for JSONPrinter {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`if let Ok(json_str) = serde_json::to_string(&serde_json::Value::Array(elements)) {`
`29`		`- if let Err(error) = writeln!(stdout(), "{}", json_str) {`
`30`		`- eprintln!("{}", error);`
	`29`	`+ if let Err(error) = writeln!(stdout(), "{json_str}") {`
	`30`	`+ eprintln!("{error}");`
`31`	`31`	`std::process::exit(1);`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,12 +33,12 @@ impl BaseOutputPrinter for YAMLPrinter {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`if let Err(error) = emitter.dump(&Yaml::Array(rows_rows)) {`
`36`		`- eprintln!("{}", error);`
	`36`	`+ eprintln!("{error}");`
`37`	`37`	`std::process::exit(1);`
`38`	`38`	`}`
`39`	`39`
`40`		`- if let Err(error) = writeln!(stdout(), "{}", out_str) {`
`41`		`- eprintln!("{}", error);`
	`40`	`+ if let Err(error) = writeln!(stdout(), "{out_str}") {`
	`41`	`+ eprintln!("{error}");`
`42`	`42`	`std::process::exit(1);`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,8 +258,7 @@ fn evaluate_global_variable(`
`258`	`258`	`}`
`259`	`259`
`260`	`260`	`Err(format!(`
`261`		- "The value of `{}` may be not exists or calculated yet",
`262`		`- name`
	`261`	+ "The value of `{name}` may be not exists or calculated yet",
`263`	`262`	`))`
`264`	`263`	`}`
`265`	`264`