chore: move to edition 2024

This will enable us to use let chains in the future among other things: rust-lang/rust#132833

Author: Hofer-Julian

Cargo.toml

@@ -8,7 +8,7 @@ members = ["crates/*"]
 
 [workspace.package]
 authors = ["pixi contributors <[email protected]>"]
-edition = "2021"
+edition = "2024"
 homepage = "https://github.com/prefix-dev/pixi"
 license = "BSD-3-Clause"
 readme = "README.md"

crates/pixi_allocator/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 description = "A crate that provides the best memory allocator for different platforms"
-edition = "2021"
 name = "pixi_allocator"
 version = "0.1.0"
 

crates/pixi_build_frontend/src/backend_override.rs

@@ -202,7 +202,9 @@ mod tests {
 
     #[test]
     fn test_invalid_format() {
-        let input = format!("pixi-build-python{EQUALS}/some/path/to/custom-build{SEPARATOR}invalid{EQUALS}tool{EQUALS}extra");
+        let input = format!(
+            "pixi-build-python{EQUALS}/some/path/to/custom-build{SEPARATOR}invalid{EQUALS}tool{EQUALS}extra"
+        );
         let parsed = OverriddenBackends::from_str(input.as_str());
         assert!(parsed.is_err());
     }

crates/pixi_build_frontend/src/build_frontend.rs

@@ -5,10 +5,9 @@ use miette::Diagnostic;
 use rattler_conda_types::ChannelConfig;
 
 use crate::{
-    protocol,
+    SetupRequest, ToolContext, protocol,
     protocol_builder::{EnabledProtocols, ProtocolBuilder},
     protocols::JsonRPCBuildProtocol,
-    SetupRequest, ToolContext,
 };
 
 /// The frontend for building packages.

crates/pixi_build_frontend/src/jsonrpc/mod.rs

@@ -3,7 +3,7 @@ use serde::Serialize;
 use serde_json::value::RawValue;
 
 mod stdio;
-pub(crate) use stdio::{stdio_transport, Receiver, Sender};
+pub(crate) use stdio::{Receiver, Sender, stdio_transport};
 
 /// A helper struct to convert a serializable type into a JSON-RPC parameter.
 pub struct RpcParams<T>(pub T);

crates/pixi_build_frontend/src/lib.rs

@@ -6,8 +6,8 @@ mod protocols;
 
 use std::fmt::{Debug, Formatter};
 
-pub use protocols::builders::{pixi_protocol, rattler_build_protocol};
 pub use protocols::JsonRPCBuildProtocol;
+pub use protocols::builders::{pixi_protocol, rattler_build_protocol};
 
 mod protocol_builder;
 mod reporters;

crates/pixi_build_frontend/src/protocol_builder.rs

@@ -7,11 +7,12 @@ use std::{
 use rattler_conda_types::ChannelConfig;
 
 use crate::{
+    BuildFrontendError, ToolContext,
     backend_override::BackendOverride,
     pixi_protocol,
     protocol::{DiscoveryError, FinishError},
     protocols::JsonRPCBuildProtocol,
-    rattler_build_protocol, BuildFrontendError, ToolContext,
+    rattler_build_protocol,
 };
 
 /// Configuration to enable or disable certain protocols discovery.

crates/pixi_build_frontend/src/protocols/builders/pixi.rs

@@ -14,11 +14,11 @@ use thiserror::Error;
 use which::Error;
 
 use crate::{
+    InProcessBackend, ToolContext,
     backend_override::BackendOverride,
     jsonrpc::{Receiver, Sender},
     protocols::{InitializeError, JsonRPCBuildProtocol},
     tool::{IsolatedToolSpec, ToolCacheError, ToolSpec},
-    InProcessBackend, ToolContext,
 };
 
 /// A protocol that uses a pixi manifest to invoke a build backend .
@@ -60,14 +60,37 @@ impl Display for FinishError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
             FinishError::Init(init) => write!(f, "{init}"),
-            FinishError::NoBuildSection(_) => write!(f, "failed to setup a build backend, the project manifest does not contain a [build-system] section"),
+            FinishError::NoBuildSection(_) => write!(
+                f,
+                "failed to setup a build backend, the project manifest does not contain a [build-system] section"
+            ),
             FinishError::Tool(ToolCacheError::Instantiate(tool, err)) => match err {
-                Error::CannotGetCurrentDirAndPathListEmpty | Error::CannotFindBinaryPath => write!(f, "failed to setup a build backend, the backend tool '{}' could not be found", tool.display()),
-                Error::CannotCanonicalize => write!(f, "failed to setup a build backend, although the backend tool  '{}' can be resolved it could not be canonicalized", tool.display()),
+                Error::CannotGetCurrentDirAndPathListEmpty | Error::CannotFindBinaryPath => write!(
+                    f,
+                    "failed to setup a build backend, the backend tool '{}' could not be found",
+                    tool.display()
+                ),
+                Error::CannotCanonicalize => write!(
+                    f,
+                    "failed to setup a build backend, although the backend tool  '{}' can be resolved it could not be canonicalized",
+                    tool.display()
+                ),
             },
-            FinishError::Tool(ToolCacheError::Install(report)) => write!(f, "failed to setup a build backend, the backend tool could not be installed: {}", report),
-            FinishError::Tool(ToolCacheError::CacheDir(report)) => write!(f, "failed to setup a build backend, the cache dir could not be discovered: {}", report),
-            FinishError::SpecConversionError(err) => write!(f, "failed to setup a build backend, the backend tool spec could not be converted: {}", err),
+            FinishError::Tool(ToolCacheError::Install(report)) => write!(
+                f,
+                "failed to setup a build backend, the backend tool could not be installed: {}",
+                report
+            ),
+            FinishError::Tool(ToolCacheError::CacheDir(report)) => write!(
+                f,
+                "failed to setup a build backend, the cache dir could not be discovered: {}",
+                report
+            ),
+            FinishError::SpecConversionError(err) => write!(
+                f,
+                "failed to setup a build backend, the backend tool spec could not be converted: {}",
+                err
+            ),
         }
     }
 }

crates/pixi_build_frontend/src/protocols/builders/rattler_build.rs

@@ -9,10 +9,10 @@ use thiserror::Error;
 
 use super::pixi::ProtocolBuildError as PixiProtocolBuildError;
 use crate::{
+    ToolContext,
     backend_override::BackendOverride,
     protocols::{InitializeError, JsonRPCBuildProtocol},
     tool::{IsolatedToolSpec, ToolCacheError, ToolSpec},
-    ToolContext,
 };
 
 const DEFAULT_BUILD_TOOL: &str = "pixi-build-rattler-build";
@@ -26,7 +26,8 @@ pub enum FinishError {
     #[diagnostic(transparent)]
     Init(#[from] InitializeError),
 
-    #[error("failed to setup a build backend, the project manifest at {0} does not contain a [build] section"
+    #[error(
+        "failed to setup a build backend, the project manifest at {0} does not contain a [build] section"
     )]
     NoBuildSection(PathBuf),
 }

crates/pixi_build_frontend/src/protocols/mod.rs

@@ -10,22 +10,22 @@ use futures::TryFutureExt;
 use jsonrpsee::{
     async_client::{Client, ClientBuilder},
     core::{
-        client::{ClientT, Error, TransportReceiverT, TransportSenderT},
         ClientError,
+        client::{ClientT, Error, TransportReceiverT, TransportSenderT},
     },
     types::ErrorCode,
 };
 use miette::Diagnostic;
 use pixi_build_type_conversions::to_project_model_v1;
 use pixi_build_types::{
+    BackendCapabilities, FrontendCapabilities,
     procedures::{
         self,
         conda_build::{CondaBuildParams, CondaBuildResult},
         conda_metadata::{CondaMetadataParams, CondaMetadataResult},
         initialize::{InitializeParams, InitializeResult},
         negotiate_capabilities::{NegotiateCapabilitiesParams, NegotiateCapabilitiesResult},
     },
-    BackendCapabilities, FrontendCapabilities,
 };
 use pixi_manifest::PackageManifest;
 use rattler_conda_types::ChannelConfig;
@@ -34,14 +34,14 @@ use thiserror::Error;
 use tokio::{
     io::{AsyncBufReadExt, BufReader, Lines},
     process::ChildStderr,
-    sync::{oneshot, Mutex},
+    sync::{Mutex, oneshot},
 };
 
 use crate::{
-    jsonrpc::{stdio_transport, RpcParams},
+    CondaBuildReporter, CondaMetadataReporter,
+    jsonrpc::{RpcParams, stdio_transport},
     protocols::stderr::stderr_buffer,
     tool::Tool,
-    CondaBuildReporter, CondaMetadataReporter,
 };
 
 pub mod builders;
@@ -60,7 +60,9 @@ pub enum BuildBackendSetupError {
 #[derive(Debug, Error, Diagnostic)]
 pub enum InitializeError {
     #[error("failed to setup communication with the build-backend")]
-    #[diagnostic(help("This is often caused by a broken build-backend. Try upgrading or downgrading the build backend."))]
+    #[diagnostic(help(
+        "This is often caused by a broken build-backend. Try upgrading or downgrading the build backend."
+    ))]
     Setup(
         #[diagnostic_source]
         #[from]

crates/pixi_build_frontend/src/protocols/stderr.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use tokio::{
     io::{BufReader, Lines},
     process::ChildStderr,
-    sync::{mpsc, oneshot, Mutex},
+    sync::{Mutex, mpsc, oneshot},
 };
 
 /// Stderr stream that captures the stderr output of the backend

crates/pixi_build_frontend/src/tool/cache.rs

@@ -16,7 +16,7 @@ use rattler_shell::{
 };
 use tokio::sync::broadcast;
 
-use super::{installer::ToolInstaller, IsolatedTool};
+use super::{IsolatedTool, installer::ToolInstaller};
 use crate::IsolatedToolSpec;
 
 /// A entity that is either pending or has been fetched.
@@ -302,12 +302,12 @@ mod tests {
     use tokio::sync::{Barrier, Mutex, Semaphore};
 
     use crate::{
+        IsolatedToolSpec,
         tool::{
-            cache::{find_spec_records, ToolCache},
-            installer::{ToolContext, ToolInstaller},
             IsolatedTool, ToolSpec,
+            cache::{ToolCache, find_spec_records},
+            installer::{ToolContext, ToolInstaller},
         },
-        IsolatedToolSpec,
     };
 
     const BAT_META_JSON: &str = "bat-0.24.0-h3bba108_1.json";

crates/pixi_build_frontend/src/tool/installer.rs

@@ -8,18 +8,18 @@ use rattler_shell::{
     activation::{ActivationVariables, Activator},
     shell::ShellEnum,
 };
-use rattler_solve::{resolvo::Solver, SolverImpl, SolverTask};
+use rattler_solve::{SolverImpl, SolverTask, resolvo::Solver};
 use rattler_virtual_packages::{VirtualPackage, VirtualPackageOverrides};
 use reqwest_middleware::ClientWithMiddleware;
 use std::fmt::Debug;
 use std::future::Future;
 use std::path::PathBuf;
 
 use super::{
-    cache::ToolCache, IsolatedTool, IsolatedToolSpec, SystemTool, Tool, ToolCacheError, ToolSpec,
+    IsolatedTool, IsolatedToolSpec, SystemTool, Tool, ToolCacheError, ToolSpec, cache::ToolCache,
 };
 
-use miette::{miette, IntoDiagnostic};
+use miette::{IntoDiagnostic, miette};
 
 /// A trait that is responsible for installing tools.
 pub trait ToolInstaller {

crates/pixi_build_frontend/tests/diagnostics.rs

@@ -5,9 +5,9 @@ use futures::{SinkExt, StreamExt};
 use miette::{Diagnostic, GraphicalReportHandler, GraphicalTheme};
 use pixi_build_frontend::{BuildFrontend, InProcessBackend, SetupRequest, ToolContext};
 use pixi_manifest::{
-    toml::{ExternalWorkspaceProperties, FromTomlStr, TomlManifest},
     BuildBackend, KnownPreviewFeature, Package, PackageBuild, PackageManifest, Preview, Workspace,
     WorkspaceManifest,
+    toml::{ExternalWorkspaceProperties, FromTomlStr, TomlManifest},
 };
 use pixi_spec::BinarySpec;
 use rattler_conda_types::{NamedChannelOrUrl, PackageName, Platform};

crates/pixi_build_types/src/project_model.rs

@@ -20,10 +20,10 @@ use std::path::PathBuf;
 
 use indexmap::IndexMap;
 use rattler_conda_types::{BuildNumberSpec, StringMatcher, Version, VersionSpec};
-use rattler_digest::{serde::SerializableHash, Md5, Md5Hash, Sha256, Sha256Hash};
+use rattler_digest::{Md5, Md5Hash, Sha256, Sha256Hash, serde::SerializableHash};
 use serde::{Deserialize, Serialize};
-use serde_with::serde_as;
 use serde_with::DisplayFromStr;
+use serde_with::serde_as;
 use url::Url;
 
 /// Enum containing all versions of the project model.