First release (#10)

.github/workflows/dotnet.yaml

@@ -33,10 +33,10 @@ jobs:
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-    - name: Restore dependencies
+    - name: Build source generator
-      run: nix develop --command dotnet restore
+      run: nix develop --command dotnet build WoofWare.Whippet/
-    - name: Build
+    - name: Build solution
-      run: nix develop --command dotnet build --no-restore --configuration ${{matrix.config}}
+      run: nix develop --command dotnet build --configuration ${{matrix.config}}
     - name: Test
       run: nix develop --command dotnet test --no-build --verbosity normal --configuration ${{matrix.config}}
 
@@ -61,20 +61,20 @@ jobs:
       - name: Run analyzers
         run: nix run .#fsharp-analyzers -- --project ./WoofWare.Whippet/WoofWare.Whippet.fsproj --analyzers-path ./.analyzerpackages/g-research.fsharp.analyzers/*/ --verbosity detailed --report ./analysis.sarif --treat-as-error GRA-STRING-001 GRA-STRING-002 GRA-STRING-003 GRA-UNIONCASE-001 GRA-INTERPOLATED-001 GRA-TYPE-ANNOTATE-001 GRA-VIRTUALCALL-001 GRA-IMMUTABLECOLLECTIONEQUALITY-001 GRA-JSONOPTS-001 GRA-LOGARGFUNCFULLAPP-001 GRA-DISPBEFOREASYNC-001 --exclude-analyzers PartialAppAnalyzer
 
-  build-nix:
+#   build-nix:
-    runs-on: ubuntu-latest
+#     runs-on: ubuntu-latest
-    steps:
+#     steps:
-      - name: Checkout
+#       - name: Checkout
-        uses: actions/checkout@v4
+#         uses: actions/checkout@v4
-      - name: Install Nix
+#       - name: Install Nix
-        uses: cachix/install-nix-action@v29
+#         uses: cachix/install-nix-action@v29
-        with:
+#         with:
-          extra_nix_config: |
+#           extra_nix_config: |
-            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+#             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-      - name: Build
+#       - name: Build
-        run: nix build
+#         run: nix build
-      - name: Reproducibility check
+#       - name: Reproducibility check
-        run: nix build --rebuild
+#         run: nix build --rebuild
 
   check-dotnet-format:
     runs-on: ubuntu-latest
@@ -139,10 +139,10 @@ jobs:
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-    - name: Restore dependencies
+    - name: Build source generator
-      run: nix develop --command dotnet restore
+      run: nix develop --command dotnet build WoofWare.Whippet/
-    - name: Build
+    - name: Build solution
-      run: nix develop --command dotnet build --no-restore --configuration Release
+      run: nix develop --command dotnet build --configuration Release
     - name: Pack
       run: nix develop --command dotnet pack --configuration Release
     - name: Upload NuGet artifact (runner)
@@ -160,6 +160,26 @@ jobs:
       with:
         name: nuget-package-fantomas
         path: WoofWare.Whippet.Fantomas/bin/Release/WoofWare.Whippet.Fantomas.*.nupkg
+    - name: Upload NuGet artifact (JSON attrs)
+      uses: actions/upload-artifact@v4
+      with:
+        name: nuget-package-json-attrs
+        path: Plugins/Json/WoofWare.Whippet.Plugin.Json.Attributes/bin/Release/WoofWare.Whippet.Plugin.Json.*.nupkg
+    - name: Upload NuGet artifact (JSON plugin)
+      uses: actions/upload-artifact@v4
+      with:
+        name: nuget-package-json
+        path: Plugins/Json/WoofWare.Whippet.Plugin.Json/bin/Release/WoofWare.Whippet.Plugin.Json.*.nupkg
+    - name: Upload NuGet artifact (argparser attrs)
+      uses: actions/upload-artifact@v4
+      with:
+        name: nuget-package-argparser-attrs
+        path: Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Attributes/bin/Release/WoofWare.Whippet.Plugin.ArgParser.*.nupkg
+    - name: Upload NuGet artifact (argparser plugin)
+      uses: actions/upload-artifact@v4
+      with:
+        name: nuget-package-argparser
+        path: Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/bin/Release/WoofWare.Whippet.Plugin.ArgParser.*.nupkg
 
   expected-pack:
     needs: [nuget-pack]
@@ -189,9 +209,66 @@ jobs:
       - name: Check NuGet contents
         # Verify that there is exactly one nupkg in the artifact that would be NuGet published
         run: if [[ $(find packed-fantomas -maxdepth 1 -name 'WoofWare.Whippet.Fantomas.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
+      - name: Download NuGet artifact (JSON attrs)
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-json-attrs
+          path: packed-json-attrs
+      - name: Check NuGet contents
+        # Verify that there is exactly one nupkg in the artifact that would be NuGet published
+        run: if [[ $(find packed-json-attrs -maxdepth 1 -name 'WoofWare.Whippet.Plugin.Json.Attributes.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
+      - name: Download NuGet artifact (JSON plugin)
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-json
+          path: packed-json
+      - name: Check NuGet contents
+        # Verify that there is exactly one nupkg in the artifact that would be NuGet published
+        run: if [[ $(find packed-json -maxdepth 1 -name 'WoofWare.Whippet.Plugin.Json.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
+      - name: Download NuGet artifact (argparser attrs)
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-argparser-attrs
+          path: packed-argparser-attrs
+      - name: Check NuGet contents
+        # Verify that there is exactly one nupkg in the artifact that would be NuGet published
+        run: if [[ $(find packed-argparser-attrs -maxdepth 1 -name 'WoofWare.Whippet.Plugin.ArgParser.Attributes.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
+      - name: Download NuGet artifact (argparser plugin)
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-argparser
+          path: packed-argparser
+      - name: Check NuGet contents
+        # Verify that there is exactly one nupkg in the artifact that would be NuGet published
+        run: if [[ $(find packed-argparser -maxdepth 1 -name 'WoofWare.Whippet.Plugin.ArgParser.*.nupkg' -printf c | wc -c) -ne "1" ]]; then exit 1; fi
+
+  check-accurate-generations:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
+      - name: Install Nix
+        uses: cachix/install-nix-action@v29
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Whitespace change to invalidate all caches
+        run: |
+            find . -type f -name '*.fs' -exec bash -c "echo ' ' >> '{}'" \;
+            find . -type f -name 'Generated*.fs' -exec bash -c "rm '{}'" \;
+      - name: Build Whippet
+        run: nix develop --command dotnet build WoofWare.Whippet
+      - name: Generate code
+        run: nix develop --command dotnet build
+      - name: Run Fantomas
+        run: nix run .#fantomas -- .
+      - name: Verify there is no diff
+        run: git diff --name-only --no-color --exit-code
 
   all-required-checks-complete:
-    needs: [check-dotnet-format, check-nix-format, build, build-nix, linkcheck, flake-check, nuget-pack, expected-pack, analyzers]
+    needs: [check-dotnet-format, check-nix-format, build, linkcheck, flake-check, nuget-pack, expected-pack, analyzers, check-accurate-generations]
     if: ${{ always() }}
     runs-on: ubuntu-latest
     steps:
@@ -199,6 +276,39 @@ jobs:
         with:
           needs-context: ${{ toJSON(needs) }}
 
+  nuget-publish:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Nix
+        uses: cachix/install-nix-action@v29
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-runner
+          path: packed
+      - name: Identify `dotnet`
+        id: dotnet-identify
+        run: nix develop --command bash -c 'echo "dotnet=$(which dotnet)" >> $GITHUB_OUTPUT'
+      - name: Publish to NuGet
+        id: publish-success
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.Whippet
+          nuget-key: ${{ secrets.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.dotnet-identify.outputs.dotnet }}
+
   nuget-publish-fantomas:
     runs-on: ubuntu-latest
     if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
@@ -232,3 +342,134 @@ jobs:
           nupkg-dir: packed/
           dotnet: ${{ steps.dotnet-identify.outputs.dotnet }}
 
+  nuget-publish-json-plugin:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Nix
+        uses: cachix/install-nix-action@v29
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-json
+          path: packed
+      - name: Identify `dotnet`
+        id: dotnet-identify
+        run: nix develop --command bash -c 'echo "dotnet=$(which dotnet)" >> $GITHUB_OUTPUT'
+      - name: Publish to NuGet
+        id: publish-success
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.Whippet.Plugin.Json
+          nuget-key: ${{ secrets.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.dotnet-identify.outputs.dotnet }}
+
+  nuget-publish-json-attrs:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Nix
+        uses: cachix/install-nix-action@v29
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-json-attrs
+          path: packed
+      - name: Identify `dotnet`
+        id: dotnet-identify
+        run: nix develop --command bash -c 'echo "dotnet=$(which dotnet)" >> $GITHUB_OUTPUT'
+      - name: Publish to NuGet
+        id: publish-success
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.Whippet.Plugin.Json.Attributes
+          nuget-key: ${{ secrets.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.dotnet-identify.outputs.dotnet }}
+
+  nuget-publish-argparser-plugin:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Nix
+        uses: cachix/install-nix-action@v29
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-argparser
+          path: packed
+      - name: Identify `dotnet`
+        id: dotnet-identify
+        run: nix develop --command bash -c 'echo "dotnet=$(which dotnet)" >> $GITHUB_OUTPUT'
+      - name: Publish to NuGet
+        id: publish-success
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.Whippet.Plugin.ArgParser
+          nuget-key: ${{ secrets.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.dotnet-identify.outputs.dotnet }}
+
+  nuget-publish-argparser-attrs:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      id-token: write
+      attestations: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Nix
+        uses: cachix/install-nix-action@v29
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Download NuGet artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-argparser-attrs
+          path: packed
+      - name: Identify `dotnet`
+        id: dotnet-identify
+        run: nix develop --command bash -c 'echo "dotnet=$(which dotnet)" >> $GITHUB_OUTPUT'
+      - name: Publish to NuGet
+        id: publish-success
+        uses: G-Research/common-actions/publish-nuget@2b7dc49cb14f3344fbe6019c14a31165e258c059
+        with:
+          package-name: WoofWare.Whippet.Plugin.ArgParser.Attributes
+          nuget-key: ${{ secrets.NUGET_API_KEY }}
+          nupkg-dir: packed/
+          dotnet: ${{ steps.dotnet-identify.outputs.dotnet }}

NuGet.config

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+  <!-- For tests, we consume Whippet from its binary build. We do this by adding a local NuGet source,
+       and then banning the package from coming from anywhere except that local source.
+  -->
+    <add key="local" value="./WoofWare.Whippet/bin/Debug/" />
+  </packageSources>
+  <packageSourceMapping>
+    <packageSource key="local">
+      <package pattern="WoofWare.Whippet" />
+    </packageSource>
+    <packageSource key="nuget.org">
+      <package pattern="*" />
+      <package pattern="!WoofWare.Whippet" />
+    </packageSource>
+  </packageSourceMapping>
+</configuration>

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Attributes/Attributes.fs

@@ -0,0 +1,96 @@
+namespace WoofWare.Whippet.Plugin.ArgParser
+
+open System
+
+/// Attribute indicating a record type to which the "build arg parser" Whippet generator should apply during build.
+///
+/// If you supply isExtensionMethod = false, you will get a module rather than extension methods.
+/// These can only be consumed from F#, but the benefit is that they don't use up the module name
+/// (since by default we create a module called "{TypeName}").
+type ArgParserAttribute (isExtensionMethod : bool) =
+    inherit Attribute ()
+
+    /// The default value of `isExtensionMethod`, the optional argument to the ArgParserAttribute constructor.
+    static member DefaultIsExtensionMethod = true
+
+    /// Shorthand for the "isExtensionMethod = false" constructor; see documentation there for details.
+    new () = ArgParserAttribute ArgParserAttribute.DefaultIsExtensionMethod
+
+/// Attribute indicating that this field shall accumulate all unmatched args,
+/// as well as any that appear after a bare `--`.
+///
+/// Set `includeFlagLike = true` to include args that begin `--` in the
+/// positional args.
+/// (By default, `includeFlagLike = false` and we throw when encountering
+/// an argument which looks like a flag but which we don't recognise.)
+/// We will still interpret `--help` as requesting help, unless it comes after
+/// a standalone `--` separator.
+type PositionalArgsAttribute (includeFlagLike : bool) =
+    inherit Attribute ()
+
+    /// The default value of `isExtensionMethod`, the optional argument to the ArgParserAttribute constructor.
+    static member DefaultIncludeFlagLike = false
+
+    /// Shorthand for the "includeFlagLike = false" constructor; see documentation there for details.
+    new () = PositionalArgsAttribute PositionalArgsAttribute.DefaultIncludeFlagLike
+
+/// Attribute indicating that this field shall have a default value derived
+/// from calling an appropriately named static method on the type.
+///
+/// This attribute can only be placed on fields of type `Choice<_, _>` where both type parameters
+/// are the same.
+/// After a successful parse, the value is Choice1Of2 if the user supplied an input,
+/// or Choice2Of2 if the input was obtained by calling the default function.
+///
+/// The static method we call for field `FieldName : 'a` is `DefaultFieldName : unit -> 'a`.
+type ArgumentDefaultFunctionAttribute () =
+    inherit Attribute ()
+
+/// Attribute indicating that this field shall have a default value derived
+/// from an environment variable (whose name you give in the attribute constructor).
+///
+/// This attribute can only be placed on fields of type `Choice<_, _>` where both type parameters
+/// are the same.
+/// After a successful parse, the value is Choice1Of2 if the user supplied an input,
+/// or Choice2Of2 if the input was obtained by pulling a value from `Environment.GetEnvironmentVariable`.
+type ArgumentDefaultEnvironmentVariableAttribute (envVar : string) =
+    inherit Attribute ()
+
+/// Attribute indicating that this field shall have the given help text, when `--help` is invoked
+/// or when a parse error causes us to print help text.
+type ArgumentHelpTextAttribute (helpText : string) =
+    inherit Attribute ()
+
+/// Attribute indicating that this field should be parsed with a ParseExact method on its type.
+/// For example, on a TimeSpan field, with [<ArgumentParseExact @"hh\:mm\:ss">], we will call
+/// `TimeSpan.ParseExact (s, @"hh\:mm\:ss", CultureInfo.CurrentCulture).
+type ParseExactAttribute (format : string) =
+    inherit Attribute ()
+
+/// Attribute indicating that this field should be parsed in the invariant culture, rather than the
+/// default current culture.
+/// For example, on a TimeSpan field, with [<InvariantCulture>] and [<ArgumentParseExact @"hh\:mm\:ss">], we will call
+/// `TimeSpan.ParseExact (s, @"hh\:mm\:ss", CultureInfo.InvariantCulture).
+type InvariantCultureAttribute () =
+    inherit Attribute ()
+
+/// Attribute placed on a field of a two-case no-data discriminated union, indicating that this is "basically a bool".
+/// For example: `type DryRun = | [<ArgumentFlag true>] Dry | [<ArgumentFlag false>] Wet`
+/// A record with `{ DryRun : DryRun }` will then be parsed like `{ DryRun : bool }` (so the user supplies `--dry-run`),
+/// but that you get this strongly-typed value directly in the code (so you `match args.DryRun with | DryRun.Dry ...`).
+///
+/// You must put this attribute on both cases of the discriminated union, with opposite values in each case.
+type ArgumentFlagAttribute (flagValue : bool) =
+    inherit Attribute ()
+
+/// Attribute placed on a field of a record to specify a different long form from the default. If you place this
+/// attribute, you won't get the default: ArgFoo would normally be expressed as `--arg-foo`, but if you instead
+/// say `[<ArgumentLongForm "thingy-blah">]` or `[<ArgumentLongForm "thingy">]`, you instead use `--thingy-blah`
+/// or `--thingy` respectively.
+///
+/// You can place this argument multiple times.
+///
+/// Omit the initial `--` that you expect the user to type.
+[<AttributeUsage(AttributeTargets.Field, AllowMultiple = true)>]
+type ArgumentLongForm (s : string) =
+    inherit Attribute ()

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Attributes/README.md

@@ -0,0 +1,5 @@
+# WoofWare.Whippet.Plugin.ArgParser.Attributes
+
+This is a very slim runtime dependency we expect consumers of WoofWare.Whippet.Plugin.ArgParser to take.
+This dependency contains attributes which control that source generator.
+Please see WoofWare.Whippet.Plugin.ArgParser's README for further information.

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Attributes/SurfaceBaseline.txt

@@ -0,0 +1,24 @@
+WoofWare.Whippet.Plugin.ArgParser.ArgParserAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ArgParserAttribute..ctor [constructor]: bool
+WoofWare.Whippet.Plugin.ArgParser.ArgParserAttribute..ctor [constructor]: unit
+WoofWare.Whippet.Plugin.ArgParser.ArgParserAttribute.DefaultIsExtensionMethod [static property]: [read-only] bool
+WoofWare.Whippet.Plugin.ArgParser.ArgParserAttribute.get_DefaultIsExtensionMethod [static method]: unit -> bool
+WoofWare.Whippet.Plugin.ArgParser.ArgumentDefaultEnvironmentVariableAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ArgumentDefaultEnvironmentVariableAttribute..ctor [constructor]: string
+WoofWare.Whippet.Plugin.ArgParser.ArgumentDefaultFunctionAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ArgumentDefaultFunctionAttribute..ctor [constructor]: unit
+WoofWare.Whippet.Plugin.ArgParser.ArgumentFlagAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ArgumentFlagAttribute..ctor [constructor]: bool
+WoofWare.Whippet.Plugin.ArgParser.ArgumentHelpTextAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ArgumentHelpTextAttribute..ctor [constructor]: string
+WoofWare.Whippet.Plugin.ArgParser.ArgumentLongForm inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ArgumentLongForm..ctor [constructor]: string
+WoofWare.Whippet.Plugin.ArgParser.InvariantCultureAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.InvariantCultureAttribute..ctor [constructor]: unit
+WoofWare.Whippet.Plugin.ArgParser.ParseExactAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.ParseExactAttribute..ctor [constructor]: string
+WoofWare.Whippet.Plugin.ArgParser.PositionalArgsAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.ArgParser.PositionalArgsAttribute..ctor [constructor]: bool
+WoofWare.Whippet.Plugin.ArgParser.PositionalArgsAttribute..ctor [constructor]: unit
+WoofWare.Whippet.Plugin.ArgParser.PositionalArgsAttribute.DefaultIncludeFlagLike [static property]: [read-only] bool
+WoofWare.Whippet.Plugin.ArgParser.PositionalArgsAttribute.get_DefaultIncludeFlagLike [static method]: unit -> bool

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Attributes/WoofWare.Whippet.Plugin.ArgParser.Attributes.fsproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>netstandard2.0</TargetFramework>
+      <GenerateDocumentationFile>true</GenerateDocumentationFile>
+      <Authors>Patrick Stevens</Authors>
+      <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
+      <Description>Attributes to accompany the WoofWare.Whippet.Plugin.ArgParser source generator, to indicate what you want your types to be doing.</Description>
+      <RepositoryType>git</RepositoryType>
+      <RepositoryUrl>https://github.com/Smaug123/WoofWare.Whippet</RepositoryUrl>
+      <PackageLicenseExpression>MIT</PackageLicenseExpression>
+      <PackageReadmeFile>README.md</PackageReadmeFile>
+      <PackageTags>fsharp;source-generator;source-gen;whippet;arguments;arg-parser</PackageTags>
+      <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+      <WarnOn>FS3559</WarnOn>
+      <PackageId>WoofWare.Whippet.Plugin.ArgParser.Attributes</PackageId>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Compile Include="Attributes.fs" />
+      <EmbeddedResource Include="SurfaceBaseline.txt" />
+      <EmbeddedResource Include="version.json" />
+      <None Include="README.md">
+        <Pack>True</Pack>
+        <PackagePath>/</PackagePath>
+        <Link>README.md</Link>
+      </None>
+    </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Update="FSharp.Core" Version="4.3.4" />
+  </ItemGroup>
+</Project>

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Attributes/version.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
+  "pathFilters": [
+    "./",
+    ":/global.json",
+    ":/Directory.Build.props"
+  ]
+}

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Consumer/Args.fs

@@ -0,0 +1,237 @@
+namespace Consumer
+
+open System
+open System.IO
+open WoofWare.Whippet.Plugin.ArgParser
+
+[<ArgParser>]
+type BasicNoPositionals =
+    {
+        Foo : int
+        Bar : string
+        Baz : bool
+        Rest : int list
+    }
+
+[<ArgParser>]
+type Basic =
+    {
+        [<ArgumentHelpText "This is a foo!">]
+        Foo : int
+        Bar : string
+        Baz : bool
+        [<ArgumentHelpText "Here's where the rest of the args go">]
+        [<PositionalArgs>]
+        Rest : string list
+    }
+
+[<ArgParser>]
+type BasicWithIntPositionals =
+    {
+        Foo : int
+        Bar : string
+        Baz : bool
+        [<PositionalArgs>]
+        Rest : int list
+    }
+
+[<ArgParser>]
+type LoadsOfTypes =
+    {
+        Foo : int
+        Bar : string
+        Baz : bool
+        SomeFile : FileInfo
+        SomeDirectory : DirectoryInfo
+        SomeList : DirectoryInfo list
+        OptionalThingWithNoDefault : int option
+        [<PositionalArgs>]
+        Positionals : int list
+        [<ArgumentDefaultFunction>]
+        OptionalThing : Choice<bool, bool>
+        [<ArgumentDefaultFunction>]
+        AnotherOptionalThing : Choice<int, int>
+        [<ArgumentDefaultEnvironmentVariable "CONSUMEPLUGIN_THINGS">]
+        YetAnotherOptionalThing : Choice<string, string>
+    }
+
+    static member DefaultOptionalThing () = true
+
+    static member DefaultAnotherOptionalThing () = 3
+
+[<ArgParser>]
+type LoadsOfTypesNoPositionals =
+    {
+        Foo : int
+        Bar : string
+        Baz : bool
+        SomeFile : FileInfo
+        SomeDirectory : DirectoryInfo
+        SomeList : DirectoryInfo list
+        OptionalThingWithNoDefault : int option
+        [<ArgumentDefaultFunction>]
+        OptionalThing : Choice<bool, bool>
+        [<ArgumentDefaultFunction>]
+        AnotherOptionalThing : Choice<int, int>
+        [<ArgumentDefaultEnvironmentVariable "CONSUMEPLUGIN_THINGS">]
+        YetAnotherOptionalThing : Choice<string, string>
+    }
+
+    static member DefaultOptionalThing () = false
+
+    static member DefaultAnotherOptionalThing () = 3
+
+[<ArgParser true>]
+type DatesAndTimes =
+    {
+        Plain : TimeSpan
+        [<InvariantCulture>]
+        Invariant : TimeSpan
+        [<ParseExact @"hh\:mm\:ss">]
+        [<ArgumentHelpText "An exact time please">]
+        Exact : TimeSpan
+        [<InvariantCulture ; ParseExact @"hh\:mm\:ss">]
+        InvariantExact : TimeSpan
+    }
+
+type ChildRecord =
+    {
+        Thing1 : int
+        Thing2 : string
+    }
+
+[<ArgParser true>]
+type ParentRecord =
+    {
+        Child : ChildRecord
+        AndAnother : bool
+    }
+
+type ChildRecordWithPositional =
+    {
+        Thing1 : int
+        [<PositionalArgs>]
+        Thing2 : Uri list
+    }
+
+[<ArgParser true>]
+type ParentRecordChildPos =
+    {
+        Child : ChildRecordWithPositional
+        AndAnother : bool
+    }
+
+[<ArgParser true>]
+type ParentRecordSelfPos =
+    {
+        Child : ChildRecord
+        [<PositionalArgs>]
+        AndAnother : bool list
+    }
+
+[<ArgParser true>]
+type ChoicePositionals =
+    {
+        [<PositionalArgs>]
+        Args : Choice<string, string> list
+    }
+
+[<ArgParser true>]
+type ContainsBoolEnvVar =
+    {
+        [<ArgumentDefaultEnvironmentVariable "CONSUMEPLUGIN_THINGS">]
+        BoolVar : Choice<bool, bool>
+    }
+
+[<RequireQualifiedAccess>]
+module Consts =
+    [<Literal>]
+    let FALSE = false
+
+    [<Literal>]
+    let TRUE = true
+
+type DryRunMode =
+    | [<ArgumentFlag(Consts.FALSE)>] Wet
+    | [<ArgumentFlag true>] Dry
+
+[<ArgParser true>]
+type WithFlagDu =
+    {
+        DryRun : DryRunMode
+    }
+
+[<ArgParser true>]
+type ContainsFlagEnvVar =
+    {
+        // This phrasing is odd, but it's for a test. Nobody's really going to have `--dry-run`
+        // controlled by an env var!
+        [<ArgumentDefaultEnvironmentVariable "CONSUMEPLUGIN_THINGS">]
+        DryRun : Choice<DryRunMode, DryRunMode>
+    }
+
+[<ArgParser true>]
+type ContainsFlagDefaultValue =
+    {
+        [<ArgumentDefaultFunction>]
+        DryRun : Choice<DryRunMode, DryRunMode>
+    }
+
+    static member DefaultDryRun () = DryRunMode.Wet
+
+[<ArgParser true>]
+type ManyLongForms =
+    {
+        [<ArgumentLongForm "do-something-else">]
+        [<ArgumentLongForm "anotherarg">]
+        DoTheThing : string
+
+        [<ArgumentLongForm "turn-it-on">]
+        [<ArgumentLongForm "dont-turn-it-off">]
+        SomeFlag : bool
+    }
+
+[<RequireQualifiedAccess>]
+type private IrrelevantDu =
+    | Foo
+    | Bar
+
+[<ArgParser true>]
+type FlagsIntoPositionalArgs =
+    {
+        A : string
+        [<PositionalArgs true>]
+        GrabEverything : string list
+    }
+
+[<ArgParser true>]
+type FlagsIntoPositionalArgsChoice =
+    {
+        A : string
+        [<PositionalArgs true>]
+        GrabEverything : Choice<string, string> list
+    }
+
+[<ArgParser true>]
+type FlagsIntoPositionalArgsInt =
+    {
+        A : string
+        [<PositionalArgs true>]
+        GrabEverything : int list
+    }
+
+[<ArgParser true>]
+type FlagsIntoPositionalArgsIntChoice =
+    {
+        A : string
+        [<PositionalArgs true>]
+        GrabEverything : Choice<int, int> list
+    }
+
+[<ArgParser true>]
+type FlagsIntoPositionalArgs' =
+    {
+        A : string
+        [<PositionalArgs false>]
+        DontGrabEverything : string list
+    }

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser.Consumer/WoofWare.Whippet.Plugin.ArgParser.Consumer.fsproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net8.0</TargetFramework>
+      <GenerateDocumentationFile>true</GenerateDocumentationFile>
+      <IsPackable>false</IsPackable>
+      <RestoreAdditionalProjectSources>$(MSBuildThisFileDirectory)/../../../WoofWare.Whippet/bin/$(Configuration)</RestoreAdditionalProjectSources>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Compile Include="Args.fs" />
+      <Compile Include="GeneratedArgs.fs">
+        <WhippetFile>Args.fs</WhippetFile>
+      </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\WoofWare.Whippet.Plugin.ArgParser.Attributes\WoofWare.Whippet.Plugin.ArgParser.Attributes.fsproj" />
+      <ProjectReference Include="..\WoofWare.Whippet.Plugin.ArgParser\WoofWare.Whippet.Plugin.ArgParser.fsproj" PrivateAssets="all" WhippetPlugin="true" />
+
+      <!-- Dance to get a binary dependency on a locally-built Whippet -->
+      <!-- ProjectReference Include="..\..\..\WoofWare.Whippet\WoofWare.Whippet.fsproj" PrivateAssets="all" -->
+      <PackageReference Include="WoofWare.Whippet" Version="*-*" PrivateAssets="all" />
+    </ItemGroup>
+
+</Project>

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/README.md

@@ -0,0 +1,97 @@
+# WoofWare.Whippet.Plugin.ArgParser
+
+This is a [Whippet](https://github.com/Smaug123/WoofWare.Whippet) plugin defining an argument parser.
+
+It is a copy of the corresponding [Myriad](https://github.com/MoiraeSoftware/myriad) arg parser in [WoofWare.Myriad](https://github.com/Smaug123/WoofWare.Myriad), taken from commit d59ebdfccb87a06579fb99008a15f58ea8be394e.
+
+## Usage
+
+Define an `Args.fs` file like the following:
+
+```fsharp
+namespace MyNamespace
+
+[<ArgParser>]
+type LoadsOfTypes =
+    {
+        Foo : int
+        Bar : string
+        Baz : bool
+        SomeFile : FileInfo
+        SomeDirectory : DirectoryInfo
+        SomeList : DirectoryInfo list
+        OptionalThingWithNoDefault : int option
+        [<PositionalArgs>]
+        Positionals : int list
+        [<ArgumentDefaultFunction>]
+        OptionalThing : Choice<bool, bool>
+        [<ArgumentDefaultFunction>]
+        AnotherOptionalThing : Choice<int, int>
+        [<ArgumentDefaultEnvironmentVariable "CONSUMEPLUGIN_THINGS">]
+        YetAnotherOptionalThing : Choice<string, string>
+    }
+
+    static member DefaultOptionalThing () = true
+
+    static member DefaultAnotherOptionalThing () = 3
+```
+
+In your fsproj:
+
+```xml
+<Project>
+    <ItemGroup>
+        <Compile Include="Args.fs" />
+        <Compile Include="GeneratedArgs.fs">
+            <WhippetFile>Args.fs</WhippetFile>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- Runtime dependency: you use attributes to give instructions to the generator.
+             Specify the `Version` appropriately by getting the latest version from NuGet.org.
+         -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.ArgParser.Attributes" Version="" />
+        <!-- Development dependencies, hence PrivateAssets="all". Note `WhippetPlugin="true"`. -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.ArgParser" WhippetPlugin="true" Version="" />
+        <PackageReference Include="WoofWare.Whippet" Version="" PrivateAssets="all" />
+    </ItemGroup>
+</Project>
+```
+
+The generator will produce a file like the following:
+
+```fsharp
+[<RequireQualifiedAccess>]
+module LoadsOfTypes =
+    // in case you want to test it, you get one with dependencies injected
+    let parse' (getEnvVar : string -> string) (args : string list) : LoadsOfTypes = ...
+    // this is the one we expect you actually want to use, if you don't want to test the arg parser
+    let parse (args : string list) : LoadsOfTypes = ...
+```
+
+## Features
+
+* Default arguments are handled as `Choice<'a, 'a>`: you get a `Choice1Of2` if the user provided the input, or a `Choice2Of2` if the parser filled in your specified default value.
+* Default arguments from the environment, specified with `[<ArgumentDefaultEnvironmentVariable "ENV_VAR">]`. If such an arg is not supplied on the command line, its value is parsed from the value of that env var.
+* Default arguments, specified with `[<ArgumentDefaultFunction>]`. If an arg `[<ArgumentDefaultFunction>] Foo : Choice<'a, 'a>` is not supplied on the command line, the parser calls `DefaultFoo : unit -> 'a` to obtain its value.
+* Positional arguments: a list with attribute `[<PositionalArgs>]` will accumulate all args which didn't match anything else. By default, the parser will fail if any of these arguments looks like an arg itself (i.e. it starts with `--`) but comes *before* a positional arg separator `--`; you can optionally give this attribute the argument `(* includeFlagLike = *) true` to instead just put such flag-like args into the accumulator.
+* Positional args can also be of type `Choice<'a, 'a> list`, in which case we tell you whether the arg came before (`Choice1Of2`) or after (`Choice2Of2`) any `--` positional args separator.
+* You can control TimeSpan and friends with the `[<InvariantCulture>]` and `[<ParseExact @"hh\:mm\:ss">]` attributes.
+* By default, we generate F# extension methods for the type; you can instead create a module with the type's name, using `[<ArgParser (* isExtensionMethod = *) false>]`.
+* If `--help` appears in a position where the parser is expecting a key (e.g. in the first position, or after a `--foo=bar`), the parser fails with help text. The parser also makes a limited effort to supply help text when encountering an invalid parse.
+* "Flag DUs": if a two-case DU appears in the generator input file, you can tag its cases as in `type DryRun = | [<ArgumentFlag false>] Wet | [<ArgumentFlag true>] Dry`. Then you can consume the flag like a bool: `[<ArgParser>] type Args = { DryRun : DryRun }`, so `--dry-run` is parsed into `DryRun.Dry`.
+* Control long forms of arguments with `[<ArgumentLongForm "alternative-name">] Foo : int`, so that instead of accepting the default `--foo=3`, we accept `--alternative-name=3`.
+* Custom help text for individual args is supplied with `[<ArgumentHelpText "this text is displayed next to the arg when the user calls --help">]`, and similarly help text for the entire args object is supplied with `[<ArgParser>] [<ArgumentHelpText "hi!">] type Args = ...`.
+
+## Limitations
+
+This is very bare-bones, but do raise GitHub issues if you like (or if you find cases where the parser does the wrong thing).
+
+* Help is signalled by throwing an exception, so you'll get an unsightly stack trace and a nonzero exit code.
+* Help doesn't take into account any arguments the user has entered. Ideally you'd get contextual information like an identification of which args the user has supplied at the point where the parse failed or help was requested.
+* I don't handle very many types, and in particular a real arg parser would handle DUs and records with nesting.
+* I don't try very hard to find a valid parse. It may well be possible to find a case where I fail to parse despite there existing a valid parse.
+* There's no subcommand support (you'll have to do that yourself).
+
+It should work fine if you just want to compose a few primitive types, though.

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/WoofWare.Whippet.Plugin.ArgParser.Test/TestArgParser.fs

@@ -0,0 +1,706 @@
+namespace WoofWare.Whippet.Plugin.ArgParser.Test
+
+open System
+open System.Threading
+open NUnit.Framework
+open FsUnitTyped
+open Consumer
+open FsCheck
+
+[<TestFixture>]
+module TestArgParser =
+
+    [<TestCase true>]
+    [<TestCase false>]
+    let ``Positionals get parsed: they don't have to be strings`` (sep : bool) =
+        let getEnvVar (_ : string) = failwith "should not call"
+
+        let property
+            (fooSep : bool)
+            (barSep : bool)
+            (bazSep : bool)
+            (pos0 : int list)
+            (pos1 : int list)
+            (pos2 : int list)
+            (pos3 : int list)
+            (pos4 : int list)
+            =
+            let args =
+                [
+                    yield! pos0 |> List.map string<int>
+                    if fooSep then
+                        yield "--foo=3"
+                    else
+                        yield "--foo"
+                        yield "3"
+                    yield! pos1 |> List.map string<int>
+                    if barSep then
+                        yield "--bar=4"
+                    else
+                        yield "--bar"
+                        yield "4"
+                    yield! pos2 |> List.map string<int>
+                    if bazSep then
+                        yield "--baz=true"
+                    else
+                        yield "--baz"
+                        yield "true"
+                    yield! pos3 |> List.map string<int>
+                    if sep then
+                        yield "--"
+                    yield! pos4 |> List.map string<int>
+                ]
+
+            BasicWithIntPositionals.parse' getEnvVar args
+            |> shouldEqual
+                {
+                    Foo = 3
+                    Bar = "4"
+                    Baz = true
+                    Rest = pos0 @ pos1 @ pos2 @ pos3 @ pos4
+                }
+
+        Check.QuickThrowOnFailure property
+
+    [<Test>]
+    let ``Arg-like thing appearing before double dash`` () =
+        let envCalls = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment envCalls |> ignore<int>
+            ""
+
+        let args = [ "--foo=3" ; "--non-existent" ; "--bar=4" ; "--baz=true" ]
+
+        let exc =
+            Assert.Throws<exn> (fun () -> Basic.parse' getEnvVar args |> ignore<Basic>)
+
+        envCalls.Value |> shouldEqual 0
+
+        exc.Message
+        |> shouldEqual
+            """Unable to process supplied arg --non-existent. Help text follows.
+--foo  int32 : This is a foo!
+--bar  string
+--baz  bool
+--rest  string (positional args) (can be repeated) : Here's where the rest of the args go"""
+
+    [<Test>]
+    let ``Can supply positional args with key`` () =
+        let envCalls = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment envCalls |> ignore<int>
+            ""
+
+        let property (args : (int * bool) list) (afterDoubleDash : int list option) =
+            let flatArgs =
+                args
+                |> List.collect (fun (value, sep) ->
+                    if sep then
+                        [ $"--rest=%i{value}" ]
+                    else
+                        [ "--rest" ; string<int> value ]
+                )
+                |> fun l -> l @ [ "--foo=3" ; "--bar=4" ; "--baz=true" ]
+
+            let flatArgs, expected =
+                match afterDoubleDash with
+                | None -> flatArgs, List.map fst args
+                | Some rest -> flatArgs @ [ "--" ] @ (List.map string<int> rest), List.map fst args @ rest
+
+            BasicWithIntPositionals.parse' getEnvVar flatArgs
+            |> shouldEqual
+                {
+                    Foo = 3
+                    Bar = "4"
+                    Baz = true
+                    Rest = expected
+                }
+
+        Check.QuickThrowOnFailure property
+        envCalls.Value |> shouldEqual 0
+
+    [<Test>]
+    let ``Consume multiple occurrences of required arg`` () =
+        let envCalls = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment envCalls |> ignore<int>
+            ""
+
+        let args = [ "--foo=3" ; "--rest" ; "7" ; "--bar=4" ; "--baz=true" ; "--rest=8" ]
+
+        let result = BasicNoPositionals.parse' getEnvVar args
+
+        envCalls.Value |> shouldEqual 0
+
+        result
+        |> shouldEqual
+            {
+                Foo = 3
+                Bar = "4"
+                Baz = true
+                Rest = [ 7 ; 8 ]
+            }
+
+    [<Test>]
+    let ``Gracefully handle invalid multiple occurrences of required arg`` () =
+        let envCalls = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment envCalls |> ignore<int>
+            ""
+
+        let args = [ "--foo=3" ; "--foo" ; "9" ; "--bar=4" ; "--baz=true" ; "--baz=false" ]
+
+        let exc =
+            Assert.Throws<exn> (fun () -> Basic.parse' getEnvVar args |> ignore<Basic>)
+
+        envCalls.Value |> shouldEqual 0
+
+        exc.Message
+        |> shouldEqual
+            """Errors during parse!
+Argument '--foo' was supplied multiple times: 3 and 9
+Argument '--baz' was supplied multiple times: True and false"""
+
+    [<Test>]
+    let ``Args appearing after double dash are positional`` () =
+        let envCalls = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment envCalls |> ignore<int>
+            ""
+
+        let args = [ "--" ; "--foo=3" ; "--bar=4" ; "--baz=true" ]
+
+        let exc =
+            Assert.Throws<exn> (fun () -> Basic.parse' getEnvVar args |> ignore<Basic>)
+
+        exc.Message
+        |> shouldEqual
+            """Errors during parse!
+Required argument '--foo' received no value
+Required argument '--bar' received no value
+Required argument '--baz' received no value"""
+
+        envCalls.Value |> shouldEqual 0
+
+    [<Test>]
+    let ``Help text`` () =
+        let getEnvVar (s : string) =
+            s |> shouldEqual "CONSUMEPLUGIN_THINGS"
+            "hi!"
+
+        let exc =
+            Assert.Throws<exn> (fun () -> Basic.parse' getEnvVar [ "--help" ] |> ignore<Basic>)
+
+        exc.Message
+        |> shouldEqual
+            """Help text requested.
+--foo  int32 : This is a foo!
+--bar  string
+--baz  bool
+--rest  string (positional args) (can be repeated) : Here's where the rest of the args go"""
+
+    [<Test>]
+    let ``Help text, with default values`` () =
+        let envVars = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment envVars |> ignore<int>
+            ""
+
+        let exc =
+            Assert.Throws<exn> (fun () -> LoadsOfTypes.parse' getEnvVar [ "--help" ] |> ignore<LoadsOfTypes>)
+
+        exc.Message
+        |> shouldEqual
+            """Help text requested.
+--foo  int32
+--bar  string
+--baz  bool
+--some-file  FileInfo
+--some-directory  DirectoryInfo
+--some-list  DirectoryInfo (can be repeated)
+--optional-thing-with-no-default  int32 (optional)
+--optional-thing  bool (default value: True)
+--another-optional-thing  int32 (default value: 3)
+--yet-another-optional-thing  string (default value populated from env var CONSUMEPLUGIN_THINGS)
+--positionals  int32 (positional args) (can be repeated)"""
+
+        envVars.Value |> shouldEqual 0
+
+    [<Test>]
+    let ``Default values`` () =
+        let getEnvVar (s : string) =
+            s |> shouldEqual "CONSUMEPLUGIN_THINGS"
+            "hi!"
+
+        let args =
+            [
+                "--foo"
+                "3"
+                "--bar=some string"
+                "--baz"
+                "--some-file=/path/to/file"
+                "--some-directory"
+                "/a/dir"
+                "--another-optional-thing"
+                "3000"
+            ]
+
+        let result = LoadsOfTypes.parse' getEnvVar args
+
+        result.OptionalThing |> shouldEqual (Choice2Of2 true)
+        result.OptionalThingWithNoDefault |> shouldEqual None
+        result.AnotherOptionalThing |> shouldEqual (Choice1Of2 3000)
+        result.YetAnotherOptionalThing |> shouldEqual (Choice2Of2 "hi!")
+
+    [<Test>]
+    let ``ParseExact and help`` () =
+        let count = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment count |> ignore<int>
+            ""
+
+        let exc =
+            Assert.Throws<exn> (fun () -> DatesAndTimes.parse' getEnvVar [ "--help" ] |> ignore<DatesAndTimes>)
+
+        exc.Message
+        |> shouldEqual
+            @"Help text requested.
+--plain  TimeSpan
+--invariant  TimeSpan
+--exact  TimeSpan : An exact time please [Parse format (.NET): hh\:mm\:ss]
+--invariant-exact  TimeSpan : [Parse format (.NET): hh\:mm\:ss]"
+
+        count.Value |> shouldEqual 0
+
+    [<Test>]
+    let rec ``TimeSpans and their attributes`` () =
+        let count = ref 0
+
+        let getEnvVar (_ : string) =
+            Interlocked.Increment count |> ignore<int>
+            ""
+
+        let parsed =
+            DatesAndTimes.parse'
+                getEnvVar
+                [
+                    "--exact=11:34:00"
+                    "--plain=1"
+                    "--invariant=23:59"
+                    "--invariant-exact=23:59:00"
+                ]
+
+        parsed.Plain |> shouldEqual (TimeSpan (1, 0, 0, 0))
+        parsed.Invariant |> shouldEqual (TimeSpan (23, 59, 00))
+        parsed.Exact |> shouldEqual (TimeSpan (11, 34, 00))
+        parsed.InvariantExact |> shouldEqual (TimeSpan (23, 59, 00))
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                DatesAndTimes.parse'
+                    getEnvVar
+                    [
+                        "--exact=11:34:00"
+                        "--plain=1"
+                        "--invariant=23:59"
+                        "--invariant-exact=23:59"
+                    ]
+                |> ignore<DatesAndTimes>
+            )
+
+        exc.Message
+        |> shouldEqual
+            """Errors during parse!
+Input string was not in a correct format. (at arg --invariant-exact=23:59)
+Required argument '--invariant-exact' received no value"""
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                DatesAndTimes.parse'
+                    getEnvVar
+                    [
+                        "--exact=11:34"
+                        "--plain=1"
+                        "--invariant=23:59"
+                        "--invariant-exact=23:59:00"
+                    ]
+                |> ignore<DatesAndTimes>
+            )
+
+        exc.Message
+        |> shouldEqual
+            """Errors during parse!
+Input string was not in a correct format. (at arg --exact=11:34)
+Required argument '--exact' received no value"""
+
+        count.Value |> shouldEqual 0
+
+    [<Test>]
+    let ``Can consume stacked record without positionals`` () =
+        let getEnvVar (_ : string) = failwith "should not call"
+
+        let parsed =
+            ParentRecord.parse' getEnvVar [ "--and-another=true" ; "--thing1=9" ; "--thing2=a thing!" ]
+
+        parsed
+        |> shouldEqual
+            {
+                Child =
+                    {
+                        Thing1 = 9
+                        Thing2 = "a thing!"
+                    }
+                AndAnother = true
+            }
+
+    [<Test>]
+    let ``Can consume stacked record, child has positionals`` () =
+        let getEnvVar (_ : string) = failwith "should not call"
+
+        let parsed =
+            ParentRecordChildPos.parse'
+                getEnvVar
+                [
+                    "--and-another=true"
+                    "--thing1=9"
+                    "--thing2=https://example.com"
+                    "--thing2=http://example.com"
+                ]
+
+        parsed.AndAnother |> shouldEqual true
+        parsed.Child.Thing1 |> shouldEqual 9
+
+        parsed.Child.Thing2
+        |> List.map (fun (x : Uri) -> x.ToString ())
+        |> shouldEqual [ "https://example.com/" ; "http://example.com/" ]
+
+    [<Test>]
+    let ``Can consume stacked record, child has no positionals, parent has positionals`` () =
+        let getEnvVar (_ : string) = failwith "should not call"
+
+        let parsed =
+            ParentRecordSelfPos.parse'
+                getEnvVar
+                [
+                    "--and-another=true"
+                    "--and-another=false"
+                    "--and-another=true"
+                    "--thing1=9"
+                    "--thing2=some"
+                ]
+
+        parsed
+        |> shouldEqual
+            {
+                Child =
+                    {
+                        Thing1 = 9
+                        Thing2 = "some"
+                    }
+                AndAnother = [ true ; false ; true ]
+            }
+
+    [<Test>]
+    let ``Help text for stacked records`` () =
+        let getEnvVar (_ : string) = failwith "should not call"
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                ParentRecordSelfPos.parse' getEnvVar [ "--help" ] |> ignore<ParentRecordSelfPos>
+            )
+
+        exc.Message
+        |> shouldEqual
+            """Help text requested.
+--thing1  int32
+--thing2  string
+--and-another  bool (positional args) (can be repeated)"""
+
+    [<Test>]
+    let ``Positionals are tagged with Choice`` () =
+        let getEnvVar (_ : string) = failwith "should not call"
+
+        ChoicePositionals.parse' getEnvVar [ "a" ; "b" ; "--" ; "--c" ; "--help" ]
+        |> shouldEqual
+            {
+                Args = [ Choice1Of2 "a" ; Choice1Of2 "b" ; Choice2Of2 "--c" ; Choice2Of2 "--help" ]
+            }
+
+    let boolCases =
+        [
+            "1", true
+            "0", false
+            "true", true
+            "false", false
+            "TRUE", true
+            "FALSE", false
+        ]
+        |> List.map TestCaseData
+
+    [<TestCaseSource(nameof (boolCases))>]
+    let ``Bool env vars can be populated`` (envValue : string, boolValue : bool) =
+        let getEnvVar (s : string) =
+            s |> shouldEqual "CONSUMEPLUGIN_THINGS"
+            envValue
+
+        ContainsBoolEnvVar.parse' getEnvVar []
+        |> shouldEqual
+            {
+                BoolVar = Choice2Of2 boolValue
+            }
+
+    [<Test>]
+    let ``Bools can be treated with arity 0`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        ContainsBoolEnvVar.parse' getEnvVar [ "--bool-var" ]
+        |> shouldEqual
+            {
+                BoolVar = Choice1Of2 true
+            }
+
+    [<TestCaseSource(nameof boolCases)>]
+    let ``Flag DUs can be parsed from env var`` (envValue : string, boolValue : bool) =
+        let getEnvVar (s : string) =
+            s |> shouldEqual "CONSUMEPLUGIN_THINGS"
+            envValue
+
+        let boolValue = if boolValue then DryRunMode.Dry else DryRunMode.Wet
+
+        ContainsFlagEnvVar.parse' getEnvVar []
+        |> shouldEqual
+            {
+                DryRun = Choice2Of2 boolValue
+            }
+
+    let dryRunData =
+        [
+            [ "--dry-run" ], DryRunMode.Dry
+            [ "--dry-run" ; "true" ], DryRunMode.Dry
+            [ "--dry-run=true" ], DryRunMode.Dry
+            [ "--dry-run" ; "True" ], DryRunMode.Dry
+            [ "--dry-run=True" ], DryRunMode.Dry
+            [ "--dry-run" ; "false" ], DryRunMode.Wet
+            [ "--dry-run=false" ], DryRunMode.Wet
+            [ "--dry-run" ; "False" ], DryRunMode.Wet
+            [ "--dry-run=False" ], DryRunMode.Wet
+        ]
+        |> List.map TestCaseData
+
+    [<TestCaseSource(nameof dryRunData)>]
+    let ``Flag DUs can be parsed`` (args : string list, expected : DryRunMode) =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        ContainsFlagEnvVar.parse' getEnvVar args
+        |> shouldEqual
+            {
+                DryRun = Choice1Of2 expected
+            }
+
+    [<TestCaseSource(nameof dryRunData)>]
+    let ``Flag DUs can be parsed, ArgumentDefaultFunction`` (args : string list, expected : DryRunMode) =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        ContainsFlagDefaultValue.parse' getEnvVar args
+        |> shouldEqual
+            {
+                DryRun = Choice1Of2 expected
+            }
+
+    [<Test>]
+    let ``Flag DUs can be given a default value`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        ContainsFlagDefaultValue.parse' getEnvVar []
+        |> shouldEqual
+            {
+                DryRun = Choice2Of2 DryRunMode.Wet
+            }
+
+    [<Test>]
+    let ``Help text for flag DU`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                ContainsFlagDefaultValue.parse' getEnvVar [ "--help" ]
+                |> ignore<ContainsFlagDefaultValue>
+            )
+
+        exc.Message
+        |> shouldEqual
+            """Help text requested.
+--dry-run  bool (default value: false)"""
+
+    [<Test>]
+    let ``Help text for flag DU, non default`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        let exc =
+            Assert.Throws<exn> (fun () -> WithFlagDu.parse' getEnvVar [ "--help" ] |> ignore<WithFlagDu>)
+
+        exc.Message
+        |> shouldEqual
+            """Help text requested.
+--dry-run  bool"""
+
+    let longFormCases =
+        let doTheThing =
+            [
+                [ "--do-something-else=foo" ]
+                [ "--anotherarg=foo" ]
+                [ "--do-something-else" ; "foo" ]
+                [ "--anotherarg" ; "foo" ]
+            ]
+
+        let someFlag =
+            [
+                [ "--turn-it-on" ], true
+                [ "--dont-turn-it-off" ], true
+                [ "--turn-it-on=true" ], true
+                [ "--dont-turn-it-off=true" ], true
+                [ "--turn-it-on=false" ], false
+                [ "--dont-turn-it-off=false" ], false
+                [ "--turn-it-on" ; "true" ], true
+                [ "--dont-turn-it-off" ; "true" ], true
+                [ "--turn-it-on" ; "false" ], false
+                [ "--dont-turn-it-off" ; "false" ], false
+            ]
+
+        List.allPairs doTheThing someFlag
+        |> List.map (fun (doTheThing, (someFlag, someFlagResult)) ->
+            let args = doTheThing @ someFlag
+
+            let expected =
+                {
+                    DoTheThing = "foo"
+                    SomeFlag = someFlagResult
+                }
+
+            args, expected
+        )
+        |> List.map TestCaseData
+
+    [<TestCaseSource(nameof longFormCases)>]
+    let ``Long-form args`` (args : string list, expected : ManyLongForms) =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        ManyLongForms.parse' getEnvVar args |> shouldEqual expected
+
+    [<Test>]
+    let ``Long-form args can't be referred to by their original name`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                ManyLongForms.parse' getEnvVar [ "--do-the-thing=foo" ] |> ignore<ManyLongForms>
+            )
+
+        exc.Message
+        |> shouldEqual """Unable to process argument --do-the-thing=foo as key --do-the-thing and value foo"""
+
+    [<Test>]
+    let ``Long-form args help text`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        let exc =
+            Assert.Throws<exn> (fun () -> ManyLongForms.parse' getEnvVar [ "--help" ] |> ignore<ManyLongForms>)
+
+        exc.Message
+        |> shouldEqual
+            """Help text requested.
+--do-something-else / --anotherarg  string
+--turn-it-on / --dont-turn-it-off  bool"""
+
+    [<Test>]
+    let ``Can collect *all* non-help args into positional args with includeFlagLike`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        FlagsIntoPositionalArgs.parse' getEnvVar [ "--a" ; "foo" ; "--b=false" ; "--c" ; "hi" ; "--" ; "--help" ]
+        |> shouldEqual
+            {
+                A = "foo"
+                GrabEverything = [ "--b=false" ; "--c" ; "hi" ; "--help" ]
+            }
+
+        // Users might consider this eccentric!
+        // But we're only a simple arg parser; we don't look around to see whether this is "almost"
+        // a valid parse.
+        FlagsIntoPositionalArgs.parse' getEnvVar [ "--a" ; "--b=false" ; "--c" ; "hi" ; "--" ; "--help" ]
+        |> shouldEqual
+            {
+                A = "--b=false"
+                GrabEverything = [ "--c" ; "hi" ; "--help" ]
+            }
+
+    [<Test>]
+    let ``Can collect non-help args into positional args with Choice`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        FlagsIntoPositionalArgsChoice.parse' getEnvVar [ "--a" ; "foo" ; "--b=false" ; "--c" ; "hi" ; "--" ; "--help" ]
+        |> shouldEqual
+            {
+                A = "foo"
+                GrabEverything =
+                    [
+                        Choice1Of2 "--b=false"
+                        Choice1Of2 "--c"
+                        Choice1Of2 "hi"
+                        Choice2Of2 "--help"
+                    ]
+            }
+
+    [<Test>]
+    let ``Can collect non-help args into positional args, and we parse on the way`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        FlagsIntoPositionalArgsInt.parse' getEnvVar [ "3" ; "--a" ; "foo" ; "5" ; "--" ; "98" ]
+        |> shouldEqual
+            {
+                A = "foo"
+                GrabEverything = [ 3 ; 5 ; 98 ]
+            }
+
+    [<Test>]
+    let ``Can collect non-help args into positional args with Choice, and we parse on the way`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        FlagsIntoPositionalArgsIntChoice.parse' getEnvVar [ "3" ; "--a" ; "foo" ; "5" ; "--" ; "98" ]
+        |> shouldEqual
+            {
+                A = "foo"
+                GrabEverything = [ Choice1Of2 3 ; Choice1Of2 5 ; Choice2Of2 98 ]
+            }
+
+    [<Test>]
+    let ``Can refuse to collect non-help args with PositionalArgs false`` () =
+        let getEnvVar (_ : string) = failwith "do not call"
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                FlagsIntoPositionalArgs'.parse'
+                    getEnvVar
+                    [ "--a" ; "foo" ; "--b=false" ; "--c" ; "hi" ; "--" ; "--help" ]
+                |> ignore<FlagsIntoPositionalArgs'>
+            )
+
+        exc.Message
+        |> shouldEqual """Unable to process argument --b=false as key --b and value false"""
+
+        let exc =
+            Assert.Throws<exn> (fun () ->
+                FlagsIntoPositionalArgs'.parse' getEnvVar [ "--a" ; "--b=false" ; "--c=hi" ; "--" ; "--help" ]
+                |> ignore<FlagsIntoPositionalArgs'>
+            )
+
+        // Again perhaps eccentric!
+        // Again, we don't try to detect that the user has missed out the desired argument to `--a`.
+        exc.Message
+        |> shouldEqual """Unable to process argument --c=hi as key --c and value hi"""

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/WoofWare.Whippet.Plugin.ArgParser.Test/TestSurface.fs

@@ -0,0 +1,26 @@
+namespace WoofWare.Whippet.Plugin.ArgParser.Test
+
+open NUnit.Framework
+open WoofWare.Whippet.Plugin.ArgParser
+open ApiSurface
+
+[<TestFixture>]
+module TestAttributeSurface =
+    let assembly = typeof<ArgParserAttribute>.Assembly
+
+    [<Test>]
+    let ``Ensure API surface has not been modified`` () = ApiSurface.assertIdentical assembly
+
+    (*
+    [<Test>]
+    let ``Check version against remote`` () =
+        MonotonicVersion.validate assembly "WoofWare.Whippet.Plugin.ArgParser.Attributes"
+        *)
+
+    [<Test ; Explicit>]
+    let ``Update API surface`` () =
+        ApiSurface.writeAssemblyBaseline assembly
+
+    [<Test>]
+    let ``Ensure public API is fully documented`` () =
+        DocCoverage.assertFullyDocumented assembly

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/WoofWare.Whippet.Plugin.ArgParser.Test/WoofWare.Whippet.Plugin.ArgParser.Test.fsproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="TestArgParser.fs" />
+        <Compile Include="TestSurface.fs" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="ApiSurface" Version="4.1.5" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1"/>
+      <PackageReference Include="NUnit" Version="4.2.2"/>
+      <PackageReference Include="NUnit3TestAdapter" Version="4.6.0"/>
+      <PackageReference Include="FsUnit" Version="6.0.1"/>
+      <PackageReference Include="FsCheck" Version="2.16.6"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\WoofWare.Whippet.Plugin.ArgParser.Consumer\WoofWare.Whippet.Plugin.ArgParser.Consumer.fsproj" />
+    </ItemGroup>
+
+</Project>

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/WoofWare.Whippet.Plugin.ArgParser.fsproj

@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net8.0</TargetFramework>
+      <GenerateDocumentationFile>true</GenerateDocumentationFile>
+      <Authors>Patrick Stevens</Authors>
+      <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
+      <Description>Whippet F# source generator plugin, for generating arg parsers.</Description>
+      <RepositoryType>git</RepositoryType>
+      <RepositoryUrl>https://github.com/Smaug123/WoofWare.Whippet</RepositoryUrl>
+      <PackageLicenseExpression>MIT</PackageLicenseExpression>
+      <PackageReadmeFile>README.md</PackageReadmeFile>
+      <PackageTags>fsharp;source-generator;source-gen;whippet;arguments;arg-parser</PackageTags>
+      <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+      <WarnOn>FS3559</WarnOn>
+      <PackageId>WoofWare.Whippet.Plugin.ArgParser</PackageId>
+      <DevelopmentDependency>true</DevelopmentDependency>
+      <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+      <NoWarn>NU5118</NoWarn>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <None Include="README.md">
+        <Pack>True</Pack>
+        <PackagePath>/</PackagePath>
+        <Link>README.md</Link>
+      </None>
+      <Compile Include="ArgParserGenerator.fs" />
+      <EmbeddedResource Include="version.json" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\..\WoofWare.Whippet.Core\WoofWare.Whippet.Core.fsproj" />
+      <ProjectReference Include="..\..\..\WoofWare.Whippet.Fantomas\WoofWare.Whippet.Fantomas.fsproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="TypeEquality" Version="0.3.0" />
+    </ItemGroup>
+</Project>

Plugins/ArgParser/WoofWare.Whippet.Plugin.ArgParser/version.json

@@ -0,0 +1,14 @@
+{
+  "version": "0.1",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
+  "pathFilters": [
+    "./",
+    ":/WoofWare.Whippet.Core/",
+    ":/WoofWare.Whippet.Fantomas/",
+    ":/Plugins/ArgParser/WoofWare.Whippet.Plugins.ArgParser.Attributes/",
+    ":/global.json",
+    ":/Directory.Build.props"
+  ]
+}

Plugins/Json/WoofWare.Whippet.Plugin.Json.Attributes/Attributes.fs

@@ -0,0 +1,37 @@
+namespace WoofWare.Whippet.Plugin.Json
+
+open System
+
+/// Attribute indicating a record type to which the "Add JSON serializer" Whippet
+/// generator should apply during build.
+/// The purpose of this generator is to create methods (possibly extension methods) of the form
+/// `{TypeName}.toJsonNode : {TypeName} -> System.Text.Json.Nodes.JsonNode`.
+///
+/// If you supply isExtensionMethod = false, you will get a module rather than extension methods.
+/// Extension methods can only be consumed from F#, but the benefit is that they don't use up the module name.
+/// (If you set this to `false`, we create a module called "{TypeName}").
+type JsonSerializeAttribute (isExtensionMethod : bool) =
+    inherit Attribute ()
+
+    /// The default value of `isExtensionMethod`, the optional argument to the JsonSerializeAttribute constructor.
+    static member DefaultIsExtensionMethod = true
+
+    /// Shorthand for the "isExtensionMethod = false" constructor; see documentation there for details.
+    new () = JsonSerializeAttribute JsonSerializeAttribute.DefaultIsExtensionMethod
+
+/// Attribute indicating a record type to which the "Add JSON parse" Whippet
+/// generator should apply during build.
+/// The purpose of this generator is to create methods (possibly extension methods) of the form
+/// `{TypeName}.jsonParse : System.Text.Json.Nodes.JsonNode -> {TypeName}`.
+///
+/// If you supply isExtensionMethod = false, you will get extension methods.
+/// Extension methods can only be consumed from F#, but the benefit is that they don't use up the module name
+/// (If you set this to `false`, we create a module called "{TypeName}").
+type JsonParseAttribute (isExtensionMethod : bool) =
+    inherit Attribute ()
+
+    /// The default value of `isExtensionMethod`, the optional argument to the JsonParseAttribute constructor.
+    static member DefaultIsExtensionMethod = true
+
+    /// Shorthand for the "isExtensionMethod = false" constructor; see documentation there for details.
+    new () = JsonParseAttribute JsonParseAttribute.DefaultIsExtensionMethod

Plugins/Json/WoofWare.Whippet.Plugin.Json.Attributes/README.md

@@ -0,0 +1,6 @@
+# WoofWare.Whippet.Plugin.Json.Attributes
+
+This is a very slim runtime dependency which consumers of WoofWare.Whippet.Plugin.Json may optionally take.
+This dependency contains attributes which control that source generator,
+although you may instead omit this dependency and control the generator entirely through configuration in consumer's `.fsproj`.
+Please see WoofWare.Whippet.Plugin.Json's README for further information.

Plugins/Json/WoofWare.Whippet.Plugin.Json.Attributes/SurfaceBaseline.txt

@@ -0,0 +1,10 @@
+WoofWare.Whippet.Plugin.Json.JsonParseAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.Json.JsonParseAttribute..ctor [constructor]: bool
+WoofWare.Whippet.Plugin.Json.JsonParseAttribute..ctor [constructor]: unit
+WoofWare.Whippet.Plugin.Json.JsonParseAttribute.DefaultIsExtensionMethod [static property]: [read-only] bool
+WoofWare.Whippet.Plugin.Json.JsonParseAttribute.get_DefaultIsExtensionMethod [static method]: unit -> bool
+WoofWare.Whippet.Plugin.Json.JsonSerializeAttribute inherit System.Attribute
+WoofWare.Whippet.Plugin.Json.JsonSerializeAttribute..ctor [constructor]: bool
+WoofWare.Whippet.Plugin.Json.JsonSerializeAttribute..ctor [constructor]: unit
+WoofWare.Whippet.Plugin.Json.JsonSerializeAttribute.DefaultIsExtensionMethod [static property]: [read-only] bool
+WoofWare.Whippet.Plugin.Json.JsonSerializeAttribute.get_DefaultIsExtensionMethod [static method]: unit -> bool

Plugins/Json/WoofWare.Whippet.Plugin.Json.Attributes/WoofWare.Whippet.Plugin.Json.Attributes.fsproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>netstandard2.0</TargetFramework>
+      <GenerateDocumentationFile>true</GenerateDocumentationFile>
+      <Authors>Patrick Stevens</Authors>
+      <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
+      <Description>Attributes to accompany the WoofWare.Whippet.Plugin.Json source generator, to indicate what you want your types to be doing.</Description>
+      <RepositoryType>git</RepositoryType>
+      <RepositoryUrl>https://github.com/Smaug123/WoofWare.Whippet</RepositoryUrl>
+      <PackageLicenseExpression>MIT</PackageLicenseExpression>
+      <PackageReadmeFile>README.md</PackageReadmeFile>
+      <PackageTags>fsharp;source-generator;source-gen;whippet;arguments;arg-parser</PackageTags>
+      <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+      <WarnOn>FS3559</WarnOn>
+      <PackageId>WoofWare.Whippet.Plugin.Json.Attributes</PackageId>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Compile Include="Attributes.fs" />
+      <EmbeddedResource Include="SurfaceBaseline.txt" />
+      <EmbeddedResource Include="version.json" />
+      <None Include="README.md">
+        <Pack>True</Pack>
+        <PackagePath>/</PackagePath>
+        <Link>README.md</Link>
+      </None>
+    </ItemGroup>
+  <ItemGroup>
+    <PackageReference Update="FSharp.Core" Version="4.3.4" />
+  </ItemGroup>
+
+</Project>

Plugins/Json/WoofWare.Whippet.Plugin.Json.Attributes/version.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
+  "pathFilters": [
+    "./",
+    ":/global.json",
+    ":/Directory.Build.props"
+  ]
+}

Plugins/Json/WoofWare.Whippet.Plugin.Json.Consumer/GeneratedJson.fs

@@ -0,0 +1,483 @@
+namespace ConsumePlugin
+
+open System.Text.Json.Serialization
+open WoofWare.Whippet.Plugin.Json
+
+/// Module containing JSON serializing extension members for the InternalTypeNotExtensionSerial type
+[<AutoOpen>]
+module internal InternalTypeNotExtensionSerialJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type InternalTypeNotExtensionSerial with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : InternalTypeNotExtensionSerial) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add (
+                    (Literals.something),
+                    (input.InternalThing2 |> System.Text.Json.Nodes.JsonValue.Create<string>)
+                )
+
+            node :> _
+namespace ConsumePlugin
+
+open System.Text.Json.Serialization
+open WoofWare.Whippet.Plugin.Json
+
+/// Module containing JSON serializing extension members for the InternalTypeExtension type
+[<AutoOpen>]
+module internal InternalTypeExtensionJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type InternalTypeExtension with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : InternalTypeExtension) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+            do node.Add ((Literals.something), (input.ExternalThing |> System.Text.Json.Nodes.JsonValue.Create<string>))
+            node :> _
+
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the InnerType type
+[<AutoOpen>]
+module InnerTypeJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type InnerType with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : InnerType =
+            let arg_0 =
+                (match node.[(Literals.something)] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ((Literals.something))
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            {
+                Thing = arg_0
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the JsonRecordType type
+[<AutoOpen>]
+module JsonRecordTypeJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type JsonRecordType with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : JsonRecordType =
+            let arg_5 =
+                (match node.["f"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("f")
+                         )
+                     )
+                 | v -> v)
+                    .AsArray ()
+                |> Seq.map (fun elt -> elt.AsValue().GetValue<System.Int32> ())
+                |> Array.ofSeq
+
+            let arg_4 =
+                (match node.["e"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("e")
+                         )
+                     )
+                 | v -> v)
+                    .AsArray ()
+                |> Seq.map (fun elt -> elt.AsValue().GetValue<System.String> ())
+                |> Array.ofSeq
+
+            let arg_3 =
+                InnerType.jsonParse (
+                    match node.["d"] with
+                    | null ->
+                        raise (
+                            System.Collections.Generic.KeyNotFoundException (
+                                sprintf "Required key '%s' not found on JSON object" ("d")
+                            )
+                        )
+                    | v -> v
+                )
+
+            let arg_2 =
+                (match node.["hi"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("hi")
+                         )
+                     )
+                 | v -> v)
+                    .AsArray ()
+                |> Seq.map (fun elt -> elt.AsValue().GetValue<System.Int32> ())
+                |> List.ofSeq
+
+            let arg_1 =
+                (match node.["another-thing"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("another-thing")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            let arg_0 =
+                (match node.["a"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("a")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+
+            {
+                A = arg_0
+                B = arg_1
+                C = arg_2
+                D = arg_3
+                E = arg_4
+                F = arg_5
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the InternalTypeNotExtension type
+[<AutoOpen>]
+module internal InternalTypeNotExtensionJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type InternalTypeNotExtension with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : InternalTypeNotExtension =
+            let arg_0 =
+                (match node.[(Literals.something)] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ((Literals.something))
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            {
+                InternalThing = arg_0
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the InternalTypeExtension type
+[<AutoOpen>]
+module internal InternalTypeExtensionJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type InternalTypeExtension with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : InternalTypeExtension =
+            let arg_0 =
+                (match node.[(Literals.something)] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ((Literals.something))
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            {
+                ExternalThing = arg_0
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the ToGetExtensionMethod type
+[<AutoOpen>]
+module ToGetExtensionMethodJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type ToGetExtensionMethod with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : ToGetExtensionMethod =
+            let arg_20 = System.Numerics.BigInteger.Parse (node.["whiskey"].ToJsonString ())
+
+            let arg_19 =
+                (match node.["victor"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("victor")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Char> ()
+
+            let arg_18 =
+                (match node.["uniform"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("uniform")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Decimal> ()
+
+            let arg_17 =
+                (match node.["tango"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("tango")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.SByte> ()
+
+            let arg_16 =
+                (match node.["quebec"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("quebec")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Byte> ()
+
+            let arg_15 =
+                (match node.["papa"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("papa")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Byte> ()
+
+            let arg_14 =
+                (match node.["oscar"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("oscar")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.SByte> ()
+
+            let arg_13 =
+                (match node.["november"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("november")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt16> ()
+
+            let arg_12 =
+                (match node.["mike"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("mike")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int16> ()
+
+            let arg_11 =
+                (match node.["lima"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("lima")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt32> ()
+
+            let arg_10 =
+                (match node.["kilo"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("kilo")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+
+            let arg_9 =
+                (match node.["juliette"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("juliette")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt32> ()
+
+            let arg_8 =
+                (match node.["india"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("india")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+
+            let arg_7 =
+                (match node.["hotel"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("hotel")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt64> ()
+
+            let arg_6 =
+                (match node.["golf"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("golf")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int64> ()
+
+            let arg_5 =
+                (match node.["foxtrot"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("foxtrot")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Double> ()
+
+            let arg_4 =
+                (match node.["echo"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("echo")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Single> ()
+
+            let arg_3 =
+                (match node.["delta"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("delta")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Single> ()
+
+            let arg_2 =
+                (match node.["charlie"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("charlie")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Double> ()
+
+            let arg_1 =
+                (match node.["bravo"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("bravo")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<string> ()
+                |> System.Uri
+
+            let arg_0 =
+                (match node.["alpha"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("alpha")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            {
+                Alpha = arg_0
+                Bravo = arg_1
+                Charlie = arg_2
+                Delta = arg_3
+                Echo = arg_4
+                Foxtrot = arg_5
+                Golf = arg_6
+                Hotel = arg_7
+                India = arg_8
+                Juliette = arg_9
+                Kilo = arg_10
+                Lima = arg_11
+                Mike = arg_12
+                November = arg_13
+                Oscar = arg_14
+                Papa = arg_15
+                Quebec = arg_16
+                Tango = arg_17
+                Uniform = arg_18
+                Victor = arg_19
+                Whiskey = arg_20
+            }

Plugins/Json/WoofWare.Whippet.Plugin.Json.Consumer/GeneratedSerializationAndDeserialization.fs

@@ -0,0 +1,977 @@
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the InnerTypeWithBoth type
+[<AutoOpen>]
+module InnerTypeWithBothJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type InnerTypeWithBoth with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : InnerTypeWithBoth) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add (("it's-a-me"), (input.Thing |> System.Text.Json.Nodes.JsonValue.Create<Guid>))
+
+                node.Add (
+                    "map",
+                    (input.Map
+                     |> (fun field ->
+                         let ret = System.Text.Json.Nodes.JsonObject ()
+
+                         for (KeyValue (key, value)) in field do
+                             ret.Add (key.ToString (), System.Text.Json.Nodes.JsonValue.Create<Uri> value)
+
+                         ret
+                     ))
+                )
+
+                node.Add (
+                    "readOnlyDict",
+                    (input.ReadOnlyDict
+                     |> (fun field ->
+                         let ret = System.Text.Json.Nodes.JsonObject ()
+
+                         for (KeyValue (key, value)) in field do
+                             ret.Add (
+                                 key.ToString (),
+                                 (fun field ->
+                                     let arr = System.Text.Json.Nodes.JsonArray ()
+
+                                     for mem in field do
+                                         arr.Add (System.Text.Json.Nodes.JsonValue.Create<char> mem)
+
+                                     arr
+                                 )
+                                     value
+                             )
+
+                         ret
+                     ))
+                )
+
+                node.Add (
+                    "dict",
+                    (input.Dict
+                     |> (fun field ->
+                         let ret = System.Text.Json.Nodes.JsonObject ()
+
+                         for (KeyValue (key, value)) in field do
+                             ret.Add (key.ToString (), System.Text.Json.Nodes.JsonValue.Create<bool> value)
+
+                         ret
+                     ))
+                )
+
+                node.Add (
+                    "concreteDict",
+                    (input.ConcreteDict
+                     |> (fun field ->
+                         let ret = System.Text.Json.Nodes.JsonObject ()
+
+                         for (KeyValue (key, value)) in field do
+                             ret.Add (key.ToString (), InnerTypeWithBoth.toJsonNode value)
+
+                         ret
+                     ))
+                )
+
+            node :> _
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the SomeEnum type
+[<AutoOpen>]
+module SomeEnumJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type SomeEnum with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : SomeEnum) : System.Text.Json.Nodes.JsonNode =
+            match input with
+            | SomeEnum.Blah -> System.Text.Json.Nodes.JsonValue.Create 1
+            | SomeEnum.Thing -> System.Text.Json.Nodes.JsonValue.Create 0
+            | v -> failwith (sprintf "Unrecognised value for enum: %O" v)
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the JsonRecordTypeWithBoth type
+[<AutoOpen>]
+module JsonRecordTypeWithBothJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type JsonRecordTypeWithBoth with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : JsonRecordTypeWithBoth) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add ("a", (input.A |> System.Text.Json.Nodes.JsonValue.Create<int>))
+                node.Add ("b", (input.B |> System.Text.Json.Nodes.JsonValue.Create<string>))
+
+                node.Add (
+                    "c",
+                    (input.C
+                     |> (fun field ->
+                         let arr = System.Text.Json.Nodes.JsonArray ()
+
+                         for mem in field do
+                             arr.Add (System.Text.Json.Nodes.JsonValue.Create<int> mem)
+
+                         arr
+                     ))
+                )
+
+                node.Add ("d", (input.D |> InnerTypeWithBoth.toJsonNode))
+
+                node.Add (
+                    "e",
+                    (input.E
+                     |> (fun field ->
+                         let arr = System.Text.Json.Nodes.JsonArray ()
+
+                         for mem in field do
+                             arr.Add (System.Text.Json.Nodes.JsonValue.Create<string> mem)
+
+                         arr
+                     ))
+                )
+
+                node.Add (
+                    "arr",
+                    (input.Arr
+                     |> (fun field ->
+                         let arr = System.Text.Json.Nodes.JsonArray ()
+
+                         for mem in field do
+                             arr.Add (System.Text.Json.Nodes.JsonValue.Create<int> mem)
+
+                         arr
+                     ))
+                )
+
+                node.Add ("byte", (input.Byte |> System.Text.Json.Nodes.JsonValue.Create<byte<measure>>))
+                node.Add ("sbyte", (input.Sbyte |> System.Text.Json.Nodes.JsonValue.Create<sbyte<measure>>))
+                node.Add ("i", (input.I |> System.Text.Json.Nodes.JsonValue.Create<int<measure>>))
+                node.Add ("i32", (input.I32 |> System.Text.Json.Nodes.JsonValue.Create<int32<measure>>))
+                node.Add ("i64", (input.I64 |> System.Text.Json.Nodes.JsonValue.Create<int64<measure>>))
+                node.Add ("u", (input.U |> System.Text.Json.Nodes.JsonValue.Create<uint<measure>>))
+                node.Add ("u32", (input.U32 |> System.Text.Json.Nodes.JsonValue.Create<uint32<measure>>))
+                node.Add ("u64", (input.U64 |> System.Text.Json.Nodes.JsonValue.Create<uint64<measure>>))
+                node.Add ("f", (input.F |> System.Text.Json.Nodes.JsonValue.Create<float<measure>>))
+                node.Add ("f32", (input.F32 |> System.Text.Json.Nodes.JsonValue.Create<float32<measure>>))
+                node.Add ("single", (input.Single |> System.Text.Json.Nodes.JsonValue.Create<single<measure>>))
+
+                node.Add (
+                    "intMeasureOption",
+                    (input.IntMeasureOption
+                     |> (fun field ->
+                         match field with
+                         | None -> null :> System.Text.Json.Nodes.JsonNode
+                         | Some field ->
+                             (System.Text.Json.Nodes.JsonValue.Create<int<measure>> field)
+                             :> System.Text.Json.Nodes.JsonNode
+                     ))
+                )
+
+                node.Add (
+                    "intMeasureNullable",
+                    (input.IntMeasureNullable
+                     |> (fun field ->
+                         if field.HasValue then
+                             System.Text.Json.Nodes.JsonValue.Create<int<measure>> field.Value
+                             :> System.Text.Json.Nodes.JsonNode
+                         else
+                             null :> System.Text.Json.Nodes.JsonNode
+                     ))
+                )
+
+                node.Add ("enum", (input.Enum |> SomeEnum.toJsonNode))
+
+                node.Add (
+                    "timestamp",
+                    (input.Timestamp
+                     |> (fun field -> field.ToString "o" |> System.Text.Json.Nodes.JsonValue.Create<string>))
+                )
+
+                node.Add ("unit", (input.Unit |> (fun value -> System.Text.Json.Nodes.JsonObject ())))
+
+            node :> _
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the FirstDu type
+[<AutoOpen>]
+module FirstDuJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type FirstDu with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : FirstDu) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            match input with
+            | FirstDu.EmptyCase -> node.Add ("type", System.Text.Json.Nodes.JsonValue.Create "emptyCase")
+            | FirstDu.Case1 arg0 ->
+                node.Add ("type", System.Text.Json.Nodes.JsonValue.Create "case1")
+                let dataNode = System.Text.Json.Nodes.JsonObject ()
+                dataNode.Add ("data", System.Text.Json.Nodes.JsonValue.Create<string> arg0)
+                node.Add ("data", dataNode)
+            | FirstDu.Case2 (arg0, arg1) ->
+                node.Add ("type", System.Text.Json.Nodes.JsonValue.Create "case2")
+                let dataNode = System.Text.Json.Nodes.JsonObject ()
+                dataNode.Add ("record", JsonRecordTypeWithBoth.toJsonNode arg0)
+                dataNode.Add ("i", System.Text.Json.Nodes.JsonValue.Create<int> arg1)
+                node.Add ("data", dataNode)
+
+            node :> _
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the HeaderAndValue type
+[<AutoOpen>]
+module HeaderAndValueJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type HeaderAndValue with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : HeaderAndValue) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add ("header", (input.Header |> System.Text.Json.Nodes.JsonValue.Create<string>))
+                node.Add ("value", (input.Value |> System.Text.Json.Nodes.JsonValue.Create<string>))
+
+            node :> _
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the Foo type
+[<AutoOpen>]
+module FooJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type Foo with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : Foo) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add (
+                    "message",
+                    (input.Message
+                     |> (fun field ->
+                         match field with
+                         | None -> null :> System.Text.Json.Nodes.JsonNode
+                         | Some field -> HeaderAndValue.toJsonNode field
+                     ))
+                )
+
+            node :> _
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the CollectRemaining type
+[<AutoOpen>]
+module CollectRemainingJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type CollectRemaining with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : CollectRemaining) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add (
+                    "message",
+                    (input.Message
+                     |> (fun field ->
+                         match field with
+                         | None -> null :> System.Text.Json.Nodes.JsonNode
+                         | Some field -> HeaderAndValue.toJsonNode field
+                     ))
+                )
+
+                for KeyValue (key, value) in input.Rest do
+                    node.Add (key, id value)
+
+            node :> _
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+/// Module containing JSON serializing extension members for the OuterCollectRemaining type
+[<AutoOpen>]
+module OuterCollectRemainingJsonSerializeExtension =
+    /// Extension methods for JSON parsing
+    type OuterCollectRemaining with
+
+        /// Serialize to a JSON node
+        static member toJsonNode (input : OuterCollectRemaining) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                for KeyValue (key, value) in input.Others do
+                    node.Add (key, System.Text.Json.Nodes.JsonValue.Create<int> value)
+
+                node.Add ("remaining", (input.Remaining |> CollectRemaining.toJsonNode))
+
+            node :> _
+
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the InnerTypeWithBoth type
+[<AutoOpen>]
+module InnerTypeWithBothJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type InnerTypeWithBoth with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : InnerTypeWithBoth =
+            let arg_4 =
+                (match node.["concreteDict"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("concreteDict")
+                         )
+                     )
+                 | v -> v)
+                    .AsObject ()
+                |> Seq.map (fun kvp ->
+                    let key = (kvp.Key)
+                    let value = InnerTypeWithBoth.jsonParse (kvp.Value)
+                    key, value
+                )
+                |> Seq.map System.Collections.Generic.KeyValuePair
+                |> System.Collections.Generic.Dictionary
+
+            let arg_3 =
+                (match node.["dict"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("dict")
+                         )
+                     )
+                 | v -> v)
+                    .AsObject ()
+                |> Seq.map (fun kvp ->
+                    let key = (kvp.Key) |> System.Uri
+                    let value = (kvp.Value).AsValue().GetValue<System.Boolean> ()
+                    key, value
+                )
+                |> dict
+
+            let arg_2 =
+                (match node.["readOnlyDict"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("readOnlyDict")
+                         )
+                     )
+                 | v -> v)
+                    .AsObject ()
+                |> Seq.map (fun kvp ->
+                    let key = (kvp.Key)
+
+                    let value =
+                        (kvp.Value).AsArray ()
+                        |> Seq.map (fun elt -> elt.AsValue().GetValue<System.Char> ())
+                        |> List.ofSeq
+
+                    key, value
+                )
+                |> readOnlyDict
+
+            let arg_1 =
+                (match node.["map"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("map")
+                         )
+                     )
+                 | v -> v)
+                    .AsObject ()
+                |> Seq.map (fun kvp ->
+                    let key = (kvp.Key)
+                    let value = (kvp.Value).AsValue().GetValue<string> () |> System.Uri
+                    key, value
+                )
+                |> Map.ofSeq
+
+            let arg_0 =
+                (match node.[("it's-a-me")] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" (("it's-a-me"))
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<string> ()
+                |> System.Guid.Parse
+
+            {
+                Thing = arg_0
+                Map = arg_1
+                ReadOnlyDict = arg_2
+                Dict = arg_3
+                ConcreteDict = arg_4
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the SomeEnum type
+[<AutoOpen>]
+module SomeEnumJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type SomeEnum with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : SomeEnum =
+            match node.GetValueKind () with
+            | System.Text.Json.JsonValueKind.Number -> node.AsValue().GetValue<int> () |> enum<SomeEnum>
+            | System.Text.Json.JsonValueKind.String ->
+                match node.AsValue().GetValue<string>().ToLowerInvariant () with
+                | "blah" -> SomeEnum.Blah
+                | "thing" -> SomeEnum.Thing
+                | v -> failwith ("Unrecognised value for enum: %i" + v)
+            | _ -> failwith ("Unrecognised kind for enum of type: " + "SomeEnum")
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the JsonRecordTypeWithBoth type
+[<AutoOpen>]
+module JsonRecordTypeWithBothJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type JsonRecordTypeWithBoth with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : JsonRecordTypeWithBoth =
+            let arg_21 = ()
+
+            let arg_20 =
+                (match node.["timestamp"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("timestamp")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<string> ()
+                |> System.DateTimeOffset.Parse
+
+            let arg_19 =
+                SomeEnum.jsonParse (
+                    match node.["enum"] with
+                    | null ->
+                        raise (
+                            System.Collections.Generic.KeyNotFoundException (
+                                sprintf "Required key '%s' not found on JSON object" ("enum")
+                            )
+                        )
+                    | v -> v
+                )
+
+            let arg_18 =
+                match node.["intMeasureNullable"] with
+                | null -> System.Nullable ()
+                | v ->
+                    v.AsValue().GetValue<System.Int32> ()
+                    |> LanguagePrimitives.Int32WithMeasure
+                    |> System.Nullable
+
+            let arg_17 =
+                match node.["intMeasureOption"] with
+                | null -> None
+                | v ->
+                    v.AsValue().GetValue<System.Int32> ()
+                    |> LanguagePrimitives.Int32WithMeasure
+                    |> Some
+
+            let arg_16 =
+                (match node.["single"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("single")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Single> ()
+                |> LanguagePrimitives.Float32WithMeasure
+
+            let arg_15 =
+                (match node.["f32"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("f32")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Single> ()
+                |> LanguagePrimitives.Float32WithMeasure
+
+            let arg_14 =
+                (match node.["f"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("f")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Double> ()
+                |> LanguagePrimitives.FloatWithMeasure
+
+            let arg_13 =
+                (match node.["u64"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("u64")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt64> ()
+                |> LanguagePrimitives.UInt64WithMeasure
+
+            let arg_12 =
+                (match node.["u32"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("u32")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt32> ()
+                |> LanguagePrimitives.UInt32WithMeasure
+
+            let arg_11 =
+                (match node.["u"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("u")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt32> ()
+                |> LanguagePrimitives.UInt32WithMeasure
+
+            let arg_10 =
+                (match node.["i64"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("i64")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int64> ()
+                |> LanguagePrimitives.Int64WithMeasure
+
+            let arg_9 =
+                (match node.["i32"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("i32")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+                |> LanguagePrimitives.Int32WithMeasure
+
+            let arg_8 =
+                (match node.["i"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("i")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+                |> LanguagePrimitives.Int32WithMeasure
+
+            let arg_7 =
+                (match node.["sbyte"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("sbyte")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.SByte> ()
+                |> LanguagePrimitives.SByteWithMeasure
+
+            let arg_6 =
+                (match node.["byte"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("byte")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Byte> ()
+                |> LanguagePrimitives.ByteWithMeasure
+
+            let arg_5 =
+                (match node.["arr"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("arr")
+                         )
+                     )
+                 | v -> v)
+                    .AsArray ()
+                |> Seq.map (fun elt -> elt.AsValue().GetValue<System.Int32> ())
+                |> Array.ofSeq
+
+            let arg_4 =
+                (match node.["e"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("e")
+                         )
+                     )
+                 | v -> v)
+                    .AsArray ()
+                |> Seq.map (fun elt -> elt.AsValue().GetValue<System.String> ())
+                |> Array.ofSeq
+
+            let arg_3 =
+                InnerTypeWithBoth.jsonParse (
+                    match node.["d"] with
+                    | null ->
+                        raise (
+                            System.Collections.Generic.KeyNotFoundException (
+                                sprintf "Required key '%s' not found on JSON object" ("d")
+                            )
+                        )
+                    | v -> v
+                )
+
+            let arg_2 =
+                (match node.["c"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("c")
+                         )
+                     )
+                 | v -> v)
+                    .AsArray ()
+                |> Seq.map (fun elt -> elt.AsValue().GetValue<System.Int32> ())
+                |> List.ofSeq
+
+            let arg_1 =
+                (match node.["b"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("b")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            let arg_0 =
+                (match node.["a"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("a")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+
+            {
+                A = arg_0
+                B = arg_1
+                C = arg_2
+                D = arg_3
+                E = arg_4
+                Arr = arg_5
+                Byte = arg_6
+                Sbyte = arg_7
+                I = arg_8
+                I32 = arg_9
+                I64 = arg_10
+                U = arg_11
+                U32 = arg_12
+                U64 = arg_13
+                F = arg_14
+                F32 = arg_15
+                Single = arg_16
+                IntMeasureOption = arg_17
+                IntMeasureNullable = arg_18
+                Enum = arg_19
+                Timestamp = arg_20
+                Unit = arg_21
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the FirstDu type
+[<AutoOpen>]
+module FirstDuJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type FirstDu with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : FirstDu =
+            let ty =
+                (match node.["type"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("type")
+                         )
+                     )
+                 | v -> v)
+                |> (fun v -> v.GetValue<string> ())
+
+            match ty with
+            | "emptyCase" -> FirstDu.EmptyCase
+            | "case1" ->
+                let node =
+                    (match node.["data"] with
+                     | null ->
+                         raise (
+                             System.Collections.Generic.KeyNotFoundException (
+                                 sprintf "Required key '%s' not found on JSON object" ("data")
+                             )
+                         )
+                     | v -> v)
+
+                FirstDu.Case1 (
+                    (match node.["data"] with
+                     | null ->
+                         raise (
+                             System.Collections.Generic.KeyNotFoundException (
+                                 sprintf "Required key '%s' not found on JSON object" ("data")
+                             )
+                         )
+                     | v -> v)
+                        .AsValue()
+                        .GetValue<System.String> ()
+                )
+            | "case2" ->
+                let node =
+                    (match node.["data"] with
+                     | null ->
+                         raise (
+                             System.Collections.Generic.KeyNotFoundException (
+                                 sprintf "Required key '%s' not found on JSON object" ("data")
+                             )
+                         )
+                     | v -> v)
+
+                FirstDu.Case2 (
+                    JsonRecordTypeWithBoth.jsonParse (
+                        match node.["record"] with
+                        | null ->
+                            raise (
+                                System.Collections.Generic.KeyNotFoundException (
+                                    sprintf "Required key '%s' not found on JSON object" ("record")
+                                )
+                            )
+                        | v -> v
+                    ),
+                    (match node.["i"] with
+                     | null ->
+                         raise (
+                             System.Collections.Generic.KeyNotFoundException (
+                                 sprintf "Required key '%s' not found on JSON object" ("i")
+                             )
+                         )
+                     | v -> v)
+                        .AsValue()
+                        .GetValue<System.Int32> ()
+                )
+            | v -> failwith ("Unrecognised 'type' field value: " + v)
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the HeaderAndValue type
+[<AutoOpen>]
+module HeaderAndValueJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type HeaderAndValue with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : HeaderAndValue =
+            let arg_1 =
+                (match node.["value"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("value")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            let arg_0 =
+                (match node.["header"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("header")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.String> ()
+
+            {
+                Header = arg_0
+                Value = arg_1
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the Foo type
+[<AutoOpen>]
+module FooJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type Foo with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : Foo =
+            let arg_0 =
+                match node.["message"] with
+                | null -> None
+                | v -> HeaderAndValue.jsonParse v |> Some
+
+            {
+                Message = arg_0
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the CollectRemaining type
+[<AutoOpen>]
+module CollectRemainingJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type CollectRemaining with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : CollectRemaining =
+            let arg_1 =
+                let result =
+                    System.Collections.Generic.Dictionary<string, System.Text.Json.Nodes.JsonNode> ()
+
+                let node = node.AsObject ()
+
+                for KeyValue (key, value) in node do
+                    if key = "message" then () else result.Add (key, node.[key])
+
+                result
+
+            let arg_0 =
+                match node.["message"] with
+                | null -> None
+                | v -> HeaderAndValue.jsonParse v |> Some
+
+            {
+                Message = arg_0
+                Rest = arg_1
+            }
+namespace ConsumePlugin
+
+/// Module containing JSON parsing extension members for the OuterCollectRemaining type
+[<AutoOpen>]
+module OuterCollectRemainingJsonParseExtension =
+    /// Extension methods for JSON parsing
+    type OuterCollectRemaining with
+
+        /// Parse from a JSON node.
+        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : OuterCollectRemaining =
+            let arg_1 =
+                CollectRemaining.jsonParse (
+                    match node.["remaining"] with
+                    | null ->
+                        raise (
+                            System.Collections.Generic.KeyNotFoundException (
+                                sprintf "Required key '%s' not found on JSON object" ("remaining")
+                            )
+                        )
+                    | v -> v
+                )
+
+            let arg_0 =
+                let result = System.Collections.Generic.Dictionary<string, int> ()
+                let node = node.AsObject ()
+
+                for KeyValue (key, value) in node do
+                    if key = "remaining" then
+                        ()
+                    else
+                        result.Add (
+                            key,
+                            (match node.[key] with
+                             | null ->
+                                 raise (
+                                     System.Collections.Generic.KeyNotFoundException (
+                                         sprintf "Required key '%s' not found on JSON object" (key)
+                                     )
+                                 )
+                             | v -> v)
+                                .AsValue()
+                                .GetValue<System.Int32> ()
+                        )
+
+                result
+
+            {
+                Others = arg_0
+                Remaining = arg_1
+            }

Plugins/Json/WoofWare.Whippet.Plugin.Json.Consumer/JsonRecord.fs

@@ -0,0 +1,83 @@
+namespace ConsumePlugin
+
+open System.Text.Json.Serialization
+open WoofWare.Whippet.Plugin.Json
+
+module Literals =
+    [<Literal>]
+    let something = "something"
+
+[<JsonParse>]
+type InnerType =
+    {
+        [<JsonPropertyName(Literals.something)>]
+        Thing : string
+    }
+
+/// My whatnot
+[<JsonParse>]
+type JsonRecordType =
+    {
+        /// A thing!
+        A : int
+        /// Another thing!
+        [<JsonPropertyName "another-thing">]
+        B : string
+        [<System.Text.Json.Serialization.JsonPropertyName "hi">]
+        C : int list
+        D : InnerType
+        E : string array
+        F : int[]
+    }
+
+[<JsonParse>]
+type internal InternalTypeNotExtension =
+    {
+        [<JsonPropertyName(Literals.something)>]
+        InternalThing : string
+    }
+
+[<JsonSerialize>]
+type internal InternalTypeNotExtensionSerial =
+    {
+        [<JsonPropertyName(Literals.something)>]
+        InternalThing2 : string
+    }
+
+[<JsonParse true>]
+[<JsonSerialize true>]
+type internal InternalTypeExtension =
+    {
+        [<JsonPropertyName(Literals.something)>]
+        ExternalThing : string
+    }
+
+[<JsonParse true>]
+type ToGetExtensionMethod =
+    {
+        Alpha : string
+        Bravo : System.Uri
+        Charlie : float
+        Delta : float32
+        Echo : single
+        Foxtrot : double
+        Golf : int64
+        Hotel : uint64
+        India : int
+        Juliette : uint
+        Kilo : int32
+        Lima : uint32
+        Mike : int16
+        November : uint16
+        Oscar : int8
+        Papa : uint8
+        Quebec : byte
+        Tango : sbyte
+        Uniform : decimal
+        Victor : char
+        Whiskey : bigint
+    }
+
+[<RequireQualifiedAccess>]
+module ToGetExtensionMethod =
+    let thisModuleWouldClash = 3

Plugins/Json/WoofWare.Whippet.Plugin.Json.Consumer/PureGymDto.fs

@@ -0,0 +1,190 @@
+// Copied from https://gitea.patrickstevens.co.uk/patrick/puregym-unofficial-dotnet/src/commit/2741c5e36cf0bdb203b12b78a8062e25af9d89c7/PureGym/Api.fs
+
+namespace PureGym
+
+open System
+open System.Text.Json.Serialization
+open WoofWare.Whippet.Plugin.Json
+
+[<JsonParse>]
+type GymOpeningHours =
+    {
+        IsAlwaysOpen : bool
+        OpeningHours : string list
+    }
+
+[<JsonParse>]
+type GymAccessOptions =
+    {
+        PinAccess : bool
+        QrCodeAccess : bool
+    }
+
+[<Measure>]
+type measure
+
+[<JsonParse>]
+type GymLocation =
+    {
+        [<JsonNumberHandling(JsonNumberHandling.AllowReadingFromString)>]
+        Longitude : float
+        [<JsonNumberHandling(JsonNumberHandling.AllowReadingFromString)>]
+        Latitude : float<measure>
+    }
+
+[<JsonParse>]
+type GymAddress =
+    {
+        [<JsonRequired>]
+        AddressLine1 : string
+        AddressLine2 : string option
+        AddressLine3 : string option
+        [<JsonRequired>]
+        Town : string
+        County : string option
+        [<JsonRequired>]
+        Postcode : string
+    }
+
+[<JsonParse>]
+type Gym =
+    {
+        [<JsonRequired>]
+        Name : string
+        [<JsonRequired>]
+        Id : int
+        [<JsonRequired>]
+        Status : int
+        [<JsonRequired>]
+        Address : GymAddress
+        [<JsonRequired>]
+        PhoneNumber : string
+        [<JsonRequired>]
+        EmailAddress : string
+        [<JsonRequired>]
+        GymOpeningHours : GymOpeningHours
+        [<JsonRequired>]
+        AccessOptions : GymAccessOptions
+        [<JsonRequired>]
+        Location : GymLocation
+        [<JsonRequired>]
+        TimeZone : string
+        ReopenDate : string
+    }
+
+[<JsonParse true>]
+[<JsonSerialize true>]
+type Member =
+    {
+        Id : int
+        CompoundMemberId : string
+        FirstName : string
+        LastName : string
+        HomeGymId : int
+        HomeGymName : string
+        EmailAddress : string
+        GymAccessPin : string
+        [<JsonPropertyName "dateofBirth">]
+        DateOfBirth : DateOnly
+        MobileNumber : string
+        [<JsonPropertyName "postCode">]
+        Postcode : string
+        MembershipName : string
+        MembershipLevel : int
+        SuspendedReason : int
+        MemberStatus : int
+    }
+
+[<JsonParse>]
+type GymAttendance =
+    {
+        [<JsonRequired>]
+        Description : string
+        [<JsonRequired>]
+        TotalPeopleInGym : int
+        [<JsonRequired>]
+        TotalPeopleInClasses : int
+        TotalPeopleSuffix : string option
+        [<JsonRequired>]
+        IsApproximate : bool
+        AttendanceTime : DateTime
+        LastRefreshed : DateTime
+        LastRefreshedPeopleInClasses : DateTime
+        MaximumCapacity : int
+    }
+
+[<JsonParse>]
+type MemberActivityDto =
+    {
+        [<JsonRequired>]
+        TotalDuration : int
+        [<JsonRequired>]
+        AverageDuration : int
+        [<JsonRequired>]
+        TotalVisits : int
+        [<JsonRequired>]
+        TotalClasses : int
+        [<JsonRequired>]
+        IsEstimated : bool
+        [<JsonRequired>]
+        LastRefreshed : DateTime
+    }
+
+[<JsonParse>]
+type SessionsAggregate =
+    {
+        [<JsonPropertyName "Activities">]
+        Activities : int
+        [<JsonPropertyName "Visits">]
+        Visits : int
+        [<JsonPropertyName "Duration">]
+        Duration : int
+    }
+
+[<JsonParse>]
+type VisitGym =
+    {
+        [<JsonPropertyName "Id">]
+        Id : int
+        [<JsonPropertyName "Name">]
+        Name : string
+        [<JsonPropertyName "Status">]
+        Status : string
+    }
+
+[<JsonParse>]
+type Visit =
+    {
+        [<JsonPropertyName "IsDurationEstimated">]
+        IsDurationEstimated : bool
+        [<JsonPropertyName "StartTime">]
+        StartTime : DateTime
+        [<JsonPropertyName "Duration">]
+        Duration : int
+        [<JsonPropertyName "Gym">]
+        Gym : VisitGym
+    }
+
+[<JsonParse>]
+type SessionsSummary =
+    {
+        [<JsonPropertyName "Total">]
+        Total : SessionsAggregate
+        [<JsonPropertyName "ThisWeek">]
+        ThisWeek : SessionsAggregate
+    }
+
+[<JsonParse>]
+type Sessions =
+    {
+        [<JsonPropertyName "Summary">]
+        Summary : SessionsSummary
+        [<JsonPropertyName "Visits">]
+        Visits : Visit list
+    }
+
+[<JsonParse>]
+type UriThing =
+    {
+        SomeUri : Uri
+    }

Plugins/Json/WoofWare.Whippet.Plugin.Json.Consumer/SerializationAndDeserialization.fs

@@ -0,0 +1,94 @@
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+type InnerTypeWithBoth =
+    {
+        [<JsonPropertyName("it's-a-me")>]
+        Thing : Guid
+        Map : Map<string, Uri>
+        ReadOnlyDict : IReadOnlyDictionary<string, char list>
+        Dict : IDictionary<Uri, bool>
+        ConcreteDict : Dictionary<string, InnerTypeWithBoth>
+    }
+
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+type SomeEnum =
+    | Blah = 1
+    | Thing = 0
+
+[<Measure>]
+type measure
+
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+type JsonRecordTypeWithBoth =
+    {
+        A : int
+        B : string
+        C : int list
+        D : InnerTypeWithBoth
+        E : string array
+        Arr : int[]
+        Byte : byte<measure>
+        Sbyte : sbyte<measure>
+        I : int<measure>
+        I32 : int32<measure>
+        I64 : int64<measure>
+        U : uint<measure>
+        U32 : uint32<measure>
+        U64 : uint64<measure>
+        F : float<measure>
+        F32 : float32<measure>
+        Single : single<measure>
+        IntMeasureOption : int<measure> option
+        IntMeasureNullable : int<measure> Nullable
+        Enum : SomeEnum
+        Timestamp : DateTimeOffset
+        Unit : unit
+    }
+
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+type FirstDu =
+    | EmptyCase
+    | Case1 of data : string
+    | Case2 of record : JsonRecordTypeWithBoth * i : int
+
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+type HeaderAndValue =
+    {
+        Header : string
+        Value : string
+    }
+
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+type Foo =
+    {
+        Message : HeaderAndValue option
+    }
+
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+type CollectRemaining =
+    {
+        Message : HeaderAndValue option
+        [<JsonExtensionData>]
+        Rest : Dictionary<string, System.Text.Json.Nodes.JsonNode>
+    }
+
+[<WoofWare.Whippet.Plugin.Json.JsonSerialize true>]
+[<WoofWare.Whippet.Plugin.Json.JsonParse true>]
+type OuterCollectRemaining =
+    {
+        [<JsonExtensionData>]
+        Others : Dictionary<string, int>
+        Remaining : CollectRemaining
+    }

Plugins/Json/WoofWare.Whippet.Plugin.Json.Consumer/WoofWare.Whippet.Plugin.Json.Consumer.fsproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net8.0</TargetFramework>
+      <GenerateDocumentationFile>true</GenerateDocumentationFile>
+      <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="JsonRecord.fs" />
+        <Compile Include="GeneratedJson.fs">
+          <WhippetFile>JsonRecord.fs</WhippetFile>
+        </Compile>
+        <Compile Include="SerializationAndDeserialization.fs" />
+        <Compile Include="GeneratedSerializationAndDeserialization.fs">
+          <WhippetFile>SerializationAndDeserialization.fs</WhippetFile>
+        </Compile>
+      <Compile Include="PureGymDto.fs" />
+      <Compile Include="GeneratedPureGymDto.fs">
+        <WhippetFile>PureGymDto.fs</WhippetFile>
+      </Compile>
+    </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WoofWare.Whippet.Plugin.Json\WoofWare.Whippet.Plugin.Json.fsproj" WhippetPlugin="true" />
+    <!-- Dance to get a binary dependency on a locally-built Whippet -->
+    <!-- ProjectReference Include="..\..\..\WoofWare.Whippet\WoofWare.Whippet.fsproj" PrivateAssets="all" -->
+    <PackageReference Include="WoofWare.Whippet" Version="*-*" PrivateAssets="all" />
+  </ItemGroup>
+
+</Project>

Plugins/Json/WoofWare.Whippet.Plugin.Json/DesiredGenerator.fs

@@ -0,0 +1,15 @@
+namespace WoofWare.Whippet.Plugin.Json
+
+type internal DesiredGenerator =
+    | JsonParse of extensionMethod : bool option
+    | JsonSerialize of extensionMethod : bool option
+
+    static member Parse (s : string) =
+        match s with
+        | "JsonParse" -> DesiredGenerator.JsonParse None
+        | "JsonParse(true)" -> DesiredGenerator.JsonParse (Some true)
+        | "JsonParse(false)" -> DesiredGenerator.JsonParse (Some false)
+        | "JsonSerialize" -> DesiredGenerator.JsonSerialize None
+        | "JsonSerialize(true)" -> DesiredGenerator.JsonSerialize (Some true)
+        | "JsonSerialize(false)" -> DesiredGenerator.JsonSerialize (Some false)
+        | _ -> failwith $"Failed to parse as a generator specification: %s{s}"

Plugins/Json/WoofWare.Whippet.Plugin.Json/JsonParseGenerator.fs

@@ -0,0 +1,783 @@
+namespace WoofWare.Whippet.Plugin.Json
+
+open System
+open System.Text
+open Fantomas.FCS.Syntax
+open Fantomas.FCS.SyntaxTrivia
+open WoofWare.Whippet.Core
+open WoofWare.Whippet.Fantomas
+
+type internal JsonParseOutputSpec =
+    {
+        ExtensionMethods : bool
+    }
+
+[<RequireQualifiedAccess>]
+module internal JsonParseGenerator =
+    open Fantomas.FCS.Text.Range
+
+    type JsonParseOption =
+        {
+            JsonNumberHandlingArg : SynExpr option
+        }
+
+        static member None =
+            {
+                JsonNumberHandlingArg = None
+            }
+
+    /// (match {indexed} with | null -> raise (System.Collections.Generic.KeyNotFoundException ({propertyName} not found)) | v -> v)
+    let assertNotNull (propertyName : SynExpr) (indexed : SynExpr) =
+        let raiseExpr =
+            SynExpr.applyFunction
+                (SynExpr.createIdent "sprintf")
+                (SynExpr.CreateConst "Required key '%s' not found on JSON object")
+            |> SynExpr.applyTo (SynExpr.paren propertyName)
+            |> SynExpr.paren
+            |> SynExpr.applyFunction (
+                SynExpr.createLongIdent [ "System" ; "Collections" ; "Generic" ; "KeyNotFoundException" ]
+            )
+            |> SynExpr.paren
+            |> SynExpr.applyFunction (SynExpr.createIdent "raise")
+
+        [
+            SynMatchClause.create SynPat.createNull raiseExpr
+            SynMatchClause.create (SynPat.named "v") (SynExpr.createIdent "v")
+        ]
+        |> SynExpr.createMatch indexed
+        |> SynExpr.paren
+
+    /// {node}.AsValue().GetValue<{typeName}> ()
+    /// If `propertyName` is Some, uses `assertNotNull {node}` instead of `{node}`.
+    let asValueGetValue (propertyName : SynExpr option) (typeName : string) (node : SynExpr) : SynExpr =
+        match propertyName with
+        | None -> node
+        | Some propertyName -> assertNotNull propertyName node
+        |> SynExpr.callMethod "AsValue"
+        |> SynExpr.callGenericMethod' "GetValue" typeName
+
+    let asValueGetValueIdent (propertyName : SynExpr option) (typeName : LongIdent) (node : SynExpr) : SynExpr =
+        match propertyName with
+        | None -> node
+        | Some propertyName -> assertNotNull propertyName node
+        |> SynExpr.callMethod "AsValue"
+        |> SynExpr.callGenericMethod (SynLongIdent.createS "GetValue") [ SynType.createLongIdent typeName ]
+
+    /// {node}.AsObject()
+    /// If `propertyName` is Some, uses `assertNotNull {node}` instead of `{node}`.
+    let asObject (propertyName : SynExpr option) (node : SynExpr) : SynExpr =
+        match propertyName with
+        | None -> node
+        | Some propertyName -> assertNotNull propertyName node
+        |> SynExpr.callMethod "AsObject"
+
+    /// {type}.jsonParse {node}
+    let typeJsonParse (typeName : LongIdent) (node : SynExpr) : SynExpr =
+        node
+        |> SynExpr.applyFunction (SynExpr.createLongIdent' (typeName @ [ Ident.create "jsonParse" ]))
+
+    /// collectionType is e.g. "List"; we'll be calling `ofSeq` on it.
+    /// body is the body of a lambda which takes a parameter `elt`.
+    /// {assertNotNull node}.AsArray()
+    /// |> Seq.map (fun elt -> {body})
+    /// |> {collectionType}.ofSeq
+    let asArrayMapped
+        (propertyName : SynExpr option)
+        (collectionType : string)
+        (node : SynExpr)
+        (body : SynExpr)
+        : SynExpr
+        =
+        match propertyName with
+        | None -> node
+        | Some propertyName -> assertNotNull propertyName node
+        |> SynExpr.callMethod "AsArray"
+        |> SynExpr.pipeThroughFunction (
+            SynExpr.applyFunction (SynExpr.createLongIdent [ "Seq" ; "map" ]) (SynExpr.createLambda "elt" body)
+        )
+        |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ collectionType ; "ofSeq" ])
+
+    let dotParse (typeName : LongIdent) : LongIdent =
+        List.append typeName [ Ident.create "Parse" ]
+
+    /// fun kvp -> let key = {key(kvp)} in let value = {value(kvp)} in (key, value))
+    /// The inputs will be fed with appropriate SynExprs to apply them to the `kvp.Key` and `kvp.Value` args.
+    let dictionaryMapper (key : SynExpr -> SynExpr) (value : SynExpr -> SynExpr) : SynExpr =
+        let keyArg = SynExpr.createLongIdent [ "kvp" ; "Key" ] |> SynExpr.paren
+
+        let valueArg = SynExpr.createLongIdent [ "kvp" ; "Value" ] |> SynExpr.paren
+
+        // No need to paren here, we're on the LHS of a `let`
+        SynExpr.tupleNoParen [ SynExpr.createIdent "key" ; SynExpr.createIdent "value" ]
+        |> SynExpr.createLet [ SynBinding.basic [ Ident.create "value" ] [] (value valueArg) ]
+        |> SynExpr.createLet [ SynBinding.basic [ Ident.create "key" ] [] (key keyArg) ]
+        |> SynExpr.createLambda "kvp"
+
+    /// A conforming JSON object has only strings as keys. But it would be reasonable to allow the user
+    /// to parse these as URIs, for example.
+    let parseKeyString (desiredType : SynType) (key : SynExpr) : SynExpr =
+        match desiredType with
+        | String -> key
+        | Uri ->
+            key
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "Uri" ])
+        | _ ->
+            failwithf
+                $"Unable to parse the key type %+A{desiredType} of a JSON object. Keys are strings, and this plugin does not know how to convert to that from a string."
+
+    let private parseNumberType
+        (options : JsonParseOption)
+        (propertyName : SynExpr option)
+        (node : SynExpr)
+        (typeName : LongIdent)
+        =
+        let basic = asValueGetValueIdent propertyName typeName node
+
+        match options.JsonNumberHandlingArg with
+        | None -> basic
+        | Some option ->
+            let cond =
+                SynExpr.DotGet (SynExpr.createIdent "exc", range0, SynLongIdent.createS "Message", range0)
+                |> SynExpr.callMethodArg "Contains" (SynExpr.CreateConst "cannot be converted to")
+
+            let handler =
+                asValueGetValue propertyName "string" node
+                |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent' (typeName |> dotParse))
+                |> SynExpr.ifThenElse
+                    (SynExpr.equals
+                        option
+                        (SynExpr.createLongIdent
+                            [
+                                "System"
+                                "Text"
+                                "Json"
+                                "Serialization"
+                                "JsonNumberHandling"
+                                "AllowReadingFromString"
+                            ]))
+                    SynExpr.reraise
+                |> SynExpr.ifThenElse cond SynExpr.reraise
+
+            basic
+            |> SynExpr.pipeThroughTryWith
+                (SynPat.IsInst (
+                    SynType.LongIdent (SynLongIdent.createS' [ "System" ; "InvalidOperationException" ]),
+                    range0
+                ))
+                handler
+
+    /// Given `node.["town"]`, for example, choose how to obtain a JSON value from it.
+    /// The property name is used in error messages at runtime to show where a JSON
+    /// parse error occurred; supply `None` to indicate "don't validate".
+    let rec parseNode
+        (propertyName : SynExpr option)
+        (options : JsonParseOption)
+        (fieldType : SynType)
+        (node : SynExpr)
+        : SynExpr
+        =
+        // TODO: parsing format for DateTime etc
+        match fieldType with
+        | DateOnly ->
+            node
+            |> asValueGetValue propertyName "string"
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "DateOnly" ; "Parse" ])
+        | Uri ->
+            node
+            |> asValueGetValue propertyName "string"
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "Uri" ])
+        | Guid ->
+            node
+            |> asValueGetValue propertyName "string"
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "Guid" ; "Parse" ])
+        | DateTime ->
+            node
+            |> asValueGetValue propertyName "string"
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "DateTime" ; "Parse" ])
+        | DateTimeOffset ->
+            node
+            |> asValueGetValue propertyName "string"
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "DateTimeOffset" ; "Parse" ])
+        | NumberType typeName -> parseNumberType options propertyName node typeName
+        | PrimitiveType typeName -> asValueGetValueIdent propertyName typeName node
+        | OptionType ty ->
+            let someClause =
+                parseNode None options ty (SynExpr.createIdent "v")
+                |> SynExpr.pipeThroughFunction (SynExpr.createIdent "Some")
+                |> SynMatchClause.create (SynPat.named "v")
+
+            [
+                SynMatchClause.create SynPat.createNull (SynExpr.createIdent "None")
+                someClause
+            ]
+            |> SynExpr.createMatch node
+        | NullableType ty ->
+            let someClause =
+                parseNode None options ty (SynExpr.createIdent "v")
+                |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "System" ; "Nullable" ])
+                |> SynMatchClause.create (SynPat.named "v")
+
+            [
+                SynMatchClause.create
+                    SynPat.createNull
+                    (SynExpr.applyFunction (SynExpr.createLongIdent [ "System" ; "Nullable" ]) (SynExpr.CreateConst ()))
+                someClause
+            ]
+            |> SynExpr.createMatch node
+        | ListType ty ->
+            parseNode None options ty (SynExpr.createIdent "elt")
+            |> asArrayMapped propertyName "List" node
+        | ArrayType ty ->
+            parseNode None options ty (SynExpr.createIdent "elt")
+            |> asArrayMapped propertyName "Array" node
+        | IDictionaryType (keyType, valueType) ->
+            node
+            |> asObject propertyName
+            |> SynExpr.pipeThroughFunction (
+                SynExpr.applyFunction
+                    (SynExpr.createLongIdent [ "Seq" ; "map" ])
+                    (dictionaryMapper (parseKeyString keyType) (parseNode None options valueType))
+            )
+            |> SynExpr.pipeThroughFunction (SynExpr.createIdent "dict")
+        | DictionaryType (keyType, valueType) ->
+            node
+            |> asObject propertyName
+            |> SynExpr.pipeThroughFunction (
+                SynExpr.applyFunction
+                    (SynExpr.createLongIdent [ "Seq" ; "map" ])
+                    (dictionaryMapper (parseKeyString keyType) (parseNode None options valueType))
+            )
+            |> SynExpr.pipeThroughFunction (
+                SynExpr.applyFunction
+                    (SynExpr.createLongIdent [ "Seq" ; "map" ])
+                    (SynExpr.createLongIdent [ "System" ; "Collections" ; "Generic" ; "KeyValuePair" ])
+            )
+            |> SynExpr.pipeThroughFunction (
+                SynExpr.createLongIdent [ "System" ; "Collections" ; "Generic" ; "Dictionary" ]
+            )
+        | IReadOnlyDictionaryType (keyType, valueType) ->
+            node
+            |> asObject propertyName
+            |> SynExpr.pipeThroughFunction (
+                SynExpr.applyFunction
+                    (SynExpr.createLongIdent [ "Seq" ; "map" ])
+                    (dictionaryMapper (parseKeyString keyType) (parseNode None options valueType))
+            )
+            |> SynExpr.pipeThroughFunction (SynExpr.createIdent "readOnlyDict")
+        | MapType (keyType, valueType) ->
+            node
+            |> asObject propertyName
+            |> SynExpr.pipeThroughFunction (
+                SynExpr.applyFunction
+                    (SynExpr.createLongIdent [ "Seq" ; "map" ])
+                    (dictionaryMapper (parseKeyString keyType) (parseNode None options valueType))
+            )
+            |> SynExpr.pipeThroughFunction (SynExpr.createLongIdent [ "Map" ; "ofSeq" ])
+        | BigInt ->
+            node
+            |> SynExpr.callMethod "ToJsonString"
+            |> SynExpr.paren
+            |> SynExpr.applyFunction (SynExpr.createLongIdent [ "System" ; "Numerics" ; "BigInteger" ; "Parse" ])
+        | Measure (_measure, primType) ->
+            parseNumberType options propertyName node primType
+            |> SynExpr.pipeThroughFunction (Measure.getLanguagePrimitivesMeasure primType)
+        | JsonNode -> node
+        | UnitType -> SynExpr.CreateConst ()
+        | _ ->
+            // Let's just hope that we've also got our own type annotation!
+            let typeName =
+                match fieldType with
+                | SynType.LongIdent ident -> ident.LongIdent
+                | _ -> failwith $"Unrecognised type: %+A{fieldType}"
+
+            match propertyName with
+            | None -> node
+            | Some propertyName -> assertNotNull propertyName node
+            |> typeJsonParse typeName
+
+    /// propertyName is probably a string literal, but it could be a [<Literal>] variable
+    /// The result of this function is the body of a let-binding (not including the LHS of that let-binding).
+    let createParseRhs (options : JsonParseOption) (propertyName : SynExpr) (fieldType : SynType) : SynExpr =
+        let objectToParse = SynExpr.createIdent "node" |> SynExpr.index propertyName
+        parseNode (Some propertyName) options fieldType objectToParse
+
+    let isJsonNumberHandling (literal : LongIdent) : bool =
+        match List.rev literal |> List.map (fun ident -> ident.idText) with
+        | [ _ ; "JsonNumberHandling" ]
+        | [ _ ; "JsonNumberHandling" ; "Serialization" ]
+        | [ _ ; "JsonNumberHandling" ; "Serialization" ; "Json" ]
+        | [ _ ; "JsonNumberHandling" ; "Serialization" ; "Json" ; "Text" ]
+        | [ _ ; "JsonNumberHandling" ; "Serialization" ; "Json" ; "Text" ; "System" ] -> true
+        | _ -> false
+
+    /// `populateNode` will be inserted before we return the `node` variable.
+    ///
+    /// That is, we give you access to a `JsonNode` called `node`,
+    /// and you must return a `typeName`.
+    let scaffolding (spec : JsonParseOutputSpec) (typeName : LongIdent) (functionBody : SynExpr) : SynModuleDecl =
+        let xmlDoc = PreXmlDoc.create "Parse from a JSON node."
+
+        let returnInfo = SynType.createLongIdent typeName
+
+        let inputArg = "node"
+        let functionName = Ident.create "jsonParse"
+
+        let arg =
+            SynPat.named inputArg
+            |> SynPat.annotateType (SynType.createLongIdent' [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonNode" ])
+
+        if spec.ExtensionMethods then
+            let binding =
+                SynBinding.basic [ functionName ] [ arg ] functionBody
+                |> SynBinding.withXmlDoc xmlDoc
+                |> SynBinding.withReturnAnnotation returnInfo
+                |> SynMemberDefn.staticMember
+
+            let componentInfo =
+                SynComponentInfo.createLong typeName
+                |> SynComponentInfo.withDocString (PreXmlDoc.create "Extension methods for JSON parsing")
+
+            let containingType =
+                SynTypeDefnRepr.augmentation ()
+                |> SynTypeDefn.create componentInfo
+                |> SynTypeDefn.withMemberDefns [ binding ]
+
+            SynModuleDecl.Types ([ containingType ], range0)
+        else
+            SynBinding.basic [ functionName ] [ arg ] functionBody
+            |> SynBinding.withXmlDoc xmlDoc
+            |> SynBinding.withReturnAnnotation returnInfo
+            |> SynModuleDecl.createLet
+
+    let getParseOptions (fieldAttrs : SynAttribute list) =
+        (JsonParseOption.None, fieldAttrs)
+        ||> List.fold (fun options attr ->
+            if
+                (SynLongIdent.toString attr.TypeName)
+                    .EndsWith ("JsonNumberHandling", StringComparison.Ordinal)
+            then
+                let qualifiedEnumValue =
+                    match SynExpr.stripOptionalParen attr.ArgExpr with
+                    | SynExpr.LongIdent (_, SynLongIdent (ident, _, _), _, _) when isJsonNumberHandling ident ->
+                        // Make sure it's fully qualified
+                        SynExpr.createLongIdent
+                            [
+                                "System"
+                                "Text"
+                                "Json"
+                                "Serialization"
+                                "JsonNumberHandling"
+                                "AllowReadingFromString"
+                            ]
+                    | _ -> attr.ArgExpr
+
+                {
+                    JsonNumberHandlingArg = Some qualifiedEnumValue
+                }
+            else
+                options
+        )
+
+    let createRecordMaker (spec : JsonParseOutputSpec) (fields : SynFieldData<Ident> list) =
+        let propertyFields =
+            fields
+            |> List.map (fun fieldData ->
+                let propertyNameAttr =
+                    fieldData.Attrs
+                    |> List.tryFind (fun attr ->
+                        (SynLongIdent.toString attr.TypeName)
+                            .EndsWith ("JsonPropertyName", StringComparison.Ordinal)
+                    )
+
+                let extensionDataAttr =
+                    fieldData.Attrs
+                    |> List.tryFind (fun attr ->
+                        (SynLongIdent.toString attr.TypeName)
+                            .EndsWith ("JsonExtensionData", StringComparison.Ordinal)
+                    )
+
+                let propertyName =
+                    match propertyNameAttr with
+                    | None ->
+                        let sb = StringBuilder fieldData.Ident.idText.Length
+
+                        sb.Append (Char.ToLowerInvariant fieldData.Ident.idText.[0])
+                        |> ignore<StringBuilder>
+
+                        if fieldData.Ident.idText.Length > 1 then
+                            sb.Append (fieldData.Ident.idText.Substring 1) |> ignore<StringBuilder>
+
+                        sb.ToString () |> SynExpr.CreateConst
+                    | Some name -> name.ArgExpr
+
+                propertyName, extensionDataAttr
+            )
+
+        let namedPropertyFields =
+            propertyFields
+            |> List.choose (fun (name, extension) ->
+                match extension with
+                | Some _ -> None
+                | None -> Some name
+            )
+
+        let isNamedPropertyField =
+            match namedPropertyFields with
+            | [] -> SynExpr.CreateConst false
+            | _ ->
+                namedPropertyFields
+                |> List.map (fun fieldName -> SynExpr.equals (SynExpr.createIdent "key") fieldName)
+                |> List.reduce SynExpr.booleanOr
+
+        let assignments =
+            List.zip fields propertyFields
+            |> List.mapi (fun i (fieldData, (propertyName, extensionDataAttr)) ->
+                let options = getParseOptions fieldData.Attrs
+
+                let accIdent = Ident.create $"arg_%i{i}"
+
+                match extensionDataAttr with
+                | Some _ ->
+                    // Can't go through the usual parse logic here, because that will try and identify the node that's
+                    // been labelled. The whole point of JsonExtensionData is that there is no such node!
+                    let valType =
+                        match fieldData.Type with
+                        | DictionaryType (String, v) -> v
+                        | _ -> failwith "Expected JsonExtensionData to be Dictionary<string, _>"
+
+                    SynExpr.ifThenElse
+                        isNamedPropertyField
+                        (SynExpr.callMethodArg
+                            "Add"
+                            (SynExpr.tuple
+                                [
+                                    SynExpr.createIdent "key"
+                                    createParseRhs options (SynExpr.createIdent "key") valType
+                                ])
+                            (SynExpr.createIdent "result"))
+                        (SynExpr.CreateConst ())
+                    |> SynExpr.createForEach
+                        (SynPat.nameWithArgs "KeyValue" [ SynPat.named "key" ; SynPat.named "value" ])
+                        (SynExpr.createIdent "node")
+                    |> fun forEach -> [ forEach ; SynExpr.createIdent "result" ]
+                    |> SynExpr.sequential
+                    |> SynExpr.createLet
+                        [
+                            SynBinding.basic
+                                [ Ident.create "result" ]
+                                []
+                                (SynExpr.typeApp
+                                    [ SynType.string ; valType ]
+                                    (SynExpr.createLongIdent [ "System" ; "Collections" ; "Generic" ; "Dictionary" ])
+                                 |> SynExpr.applyTo (SynExpr.CreateConst ()))
+
+                            SynBinding.basic
+                                [ Ident.create "node" ]
+                                []
+                                (SynExpr.createIdent "node" |> SynExpr.callMethod "AsObject")
+                        ]
+                    |> SynBinding.basic [ accIdent ] []
+                | None ->
+
+                createParseRhs options propertyName fieldData.Type
+                |> SynBinding.basic [ accIdent ] []
+            )
+
+        let finalConstruction =
+            fields
+            |> List.mapi (fun i fieldData -> SynLongIdent.createI fieldData.Ident, SynExpr.createIdent $"arg_%i{i}")
+            |> AstHelper.instantiateRecord
+
+        (finalConstruction, assignments)
+        ||> List.fold (fun final assignment -> SynExpr.createLet [ assignment ] final)
+
+    let createUnionMaker (spec : JsonParseOutputSpec) (typeName : LongIdent) (fields : UnionCase<Ident> list) =
+        fields
+        |> List.map (fun case ->
+            let propertyName = JsonSerializeGenerator.getPropertyName case.Name case.Attributes
+
+            let body =
+                if case.Fields.IsEmpty then
+                    SynExpr.createLongIdent' (typeName @ [ case.Name ])
+                else
+                    case.Fields
+                    |> List.map (fun field ->
+                        let propertyName = JsonSerializeGenerator.getPropertyName field.Ident field.Attrs
+                        let options = getParseOptions field.Attrs
+                        createParseRhs options propertyName field.Type
+                    )
+                    |> SynExpr.tuple
+                    |> SynExpr.applyFunction (SynExpr.createLongIdent' (typeName @ [ case.Name ]))
+                    |> SynExpr.createLet
+                        [
+                            SynExpr.index (SynExpr.CreateConst "data") (SynExpr.createIdent "node")
+                            |> assertNotNull (SynExpr.CreateConst "data")
+                            |> SynBinding.basic [ Ident.create "node" ] []
+                        ]
+
+            match propertyName with
+            | SynExpr.Const (synConst, _) ->
+                SynMatchClause.SynMatchClause (
+                    SynPat.createConst synConst,
+                    None,
+                    body,
+                    range0,
+                    DebugPointAtTarget.Yes,
+                    {
+                        ArrowRange = Some range0
+                        BarRange = Some range0
+                    }
+                )
+            | _ ->
+                SynMatchClause.create (SynPat.named "x") body
+                |> SynMatchClause.withWhere (SynExpr.equals (SynExpr.createIdent "x") propertyName)
+        )
+        |> fun l ->
+            l
+            @ [
+                let fail =
+                    SynExpr.plus (SynExpr.CreateConst "Unrecognised 'type' field value: ") (SynExpr.createIdent "v")
+                    |> SynExpr.paren
+                    |> SynExpr.applyFunction (SynExpr.createIdent "failwith")
+
+                SynMatchClause.SynMatchClause (
+                    SynPat.named "v",
+                    None,
+                    fail,
+                    range0,
+                    DebugPointAtTarget.Yes,
+                    {
+                        ArrowRange = Some range0
+                        BarRange = Some range0
+                    }
+                )
+            ]
+        |> SynExpr.createMatch (SynExpr.createIdent "ty")
+        |> SynExpr.createLet
+            [
+                let property = SynExpr.CreateConst "type"
+
+                SynExpr.createIdent "node"
+                |> SynExpr.index property
+                |> assertNotNull property
+                |> SynExpr.pipeThroughFunction (
+                    SynExpr.createLambda "v" (SynExpr.callGenericMethod' "GetValue" "string" (SynExpr.createIdent "v"))
+                )
+                |> SynBinding.basic [ Ident.create "ty" ] []
+            ]
+
+    let createEnumMaker
+        (spec : JsonParseOutputSpec)
+        (typeName : LongIdent)
+        (fields : (Ident * SynExpr) list)
+        : SynExpr
+        =
+        let numberKind =
+            [ "System" ; "Text" ; "Json" ; "JsonValueKind" ; "Number" ]
+            |> List.map Ident.create
+
+        let stringKind =
+            [ "System" ; "Text" ; "Json" ; "JsonValueKind" ; "String" ]
+            |> List.map Ident.create
+
+        let fail =
+            SynExpr.plus
+                (SynExpr.CreateConst "Unrecognised kind for enum of type: ")
+                (SynExpr.CreateConst (typeName |> List.map _.idText |> String.concat "."))
+            |> SynExpr.paren
+            |> SynExpr.applyFunction (SynExpr.createIdent "failwith")
+
+        let failString =
+            SynExpr.plus (SynExpr.CreateConst "Unrecognised value for enum: %i") (SynExpr.createIdent "v")
+            |> SynExpr.paren
+            |> SynExpr.applyFunction (SynExpr.createIdent "failwith")
+
+        let parseString =
+            fields
+            |> List.map (fun (ident, _) ->
+                SynMatchClause.create
+                    (SynPat.createConst (
+                        SynConst.String (ident.idText.ToLowerInvariant (), SynStringKind.Regular, range0)
+                    ))
+                    (SynExpr.createLongIdent' (typeName @ [ ident ]))
+            )
+            |> fun l -> l @ [ SynMatchClause.create (SynPat.named "v") failString ]
+            |> SynExpr.createMatch (
+                asValueGetValue None "string" (SynExpr.createIdent "node")
+                |> SynExpr.callMethod "ToLowerInvariant"
+            )
+
+        [
+            SynMatchClause.create
+                (SynPat.identWithArgs numberKind (SynArgPats.create []))
+                (asValueGetValue None "int" (SynExpr.createIdent "node")
+                 |> SynExpr.pipeThroughFunction (
+                     SynExpr.typeApp [ SynType.createLongIdent typeName ] (SynExpr.createIdent "enum")
+                 ))
+            SynMatchClause.create (SynPat.identWithArgs stringKind (SynArgPats.create [])) parseString
+            SynMatchClause.create (SynPat.named "_") fail
+        ]
+        |> SynExpr.createMatch (SynExpr.callMethod "GetValueKind" (SynExpr.createIdent "node"))
+
+    let createModule (namespaceId : LongIdent) (spec : JsonParseOutputSpec) (typeDefn : SynTypeDefn) =
+        let (SynTypeDefn (synComponentInfo, synTypeDefnRepr, _members, _implicitCtor, _, _)) =
+            typeDefn
+
+        let (SynComponentInfo (_attributes, _typeParams, _constraints, ident, _, _preferPostfix, access, _)) =
+            synComponentInfo
+
+        let attributes =
+            if spec.ExtensionMethods then
+                [ SynAttribute.autoOpen ]
+            else
+                [ SynAttribute.requireQualifiedAccess ; SynAttribute.compilationRepresentation ]
+
+        let xmlDoc =
+            let fullyQualified = ident |> Seq.map (fun i -> i.idText) |> String.concat "."
+
+            let description =
+                if spec.ExtensionMethods then
+                    "extension members"
+                else
+                    "methods"
+
+            $"Module containing JSON parsing %s{description} for the %s{fullyQualified} type"
+            |> PreXmlDoc.create
+
+        let moduleName =
+            if spec.ExtensionMethods then
+                match ident with
+                | [] -> failwith "unexpectedly got an empty identifier for record name"
+                | ident ->
+                    let expanded =
+                        List.last ident
+                        |> fun i -> i.idText
+                        |> fun s -> s + "JsonParseExtension"
+                        |> Ident.create
+
+                    List.take (List.length ident - 1) ident @ [ expanded ]
+            else
+                ident
+
+        let info =
+            SynComponentInfo.createLong moduleName
+            |> SynComponentInfo.withDocString xmlDoc
+            |> SynComponentInfo.setAccessibility access
+            |> SynComponentInfo.addAttributes attributes
+
+        let decl =
+            match synTypeDefnRepr with
+            | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Record (_accessibility, fields, _range), _) ->
+                fields |> List.map SynField.extractWithIdent |> createRecordMaker spec
+            | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Union (_accessibility, cases, _range), _) ->
+                let optionGet (i : Ident option) =
+                    match i with
+                    | None ->
+                        failwith "WoofWare.Whippet.Plugin.Json requires union cases to have identifiers on each field."
+                    | Some i -> i
+
+                cases
+                |> List.map UnionCase.ofSynUnionCase
+                |> List.map (UnionCase.mapIdentFields optionGet)
+                |> createUnionMaker spec ident
+            | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Enum (cases, _range), _) ->
+                cases
+                |> List.map (fun c ->
+                    match c with
+                    | SynEnumCase.SynEnumCase (_, SynIdent.SynIdent (ident, _), value, _, _, _) -> ident, value
+                )
+                |> createEnumMaker spec ident
+            | _ -> failwithf "Not a record or union type"
+
+        [ scaffolding spec ident decl ]
+        |> SynModuleDecl.nestedModule info
+        |> List.singleton
+        |> SynModuleOrNamespace.createNamespace namespaceId
+
+/// Whippet generator that provides a method (possibly an extension method) for a record type,
+/// containing a JSON parse function.
+[<WhippetGenerator>]
+type JsonParseGenerator () =
+
+    interface IGenerateRawFromRaw with
+        member _.GenerateRawFromRaw (context : RawSourceGenerationArgs) =
+            if not (context.FilePath.EndsWith (".fs", StringComparison.Ordinal)) then
+                null
+            else
+
+            let targetedTypes =
+                context.Parameters
+                |> Seq.map (fun (KeyValue (k, v)) -> k, v.Split '!' |> Array.toList |> List.map DesiredGenerator.Parse)
+                |> Map.ofSeq
+
+            let ast = Ast.parse (Encoding.UTF8.GetString context.FileContents)
+
+            let relevantTypes =
+                Ast.getTypes ast
+                |> List.map (fun (name, defns) ->
+                    defns
+                    |> List.choose (fun defn ->
+                        if SynTypeDefn.isRecord defn then Some defn
+                        elif SynTypeDefn.isDu defn then Some defn
+                        elif SynTypeDefn.isEnum defn then Some defn
+                        else None
+                    )
+                    |> fun defns -> name, defns
+                )
+
+            let namespaceAndTypes =
+                relevantTypes
+                |> List.choose (fun (ns, types) ->
+                    types
+                    |> List.choose (fun typeDef ->
+                        match SynTypeDefn.getAttribute typeof<JsonParseAttribute>.Name typeDef with
+                        | None ->
+                            let name = SynTypeDefn.getName typeDef |> List.map _.idText |> String.concat "."
+
+                            match Map.tryFind name targetedTypes with
+                            | Some desired ->
+                                desired
+                                |> List.tryPick (fun generator ->
+                                    match generator with
+                                    | DesiredGenerator.JsonParse arg ->
+                                        let spec =
+                                            {
+                                                ExtensionMethods =
+                                                    arg
+                                                    |> Option.defaultValue
+                                                        JsonParseAttribute.DefaultIsExtensionMethod
+                                            }
+
+                                        Some (typeDef, spec)
+                                    | _ -> None
+                                )
+                            | _ -> None
+
+                        | Some attr ->
+                            let arg =
+                                match SynExpr.stripOptionalParen attr.ArgExpr with
+                                | SynExpr.Const (SynConst.Bool value, _) -> value
+                                | SynExpr.Const (SynConst.Unit, _) -> JsonParseAttribute.DefaultIsExtensionMethod
+                                | arg ->
+                                    failwith
+                                        $"Unrecognised argument %+A{arg} to [<%s{nameof JsonParseAttribute}>]. Literals are not supported. Use `true` or `false` (or unit) only."
+
+                            let spec =
+                                {
+                                    ExtensionMethods = arg
+                                }
+
+                            Some (typeDef, spec)
+                    )
+                    |> function
+                        | [] -> None
+                        | ty -> Some (ns, ty)
+                )
+
+            let modules =
+                namespaceAndTypes
+                |> List.collect (fun (ns, types) ->
+                    types |> List.map (fun (ty, spec) -> JsonParseGenerator.createModule ns spec ty)
+                )
+
+            Ast.render modules |> Option.toObj

Plugins/Json/WoofWare.Whippet.Plugin.Json/JsonSerializeGenerator.fs

@@ -0,0 +1,602 @@
+namespace WoofWare.Whippet.Plugin.Json
+
+open System
+open System.Text
+open Fantomas.FCS.Syntax
+open WoofWare.Whippet.Core
+open WoofWare.Whippet.Fantomas
+
+type internal JsonSerializeOutputSpec =
+    {
+        ExtensionMethods : bool
+    }
+
+[<RequireQualifiedAccess>]
+module internal JsonSerializeGenerator =
+    open Fantomas.FCS.Text.Range
+
+
+    // The absolutely galaxy-brained implementation of JsonValue has `JsonValue.Parse "null"`
+    // identically equal to null. We have to work around this later, but we might as well just
+    // be efficient here and whip up the null directly.
+    let private jsonNull () =
+        SynExpr.createNull ()
+        |> SynExpr.upcast' (SynType.createLongIdent' [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonNode" ])
+
+    /// Given `input.Ident`, for example, choose how to add it to the ambient `node`.
+    /// The result is a line like `(fun ident -> InnerType.toJsonNode ident)` or `(fun ident -> JsonValue.Create ident)`.
+    /// Returns also a bool which is true if the resulting SynExpr represents something of type JsonNode.
+    let rec serializeNode (fieldType : SynType) : SynExpr * bool =
+        // TODO: serialization format for DateTime etc
+        match fieldType with
+        | DateOnly
+        | DateTime
+        | NumberType _
+        | Measure _
+        | PrimitiveType _
+        | Guid
+        | Uri ->
+            // JsonValue.Create<type>
+            SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonValue" ; "Create" ]
+            |> SynExpr.typeApp [ fieldType ]
+            |> fun e -> e, false
+        | DateTimeOffset ->
+            // fun field -> field.ToString("o") |> JsonValue.Create<string>
+            let create =
+                SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonValue" ; "Create" ]
+                |> SynExpr.typeApp [ SynType.named "string" ]
+
+            SynExpr.createIdent "field"
+            |> SynExpr.callMethodArg "ToString" (SynExpr.CreateConst "o")
+            |> SynExpr.pipeThroughFunction create
+            |> SynExpr.createLambda "field"
+            |> fun e -> e, false
+        | NullableType ty ->
+            // fun field -> if field.HasValue then {serializeNode ty} field.Value else JsonValue.Create null
+            let inner, innerIsJsonNode = serializeNode ty
+
+            SynExpr.applyFunction inner (SynExpr.createLongIdent [ "field" ; "Value" ])
+            |> SynExpr.upcast' (SynType.createLongIdent' [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonNode" ])
+            |> SynExpr.ifThenElse (SynExpr.createLongIdent [ "field" ; "HasValue" ]) (jsonNull ())
+            |> SynExpr.createLambda "field"
+            |> fun e -> e, innerIsJsonNode
+        | OptionType ty ->
+            // fun field -> match field with | None -> JsonValue.Create null | Some v -> {serializeNode ty} field
+            let noneClause = jsonNull () |> SynMatchClause.create (SynPat.named "None")
+
+            let someClause =
+                let inner, innerIsJsonNode = serializeNode ty
+                let target = SynExpr.applyFunction inner (SynExpr.createIdent "field")
+
+                if innerIsJsonNode then
+                    target
+                else
+                    target
+                    |> SynExpr.paren
+                    |> SynExpr.upcast' (SynType.createLongIdent' [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonNode" ])
+                |> SynMatchClause.create (SynPat.nameWithArgs "Some" [ SynPat.named "field" ])
+
+            [ noneClause ; someClause ]
+            |> SynExpr.createMatch (SynExpr.createIdent "field")
+            |> SynExpr.createLambda "field"
+            |> fun e -> e, true
+        | ArrayType ty
+        | ListType ty ->
+            // fun field ->
+            //     let arr = JsonArray ()
+            //     for mem in field do arr.Add ({serializeNode} mem)
+            //     arr
+            [
+                SynExpr.ForEach (
+                    DebugPointAtFor.Yes range0,
+                    DebugPointAtInOrTo.Yes range0,
+                    SeqExprOnly.SeqExprOnly false,
+                    true,
+                    SynPat.named "mem",
+                    SynExpr.createIdent "field",
+                    SynExpr.applyFunction
+                        (SynExpr.createLongIdent [ "arr" ; "Add" ])
+                        (SynExpr.paren (SynExpr.applyFunction (fst (serializeNode ty)) (SynExpr.createIdent "mem"))),
+                    range0
+                )
+                SynExpr.createIdent "arr"
+            ]
+            |> SynExpr.sequential
+            |> SynExpr.createLet
+                [
+                    SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonArray" ]
+                    |> SynExpr.applyTo (SynExpr.CreateConst ())
+                    |> SynBinding.basic [ Ident.create "arr" ] []
+                ]
+            |> SynExpr.createLambda "field"
+            |> fun e -> e, false
+        | IDictionaryType (_keyType, valueType)
+        | DictionaryType (_keyType, valueType)
+        | IReadOnlyDictionaryType (_keyType, valueType)
+        | MapType (_keyType, valueType) ->
+            // fun field ->
+            //    let ret = JsonObject ()
+            //    for (KeyValue(key, value)) in field do
+            //        ret.Add (key.ToString (), {serializeNode} value)
+            //    ret
+            [
+                SynExpr.ForEach (
+                    DebugPointAtFor.Yes range0,
+                    DebugPointAtInOrTo.Yes range0,
+                    SeqExprOnly.SeqExprOnly false,
+                    true,
+                    SynPat.paren (SynPat.nameWithArgs "KeyValue" [ SynPat.named "key" ; SynPat.named "value" ]),
+                    SynExpr.createIdent "field",
+                    SynExpr.applyFunction
+                        (SynExpr.createLongIdent [ "ret" ; "Add" ])
+                        (SynExpr.tuple
+                            [
+                                SynExpr.createLongIdent [ "key" ; "ToString" ]
+                                |> SynExpr.applyTo (SynExpr.CreateConst ())
+                                SynExpr.applyFunction (fst (serializeNode valueType)) (SynExpr.createIdent "value")
+                            ]),
+                    range0
+                )
+                SynExpr.createIdent "ret"
+            ]
+            |> SynExpr.sequential
+            |> SynExpr.createLet
+                [
+                    SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonObject" ]
+                    |> SynExpr.applyTo (SynExpr.CreateConst ())
+                    |> SynBinding.basic [ Ident.create "ret" ] []
+                ]
+            |> SynExpr.createLambda "field"
+            |> fun e -> e, false
+        | JsonNode -> SynExpr.createIdent "id", true
+        | UnitType ->
+            SynExpr.createLambda
+                "value"
+                (SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonObject" ]
+                 |> SynExpr.applyTo (SynExpr.CreateConst ())),
+            false
+        | _ ->
+            // {type}.toJsonNode
+            let typeName =
+                match fieldType with
+                | SynType.LongIdent ident -> ident.LongIdent
+                | _ -> failwith $"Unrecognised type: %+A{fieldType}"
+
+            SynExpr.createLongIdent' (typeName @ [ Ident.create "toJsonNode" ]), true
+
+    /// propertyName is probably a string literal, but it could be a [<Literal>] variable
+    /// `node.Add ({propertyName}, {toJsonNode})`
+    let createSerializeRhsRecord (propertyName : SynExpr) (fieldId : Ident) (fieldType : SynType) : SynExpr =
+        [
+            propertyName
+            SynExpr.pipeThroughFunction
+                (fst (serializeNode fieldType))
+                (SynExpr.createLongIdent' [ Ident.create "input" ; fieldId ])
+            |> SynExpr.paren
+        ]
+        |> SynExpr.tuple
+        |> SynExpr.applyFunction (SynExpr.createLongIdent [ "node" ; "Add" ])
+
+    let getPropertyName (fieldId : Ident) (attrs : SynAttribute list) : SynExpr =
+        let propertyNameAttr =
+            attrs
+            |> List.tryFind (fun attr ->
+                (SynLongIdent.toString attr.TypeName)
+                    .EndsWith ("JsonPropertyName", StringComparison.Ordinal)
+            )
+
+        match propertyNameAttr with
+        | None ->
+            let sb = StringBuilder fieldId.idText.Length
+            sb.Append (Char.ToLowerInvariant fieldId.idText.[0]) |> ignore
+
+            if fieldId.idText.Length > 1 then
+                sb.Append fieldId.idText.[1..] |> ignore
+
+            sb.ToString () |> SynExpr.CreateConst
+        | Some name -> name.ArgExpr
+
+    let getIsJsonExtension (attrs : SynAttribute list) : bool =
+        attrs
+        |> List.tryFind (fun attr ->
+            (SynLongIdent.toString attr.TypeName)
+                .EndsWith ("JsonExtensionData", StringComparison.Ordinal)
+        )
+        |> Option.isSome
+
+    /// `populateNode` will be inserted before we return the `node` variable.
+    ///
+    /// That is, we give you access to a `JsonObject` called `node`,
+    /// and you have access to a variable `inputArgName` which is of type `typeName`.
+    /// Your job is to provide a `populateNode` expression which has the side effect
+    /// of mutating `node` to faithfully reflect the value of `inputArgName`.
+    let scaffolding
+        (spec : JsonSerializeOutputSpec)
+        (typeName : LongIdent)
+        (inputArgName : Ident)
+        (populateNode : SynExpr)
+        : SynModuleDecl
+        =
+        let xmlDoc = PreXmlDoc.create "Serialize to a JSON node"
+
+        let returnInfo =
+            SynLongIdent.createS' [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonNode" ]
+            |> SynType.LongIdent
+
+        let functionName = Ident.create "toJsonNode"
+
+        let assignments =
+            [
+                populateNode
+                SynExpr.Upcast (SynExpr.createIdent "node", SynType.Anon range0, range0)
+            ]
+            |> SynExpr.sequential
+            |> SynExpr.createLet
+                [
+                    SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonObject" ]
+                    |> SynExpr.applyTo (SynExpr.CreateConst ())
+                    |> SynBinding.basic [ Ident.create "node" ] []
+                ]
+
+        let pattern =
+            SynPat.namedI inputArgName
+            |> SynPat.annotateType (SynType.LongIdent (SynLongIdent.create typeName))
+
+        if spec.ExtensionMethods then
+            let componentInfo =
+                SynComponentInfo.createLong typeName
+                |> SynComponentInfo.withDocString (PreXmlDoc.create "Extension methods for JSON parsing")
+
+            let memberDef =
+                assignments
+                |> SynBinding.basic [ functionName ] [ pattern ]
+                |> SynBinding.withXmlDoc xmlDoc
+                |> SynBinding.withReturnAnnotation returnInfo
+                |> SynMemberDefn.staticMember
+
+            let containingType =
+                SynTypeDefnRepr.augmentation ()
+                |> SynTypeDefn.create componentInfo
+                |> SynTypeDefn.withMemberDefns [ memberDef ]
+
+            SynModuleDecl.Types ([ containingType ], range0)
+        else
+            assignments
+            |> SynBinding.basic [ functionName ] [ pattern ]
+            |> SynBinding.withReturnAnnotation returnInfo
+            |> SynBinding.withXmlDoc xmlDoc
+            |> SynModuleDecl.createLet
+
+    let recordModule (spec : JsonSerializeOutputSpec) (_typeName : LongIdent) (fields : SynField list) =
+        let fields = fields |> List.map SynField.extractWithIdent
+
+        fields
+        |> List.map (fun fieldData ->
+            let propertyName = getPropertyName fieldData.Ident fieldData.Attrs
+            let isJsonExtension = getIsJsonExtension fieldData.Attrs
+
+            if isJsonExtension then
+                let valType =
+                    match fieldData.Type with
+                    | DictionaryType (String, v) -> v
+                    | _ -> failwith "Expected JsonExtensionData to be a Dictionary<string, something>"
+
+                let serialise = fst (serializeNode valType)
+
+                SynExpr.createIdent "node"
+                |> SynExpr.callMethodArg
+                    "Add"
+                    (SynExpr.tuple
+                        [
+                            SynExpr.createIdent "key"
+                            SynExpr.applyFunction serialise (SynExpr.createIdent "value")
+                        ])
+                |> SynExpr.createForEach
+                    (SynPat.identWithArgs
+                        [ Ident.create "KeyValue" ]
+                        (SynArgPats.create [ SynPat.named "key" ; SynPat.named "value" ]))
+                    (SynExpr.createLongIdent' [ Ident.create "input" ; fieldData.Ident ])
+            else
+                createSerializeRhsRecord propertyName fieldData.Ident fieldData.Type
+        )
+        |> SynExpr.sequential
+        |> fun expr -> SynExpr.Do (expr, range0)
+
+    let unionModule (spec : JsonSerializeOutputSpec) (typeName : LongIdent) (cases : SynUnionCase list) =
+        let inputArg = Ident.create "input"
+        let fields = cases |> List.map UnionCase.ofSynUnionCase
+
+        fields
+        |> List.map (fun unionCase ->
+            let propertyName = getPropertyName unionCase.Name unionCase.Attributes
+
+            let caseNames = unionCase.Fields |> List.mapi (fun i _ -> $"arg%i{i}")
+
+            let argPats = SynArgPats.createNamed caseNames
+
+            let pattern =
+                SynPat.LongIdent (
+                    SynLongIdent.create (typeName @ [ unionCase.Name ]),
+                    None,
+                    None,
+                    argPats,
+                    None,
+                    range0
+                )
+
+            let typeLine =
+                [
+                    SynExpr.CreateConst "type"
+                    SynExpr.applyFunction
+                        (SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonValue" ; "Create" ])
+                        propertyName
+                ]
+                |> SynExpr.tuple
+                |> SynExpr.applyFunction (SynExpr.createLongIdent [ "node" ; "Add" ])
+
+            let dataNode =
+                SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonObject" ]
+                |> SynExpr.applyTo (SynExpr.CreateConst ())
+                |> SynBinding.basic [ Ident.create "dataNode" ] []
+
+            let dataBindings =
+                (unionCase.Fields, caseNames)
+                ||> List.zip
+                |> List.map (fun (fieldData, caseName) ->
+                    let propertyName = getPropertyName (Option.get fieldData.Ident) fieldData.Attrs
+
+                    let node =
+                        SynExpr.applyFunction (fst (serializeNode fieldData.Type)) (SynExpr.createIdent caseName)
+
+                    [ propertyName ; node ]
+                    |> SynExpr.tuple
+                    |> SynExpr.applyFunction (SynExpr.createLongIdent [ "dataNode" ; "Add" ])
+                )
+
+            let assignToNode =
+                [ SynExpr.CreateConst "data" ; SynExpr.createIdent "dataNode" ]
+                |> SynExpr.tuple
+                |> SynExpr.applyFunction (SynExpr.createLongIdent [ "node" ; "Add" ])
+
+            let dataNode =
+                SynExpr.sequential (dataBindings @ [ assignToNode ])
+                |> SynExpr.createLet [ dataNode ]
+
+            let action =
+                [
+                    yield typeLine
+                    if not dataBindings.IsEmpty then
+                        yield dataNode
+                ]
+                |> SynExpr.sequential
+
+            SynMatchClause.create pattern action
+        )
+        |> SynExpr.createMatch (SynExpr.createIdent' inputArg)
+
+    let enumModule
+        (spec : JsonSerializeOutputSpec)
+        (typeName : LongIdent)
+        (cases : (Ident * SynExpr) list)
+        : SynModuleDecl
+        =
+        let fail =
+            SynExpr.CreateConst "Unrecognised value for enum: %O"
+            |> SynExpr.applyFunction (SynExpr.createIdent "sprintf")
+            |> SynExpr.applyTo (SynExpr.createIdent "v")
+            |> SynExpr.paren
+            |> SynExpr.applyFunction (SynExpr.createIdent "failwith")
+
+        let body =
+            cases
+            |> List.map (fun (caseName, value) ->
+                value
+                |> SynExpr.applyFunction (
+                    SynExpr.createLongIdent [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonValue" ; "Create" ]
+                )
+                |> SynMatchClause.create (SynPat.identWithArgs (typeName @ [ caseName ]) (SynArgPats.create []))
+            )
+            |> fun l -> l @ [ SynMatchClause.create (SynPat.named "v") fail ]
+            |> SynExpr.createMatch (SynExpr.createIdent "input")
+
+        let xmlDoc = PreXmlDoc.create "Serialize to a JSON node"
+
+        let returnInfo =
+            SynLongIdent.createS' [ "System" ; "Text" ; "Json" ; "Nodes" ; "JsonNode" ]
+            |> SynType.LongIdent
+
+        let functionName = Ident.create "toJsonNode"
+
+        let pattern =
+            SynPat.named "input"
+            |> SynPat.annotateType (SynType.LongIdent (SynLongIdent.create typeName))
+
+        if spec.ExtensionMethods then
+            let componentInfo =
+                SynComponentInfo.createLong typeName
+                |> SynComponentInfo.withDocString (PreXmlDoc.create "Extension methods for JSON parsing")
+
+            let memberDef =
+                body
+                |> SynBinding.basic [ functionName ] [ pattern ]
+                |> SynBinding.withXmlDoc xmlDoc
+                |> SynBinding.withReturnAnnotation returnInfo
+                |> SynMemberDefn.staticMember
+
+            let containingType =
+                SynTypeDefnRepr.augmentation ()
+                |> SynTypeDefn.create componentInfo
+                |> SynTypeDefn.withMemberDefns [ memberDef ]
+
+            SynModuleDecl.Types ([ containingType ], range0)
+        else
+            body
+            |> SynBinding.basic [ functionName ] [ pattern ]
+            |> SynBinding.withReturnAnnotation returnInfo
+            |> SynBinding.withXmlDoc xmlDoc
+            |> SynModuleDecl.createLet
+
+    let createModule
+        (namespaceId : LongIdent)
+        (opens : SynOpenDeclTarget list)
+        (spec : JsonSerializeOutputSpec)
+        (typeDefn : SynTypeDefn)
+        =
+        let (SynTypeDefn (synComponentInfo, synTypeDefnRepr, _members, _implicitCtor, _, _)) =
+            typeDefn
+
+        let (SynComponentInfo (_attributes, _typeParams, _constraints, ident, _, _preferPostfix, access, _)) =
+            synComponentInfo
+
+        let attributes =
+            if spec.ExtensionMethods then
+                [ SynAttribute.autoOpen ]
+            else
+                [ SynAttribute.requireQualifiedAccess ; SynAttribute.compilationRepresentation ]
+
+        let xmlDoc =
+            let fullyQualified = ident |> Seq.map (fun i -> i.idText) |> String.concat "."
+
+            let description =
+                if spec.ExtensionMethods then
+                    "extension members"
+                else
+                    "methods"
+
+            $"Module containing JSON serializing %s{description} for the %s{fullyQualified} type"
+            |> PreXmlDoc.create
+
+        let moduleName =
+            if spec.ExtensionMethods then
+                match ident with
+                | [] -> failwith "unexpectedly got an empty identifier for type name"
+                | ident ->
+                    let expanded =
+                        List.last ident
+                        |> fun i -> i.idText
+                        |> fun s -> s + "JsonSerializeExtension"
+                        |> Ident.create
+
+                    List.take (List.length ident - 1) ident @ [ expanded ]
+            else
+                ident
+
+        let info =
+            SynComponentInfo.createLong moduleName
+            |> SynComponentInfo.addAttributes attributes
+            |> SynComponentInfo.setAccessibility access
+            |> SynComponentInfo.withDocString xmlDoc
+
+        let decls =
+            match synTypeDefnRepr with
+            | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Record (_accessibility, recordFields, _range), _) ->
+                recordModule spec ident recordFields
+                |> scaffolding spec ident (Ident.create "input")
+            | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Union (_accessibility, unionFields, _range), _) ->
+                unionModule spec ident unionFields
+                |> scaffolding spec ident (Ident.create "input")
+            | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Enum (cases, _range), _) ->
+                cases
+                |> List.map (fun c ->
+                    match c with
+                    | SynEnumCase.SynEnumCase (_, SynIdent.SynIdent (ident, _), value, _, _, _) -> ident, value
+                )
+                |> enumModule spec ident
+            | ty -> failwithf "Unsupported type: got %O" ty
+
+        [
+            yield! opens |> List.map SynModuleDecl.openAny
+            yield decls |> List.singleton |> SynModuleDecl.nestedModule info
+        ]
+        |> SynModuleOrNamespace.createNamespace namespaceId
+
+/// Whippet generator that provides a method (possibly an extension method) for a record type,
+/// containing a JSON serialization function.
+[<WhippetGenerator>]
+type JsonSerializeGenerator () =
+
+    interface IGenerateRawFromRaw with
+        member _.GenerateRawFromRaw (context : RawSourceGenerationArgs) =
+            if not (context.FilePath.EndsWith (".fs", StringComparison.Ordinal)) then
+                null
+            else
+
+            let targetedTypes =
+                context.Parameters
+                |> Seq.map (fun (KeyValue (k, v)) -> k, v.Split '!' |> Array.toList |> List.map DesiredGenerator.Parse)
+                |> Map.ofSeq
+
+            let ast = Ast.parse (Encoding.UTF8.GetString context.FileContents)
+
+            let relevantTypes =
+                Ast.getTypes ast
+                |> List.map (fun (name, defns) ->
+                    defns
+                    |> List.choose (fun defn ->
+                        if SynTypeDefn.isRecord defn then Some defn
+                        elif SynTypeDefn.isDu defn then Some defn
+                        elif SynTypeDefn.isEnum defn then Some defn
+                        else None
+                    )
+                    |> fun defns -> name, defns
+                )
+
+            let namespaceAndTypes =
+                relevantTypes
+                |> List.choose (fun (ns, types) ->
+                    types
+                    |> List.choose (fun typeDef ->
+                        match SynTypeDefn.getAttribute typeof<JsonSerializeAttribute>.Name typeDef with
+                        | None ->
+                            let name = SynTypeDefn.getName typeDef |> List.map _.idText |> String.concat "."
+
+                            match Map.tryFind name targetedTypes with
+                            | Some desired ->
+                                desired
+                                |> List.tryPick (fun generator ->
+                                    match generator with
+                                    | DesiredGenerator.JsonSerialize arg ->
+                                        let spec =
+                                            {
+                                                ExtensionMethods =
+                                                    arg
+                                                    |> Option.defaultValue
+                                                        JsonSerializeAttribute.DefaultIsExtensionMethod
+                                            }
+
+                                        Some (typeDef, spec)
+                                    | _ -> None
+                                )
+                            | _ -> None
+
+                        | Some attr ->
+                            let arg =
+                                match SynExpr.stripOptionalParen attr.ArgExpr with
+                                | SynExpr.Const (SynConst.Bool value, _) -> value
+                                | SynExpr.Const (SynConst.Unit, _) -> JsonSerializeAttribute.DefaultIsExtensionMethod
+                                | arg ->
+                                    failwith
+                                        $"Unrecognised argument %+A{arg} to [<%s{nameof JsonSerializeAttribute}>]. Literals are not supported. Use `true` or `false` (or unit) only."
+
+                            let spec =
+                                {
+                                    ExtensionMethods = arg
+                                }
+
+                            Some (typeDef, spec)
+                    )
+                    |> function
+                        | [] -> None
+                        | ty -> Some (ns, ty)
+                )
+
+            let opens = AstHelper.extractOpens ast
+
+            let modules =
+                namespaceAndTypes
+                |> List.collect (fun (ns, types) ->
+                    types
+                    |> List.map (fun (ty, spec) -> JsonSerializeGenerator.createModule ns opens spec ty)
+                )
+
+            Ast.render modules |> Option.toObj

Plugins/Json/WoofWare.Whippet.Plugin.Json/README.md

@@ -0,0 +1,223 @@
+# WoofWare.Whippet.Plugin.Json
+
+This is a [Whippet](https://github.com/Smaug123/WoofWare.Whippet) plugin defining JSON parse and serialise methods.
+
+It is a copy of the corresponding [Myriad](https://github.com/MoiraeSoftware/myriad) JSON plugin in [WoofWare.Myriad](https://github.com/Smaug123/WoofWare.Myriad), taken from commit d59ebdfccb87a06579fb99008a15f58ea8be394e.
+
+## What's the point?
+
+`System.Text.Json`, in a `PublishAot` context, relies on C# source generators.
+The default reflection-heavy implementations have the necessary code trimmed away, and result in a runtime exception.
+But C# source generators [are entirely unsupported in F#](https://github.com/dotnet/fsharp/issues/14300).
+
+These generators handle going from your strongly-typed domain objects to `System.Text.Json.Nodes.JsonNode`, and back.
+
+## Usage: `JsonParse`
+
+Define a `Dto.fs` file like the following:
+
+```fsharp
+namespace MyNamespace
+
+open WoofWare.Whippet.Plugin.Json
+
+[<JsonParse>]
+type InnerType =
+    {
+        [<JsonPropertyName "something">]
+        Thing : string
+    }
+
+/// My whatnot
+[<JsonParse (* isExtensionMethod = *) false>]
+type JsonRecordType =
+    {
+        /// A thing!
+        A : int
+        /// Another thing!
+        B : string
+        [<System.Text.Json.Serialization.JsonPropertyName "hi">]
+        C : int list
+        D : InnerType
+    }
+```
+
+In your fsproj:
+
+```xml
+<Project>
+    <ItemGroup>
+        <Compile Include="Dto.fs" />
+        <Compile Include="GeneratedDto.fs">
+            <WhippetFile>Dto.fs</WhippetFile>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- Optional runtime dependency: you may use attributes to give instructions to the generator.
+             Specify the `Version` appropriately by getting the latest version from NuGet.org.
+         -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.Json.Attributes" Version="" />
+        <!-- Development dependencies, hence PrivateAssets="all". Note `WhippetPlugin="true"`. -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.Json" WhippetPlugin="true" Version="" />
+        <PackageReference Include="WoofWare.Whippet" Version="" PrivateAssets="all" />
+    </ItemGroup>
+</Project>
+```
+
+The generator will produce a file somewhat like the following:
+
+```fsharp
+/// Module containing JSON parsing methods for the InnerType type
+[<RequireQualifiedAccess>]
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module InnerType =
+    /// Parse from a JSON node.
+    let jsonParse (node: System.Text.Json.Nodes.JsonNode) : InnerType =
+        let Thing = node.["something"].AsValue().GetValue<string>()
+        { Thing = Thing }
+namespace UsePlugin
+
+/// Module containing JSON parsing methods for the JsonRecordType type
+[<AutoOpen>]
+module JsonRecordTypeExtension =
+    type JsonRecordType with
+        /// Parse from a JSON node.
+        let jsonParse (node: System.Text.Json.Nodes.JsonNode) : JsonRecordType =
+            let D = InnerType.jsonParse node.["d"]
+
+            let C =
+                node.["hi"].AsArray() |> Seq.map (fun elt -> elt.GetValue<int>()) |> List.ofSeq
+
+            let B = node.["b"].AsValue().GetValue<string>()
+            let A = node.["a"].AsValue().GetValue<int>()
+            { A = A; B = B; C = C; D = D }
+```
+
+You may instead choose to define attributes with the correct name yourself (if you don't want to take a dependency on the `WoofWare.Whippet.Plugin.Json.Attributes` package).
+Alternatively, you may omit the attributes and the runtime dependency, and control the generator entirely through the fsproj file:
+
+```xml
+<Project>
+    <ItemGroup>
+        <Compile Include="Dto.fs" />
+        <Compile Include="GeneratedDto.fs">
+            <WhippetFile>Dto.fs</WhippetFile>
+            <WhippetParamInnerType>JsonParse</WhippetParamInnerType>
+            <WhippetParamJsonRecordType>JsonParse(false)</WhippetParamJsonRecordType>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- Development dependencies, hence PrivateAssets="all". Note `WhippetPlugin="true"`. -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.Json" WhippetPlugin="true" Version="" />
+        <PackageReference Include="WoofWare.Whippet" Version="" PrivateAssets="all" />
+    </ItemGroup>
+</Project>
+```
+
+(This plugin follows a standard convention taken by `WoofWare.Whippet.Plugin` plugins,
+where you use Whippet parameters with the same name as each input type,
+whose contents are a `!`-delimited list of the generators which you wish to apply to that input type.)
+
+## Usage: `JsonSerialize`
+
+Define a `Dto.fs` file like the following:
+
+```fsharp
+namespace MyNamespace
+
+open WoofWare.Whippet.Plugin.Json
+
+[<JsonSerialize true>]
+type InnerTypeWithBoth =
+    {
+        [<JsonPropertyName("it's-a-me")>]
+        Thing : string
+        ReadOnlyDict : IReadOnlyDictionary<string, Uri list>
+    }
+```
+
+In your fsproj:
+
+```xml
+<Project>
+    <ItemGroup>
+        <Compile Include="Dto.fs" />
+        <Compile Include="GeneratedDto.fs">
+            <WhippetFile>Dto.fs</WhippetFile>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- Optional runtime dependency: you may use attributes to give instructions to the generator.
+             Specify the `Version` appropriately by getting the latest version from NuGet.org.
+         -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.Json.Attributes" Version="" />
+        <!-- Development dependencies, hence PrivateAssets="all". Note `WhippetPlugin="true"`. -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.Json" WhippetPlugin="true" Version="" />
+        <PackageReference Include="WoofWare.Whippet" Version="" PrivateAssets="all" />
+    </ItemGroup>
+</Project>
+```
+
+The generator will produce a file somewhat like the following:
+
+```fsharp
+namespace UsePlugin
+
+/// Module containing JSON parsing methods for the JsonRecordType type
+[<AutoOpen>]
+module JsonRecordTypeExtension =
+    type InnerTypeWithBoth with
+        let toJsonNode (input : InnerTypeWithBoth) : System.Text.Json.Nodes.JsonNode =
+            let node = System.Text.Json.Nodes.JsonObject ()
+
+            do
+                node.Add (("it's-a-me"), System.Text.Json.Nodes.JsonValue.Create<string> input.Thing)
+
+                node.Add (
+                    "ReadOnlyDict",
+                    (fun field ->
+                        let ret = System.Text.Json.Nodes.JsonObject ()
+
+                        for (KeyValue (key, value)) in field do
+                            ret.Add (key.ToString (), System.Text.Json.Nodes.JsonValue.Create<Uri> value)
+
+                        ret
+                    ) input.Map
+                )
+
+            node
+```
+
+You may instead choose to define attributes with the correct name yourself (if you don't want to take a dependency on the `WoofWare.Whippet.Plugin.Json.Attributes` package).
+Alternatively, you may omit the attributes and the runtime dependency, and control the generator entirely through the fsproj file:
+
+```xml
+<Project>
+    <ItemGroup>
+        <Compile Include="Dto.fs" />
+        <Compile Include="GeneratedDto.fs">
+            <WhippetFile>Dto.fs</WhippetFile>
+            <WhippetParamInnerType>JsonSerialize</WhippetParamInnerType>
+            <WhippetParamJsonRecordType>JsonSerialize(false)</WhippetParamJsonRecordType>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <!-- Development dependencies, hence PrivateAssets="all". Note `WhippetPlugin="true"`. -->
+        <PackageReference Include="WoofWare.Whippet.Plugin.Json" WhippetPlugin="true" Version="" />
+        <PackageReference Include="WoofWare.Whippet" Version="" PrivateAssets="all" />
+    </ItemGroup>
+</Project>
+```
+
+(This plugin follows a standard convention taken by `WoofWare.Whippet.Plugin` plugins,
+where you use Whippet parameters with the same name as each input type,
+whose contents are a `!`-delimited list of the generators which you wish to apply to that input type.)
+
+## Notes
+
+* The plugin includes an *opinionated* de/serializer for discriminated unions. (Any such serializer must be opinionated, because JSON does not natively model DUs.)
+* Supply the optional boolean arg `false` to the `[<JsonParse>]`/`[<JsonSerialize>]` attributes, or pass it via `<WhippetParamMyType>JsonParse(false)</WhippetParamMyType>`, to get a genuine module that can be consumed from C#.

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/PureGymDtos.fs

@@ -0,0 +1,264 @@
+namespace WoofWare.Whippet.Plugin.Json.Test
+
+open PureGym
+open System
+
+[<RequireQualifiedAccess>]
+module PureGymDtos =
+
+    let gymOpeningHoursCases =
+        [
+            """{"openingHours": [], "isAlwaysOpen": false}""",
+            {
+                GymOpeningHours.OpeningHours = []
+                IsAlwaysOpen = false
+            }
+            """{"openingHours": ["something"], "isAlwaysOpen": false}""",
+            {
+                GymOpeningHours.OpeningHours = [ "something" ]
+                IsAlwaysOpen = false
+            }
+        ]
+
+    let gymAccessOptionsCases =
+        List.allPairs [ true ; false ] [ true ; false ]
+        |> List.map (fun (a, b) ->
+            let s = sprintf """{"pinAccess": %b, "qrCodeAccess": %b}""" a b
+
+            s,
+            {
+                GymAccessOptions.PinAccess = a
+                QrCodeAccess = b
+            }
+        )
+
+    let gymAddressCases =
+        [
+            """{"addressLine1": "", "postCode": "hi", "town": ""}""",
+            {
+                GymAddress.AddressLine1 = ""
+                AddressLine2 = None
+                AddressLine3 = None
+                County = None
+                Postcode = "hi"
+                Town = ""
+            }
+            """{"addressLine1": "", "addressLine2": null, "postCode": "hi", "town": ""}""",
+            {
+                GymAddress.AddressLine1 = ""
+                AddressLine2 = None
+                AddressLine3 = None
+                County = None
+                Postcode = "hi"
+                Town = ""
+            }
+        ]
+
+    let gymLocationCases =
+        [
+            """{"latitude": 1.0, "longitude": 3.0}""",
+            {
+                GymLocation.Latitude = 1.0<measure>
+                Longitude = 3.0
+            }
+        ]
+
+    let gymCases =
+        let ovalJson =
+            """{"name":"London Oval","id":19,"status":2,"address":{"addressLine1":"Canterbury Court","addressLine2":"Units 4, 4A, 5 And 5A","addressLine3":"Kennington Park","town":"LONDON","county":null,"postcode":"SW9 6DE"},"phoneNumber":"+44 3444770005","emailAddress":"info.londonoval@puregym.com","staffMembers":null,"gymOpeningHours":{"isAlwaysOpen":true,"openingHours":[]},"reasonsToJoin":null,"accessOptions":{"pinAccess":true,"qrCodeAccess":true},"virtualTourUrl":null,"personalTrainersUrl":null,"webViewUrl":null,"floorPlanUrl":null,"location":{"longitude":"-0.110252","latitude":"51.480401"},"timeZone":"Europe/London","reopenDate":"2021-04-12T00:00:00+01 Europe/London"}"""
+
+        let oval =
+            {
+                Gym.Name = "London Oval"
+                Id = 19
+                Status = 2
+                Address =
+                    {
+                        AddressLine1 = "Canterbury Court"
+                        AddressLine2 = Some "Units 4, 4A, 5 And 5A"
+                        AddressLine3 = Some "Kennington Park"
+                        Town = "LONDON"
+                        County = None
+                        Postcode = "SW9 6DE"
+                    }
+                PhoneNumber = "+44 3444770005"
+                EmailAddress = "info.londonoval@puregym.com"
+                GymOpeningHours =
+                    {
+                        IsAlwaysOpen = true
+                        OpeningHours = []
+                    }
+                AccessOptions =
+                    {
+                        PinAccess = true
+                        QrCodeAccess = true
+                    }
+                Location =
+                    {
+                        Longitude = -0.110252
+                        Latitude = 51.480401<measure>
+                    }
+                TimeZone = "Europe/London"
+                ReopenDate = "2021-04-12T00:00:00+01 Europe/London"
+            }
+
+        [ ovalJson, oval ]
+
+    let memberCases =
+        let me =
+            {
+                Id = 1234567
+                CompoundMemberId = "12A123456"
+                FirstName = "Patrick"
+                LastName = "Stevens"
+                HomeGymId = 19
+                HomeGymName = "London Oval"
+                EmailAddress = "someone@somewhere"
+                GymAccessPin = "00000000"
+                DateOfBirth = DateOnly (1994, 01, 02)
+                MobileNumber = "+44 1234567"
+                Postcode = "W1A 1AA"
+                MembershipName = "Corporate"
+                MembershipLevel = 12
+                SuspendedReason = 0
+                MemberStatus = 2
+            }
+
+        let meJson =
+            """{
+  "id": 1234567,
+  "compoundMemberId": "12A123456",
+  "firstName": "Patrick",
+  "lastName": "Stevens",
+  "homeGymId": 19,
+  "homeGymName": "London Oval",
+  "emailAddress": "someone@somewhere",
+  "gymAccessPin": "00000000",
+  "dateofBirth": "1994-01-02",
+  "mobileNumber": "+44 1234567",
+  "postCode": "W1A 1AA",
+  "membershipName": "Corporate",
+  "membershipLevel": 12,
+  "suspendedReason": 0,
+  "memberStatus": 2
+}"""
+
+        [ meJson, me ]
+
+    let gymAttendanceCases =
+        let json =
+            """{
+  "description": "65",
+  "totalPeopleInGym": 65,
+  "totalPeopleInClasses": 2,
+  "totalPeopleSuffix": null,
+  "isApproximate": false,
+  "attendanceTime": "2023-12-27T18:54:09.5101697",
+  "lastRefreshed": "2023-12-27T18:54:09.5101697Z",
+  "lastRefreshedPeopleInClasses": "2023-12-27T18:50:26.0782286Z",
+  "maximumCapacity": 0
+}"""
+
+        let expected =
+            {
+                Description = "65"
+                TotalPeopleInGym = 65
+                TotalPeopleInClasses = 2
+                TotalPeopleSuffix = None
+                IsApproximate = false
+                AttendanceTime =
+                    DateTime (2023, 12, 27, 18, 54, 09, 510, 169, DateTimeKind.Utc)
+                    + TimeSpan.FromTicks 7L
+                LastRefreshed =
+                    DateTime (2023, 12, 27, 18, 54, 09, 510, 169, DateTimeKind.Utc)
+                    + TimeSpan.FromTicks 7L
+                LastRefreshedPeopleInClasses =
+                    DateTime (2023, 12, 27, 18, 50, 26, 078, 228, DateTimeKind.Utc)
+                    + TimeSpan.FromTicks 6L
+                MaximumCapacity = 0
+            }
+
+        [ json, expected ]
+
+    let memberActivityDtoCases =
+        let json =
+            """{"totalDuration":2217,"averageDuration":48,"totalVisits":46,"totalClasses":0,"isEstimated":false,"lastRefreshed":"2023-12-27T19:00:56.0309892Z"}"""
+
+        let value =
+            {
+                TotalDuration = 2217
+                AverageDuration = 48
+                TotalVisits = 46
+                TotalClasses = 0
+                IsEstimated = false
+                LastRefreshed =
+                    DateTime (2023, 12, 27, 19, 00, 56, 030, 989, DateTimeKind.Utc)
+                    + TimeSpan.FromTicks 2L
+            }
+
+        [ json, value ]
+
+    let sessionsCases =
+        let json =
+            """{
+    "Summary":{"Total":{"Activities":0,"Visits":10,"Duration":445},"ThisWeek":{"Activities":0,"Visits":0,"Duration":0}},
+    "Visits":[
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-21T10:12:00","Duration":50,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-20T12:05:00","Duration":80,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-17T19:37:00","Duration":46,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-16T12:19:00","Duration":37,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-15T11:14:00","Duration":47,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-13T10:30:00","Duration":36,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-10T16:18:00","Duration":32,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-05T22:36:00","Duration":40,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-03T17:59:00","Duration":48,"Name":null},
+        {"IsDurationEstimated":false,"Gym":{"Id":19,"Name":"London Oval","Status":"Blocked","Location":null,"GymAccess":null,"ContactInfo":null,"TimeZone":null},"StartTime":"2023-12-01T21:41:00","Duration":29,"Name":null}],
+        "Activities":[]}
+"""
+
+        let singleVisit startTime duration =
+            {
+                IsDurationEstimated = false
+                Gym =
+                    {
+                        Id = 19
+                        Name = "London Oval"
+                        Status = "Blocked"
+                    }
+                StartTime = startTime
+                Duration = duration
+            }
+
+        let expected =
+            {
+                Summary =
+                    {
+                        Total =
+                            {
+                                Activities = 0
+                                Visits = 10
+                                Duration = 445
+                            }
+                        ThisWeek =
+                            {
+                                Activities = 0
+                                Visits = 0
+                                Duration = 0
+                            }
+                    }
+                Visits =
+                    [
+                        singleVisit (DateTime (2023, 12, 21, 10, 12, 00)) 50
+                        singleVisit (DateTime (2023, 12, 20, 12, 05, 00)) 80
+                        singleVisit (DateTime (2023, 12, 17, 19, 37, 00)) 46
+                        singleVisit (DateTime (2023, 12, 16, 12, 19, 00)) 37
+                        singleVisit (DateTime (2023, 12, 15, 11, 14, 00)) 47
+                        singleVisit (DateTime (2023, 12, 13, 10, 30, 00)) 36
+                        singleVisit (DateTime (2023, 12, 10, 16, 18, 00)) 32
+                        singleVisit (DateTime (2023, 12, 05, 22, 36, 00)) 40
+                        singleVisit (DateTime (2023, 12, 03, 17, 59, 00)) 48
+                        singleVisit (DateTime (2023, 12, 01, 21, 41, 00)) 29
+                    ]
+            }
+
+        [ json, expected ]

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/TestExtensionMethod.fs

@@ -0,0 +1,74 @@
+namespace WoofWare.Whippet.Plugin.Json.Test
+
+open System
+open System.Numerics
+open System.Text.Json.Nodes
+open ConsumePlugin
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture>]
+module TestExtensionMethod =
+
+    [<Test>]
+    let ``Parse via extension method`` () =
+        let json =
+            """{
+    "alpha": "hello!",
+    "bravo": "https://example.com",
+    "charlie": 0.3341,
+    "delta": 110033.4,
+    "echo": -0.000993,
+    "foxtrot": -999999999999,
+    "golf": -123456789101112,
+    "hotel": 18446744073709551615,
+    "india": 99884,
+    "juliette": 12223334,
+    "kilo": -2147483642,
+    "lima": 4294967293,
+    "mike": -32767,
+    "november": 65533,
+    "oscar": -125,
+    "papa": 253,
+    "quebec": 254,
+    "tango": -3,
+    "uniform": 1004443.300988393349583009,
+    "victor": "x",
+    "whiskey": 123456123456123456123456123456123456123456
+}"""
+            |> JsonNode.Parse
+
+        let expected =
+            {
+                Alpha = "hello!"
+                Bravo = Uri "https://example.com"
+                Charlie = 0.3341
+                Delta = 110033.4f
+                Echo = -0.000993f
+                Foxtrot = -999999999999.0
+                Golf = -123456789101112L
+                Hotel = 18446744073709551615UL
+                India = 99884
+                Juliette = 12223334u
+                Kilo = -2147483642
+                Lima = 4294967293u
+                Mike = -32767s
+                November = 65533us
+                Oscar = -125y
+                Papa = 253uy
+                Quebec = 254uy
+                Tango = -3y
+                Uniform = 1004443.300988393349583009m
+                Victor = 'x'
+                Whiskey =
+                    let mutable i = BigInteger 0
+
+                    for _ = 0 to 6 do
+                        i <- i * BigInteger 1000000 + BigInteger 123456
+
+                    i
+            }
+
+        let actual = ToGetExtensionMethod.jsonParse json
+
+        actual |> shouldEqual expected

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/TestJsonParse.fs

@@ -0,0 +1,63 @@
+namespace WoofWare.Whippet.Plugin.Json.Test
+
+open System.Text.Json.Nodes
+open ConsumePlugin
+open NUnit.Framework
+open FsUnitTyped
+
+[<TestFixture>]
+module TestJsonParse =
+    let _canSeePastExtensionMethod = ToGetExtensionMethod.thisModuleWouldClash
+
+    [<Test>]
+    let ``Single example`` () =
+        let s =
+            """
+{
+    "a": 3, "another-thing": "hello", "hi": [6, 1], "d": {"something": "oh hi"},
+    "e": ["something", "else"], "f": []
+}
+"""
+
+        let expected =
+            {
+                A = 3
+                B = "hello"
+                C = [ 6 ; 1 ]
+                D =
+                    {
+                        Thing = "oh hi"
+                    }
+                E = [| "something" ; "else" |]
+                F = [||]
+            }
+
+        let actual = s |> JsonNode.Parse |> JsonRecordType.jsonParse
+        actual |> shouldEqual expected
+
+    [<Test>]
+    let ``Inner example`` () =
+        let s =
+            """{
+    "something": "oh hi"
+}"""
+
+        let expected =
+            {
+                Thing = "oh hi"
+            }
+
+        let actual = s |> JsonNode.Parse |> InnerType.jsonParse
+        actual |> shouldEqual expected
+
+    [<TestCase("thing", SomeEnum.Thing)>]
+    [<TestCase("Thing", SomeEnum.Thing)>]
+    [<TestCase("THING", SomeEnum.Thing)>]
+    [<TestCase("blah", SomeEnum.Blah)>]
+    [<TestCase("Blah", SomeEnum.Blah)>]
+    [<TestCase("BLAH", SomeEnum.Blah)>]
+    let ``Can deserialise enum`` (str : string, expected : SomeEnum) =
+        sprintf "\"%s\"" str
+        |> JsonNode.Parse
+        |> SomeEnum.jsonParse
+        |> shouldEqual expected

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/TestJsonSerde.fs

@@ -0,0 +1,474 @@
+namespace WoofWare.Whippet.Plugin.Json.Test
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Nodes
+open FsCheck.Random
+open Microsoft.FSharp.Reflection
+open NUnit.Framework
+open FsCheck
+open FsUnitTyped
+open ConsumePlugin
+
+[<TestFixture>]
+module TestJsonSerde =
+
+    let uriGen : Gen<Uri> =
+        gen {
+            let! suffix = Arb.generate<int>
+            return Uri $"https://example.com/%i{suffix}"
+        }
+
+    let rec innerGen (count : int) : Gen<InnerTypeWithBoth> =
+        gen {
+            let! guid = Arb.generate<Guid>
+            let! mapKeys = Gen.listOf Arb.generate<NonNull<string>>
+            let mapKeys = mapKeys |> List.map _.Get |> List.distinct
+            let! mapValues = Gen.listOfLength mapKeys.Length uriGen
+            let map = List.zip mapKeys mapValues |> Map.ofList
+
+            let! concreteDictKeys =
+                if count > 0 then
+                    Gen.listOf Arb.generate<NonNull<string>>
+                else
+                    Gen.constant []
+
+            let concreteDictKeys =
+                concreteDictKeys
+                |> List.map _.Get
+                |> List.distinct
+                |> fun x -> List.take (min 3 x.Length) x
+
+            let! concreteDictValues =
+                if count > 0 then
+                    Gen.listOfLength concreteDictKeys.Length (innerGen (count - 1))
+                else
+                    Gen.constant []
+
+            let concreteDict =
+                List.zip concreteDictKeys concreteDictValues
+                |> List.map KeyValuePair
+                |> Dictionary
+
+            let! readOnlyDictKeys = Gen.listOf Arb.generate<NonNull<string>>
+            let readOnlyDictKeys = readOnlyDictKeys |> List.map _.Get |> List.distinct
+            let! readOnlyDictValues = Gen.listOfLength readOnlyDictKeys.Length (Gen.listOf Arb.generate<char>)
+            let readOnlyDict = List.zip readOnlyDictKeys readOnlyDictValues |> readOnlyDict
+
+            let! dictKeys = Gen.listOf uriGen
+            let! dictValues = Gen.listOfLength dictKeys.Length Arb.generate<bool>
+            let dict = List.zip dictKeys dictValues |> dict
+
+            return
+                {
+                    Thing = guid
+                    Map = map
+                    ReadOnlyDict = readOnlyDict
+                    Dict = dict
+                    ConcreteDict = concreteDict
+                }
+        }
+
+    let outerGen : Gen<JsonRecordTypeWithBoth> =
+        gen {
+            let! a = Arb.generate<int>
+            let! b = Arb.generate<NonNull<string>>
+            let! c = Gen.listOf Arb.generate<int>
+            let! depth = Gen.choose (0, 2)
+            let! d = innerGen depth
+            let! e = Gen.arrayOf Arb.generate<NonNull<string>>
+            let! arr = Gen.arrayOf Arb.generate<int>
+            let! byte = Arb.generate
+            let! sbyte = Arb.generate
+            let! i = Arb.generate
+            let! i32 = Arb.generate
+            let! i64 = Arb.generate
+            let! u = Arb.generate
+            let! u32 = Arb.generate
+            let! u64 = Arb.generate
+            let! f = Arb.generate |> Gen.filter (fun s -> Double.IsFinite (s / 1.0<measure>))
+            let! f32 = Arb.generate |> Gen.filter (fun s -> Single.IsFinite (s / 1.0f<measure>))
+            let! single = Arb.generate |> Gen.filter (fun s -> Single.IsFinite (s / 1.0f<measure>))
+            let! intMeasureOption = Arb.generate
+            let! intMeasureNullable = Arb.generate
+            let! someEnum = Gen.choose (0, 1)
+            let! timestamp = Arb.generate
+
+            return
+                {
+                    A = a
+                    B = b.Get
+                    C = c
+                    D = d
+                    E = e |> Array.map _.Get
+                    Arr = arr
+                    Byte = byte
+                    Sbyte = sbyte
+                    I = i
+                    I32 = i32
+                    I64 = i64
+                    U = u
+                    U32 = u32
+                    U64 = u64
+                    F = f
+                    F32 = f32
+                    Single = single
+                    IntMeasureOption = intMeasureOption
+                    IntMeasureNullable = intMeasureNullable
+                    Enum = enum<SomeEnum> someEnum
+                    Timestamp = timestamp
+                    Unit = ()
+                }
+        }
+
+    [<Test>]
+    let ``It just works`` () =
+        let property (o : JsonRecordTypeWithBoth) : bool =
+            o
+            |> JsonRecordTypeWithBoth.toJsonNode
+            |> fun s -> s.ToJsonString ()
+            |> JsonNode.Parse
+            |> JsonRecordTypeWithBoth.jsonParse
+            |> shouldEqual o
+
+            true
+
+        property |> Prop.forAll (Arb.fromGen outerGen) |> Check.QuickThrowOnFailure
+
+    [<Test>]
+    let ``Single example of big record`` () =
+        let guid = Guid.Parse "dfe24db5-9f8d-447b-8463-4c0bcf1166d5"
+
+        let data =
+            {
+                A = 3
+                B = "hello!"
+                C = [ 1 ; -9 ]
+                D =
+                    {
+                        Thing = guid
+                        Map = Map.ofList []
+                        ReadOnlyDict = readOnlyDict []
+                        Dict = dict []
+                        ConcreteDict = Dictionary ()
+                    }
+                E = [| "I'm-a-string" |]
+                Arr = [| -18883 ; 9100 |]
+                Byte = 87uy<measure>
+                Sbyte = 89y<measure>
+                I = 199993345<measure>
+                I32 = -485832<measure>
+                I64 = -13458625689L<measure>
+                U = 458582u<measure>
+                U32 = 857362147u<measure>
+                U64 = 1234567892123414596UL<measure>
+                F = 8833345667.1<measure>
+                F32 = 1000.98f<measure>
+                Single = 0.334f<measure>
+                IntMeasureOption = Some 981<measure>
+                IntMeasureNullable = Nullable -883<measure>
+                Enum = enum<SomeEnum> 1
+                Timestamp = DateTimeOffset (2024, 07, 01, 17, 54, 00, TimeSpan.FromHours 1.0)
+                Unit = ()
+            }
+
+        let expected =
+            """{
+    "a": 3,
+    "b": "hello!",
+    "c": [1, -9],
+    "d": {
+      "it\u0027s-a-me": "dfe24db5-9f8d-447b-8463-4c0bcf1166d5",
+      "map": {},
+      "readOnlyDict": {},
+      "dict": {},
+      "concreteDict": {}
+    },
+    "e": ["I\u0027m-a-string"],
+    "arr": [-18883, 9100],
+    "byte": 87,
+    "sbyte": 89,
+    "i": 199993345,
+    "i32": -485832,
+    "i64": -13458625689,
+    "u": 458582,
+    "u32": 857362147,
+    "u64": 1234567892123414596,
+    "f": 8833345667.1,
+    "f32": 1000.98,
+    "single": 0.334,
+    "intMeasureOption": 981,
+    "intMeasureNullable": -883,
+    "enum": 1,
+    "timestamp": "2024-07-01T17:54:00.0000000\u002B01:00",
+    "unit": {}
+}
+"""
+            |> fun s -> s.ToCharArray ()
+            |> Array.filter (fun c -> not (Char.IsWhiteSpace c))
+            |> fun s -> new String (s)
+
+        JsonRecordTypeWithBoth.toJsonNode(data).ToJsonString () |> shouldEqual expected
+        JsonRecordTypeWithBoth.jsonParse (JsonNode.Parse expected) |> shouldEqual data
+
+    [<Test>]
+    let ``Guids are treated just like strings`` () =
+        let guidStr = "b1e7496e-6e79-4158-8579-a01de355d3b2"
+        let guid = Guid.Parse guidStr
+
+        let node =
+            {
+                Thing = guid
+                Map = Map.empty
+                ReadOnlyDict = readOnlyDict []
+                Dict = dict []
+                ConcreteDict = Dictionary ()
+            }
+            |> InnerTypeWithBoth.toJsonNode
+
+        node.ToJsonString ()
+        |> shouldEqual (
+            sprintf """{"it\u0027s-a-me":"%s","map":{},"readOnlyDict":{},"dict":{},"concreteDict":{}}""" guidStr
+        )
+
+    type Generators =
+        static member TestCase () =
+            { new Arbitrary<InnerTypeWithBoth>() with
+                override x.Generator = innerGen 5
+            }
+
+    let sanitiseInner (r : InnerTypeWithBoth) : InnerTypeWithBoth =
+        {
+            Thing = r.Thing
+            Map = r.Map
+            ReadOnlyDict = r.ReadOnlyDict
+            Dict = r.Dict
+            ConcreteDict = r.ConcreteDict
+        }
+
+    let sanitiseRec (r : JsonRecordTypeWithBoth) : JsonRecordTypeWithBoth =
+        { r with
+            B = if isNull r.B then "<null>" else r.B
+            C =
+                if Object.ReferenceEquals (r.C, (null : obj)) then
+                    []
+                else
+                    r.C
+            D = sanitiseInner r.D
+            E = if isNull r.E then [||] else r.E
+            Arr =
+                if Object.ReferenceEquals (r.Arr, (null : obj)) then
+                    [||]
+                else
+                    r.Arr
+        }
+
+    let duGen =
+        gen {
+            let! case = Gen.choose (0, 2)
+
+            match case with
+            | 0 -> return FirstDu.EmptyCase
+            | 1 ->
+                let! s = Arb.generate<NonNull<string>>
+                return FirstDu.Case1 s.Get
+            | 2 ->
+                let! i = Arb.generate<int>
+                let! record = outerGen
+                return FirstDu.Case2 (record, i)
+            | _ -> return failwith $"unexpected: %i{case}"
+        }
+
+    [<Test>]
+    let ``Discriminated union works`` () =
+        let property (du : FirstDu) : unit =
+            du
+            |> FirstDu.toJsonNode
+            |> fun s -> s.ToJsonString ()
+            |> JsonNode.Parse
+            |> FirstDu.jsonParse
+            |> shouldEqual du
+
+        property |> Prop.forAll (Arb.fromGen duGen) |> Check.QuickThrowOnFailure
+
+    [<Test>]
+    let ``DU generator covers all cases`` () =
+        let rand = Random ()
+        let cases = FSharpType.GetUnionCases typeof<FirstDu>
+        let counts = Array.zeroCreate<int> cases.Length
+
+        let decompose = FSharpValue.PreComputeUnionTagReader typeof<FirstDu>
+
+        let mutable i = 0
+
+        while i < 10_000 && Array.exists (fun i -> i = 0) counts do
+            let du = Gen.eval 10 (StdGen.StdGen (rand.Next (), rand.Next ())) duGen
+            let tag = decompose du
+            counts.[tag] <- counts.[tag] + 1
+            i <- i + 1
+
+        for i in counts do
+            i |> shouldBeGreaterThan 0
+
+    let dict<'a, 'b when 'a : equality> (xs : ('a * 'b) seq) : Dictionary<'a, 'b> =
+        let result = Dictionary ()
+
+        for k, v in xs do
+            result.Add (k, v)
+
+        result
+
+    let inline makeJsonArr< ^t, ^u when ^u : (static member op_Implicit : ^t -> JsonNode) and ^u :> JsonNode>
+        (arr : ^t seq)
+        : JsonNode
+        =
+        let result = JsonArray ()
+
+        for a in arr do
+            result.Add a
+
+        result :> JsonNode
+
+    let normalise (d : Dictionary<'a, 'b>) : ('a * 'b) list =
+        d |> Seq.map (fun (KeyValue (a, b)) -> a, b) |> Seq.toList |> List.sortBy fst
+
+    [<Test>]
+    let ``Can collect extension data`` () =
+        let str =
+            """{
+    "message": { "header": "hi", "value": "bye" },
+    "something": 3,
+    "arr": ["egg", "toast"],
+    "str": "whatnot"
+}"""
+            |> JsonNode.Parse
+
+        let expected =
+            {
+                Rest =
+                    [
+                        "something", JsonNode.op_Implicit 3
+                        "arr", makeJsonArr [| "egg" ; "toast" |]
+                        "str", JsonNode.op_Implicit "whatnot"
+                    ]
+                    |> dict
+                Message =
+                    Some
+                        {
+                            Header = "hi"
+                            Value = "bye"
+                        }
+            }
+
+        let actual = CollectRemaining.jsonParse str
+
+        actual.Message |> shouldEqual expected.Message
+
+        normalise actual.Rest
+        |> List.map (fun (k, v) -> k, v.ToJsonString ())
+        |> shouldEqual (normalise expected.Rest |> List.map (fun (k, v) -> k, v.ToJsonString ()))
+
+    [<Test>]
+    let ``Can write out extension data`` () =
+        let expected =
+            """{"message":{"header":"hi","value":"bye"},"something":3,"arr":["egg","toast"],"str":"whatnot"}"""
+
+        let toWrite =
+            {
+                Rest =
+                    [
+                        "something", JsonNode.op_Implicit 3
+                        "arr", makeJsonArr [| "egg" ; "toast" |]
+                        "str", JsonNode.op_Implicit "whatnot"
+                    ]
+                    |> dict
+                Message =
+                    Some
+                        {
+                            Header = "hi"
+                            Value = "bye"
+                        }
+            }
+
+        let actual = CollectRemaining.toJsonNode toWrite |> fun s -> s.ToJsonString ()
+
+        actual |> shouldEqual expected
+
+    [<Test>]
+    let ``Can collect extension data, nested`` () =
+        let str =
+            """{
+  "thing": 99,
+  "baz": -123,
+  "remaining": {
+    "message": { "header": "hi", "value": "bye" },
+    "something": 3,
+    "arr": ["egg", "toast"],
+    "str": "whatnot"
+  }
+}"""
+            |> JsonNode.Parse
+
+        let expected : OuterCollectRemaining =
+            {
+                Remaining =
+                    {
+                        Message =
+                            Some
+                                {
+                                    Header = "hi"
+                                    Value = "bye"
+                                }
+                        Rest =
+                            [
+                                "something", JsonNode.op_Implicit 3
+                                "arr", makeJsonArr [| "egg" ; "toast" |]
+                                "str", JsonNode.op_Implicit "whatnot"
+                            ]
+                            |> dict
+                    }
+                Others = [ "thing", 99 ; "baz", -123 ] |> dict
+            }
+
+        let actual = OuterCollectRemaining.jsonParse str
+
+        normalise actual.Others |> shouldEqual (normalise expected.Others)
+
+        let actual = actual.Remaining
+        let expected = expected.Remaining
+
+        actual.Message |> shouldEqual expected.Message
+
+        normalise actual.Rest
+        |> List.map (fun (k, v) -> k, v.ToJsonString ())
+        |> shouldEqual (normalise expected.Rest |> List.map (fun (k, v) -> k, v.ToJsonString ()))
+
+    [<Test>]
+    let ``Can write out extension data, nested`` () =
+        let expected =
+            """{"thing":99,"baz":-123,"remaining":{"message":{"header":"hi","value":"bye"},"something":3,"arr":["egg","toast"],"str":"whatnot"}}"""
+
+        let toWrite : OuterCollectRemaining =
+            {
+                Others = [ "thing", 99 ; "baz", -123 ] |> dict
+                Remaining =
+                    {
+                        Rest =
+                            [
+                                "something", JsonNode.op_Implicit 3
+                                "arr", makeJsonArr [| "egg" ; "toast" |]
+                                "str", JsonNode.op_Implicit "whatnot"
+                            ]
+                            |> dict
+                        Message =
+                            Some
+                                {
+                                    Header = "hi"
+                                    Value = "bye"
+                                }
+                    }
+            }
+
+        let actual = OuterCollectRemaining.toJsonNode toWrite |> fun s -> s.ToJsonString ()
+
+        actual |> shouldEqual expected

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/TestPureGymJson.fs

@@ -0,0 +1,71 @@
+namespace WoofWare.Whippet.Plugin.Json.Test
+
+open System
+open System.Text.Json.Nodes
+open NUnit.Framework
+open FsUnitTyped
+open PureGym
+
+[<TestFixture>]
+module TestPureGymJson =
+
+    let gymOpeningHoursCases = PureGymDtos.gymOpeningHoursCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymOpeningHoursCases)>]
+    let ``GymOpeningHours JSON parse`` (json : string, expected : GymOpeningHours) =
+        JsonNode.Parse json |> GymOpeningHours.jsonParse |> shouldEqual expected
+
+    let gymAccessOptionsCases =
+        PureGymDtos.gymAccessOptionsCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymAccessOptionsCases)>]
+    let ``GymAccessOptions JSON parse`` (json : string, expected : GymAccessOptions) =
+        JsonNode.Parse json |> GymAccessOptions.jsonParse |> shouldEqual expected
+
+    let gymLocationCases = PureGymDtos.gymLocationCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymLocationCases)>]
+    let ``GymLocation JSON parse`` (json : string, expected : GymLocation) =
+        JsonNode.Parse json |> GymLocation.jsonParse |> shouldEqual expected
+
+    let gymAddressCases = PureGymDtos.gymAddressCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymAddressCases)>]
+    let ``GymAddress JSON parse`` (json : string, expected : GymAddress) =
+        JsonNode.Parse (json, Nullable (JsonNodeOptions (PropertyNameCaseInsensitive = true)))
+        |> GymAddress.jsonParse
+        |> shouldEqual expected
+
+    let gymCases = PureGymDtos.gymCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymCases)>]
+    let ``Gym JSON parse`` (json : string, expected : Gym) =
+        JsonNode.Parse json |> Gym.jsonParse |> shouldEqual expected
+
+    let memberCases = PureGymDtos.memberCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof memberCases)>]
+    let ``Member JSON parse`` (json : string, expected : Member) =
+        json |> JsonNode.Parse |> Member.jsonParse |> shouldEqual expected
+
+    let gymAttendanceCases = PureGymDtos.gymAttendanceCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymAttendanceCases)>]
+    let ``GymAttendance JSON parse`` (json : string, expected : GymAttendance) =
+        json |> JsonNode.Parse |> GymAttendance.jsonParse |> shouldEqual expected
+
+    let memberActivityDtoCases =
+        PureGymDtos.memberActivityDtoCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof memberActivityDtoCases)>]
+    let ``MemberActivityDto JSON parse`` (json : string, expected : MemberActivityDto) =
+        json |> JsonNode.Parse |> MemberActivityDto.jsonParse |> shouldEqual expected
+
+    let sessionsCases = PureGymDtos.sessionsCases |> List.map TestCaseData
+
+    [<TestCaseSource(nameof sessionsCases)>]
+    let ``Sessions JSON parse`` (json : string, expected : Sessions) =
+        json
+        |> fun o -> JsonNode.Parse (o, Nullable (JsonNodeOptions (PropertyNameCaseInsensitive = true)))
+        |> Sessions.jsonParse
+        |> shouldEqual expected

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/TestSurface.fs

@@ -0,0 +1,26 @@
+namespace WoofWare.Whippet.Plugin.Json.Test
+
+open NUnit.Framework
+open WoofWare.Whippet.Plugin.Json
+open ApiSurface
+
+[<TestFixture>]
+module TestAttributeSurface =
+    let assembly = typeof<JsonParseAttribute>.Assembly
+
+    [<Test>]
+    let ``Ensure API surface has not been modified`` () = ApiSurface.assertIdentical assembly
+
+    (*
+    [<Test>]
+    let ``Check version against remote`` () =
+        MonotonicVersion.validate assembly "WoofWare.Whippet.Plugin.Json.Attributes"
+        *)
+
+    [<Test ; Explicit>]
+    let ``Update API surface`` () =
+        ApiSurface.writeAssemblyBaseline assembly
+
+    [<Test>]
+    let ``Ensure public API is fully documented`` () =
+        DocCoverage.assertFullyDocumented assembly

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.Test/WoofWare.Whippet.Plugin.Json.Test.fsproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="PureGymDtos.fs" />
+        <Compile Include="TestJsonSerde.fs" />
+        <Compile Include="TestJsonParse.fs" />
+        <Compile Include="TestExtensionMethod.fs" />
+        <Compile Include="TestPureGymJson.fs" />
+        <Compile Include="TestSurface.fs" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1"/>
+      <PackageReference Include="NUnit" Version="4.2.2"/>
+      <PackageReference Include="NUnit3TestAdapter" Version="4.6.0"/>
+      <PackageReference Include="FsUnit" Version="6.0.1"/>
+      <PackageReference Include="FsCheck" Version="2.16.6"/>
+      <PackageReference Include="ApiSurface" Version="4.1.5"/>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\WoofWare.Whippet.Plugin.Json.Consumer\WoofWare.Whippet.Plugin.Json.Consumer.fsproj" />
+    </ItemGroup>
+
+</Project>

Plugins/Json/WoofWare.Whippet.Plugin.Json/WoofWare.Whippet.Plugin.Json.fsproj

@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net8.0</TargetFramework>
+      <GenerateDocumentationFile>true</GenerateDocumentationFile>
+      <Authors>Patrick Stevens</Authors>
+      <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
+      <Description>Whippet F# source generator plugin, for generating JSON parse and serialize methods.</Description>
+      <RepositoryType>git</RepositoryType>
+      <RepositoryUrl>https://github.com/Smaug123/WoofWare.Whippet</RepositoryUrl>
+      <PackageLicenseExpression>MIT</PackageLicenseExpression>
+      <PackageReadmeFile>README.md</PackageReadmeFile>
+      <PackageTags>fsharp;source-generator;source-gen;whippet;json;serialize;deserialize;serde</PackageTags>
+      <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+      <WarnOn>FS3559</WarnOn>
+      <PackageId>WoofWare.Whippet.Plugin.Json</PackageId>
+      <DevelopmentDependency>true</DevelopmentDependency>
+      <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+      <NoWarn>NU5118</NoWarn>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Compile Include="DesiredGenerator.fs" />
+      <Compile Include="JsonSerializeGenerator.fs" />
+      <Compile Include="JsonParseGenerator.fs" />
+      <None Include="README.md">
+        <Pack>True</Pack>
+        <PackagePath>/</PackagePath>
+        <Link>README.md</Link>
+      </None>
+      <EmbeddedResource Include="version.json" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\..\WoofWare.Whippet.Core\WoofWare.Whippet.Core.fsproj" />
+      <ProjectReference Include="..\..\..\WoofWare.Whippet.Fantomas\WoofWare.Whippet.Fantomas.fsproj" />
+      <ProjectReference Include="..\WoofWare.Whippet.Plugin.Json.Attributes\WoofWare.Whippet.Plugin.Json.Attributes.fsproj" />
+    </ItemGroup>
+
+</Project>

Plugins/Json/WoofWare.Whippet.Plugin.Json/version.json

@@ -0,0 +1,14 @@
+{
+  "version": "0.1",
+  "publicReleaseRefSpec": [
+    "^refs/heads/main$"
+  ],
+  "pathFilters": [
+    "./",
+    ":/WoofWare.Whippet.Core/",
+    ":/WoofWare.Whippet.Fantomas/",
+    ":/Plugins/Json/WoofWare.Whippet.Plugins.Json.Attributes/",
+    ":/global.json",
+    ":/Directory.Build.props"
+  ]
+}

README.md

@@ -2,12 +2,81 @@
 
 Whippet is a source generator for F#, inspired by [Myriad](https://github.com/MoiraeSoftware/myriad).
 
-It is currently vapourware; please do not use it.
+It is currently vapourware; please do not use it, because its API surface and features are liable to change completely without notice.
-With some modest changes to [WoofWare.Myriad.Plugins](https://github.com/Smaug123/WoofWare.Myriad/) I was able to use Whippet to generate source files in that repo.
+It currently lacks most of the future features intended to distinguish Whippet from Myriad.
-However, it currently lacks any of Myriad's ease of invocation, and indeed any of the future features intended to distinguish Whippet from Myriad.
 
 Differentiating features:
 
-* Whippet expands the range of information available to a source-generating plugin. Eventually we intend for it to supply type-checking information.
+* Whippet expands the range of information available to a source-generating plugin. Eventually (in the far future) we intend for it to supply type-checking information.
-* Whippet will eventually support the Fantomas [Oak](https://fsprojects.github.io/fantomas/docs/end-users/GeneratingCode.html) format, rather than just a plain AST.
+* Whippet will eventually support the Fantomas [Oak](https://fsprojects.github.io/fantomas/docs/end-users/GeneratingCode.html) format, rather than just a plain AST. It already does support this, in the sense that the only interface to Whippet is "we give you bytes, you give us text", so you're free to use an Oak already; but we give you no help with this.
 * Whippet is intended to be more modular, providing various different helper assemblies a plugin author can optionally use depending on what features they want.
+
+## How to use
+
+The simplest invocation is as follows.
+
+### Import the source generator framework
+
+In your `.fsproj`, take the following `PackageReference`, setting the `Version=""` to the latest version available on NuGet.
+
+```xml
+<PackageReference Include="WoofWare.Whippet" PrivateAssets="all" Version="" />
+```
+
+(`PrivateAssets="all"` is necessary to prevent the Whippet dependency from flowing to the consumers of your package.)
+
+### Import the plugin you wish to call
+
+```xml
+<PackageReference Include="WoofWare.Whippet.Plugin.ArgParser" PrivateAssets="all" WhippetPlugin="true" />
+```
+
+Note the important `WhippetPlugin="true"` which is how Whippet determines which packages to search for plugins,
+and the `PrivateAssets="all"` again to prevent this dependency from flowing to your consumers.
+
+### Configure the source generator
+
+The simplest possible configuration is as follows:
+
+```xml
+<ItemGroup>
+  <Compile Include="Args.fs" />
+  <Compile Include="GeneratedArgs.fs">
+    <WhippetFile>Args.fs</WhippetFile>
+  </Compile>
+</ItemGroup>
+```
+
+Here, you wrote the `Args.fs` file, and have specified that the `GeneratedArgs.fs` file is to be generated using `Args.fs`
+as input.
+
+### Advanced configuration of source generators
+
+A plugin author may choose to have their plugin be configurable, by recognising parameters passed through the fsproj.
+
+```xml
+<ItemGroup>
+    <Compile Include="SwaggerGitea.fs" />
+    <Compile Include="GeneratedSwaggerGitea.fs">
+        <WhippetFile>swagger-gitea.json</WhippetFile>
+        <WhippetParamGenerateMockInternal>true</WhippetParamGenerateMockInternal>
+        <WhippetParamClassName>Gitea</WhippetParamClassName>
+    </Compile>
+</ItemGroup>
+```
+
+Any key prefixed with `WhippetParam` will have that prefix removed and the string value passed in to the generator
+through the `Parameters` field on the plugin's args.
+(MSBuild only allows strings here, so the `"true"` in the above example is a string, not a boolean.
+If you want more advanced inputs to your plugin, you will have to create a parser yourself.)
+
+## Standalone tool
+
+The standalone tool takes the following arguments:
+
+* A path to an `fsproj` file.
+* (positional args) A list of DLLs from which to load plugins. (Currently I strongly recommend only using one plugin per fsproj file; it's completely untested to use more!)
+
+The tool uses MSBuild to load the fsproj file to discover what files need to be generated.
+(This duplicates a bunch of work, because you're presumably executing the tool during a build anyway!)
+The tool then loads the plugins, and reflectively determines which source generators contained therein should run on each file.

WoofWare.Whippet.App/AppContext.fs

@@ -0,0 +1,33 @@
+namespace WoofWare.Whippet
+
+open System
+open System.IO
+open System.Reflection
+
+// Fix for https://github.com/Smaug123/unofficial-nunit-runner/issues/8
+// (This tells the DLL loader to look next to the input DLL for dependencies.)
+/// Context manager to set the AppContext.BaseDirectory of the executing DLL.
+type SetBaseDir (testDll : FileInfo) =
+    let oldBaseDir = AppContext.BaseDirectory
+
+    let setData =
+        let appContext = Type.GetType "System.AppContext"
+
+        if Object.ReferenceEquals (appContext, (null : obj)) then
+            ignore<string * string>
+        else
+
+        let setDataMethod =
+            appContext.GetMethod ("SetData", BindingFlags.Static ||| BindingFlags.Public)
+
+        if Object.ReferenceEquals (setDataMethod, (null : obj)) then
+            ignore<string * string>
+        else
+
+        fun (k, v) -> setDataMethod.Invoke ((null : obj), [| k ; v |]) |> unbox<unit>
+
+    do setData ("APP_CONTEXT_BASE_DIRECTORY", testDll.Directory.FullName)
+
+    interface IDisposable with
+        member _.Dispose () =
+            setData ("APP_CONTEXT_BASE_DIRECTORY", oldBaseDir)

WoofWare.Whippet.App/Context.fs

@@ -0,0 +1,26 @@
+namespace WoofWare.Whippet
+
+open System.IO
+open System.Reflection
+open System.Runtime.Loader
+
+type Ctx (dll : FileInfo, runtimes : DirectoryInfo list) =
+    inherit AssemblyLoadContext ()
+
+    override this.Load (target : AssemblyName) : Assembly =
+        let path = Path.Combine (dll.Directory.FullName, $"%s{target.Name}.dll")
+
+        if File.Exists path then
+            this.LoadFromAssemblyPath path
+        else
+
+        runtimes
+        |> List.tryPick (fun di ->
+            let path = Path.Combine (di.FullName, $"%s{target.Name}.dll")
+
+            if File.Exists path then
+                this.LoadFromAssemblyPath path |> Some
+            else
+                None
+        )
+        |> Option.defaultValue null

WoofWare.Whippet.App/Program.fs

@@ -10,27 +10,27 @@ open WoofWare.Whippet.Core
 
 type Args =
     {
-        PluginDll : FileInfo
         InputFile : FileInfo
+        Plugins : FileInfo list
     }
 
 type WhippetTarget =
     {
         InputSource : FileInfo
         GeneratedDest : FileInfo
+        Params : Map<string, string>
     }
 
 module Program =
     let parseArgs (argv : string array) =
         let inputFile = argv.[0] |> FileInfo
-        let pluginDll = argv.[1] |> FileInfo
 
         {
             InputFile = inputFile
-            PluginDll = pluginDll
+            Plugins = argv.[1..] |> Seq.map FileInfo |> Seq.toList
         }
 
-    let getGenerateRawFromRaw (host : obj) : (RawSourceGenerationArgs -> string) option =
+    let getGenerateRawFromRaw (host : obj) : (RawSourceGenerationArgs -> string option) option =
         let pluginType = host.GetType ()
 
         let generateRawFromRaw =
@@ -71,7 +71,14 @@ module Program =
                 failwith
                     $"Expected GenerateRawFromRaw method to have return type `string`, but was: %s{retType.FullName}"
 
-            fun args -> generateRawFromRaw.Invoke (host, [| args |]) |> unbox<string>
+            fun args ->
+                let args =
+                    Activator.CreateInstance (
+                        pars.[0].ParameterType,
+                        [| box args.FilePath ; box args.FileContents ; box args.Parameters |]
+                    )
+
+                generateRawFromRaw.Invoke (host, [| args |]) |> unbox<string> |> Option.ofObj
             |> Some
 
     [<EntryPoint>]
@@ -113,17 +120,50 @@ module Program =
                 | None -> None
                 | Some myriadFile ->
 
+                let pars =
+                    metadata
+                    |> Map.toSeq
+                    |> Seq.choose (fun (key, value) ->
+                        if key.StartsWith ("WhippetParam", StringComparison.Ordinal) then
+                            Some (key.Substring "WhippetParam".Length, value)
+                        else
+                            None
+                    )
+                    |> Map.ofSeq
+
+                let inputSource =
+                    FileInfo (Path.Combine (Path.GetDirectoryName desiredProject.ProjectFileName, myriadFile))
+
+                let generatedDest = FileInfo fullPath
+
+                if inputSource.FullName = generatedDest.FullName then
+                    failwith $"Input source %s{inputSource.FullName} was identical to output path; aborting."
+
                 {
-                    GeneratedDest = FileInfo fullPath
+                    GeneratedDest = generatedDest
-                    InputSource =
+                    InputSource = inputSource
-                        FileInfo (Path.Combine (Path.GetDirectoryName desiredProject.ProjectFileName, myriadFile))
+                    Params = pars
                 }
                 |> Some
             )
 
-        Console.Error.WriteLine $"Loading plugin: %s{args.PluginDll.FullName}"
+        let runtime =
+            DotnetRuntime.locate (Assembly.GetExecutingAssembly().Location |> FileInfo)
 
-        let pluginAssembly = Assembly.LoadFrom args.PluginDll.FullName
+        let pluginDll =
+            match args.Plugins with
+            | [] -> failwith "must supply a plugin!"
+            | [ plugin ] -> plugin
+            | _ -> failwith "We don't yet support running more than one Whippet plugin in a given project file"
+
+        // TODO: should ideally loop over files, not plugins, so we fully generate a file before moving on to the next
+        // one
+
+        Console.Error.WriteLine $"Loading plugin: %s{pluginDll.FullName}"
+
+        let ctx = Ctx (pluginDll, runtime)
+
+        let pluginAssembly = ctx.LoadFromAssemblyPath pluginDll.FullName
 
         // We will look up any member called GenerateRawFromRaw and/or GenerateFromRaw.
         // It's your responsibility to decide whether to do anything with this call; you return null if you don't want
@@ -159,13 +199,15 @@ module Program =
                         {
                             RawSourceGenerationArgs.FilePath = item.InputSource.FullName
                             FileContents = fileContents
+                            Parameters = item.Params
                         }
 
                     let result = generateRawFromRaw args
 
                     match result with
-                    | null -> ()
+                    | None
-                    | result ->
+                    | Some null -> ()
+                    | Some result ->
                         Console.Error.WriteLine
                             $"Writing output for generator %s{plugin.Name} to file %s{item.GeneratedDest.FullName}"
 

WoofWare.Whippet.App/RuntimeConfig.fs

@@ -0,0 +1,47 @@
+namespace WoofWare.Whippet
+
+open System
+
+type FrameworkDescription =
+    {
+        Name : string
+        Version : string
+    }
+
+type RuntimeOptions =
+    {
+        Tfm : string
+        Framework : FrameworkDescription option
+        Frameworks : FrameworkDescription list option
+        RollForward : string option
+    }
+
+type RuntimeConfig =
+    {
+        RuntimeOptions : RuntimeOptions
+    }
+
+[<RequireQualifiedAccess>]
+type RollForward =
+    | Minor
+    | Major
+    | LatestPatch
+    | LatestMinor
+    | LatestMajor
+    | Disable
+
+    static member Parse (s : string) : RollForward =
+        if s.Equals ("minor", StringComparison.OrdinalIgnoreCase) then
+            RollForward.Minor
+        elif s.Equals ("major", StringComparison.OrdinalIgnoreCase) then
+            RollForward.Major
+        elif s.Equals ("latestpatch", StringComparison.OrdinalIgnoreCase) then
+            RollForward.LatestPatch
+        elif s.Equals ("latestminor", StringComparison.OrdinalIgnoreCase) then
+            RollForward.LatestMinor
+        elif s.Equals ("latestmajor", StringComparison.OrdinalIgnoreCase) then
+            RollForward.LatestMajor
+        elif s.Equals ("disable", StringComparison.OrdinalIgnoreCase) then
+            RollForward.Disable
+        else
+            failwith $"Could not interpret '%s{s}' as a RollForward"

WoofWare.Whippet.App/RuntimeConfigGen.fs

@@ -0,0 +1,103 @@
+namespace WoofWare.Whippet
+
+(* File originally generated by Myriad. *)
+
+/// Module containing JSON parsing methods for the FrameworkDescription type
+[<RequireQualifiedAccess ; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module FrameworkDescription =
+    /// Parse from a JSON node.
+    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : FrameworkDescription =
+        let arg_1 =
+            (match node.["version"] with
+             | null ->
+                 raise (
+                     System.Collections.Generic.KeyNotFoundException (
+                         sprintf "Required key '%s' not found on JSON object" ("version")
+                     )
+                 )
+             | v -> v)
+                .AsValue()
+                .GetValue<System.String> ()
+
+        let arg_0 =
+            (match node.["name"] with
+             | null ->
+                 raise (
+                     System.Collections.Generic.KeyNotFoundException (
+                         sprintf "Required key '%s' not found on JSON object" ("name")
+                     )
+                 )
+             | v -> v)
+                .AsValue()
+                .GetValue<System.String> ()
+
+        {
+            Name = arg_0
+            Version = arg_1
+        }
+namespace WoofWare.Whippet
+
+/// Module containing JSON parsing methods for the RuntimeOptions type
+[<RequireQualifiedAccess ; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module RuntimeOptions =
+    /// Parse from a JSON node.
+    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : RuntimeOptions =
+        let arg_3 =
+            match node.["rollForward"] with
+            | null -> None
+            | v -> v.AsValue().GetValue<System.String> () |> Some
+
+        let arg_2 =
+            match node.["frameworks"] with
+            | null -> None
+            | v ->
+                v.AsArray ()
+                |> Seq.map (fun elt -> FrameworkDescription.jsonParse elt)
+                |> List.ofSeq
+                |> Some
+
+        let arg_1 =
+            match node.["framework"] with
+            | null -> None
+            | v -> FrameworkDescription.jsonParse v |> Some
+
+        let arg_0 =
+            (match node.["tfm"] with
+             | null ->
+                 raise (
+                     System.Collections.Generic.KeyNotFoundException (
+                         sprintf "Required key '%s' not found on JSON object" ("tfm")
+                     )
+                 )
+             | v -> v)
+                .AsValue()
+                .GetValue<System.String> ()
+
+        {
+            Tfm = arg_0
+            Framework = arg_1
+            Frameworks = arg_2
+            RollForward = arg_3
+        }
+namespace WoofWare.Whippet
+
+/// Module containing JSON parsing methods for the RuntimeConfig type
+[<RequireQualifiedAccess ; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+module RuntimeConfig =
+    /// Parse from a JSON node.
+    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : RuntimeConfig =
+        let arg_0 =
+            RuntimeOptions.jsonParse (
+                match node.["runtimeOptions"] with
+                | null ->
+                    raise (
+                        System.Collections.Generic.KeyNotFoundException (
+                            sprintf "Required key '%s' not found on JSON object" ("runtimeOptions")
+                        )
+                    )
+                | v -> v
+            )
+
+        {
+            RuntimeOptions = arg_0
+        }

WoofWare.Whippet.App/RuntimeLocator.fs

@@ -0,0 +1,104 @@
+namespace WoofWare.Whippet
+
+open System
+open System.IO
+open WoofWare.DotnetRuntimeLocator
+
+/// Functions for locating .NET runtimes.
+[<RequireQualifiedAccess>]
+module DotnetRuntime =
+    let private selectRuntime
+        (config : RuntimeOptions)
+        (f : DotnetEnvironmentInfo)
+        : Choice<DotnetEnvironmentFrameworkInfo, DotnetEnvironmentSdkInfo> option
+        =
+        let rollForward =
+            match Environment.GetEnvironmentVariable "DOTNET_ROLL_FORWARD" with
+            | null ->
+                config.RollForward
+                |> Option.map RollForward.Parse
+                |> Option.defaultValue RollForward.Minor
+            | s -> RollForward.Parse s
+
+        let desiredVersions =
+            match config.Framework with
+            | Some f -> [ Version f.Version, f.Name ]
+            | None ->
+
+            match config.Frameworks with
+            | Some f -> f |> List.map (fun f -> Version f.Version, f.Name)
+            | None ->
+                failwith
+                    "Could not deduce a framework version due to lack of either Framework or Frameworks in runtimeconfig"
+
+        let compatiblyNamedRuntimes =
+            f.Frameworks
+            |> Seq.collect (fun availableFramework ->
+                desiredVersions
+                |> List.choose (fun (desiredVersion, desiredName) ->
+                    if desiredName = availableFramework.Name then
+                        Some
+                            {|
+                                Desired = desiredVersion
+                                Name = desiredName
+                                Installed = availableFramework
+                                InstalledVersion = Version availableFramework.Version
+                            |}
+                    else
+                        None
+                )
+            )
+            |> Seq.toList
+
+        match rollForward with
+        | RollForward.Minor ->
+            let available =
+                compatiblyNamedRuntimes
+                |> Seq.filter (fun data ->
+                    data.InstalledVersion.Major = data.Desired.Major
+                    && data.InstalledVersion.Minor >= data.Desired.Minor
+                )
+                |> Seq.groupBy (fun data -> data.Name)
+                |> Seq.map (fun (name, data) ->
+                    let data =
+                        data
+                        |> Seq.minBy (fun data -> data.InstalledVersion.Minor, data.InstalledVersion.Build)
+
+                    name, data.Installed
+                )
+                // TODO: how do we select between many available frameworks?
+                |> Seq.tryHead
+
+            match available with
+            | Some (_, f) -> Some (Choice1Of2 f)
+            | None ->
+                // TODO: maybe we can ask the SDK. But we keep on trucking: maybe we're self-contained,
+                // and we'll actually find all the runtime next to the DLL.
+                None
+        | _ -> failwith "non-minor RollForward not supported yet; please shout if you want it"
+
+    /// Given an executable DLL, locate the .NET runtime that can best run it.
+    let locate (dll : FileInfo) : DirectoryInfo list =
+        let runtimeConfig =
+            let name =
+                if not (dll.Name.EndsWith (".dll", StringComparison.OrdinalIgnoreCase)) then
+                    failwith $"Expected DLL %s{dll.FullName} to end in .dll"
+
+                dll.Name.Substring (0, dll.Name.Length - 4)
+
+            Path.Combine (dll.Directory.FullName, $"%s{name}.runtimeconfig.json")
+            |> File.ReadAllText
+            |> System.Text.Json.Nodes.JsonNode.Parse
+            |> RuntimeConfig.jsonParse
+            |> fun f -> f.RuntimeOptions
+
+        let availableRuntimes = DotnetEnvironmentInfo.Get ()
+
+        let runtime = selectRuntime runtimeConfig availableRuntimes
+
+        match runtime with
+        | None ->
+            // Keep on trucking: let's be optimistic and hope that we're self-contained.
+            [ dll.Directory ]
+        | Some (Choice1Of2 runtime) -> [ dll.Directory ; DirectoryInfo $"%s{runtime.Path}/%s{runtime.Version}" ]
+        | Some (Choice2Of2 sdk) -> [ dll.Directory ; DirectoryInfo sdk.Path ]

WoofWare.Whippet.App/WoofWare.Whippet.App.fsproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="RuntimeConfig.fs" />
+        <Compile Include="RuntimeConfigGen.fs" />
+        <Compile Include="AppContext.fs" />
+        <Compile Include="RuntimeLocator.fs" />
+        <Compile Include="Context.fs" />
+        <Compile Include="Program.fs" />
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="WoofWare.DotnetRuntimeLocator" Version="0.1.9" />
+        <PackageReference Include="Ionide.ProjInfo" Version="0.67.0" PrivateAssets="compile" />
+        <PackageReference Include="Microsoft.Build.Framework" Version="17.2.0" ExcludeAssets="runtime" PrivateAssets="all" />
+        <PackageReference Include="NuGet.Frameworks" Version="6.11.1" ExcludeAssets="runtime" PrivateAssets="all" />
+    </ItemGroup>
+    <ItemGroup>
+      <ProjectReference Include="..\WoofWare.Whippet.Core\WoofWare.Whippet.Core.fsproj" />
+    </ItemGroup>
+
+</Project>

WoofWare.Whippet.Core/Domain.fs

@@ -1,5 +1,7 @@
 namespace WoofWare.Whippet.Core
 
+open System.Collections.Generic
+
 (*
 These types should take no dependencies and should only change additively; otherwise consumers will break!
 *)
@@ -18,6 +20,8 @@ type RawSourceGenerationArgs =
         FilePath : string
         /// Contents of the file; you might want to `System.Text.Encoding.UTF8.GetString` this.
         FileContents : byte[]
+        /// Extra parameters as supplied through the project file with <Whippet{ParamName}>{ParamValue}</Whippet{ParamName}>.
+        Parameters : IReadOnlyDictionary<string, string>
     }
 
 /// We provide this interface as a helper to give you compile-time safety, but you don't have to use it.

WoofWare.Whippet.Core/SurfaceBaseline.txt

@@ -1,11 +1,13 @@
 WoofWare.Whippet.Core.IGenerateRawFromRaw - interface with 1 member(s)
 WoofWare.Whippet.Core.IGenerateRawFromRaw.GenerateRawFromRaw [method]: WoofWare.Whippet.Core.RawSourceGenerationArgs -> string
-WoofWare.Whippet.Core.RawSourceGenerationArgs inherit obj, implements WoofWare.Whippet.Core.RawSourceGenerationArgs System.IEquatable, System.Collections.IStructuralEquatable, WoofWare.Whippet.Core.RawSourceGenerationArgs System.IComparable, System.IComparable, System.Collections.IStructuralComparable
+WoofWare.Whippet.Core.RawSourceGenerationArgs inherit obj, implements WoofWare.Whippet.Core.RawSourceGenerationArgs System.IEquatable, System.Collections.IStructuralEquatable
-WoofWare.Whippet.Core.RawSourceGenerationArgs..ctor [constructor]: (string, System.Byte [])
+WoofWare.Whippet.Core.RawSourceGenerationArgs..ctor [constructor]: (string, System.Byte [], System.Collections.Generic.IReadOnlyDictionary<string, string>)
 WoofWare.Whippet.Core.RawSourceGenerationArgs.Equals [method]: (WoofWare.Whippet.Core.RawSourceGenerationArgs, System.Collections.IEqualityComparer) -> bool
 WoofWare.Whippet.Core.RawSourceGenerationArgs.FileContents [property]: [read-only] System.Byte []
 WoofWare.Whippet.Core.RawSourceGenerationArgs.FilePath [property]: [read-only] string
 WoofWare.Whippet.Core.RawSourceGenerationArgs.get_FileContents [method]: unit -> System.Byte []
 WoofWare.Whippet.Core.RawSourceGenerationArgs.get_FilePath [method]: unit -> string
+WoofWare.Whippet.Core.RawSourceGenerationArgs.get_Parameters [method]: unit -> System.Collections.Generic.IReadOnlyDictionary<string, string>
+WoofWare.Whippet.Core.RawSourceGenerationArgs.Parameters [property]: [read-only] System.Collections.Generic.IReadOnlyDictionary<string, string>
 WoofWare.Whippet.Core.WhippetGeneratorAttribute inherit System.Attribute
 WoofWare.Whippet.Core.WhippetGeneratorAttribute..ctor [constructor]: unit

WoofWare.Whippet.Fantomas/Ast.fs

@@ -45,7 +45,8 @@ module Ast =
 
         let cfg = FormatConfig.Default
 
-        CodeFormatter.FormatASTAsync (parseTree, cfg) |> Async.RunSynchronously |> Some
+        let output = CodeFormatter.FormatASTAsync (parseTree, cfg) |> Async.RunSynchronously
+        Some output
 
     /// For each namespace in the AST, returns the types defined therein.
     let getTypes (ast : ParsedInput) : (LongIdent * SynTypeDefn list) list =

WoofWare.Whippet.Fantomas/Measure.fs

@@ -0,0 +1,26 @@
+namespace WoofWare.Whippet.Fantomas
+
+open Fantomas.FCS.Syntax
+
+/// Methods for manipulating units of measure.
+[<RequireQualifiedAccess>]
+module Measure =
+
+    /// Get the function that adds an arbitrary measure to the given fully-qualified type.
+    /// For example, ["System" ; "Single"] would result in `LanguagePrimitives.Float32WithMeasure`.
+    let getLanguagePrimitivesMeasure (typeName : LongIdent) : SynExpr =
+        match typeName |> List.map _.idText with
+        | [ "System" ; "Single" ] -> [ "LanguagePrimitives" ; "Float32WithMeasure" ]
+        | [ "System" ; "Double" ] -> [ "LanguagePrimitives" ; "FloatWithMeasure" ]
+        | [ "System" ; "Byte" ] -> [ "LanguagePrimitives" ; "ByteWithMeasure" ]
+        | [ "System" ; "SByte" ] -> [ "LanguagePrimitives" ; "SByteWithMeasure" ]
+        | [ "System" ; "Int16" ] -> [ "LanguagePrimitives" ; "Int16WithMeasure" ]
+        | [ "System" ; "Int32" ] -> [ "LanguagePrimitives" ; "Int32WithMeasure" ]
+        | [ "System" ; "Int64" ] -> [ "LanguagePrimitives" ; "Int64WithMeasure" ]
+        | [ "System" ; "UInt16" ] -> [ "LanguagePrimitives" ; "UInt16WithMeasure" ]
+        | [ "System" ; "UInt32" ] -> [ "LanguagePrimitives" ; "UInt32WithMeasure" ]
+        | [ "System" ; "UInt64" ] -> [ "LanguagePrimitives" ; "UInt64WithMeasure" ]
+        | l ->
+            let l = String.concat "." l
+            failwith $"unrecognised type for measure: %s{l}"
+        |> SynExpr.createLongIdent

WoofWare.Whippet.Fantomas/SurfaceBaseline.txt

@@ -66,6 +66,8 @@ WoofWare.Whippet.Fantomas.InterfaceType.Inherits [property]: [read-only] Fantoma
 WoofWare.Whippet.Fantomas.InterfaceType.Members [property]: [read-only] WoofWare.Whippet.Fantomas.MemberInfo list
 WoofWare.Whippet.Fantomas.InterfaceType.Name [property]: [read-only] Fantomas.FCS.Syntax.Ident list
 WoofWare.Whippet.Fantomas.InterfaceType.Properties [property]: [read-only] WoofWare.Whippet.Fantomas.PropertyInfo list
+WoofWare.Whippet.Fantomas.Measure inherit obj
+WoofWare.Whippet.Fantomas.Measure.getLanguagePrimitivesMeasure [static method]: Fantomas.FCS.Syntax.Ident list -> Fantomas.FCS.Syntax.SynExpr
 WoofWare.Whippet.Fantomas.MemberInfo inherit obj
 WoofWare.Whippet.Fantomas.MemberInfo..ctor [constructor]: (Fantomas.FCS.Syntax.SynType, Fantomas.FCS.Syntax.SynAccess option, WoofWare.Whippet.Fantomas.TupledArg list, Fantomas.FCS.Syntax.Ident, Fantomas.FCS.Syntax.SynAttribute list, Fantomas.FCS.Xml.PreXmlDoc option, bool, bool)
 WoofWare.Whippet.Fantomas.MemberInfo.Accessibility [property]: [read-only] Fantomas.FCS.Syntax.SynAccess option

WoofWare.Whippet.Fantomas/WoofWare.Whippet.Fantomas.fsproj

@@ -48,6 +48,7 @@
     <Compile Include="SynModuleOrNamespace.fs" />
     <Compile Include="AstHelper.fs" />
     <Compile Include="Ast.fs" />
+    <Compile Include="Measure.fs" />
     <None Include="README.md">
       <Pack>True</Pack>
       <PackagePath>/</PackagePath>

WoofWare.Whippet.Fantomas/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2",
+  "version": "0.3",
   "publicReleaseRefSpec": [
     "^refs/heads/main$"
   ],

WoofWare.Whippet.sln

@@ -10,6 +10,24 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Fantomas",
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Fantomas.Test", "WoofWare.Whippet.Fantomas.Test\WoofWare.Whippet.Fantomas.Test.fsproj", "{E220B17E-D608-43CB-B117-329BA240B13B}"
 EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.ArgParser", "Plugins\ArgParser\WoofWare.Whippet.Plugin.ArgParser\WoofWare.Whippet.Plugin.ArgParser.fsproj", "{C8165033-31E4-43A1-AE30-D2F2B1217374}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.ArgParser.Attributes", "Plugins\ArgParser\WoofWare.Whippet.Plugin.ArgParser.Attributes\WoofWare.Whippet.Plugin.ArgParser.Attributes.fsproj", "{6AD1F2B6-4E91-4587-AF93-7EABAE9D3203}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.ArgParser.Consumer", "Plugins\ArgParser\WoofWare.Whippet.Plugin.ArgParser.Consumer\WoofWare.Whippet.Plugin.ArgParser.Consumer.fsproj", "{7CD49A84-0B37-4CCC-BE5D-05BE828B5B97}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.ArgParser.Test", "Plugins\ArgParser\WoofWare.Whippet.Plugin.ArgParser\WoofWare.Whippet.Plugin.ArgParser.Test\WoofWare.Whippet.Plugin.ArgParser.Test.fsproj", "{DFF9FCEE-CD1A-450E-A71D-BD0CD267D5B4}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.Json", "Plugins\Json\WoofWare.Whippet.Plugin.Json\WoofWare.Whippet.Plugin.Json.fsproj", "{8164E85B-3E7F-4F0B-8E25-CFA67E189668}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.Json.Consumer", "Plugins\Json\WoofWare.Whippet.Plugin.Json.Consumer\WoofWare.Whippet.Plugin.Json.Consumer.fsproj", "{9DE5BA14-F8F8-4E3F-8C32-2A3439A906AC}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.Json.Test", "Plugins\Json\WoofWare.Whippet.Plugin.Json\WoofWare.Whippet.Plugin.Json.Test\WoofWare.Whippet.Plugin.Json.Test.fsproj", "{0BBF5FEB-0BC6-4EDA-94E8-44DCDFDBB1CF}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.Plugin.Json.Attributes", "Plugins\Json\WoofWare.Whippet.Plugin.Json.Attributes\WoofWare.Whippet.Plugin.Json.Attributes.fsproj", "{649938B1-9993-4422-A9D9-5075323833E3}"
+EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "WoofWare.Whippet.App", "WoofWare.Whippet.App\WoofWare.Whippet.App.fsproj", "{A2258153-1C1F-4B25-B49A-BCC8EA4A3278}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -36,5 +54,41 @@ Global
 		{E220B17E-D608-43CB-B117-329BA240B13B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E220B17E-D608-43CB-B117-329BA240B13B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E220B17E-D608-43CB-B117-329BA240B13B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C8165033-31E4-43A1-AE30-D2F2B1217374}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C8165033-31E4-43A1-AE30-D2F2B1217374}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C8165033-31E4-43A1-AE30-D2F2B1217374}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C8165033-31E4-43A1-AE30-D2F2B1217374}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6AD1F2B6-4E91-4587-AF93-7EABAE9D3203}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6AD1F2B6-4E91-4587-AF93-7EABAE9D3203}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6AD1F2B6-4E91-4587-AF93-7EABAE9D3203}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6AD1F2B6-4E91-4587-AF93-7EABAE9D3203}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7CD49A84-0B37-4CCC-BE5D-05BE828B5B97}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7CD49A84-0B37-4CCC-BE5D-05BE828B5B97}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7CD49A84-0B37-4CCC-BE5D-05BE828B5B97}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7CD49A84-0B37-4CCC-BE5D-05BE828B5B97}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DFF9FCEE-CD1A-450E-A71D-BD0CD267D5B4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DFF9FCEE-CD1A-450E-A71D-BD0CD267D5B4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DFF9FCEE-CD1A-450E-A71D-BD0CD267D5B4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DFF9FCEE-CD1A-450E-A71D-BD0CD267D5B4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8164E85B-3E7F-4F0B-8E25-CFA67E189668}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8164E85B-3E7F-4F0B-8E25-CFA67E189668}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8164E85B-3E7F-4F0B-8E25-CFA67E189668}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8164E85B-3E7F-4F0B-8E25-CFA67E189668}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9DE5BA14-F8F8-4E3F-8C32-2A3439A906AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9DE5BA14-F8F8-4E3F-8C32-2A3439A906AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9DE5BA14-F8F8-4E3F-8C32-2A3439A906AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9DE5BA14-F8F8-4E3F-8C32-2A3439A906AC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0BBF5FEB-0BC6-4EDA-94E8-44DCDFDBB1CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0BBF5FEB-0BC6-4EDA-94E8-44DCDFDBB1CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0BBF5FEB-0BC6-4EDA-94E8-44DCDFDBB1CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0BBF5FEB-0BC6-4EDA-94E8-44DCDFDBB1CF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{649938B1-9993-4422-A9D9-5075323833E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{649938B1-9993-4422-A9D9-5075323833E3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{649938B1-9993-4422-A9D9-5075323833E3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{649938B1-9993-4422-A9D9-5075323833E3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A2258153-1C1F-4B25-B49A-BCC8EA4A3278}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A2258153-1C1F-4B25-B49A-BCC8EA4A3278}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A2258153-1C1F-4B25-B49A-BCC8EA4A3278}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A2258153-1C1F-4B25-B49A-BCC8EA4A3278}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

WoofWare.Whippet/WoofWare.Whippet.fsproj

@@ -1,38 +1,44 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <OutputType>Exe</OutputType>
+      <OutputType>Library</OutputType>
-        <TargetFramework>net8.0</TargetFramework>
+      <TargetFramework>net8.0</TargetFramework>
-        <Authors>Patrick Stevens</Authors>
+      <Authors>Patrick Stevens</Authors>
-        <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
+      <Copyright>Copyright (c) Patrick Stevens 2024</Copyright>
-        <Description>A source generator for F#.</Description>
+      <Description>A source generator for F#.</Description>
-        <RepositoryType>git</RepositoryType>
+      <RepositoryType>git</RepositoryType>
-        <RepositoryUrl>https://github.com/Smaug123/WoofWare.Whippet</RepositoryUrl>
+      <RepositoryUrl>https://github.com/Smaug123/WoofWare.Whippet</RepositoryUrl>
-        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+      <PackageLicenseExpression>MIT</PackageLicenseExpression>
-        <PackageReadmeFile>README.md</PackageReadmeFile>
+      <PackageReadmeFile>README.md</PackageReadmeFile>
-        <PackageTags>fsharp;source-generator;source-gen</PackageTags>
+      <PackageTags>fsharp;source-generator;source-gen</PackageTags>
-        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+      <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-        <WarnOn>FS3559</WarnOn>
+      <WarnOn>FS3559</WarnOn>
-        <PackageId>WoofWare.Whippet</PackageId>
+      <PackageId>WoofWare.Whippet</PackageId>
+      <DevelopmentDependency>true</DevelopmentDependency>
+      <NoWarn>NU5118</NoWarn>
+      <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     </PropertyGroup>
 
     <ItemGroup>
-        <Compile Include="Program.fs"/>
         <None Include="../README.md">
             <Pack>True</Pack>
             <PackagePath>\</PackagePath>
         </None>
+      <Content Include="build\WoofWare.Whippet.targets" PackagePath="build" />
+      <EmbeddedResource Include="version.json" />
     </ItemGroup>
+  
     <ItemGroup>
-        <PackageReference Include="Ionide.ProjInfo" Version="0.67.0" />
+      <ProjectReference Include="..\WoofWare.Whippet.App\WoofWare.Whippet.App.fsproj" PrivateAssets="all" />
-        <PackageReference Include="Microsoft.Build.Framework" Version="17.2.0" ExcludeAssets="runtime" PrivateAssets="all" />
-        <PackageReference Include="NuGet.Frameworks" Version="6.11.1" ExcludeAssets="runtime" PrivateAssets="all" />
-    </ItemGroup>
-    <ItemGroup>
-      <ProjectReference Include="..\WoofWare.Whippet.Core\WoofWare.Whippet.Core.fsproj" />
-    </ItemGroup>
-    <ItemGroup>
-      <Content Include="version.json" />
     </ItemGroup>
 
+  <PropertyGroup>
+    <DependsOnTargets>Build;_CopyFilesMarkedCopyLocal</DependsOnTargets>
+  </PropertyGroup>
+
+  <Target Name="PackAfterWhippetBuild" AfterTargets="Build">
+    <ItemGroup>
+      <None Include="../WoofWare.Whippet.App/bin/$(Configuration)/$(TargetFramework)/*" Pack="true" PackagePath="tools/$(TargetFramework)/any/" />
+    </ItemGroup>
+  </Target>
 </Project>

WoofWare.Whippet/build/WoofWare.Whippet.targets

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!-- Define package reference metadata -->
+  <ItemDefinitionGroup>
+    <PackageReference>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemDefinitionGroup>
+
+  <!-- Properties to control the executable path -->
+  <PropertyGroup>
+    <SourceGeneratorExe>$(MSBuildThisFileDirectory)../tools/net8.0/any/WoofWare.Whippet.App.dll</SourceGeneratorExe>
+  </PropertyGroup>
+
+  <Target Name="GetWhippetPlugins"
+          DependsOnTargets="ResolvePackageAssets"
+          BeforeTargets="CoreCompile"
+          Condition="'$(DesignTimeBuild)' != 'true'">
+    <ItemGroup>
+      <!-- Filter to only WhippetPlugin=true references and get their resolved paths -->
+      <WhippetPlugin Include="@(ReferencePath)"
+                     Condition="'%(ReferencePath.NuGetPackageId)' != '' and
+                              '@(PackageReference->WithMetadataValue('Identity', '%(ReferencePath.NuGetPackageId)')->WithMetadataValue('WhippetPlugin', 'true'))' != ''">
+        <PluginName>%(ReferencePath.NuGetPackageId)</PluginName>
+      </WhippetPlugin>
+
+      <WhippetPlugin Include="@(ReferencePath)"
+                     Condition="'%(ReferencePath.ReferenceSourceTarget)' == 'ProjectReference' and
+                               '%(ReferencePath.WhippetPlugin)' == 'true'">
+        <PluginName>$([System.IO.Path]::GetFileNameWithoutExtension('%(ReferencePath.Filename)'))</PluginName>
+      </WhippetPlugin>
+
+      <!-- Create the properly formatted command line arguments -->
+      <WhippetPluginArgs Include="%(WhippetPlugin.PluginName)">
+        <Path>%(WhippetPlugin.FullPath)</Path>
+      </WhippetPluginArgs>
+    </ItemGroup>
+
+    <!-- Store all arguments in a property for the Exec task -->
+    <PropertyGroup>
+      <WhippetPluginCommandLine>@(WhippetPluginArgs->'"%(Path)"', ' ')</WhippetPluginCommandLine>
+    </PropertyGroup>
+
+    <!-- Execute the command -->
+    <Exec Command="&quot;$(MSBuildSDKsPath)/../../../dotnet&quot; exec &quot;$(SourceGeneratorExe)&quot; &quot;$(MSBuildProjectFullPath)&quot; $(WhippetPluginCommandLine)"
+          WorkingDirectory="$(MSBuildProjectDirectory)"
+          StandardOutputImportance="high" />
+  </Target>
+</Project>