fix: evaluate conditionals properly (#450)

* fix: properly handle target-specific dependencies in backends

The backends were incorrectly trying to evaluate rattler-build selector
expressions (like `host_platform == 'linux-64'`) using simple string
comparison against platform strings (like `"linux-64"`), which always
failed. This meant target-specific dependencies were never properly
resolved.

Changes:
- Use ProjectModel::dependencies() with platform parameter to get
  properly filtered dependencies instead of manually resolving selectors
- Add Contains trait and implementations for checking package names in
  dependency maps
- Add Dependencies::build_and_host_names() helper method for getting
  package names from build and host dependencies
- Update all backends (python, rust, cmake, mojo) to use the new
  approach
- Remove unused ConditionalRequirements::resolve() calls
- Clean up unused imports

This fixes the issue reported in prefix-dev/pixi#4802 where
target-specific dependencies were not being injected into the generated
recipes.

* refactor: simplify compiler requirements function to accept Dependencies directly

- Replace generic add_compilers_to_requirements_by_name with add_compilers_to_requirements_with_dependencies
- Pass Dependencies struct directly instead of using Contains trait
- Fix Python check in cmake backend to only check host dependencies
- Add unit tests for target-specific dependency handling
- Tests verify that ProjectModel.dependencies() correctly filters deps by platform

* test: improve target-specific dependency tests to verify actual conditions

- Check that conditional items contain the correct package name (openssl/gcc)
- Verify the condition matches the expected platform selector
- Tests now properly validate that linux-64 conditions include linux-64 deps
- Tests now properly validate that unix conditions include unix deps

* refactor: remove unused Contains trait and simplify dependency checks

- Remove unused add_compilers_to_requirements and add_compilers_and_stdlib_to_requirements
- Remove Contains trait and all implementations
- Remove Contains imports from all backend files
- Use contains_key with SourcePackageName for dependency checks
- Fix has_openssl to only check host dependencies
- Fix conditional tests to match exact condition strings
- Remove unused boltons dependencies from test fixtures

* fix: use host_platform for all target-specific dependency conditionals

- Change build, host, and run dependencies to all use host_platform
- Update tests to expect host_platform in conditions
- This ensures that target selectors match the actual target platform

* refactor: rename add_compilers_to_requirements_with_dependencies to add_compilers_to_requirements

Since we removed the old add_compilers_to_requirements function, we can now use the simpler name for the Dependencies-based version.

* fixes

* fix formatting and clippy

* Small improvements

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Julian Hofer <julianhofer@gnome.org>

Author: 3 people

crates/pixi-build-backend/src/compilers.rs

@@ -3,10 +3,9 @@
 
 use std::{collections::HashSet, fmt::Display, ops::Deref};
 
-use indexmap::IndexMap;
 use itertools::Itertools;
 use rattler_build::NormalizedKey;
-use rattler_conda_types::{PackageName, Platform};
+use rattler_conda_types::Platform;
 use recipe_stage0::{
     matchspec::PackageDependency,
     recipe::{Item, Value},
@@ -82,40 +81,21 @@ pub fn compiler_requirement(language: &Language) -> Item<PackageDependency> {
 /// # Arguments
 /// * `compilers` - List of compiler names (e.g., ["c", "cxx", "rust", "cuda"])
 /// * `requirements` - Mutable reference to the requirements to modify
-/// * `resolved_build_requirements` - IndexMap of already resolved build
-///   requirements
+/// * `dependencies` - The Dependencies struct containing build/host/run dependencies
 /// * `host_platform` - The target platform for determining default compiler
 ///   names
-/// * `variants` - The variants available in the recipe, used to determine if
-///   stdlib is needed
-pub fn add_compilers_and_stdlib_to_requirements(
+pub fn add_compilers_to_requirements<S>(
     compilers: &[String],
     requirements: &mut Vec<Item<PackageDependency>>,
-    resolved_build_requirements: &IndexMap<PackageName, PackageDependency>,
-    host_platform: &Platform,
-    variants: &HashSet<NormalizedKey>,
-) {
-    add_compilers_to_requirements(
-        compilers,
-        requirements,
-        resolved_build_requirements,
-        host_platform,
-    );
-    add_stdlib_to_requirements(compilers, requirements, variants);
-}
-
-pub fn add_compilers_to_requirements(
-    compilers: &[String],
-    requirements: &mut Vec<Item<PackageDependency>>,
-    resolved_build_requirements: &IndexMap<PackageName, PackageDependency>,
+    dependencies: &crate::traits::targets::Dependencies<S>,
     host_platform: &Platform,
 ) {
     for compiler_str in compilers {
-        // Check if the specific compiler is already present
+        // Check if the specific compiler is already present in build dependencies
         let language_compiler = default_compiler(host_platform, compiler_str);
+        let source_package_name = pixi_build_types::SourcePackageName::from(language_compiler);
 
-        if !resolved_build_requirements.contains_key(&PackageName::new_unchecked(language_compiler))
-        {
+        if !dependencies.build.contains_key(&source_package_name) {
             let template = format!("${{{{ compiler('{compiler_str}') }}}}");
             requirements.push(Item::Value(Value::Template(template)));
         }

crates/pixi-build-backend/src/specs_conversion.rs

@@ -105,15 +105,16 @@ pub fn from_targets_v1_to_conditional_requirements(targets: &TargetsV1) -> Condi
         for (selector, target) in specific_targets {
             let package_requirements = target_to_package_spec(target);
 
-            // add the binary requirements
+            // Add the binary requirements
+            // Use host_platform for all dependency types to match the actual target platform
             build_items.extend(
                 package_requirements
                     .build
                     .into_iter()
                     .map(|spec| spec.1)
                     .map(|spec| {
                         Conditional {
-                            condition: to_rattler_build_selector(selector, PlatformKind::Build),
+                            condition: to_rattler_build_selector(selector, PlatformKind::Host),
                             then: ListOrItem(vec![spec]),
                             else_value: ListOrItem::default(),
                         }
@@ -141,7 +142,7 @@ pub fn from_targets_v1_to_conditional_requirements(targets: &TargetsV1) -> Condi
                     .map(|spec| spec.1)
                     .map(|spec| {
                         Conditional {
-                            condition: to_rattler_build_selector(selector, PlatformKind::Target),
+                            condition: to_rattler_build_selector(selector, PlatformKind::Host),
                             then: ListOrItem(vec![spec]),
                             else_value: ListOrItem::default(),
                         }

crates/pixi-build-backend/src/traits/targets.rs

@@ -59,6 +59,16 @@ impl<'a, S> Dependencies<'a, S> {
     pub fn contains(&self, name: &SourcePackageName) -> bool {
         self.run.contains_key(name) || self.host.contains_key(name) || self.build.contains_key(name)
     }
+
+    /// Return an iterator of all package names from build and host dependencies.
+    /// This is useful for checking build tools and compilers.
+    pub fn build_and_host_names(&self) -> impl Iterator<Item = &str> {
+        self.build
+            .keys()
+            .chain(self.host.keys())
+            .map(|name| name.as_ref() as &str)
+            .unique()
+    }
 }
 
 /// A trait that represent a project target.

crates/pixi-build-cmake/src/main.rs

@@ -5,14 +5,14 @@ use build_script::{BuildPlatform, BuildScriptContext};
 use config::CMakeBackendConfig;
 use miette::IntoDiagnostic;
 use pixi_build_backend::{
-    compilers::add_compilers_and_stdlib_to_requirements,
     generated_recipe::{DefaultMetadataProvider, GenerateRecipe, GeneratedRecipe, PythonParams},
     intermediate_backend::IntermediateBackendInstantiator,
+    traits::ProjectModel,
 };
-use pixi_build_types::ProjectModelV1;
+use pixi_build_types::{ProjectModelV1, SourcePackageName};
 use rattler_build::{NormalizedKey, recipe::variable::Variable};
-use rattler_conda_types::{ChannelUrl, 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::path::PathBuf;
 use std::{
@@ -61,13 +61,11 @@ impl GenerateRecipe for CMakeGenerator {
 
         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),
-        );
+        // Get the platform-specific dependencies from the project model.
+        // This properly handles target selectors like [target.linux-64] by using
+        // the ProjectModel trait's platform-aware API instead of trying to evaluate
+        // rattler-build selectors with simple string comparison.
+        let model_dependencies = model.dependencies(Some(host_platform));
 
         // Get the list of compilers from config, defaulting to ["cxx"] if not specified
         let compilers = config
@@ -76,26 +74,32 @@ impl GenerateRecipe for CMakeGenerator {
             .unwrap_or_else(|| vec!["cxx".to_string()]);
 
         // Add configured compilers to build requirements
-        add_compilers_and_stdlib_to_requirements(
+        pixi_build_backend::compilers::add_compilers_to_requirements(
             &compilers,
             &mut requirements.build,
-            &resolved_requirements.build,
+            &model_dependencies,
             &host_platform,
+        );
+        pixi_build_backend::compilers::add_stdlib_to_requirements(
+            &compilers,
+            &mut requirements.build,
             variants,
         );
 
         // add necessary build tools
         for tool in ["cmake", "ninja"] {
-            let tool_name = PackageName::new_unchecked(tool);
-            if !resolved_requirements.build.contains_key(&tool_name) {
+            let tool_name = SourcePackageName::from(tool);
+            if !model_dependencies.build.contains_key(&tool_name) {
                 requirements.build.push(tool.parse().into_diagnostic()?);
             }
         }
 
         // Check if the host platform has a host python dependency
         // This is used to determine if we need to the cmake argument for the python
         // executable
-        let has_host_python = resolved_requirements.contains(&PackageName::new_unchecked("python"));
+        let has_host_python = model_dependencies
+            .host
+            .contains_key(&SourcePackageName::from("python"));
 
         let build_script = BuildScriptContext {
             build_platform: if Platform::current().is_windows() {

crates/pixi-build-mojo/src/main.rs

@@ -6,14 +6,14 @@ use config::{MojoBackendConfig, clean_project_name};
 use miette::{Error, IntoDiagnostic};
 use pixi_build_backend::generated_recipe::DefaultMetadataProvider;
 use pixi_build_backend::{
-    compilers::add_compilers_and_stdlib_to_requirements,
     generated_recipe::{GenerateRecipe, GeneratedRecipe, PythonParams},
     intermediate_backend::IntermediateBackendInstantiator,
+    traits::ProjectModel,
 };
 use pixi_build_types::ProjectModelV1;
 use rattler_build::NormalizedKey;
-use rattler_conda_types::{ChannelUrl, 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::path::PathBuf;
 use std::{collections::BTreeSet, path::Path, sync::Arc};
@@ -68,13 +68,12 @@ impl GenerateRecipe for MojoGenerator {
 
         // Add compiler
         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),
-        );
+
+        // Get the platform-specific dependencies from the project model.
+        // This properly handles target selectors like [target.linux-64] by using
+        // the ProjectModel trait's platform-aware API instead of trying to evaluate
+        // rattler-build selectors with simple string comparison.
+        let model_dependencies = model.dependencies(Some(host_platform));
 
         // Get the list of compilers from config, defaulting to ["mojo"] if not specified
         let mut compilers = config
@@ -84,17 +83,18 @@ impl GenerateRecipe for MojoGenerator {
 
         // Handle mojo compiler specially if it's in the list
         if let Some(idx) = compilers.iter().position(|name| name == "mojo") {
-            let mojo_compiler_pkg = "mojo-compiler".to_string();
+            let mojo_compiler_pkg = "mojo-compiler";
             // All of these packages also contain the mojo compiler and maintain backward compat.
             // They should be removable at a future point.
             let alt_names = ["max", "mojo", "modular"];
 
-            if !resolved_requirements
-                .build
-                .contains_key(&PackageName::new_unchecked(&mojo_compiler_pkg))
-                && !alt_names
-                    .iter()
-                    .any(|alt| resolved_requirements.build.contains_key(*alt))
+            let mojo_pkg_name = pixi_build_types::SourcePackageName::from(mojo_compiler_pkg);
+            if !model_dependencies.build.contains_key(&mojo_pkg_name)
+                && !alt_names.iter().any(|alt| {
+                    model_dependencies
+                        .build
+                        .contains_key(&pixi_build_types::SourcePackageName::from(*alt))
+                })
             {
                 requirements
                     .build
@@ -105,11 +105,15 @@ impl GenerateRecipe for MojoGenerator {
             compilers.swap_remove(idx);
         }
 
-        add_compilers_and_stdlib_to_requirements(
+        pixi_build_backend::compilers::add_compilers_to_requirements(
             &compilers,
             &mut requirements.build,
-            &resolved_requirements.build,
+            &model_dependencies,
             &host_platform,
+        );
+        pixi_build_backend::compilers::add_stdlib_to_requirements(
+            &compilers,
+            &mut requirements.build,
             variants,
         );
 

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

@@ -1,8 +1,6 @@
 use std::path::PathBuf;
 
 use minijinja::Environment;
-use rattler_conda_types::PackageName;
-use recipe_stage0::{matchspec::PackageDependency, requirements::PackageSpecDependencies};
 use serde::Serialize;
 
 const UV: &str = "uv";
@@ -31,12 +29,15 @@ impl Installer {
         }
     }
 
-    pub fn determine_installer(
-        dependencies: &PackageSpecDependencies<PackageDependency>,
+    /// Determine the installer from an iterator of dependency package names.
+    /// Checks if "uv" is present in the package names.
+    pub fn determine_installer_from_names<'a>(
+        mut package_names: impl Iterator<Item = &'a str>,
     ) -> Installer {
-        // Determine the installer to use
-        let uv = PackageName::new_unchecked(UV.to_string());
-        if dependencies.contains(&uv) {
+        // Check all dependency names for "uv" package
+        let has_uv = package_names.any(|name| name == UV);
+
+        if has_uv {
             Installer::Uv
         } else {
             Installer::Pip

crates/pixi-build-python/src/main.rs

@@ -7,15 +7,15 @@ use config::PythonBackendConfig;
 use miette::IntoDiagnostic;
 use pixi_build_backend::variants::NormalizedKey;
 use pixi_build_backend::{
-    compilers::add_compilers_and_stdlib_to_requirements,
     generated_recipe::{GenerateRecipe, GeneratedRecipe, PythonParams},
     intermediate_backend::IntermediateBackendInstantiator,
+    traits::ProjectModel,
 };
 use pixi_build_types::ProjectModelV1;
 use pyproject_toml::PyProjectToml;
-use rattler_conda_types::{ChannelUrl, PackageName, Platform, package::EntryPoint};
+use rattler_conda_types::{ChannelUrl, Platform, package::EntryPoint};
 use recipe_stage0::matchspec::PackageDependency;
-use recipe_stage0::recipe::{self, ConditionalRequirements, NoArchKind, Python, Script};
+use recipe_stage0::recipe::{self, NoArchKind, Python, Script};
 use std::collections::HashSet;
 use std::{
     collections::BTreeSet,
@@ -93,27 +93,25 @@ impl GenerateRecipe for PythonGenerator {
 
         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),
-        );
+        // Get the platform-specific dependencies from the project model.
+        // This properly handles target selectors like [target.linux-64] by using
+        // the ProjectModel trait's platform-aware API instead of trying to evaluate
+        // rattler-build selectors with simple string comparison.
+        let model_dependencies = model.dependencies(Some(host_platform));
 
         // Ensure the python build tools are added to the `host` requirements.
         // Please note: this is a subtle difference for python, where the build tools
         // are added to the `host` requirements, while for cmake/rust they are
         // added to the `build` requirements.
-        let installer = Installer::determine_installer(&resolved_requirements);
+        // We only check build and host dependencies for the installer.
+        let installer =
+            Installer::determine_installer_from_names(model_dependencies.build_and_host_names());
 
         let installer_name = installer.package_name().to_string();
+        let installer_pkg = pixi_build_types::SourcePackageName::from(installer_name.as_str());
 
         // add installer in the host requirements
-        if !resolved_requirements
-            .host
-            .contains_key(&PackageName::new_unchecked(&installer_name))
-        {
+        if !model_dependencies.host.contains_key(&installer_pkg) {
             requirements
                 .host
                 .push(installer_name.parse().into_diagnostic()?);
@@ -128,28 +126,27 @@ impl GenerateRecipe for PythonGenerator {
             python_requirement_str.parse().into_diagnostic()
         };
 
+        let python_pkg = pixi_build_types::SourcePackageName::from("python");
         // add python in both host and run requirements
-        if !resolved_requirements
-            .host
-            .contains_key(&PackageName::new_unchecked("python"))
-        {
+        if !model_dependencies.host.contains_key(&python_pkg) {
             requirements.host.push(get_python_requirement()?);
         }
-        if !resolved_requirements
-            .run
-            .contains_key(&PackageName::new_unchecked("python"))
-        {
+        if !model_dependencies.run.contains_key(&python_pkg) {
             requirements.run.push(get_python_requirement()?);
         }
 
         // Get the list of compilers from config, defaulting to no compilers for pure
         // Python packages and add them to the build requirements.
         let compilers = config.compilers.clone().unwrap_or_default();
-        add_compilers_and_stdlib_to_requirements(
+        pixi_build_backend::compilers::add_compilers_to_requirements(
             &compilers,
             &mut requirements.build,
-            &resolved_requirements.build,
+            &model_dependencies,
             &host_platform,
+        );
+        pixi_build_backend::compilers::add_stdlib_to_requirements(
+            &compilers,
+            &mut requirements.build,
             variants,
         );