Use exactly the scanner's equality in schema validation

ToUpperInvariant keying is strictly coarser than OrdinalIgnoreCase (the
equality the scanner matches keys with): "s" and "ſ" uppercase to the
same string but are distinct keys, so the checked constructor falsely
rejected schemas the scanner routes unambiguously. Group claims with
StringComparer.OrdinalIgnoreCase instead.

Also reject forms no token can ever address: an empty form (its token
is the positional separator) and forms containing '=' (a --key=value
token splits at its first '='), either of which could otherwise leave a
required argument, or a whole union case, permanently unsatisfiable.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Smaug123

WoofWare.Myriad.Plugins.Test/TestArgParser/TestArgParserRuntime.fs

@@ -1325,3 +1325,57 @@ module TestArgParserRuntime =
 
         let config = Config.QuickThrowOnFailure.WithMaxTest 500
         Check.One (config, Prop.forAll (Arb.fromGen cases) property)
+
+    [<Test>]
+    let ``Collision detection uses exactly the scanner's equality`` () =
+        // "s" and "ſ" (long s) uppercase to the same string, but OrdinalIgnoreCase — the equality
+        // the scanner matches keys with — considers them distinct. A coarser normalisation (e.g.
+        // ToUpperInvariant keying) would falsely reject this schema even though the scanner
+        // routes its tokens unambiguously.
+        let schema =
+            productSchema
+                [
+                    leaf 0 "s" ErasedArity.One ErasedRequirement.Required
+                    leaf 1 "ſ" ErasedArity.One ErasedRequirement.Required
+                ]
+                None
+
+        // The scanner really does distinguish them.
+        scan schema [ "--s=1" ] |> shouldEqual [ occ 0 (Some "1") false "--s=1" ]
+        scan schema [ "--ſ=1" ] |> shouldEqual [ occ 1 (Some "1") false "--ſ=1" ]
+
+        WellFormedSchema.errors schema |> shouldEqual []
+
+    [<Test>]
+    let ``An empty form is rejected: its token would be the separator`` () =
+        let bad =
+            { leaf 0 "a" ErasedArity.One ErasedRequirement.Required with
+                Forms = [ "" ]
+            }
+
+        WellFormedSchema.errors (productSchema [ bad ] None)
+        |> shouldEqual [ SchemaError.EmptyForm "argument id 0" ]
+
+    [<Test>]
+    let ``A form containing an equals sign is rejected: the scanner splits at the first equals`` () =
+        // A required argument under such a form would make its schema (or its union case)
+        // permanently unsatisfiable, while still passing every name-collision check.
+        let bad =
+            { leaf 0 "a" ErasedArity.One ErasedRequirement.Required with
+                Forms = [ "foo=bar" ]
+            }
+
+        WellFormedSchema.errors (productSchema [ bad ] None)
+        |> shouldEqual [ SchemaError.FormContainsEquals ("argument id 0", "foo=bar") ]
+
+        let badSink =
+            {
+                Id = 99
+                Forms = [ "rest=stuff" ]
+                FlagLike = ErasedFlagLikeBehaviour.Reject
+                TypeDescription = "string"
+                Help = None
+            }
+
+        WellFormedSchema.errors (productSchema [ leaf 0 "a" ErasedArity.One ErasedRequirement.Required ] (Some badSink))
+        |> shouldEqual [ SchemaError.FormContainsEquals ("the positional-args sink", "rest=stuff") ]

WoofWare.Myriad.Plugins/ArgParserRuntime.fs

@@ -608,6 +608,13 @@ module internal ArgParserRuntime =
         | NoForms of leafId : int
         /// A leaf accepts `--no-` negation but is not boolean-like.
         | NegationOnNonBool of leafId : int
+        /// A form is the empty string: its token would be `--`, which the scanner always
+        /// treats as the positional separator, so the argument could never be addressed.
+        | EmptyForm of claimant : string
+        /// A form contains an equals sign: the scanner splits a `--key=value` token at its
+        /// *first* `=`, so such a form can never match. An argument required under such a form
+        /// makes the schema (or a union case of it) permanently unsatisfiable.
+        | FormContainsEquals of claimant : string * form : string
         /// Two distinct claimants respond to the same `--token` under the scanner's
         /// case-insensitive matching (so e.g. forms `foo` and `FOO` collide, as do a literal
         /// form `no-foo` and the negated variant of a negatable `foo`). The token is reported
@@ -631,6 +638,13 @@ module internal ArgParserRuntime =
             | SchemaError.NoForms leafId -> sprintf "argument id %i has no names" leafId
             | SchemaError.NegationOnNonBool leafId ->
                 sprintf "argument id %i accepts --no- negation but is not boolean-like" leafId
+            | SchemaError.EmptyForm claimant ->
+                sprintf "%s has an empty name: its token would be '--', which is the positional separator" claimant
+            | SchemaError.FormContainsEquals (claimant, form) ->
+                sprintf
+                    "%s has the name '%s', which contains '='; a --key=value token splits at its first '=', so this argument could never be addressed"
+                    claimant
+                    form
             | SchemaError.TokenCollision (token, claimants) ->
                 sprintf
                     "the token '%s' is claimed by: %s (argument names are matched case-insensitively)"
@@ -736,14 +750,66 @@ module internal ArgParserRuntime =
                 )
                 @ [ "--help", "the built-in help flag" ]
 
+            // Group under the scanner's own equality (OrdinalIgnoreCase), preserving
+            // declaration order. This is deliberately not ToUpperInvariant keying, which is a
+            // strictly coarser relation: e.g. "s" and "ſ" (long s) uppercase to the same string,
+            // but the scanner considers them distinct, so they do not collide.
             let collisions =
-                claims
-                |> List.groupBy (fun (token, _) -> token.ToUpperInvariant ())
-                |> List.choose (fun (_, group) ->
-                    match group with
-                    | []
-                    | [ _ ] -> None
-                    | (token, _) :: _ -> Some (SchemaError.TokenCollision (token, group |> List.map snd))
+                let indexOf =
+                    System.Collections.Generic.Dictionary<string, int> (StringComparer.OrdinalIgnoreCase)
+
+                let buckets = ResizeArray<ResizeArray<string * string>> ()
+
+                for token, claimant in claims do
+                    match indexOf.TryGetValue token with
+                    | true, index -> buckets.[index].Add ((token, claimant))
+                    | false, _ ->
+                        indexOf.[token] <- buckets.Count
+                        let bucket = ResizeArray ()
+                        bucket.Add ((token, claimant))
+                        buckets.Add bucket
+
+                buckets
+                |> Seq.choose (fun bucket ->
+                    if bucket.Count < 2 then
+                        None
+                    else
+                        let token, _ = bucket.[0]
+                        Some (SchemaError.TokenCollision (token, bucket |> Seq.map snd |> List.ofSeq))
+                )
+                |> List.ofSeq
+
+            // Forms which no token could ever address, because of how the scanner tokenises.
+            let unaddressable =
+                (schema.Leaves
+                 |> List.collect (fun leaf ->
+                     let claimant = sprintf "argument id %i" leaf.Id
+
+                     leaf.Forms
+                     |> List.collect (fun form ->
+                         if form = "" then
+                             [ SchemaError.EmptyForm claimant ]
+                         elif form.Contains "=" then
+                             [ SchemaError.FormContainsEquals (claimant, form) ]
+                         else
+                             []
+                     )
+                 ))
+                @ (
+                    match schema.Positional with
+                    | None -> []
+                    | Some positional ->
+                        let claimant = "the positional-args sink"
+
+                        positional.Forms
+                        |> List.collect (fun form ->
+                            if form = "" then
+                                [ SchemaError.EmptyForm claimant ]
+                            elif form.Contains "=" then
+                                [ SchemaError.FormContainsEquals (claimant, form) ]
+                            else
+                                []
+                        )
                 )
 
             duplicateLeafIds
@@ -753,6 +819,7 @@ module internal ArgParserRuntime =
             @ duplicateSumIds
             @ noForms
             @ negationOnNonBool
+            @ unaddressable
             @ collisions
 
         /// Check the invariants which the scanning and selection semantics rely on.