Skip to content

refactor: separate package discovery from solving #2241

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Yu-zh merged 2 commits into from
Sep 21, 2026
Merged

refactor: separate package discovery from solving #2241

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4a21497
refactor: separate package discovery from solving
Yu-zh Sep 21, 2026
346936e
refactor: name the discovery result DiscoveredProject
Yu-zh Sep 21, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
52 changes: 26 additions & 26 deletions crates/moon/src/cli/build.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -618,14 +618,14 @@ fn has_explicit_build_selector(cmd: &BuildSubcommand) -> bool {
}

fn resolve_build_target_selections(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
cmd: &BuildSubcommand,
selected_target_backend: Option<TargetBackend>,
user_log: &UserLog,
) -> anyhow::Result<Vec<TargetPackageGroup>> {
if let Some(target_backend) = selected_target_backend {
let packages =
resolve_selected_build_packages(resolve_output, cmd, Some(target_backend), user_log)?;
resolve_selected_build_packages(discovered, cmd, Some(target_backend), user_log)?;
if packages.is_empty() {
return Ok(Vec::new());
}
Expand All @@ -635,15 +635,15 @@ fn resolve_build_target_selections(
}]);
}

let selected = resolve_selected_build_packages(resolve_output, cmd, None, user_log)?;
let mut selections = group_packages_by_preferred_backend(resolve_output, selected);
let selected = resolve_selected_build_packages(discovered, cmd, None, user_log)?;
let mut selections = group_packages_by_preferred_backend(discovered, selected);

for selection in &mut selections {
selection.packages = selection
.packages
.iter()
.copied()
.filter(|&pkg| package_supports_backend(resolve_output, pkg, selection.target_backend))
.filter(|&pkg| package_supports_backend(discovered, pkg, selection.target_backend))
.collect();
}
selections.retain(|selection| !selection.packages.is_empty());
Expand All @@ -652,17 +652,17 @@ fn resolve_build_target_selections(
}

fn resolve_selected_build_packages(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
cmd: &BuildSubcommand,
target_backend: Option<TargetBackend>,
user_log: &UserLog,
) -> anyhow::Result<Vec<PackageId>> {
if !cmd.path.is_empty() {
if let Some(target_backend) = target_backend {
return select_supported_packages(resolve_output, &cmd.path, target_backend, user_log);
return select_supported_packages(discovered, &cmd.path, target_backend, user_log);
}
return Ok(select_packages(&cmd.path, user_log, |dir| {
filter_pkg_by_dir(resolve_output, dir)
filter_pkg_by_dir(discovered, dir)
})?
.into_iter()
.map(|(_, pkg_id)| pkg_id)
Expand All @@ -671,21 +671,21 @@ fn resolve_selected_build_packages(

if let Some(package_filter) = cmd.package.as_deref() {
let pkgs = match_packages_by_name_rr(
resolve_output,
resolve_output.local_modules(),
discovered,
discovered.local_modules(),
package_filter,
user_log,
);
if let Some(target_backend) = target_backend {
ensure_packages_support_backend(resolve_output, pkgs.iter().copied(), target_backend)?;
ensure_packages_support_backend(discovered, pkgs.iter().copied(), target_backend)?;
}
return Ok(pkgs);
}

Ok(rr_build::local_packages(resolve_output)
Ok(rr_build::local_packages(discovered)
.filter(|&pkg_id| {
target_backend
.is_none_or(|backend| package_supports_backend(resolve_output, pkg_id, backend))
.is_none_or(|backend| package_supports_backend(discovered, pkg_id, backend))
})
.collect())
}
Expand All @@ -697,49 +697,49 @@ fn resolve_selected_build_packages(
fn calc_user_intent(
path_filters: &[PathBuf],
package_filter: Option<&str>,
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
target_backend: TargetBackend,
user_log: &UserLog,
) -> Result<CalcUserIntentOutput, anyhow::Error> {
if !path_filters.is_empty() {
let selected =
select_supported_packages(resolve_output, path_filters, target_backend, user_log)?;
select_supported_packages(discovered, path_filters, target_backend, user_log)?;
Ok(selected
.into_iter()
.map(UserIntent::Build)
.collect::<Vec<_>>()
.into())
} else if let Some(package_filter) = package_filter {
let pkgs = match_packages_by_name_rr(
resolve_output,
resolve_output.local_modules(),
discovered,
discovered.local_modules(),
package_filter,
user_log,
);
ensure_packages_support_backend(resolve_output, pkgs.iter().copied(), target_backend)?;
ensure_packages_support_backend(discovered, pkgs.iter().copied(), target_backend)?;
Ok(pkgs
.into_iter()
.map(UserIntent::Build)
.collect::<Vec<_>>()
.into())
} else {
calc_user_intent_from_scoped_packages(
resolve_output,
&rr_build::local_packages(resolve_output)
.filter(|&pkg_id| package_supports_backend(resolve_output, pkg_id, target_backend))
discovered,
&rr_build::local_packages(discovered)
.filter(|&pkg_id| package_supports_backend(discovered, pkg_id, target_backend))
.collect::<Vec<_>>(),
target_backend,
)
}
}

fn calc_user_intent_from_scoped_packages(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
supported_packages: &[PackageId],
target_backend: TargetBackend,
) -> Result<CalcUserIntentOutput, anyhow::Error> {
let linkable_pkgs = get_linkable_pkgs(
resolve_output,
discovered,
target_backend,
supported_packages.iter().copied(),
);
Expand All @@ -748,7 +748,7 @@ fn calc_user_intent_from_scoped_packages(
.iter()
.copied()
.filter(|&pkg_id| {
let pkg = resolve_output.pkg_dirs.get_package(pkg_id);
let pkg = discovered.pkg_dirs.get_package(pkg_id);
!pkg.is_stdlib
})
.map(UserIntent::Build)
Expand All @@ -760,13 +760,13 @@ fn calc_user_intent_from_scoped_packages(
}

fn get_linkable_pkgs(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
target_backend: TargetBackend,
packages: impl Iterator<Item = PackageId>,
) -> Vec<PackageId> {
let mut linkable_pkgs = vec![];
for pkg_id in packages {
let pkg = resolve_output.pkg_dirs.get_package(pkg_id);
let pkg = discovered.pkg_dirs.get_package(pkg_id);
if pkg.raw.force_link
|| pkg
.raw
Expand Down
4 changes: 2 additions & 2 deletions crates/moon/src/cli/bundle.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -247,9 +247,9 @@ pub(crate) fn plan_bundle_rr_from_resolved(
}

fn bundle_user_intent(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
) -> CalcUserIntentOutput {
resolve_output
discovered
.local_modules()
.iter()
.map(|&module| UserIntent::Bundle(module))
Expand Down
68 changes: 31 additions & 37 deletions crates/moon/src/cli/check.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -622,12 +622,12 @@ fn run_check_for_single_file_rr(
}

fn get_user_intents_single_file(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
_backend: TargetBackend,
) -> Result<CalcUserIntentOutput, anyhow::Error> {
let m_packages = resolve_output
let m_packages = discovered
.pkg_dirs
.packages_for_module(resolve_output.local_modules()[0])
.packages_for_module(discovered.local_modules()[0])
.context("single-file project must resolve a local module")?;
let pkg = *m_packages
.iter()
Expand Down Expand Up @@ -957,7 +957,7 @@ pub(crate) fn plan_check_rr_from_resolved_all(
}

fn validate_selector_flags_before_split(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
cmd: &CheckSubcommand,
source_dir: &Path,
target_backend: Option<TargetBackend>,
Expand All @@ -968,7 +968,7 @@ fn validate_selector_flags_before_split(
}

let selected =
resolve_selected_packages(resolve_output, cmd, source_dir, target_backend, user_log)?;
resolve_selected_packages(discovered, cmd, source_dir, target_backend, user_log)?;
if cmd.patch_file.is_some() && selected.len() != 1 {
anyhow::bail!("`--patch-file` requires the selector to resolve to a single package");
}
Expand Down Expand Up @@ -1059,33 +1059,28 @@ fn plan_check_rr_from_selection(
}

pub(crate) fn resolve_check_target_selections(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
cmd: &CheckSubcommand,
source_dir: &Path,
selected_target_backend: Option<TargetBackend>,
user_log: &UserLog,
) -> anyhow::Result<Vec<TargetPackageGroup>> {
if let Some(target_backend) = selected_target_backend {
let packages = resolve_selected_packages(
resolve_output,
cmd,
source_dir,
Some(target_backend),
user_log,
)?;
let packages =
resolve_selected_packages(discovered, cmd, source_dir, Some(target_backend), user_log)?;
return Ok(vec![TargetPackageGroup {
target_backend,
packages,
}]);
}

let selected = resolve_selected_packages(resolve_output, cmd, source_dir, None, user_log)?;
let selections = group_packages_by_preferred_backend(resolve_output, selected);
let selected = resolve_selected_packages(discovered, cmd, source_dir, None, user_log)?;
let selections = group_packages_by_preferred_backend(discovered, selected);

let mut filtered = Vec::new();
for selection in selections {
let packages = filter_packages_for_backend(
resolve_output,
discovered,
selection.packages,
selection.target_backend,
user_log,
Expand All @@ -1102,43 +1097,42 @@ pub(crate) fn resolve_check_target_selections(
}

fn resolve_selected_packages(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
cmd: &CheckSubcommand,
source_dir: &Path,
target_backend: Option<TargetBackend>,
user_log: &UserLog,
) -> anyhow::Result<Vec<PackageId>> {
if let Some(filter_path) = cmd.package_path.as_deref() {
let (dir, _) = canonicalize_with_filename(&source_dir.join(filter_path))?;
let pkg = filter_pkg_by_dir(resolve_output, &dir)?;
let pkg = filter_pkg_by_dir(discovered, &dir)?;
if let Some(target_backend) = target_backend {
ensure_package_supports_backend(resolve_output, pkg, target_backend)?;
ensure_package_supports_backend(discovered, pkg, target_backend)?;
}
return Ok(vec![pkg]);
}

if !cmd.path.is_empty() {
if let Some(target_backend) = target_backend {
return select_supported_packages(resolve_output, &cmd.path, target_backend, user_log);
return select_supported_packages(discovered, &cmd.path, target_backend, user_log);
}
return Ok(select_packages(&cmd.path, user_log, |dir| {
filter_pkg_by_dir(resolve_output, dir)
filter_pkg_by_dir(discovered, dir)
})?
.into_iter()
.map(|(_, pkg_id)| pkg_id)
.collect());
}

Ok(rr_build::local_packages(resolve_output)
Ok(rr_build::local_packages(discovered)
.filter(|&pkg| {
target_backend
.is_none_or(|backend| package_supports_backend(resolve_output, pkg, backend))
target_backend.is_none_or(|backend| package_supports_backend(discovered, pkg, backend))
})
.collect())
}

fn filter_packages_for_backend(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
packages: Vec<PackageId>,
target_backend: TargetBackend,
user_log: &UserLog,
Expand All @@ -1147,7 +1141,7 @@ fn filter_packages_for_backend(
let mut unsupported = Vec::new();

for pkg in packages {
if package_supports_backend(resolve_output, pkg, target_backend) {
if package_supports_backend(discovered, pkg, target_backend) {
supported.push(pkg);
} else {
unsupported.push(pkg);
Expand All @@ -1156,10 +1150,10 @@ fn filter_packages_for_backend(

if supported.is_empty() && !unsupported.is_empty() {
if let [pkg] = unsupported.as_slice() {
ensure_package_supports_backend(resolve_output, *pkg, target_backend)?;
ensure_package_supports_backend(discovered, *pkg, target_backend)?;
} else {
ensure_packages_support_backend(
resolve_output,
discovered,
unsupported.iter().copied(),
target_backend,
)?;
Expand All @@ -1168,52 +1162,52 @@ fn filter_packages_for_backend(

for pkg in unsupported {
let pkg_id = pkg;
let pkg = resolve_output.pkg_dirs.get_package(pkg_id);
let pkg = discovered.pkg_dirs.get_package(pkg_id);
user_log.info(format!(
"skipping package `{}` because it does not support the selected target backend `{}`. Supported backends: {}",
pkg.fqn,
target_backend,
format_supported_backends(resolve_output, pkg_id),
format_supported_backends(discovered, pkg_id),
));
}

Ok(supported)
}

fn calc_user_intent_from_package_path(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
source_dir: &Path,
filter_path: &Path,
target_backend: TargetBackend,
patch_file: Option<&Path>,
) -> Result<CalcUserIntentOutput, anyhow::Error> {
let (dir, _) = canonicalize_with_filename(&source_dir.join(filter_path))?;
let pkg = filter_pkg_by_dir(resolve_output, &dir)?;
ensure_package_supports_backend(resolve_output, pkg, target_backend)?;
let pkg = filter_pkg_by_dir(discovered, &dir)?;
ensure_package_supports_backend(discovered, pkg, target_backend)?;
let directive =
rr_build::build_patch_directive_for_package(pkg, false, None, patch_file, false)?;
Ok((vec![UserIntent::Check(pkg)], directive).into())
}

#[instrument(level = Level::DEBUG, skip_all)]
fn calc_user_intent(
resolve_output: &moonbuild_rupes_recta::ResolveOutput,
discovered: &moonbuild_rupes_recta::DiscoveredProject,
paths: &[PathBuf],
target_backend: TargetBackend,
patch_file: Option<&Path>,
user_log: &UserLog,
) -> Result<CalcUserIntentOutput, anyhow::Error> {
if !paths.is_empty() {
let selected = select_supported_packages(resolve_output, paths, target_backend, user_log)?;
let selected = select_supported_packages(discovered, paths, target_backend, user_log)?;
let directive = build_directive_for_selected_packages(&selected, patch_file)?;
Ok((
selected.into_iter().map(UserIntent::Check).collect(),
directive,
)
.into())
} else {
let intents: Vec<_> = rr_build::local_packages(resolve_output)
.filter(|&pkg| package_supports_backend(resolve_output, pkg, target_backend))
let intents: Vec<_> = rr_build::local_packages(discovered)
.filter(|&pkg| package_supports_backend(discovered, pkg, target_backend))
.map(UserIntent::Check)
.collect();
Ok(intents.into())
Expand Down
Loading
Loading