[Repo Assist] Add JSON SaveOptions property tests + STJ benchmark prototype (#1671) (#1694)

* Add JSON property tests for all SaveOptions + STJ benchmark prototype

Task 9: Add two new FsCheck property tests to JsonParserProperties.fs verifying
that JsonValue roundtrips correctly through all three JsonSaveOptions variants
(None/indented and CompactSpaceAfterComma were previously untested; only
DisableFormatting was covered by the existing property test).

Task 10: Add JsonStjBenchmarks.fs — a concrete prototype of 'Option 2' from
#1671 (keep the JsonValue public API, use System.Text.Json as the parsing kernel).
The StjConverter module converts JsonDocument → JsonValue and benchmarks it
against the current hand-written parser on three real-world JSON files (GitHub,
Twitter, WorldBank). No new NuGet dependencies — System.Text.Json is part of the
net8.0 shared framework. Updates Program.fs to support 'stj' benchmark target.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* ci: trigger checks

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

tests/FSharp.Data.Benchmarks/FSharp.Data.Benchmarks.fsproj

@@ -14,6 +14,7 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </EmbeddedResource>
     <Compile Include="JsonBenchmarks.fs" />
+    <Compile Include="JsonStjBenchmarks.fs" />
     <Compile Include="HtmlBenchmarks.fs" />
     <Compile Include="CsvBenchmarks.fs" />
     <Compile Include="Program.fs" />

tests/FSharp.Data.Benchmarks/JsonStjBenchmarks.fs

@@ -0,0 +1,84 @@
+/// Benchmark: System.Text.Json-backed parser vs current FSharp.Data hand-written parser
+/// Prototypes "Option 2" from https://github.com/fsprojects/FSharp.Data/issues/1671 —
+/// keep the JsonValue public API while using Utf8JsonReader / JsonDocument as the parsing kernel.
+///
+/// Run with: dotnet run -c Release -- stj
+namespace FSharp.Data.Benchmarks
+
+open System.IO
+open System.Text.Json
+open BenchmarkDotNet.Attributes
+open FSharp.Data
+
+/// Converts a System.Text.Json JsonElement into a FSharp.Data JsonValue.
+/// This is the prototype STJ backend that could replace the hand-written parser.
+module private StjConverter =
+
+    let rec ofJsonElement (el: JsonElement) : JsonValue =
+        match el.ValueKind with
+        | JsonValueKind.Null -> JsonValue.Null
+        | JsonValueKind.True -> JsonValue.Boolean true
+        | JsonValueKind.False -> JsonValue.Boolean false
+        | JsonValueKind.String -> JsonValue.String(el.GetString())
+        | JsonValueKind.Number ->
+            let mutable d = 0m
+
+            if el.TryGetDecimal(&d) then
+                JsonValue.Number(d)
+            else
+                JsonValue.Float(el.GetDouble())
+        | JsonValueKind.Array ->
+            el.EnumerateArray()
+            |> Seq.map ofJsonElement
+            |> Seq.toArray
+            |> JsonValue.Array
+        | JsonValueKind.Object ->
+            el.EnumerateObject()
+            |> Seq.map (fun p -> p.Name, ofJsonElement p.Value)
+            |> Seq.toArray
+            |> JsonValue.Record
+        | _ -> JsonValue.Null
+
+    /// Parse a JSON string to JsonValue using System.Text.Json as the parsing backend.
+    let parse (text: string) : JsonValue =
+        use doc = JsonDocument.Parse(text)
+        ofJsonElement doc.RootElement
+
+/// Compares the current FSharp.Data hand-written parser with a System.Text.Json-backed
+/// prototype on three representative real-world JSON files. See issue #1671 for context.
+[<MemoryDiagnoser>]
+[<SimpleJob>]
+type JsonStjBenchmarks() =
+
+    let mutable githubJsonText = ""
+    let mutable twitterJsonText = ""
+    let mutable worldBankJsonText = ""
+
+    [<GlobalSetup>]
+    member _.Setup() =
+        let dataPath = Path.Combine(__SOURCE_DIRECTORY__, "../FSharp.Data.Tests/Data")
+        githubJsonText <- File.ReadAllText(Path.Combine(dataPath, "GitHub.json"))
+        twitterJsonText <- File.ReadAllText(Path.Combine(dataPath, "TwitterSample.json"))
+        worldBankJsonText <- File.ReadAllText(Path.Combine(dataPath, "WorldBank.json"))
+
+    // ── Current hand-written parser (baseline) ──────────────────────────────────────
+
+    [<Benchmark(Baseline = true)>]
+    member _.ParseGitHub_Current() = JsonValue.Parse(githubJsonText)
+
+    [<Benchmark>]
+    member _.ParseTwitter_Current() = JsonValue.Parse(twitterJsonText)
+
+    [<Benchmark>]
+    member _.ParseWorldBank_Current() = JsonValue.Parse(worldBankJsonText)
+
+    // ── STJ-backed prototype (Option 2 from #1671) ──────────────────────────────────
+
+    [<Benchmark>]
+    member _.ParseGitHub_Stj() = StjConverter.parse githubJsonText
+
+    [<Benchmark>]
+    member _.ParseTwitter_Stj() = StjConverter.parse twitterJsonText
+
+    [<Benchmark>]
+    member _.ParseWorldBank_Stj() = StjConverter.parse worldBankJsonText

tests/FSharp.Data.Benchmarks/Program.fs

@@ -12,11 +12,13 @@ let main args =
     | [| "conversions" |] -> BenchmarkRunner.Run<JsonConversionBenchmarks>() |> ignore
     | [| "html" |] -> BenchmarkRunner.Run<HtmlBenchmarks>() |> ignore
     | [| "csv" |] -> BenchmarkRunner.Run<CsvBenchmarks>() |> ignore
+    | [| "stj" |] -> BenchmarkRunner.Run<JsonStjBenchmarks>() |> ignore
     | _ ->
         printfn "Running all benchmarks..."
         BenchmarkRunner.Run<JsonBenchmarks>() |> ignore
         BenchmarkRunner.Run<JsonConversionBenchmarks>() |> ignore
         BenchmarkRunner.Run<HtmlBenchmarks>() |> ignore
         BenchmarkRunner.Run<CsvBenchmarks>() |> ignore
+        BenchmarkRunner.Run<JsonStjBenchmarks>() |> ignore
 
     0

tests/FSharp.Data.Core.Tests/JsonParserProperties.fs

@@ -120,15 +120,34 @@ let unescape s =
     r.Replace(s, convert)
 
 [<Test>]
-let  ``Parsing stringified JsonValue returns the same JsonValue`` () =
+let ``Parsing stringified JsonValue returns the same JsonValue`` () =
     Arb.register<Generators>() |> ignore
 
     let parseStringified (json: JsonValue) =
         json.ToString(JsonSaveOptions.DisableFormatting)
         |> JsonValue.Parse = json
 
-    Check.One ({Config.QuickThrowOnFailure with MaxTest = 1000},
-               parseStringified)
+    Check.One({Config.QuickThrowOnFailure with MaxTest = 1000}, parseStringified)
+
+[<Test>]
+let ``Parsing JsonValue formatted with None (indented) returns the same JsonValue`` () =
+    Arb.register<Generators>() |> ignore
+
+    let parseFormatted (json: JsonValue) =
+        json.ToString(JsonSaveOptions.None)
+        |> JsonValue.Parse = json
+
+    Check.One({Config.QuickThrowOnFailure with MaxTest = 500}, parseFormatted)
+
+[<Test>]
+let ``Parsing JsonValue formatted with CompactSpaceAfterComma returns the same JsonValue`` () =
+    Arb.register<Generators>() |> ignore
+
+    let parseCompact (json: JsonValue) =
+        json.ToString(JsonSaveOptions.CompactSpaceAfterComma)
+        |> JsonValue.Parse = json
+
+    Check.One({Config.QuickThrowOnFailure with MaxTest = 500}, parseCompact)
 
 [<Test>]
 let ``Stringifying parsed string returns the same string`` () =