Avoid unnecessary progress bar initializations (#7412)

## Summary

Closes https://github.com/astral-sh/uv/issues/6343.

crates/uv-requirements/src/unnamed.rs

@@ -12,7 +12,7 @@ use url::Host;
 use distribution_filename::{DistExtension, SourceDistFilename, WheelFilename};
 use distribution_types::{
     BuildableSource, DirectSourceUrl, DirectorySourceUrl, GitSourceUrl, PathSourceUrl,
-    RemoteSource, SourceUrl, UnresolvedRequirement, UnresolvedRequirementSpecification, VersionId,
+    RemoteSource, SourceUrl, VersionId,
 };
 use pep508_rs::{UnnamedRequirement, VersionOrUrl};
 use pypi_types::Requirement;
@@ -37,7 +37,7 @@ pub enum NamedRequirementsError {
 /// Like [`RequirementsSpecification`], but with concrete names for all requirements.
 pub struct NamedRequirementsResolver<'a, Context: BuildContext> {
     /// The requirements for the project.
-    requirements: Vec<UnresolvedRequirementSpecification>,
+    requirements: Vec<UnnamedRequirement<VerbatimParsedUrl>>,
     /// Whether to check hashes for distributions.
     hasher: &'a HashStrategy,
     /// The in-memory index for resolving dependencies.
@@ -49,7 +49,7 @@ pub struct NamedRequirementsResolver<'a, Context: BuildContext> {
 impl<'a, Context: BuildContext> NamedRequirementsResolver<'a, Context> {
     /// Instantiate a new [`NamedRequirementsResolver`] for a given set of requirements.
     pub fn new(
-        requirements: Vec<UnresolvedRequirementSpecification>,
+        requirements: Vec<UnnamedRequirement<VerbatimParsedUrl>>,
         hasher: &'a HashStrategy,
         index: &'a InMemoryIndex,
         database: DistributionDatabase<'a, Context>,
@@ -81,13 +81,10 @@ impl<'a, Context: BuildContext> NamedRequirementsResolver<'a, Context> {
         } = self;
         requirements
             .into_iter()
-            .map(|entry| async {
-                match entry.requirement {
-                    UnresolvedRequirement::Named(requirement) => Ok(requirement),
-                    UnresolvedRequirement::Unnamed(requirement) => Ok(Requirement::from(
-                        Self::resolve_requirement(requirement, hasher, index, &database).await?,
-                    )),
-                }
+            .map(|requirement| async {
+                Self::resolve_requirement(requirement, hasher, index, &database)
+                    .await
+                    .map(Requirement::from)
             })
             .collect::<FuturesOrdered<_>>()
             .try_collect()

crates/uv/src/commands/pip/operations.rs

@@ -10,7 +10,7 @@ use tracing::debug;
 
 use distribution_types::{
     CachedDist, Diagnostic, InstalledDist, LocalDist, NameRequirementSpecification,
-    ResolutionDiagnostic, UnresolvedRequirementSpecification,
+    ResolutionDiagnostic, UnresolvedRequirement, UnresolvedRequirementSpecification,
 };
 use distribution_types::{
     DistributionMetadata, IndexLocations, InstalledMetadata, Name, Resolution,
@@ -116,16 +116,33 @@ pub(crate) async fn resolve<InstalledPackages: InstalledPackagesProvider>(
 
     // Resolve the requirements from the provided sources.
     let requirements = {
-        // Convert from unnamed to named requirements.
-        let mut requirements = NamedRequirementsResolver::new(
-            requirements,
-            hasher,
-            index,
-            DistributionDatabase::new(client, build_dispatch, concurrency.downloads),
-        )
-        .with_reporter(ResolverReporter::from(printer))
-        .resolve()
-        .await?;
+        // Partition the requirements into named and unnamed requirements.
+        let (mut requirements, unnamed): (Vec<_>, Vec<_>) =
+            requirements
+                .into_iter()
+                .partition_map(|spec| match spec.requirement {
+                    UnresolvedRequirement::Named(requirement) => {
+                        itertools::Either::Left(requirement)
+                    }
+                    UnresolvedRequirement::Unnamed(requirement) => {
+                        itertools::Either::Right(requirement)
+                    }
+                });
+
+        // Resolve any unnamed requirements.
+        if !unnamed.is_empty() {
+            requirements.extend(
+                NamedRequirementsResolver::new(
+                    unnamed,
+                    hasher,
+                    index,
+                    DistributionDatabase::new(client, build_dispatch, concurrency.downloads),
+                )
+                .with_reporter(ResolverReporter::from(printer))
+                .resolve()
+                .await?,
+            );
+        }
 
         // Resolve any source trees into requirements.
         if !source_trees.is_empty() {
@@ -183,15 +200,37 @@ pub(crate) async fn resolve<InstalledPackages: InstalledPackagesProvider>(
     };
 
     // Resolve the overrides from the provided sources.
-    let overrides = NamedRequirementsResolver::new(
-        overrides,
-        hasher,
-        index,
-        DistributionDatabase::new(client, build_dispatch, concurrency.downloads),
-    )
-    .with_reporter(ResolverReporter::from(printer))
-    .resolve()
-    .await?;
+    let overrides = {
+        // Partition the overrides into named and unnamed requirements.
+        let (mut overrides, unnamed): (Vec<_>, Vec<_>) =
+            overrides
+                .into_iter()
+                .partition_map(|spec| match spec.requirement {
+                    UnresolvedRequirement::Named(requirement) => {
+                        itertools::Either::Left(requirement)
+                    }
+                    UnresolvedRequirement::Unnamed(requirement) => {
+                        itertools::Either::Right(requirement)
+                    }
+                });
+
+        // Resolve any unnamed overrides.
+        if !unnamed.is_empty() {
+            overrides.extend(
+                NamedRequirementsResolver::new(
+                    unnamed,
+                    hasher,
+                    index,
+                    DistributionDatabase::new(client, build_dispatch, concurrency.downloads),
+                )
+                .with_reporter(ResolverReporter::from(printer))
+                .resolve()
+                .await?,
+            );
+        }
+
+        overrides
+    };
 
     // Collect constraints and overrides.
     let constraints = Constraints::from_requirements(

crates/uv/src/commands/project/add.rs

@@ -3,11 +3,13 @@ use std::fmt::Write;
 use std::path::{Path, PathBuf};
 
 use anyhow::{bail, Context, Result};
+use itertools::Itertools;
 use owo_colors::OwoColorize;
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use tracing::debug;
 
 use cache_key::RepositoryUrl;
+use distribution_types::UnresolvedRequirement;
 use pep508_rs::{ExtraName, Requirement, VersionOrUrl};
 use pypi_types::redact_git_credentials;
 use uv_auth::{store_credentials_from_url, Credentials};
@@ -313,15 +315,37 @@ pub(crate) async fn add(
     );
 
     // Resolve any unnamed requirements.
-    let requirements = NamedRequirementsResolver::new(
-        requirements,
-        &hasher,
-        &state.index,
-        DistributionDatabase::new(&client, &build_dispatch, concurrency.downloads),
-    )
-    .with_reporter(ResolverReporter::from(printer))
-    .resolve()
-    .await?;
+    let requirements = {
+        // Partition the requirements into named and unnamed requirements.
+        let (mut requirements, unnamed): (Vec<_>, Vec<_>) =
+            requirements
+                .into_iter()
+                .partition_map(|spec| match spec.requirement {
+                    UnresolvedRequirement::Named(requirement) => {
+                        itertools::Either::Left(requirement)
+                    }
+                    UnresolvedRequirement::Unnamed(requirement) => {
+                        itertools::Either::Right(requirement)
+                    }
+                });
+
+        // Resolve any unnamed requirements.
+        if !unnamed.is_empty() {
+            requirements.extend(
+                NamedRequirementsResolver::new(
+                    unnamed,
+                    &hasher,
+                    &state.index,
+                    DistributionDatabase::new(&client, &build_dispatch, concurrency.downloads),
+                )
+                .with_reporter(ResolverReporter::from(printer))
+                .resolve()
+                .await?,
+            );
+        }
+
+        requirements
+    };
 
     // Add the requirements to the `pyproject.toml` or script.
     let mut toml = match &target {

crates/uv/src/commands/project/mod.rs

@@ -5,7 +5,7 @@ use itertools::Itertools;
 use owo_colors::OwoColorize;
 use tracing::debug;
 
-use distribution_types::{Resolution, UnresolvedRequirementSpecification};
+use distribution_types::{Resolution, UnresolvedRequirement, UnresolvedRequirementSpecification};
 use pep440_rs::{Version, VersionSpecifiers};
 use pep508_rs::MarkerTreeContents;
 use pypi_types::Requirement;
@@ -548,6 +548,22 @@ pub(crate) async fn resolve_names(
     cache: &Cache,
     printer: Printer,
 ) -> anyhow::Result<Vec<Requirement>> {
+    // Partition the requirements into named and unnamed requirements.
+    let (mut requirements, unnamed): (Vec<_>, Vec<_>) =
+        requirements
+            .into_iter()
+            .partition_map(|spec| match spec.requirement {
+                UnresolvedRequirement::Named(requirement) => itertools::Either::Left(requirement),
+                UnresolvedRequirement::Unnamed(requirement) => {
+                    itertools::Either::Right(requirement)
+                }
+            });
+
+    // Short-circuit if there are no unnamed requirements.
+    if unnamed.is_empty() {
+        return Ok(requirements);
+    }
+
     // Extract the project settings.
     let ResolverInstallerSettings {
         index_locations,
@@ -627,16 +643,20 @@ pub(crate) async fn resolve_names(
         concurrency,
     );
 
-    // Initialize the resolver.
-    let resolver = NamedRequirementsResolver::new(
-        requirements,
-        &hasher,
-        &state.index,
-        DistributionDatabase::new(&client, &build_dispatch, concurrency.downloads),
-    )
-    .with_reporter(ResolverReporter::from(printer));
+    // Resolve the unnamed requirements.
+    requirements.extend(
+        NamedRequirementsResolver::new(
+            unnamed,
+            &hasher,
+            &state.index,
+            DistributionDatabase::new(&client, &build_dispatch, concurrency.downloads),
+        )
+        .with_reporter(ResolverReporter::from(printer))
+        .resolve()
+        .await?,
+    );
 
-    Ok(resolver.resolve().await?)
+    Ok(requirements)
 }
 
 /// Run dependency resolution for an interpreter, returning the [`ResolutionGraph`].