chore: update rust to 1.89.0 (#5587)

Update Rust to 1.89.0 and fix new compiler and clippy warnings.

Author: aqrln

libs/query-engine-common/src/tracer.rs

@@ -29,12 +29,12 @@ pub async fn start_trace(
         .and_then(|tc| tc.traceparent)
         .and_then(|tp| tp.parse::<TraceParent>().ok());
 
-    if let Some(traceparent) = traceparent {
-        if traceparent.sampled() {
-            exporter
-                .start_capturing(request_id, CaptureSettings::new(CaptureTarget::Spans))
-                .await;
-        }
+    if let Some(traceparent) = traceparent
+        && traceparent.sampled()
+    {
+        exporter
+            .start_capturing(request_id, CaptureSettings::new(CaptureTarget::Spans))
+            .await;
     }
 
     Ok(traceparent)

libs/telemetry/src/exporter.rs

@@ -200,18 +200,18 @@ impl Exporter {
                     }
 
                     Message::AddSpan(request_id, span) => {
-                        if let Some(trace) = traces.get_mut(&request_id) {
-                            if trace.settings.filter(CaptureTarget::Spans) {
-                                trace.data.spans.push(span.into());
-                            }
+                        if let Some(trace) = traces.get_mut(&request_id)
+                            && trace.settings.filter(CaptureTarget::Spans)
+                        {
+                            trace.data.spans.push(span.into());
                         }
                     }
 
                     Message::AddEvent(request_id, event) => {
-                        if let Some(trace) = traces.get_mut(&request_id) {
-                            if trace.settings.filter(event.level.into()) {
-                                trace.data.events.push(event.into());
-                            }
+                        if let Some(trace) = traces.get_mut(&request_id)
+                            && trace.settings.filter(event.level.into())
+                        {
+                            trace.data.events.push(event.into());
                         }
                     }
                 }

prisma-fmt/src/code_actions/block.rs

@@ -48,17 +48,17 @@ pub(super) fn create_missing_block_for_model(
             model.newline(),
         );
 
-        if let Some(ds) = context.datasource() {
-            if ds.active_provider == "mongodb" {
-                push_missing_block(
-                    diag,
-                    context.params.text_document.uri.clone(),
-                    range,
-                    "type",
-                    actions,
-                    model.newline(),
-                );
-            }
+        if let Some(ds) = context.datasource()
+            && ds.active_provider == "mongodb"
+        {
+            push_missing_block(
+                diag,
+                context.params.text_document.uri.clone(),
+                range,
+                "type",
+                actions,
+                model.newline(),
+            );
         }
     })
 }

prisma-fmt/src/text_document_completion.rs

@@ -112,16 +112,16 @@ fn push_ast_completions(ctx: CompletionContext<'_>, completion_list: &mut Comple
                 ast::FieldPosition::Attribute("relation", _, AttributePosition::ArgumentValue(attr_name, value)),
             ),
         ) => {
-            if let Some(attr_name) = attr_name {
-                if attr_name == "onDelete" || attr_name == "onUpdate" {
-                    ctx.connector()
-                        .referential_actions(&relation_mode)
-                        .iter()
-                        .filter(|ref_action| ref_action.to_string().starts_with(&value))
-                        .for_each(|referential_action| {
-                            referential_actions::referential_action_completion(completion_list, referential_action)
-                        });
-                }
+            if let Some(attr_name) = attr_name
+                && (attr_name == "onDelete" || attr_name == "onUpdate")
+            {
+                ctx.connector()
+                    .referential_actions(&relation_mode)
+                    .iter()
+                    .filter(|ref_action| ref_action.to_string().starts_with(&value))
+                    .for_each(|referential_action| {
+                        referential_actions::referential_action_completion(completion_list, referential_action)
+                    });
             }
         }
 

psl/parser-database/src/attributes.rs

@@ -802,16 +802,16 @@ fn visit_relation(model_id: crate::ModelId, relation_field_id: RelationFieldId,
     }
 
     // Validate referential actions.
-    if let Some(on_delete) = ctx.visit_optional_arg("onDelete") {
-        if let Some(action) = crate::ReferentialAction::try_from_expression(on_delete, ctx.diagnostics) {
-            ctx.types[relation_field_id].on_delete = Some((action, on_delete.span()));
-        }
+    if let Some(on_delete) = ctx.visit_optional_arg("onDelete")
+        && let Some(action) = crate::ReferentialAction::try_from_expression(on_delete, ctx.diagnostics)
+    {
+        ctx.types[relation_field_id].on_delete = Some((action, on_delete.span()));
     }
 
-    if let Some(on_update) = ctx.visit_optional_arg("onUpdate") {
-        if let Some(action) = crate::ReferentialAction::try_from_expression(on_update, ctx.diagnostics) {
-            ctx.types[relation_field_id].on_update = Some((action, on_update.span()));
-        }
+    if let Some(on_update) = ctx.visit_optional_arg("onUpdate")
+        && let Some(action) = crate::ReferentialAction::try_from_expression(on_update, ctx.diagnostics)
+    {
+        ctx.types[relation_field_id].on_update = Some((action, on_update.span()));
     }
 
     let fk_name = {

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

@@ -119,19 +119,19 @@ impl ConstraintNames {
         connector: &dyn Connector,
         double_at: bool,
     ) -> Option<DatamodelError> {
-        if let Some(name) = name {
-            if name.len() > connector.max_identifier_length() {
-                let ats = if double_at { "@@" } else { "@" };
-                return Some(DatamodelError::new_model_validation_error(
-                    &format!(
-                        "The constraint name '{name}' specified in the `map` argument for the `{ats}{attribute}` constraint is too long for your chosen provider. The maximum allowed length is {} bytes.",
-                        connector.max_identifier_length()
-                    ),
-                    "model",
-                    object_name,
-                    span,
-                ));
-            }
+        if let Some(name) = name
+            && name.len() > connector.max_identifier_length()
+        {
+            let ats = if double_at { "@@" } else { "@" };
+            return Some(DatamodelError::new_model_validation_error(
+                &format!(
+                    "The constraint name '{name}' specified in the `map` argument for the `{ats}{attribute}` constraint is too long for your chosen provider. The maximum allowed length is {} bytes.",
+                    connector.max_identifier_length()
+                ),
+                "model",
+                object_name,
+                span,
+            ));
         }
         None
     }

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

@@ -179,13 +179,13 @@ fn lift_datasource(
     };
 
     if let Some((shadow_url, _)) = &shadow_database_url {
-        if let (Some(direct_url), Some(direct_url_span)) = (&direct_url, direct_url_span) {
-            if shadow_url == direct_url {
-                diagnostics.push_error(DatamodelError::new_shadow_database_is_same_as_direct_url_error(
-                    source_name,
-                    direct_url_span,
-                ));
-            }
+        if let (Some(direct_url), Some(direct_url_span)) = (&direct_url, direct_url_span)
+            && shadow_url == direct_url
+        {
+            diagnostics.push_error(DatamodelError::new_shadow_database_is_same_as_direct_url_error(
+                source_name,
+                direct_url_span,
+            ));
         }
 
         if shadow_url == &url {

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

@@ -61,15 +61,15 @@ fn lift_generator(
         .collect::<Option<HashMap<_, _>>>()?;
 
     // E.g., "library"
-    if let Some(expr) = args.get(ENGINE_TYPE_KEY) {
-        if !expr.is_string() {
-            diagnostics.push_error(DatamodelError::new_type_mismatch_error(
-                "String",
-                expr.describe_value_type(),
-                &expr.to_string(),
-                expr.span(),
-            ))
-        }
+    if let Some(expr) = args.get(ENGINE_TYPE_KEY)
+        && !expr.is_string()
+    {
+        diagnostics.push_error(DatamodelError::new_type_mismatch_error(
+            "String",
+            expr.describe_value_type(),
+            &expr.to_string(),
+            expr.span(),
+        ))
     }
 
     // E.g., "prisma-client-js"

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

@@ -123,10 +123,10 @@ pub(crate) fn validate_length_used_with_correct_types(
         return;
     }
 
-    if let Some(r#type) = attr.as_index_field().scalar_field_type().as_builtin_scalar() {
-        if [ScalarType::String, ScalarType::Bytes].iter().any(|t| t == &r#type) {
-            return;
-        }
+    if let Some(r#type) = attr.as_index_field().scalar_field_type().as_builtin_scalar()
+        && [ScalarType::String, ScalarType::Bytes].iter().any(|t| t == &r#type)
+    {
+        return;
     };
 
     let message = "The length argument is only allowed with field types `String` or `Bytes`.";
@@ -148,16 +148,16 @@ pub(super) fn validate_native_type_arguments<'db>(field: impl Into<TypedFieldWal
     };
 
     // Validate that the attribute is scoped with the right datasource name.
-    if let Some(datasource) = ctx.datasource {
-        if datasource.name != attr_scope {
-            let suggestion = [datasource.name.as_str(), type_name].join(".");
-            ctx.push_error(DatamodelError::new_invalid_prefix_for_native_types(
-                attr_scope,
-                &datasource.name,
-                &suggestion,
-                span,
-            ));
-        }
+    if let Some(datasource) = ctx.datasource
+        && datasource.name != attr_scope
+    {
+        let suggestion = [datasource.name.as_str(), type_name].join(".");
+        ctx.push_error(DatamodelError::new_invalid_prefix_for_native_types(
+            attr_scope,
+            &datasource.name,
+            &suggestion,
+            span,
+        ));
     }
 
     let constructor = if let Some(cons) = ctx.connector.find_native_type_constructor(type_name) {

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

@@ -48,24 +48,23 @@ pub(super) fn unique_index_has_a_unique_custom_name_per_model(
 ) {
     let model = index.model();
 
-    if let Some(name) = index.name() {
-        if names
+    if let Some(name) = index.name()
+        && names
             .constraint_namespace
             .local_custom_name_scope_violations(model.id, name.as_ref())
-        {
-            let message = format!(
-                "The given custom name `{name}` has to be unique on the model. Please provide a different name for the `name` argument."
-            );
-
-            let from_arg = index.ast_attribute().span_for_argument("name");
-            let span = from_arg.unwrap_or(index.ast_attribute().span);
-
-            ctx.push_error(DatamodelError::new_attribute_validation_error(
-                &message,
-                index.attribute_name(),
-                span,
-            ));
-        }
+    {
+        let message = format!(
+            "The given custom name `{name}` has to be unique on the model. Please provide a different name for the `name` argument."
+        );
+
+        let from_arg = index.ast_attribute().span_for_argument("name");
+        let span = from_arg.unwrap_or(index.ast_attribute().span);
+
+        ctx.push_error(DatamodelError::new_attribute_validation_error(
+            &message,
+            index.attribute_name(),
+            span,
+        ));
     }
 }
 
@@ -270,14 +269,14 @@ pub(crate) fn clustering_can_be_defined_only_once(index: IndexWalker<'_>, ctx: &
         return;
     }
 
-    if let Some(pk) = index.model().primary_key() {
-        if matches!(pk.clustered(), Some(true) | None) {
-            ctx.push_error(DatamodelError::new_attribute_validation_error(
-                "A model can only hold one clustered index or key.",
-                index.attribute_name(),
-                index.ast_attribute().span,
-            ));
-        }
+    if let Some(pk) = index.model().primary_key()
+        && matches!(pk.clustered(), Some(true) | None)
+    {
+        ctx.push_error(DatamodelError::new_attribute_validation_error(
+            "A model can only hold one clustered index or key.",
+            index.attribute_name(),
+            index.ast_attribute().span,
+        ));
     }
 
     for other in index.model().indexes() {