Allocate anonymous type names from an occupied-name set

Seeding the anonymous-name counter to the largest spec-defined Type{N}
overflows on a valid schema named Type2147483647: the next
Interlocked.Increment wraps to Int32.MinValue and produces a type
declared (sanitised) as Type2147483648 but referenced as
Type-2147483648, failing with FS0010. Instead of seeding, the allocator
now skips over a set of taken (sanitised) definition/response names, so
no name can push the counter anywhere near overflow.

The ConsumePlugin regression spec now also defines Type2147483647
(structurally distinct from Type1, since identical shapes are collapsed
into one generated type), so both the collision and the overflow fail
the build if reintroduced.

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

Author: Smaug123

ConsumePlugin/GeneratedSwaggerAnonymousTypes.fs

@@ -23,6 +23,15 @@ type Type1 =
         Name : string option
     }
 
+[<JsonParse true ; JsonSerialize true>]
+type Type2147483647 =
+    {
+        [<System.Text.Json.Serialization.JsonExtensionData>]
+        AdditionalProperties : System.Collections.Generic.Dictionary<string, System.Text.Json.Nodes.JsonNode>
+        [<System.Text.Json.Serialization.JsonPropertyName "wouldOverflowASeededCounter">]
+        WouldOverflowASeededCounter : string option
+    }
+
 [<JsonParse true ; JsonSerialize true>]
 type Type2 =
     {

ConsumePlugin/swagger-anonymous-types.json

@@ -50,6 +50,14 @@
                     "type": "string"
                 }
             }
+        },
+        "Type2147483647": {
+            "type": "object",
+            "properties": {
+                "wouldOverflowASeededCounter": {
+                    "type": "string"
+                }
+            }
         }
     },
     "responses": {}

WoofWare.Myriad.Plugins/SwaggerClientGenerator.fs

@@ -69,9 +69,10 @@ module internal SwaggerClientGenerator =
         | SwaggerV2.Definition.File -> SynType.createLongIdent' [ "System" ; "IO" ; "Stream" ] |> Some
 
     /// Returns None if we lacked the information required to do this.
+    /// nextAnonymousTypeName must return a fresh unused type name on each call.
     /// bigCache is a map of e.g. {"securityDefinition": {Defn : F# type}}.
     let rec defnToType
-        (anonymousTypeCount : int ref)
+        (nextAnonymousTypeName : unit -> string)
         (handlesMap : Dictionary<string, TypeEntry>)
         (bigCache : Dictionary<string, Dictionary<SwaggerV2.Definition, TypeEntry>>)
         (thisKey : string)
@@ -154,7 +155,7 @@ module internal SwaggerClientGenerator =
                             |> Some
                         | None ->
 
-                        let defn' = defnToType anonymousTypeCount handlesMap bigCache thisKey None defn
+                        let defn' = defnToType nextAnonymousTypeName handlesMap bigCache thisKey None defn
 
                         match defn' with
                         | None -> None
@@ -200,7 +201,7 @@ module internal SwaggerClientGenerator =
                         |> Some
                     | Some SwaggerV2.AdditionalProperties.Never -> Some []
                     | Some (SwaggerV2.AdditionalProperties.Constrained defn) ->
-                        let defn' = defnToType anonymousTypeCount handlesMap bigCache thisKey None defn
+                        let defn' = defnToType nextAnonymousTypeName handlesMap bigCache thisKey None defn
 
                         match defn' with
                         | None -> None
@@ -234,7 +235,7 @@ module internal SwaggerClientGenerator =
 
                 let fSharpTypeName =
                     match typeName with
-                    | None -> $"Type%i{Interlocked.Increment anonymousTypeCount}"
+                    | None -> nextAnonymousTypeName ()
                     | Some typeName -> typeName
 
                 let properties = additionalProperties @ namedProperties
@@ -278,7 +279,8 @@ module internal SwaggerClientGenerator =
                 defn |> Some
 
             | SwaggerV2.Definition.Array elt ->
-                let child = defnToType anonymousTypeCount handlesMap bigCache thisKey None elt.Items
+                let child =
+                    defnToType nextAnonymousTypeName handlesMap bigCache thisKey None elt.Items
 
                 match child with
                 | None -> None
@@ -540,35 +542,36 @@ module internal SwaggerV2Generator =
                 (0, bigCache) ||> Seq.fold (fun count (KeyValue (_, v)) -> count + v.Count)
 
             let byHandle = Dictionary ()
-            let anonymousTypeCount = ref 0
 
             // A spec is free to define types whose (sanitised) names look like the
-            // "Type{N}" names we invent for anonymous inline schemas; start counting
-            // past any such name so we never collide with them.
-            let namedTypes =
-                seq {
-                    for KeyValue (k, _) in contents.Definitions do
-                        yield k
-
-                    for KeyValue (k, _) in contents.Responses do
-                        yield k
-                }
+            // "Type{N}" names we invent for anonymous inline schemas (including
+            // pathological ones like "Type2147483647", which would overflow a
+            // seeded counter); skip over any name that's already taken.
+            let takenNames = HashSet<string> ()
+
+            for KeyValue (k, _) in contents.Definitions do
+                takenNames.Add (Ident.createSanitisedTypeName k).idText |> ignore<bool>
+
+            for KeyValue (k, _) in contents.Responses do
+                takenNames.Add (Ident.createSanitisedTypeName k).idText |> ignore<bool>
+
+            let anonymousTypeCount = ref 0
+
+            let nextAnonymousTypeName () : string =
+                let mutable candidate = $"Type%i{Interlocked.Increment anonymousTypeCount}"
 
-            for name in namedTypes do
-                let name = (Ident.createSanitisedTypeName name).idText
+                while takenNames.Contains candidate do
+                    candidate <- $"Type%i{Interlocked.Increment anonymousTypeCount}"
 
-                if name.StartsWith ("Type", System.StringComparison.Ordinal) then
-                    match System.Int32.TryParse (name.Substring "Type".Length) with
-                    | true, n -> anonymousTypeCount.Value <- max anonymousTypeCount.Value n
-                    | false, _ -> ()
+                candidate
 
             let rec go (contents : ((string option * SwaggerV2.Definition) * string) list) =
                 let lastRound = countAll ()
 
                 contents
                 |> List.filter (fun ((name, defn), defnClass) ->
                     let doIt =
-                        SwaggerClientGenerator.defnToType anonymousTypeCount byHandle bigCache defnClass name defn
+                        SwaggerClientGenerator.defnToType nextAnonymousTypeName byHandle bigCache defnClass name defn
 
                     match doIt with
                     | None -> true