chore: inline format args on the lines already touched

tensordreams · tensordreams · commit 7b506abb3f5d · 2026-07-27T13:53:39.000+02:00
These formatting macro calls were already being rewritten to drop
redundant references, so capture their arguments in the format string
too.

Arguments that cannot be captured — method calls and field accesses —
stay positional, so a few of these strings mix the two styles.

Signed-off-by: Alexey Orlenko's AI Agent &lt;robot@aqrln.net&gt;
diff --git a/libs/driver-adapters/src/conversion/mysql.rs b/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"));
diff --git a/libs/driver-adapters/src/conversion/postgres.rs b/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"));
diff --git a/libs/driver-adapters/src/conversion/sqlite.rs b/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"));
diff --git a/libs/user-facing-errors/src/query_engine/validation.rs b/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,
diff --git a/libs/user-facing-errors/src/schema_engine.rs b/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(),
         };
 
diff --git a/psl/psl-core/src/validate/validation_pipeline/validations/fields.rs b/psl/psl-core/src/validate/validation_pipeline/validations/fields.rs
@@ -364,8 +364,7 @@ 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,
diff --git a/psl/psl-core/src/validate/validation_pipeline/validations/relations/one_to_one.rs b/psl/psl-core/src/validate/validation_pipeline/validations/relations/one_to_one.rs
@@ -41,12 +41,11 @@ pub(crate) fn fields_and_references_are_defined(relation: InlineRelationWalker<'
 
     if is_empty_fields(forward.referencing_fields()) && is_empty_fields(back.referencing_fields()) {
         let message = format!(
-            "The relation fields `{}` on Model `{}` and `{}` on Model `{}` do not provide the `fields` argument in the {} attribute. You have to provide it on one of the two fields.",
+            "The relation fields `{}` on Model `{}` and `{}` on Model `{}` do not provide the `fields` argument in the {RELATION_ATTRIBUTE_NAME} attribute. You have to provide it on one of the two fields.",
             forward.name(),
             forward.model().name(),
             back.name(),
             back.model().name(),
-            RELATION_ATTRIBUTE_NAME
         );
 
         ctx.push_error(DatamodelError::new_attribute_validation_error(
diff --git a/psl/psl/tests/common/asserts.rs b/psl/psl/tests/common/asserts.rs
@@ -115,8 +115,7 @@ impl WarningAsserts for Vec<DatamodelWarning> {
         assert_eq!(
             self.len(),
             1,
-            "Expected exactly one validation warning. Warnings are: {:?}",
-            self
+            "Expected exactly one validation warning. Warnings are: {self:?}"
         );
         assert_eq!(self[0], warning);
         self
@@ -696,7 +695,7 @@ impl DefaultValueAssert for ast::Expression {
                 panic!("Expected a numeric value for the `cuid()` version.");
             }
         } else {
-            panic!("Expected `cuid()` to be a function, got {}", self);
+            panic!("Expected `cuid()` to be a function, got {self}");
         }
 
         self
@@ -720,7 +719,7 @@ impl DefaultValueAssert for ast::Expression {
                 panic!("Expected a numeric value for the `uuid()` version.");
             }
         } else {
-            panic!("Expected `cuid()` to be a function, got {}", self);
+            panic!("Expected `cuid()` to be a function, got {self}");
         }
 
         self
diff --git a/quaint/src/tests/query.rs b/quaint/src/tests/query.rs
@@ -1683,11 +1683,11 @@ async fn op_test_div_one_level(api: &mut dyn TestApi) -> crate::Result<()> {
 #[test_each_connector(tags("postgresql"))]
 async fn enum_values(api: &mut dyn TestApi) -> crate::Result<()> {
     let type_name = api.get_name();
-    let create_type = format!("CREATE TYPE {} AS ENUM ('A', 'B')", type_name);
+    let create_type = format!("CREATE TYPE {type_name} AS ENUM ('A', 'B')");
     api.conn().raw_cmd(&create_type).await?;
 
     let table = api
-        .create_temp_table(&format!("id SERIAL PRIMARY KEY, value {}", type_name))
+        .create_temp_table(&format!("id SERIAL PRIMARY KEY, value {type_name}"))
         .await?;
 
     api.conn()
diff --git a/quaint/src/tests/query/error.rs b/quaint/src/tests/query/error.rs
@@ -240,7 +240,7 @@ async fn foreign_key_constraint_violation(api: &mut dyn TestApi) -> crate::Resul
     let parent = api.create_temp_table("id smallint not null primary key").await?;
     let foreign_key = api.foreign_key(&parent, "id", "parent_id");
     let child = api
-        .create_temp_table(&format!("parent_id smallint not null, {}", foreign_key))
+        .create_temp_table(&format!("parent_id smallint not null, {foreign_key}"))
         .await?;
 
     let insert = Insert::single_into(&child).value("parent_id", 10);
@@ -267,11 +267,10 @@ async fn ms_my_foreign_key_constraint_violation(api: &mut dyn TestApi) -> crate:
 
     let create_table = format!(
         r#"
-        CREATE TABLE {} (
+        CREATE TABLE {child_table} (
             parent_id smallint not null,
-            CONSTRAINT {} FOREIGN KEY (parent_id) REFERENCES {}(id))
-        "#,
-        child_table, constraint, parent_table
+            CONSTRAINT {constraint} FOREIGN KEY (parent_id) REFERENCES {parent_table}(id))
+        "#
     );
 
     api.conn().raw_cmd(&create_table).await?;
@@ -284,8 +283,8 @@ async fn ms_my_foreign_key_constraint_violation(api: &mut dyn TestApi) -> crate:
     let err = result.unwrap_err();
     assert!(matches!(err.kind(), ErrorKind::ForeignKeyConstraintViolation { .. }));
 
-    api.conn().raw_cmd(&format!("DROP TABLE {}", child_table)).await?;
-    api.conn().raw_cmd(&format!("DROP TABLE {}", parent_table)).await?;
+    api.conn().raw_cmd(&format!("DROP TABLE {child_table}")).await?;
+    api.conn().raw_cmd(&format!("DROP TABLE {parent_table}")).await?;
 
     Ok(())
 }
@@ -405,10 +404,7 @@ async fn unsupported_column_type(api: &mut dyn TestApi) -> crate::Result<()> {
     let table = api.create_temp_table("point point, points point[]").await?;
     api.conn()
         .query_raw(
-            &format!(
-                r#"INSERT INTO {} ("point", "points") VALUES (Point(1,2), '{{"(1, 2)", "(2, 3)"}}')"#,
-                table
-            ),
+            &format!(r#"INSERT INTO {table} ("point", "points") VALUES (Point(1,2), '{{"(1, 2)", "(2, 3)"}}')"#),
             &[],
         )
         .await?;
diff --git a/quaint/src/tests/test_api/mssql.rs b/quaint/src/tests/test_api/mssql.rs
@@ -102,10 +102,7 @@ impl TestApi for MsSql<'_> {
     fn foreign_key(&mut self, parent_table: &str, parent_column: &str, child_column: &str) -> String {
         let name = self.get_name();
 
-        format!(
-            "CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
-            name, child_column, parent_table, parent_column
-        )
+        format!("CONSTRAINT {name} FOREIGN KEY ({child_column}) REFERENCES {parent_table}({parent_column})")
     }
 
     fn autogen_id(&self, name: &str) -> String {
diff --git a/quaint/src/tests/test_api/mysql.rs b/quaint/src/tests/test_api/mysql.rs
@@ -139,10 +139,7 @@ impl TestApi for MySql<'_> {
     fn foreign_key(&mut self, parent_table: &str, parent_column: &str, child_column: &str) -> String {
         let name = self.get_name();
 
-        format!(
-            "CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
-            name, child_column, parent_table, parent_column
-        )
+        format!("CONSTRAINT {name} FOREIGN KEY ({child_column}) REFERENCES {parent_table}({parent_column})")
     }
 
     fn autogen_id(&self, name: &str) -> String {
diff --git a/quaint/src/tests/test_api/postgres.rs b/quaint/src/tests/test_api/postgres.rs
@@ -97,10 +97,7 @@ impl TestApi for PostgreSql<'_> {
     fn foreign_key(&mut self, parent_table: &str, parent_column: &str, child_column: &str) -> String {
         let name = self.get_name();
 
-        format!(
-            "CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
-            name, child_column, parent_table, parent_column
-        )
+        format!("CONSTRAINT {name} FOREIGN KEY ({child_column}) REFERENCES {parent_table}({parent_column})")
     }
 
     fn autogen_id(&self, name: &str) -> String {
diff --git a/quaint/src/tests/types/sqlite.rs b/quaint/src/tests/types/sqlite.rs
@@ -126,7 +126,7 @@ async fn test_type_text_datetime_rfc3339(api: &mut dyn TestApi) -> crate::Result
 
     api.conn()
         .execute_raw(
-            &format!("INSERT INTO {} (value) VALUES (?)", table),
+            &format!("INSERT INTO {table} (value) VALUES (?)"),
             &[Value::text(dt.to_rfc3339())],
         )
         .await?;
@@ -149,7 +149,7 @@ async fn test_type_text_datetime_rfc2822(api: &mut dyn TestApi) -> crate::Result
 
     api.conn()
         .execute_raw(
-            &format!("INSERT INTO {} (value) VALUES (?)", table),
+            &format!("INSERT INTO {table} (value) VALUES (?)"),
             &[Value::text(dt.to_rfc2822())],
         )
         .await?;
@@ -170,7 +170,7 @@ async fn test_type_text_datetime_custom(api: &mut dyn TestApi) -> crate::Result<
 
     api.conn()
         .execute_raw(
-            &format!("INSERT INTO {} (value) VALUES (?)", table),
+            &format!("INSERT INTO {table} (value) VALUES (?)"),
             &[Value::text("2020-04-20 16:20:00")],
         )
         .await?;
@@ -194,7 +194,7 @@ async fn test_get_int64_from_int32_field_fails(api: &mut dyn TestApi) -> crate::
 
     api.conn()
         .execute_raw(
-            &format!("INSERT INTO {} (value) VALUES (9223372036854775807)", table),
+            &format!("INSERT INTO {table} (value) VALUES (9223372036854775807)"),
             &[],
         )
         .await?;
diff --git a/query-compiler/core/src/query_graph_builder/extractors/filters/scalar.rs b/query-compiler/core/src/query_graph_builder/extractors/filters/scalar.rs
@@ -489,9 +489,8 @@ impl<'a> ScalarFilterParser<'a> {
                         "Expected a referenced scalar field {field_ref} but found a composite field."
                     ))),
                     None => Err(QueryGraphBuilderError::InputError(format!(
-                        "The referenced scalar field {}.{} does not exist.",
-                        field.container().name(),
-                        field_ref_name
+                        "The referenced scalar field {}.{field_ref_name} does not exist.",
+                        field.container().name()
                     ))),
                 }
             }
@@ -529,9 +528,8 @@ impl<'a> ScalarFilterParser<'a> {
                         "Expected a referenced scalar list field {cf} but found a composite field."
                     ))),
                     _ => Err(QueryGraphBuilderError::InputError(format!(
-                        "The referenced scalar list field {}.{} does not exist.",
-                        field.container().name(),
-                        field_ref_name
+                        "The referenced scalar list field {}.{field_ref_name} does not exist.",
+                        field.container().name()
                     ))),
                 }
             }
diff --git a/query-compiler/query-builders/sql-query-builder/src/join_utils.rs b/query-compiler/query-builders/sql-query-builder/src/join_utils.rs
@@ -24,7 +24,7 @@ pub(crate) fn compute_aggr_join(
     previous_join: Option<&str>,
     ctx: &Context<'_>,
 ) -> AliasedJoin {
-    let join_alias = format!("{}_{}", join_alias, rf.related_model().name());
+    let join_alias = format!("{join_alias}_{}", rf.related_model().name());
 
     if rf.relation().is_many_to_many() {
         compute_aggr_join_m2m(
diff --git a/query-compiler/query-structure/src/record.rs b/query-compiler/query-structure/src/record.rs
@@ -240,7 +240,7 @@ impl Record {
             Err(DomainError::FieldNotFound {
                 name: field.to_string(),
                 container_type: "field",
-                container_name: format!("Record values: {:?}. Field names: {:?}.", self, field_names),
+                container_name: format!("Record values: {self:?}. Field names: {field_names:?}."),
             })
         })?;
 
diff --git a/query-compiler/request-handlers/src/protocols/json/protocol_adapter.rs b/query-compiler/request-handlers/src/protocols/json/protocol_adapter.rs
@@ -146,7 +146,7 @@ impl<'a> JsonProtocolAdapter<'a> {
     }
 
     fn convert_argument(value: JsonValue) -> crate::Result<ArgumentValue> {
-        let err_message = format!("Could not convert argument value {:?} to ArgumentValue.", value);
+        let err_message = format!("Could not convert argument value {value:?} to ArgumentValue.");
         let build_err = || HandlerError::query_conversion(err_message.clone());
 
         match value {
diff --git a/query-engine/connector-test-kit-rs/qe-setup/src/driver_adapters.rs b/query-engine/connector-test-kit-rs/qe-setup/src/driver_adapters.rs
@@ -31,7 +31,7 @@ pub enum DriverAdapter {
 impl From<String> for DriverAdapter {
     fn from(s: String) -> Self {
         let s = s.as_str();
-        serde_json::from_str(s).unwrap_or_else(|_| panic!("Unknown driver adapter: {}", s))
+        serde_json::from_str(s).unwrap_or_else(|_| panic!("Unknown driver adapter: {s}"))
     }
 }
 
diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_expression.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_expression.rs
@@ -32,7 +32,7 @@ impl IntoUpdateExpression for GenericOperation {
 impl IntoUpdateExpressions for Upsert {
     fn into_update_expressions(self) -> crate::Result<Vec<UpdateExpression>> {
         let should_set_id = format!("__prisma_should_set__{}", self.field_path.identifier());
-        let should_set_ref_id = format!("${}", should_set_id);
+        let should_set_ref_id = format!("${should_set_id}");
 
         let mut expressions: Vec<UpdateExpression> = vec![];
 
@@ -94,9 +94,9 @@ impl IntoUpdateExpression for UpdateMany {
         // The alias that will be used in the `$map` operation
         let elem_alias = self.elem_alias.clone();
         // A reference to that alias
-        let ref_elem_alias = format!("$${}", elem_alias);
+        let ref_elem_alias = format!("$${elem_alias}");
 
-        let (filter_doc, _) = filter::MongoFilterVisitor::new(format!("${}", elem_alias), false)
+        let (filter_doc, _) = filter::MongoFilterVisitor::new(format!("${elem_alias}"), false)
             .visit(self.filter.clone())?
             .render();
 
diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs
@@ -102,7 +102,7 @@ impl IntoUpdateOperation for CompositeWriteOperation {
             }
             CompositeWriteOperation::DeleteMany { filter } => {
                 let elem_alias = format!("{}_item", path.identifier());
-                let (filter_doc, _) = filter::MongoFilterVisitor::new(format!("${}", elem_alias), true)
+                let (filter_doc, _) = filter::MongoFilterVisitor::new(format!("${elem_alias}"), true)
                     .visit(filter)?
                     .render();
 
diff --git a/schema-engine/cli/tests/cli_tests.rs b/schema-engine/cli/tests/cli_tests.rs
@@ -458,7 +458,7 @@ fn basic_jsonrpc_roundtrip_works_with_params(_api: TestApi) {
                 })
                 .to_string();
 
-                writeln!(stdin, "{}", params_template).unwrap();
+                writeln!(stdin, "{params_template}").unwrap();
 
                 let mut response = String::new();
                 stdout.read_line(&mut response).unwrap();
@@ -928,7 +928,7 @@ fn get_database_version_multi_file(_api: TestApi) {
                 })
                 .to_string();
 
-                writeln!(stdin, "{}", params_template).unwrap();
+                writeln!(stdin, "{params_template}").unwrap();
 
                 let mut response = String::new();
                 stdout.read_line(&mut response).unwrap();
diff --git a/schema-engine/connectors/sql-schema-connector/src/flavour/postgres/renderer.rs b/schema-engine/connectors/sql-schema-connector/src/flavour/postgres/renderer.rs
diff --git a/schema-engine/sql-schema-describer/src/getters.rs b/schema-engine/sql-schema-describer/src/getters.rs

Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ mod test {`
`98`	`98`	`for (val, expected) in test_cases {`
`99`	`99`	`let actual = value_to_js_arg(&val.clone().into_value()).unwrap();`
`100`	`100`	`if actual != expected {`
`101`		`- errors.push(format!("transforming: {:?}, expected: {:?}, actual: {:?}", val, expected, actual));`
	`101`	`+ errors.push(format!("transforming: {val:?}, expected: {expected:?}, actual: {actual:?}"));`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`	`assert_eq!(errors.len(), 0, "{}", errors.join("\n"));`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ mod test {`
`100`	`100`	`for (val, expected) in test_cases {`
`101`	`101`	`let actual = value_to_js_arg(&val).unwrap();`
`102`	`102`	`if actual != expected {`
`103`		`- errors.push(format!("transforming: {:?}, expected: {:?}, actual: {:?}", val, expected, actual));`
	`103`	`+ errors.push(format!("transforming: {val:?}, expected: {expected:?}, actual: {actual:?}"));`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`assert_eq!(errors.len(), 0, "{}", errors.join("\n"));`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ mod test {`
`105`	`105`	`for (val, expected) in test_cases {`
`106`	`106`	`let actual = value_to_js_arg(&val.clone().into_value()).unwrap();`
`107`	`107`	`if actual != expected {`
`108`		`- errors.push(format!("transforming: {:?}, expected: {:?}, actual: {:?}", val, expected, actual));`
	`108`	`+ errors.push(format!("transforming: {val:?}, expected: {expected:?}, actual: {actual:?}"));`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`assert_eq!(errors.len(), 0, "{}", errors.join("\n"));`
Original file line number	Diff line number	Diff line change
`@@ -115,8 +115,7 @@ impl WarningAsserts for Vec<DatamodelWarning> {`
`115`	`115`	`assert_eq!(`
`116`	`116`	`self.len(),`
`117`	`117`	`1,`
`118`		`- "Expected exactly one validation warning. Warnings are: {:?}",`
`119`		`- self`
	`118`	`+ "Expected exactly one validation warning. Warnings are: {self:?}"`
`120`	`119`	`);`
`121`	`120`	`assert_eq!(self[0], warning);`
`122`	`121`	`self`
`@@ -696,7 +695,7 @@ impl DefaultValueAssert for ast::Expression {`
`696`	`695`	panic!("Expected a numeric value for the `cuid()` version.");
`697`	`696`	`}`
`698`	`697`	`} else {`
`699`		- panic!("Expected `cuid()` to be a function, got {}", self);
	`698`	+ panic!("Expected `cuid()` to be a function, got {self}");
`700`	`699`	`}`
`701`	`700`
`702`	`701`	`self`
`@@ -720,7 +719,7 @@ impl DefaultValueAssert for ast::Expression {`
`720`	`719`	panic!("Expected a numeric value for the `uuid()` version.");
`721`	`720`	`}`
`722`	`721`	`} else {`
`723`		- panic!("Expected `cuid()` to be a function, got {}", self);
	`722`	+ panic!("Expected `cuid()` to be a function, got {self}");
`724`	`723`	`}`
`725`	`724`
`726`	`725`	`self`