Reject tagged types which claim the runtime-module prefix

The embedded runtime module is named ArgParserRuntime_<firstTaggedType>
and generated parser modules are named after their tagged types, so a
tagged type named ArgParserRuntime_Foo alongside a tagged type Foo
generated two modules with one name, which does not compile. The
prefix was already documented as reserved; enforce the reservation at
generation time for the names the untyped AST can see.

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

Author: Smaug123

WoofWare.Myriad.Plugins/ArgParserGenerator.fs

@@ -1855,6 +1855,18 @@ module internal ArgParserGenerator =
                 )
             )
 
+        // The runtime-module prefix is reserved: a tagged type named e.g. ArgParserRuntime_Foo
+        // would generate a parser module colliding with the runtime module emitted for a
+        // namespace whose first tagged type is Foo. Enforce the reservation where it is visible;
+        // collisions with *untagged* user declarations cannot be seen on the untyped AST, so for
+        // those the prefix is documented as reserved.
+        for _, (taggedType, _), _, _ in namespaceAndTypes do
+            let name = SynTypeDefn.getName taggedType |> List.last |> _.idText
+
+            if name.StartsWith ("ArgParserRuntime_", StringComparison.Ordinal) then
+                failwith
+                    $"Type names beginning 'ArgParserRuntime_' are reserved: the ArgParser generator emits its runtime module under that prefix alongside the generated parsers. Rename the [<ArgParser>] type '%s{name}'."
+
         // Each namespace containing a generated parser gets one embedded runtime module,
         // named after the first [<ArgParser>] type in that namespace (see
         // ArgParserRuntimeEmbed.moduleName for why that cannot collide).

WoofWare.Myriad.Plugins/ArgParserRuntimeEmbed.fs

@@ -54,5 +54,7 @@ module internal ArgParserRuntimeEmbed =
     /// parser is being generated there. That type's name is necessarily unique across the
     /// project's input files (two files defining the same type in one namespace would fail to
     /// compile anyway), unlike e.g. the input file's base name, so runtime modules emitted into
-    /// the same namespace from different generated files cannot collide.
+    /// the same namespace from different generated files cannot collide. Nor can the result
+    /// collide with a generated *parser* module (which is named after its tagged type): the
+    /// generator rejects tagged types whose names begin with this prefix.
     let moduleName (taggedTypeName : string) : string = "ArgParserRuntime_" + taggedTypeName

WoofWare.Myriad.Plugins/Test/TestArgParserRejection.fs

@@ -238,6 +238,31 @@ type Args =
         |> shouldRejectWith
             "Invalid argument name 'foo=bar' for field 'A': a --key=value token splits at its first '=', so this argument could never be addressed."
 
+    [<Test>]
+    let ``Tagged type names may not claim the reserved runtime-module prefix`` () =
+        // The generator emits one runtime module per namespace, named
+        // ArgParserRuntime_<firstTaggedType>; a tagged type named ArgParserRuntime_Foo alongside
+        // a tagged type Foo would therefore generate two modules with the same name, which does
+        // not compile. The prefix is documented as reserved; enforce it where we can see it.
+        """namespace TestMe
+
+open WoofWare.Myriad.Plugins
+
+[<ArgParser>]
+type Foo =
+    {
+        A : int
+    }
+
+[<ArgParser>]
+type ArgParserRuntime_Foo =
+    {
+        B : int
+    }
+"""
+        |> shouldRejectWith
+            "Type names beginning 'ArgParserRuntime_' are reserved: the ArgParser generator emits its runtime module under that prefix alongside the generated parsers. Rename the [<ArgParser>] type 'ArgParserRuntime_Foo'."
+
     [<Test>]
     let ``The reserved name help cannot be claimed, in any casing`` () =
         """namespace TestMe