Build backend: Add direct builds to the resolver and installer

crates/uv-dispatch/Cargo.toml

@@ -17,6 +17,7 @@ doctest = false
 workspace = true
 
 [dependencies]
+uv-build-backend = { workspace = true }
 uv-build-frontend = { workspace = true }
 uv-cache = { workspace = true }
 uv-client = { workspace = true }
@@ -30,9 +31,11 @@ uv-pypi-types = { workspace = true }
 uv-python = { workspace = true }
 uv-resolver = { workspace = true }
 uv-types = { workspace = true }
+uv-version = { workspace = true }
 
 anyhow = { workspace = true }
 futures = { workspace = true }
 itertools = { workspace = true }
 rustc-hash = { workspace = true }
+tokio = { workspace = true }
 tracing = { workspace = true }

crates/uv-dispatch/src/lib.rs

@@ -9,8 +9,8 @@ use anyhow::{anyhow, Context, Result};
 use futures::FutureExt;
 use itertools::Itertools;
 use rustc_hash::FxHashMap;
-use tracing::{debug, instrument};
-
+use tracing::{debug, instrument, trace};
+use uv_build_backend::check_direct_build;
 use uv_build_frontend::{SourceBuild, SourceBuildContext};
 use uv_cache::Cache;
 use uv_client::RegistryClient;
@@ -397,6 +397,67 @@ impl<'a> BuildContext for BuildDispatch<'a> {
         .await?;
         Ok(builder)
     }
+
+    async fn direct_build<'data>(
+        &'data self,
+        source: &'data Path,
+        subdirectory: Option<&'data Path>,
+        output_dir: &'data Path,
+        build_kind: BuildKind,
+        version_id: Option<String>,
+    ) -> Result<Option<String>> {
+        // Direct builds are a preview feature with the uv build backend.
+        if self.preview.is_disabled() {
+            trace!("Preview is disabled, not checking for direct build");
+            return Ok(None);
+        }
+
+        let source_tree = if let Some(subdir) = subdirectory {
+            source.join(subdir)
+        } else {
+            source.to_path_buf()
+        };
+
+        // Only perform the direct build if the backend is uv in a compatible version.
+        let identifier = version_id.unwrap_or_else(|| source_tree.display().to_string());
+        if !check_direct_build(&source_tree, &identifier) {
+            trace!("Requirements for direct build not matched: {identifier}");
+            return Ok(None);
+        }
+
+        debug!("Performing direct build for {identifier}");
+
+        let output_dir = output_dir.to_path_buf();
+        let filename = tokio::task::spawn_blocking(move || -> Result<String> {
+            let filename = match build_kind {
+                BuildKind::Wheel => uv_build_backend::build_wheel(
+                    &source_tree,
+                    &output_dir,
+                    None,
+                    uv_version::version(),
+                )?
+                .to_string(),
+                BuildKind::Sdist => uv_build_backend::build_source_dist(
+                    &source_tree,
+                    &output_dir,
+                    uv_version::version(),
+                )?
+                .to_string(),
+                BuildKind::Editable => uv_build_backend::build_editable(
+                    &source_tree,
+                    &output_dir,
+                    None,
+                    uv_version::version(),
+                )?
+                .to_string(),
+            };
+            Ok(filename)
+        })
+        .await??
+        .to_string();
+
+        Ok(Some(filename))
+    }
 }
 
 /// Shared state used during resolution and installation.

crates/uv-distribution/src/source/mod.rs

@@ -1803,27 +1803,46 @@ impl<'a, T: BuildContext> SourceDistributionBuilder<'a, T> {
         fs::create_dir_all(&cache_shard)
             .await
             .map_err(Error::CacheWrite)?;
-        let disk_filename = self
+        // Try a direct build if that isn't disabled and the uv build backend is used.
+        let disk_filename = if let Some(name) = self
             .build_context
-            .setup_build(
+            .direct_build(
                 source_root,
                 subdirectory,
-                source_root,
-                Some(source.to_string()),
-                source.as_dist(),
-                source_strategy,
+                temp_dir.path(),
                 if source.is_editable() {
                     BuildKind::Editable
                 } else {
                     BuildKind::Wheel
                 },
-                BuildOutput::Debug,
+                Some(source.to_string()),
             )
             .await
             .map_err(Error::Build)?
-            .wheel(temp_dir.path())
-            .await
-            .map_err(Error::Build)?;
+        {
+            name
+        } else {
+            self.build_context
+                .setup_build(
+                    source_root,
+                    subdirectory,
+                    source_root,
+                    Some(source.to_string()),
+                    source.as_dist(),
+                    source_strategy,
+                    if source.is_editable() {
+                        BuildKind::Editable
+                    } else {
+                        BuildKind::Wheel
+                    },
+                    BuildOutput::Debug,
+                )
+                .await
+                .map_err(Error::Build)?
+                .wheel(temp_dir.path())
+                .await
+                .map_err(Error::Build)?
+        };
 
         // Read the metadata from the wheel.
         let filename = WheelFilename::from_str(&disk_filename)?;

crates/uv-types/src/traits.rs

@@ -121,6 +121,21 @@ pub trait BuildContext {
         build_kind: BuildKind,
         build_output: BuildOutput,
     ) -> impl Future<Output = Result<Self::SourceDistBuilder>> + 'a;
+
+    /// Build by calling directly into the uv build backend without PEP 517, if possible.
+    ///
+    /// Checks if the source tree uses uv as build backend. If not, it returns `Ok(None)`, otherwise
+    /// it builds and returns the name of the built file.
+    ///
+    /// `version_id` is for error reporting only.
+    fn direct_build<'a>(
+        &'a self,
+        source: &'a Path,
+        subdirectory: Option<&'a Path>,
+        output_dir: &'a Path,
+        build_kind: BuildKind,
+        version_id: Option<String>,
+    ) -> impl Future<Output = Result<Option<String>>> + 'a;
 }
 
 /// A wrapper for `uv_build::SourceBuild` to avoid cyclical crate dependencies.