chore: update Rust to 1.97.1 (#5849)

## Overview

Bumps the pinned toolchain in `rust-toolchain.toml` from 1.92.0 to
1.97.1 and fixes everything the new Clippy complains about, so `make
pedantic` is green again.

## Changes

The bulk of the diff is the new lint against redundant references in
formatting macro arguments. `format!`, `panic!` and `assert_eq!` already
take their arguments by reference, so the explicit `&` was pointless.
Purely mechanical, no behaviour change.

The rest, one by one:

- **`sql_schema_differ.rs`** — `Some(TableChange::…).filter(|_|
differ.primary_key_changed())` becomes
`differ.primary_key_changed().then_some(TableChange::…)`. The lint warns
that this reorders the condition against the value; harmless here, since
the value is a unit variant and the predicate is a pure query.
- **`native_types.rs`, `flavour/postgres.rs`** — `a.and_then(|a|
b.map(|b| (a, b)))` becomes `a.zip(b)`.
- **`datasource_loader.rs`** — `sort_by(|(a, _), (b, _)| a.cmp(b))`
becomes `sort_by_key`.
- **`validations/fields.rs`** — the `DecimalType` capability check moves
from an `if` inside the match arm into a match guard.
- **`quaint/src/ast/values.rs`, `query_document/selection.rs`** — two
blocks that returned `None` on the miss now use `?`.
- **`configuration.rs`, `statistics.rs`, `differ_database.rs`** —
`iter().map(|(_, v)| …)` over maps becomes `values()`.
- **`visitor/mssql.rs`** — drop a no-op `into_iter()` on an argument
that already accepts `IntoIterator`.

## Inlined format arguments

Since the redundant-reference fix was already rewriting those formatting
macro calls, the second commit captures their arguments in the format
string as well — `panic!("Unknown driver adapter: {}", s)` becomes
`panic!("Unknown driver adapter: {s}")`.

This is scoped to the lines this PR already touches. Every argument that
*can* be captured is, including in calls that also carry arguments that
cannot be, so a few strings mix the two styles:

```rust
format!("{alter_column_prefix} SET DATA TYPE {}", render_column_type(columns.next, renderer))
```

What stays positional is only what the language cannot capture: method
calls (`field.name()`) and field accesses (`self.schema`).

Note that `clippy::uninlined_format_args` only fires when *all* of a
call's arguments are capturable, so the mixed cases above are beyond
what the lint would ask for. With this PR applied, no fully-capturable
call remains on any line it touches.

## Verification

- `make pedantic` passes (both the native and the
`wasm32-unknown-unknown` Clippy passes).
- `make test-unit` passes: 112 test binaries, no failures.

---------

Signed-off-by: Alexey Orlenko's AI Agent <robot@aqrln.net>

Author: tensordreams

libs/driver-adapters/src/conversion/mysql.rs

@@ -98,7 +98,7 @@ mod test {
         for (val, expected) in test_cases {
             let actual = value_to_js_arg(&val.clone().into_value()).unwrap();
             if actual != expected {
-                errors.push(format!("transforming: {:?}, expected: {:?}, actual: {:?}", &val, expected, actual));
+                errors.push(format!("transforming: {val:?}, expected: {expected:?}, actual: {actual:?}"));
             }
         }
         assert_eq!(errors.len(), 0, "{}", errors.join("\n"));

libs/driver-adapters/src/conversion/postgres.rs

@@ -100,7 +100,7 @@ mod test {
         for (val, expected) in test_cases {
             let actual = value_to_js_arg(&val).unwrap();
             if actual != expected {
-                errors.push(format!("transforming: {:?}, expected: {:?}, actual: {:?}", &val, expected, actual));
+                errors.push(format!("transforming: {val:?}, expected: {expected:?}, actual: {actual:?}"));
             }
         }
         assert_eq!(errors.len(), 0, "{}", errors.join("\n"));

libs/driver-adapters/src/conversion/sqlite.rs

@@ -105,7 +105,7 @@ mod test {
         for (val, expected) in test_cases {
             let actual = value_to_js_arg(&val.clone().into_value()).unwrap();
             if actual != expected {
-                errors.push(format!("transforming: {:?}, expected: {:?}, actual: {:?}", &val, expected, actual));
+                errors.push(format!("transforming: {val:?}, expected: {expected:?}, actual: {actual:?}"));
             }
         }
         assert_eq!(errors.len(), 0, "{}", errors.join("\n"));

libs/user-facing-errors/src/query_engine/validation.rs

@@ -203,17 +203,13 @@ impl ValidationError {
         let (message, meta) = if let Some(err) = underlying_err {
             let err_msg = err.to_string();
             let message = format!(
-                "Invalid argument value. `{}` is not a valid `{}`. Underlying error: {}",
-                value, expected_argument_type, &err_msg
+                "Invalid argument value. `{value}` is not a valid `{expected_argument_type}`. Underlying error: {err_msg}"
             );
             let argument = ArgumentDescription::new(*argument_name, vec![Cow::Borrowed(expected_argument_type)]);
             let meta = json!({"argumentPath": argument_path, "argument": argument, "selectionPath": selection_path, "underlyingError": &err_msg});
             (message, Some(meta))
         } else {
-            let message = format!(
-                "Invalid argument value. `{}` is not a valid `{}`",
-                value, &expected_argument_type
-            );
+            let message = format!("Invalid argument value. `{value}` is not a valid `{expected_argument_type}`");
             let argument = ArgumentDescription::new(*argument_name, vec![Cow::Borrowed(expected_argument_type)]);
             let meta = json!({"argumentPath": argument_path, "argument": argument, "selectionPath": selection_path, "underlyingError": serde_json::Value::Null});
             (message, Some(meta))
@@ -469,7 +465,7 @@ impl ValidationError {
     ///     }
     /// }
     pub fn selection_set_on_scalar(field_name: String, selection_path: Vec<&str>) -> Self {
-        let message = format!("Cannot select over scalar field '{}'", &field_name);
+        let message = format!("Cannot select over scalar field '{field_name}'");
         ValidationError {
             kind: ValidationErrorKind::SelectionSetOnScalar,
             message,

libs/user-facing-errors/src/schema_engine.rs

@@ -71,7 +71,7 @@ impl crate::UserFacingError for MigrationDoesNotApplyCleanly {
                 message: _,
                 meta: _,
                 error_code,
-            }) => format!("Error code: {}\n", &error_code),
+            }) => format!("Error code: {error_code}\n"),
             crate::ErrorType::Unknown(_) => String::new(),
         };
 
@@ -170,7 +170,7 @@ impl crate::UserFacingError for ShadowDbCreationError {
                 message: _,
                 meta: _,
                 error_code,
-            }) => format!("Error code: {}\n", &error_code),
+            }) => format!("Error code: {error_code}\n"),
             crate::ErrorType::Unknown(_) => String::new(),
         };
 
@@ -205,7 +205,7 @@ impl crate::UserFacingError for SoftResetFailed {
                 message: _,
                 meta: _,
                 error_code,
-            }) => format!("Error code: {}\n", &error_code),
+            }) => format!("Error code: {error_code}\n"),
             crate::ErrorType::Unknown(_) => String::new(),
         };
 

psl/parser-database/src/attributes.rs

@@ -361,7 +361,7 @@ fn visit_relation_field_attributes(rfid: RelationFieldId, ctx: &mut Context<'_>)
     if ctx.visit_optional_single_attr("id") {
         let msg = format!(
             "The field `{}` is a relation field and cannot be marked with `@id`. Only scalar fields can be declared as id.",
-            &ast_field.name(),
+            ast_field.name(),
         );
         ctx.push_attribute_validation_error(&msg);
         ctx.discard_arguments();

psl/psl-core/src/datamodel_connector/native_types.rs

@@ -164,7 +164,7 @@ impl NativeTypeArguments for (u32, u32) {
 
     fn from_parts(parts: &[String]) -> Option<Self> {
         match parts {
-            [a, b] => a.parse().ok().and_then(|a| b.parse().ok().map(|b| (a, b))),
+            [a, b] => a.parse().ok().zip(b.parse().ok()),
             _ => None,
         }
     }

psl/psl-core/src/validate/datasource_loader.rs

@@ -166,7 +166,7 @@ fn lift_datasource(
                     return None;
                 }
 
-                schemas.sort_by(|(a, _), (b, _)| a.cmp(b));
+                schemas.sort_by_key(|(a, _)| *a);
 
                 for pair in schemas.windows(2) {
                     if pair[0].0 == pair[1].0 {

psl/psl-core/src/validate/validation_pipeline/validations/fields.rs

@@ -295,20 +295,20 @@ pub(super) fn validate_scalar_field_connector_specific(field: ScalarFieldWalker<
             }
         }
 
-        ScalarFieldType::BuiltInScalar(ScalarType::Decimal) => {
-            if !ctx.has_capability(ConnectorCapability::DecimalType) {
-                ctx.push_error(DatamodelError::new_field_validation_error(
-                    &format!(
-                        "Field `{}` in {container} `{}` can't be of type Decimal. The current connector does not support the Decimal type.",
-                        field.name(),
-                        field.model().name(),
-                    ),
-                    container,
-                    field.model().name(),
+        ScalarFieldType::BuiltInScalar(ScalarType::Decimal)
+            if !ctx.has_capability(ConnectorCapability::DecimalType) =>
+        {
+            ctx.push_error(DatamodelError::new_field_validation_error(
+                &format!(
+                    "Field `{}` in {container} `{}` can't be of type Decimal. The current connector does not support the Decimal type.",
                     field.name(),
-                    field.ast_field().span(),
-                ));
-            }
+                    field.model().name(),
+                ),
+                container,
+                field.model().name(),
+                field.name(),
+                field.ast_field().span(),
+            ));
         }
 
         _ => (),
@@ -364,11 +364,10 @@ pub(super) fn validate_unsupported_field_type(field: ScalarFieldWalker<'_>, ctx:
             && let Some(prisma_type) = connector.scalar_type_for_native_type(&native_type, ctx.extension_types)
         {
             let msg = format!(
-                "The type `Unsupported(\"{}\")` you specified in the type definition for the field `{}` is supported as a native type by Prisma. Please use the native type notation `{} @{}.{}` for full support.",
-                unsupported_lit,
+                "The type `Unsupported(\"{unsupported_lit}\")` you specified in the type definition for the field `{}` is supported as a native type by Prisma. Please use the native type notation `{} @{}.{}` for full support.",
                 field.name(),
                 prisma_type.display(ctx.db),
-                &source.name,
+                source.name,
                 connector.native_type_to_string(&native_type)
             );
 

psl/psl-core/src/validate/validation_pipeline/validations/relations/many_to_many/implicit.rs

@@ -14,9 +14,9 @@ pub(crate) fn validate_singular_id(relation: ImplicitManyToManyRelationWalker<'_
 
             let message = format!(
                 "The relation field `{}` on {container} `{}` references `{}` which does not have an `@id` field. Models without `@id` cannot be part of a many to many relation. Use an explicit intermediate Model to represent this relationship.",
-                &relation_field.name(),
-                &relation_field.model().name(),
-                &relation_field.related_model().name(),
+                relation_field.name(),
+                relation_field.model().name(),
+                relation_field.related_model().name(),
             );
 
             ctx.push_error(DatamodelError::new_field_validation_error(
@@ -34,7 +34,7 @@ pub(crate) fn validate_singular_id(relation: ImplicitManyToManyRelationWalker<'_
             ctx.push_error(DatamodelError::new_validation_error(
             &format!(
                 "Implicit many-to-many relations must always reference the id field of the related model. Change the argument `references` to use the id field of the related model `{}`. But it is referencing the following fields that are not the id: {}",
-                &relation_field.related_model().name(),
+                relation_field.related_model().name(),
                 relation_field.referenced_fields().into_iter().flatten().map(|f| f.name()).collect::<Vec<_>>().join(", ")
             ),
             relation_field.ast_field().span())