Isolate planner comparison and ownership drop on small stack

2026-09-24 16:39:46 -07:00
parent f1c095654a
commit 18073a6f2e
2 changed files with 67 additions and 56 deletions
@@ -478,63 +478,70 @@ fn combined_shrink_offsets_typed_growth_and_counts_untouched_files() {
 }
 #[test]
 fn deep_and_wide_equality_and_late_refusal_drop_on_small_stack() {
-    std::thread::Builder::new()
-        .stack_size(128 * 1024)
-        .spawn(|| {
-            for (expression, result, nodes) in [
-                (
-                    format!("{}1{}", "abs(".repeat(127), ")".repeat(127)),
-                    "Number",
-                    128,
-                ),
-                (
-                    format!("[{}]", vec!["1"; 128].join(", ")),
-                    "List(Number)",
-                    129,
-                ),
-            ] {
-                let bundle = single(&format!(
-                    "calculation c \"C\" id \"{}\" {{ result {result}; body {expression}; }}",
-                    id(2)
-                ));
-                // One shared source/desired/result layout exercises all cases
-                // without separate large debug temporaries for each branch.
-                for mode in 0..3 {
-                    let source = authored(&bundle);
-                    assert_eq!(source.indexed.resolved.expressions.len(), nodes);
-                    let mut desired = source.project().clone();
-                    match mode {
-                        0 => {}
-                        1 => desired.definitions.get_mut(&id(2)).unwrap().alias = "p".into(),
-                        _ => calculation(&mut desired, 2).body = a::Binding::Unbound,
-                    }
-                    let result = source.plan_rename(&desired);
-                    match result {
-                        Ok(plan) => {
-                            assert_eq!(mode, 0, "mutation unexpectedly accepted");
-                            drop(plan);
-                        }
-                        Err(failure) => {
-                            assert_ne!(mode, 0, "unchanged target unexpectedly refused");
-                            assert_eq!(failure.diagnostics.len(), 1);
-                            assert_eq!(
-                                failure.diagnostics[0].diagnostic.message,
-                                if mode == 1 {
-                                    "Rename aliases collide in their final namespace."
-                                } else {
-                                    "Rename target changes non-name project semantics."
-                                }
-                            );
-                            drop(failure);
-                        }
-                    }
-                    drop(desired);
-                }
+    for (expression, result, nodes) in [
+        (
+            format!("{}1{}", "abs(".repeat(127), ")".repeat(127)),
+            "Number",
+            128,
+        ),
+        (
+            format!("[{}]", vec!["1"; 128].join(", ")),
+            "List(Number)",
+            129,
+        ),
+    ] {
+        let bundle = single(&format!(
+            "calculation c \"C\" id \"{}\" {{ result {result}; body {expression}; }}",
+            id(2)
+        ));
+        for mode in 0..3 {
+            // Admission/intent construction are prerequisites, outside the
+            // bounded planner worker. No limits or live owner state are reset.
+            let source = authored(&bundle);
+            assert_eq!(source.indexed.resolved.expressions.len(), nodes);
+            let mut desired = source.project().clone();
+            match mode {
+                0 => {}
+                1 => desired.definitions.get_mut(&id(2)).unwrap().alias = "p".into(),
+                _ => calculation(&mut desired, 2).body = a::Binding::Unbound,
            }
-        })
-        .unwrap()
-        .join()
-        .unwrap();
+            std::thread::scope(|scope| {
+                let desired = &desired;
+                std::thread::Builder::new()
+                    .stack_size(128 * 1024)
+                    .spawn_scoped(scope, move || {
+                        // The complete owner moves into this worker; successful
+                        // plans and consumed failure owners die here. Nothing
+                        // carrying source/edit authority escapes the worker.
+                        match source.plan_rename(desired) {
+                            Ok(plan) => {
+                                assert_eq!(mode, 0, "mutation unexpectedly accepted");
+                                assert!(plan.edits().is_empty());
+                                assert!(std::ptr::eq(plan.desired(), desired));
+                                drop(plan);
+                            }
+                            Err(failure) => {
+                                assert_ne!(mode, 0, "unchanged target unexpectedly refused");
+                                assert_eq!(failure.diagnostics.len(), 1);
+                                assert_eq!(
+                                    failure.diagnostics[0].diagnostic.message,
+                                    if mode == 1 {
+                                        "Rename aliases collide in their final namespace."
+                                    } else {
+                                        "Rename target changes non-name project semantics."
+                                    }
+                                );
+                                drop(failure);
+                            }
+                        }
+                    })
+                    .unwrap()
+                    .join()
+                    .unwrap();
+            });
+            drop(desired);
+        }
+    }
 }
 #[test]
 fn zero_expression_original_rejects_target_only_deep_and_wide_variants() {