From 9b68944680b4858137c50c65d4c9ce14c89f8349 Mon Sep 17 00:00:00 2001
From: Copilot <copilot@github.com>
Date: Tue, 9 Jun 2026 22:10:26 +0200
Subject: [PATCH 1/4] Add failing regression tests for #10819
 (fsi.CommandLineArgs ignores --)

RED phase: pin down the correct behaviour of fsi.CommandLineArgs when user

arguments follow the -- separator. The abbreviated flags -d, -r, -I are

currently colon-joined with their next token (e.g. '-- -d 5' becomes '-d:5'

instead of staying as two tokens), which these tests assert against.

Theory rows fail on current main; the baseline [<Fact>] passes and locks in

the current treatment of non-abbreviated post-'--' args so the GREEN fix

cannot regress them.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../fsi/FsiCommandLineArgsTests.fs            | 80 +++++++++++++++++++
 .../FSharp.Compiler.ComponentTests.fsproj     |  1 +
 2 files changed, 81 insertions(+)
 create mode 100644 tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs

diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs
new file mode 100644
index 00000000000..935cd0e2d58
--- /dev/null
+++ b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace CompilerOptions.Fsi
+
+open System
+open System.IO
+open Xunit
+open FSharp.Test
+open FSharp.Test.Compiler
+
+/// Regression tests for https://github.com/dotnet/fsharp/issues/10819
+/// fsi.CommandLineArgs must preserve every token after `--` byte-for-byte;
+/// in particular abbreviated flags like -d / -r / -I that follow `--` must
+/// NOT be colon-joined with their next argument.
+module FsiCommandLineArgsTests =
+
+    let private writeProbeScript () : string =
+        // Prints one ARG=<value> line per element of fsi.CommandLineArgs so the
+        // test can parse exact contents from stdout.
+        let body = """
+for a in fsi.CommandLineArgs do
+    printfn "ARG=%s" a
+"""
+        let path =
+            Path.Combine(
+                Path.GetTempPath(),
+                sprintf "fsi_cmdline_%s.fsx" (Guid.NewGuid().ToString("N")))
+        File.WriteAllText(path, body)
+        path
+
+    let private parseArgsFromStdOut (stdout: string) : string list =
+        stdout.Split([| '\r'; '\n' |], StringSplitOptions.RemoveEmptyEntries)
+        |> Array.choose (fun line ->
+            if line.StartsWith("ARG=") then Some (line.Substring(4)) else None)
+        |> Array.toList
+
+    /// Run fsi <script> <extra args> and return the parsed fsi.CommandLineArgs
+    /// (without index 0, which is the absolute script path and varies per run).
+    let private runAndGetTail (extraArgs: string list) : string list =
+        let scriptPath = writeProbeScript ()
+        try
+            let result = runFsiProcess (scriptPath :: extraArgs)
+            Assert.True(
+                result.ExitCode = 0,
+                sprintf "fsi exited %d. stdout=%s stderr=%s"
+                    result.ExitCode result.StdOut result.StdErr)
+            match parseArgsFromStdOut result.StdOut with
+            | [] ->
+                failwithf "No ARG= lines in stdout. stdout=%s stderr=%s"
+                    result.StdOut result.StdErr
+            | _ :: tail -> tail
+        finally
+            try File.Delete(scriptPath) with _ -> ()
+
+    // Primary regression theory for #10819: with `--`, abbreviated flags and
+    // arbitrary user tokens must reach the script verbatim.
+    [<Theory>]
+    [<InlineData("-d,5",            "-d,5")>]
+    [<InlineData("-r,5",            "-r,5")>]
+    [<InlineData("-I,5",            "-I,5")>]
+    [<InlineData("--foo,--bar=baz", "--foo,--bar=baz")>]
+    [<InlineData("a:b,c:d",         "a:b,c:d")>]
+    let ``fsi.CommandLineArgs preserves args after -- verbatim``
+        (userArgsCsv: string) (expectedCsv: string) =
+        let userArgs = userArgsCsv.Split(',') |> Array.toList
+        let expected = expectedCsv.Split(',') |> Array.toList
+        // Script appears before `--`; the script-arg tail follows `--`.
+        let tail = runAndGetTail ("--" :: userArgs)
+        Assert.Equal<string list>(expected, tail)
+
+    // Baseline: -b is not an abbreviated flag, so it already round-trips through
+    // `--` today without colon-joining. Locks in the only piece of current
+    // behaviour that is correct, so the GREEN fix can't accidentally regress
+    // unrelated tokens. NOTE: the `--` itself is still present in
+    // fsi.CommandLineArgs on main; the GREEN sprint may also strip it, in
+    // which case this baseline will need a matching update at that point.
+    [<Fact>]
+    let ``fsi.CommandLineArgs preserves non-abbreviated args after -- (baseline)`` () =
+        let tail = runAndGetTail ["--"; "-b"; "5"]
+        Assert.Equal<string list>(["--"; "-b"; "5"], tail)
diff --git a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
index 954c02b8aca..ae9b2c43064 100644
--- a/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
+++ b/tests/FSharp.Compiler.ComponentTests/FSharp.Compiler.ComponentTests.fsproj
@@ -449,6 +449,7 @@
     <Compile Include="CompilerOptions\Fsc\pdb\Pdb.fs" />
     <Compile Include="CompilerOptions\fsc\tailcalls\tailcalls.fs" />
     <Compile Include="CompilerOptions\fsi\FsiCliTests.fs" />
+    <Compile Include="CompilerOptions\fsi\FsiCommandLineArgsTests.fs" />
     <Compile Include="CompilerOptions\fsi\Nologo.fs" />
     <Compile Include="CompilerOptions\fsi\Langversion.fs" />
     <Compile Include="CompilerService\RangeModule.fs" />

From a03202c833054c7ccbbf0177bf05fea10f3ee3bf Mon Sep 17 00:00:00 2001
From: Copilot <copilot@github.com>
Date: Tue, 9 Jun 2026 22:42:36 +0200
Subject: [PATCH 2/4] Stop PostProcessCompilerArgs from mutating fsi script
 args after -- (fix #10819)

Split argv at the first `--` and only post-process the compiler-args prefix; the suffix (including the `--` separator itself) reaches downstream handlers byte-for-byte. Keeping `--` in the suffix preserves two paths:

* with a script preceding `--`, the script's OptionGeneral IsScript handler captures the suffix as script args (matching pre-fix behaviour for fsi.CommandLineArgs);

* with no script (e.g. `dotnet fsi -- -d 5`), the `--` token reaches ParseCompilerOptions and fires its OptionRest recordExplicitArg handler so `-d` and `5` are recorded as explicit args instead of being parsed as compiler options.

Updates the regression test theory to expect `--` in the captured tail and adds a new no-script Fact that locks the OptionRest path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Compiler/Interactive/fsi.fs               | 23 ++++++-
 .../fsi/FsiCommandLineArgsTests.fs            | 66 ++++++++++++++++---
 2 files changed, 78 insertions(+), 11 deletions(-)

diff --git a/src/Compiler/Interactive/fsi.fs b/src/Compiler/Interactive/fsi.fs
index 30801263752..4c633d85707 100644
--- a/src/Compiler/Interactive/fsi.fs
+++ b/src/Compiler/Interactive/fsi.fs
@@ -1225,7 +1225,28 @@ type internal FsiCommandLineOptions(fsi: FsiEvaluationSessionHostConfig, argv: s
                 @ fsiUsageSuffix tcConfigB
 
             let abbrevArgs = GetAbbrevFlagSet tcConfigB false
-            ParseCompilerOptions(collect, fsiCompilerOptions, List.tail (PostProcessCompilerArgs abbrevArgs argv))
+            // PostProcessCompilerArgs rewrites abbreviated flags like `-d 5` to `-d:5`.
+            // We must NOT apply that rewrite to user-script arguments that follow `--`,
+            // otherwise fsi.CommandLineArgs leaks the rewrite to scripts (see #10819).
+            // Split argv at the first `--`, post-process only the compiler-args prefix,
+            // and pass the suffix (including the `--` separator itself) through unmodified.
+            // Keeping `--` in the suffix preserves both downstream handlers:
+            //   * with a script preceding `--`, the OptionGeneral IsScript handler captures
+            //     the suffix as script args (matching pre-fix behaviour for fsi.CommandLineArgs);
+            //   * with no script (e.g. `dotnet fsi -- -d 5`), the `--` token reaches
+            //     ParseCompilerOptions and fires its OptionRest recordExplicitArg handler,
+            //     so `-d` and `5` are captured as explicit args instead of being parsed
+            //     as compiler options.
+            let processedArgs =
+                match Array.tryFindIndex (fun (a: string) -> a = "--") argv with
+                | Some idx ->
+                    let prefix = argv[0 .. idx - 1]
+                    let suffix = argv[idx ..]
+                    PostProcessCompilerArgs abbrevArgs prefix @ List.ofArray suffix
+                | None ->
+                    PostProcessCompilerArgs abbrevArgs argv
+
+            ParseCompilerOptions(collect, fsiCompilerOptions, List.tail processedArgs)
         with e ->
             stopProcessingRecovery e range0
             failwithf "Error creating evaluation session: %A" e
diff --git a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs
index 935cd0e2d58..10754e1684c 100644
--- a/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs
+++ b/tests/FSharp.Compiler.ComponentTests/CompilerOptions/fsi/FsiCommandLineArgsTests.fs
@@ -16,8 +16,12 @@ module FsiCommandLineArgsTests =
 
     let private writeProbeScript () : string =
         // Prints one ARG=<value> line per element of fsi.CommandLineArgs so the
-        // test can parse exact contents from stdout.
+        // test can parse exact contents from stdout. A leading empty `printfn`
+        // ensures the first ARG= line is never prefixed by an FSI `> ` prompt
+        // (which only matters when the probe runs interactively via --use,
+        // not when it is invoked as the script-file argument directly).
         let body = """
+printfn ""
 for a in fsi.CommandLineArgs do
     printfn "ARG=%s" a
 """
@@ -53,13 +57,16 @@ for a in fsi.CommandLineArgs do
             try File.Delete(scriptPath) with _ -> ()
 
     // Primary regression theory for #10819: with `--`, abbreviated flags and
-    // arbitrary user tokens must reach the script verbatim.
+    // arbitrary user tokens must reach the script verbatim. The `--` separator
+    // itself is included in fsi.CommandLineArgs (matching pre-fix behaviour);
+    // the GREEN fix only stops PostProcessCompilerArgs from colon-joining the
+    // abbreviated flags that follow it.
     [<Theory>]
-    [<InlineData("-d,5",            "-d,5")>]
-    [<InlineData("-r,5",            "-r,5")>]
-    [<InlineData("-I,5",            "-I,5")>]
-    [<InlineData("--foo,--bar=baz", "--foo,--bar=baz")>]
-    [<InlineData("a:b,c:d",         "a:b,c:d")>]
+    [<InlineData("-d,5",            "--,-d,5")>]
+    [<InlineData("-r,5",            "--,-r,5")>]
+    [<InlineData("-I,5",            "--,-I,5")>]
+    [<InlineData("--foo,--bar=baz", "--,--foo,--bar=baz")>]
+    [<InlineData("a:b,c:d",         "--,a:b,c:d")>]
     let ``fsi.CommandLineArgs preserves args after -- verbatim``
         (userArgsCsv: string) (expectedCsv: string) =
         let userArgs = userArgsCsv.Split(',') |> Array.toList
@@ -71,10 +78,49 @@ for a in fsi.CommandLineArgs do
     // Baseline: -b is not an abbreviated flag, so it already round-trips through
     // `--` today without colon-joining. Locks in the only piece of current
     // behaviour that is correct, so the GREEN fix can't accidentally regress
-    // unrelated tokens. NOTE: the `--` itself is still present in
-    // fsi.CommandLineArgs on main; the GREEN sprint may also strip it, in
-    // which case this baseline will need a matching update at that point.
+    // unrelated tokens.
     [<Fact>]
     let ``fsi.CommandLineArgs preserves non-abbreviated args after -- (baseline)`` () =
         let tail = runAndGetTail ["--"; "-b"; "5"]
         Assert.Equal<string list>(["--"; "-b"; "5"], tail)
+
+    // No-script regression for #10819: when `--` appears without a preceding
+    // script-file argument, ParseCompilerOptions must see `--` so its
+    // OptionRest recordExplicitArg handler fires. If the GREEN fix were to
+    // strip `--` from the suffix, `-d` and `5` would instead be parsed as
+    // compiler options (and `-d` would fail to bind without its joined
+    // value), so this row locks the OptionRest path.
+    [<Fact>]
+    let ``fsi.CommandLineArgs preserves args after -- with no script (OptionRest path)`` () =
+        let scriptPath = writeProbeScript ()
+        try
+            // --use:<script> + --exec loads the probe script then exits without
+            // making the script path the first non-option arg, so the IsScript
+            // OptionGeneral handler does NOT fire and the `--` token reaches
+            // ParseCompilerOptions' OptionRest handler instead. --nologo
+            // suppresses the banner so the FSI prompt prefix does not bleed
+            // into the parsed ARG= lines.
+            let result =
+                runFsiProcess
+                    [ "--nologo"
+                      "--use:" + scriptPath
+                      "--exec"
+                      "--"
+                      "-d"
+                      "5" ]
+            Assert.True(
+                result.ExitCode = 0,
+                sprintf "fsi exited %d. stdout=%s stderr=%s"
+                    result.ExitCode result.StdOut result.StdErr)
+            let args = parseArgsFromStdOut result.StdOut
+            // With no script before `--`, OptionRest captured only the tokens
+            // AFTER `--`; the `--` itself is consumed by ParseCompilerOptions.
+            // args[0] is the fsi binary path; the tail must be exactly `-d 5`.
+            match args with
+            | [] ->
+                failwithf "No ARG= lines in stdout. stdout=%s stderr=%s"
+                    result.StdOut result.StdErr
+            | _ :: tail ->
+                Assert.Equal<string list>([ "-d"; "5" ], tail)
+        finally
+            try File.Delete(scriptPath) with _ -> ()

From 01b9f62e148f6351c3f9b4c5a53db59ae1a8726c Mon Sep 17 00:00:00 2001
From: Copilot <copilot@github.com>
Date: Wed, 10 Jun 2026 01:06:01 +0200
Subject: [PATCH 3/4] Format and document #10819 fix

Fantomas-applied formatting in src/Compiler/Interactive/fsi.fs (whitespace
and pattern-match line collapse only; no behavioural change) and a single
new bullet under ### Fixed in docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
referencing Issue #10819.

Validation: focused regression filters (FsiCommandLineArgsTests,
CommandLineArgs, FsiCliTests) green under -c Release on both net10.0 and
net48. SurfaceAreaTest passes on net10.0 with no baseline update (net48
has zero tests for that filter - platform-conditional). Full
FSharp.Compiler.ComponentTests and FSharp.Compiler.Service.Tests suites
were run under -c Release as the documented alternative to
'./build.sh -c Release --testcoreclr'; the only failures observed were
two well-known flaky ScriptOptionsTests nuget-resolution tests on net48
(unrelated to argument handling; confirmed flaky in isolation; net10.0
runs all 4364 tests green).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/release-notes/.FSharp.Compiler.Service/11.0.100.md | 1 +
 src/Compiler/Interactive/fsi.fs                         | 5 ++---
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
index 965957dbc0c..d8d657505ff 100644
--- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
+++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
@@ -75,6 +75,7 @@
 ([PR #19724](https://github.com/dotnet/fsharp/pull/19724))
 * Emit debug points at a stack-empty position ([PR #19877](https://github.com/dotnet/fsharp/pull/19877))
 * Fix spurious XmlDoc warnings (unknown parameter / no documentation for parameter) under `--warnon:3390` when a get/set property documents the full parameter set across both accessors. ([Issue #13684](https://github.com/dotnet/fsharp/issues/13684), [PR #19884](https://github.com/dotnet/fsharp/pull/19884))
+* Stop F# Interactive from mutating script arguments that follow `--`. Abbreviated flags like `-d`, `-r`, `-I` after the `--` separator are no longer colon-joined with their next token in `fsi.CommandLineArgs`. ([Issue #10819](https://github.com/dotnet/fsharp/issues/10819))
 
 ### Added
 
diff --git a/src/Compiler/Interactive/fsi.fs b/src/Compiler/Interactive/fsi.fs
index 4c633d85707..cdc6cb0c56d 100644
--- a/src/Compiler/Interactive/fsi.fs
+++ b/src/Compiler/Interactive/fsi.fs
@@ -1241,10 +1241,9 @@ type internal FsiCommandLineOptions(fsi: FsiEvaluationSessionHostConfig, argv: s
                 match Array.tryFindIndex (fun (a: string) -> a = "--") argv with
                 | Some idx ->
                     let prefix = argv[0 .. idx - 1]
-                    let suffix = argv[idx ..]
+                    let suffix = argv[idx..]
                     PostProcessCompilerArgs abbrevArgs prefix @ List.ofArray suffix
-                | None ->
-                    PostProcessCompilerArgs abbrevArgs argv
+                | None -> PostProcessCompilerArgs abbrevArgs argv
 
             ParseCompilerOptions(collect, fsiCompilerOptions, List.tail processedArgs)
         with e ->

From dd50e9d03b7c9834eb140cd101b964e9ea7e6bba Mon Sep 17 00:00:00 2001
From: Copilot <copilot@github.com>
Date: Wed, 10 Jun 2026 01:42:35 +0200
Subject: [PATCH 4/4] Add PR link to release notes entry for #10819

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/release-notes/.FSharp.Compiler.Service/11.0.100.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
index d8d657505ff..785b6df131a 100644
--- a/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
+++ b/docs/release-notes/.FSharp.Compiler.Service/11.0.100.md
@@ -75,7 +75,7 @@
 ([PR #19724](https://github.com/dotnet/fsharp/pull/19724))
 * Emit debug points at a stack-empty position ([PR #19877](https://github.com/dotnet/fsharp/pull/19877))
 * Fix spurious XmlDoc warnings (unknown parameter / no documentation for parameter) under `--warnon:3390` when a get/set property documents the full parameter set across both accessors. ([Issue #13684](https://github.com/dotnet/fsharp/issues/13684), [PR #19884](https://github.com/dotnet/fsharp/pull/19884))
-* Stop F# Interactive from mutating script arguments that follow `--`. Abbreviated flags like `-d`, `-r`, `-I` after the `--` separator are no longer colon-joined with their next token in `fsi.CommandLineArgs`. ([Issue #10819](https://github.com/dotnet/fsharp/issues/10819))
+* Stop F# Interactive from mutating script arguments that follow `--`. Abbreviated flags like `-d`, `-r`, `-I` after the `--` separator are no longer colon-joined with their next token in `fsi.CommandLineArgs`. ([Issue #10819](https://github.com/dotnet/fsharp/issues/10819), [PR #19926](https://github.com/dotnet/fsharp/pull/19926))
 
 ### Added