a command runs on a stack sized for the inference it does

`run`, `build`, `transpile` and `compile` check on the thread they were
dispatched to rather than through the rayon pool, and that thread got
whatever stack the platform starts a process with — 1 MiB on windows,
where checking a file that nests deeply enough overflowed it

Author: KotlinIsland

crates/basedpython/Cargo.lock

@@ -57,7 +57,30 @@ where
         .context("Failed to read CLI arguments from file")?;
     let args = Cli::parse_from(args);
 
-    match args.command {
+    // type inference recurses with the shape of the program it is checking, so
+    // how deep a file it can survive is decided by the stack it runs on. the
+    // rayon pool asks for `STACK_SIZE`, but the thread a process starts on gets a
+    // platform default — 1 MiB on windows — and the commands that check on the
+    // calling thread rather than through the pool (`run`, `build`, `transpile`,
+    // `compile`) were overflowing it there. so the whole command runs on a thread
+    // this codebase has sized for the job, wherever it is dispatched to
+    std::thread::scope(|scope| {
+        let command = std::thread::Builder::new()
+            .stack_size(STACK_SIZE)
+            .spawn_scoped(scope, || run_command(args.command))
+            .context("failed to start the worker thread")?;
+        match command.join() {
+            Ok(status) => status,
+            // the panic has already been reported by the default hook; carrying
+            // it across the join keeps the process behaving as if it never moved
+            // off the starting thread
+            Err(payload) => std::panic::resume_unwind(payload),
+        }
+    })
+}
+
+fn run_command(command: Command) -> anyhow::Result<ExitStatus> {
+    match command {
         Command::Server => run_server().map(|()| ExitStatus::Success),
         Command::Check(check_args) => run_check(check_args),
         Command::Version { output_format } => Ok(by_commands::cmd_version_by(output_format)),

crates/ty/src/lib.rs

@@ -294,6 +294,30 @@ fn run_executes_module() {
     );
 }
 
+/// inference recurses with the shape of the expression it is checking, and `run`
+/// checks on the thread it was dispatched to rather than through the rayon pool.
+/// on the stack a process starts with — 1 MiB on windows — a file like this one
+/// overflowed before that thread was sized for the work
+#[test]
+fn run_checks_a_deeply_nested_expression() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let terms = vec!["1"; 2000].join(" + ");
+    fs::write(dir.path().join("main.by"), format!("print({terms})\n")).unwrap();
+
+    let output = Command::new(env!("CARGO_BIN_EXE_by"))
+        .args(["run", "main"])
+        .current_dir(dir.path())
+        .output()
+        .expect("failed to spawn by");
+
+    assert!(
+        output.status.success(),
+        "by run failed:\n{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "2000");
+}
+
 #[test]
 fn run_force_unwrap_yields_inner_value() {
     // `Some(x)` lowers to the `Optional(x)` wrapper; force-unwrapping it must
@@ -1780,17 +1804,36 @@ fn build_writes_a_sourcemap_beside_the_generated_python() {
     let out = dir.path().join("out");
     let map = fs::read_to_string(out.join("_by_sourcemap.py")).expect("sourcemap module");
 
-    // the paths in the map are the ones the build ran against, so a symlinked
-    // temp dir (`/tmp` on macOS) is spelled resolved there and has to be here
-    let resolved = fs::canonicalize(&out).expect("out directory");
-    let py_key = format!("{:?}", resolved.join("main.py").to_string_lossy());
+    // read the keys out of the file rather than rebuilding them: the build
+    // spells a path the way the system handed it over, which is neither the
+    // test's `dir.path()` (a symlink under `/tmp` on macOS) nor its canonical
+    // form (a `\\?\` path with the long directory name on windows)
+    let first_key_of = |table: &str| {
+        let (_, body) = map
+            .split_once(&format!("{table} = {{\n"))
+            .unwrap_or_else(|| panic!("no {table} table:\n{map}"));
+        let entry = body.lines().next().expect("an entry");
+        entry
+            .trim()
+            .split_once(": ")
+            .unwrap_or_else(|| panic!("no key in {table}:\n{map}"))
+            .0
+            .to_owned()
+    };
+
+    let mapped = first_key_of("SOURCEMAP");
     assert!(
-        map.contains(&format!("SOURCEMAP = {{\n    {py_key}: (")),
+        mapped.ends_with("main.py\""),
         "the generated module should be mapped by its own path:\n{map}"
     );
+    assert_eq!(
+        mapped,
+        first_key_of("DIGESTS"),
+        "both tables key the same generated file:\n{map}"
+    );
     assert!(
-        map.contains(&format!("    {py_key}: {{\"by\": \"sha256:")),
-        "and digested under the same key:\n{map}"
+        map.contains(&format!("{mapped}: {{\"by\": \"sha256:")),
+        "the entry should carry a digest of each side:\n{map}"
     );
     // the runner shim belongs to `by run`; a build output is not an entry point
     assert!(