Remove duplicate Lock::to_resolution (#9029)

## Summary

This got moved to `InstallTarget`! Must've been an oversight not to
delete. I verified that no code was changed here since the date that we
moved it to `InstallTarget`.

crates/uv-resolver/src/lock/mod.rs

@@ -1,4 +1,3 @@
-use either::Either;
 use itertools::Itertools;
 use petgraph::graph::NodeIndex;
 use petgraph::visit::EdgeRef;
@@ -25,14 +24,14 @@ use crate::{
     ResolutionMode,
 };
 use uv_cache_key::RepositoryUrl;
-use uv_configuration::{BuildOptions, DevGroupsManifest, ExtrasSpecification, InstallOptions};
+use uv_configuration::BuildOptions;
 use uv_distribution::DistributionDatabase;
 use uv_distribution_filename::{DistExtension, ExtensionError, SourceDistExtension, WheelFilename};
 use uv_distribution_types::{
     BuiltDist, DependencyMetadata, DirectUrlBuiltDist, DirectUrlSourceDist, DirectorySourceDist,
     Dist, DistributionMetadata, FileLocation, GitSourceDist, IndexLocations, IndexUrl, Name,
     PathBuiltDist, PathSourceDist, RegistryBuiltDist, RegistryBuiltWheel, RegistrySourceDist,
-    RemoteSource, Resolution, ResolvedDist, StaticMetadata, ToUrlError, UrlString,
+    RemoteSource, ResolvedDist, StaticMetadata, ToUrlError, UrlString,
 };
 use uv_fs::{relative_to, PortablePath, PortablePathBuf};
 use uv_git::{GitReference, GitSha, RepositoryReference, ResolvedRepositoryReference};
@@ -42,7 +41,6 @@ use uv_pep508::{split_scheme, MarkerEnvironment, MarkerTree, VerbatimUrl, Verbat
 use uv_platform_tags::{TagCompatibility, TagPriority, Tags};
 use uv_pypi_types::{
     redact_credentials, HashDigest, ParsedArchiveUrl, ParsedGitUrl, Requirement, RequirementSource,
-    ResolverMarkerEnvironment,
 };
 use uv_types::{BuildContext, HashStrategy};
 use uv_workspace::dependency_groups::DependencyGroupError;
@@ -587,139 +585,6 @@ impl Lock {
         self.fork_markers.as_slice()
     }
 
-    /// Convert the [`Lock`] to a [`Resolution`] using the given marker environment, tags, and root.
-    pub fn to_resolution(
-        &self,
-        target: InstallTarget<'_>,
-        marker_env: &ResolverMarkerEnvironment,
-        tags: &Tags,
-        extras: &ExtrasSpecification,
-        dev: &DevGroupsManifest,
-        build_options: &BuildOptions,
-        install_options: &InstallOptions,
-    ) -> Result<Resolution, LockError> {
-        let mut queue: VecDeque<(&Package, Option<&ExtraName>)> = VecDeque::new();
-        let mut seen = FxHashSet::default();
-
-        // Add the workspace packages to the queue.
-        for root_name in target.packages() {
-            let root = self
-                .find_by_name(root_name)
-                .map_err(|_| LockErrorKind::MultipleRootPackages {
-                    name: root_name.clone(),
-                })?
-                .ok_or_else(|| LockErrorKind::MissingRootPackage {
-                    name: root_name.clone(),
-                })?;
-
-            if dev.prod() {
-                // Add the base package.
-                queue.push_back((root, None));
-
-                // Add any extras.
-                match extras {
-                    ExtrasSpecification::None => {}
-                    ExtrasSpecification::All => {
-                        for extra in root.optional_dependencies.keys() {
-                            queue.push_back((root, Some(extra)));
-                        }
-                    }
-                    ExtrasSpecification::Some(extras) => {
-                        for extra in extras {
-                            queue.push_back((root, Some(extra)));
-                        }
-                    }
-                }
-            }
-
-            // Add any dev dependencies.
-            for group in dev.iter() {
-                for dep in root.dependency_groups.get(group).into_iter().flatten() {
-                    if dep.complexified_marker.evaluate(marker_env, &[]) {
-                        let dep_dist = self.find_by_id(&dep.package_id);
-                        if seen.insert((&dep.package_id, None)) {
-                            queue.push_back((dep_dist, None));
-                        }
-                        for extra in &dep.extra {
-                            if seen.insert((&dep.package_id, Some(extra))) {
-                                queue.push_back((dep_dist, Some(extra)));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Add any dependency groups that are exclusive to the workspace root (e.g., dev
-        // dependencies in (legacy) non-project workspace roots).
-        let groups = target
-            .groups()
-            .map_err(|err| LockErrorKind::DependencyGroup { err })?;
-        for group in dev.iter() {
-            for dependency in groups.get(group).into_iter().flatten() {
-                if dependency.marker.evaluate(marker_env, &[]) {
-                    let root_name = &dependency.name;
-                    let root = self
-                        .find_by_markers(root_name, marker_env)
-                        .map_err(|_| LockErrorKind::MultipleRootPackages {
-                            name: root_name.clone(),
-                        })?
-                        .ok_or_else(|| LockErrorKind::MissingRootPackage {
-                            name: root_name.clone(),
-                        })?;
-
-                    // Add the base package.
-                    queue.push_back((root, None));
-
-                    // Add any extras.
-                    for extra in &dependency.extras {
-                        queue.push_back((root, Some(extra)));
-                    }
-                }
-            }
-        }
-
-        let mut map = BTreeMap::default();
-        let mut hashes = BTreeMap::default();
-        while let Some((dist, extra)) = queue.pop_front() {
-            let deps = if let Some(extra) = extra {
-                Either::Left(dist.optional_dependencies.get(extra).into_iter().flatten())
-            } else {
-                Either::Right(dist.dependencies.iter())
-            };
-            for dep in deps {
-                if dep.complexified_marker.evaluate(marker_env, &[]) {
-                    let dep_dist = self.find_by_id(&dep.package_id);
-                    if seen.insert((&dep.package_id, None)) {
-                        queue.push_back((dep_dist, None));
-                    }
-                    for extra in &dep.extra {
-                        if seen.insert((&dep.package_id, Some(extra))) {
-                            queue.push_back((dep_dist, Some(extra)));
-                        }
-                    }
-                }
-            }
-            if install_options.include_package(
-                &dist.id.name,
-                target.project_name(),
-                &self.manifest.members,
-            ) {
-                map.insert(
-                    dist.id.name.clone(),
-                    ResolvedDist::Installable(dist.to_dist(
-                        target.workspace().install_path(),
-                        TagPolicy::Required(tags),
-                        build_options,
-                    )?),
-                );
-                hashes.insert(dist.id.name.clone(), dist.hashes());
-            }
-        }
-        let diagnostics = vec![];
-        Ok(Resolution::new(map, hashes, diagnostics))
-    }
-
     /// Returns the TOML representation of this lockfile.
     pub fn to_toml(&self) -> anyhow::Result<String> {
         // We construct a TOML document manually instead of going through Serde to enable