feat: add moon test --outline

Author: peter-jerry-ye

crates/moon/src/cli/test.rs

@@ -60,6 +60,8 @@ use crate::rr_build::preconfig_compile;
 use crate::rr_build::{BuildConfig, CalcUserIntentOutput};
 use crate::run::TestFilter;
 use crate::run::TestIndex;
+use crate::run::TestOutlineEntry;
+use crate::run::collect_test_outline;
 use crate::run::perform_promotion;
 
 use super::BenchSubcommand;
@@ -93,6 +95,32 @@ fn print_test_summary(total: usize, passed: usize, quiet: bool, backend_hint: Op
     }
 }
 
+fn print_test_outline(entries: &[TestOutlineEntry]) {
+    if entries.is_empty() {
+        eprintln!("{}: no test entry found.", "Warning".yellow().bold());
+        return;
+    }
+
+    for (i, entry) in entries.iter().enumerate() {
+        let line = entry
+            .line_number
+            .map(|v| v.to_string())
+            .unwrap_or_else(|| "?".to_string());
+        let mut line_out = format!(
+            "{:>4}. {} {}:{} index={}",
+            i + 1,
+            entry.package,
+            entry.file,
+            line,
+            entry.index
+        );
+        if let Some(name) = &entry.name {
+            line_out.push_str(&format!(" name={name:?}"));
+        }
+        println!("{line_out}");
+    }
+}
+
 /// Test the current package
 #[derive(Debug, clap::Parser, Clone)]
 pub struct TestSubcommand {
@@ -136,6 +164,10 @@ pub struct TestSubcommand {
     #[clap(long)]
     pub no_parallelize: bool,
 
+    /// Print the outline of tests to be executed and exit
+    #[clap(long, conflicts_with_all = ["build_only", "update", "test_failure_json"])]
+    pub outline: bool,
+
     /// Print failure message in JSON format
     #[clap(long)]
     pub test_failure_json: bool,
@@ -266,6 +298,12 @@ fn run_test_internal(
 
 #[instrument(level = Level::DEBUG, skip_all)]
 fn run_test_in_single_file(cli: &UniversalFlags, cmd: &TestSubcommand) -> anyhow::Result<i32> {
+    if cmd.outline && cli.dry_run {
+        anyhow::bail!("`--outline` cannot be used with `--dry-run`");
+    }
+    if cmd.outline && !cli.unstable_feature.rupes_recta {
+        anyhow::bail!("`--outline` is only supported with Rupes Recta (-Z rupes_recta)");
+    }
     if cli.unstable_feature.rupes_recta {
         return run_test_in_single_file_rr(cli, cmd);
     }
@@ -645,6 +683,7 @@ pub(crate) struct TestLikeSubcommand<'a> {
     pub auto_sync_flags: &'a AutoSyncFlags,
     pub build_only: bool,
     pub no_parallelize: bool,
+    pub outline: bool,
     pub test_failure_json: bool,
     pub patch_file: &'a Option<PathBuf>,
     pub include_skipped: bool,
@@ -667,6 +706,7 @@ impl<'a> From<&'a TestSubcommand> for TestLikeSubcommand<'a> {
             auto_sync_flags: &cmd.auto_sync_flags,
             build_only: cmd.build_only,
             no_parallelize: cmd.no_parallelize,
+            outline: cmd.outline,
             test_failure_json: cmd.test_failure_json,
             patch_file: &cmd.patch_file,
             include_skipped: cmd.include_skipped,
@@ -689,6 +729,7 @@ impl<'a> From<&'a BenchSubcommand> for TestLikeSubcommand<'a> {
             auto_sync_flags: &cmd.auto_sync_flags,
             build_only: cmd.build_only,
             no_parallelize: cmd.no_parallelize,
+            outline: false,
             test_failure_json: false,
             patch_file: &None,
             include_skipped: false,
@@ -736,6 +777,12 @@ pub(crate) fn run_test_or_bench_internal(
     if cmd.explicit_file_filter.is_some() && (cmd.package.is_some() || cmd.file.is_some()) {
         anyhow::bail!("cannot filter package or files when testing a single file in a project");
     }
+    if cmd.outline && cli.dry_run {
+        anyhow::bail!("`--outline` cannot be used with `--dry-run`");
+    }
+    if cmd.outline && !cli.unstable_feature.rupes_recta {
+        anyhow::bail!("`--outline` is only supported with Rupes Recta (-Z rupes_recta)");
+    }
 
     debug!(
         rupes_recta = cli.unstable_feature.rupes_recta,
@@ -1503,6 +1550,17 @@ fn rr_test_from_plan(
         return Ok(result.return_code_for_success());
     }
 
+    if cmd.outline {
+        let entries = collect_test_outline(
+            build_meta,
+            &filter,
+            cmd.include_skipped,
+            cmd.run_mode == RunMode::Bench,
+        )?;
+        print_test_outline(&entries);
+        return Ok(0);
+    }
+
     if cmd.build_only {
         // Match legacy behavior: create JS wrappers and print test artifacts as JSON
         let test_artifacts = collect_test_artifacts_for_build_only(build_meta, target_dir)?;

crates/moon/src/run/mod.rs

@@ -23,7 +23,7 @@ mod runtest;
 mod runtime;
 
 pub use child::run;
-pub use runtest::{TestFilter, TestIndex, perform_promotion, run_tests};
+pub use runtest::{TestFilter, TestIndex, TestOutlineEntry, collect_test_outline, perform_promotion, run_tests};
 pub use runtime::{CommandGuard, command_for};
 
 use std::sync::OnceLock;

crates/moon/src/run/runtest.rs

@@ -87,6 +87,15 @@ use crate::{rr_build::BuildMeta, run::default_rt};
 pub use filter::TestFilter;
 pub use promotion::perform_promotion;
 
+#[derive(Debug, Clone)]
+pub struct TestOutlineEntry {
+    pub package: String,
+    pub file: String,
+    pub index: u32,
+    pub name: Option<String>,
+    pub line_number: Option<usize>,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum TestResultKind {
     Passed,
@@ -382,6 +391,111 @@ impl TargetTestResult {
     }
 }
 
+fn collect_tests_by_file(
+    meta: &MooncGenTestInfo,
+    bench: bool,
+) -> IndexMap<String, IndexMap<u32, MbtTestInfo>> {
+    let mut out: IndexMap<String, IndexMap<u32, MbtTestInfo>> = IndexMap::new();
+    let lists: Vec<&IndexMap<String, Vec<MbtTestInfo>>> = if bench {
+        vec![&meta.with_bench_args_tests]
+    } else {
+        vec![
+            &meta.no_args_tests,
+            &meta.with_args_tests,
+            &meta.async_tests,
+            &meta.async_tests_with_args,
+        ]
+    };
+
+    for test_list in lists {
+        for (file, tests) in test_list {
+            let entry = out.entry(file.clone()).or_default();
+            for test in tests {
+                entry.entry(test.index).or_insert_with(|| test.clone());
+            }
+        }
+    }
+
+    out
+}
+
+#[instrument(level = "debug", skip(build_meta, filter))]
+pub fn collect_test_outline(
+    build_meta: &BuildMeta,
+    filter: &TestFilter,
+    include_skipped: bool,
+    bench: bool,
+) -> anyhow::Result<Vec<TestOutlineEntry>> {
+    let executables = gather_tests(build_meta);
+    debug!(count = executables.len(), "collecting test outline entries");
+    let mut entries = Vec::new();
+
+    for test in executables {
+        let (included, file_filt) = filter.check_package(test.target);
+        if !included {
+            continue;
+        }
+
+        let meta_bytes = std::fs::read(test.meta)
+            .with_context(|| format!("Failed to read test metadata at {}", test.meta.display()))?;
+        let meta: MooncGenTestInfo = serde_json_lenient::from_slice(&meta_bytes)
+            .with_context(|| format!("Failed to parse test metadata at {}", test.meta.display()))?;
+
+        let mut file_ranges = vec![];
+        filter::apply_filter(
+            file_filt,
+            &meta,
+            &mut file_ranges,
+            include_skipped,
+            bench,
+            filter.name_filter.as_deref(),
+        );
+
+        let mut allowed_indices: IndexMap<String, std::collections::HashSet<u32>> =
+            IndexMap::new();
+        for (file, ranges) in file_ranges {
+            let entry = allowed_indices.entry(file).or_default();
+            for range in ranges {
+                entry.extend(range);
+            }
+        }
+
+        if allowed_indices.values().all(|v| v.is_empty()) {
+            continue;
+        }
+
+        let tests_by_file = collect_tests_by_file(&meta, bench);
+        let pkgname = build_meta
+            .resolve_output
+            .pkg_dirs
+            .get_package(test.target.package)
+            .fqn
+            .to_string();
+        for (file, tests) in tests_by_file {
+            let Some(allowed) = allowed_indices.get(&file) else {
+                continue;
+            };
+            if allowed.is_empty() {
+                continue;
+            }
+            for (index, test) in tests {
+                if !allowed.contains(&index) {
+                    continue;
+                }
+                entries.push(TestOutlineEntry {
+                    package: pkgname.clone(),
+                    file: file.clone(),
+                    index,
+                    name: test.name.clone(),
+                    line_number: test.line_number,
+                });
+            }
+        }
+    }
+
+    Ok(entries)
+}
+
 /// Gather tests executables from the build metadata.
 #[instrument(level = "trace", skip(build_meta))]
 fn gather_tests(build_meta: &BuildMeta) -> Vec<TestExecutableToRun<'_>> {

crates/moon/tests/test_cases/mod.rs

@@ -100,6 +100,7 @@ mod test_include_001;
 mod test_include_002;
 mod test_include_003;
 mod test_moon_info;
+mod test_outline;
 mod test_moonbitlang_x;
 mod test_release;
 mod third_party;

crates/moon/tests/test_cases/test_outline.in/moon.mod.json

@@ -0,0 +1,10 @@
+{
+  "name": "username/outline",
+  "version": "0.1.0",
+  "readme": "README.md",
+  "repository": "",
+  "license": "",
+  "keywords": [],
+  "description": "",
+  "source": "src"
+}

crates/moon/tests/test_cases/test_outline.in/src/lib/hello.mbt

@@ -0,0 +1,11 @@
+test "alpha" {
+  let _ = 1
+}
+
+test {
+  let _ = 2
+}
+
+test "beta" {
+  let _ = 3
+}

crates/moon/tests/test_cases/test_outline.in/src/lib/moon.pkg.json

@@ -0,0 +1 @@
+{}

crates/moon/tests/test_cases/test_outline.in/src/main/main.mbt

@@ -0,0 +1,3 @@
+fn main {
+  ()
+}

crates/moon/tests/test_cases/test_outline.in/src/main/moon.pkg.json

@@ -0,0 +1,3 @@
+{
+  "is-main": true
+}

crates/moon/tests/test_cases/test_outline/mod.rs

@@ -0,0 +1,34 @@
+use crate::{TestDir, get_stdout, util::check};
+use expect_test::expect;
+
+fn normalize_outline(output: String) -> String {
+    let mut out = output
+        .lines()
+        .map(|line| line.trim_start())
+        .collect::<Vec<_>>()
+        .join("\n");
+    out.push('\n');
+    out
+}
+
+#[test]
+fn test_outline() {
+    let dir = TestDir::new("test_outline.in");
+    let output = normalize_outline(get_stdout(&dir, ["test", "--outline", "-q"]));
+    check(
+        output,
+        expect![[r#"
+1. username/outline/lib hello.mbt:1 index=0 name="alpha"
+2. username/outline/lib hello.mbt:5 index=1
+3. username/outline/lib hello.mbt:9 index=2 name="beta"
+"#]],
+    );
+
+    let output = normalize_outline(get_stdout(&dir, ["test", "--outline", "-q", "-F", "b*"]));
+    check(
+        output,
+        expect![[r#"
+1. username/outline/lib hello.mbt:9 index=2 name="beta"
+"#]],
+    );
+}