Add multiple build tasks and compilers

Author: ruben-arts

Cargo.lock

@@ -1,17 +1,30 @@
+use crate::config::BuildTask;
 use serde::Serialize;
 
 #[derive(Serialize)]
 pub struct BuildScriptContext {
-    pub build_task: String,
+    pub build_tasks: Vec<BuildTask>,
     pub manifest_root: std::path::PathBuf,
 }
 
 impl BuildScriptContext {
     pub fn render(&self) -> String {
-        format!(
-            "pixi run --as-is --manifest-path {} {}",
-            self.manifest_root.to_string_lossy(),
-            self.build_task
-        )
+        self.build_tasks
+            .iter()
+            .map(|build_task| {
+                let env_arg = build_task
+                    .environment
+                    .as_ref()
+                    .map(|env| format!(" -e {}", env))
+                    .unwrap_or_default();
+                format!(
+                    "pixi run --as-is --manifest-path {}{}  {}",
+                    self.manifest_root.to_string_lossy(),
+                    env_arg,
+                    build_task.task
+                )
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
     }
 }

crates/pixi-build-pixi/src/build_script.rs

@@ -4,6 +4,16 @@ use indexmap::IndexMap;
 use pixi_build_backend::generated_recipe::BackendConfig;
 use serde::{Deserialize, Serialize};
 
+/// A build task with optional environment specification
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct BuildTask {
+    /// Name of the task to run
+    pub task: String,
+    /// Optional environment to run the task in
+    pub environment: Option<String>,
+}
+
 #[derive(Debug, Default, Deserialize, Serialize, Clone)]
 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub struct PixiBackendConfig {
@@ -15,13 +25,12 @@ pub struct PixiBackendConfig {
     /// Extra input globs to include in addition to the default ones
     #[serde(default)]
     pub extra_input_globs: Vec<String>,
-    /// Name of the build task in pixi.toml (defaults to "build")
-    #[serde(default = "default_build_task")]
-    pub build_task: String,
-}
-
-fn default_build_task() -> String {
-    "build".to_string()
+    /// Build tasks to run in order, each with optional environment
+    #[serde(default)]
+    pub build_tasks: Vec<BuildTask>,
+    /// List of compilers to use (e.g., ["c", "cxx", "cuda"])
+    /// If not specified, no compilers will be added
+    pub compilers: Option<Vec<String>>,
 }
 
 impl BackendConfig for PixiBackendConfig {
@@ -53,11 +62,15 @@ impl BackendConfig for PixiBackendConfig {
             } else {
                 target_config.extra_input_globs.clone()
             },
-            build_task: if target_config.build_task == default_build_task() {
-                self.build_task.clone()
+            build_tasks: if target_config.build_tasks.is_empty() {
+                self.build_tasks.clone()
             } else {
-                target_config.build_task.clone()
+                target_config.build_tasks.clone()
             },
+            compilers: target_config
+                .compilers
+                .clone()
+                .or_else(|| self.compilers.clone()),
         })
     }
 }

crates/pixi-build-pixi/src/config.rs

@@ -5,12 +5,13 @@ use build_script::BuildScriptContext;
 use config::PixiBackendConfig;
 use miette::IntoDiagnostic;
 use pixi_build_backend::{
+    ProjectModel,
     generated_recipe::{DefaultMetadataProvider, GenerateRecipe, GeneratedRecipe, PythonParams},
     intermediate_backend::IntermediateBackendInstantiator,
 };
 use rattler_build::{NormalizedKey, recipe::variable::Variable};
-use rattler_conda_types::{PackageName, Platform};
-use recipe_stage0::recipe::{ConditionalRequirements, Script};
+use rattler_conda_types::{ChannelUrl, Platform};
+use recipe_stage0::recipe::Script;
 use std::collections::HashSet;
 use std::{
     collections::{BTreeMap, BTreeSet},
@@ -31,30 +32,33 @@ impl GenerateRecipe for PixiGenerator {
         manifest_root: std::path::PathBuf,
         host_platform: rattler_conda_types::Platform,
         _python_params: Option<PythonParams>,
-        _variants: &HashSet<NormalizedKey>,
+        variants: &HashSet<NormalizedKey>,
+        _channels: Vec<ChannelUrl>,
     ) -> miette::Result<GeneratedRecipe> {
         let mut generated_recipe =
             GeneratedRecipe::from_model(model.clone(), &mut DefaultMetadataProvider)
                 .into_diagnostic()?;
 
         let requirements = &mut generated_recipe.recipe.requirements;
 
-        let resolved_requirements = ConditionalRequirements::resolve(
-            requirements.build.as_ref(),
-            requirements.host.as_ref(),
-            requirements.run.as_ref(),
-            requirements.run_constraints.as_ref(),
-            Some(host_platform),
-        );
-
-        // Add pixi as a build dependency
-        let pixi_name = PackageName::new_unchecked("pixi");
-        if !resolved_requirements.build.contains_key(&pixi_name) {
-            requirements.build.push("pixi".parse().into_diagnostic()?);
+        // Add compilers if configured
+        if let Some(compilers) = &config.compilers {
+            let model_dependencies = model.dependencies(Some(host_platform));
+            pixi_build_backend::compilers::add_compilers_to_requirements(
+                compilers,
+                &mut requirements.build,
+                &model_dependencies,
+                &host_platform,
+            );
+            pixi_build_backend::compilers::add_stdlib_to_requirements(
+                compilers,
+                &mut requirements.build,
+                variants,
+            );
         }
 
         let build_script = BuildScriptContext {
-            build_task: config.build_task.clone(),
+            build_tasks: config.build_tasks.clone(),
             manifest_root,
         }
         .render();