dastest: quote spaced args in launchPrefix + regression test + typo (Copilot)

Address Copilot review on PR #2897:

1. Quoting (#3308736517): launchPrefix builds singleTest as a space-joined string. When any preserved pre-`--` arg contains a space (e.g. `-load_module "C:\Program Files\daslang/dasImgui"`), popen's shell-split on the other side breaks the boundary. Pre-fix this was a latent risk on raw_args[0]/raw_args[1] too; extending preservation to all pre-`--` args makes it more likely. Wrap each space-containing arg in double quotes — both cmd.exe and /bin/sh honor double-quote-wrapped args.

2. Regression test (#3308736537): add a second subtest in test_isolated_mode that spawns dastest with a pre-`--` `-dasroot {get_das_root()}` (no-op value) and runs against a new _isolated_fixture_pre_dashdash/ subdir whose fixture test asserts -dasroot is in get_command_line_arguments(). Catches any regression of the launchPrefix reconstruction.

3. Typo (#3308736556): "Findex" → "Find index" in the launchPrefix comment.

Verified: full dastest sweep 9/9 pass (was 8/8, +1 new subtest).

Author: borisbat

dastest/dastest.das

@@ -395,15 +395,20 @@ def main() : int {
         // dastest.das, --, ...], the old "raw_args[0] raw_args[1]" reconstruction
         // produced "daslang -load_module" — losing the flag value, breaking
         // local runs that point dastest at an external module via -load_module.
-        // Findex of `--` ≥ 0 always (dastest was invoked with `--` to receive
+        // Find index of `--` ≥ 0 always (dastest was invoked with `--` to receive
         // its own args); fall back to all raw_args if not, matching the old
-        // 2-arg implicit assumption.
+        // 2-arg implicit assumption. Quote any arg containing a space so paths
+        // like `C:/Program Files/...` survive popen's shell-split on the other
+        // side; both cmd.exe and /bin/sh honor double-quote-wrapped args.
         let dashdash = find_index(raw_args, "--")
         let launchPrefix = build_string() $(var w) {
             let n = dashdash > 0 ? dashdash : length(raw_args)
             for (i in range(n)) {
                 if (i > 0) w |> write(" ")
+                let needs_quote = raw_args[i] |> contains(" ")
+                if (needs_quote) w |> write("\"")
                 w |> write(raw_args[i])
+                if (needs_quote) w |> write("\"")
             }
         }
         log::info("Running {totalFiles} tests in isolated mode with {totalThreads} threads\n")

dastest/tests/_isolated_fixture_pre_dashdash/test_preserved_flag.das

@@ -0,0 +1,23 @@
+options gen2
+
+require dastest/testing_boost public
+require strings
+
+// This fixture asserts that a daslang flag passed BEFORE the dastest.das
+// script (e.g. `daslang -dasroot <path> dastest.das -- ...`) is preserved
+// through dastest's isolated-mode singleTest cmd reconstruction. The outer
+// test_isolated_mode.das spawns dastest with a pre-`--` `-dasroot` flag;
+// this fixture runs in the spawned subprocess and checks that `-dasroot`
+// is in its own raw argv (because dastest preserved it via launchPrefix).
+[test]
+def test_preserved_flag_round_trip(tt : T?) {
+    tt |> run("dastest preserves pre-`--` daslang flags in isolated-mode subprocess argv") <| @(t : T?) {
+        let argv <- get_command_line_arguments()
+        let idx = find_index(argv, "-dasroot")
+        t |> success(idx >= 0, "expected -dasroot in argv, got argv={argv}")
+        if (idx < 0) {
+            return
+        }
+        t |> success(idx + 1 < length(argv), "-dasroot has no following path arg in argv")
+    }
+}

dastest/tests/test_isolated_mode.das

@@ -15,9 +15,11 @@ def fixture_dir() : string {
     return "{dastest_root()}/tests/_isolated_fixture"
 }
 
-def run_isolated(var output : string&; var exit_code : int&) {
-    let exe = get_command_line_arguments()[0]
-    let cmd = "{exe} {dastest_root()}/dastest.das -- --test {fixture_dir()} --isolated-mode --isolated-mode-threads 4"
+def fixture_dir_pre_dashdash() : string {
+    return "{dastest_root()}/tests/_isolated_fixture_pre_dashdash"
+}
+
+def run_dastest(cmd : string; var output : string&; var exit_code : int&) {
     output = ""
     unsafe {
         exit_code = popen(cmd) $(f) {
@@ -33,9 +35,26 @@ def run_isolated(var output : string&; var exit_code : int&) {
 [test]
 def test_isolated_mode(tt : T?) {
     tt |> run("isolated mode spawns 4 workers, fixture suite all passes, --worker-index round-trips") <| @(t : T?) {
+        let exe = get_command_line_arguments()[0]
+        let cmd = "{exe} {dastest_root()}/dastest.das -- --test {fixture_dir()} --isolated-mode --isolated-mode-threads 4"
+        var output : string
+        var exit_code : int
+        run_dastest(cmd, output, exit_code)
+        t |> equal(exit_code, 0)
+        t |> success(output |> contains("SUCCESS"), "expected SUCCESS in dastest output, got:\n{output}")
+    }
+
+    tt |> run("isolated mode preserves pre-`--` daslang flags (-dasroot) in singleTest cmd") <| @(t : T?) {
+        // Pass `-dasroot {existing-dasroot}` — a no-op pre-`--` flag — to the outer
+        // dastest. Pre-fix, dastest's singleTest reconstruction used
+        // `raw_args[0] raw_args[1]` which dropped everything between exe and
+        // dastest.das. The fixture test under fixture_dir_pre_dashdash() asserts
+        // -dasroot survives into the spawned subprocess's argv.
+        let exe = get_command_line_arguments()[0]
+        let cmd = "{exe} -dasroot {get_das_root()} {dastest_root()}/dastest.das -- --test {fixture_dir_pre_dashdash()} --isolated-mode --isolated-mode-threads 1"
         var output : string
         var exit_code : int
-        run_isolated(output, exit_code)
+        run_dastest(cmd, output, exit_code)
         t |> equal(exit_code, 0)
         t |> success(output |> contains("SUCCESS"), "expected SUCCESS in dastest output, got:\n{output}")
     }