[Repo Assist] perf: reduce DLL-emit time for large schemas (shared ToString helper + Dictionary lookup) (#356)

* perf: reduce DLL-emit time for large schemas via reflection-based ToString() and Dictionary lookup

- Replace O(N) embedded-field-values ToString() with O(1) reflection-based implementation
  in both v2 and v3 DefinitionCompiler. For a type with N properties, the old approach
  embedded N string constants (property names) and N field-get expressions into the
  generated method body IL. For schemas with hundreds of types (e.g. Stripe API, #150),
  this significantly inflated the IL emitted in ProvidedTypes.fs phase 3 (emit member code).
  The new approach generates a fixed-size method body that discovers property names at
  runtime via reflection — same output format, much less IL to emit.

- Change pathToSchema / definitionToSchemaObject from F# Map (O(log n) lookup) to
  Dictionary (O(1) lookup) for consistency with pathToType / definitionToType, which
  already used Dictionary.

All 261 unit tests pass.

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

* ci: trigger checks

* fix: correct FS3033 type-mismatch in ToString invokeCode; add regression tests

Agent-Logs-Url: https://github.com/fsprojects/SwaggerProvider/sessions/27fbd8a4-857d-462a-9ab0-33eae4d62d93

Co-authored-by: sergey-tihon <1197905+sergey-tihon@users.noreply.github.com>

* fix: deterministic precompile order and stable ToString output (DeclaredOnly + sort by Name)

Agent-Logs-Url: https://github.com/fsprojects/SwaggerProvider/sessions/19676c20-b619-48b3-85bf-b5311d34e3cb

Co-authored-by: sergey-tihon <1197905+sergey-tihon@users.noreply.github.com>

* refactor: move ToString impl to shared RuntimeHelpers.formatObject with property cache

Agent-Logs-Url: https://github.com/fsprojects/SwaggerProvider/sessions/7cca4988-6729-451d-ba87-60703f84f0d8

Co-authored-by: sergey-tihon <1197905+sergey-tihon@users.noreply.github.com>

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: sergey-tihon <1197905+sergey-tihon@users.noreply.github.com>

Author: 4 people

src/SwaggerProvider.DesignTime/v2/DefinitionCompiler.fs

@@ -151,7 +151,14 @@ and NamespaceAbstraction(name: string) =
 
 /// Object for compiling definitions.
 type DefinitionCompiler(schema: SwaggerObject, provideNullable, useDateOnly: bool) as this =
-    let definitionToSchemaObject = Map.ofSeq schema.Definitions
+    let definitionToSchemaObject =
+        let dict = Collections.Generic.Dictionary<string, SchemaObject>()
+
+        for name, schemaObj in schema.Definitions do
+            dict.Add(name, schemaObj)
+
+        dict
+
     let definitionToType = Collections.Generic.Dictionary<_, _>()
     let nsRoot = NamespaceAbstraction("Root")
     let nsOps = nsRoot.GetOrCreateNamespace "OperationTypes"
@@ -196,14 +203,14 @@ type DefinitionCompiler(schema: SwaggerObject, provideNullable, useDateOnly: boo
         match definitionToType.TryGetValue tyDefName with
         | true, ty -> ty :> Type
         | false, _ ->
-            match definitionToSchemaObject.TryFind tyDefName with
-            | Some(def) ->
+            match definitionToSchemaObject.TryGetValue tyDefName with
+            | true, def ->
                 let ns, tyName = tyDefName |> DefinitionPath.Parse |> nsRoot.Resolve
                 let ty = compileSchemaObject ns tyName def true (registerInNsAndInDef tyDefName ns)
                 ty :> Type
-            | None when tyDefName.StartsWith("#/definitions/") ->
+            | false, _ when tyDefName.StartsWith("#/definitions/") ->
                 failwithf $"Cannot find definition '%s{tyDefName}' in schema definitions %A{definitionToType.Keys |> Seq.toArray}"
-            | None -> failwithf $"Cannot find definition '%s{tyDefName}' (references to relative documents are not supported yet)"
+            | _ -> failwithf $"Cannot find definition '%s{tyDefName}' (references to relative documents are not supported yet)"
 
     and compileSchemaObject (ns: NamespaceAbstraction) tyName (schemaObj: SchemaObject) isRequired registerNew =
         let compileNewObject(properties: DefinitionProperty[]) =
@@ -283,6 +290,8 @@ type DefinitionCompiler(schema: SwaggerObject, provideNullable, useDateOnly: boo
                 )
 
                 // Override `.ToString()`
+                // Delegates to the shared RuntimeHelpers.formatObject helper so that
+                // each generated type's method body is a single static call (O(1) IL).
                 let toStr =
                     ProvidedMethod(
                         "ToString",
@@ -292,39 +301,8 @@ type DefinitionCompiler(schema: SwaggerObject, provideNullable, useDateOnly: boo
                         invokeCode =
                             fun args ->
                                 let this = args[0]
-
-                                let pNames, pValues =
-                                    Array.ofList members
-                                    |> Array.map(fun (pField, pProp) ->
-                                        let pValObj = Expr.FieldGet(this, pField)
-                                        pProp.Name, Expr.Coerce(pValObj, typeof<obj>))
-                                    |> Array.unzip
-
-                                let pValuesArr = Expr.NewArray(typeof<obj>, List.ofArray pValues)
-
-                                <@@
-                                    let values = (%%pValuesArr: array<obj>)
-
-                                    let rec formatValue(v: obj) =
-                                        if isNull v then
-                                            "null"
-                                        else
-                                            let vTy = v.GetType()
-
-                                            if vTy = typeof<string> then
-                                                String.Format("\"{0}\"", v)
-                                            elif vTy.IsArray then
-                                                let elements = (v :?> seq<_>) |> Seq.map formatValue
-                                                String.Format("[{0}]", String.Join("; ", elements))
-                                            else
-                                                v.ToString()
-
-                                    let strs =
-                                        values
-                                        |> Array.mapi(fun i v -> String.Format("{0}={1}", pNames[i], formatValue v))
-
-                                    String.Format("{{{0}}}", String.Join("; ", strs))
-                                @@>
+                                let thisObj = Expr.Coerce(this, typeof<obj>)
+                                <@@ RuntimeHelpers.formatObject(%%thisObj: obj) @@>
                     )
 
                 toStr.SetMethodAttrs(MethodAttributes.Public ||| MethodAttributes.Virtual)

src/SwaggerProvider.DesignTime/v3/DefinitionCompiler.fs

@@ -167,12 +167,13 @@ and NamespaceAbstraction(name: string) =
 /// Object for compiling definitions.
 type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: bool) as this =
     let pathToSchema =
-        if isNull schema.Components then
-            Map.empty
-        else
-            schema.Components.Schemas
-            |> Seq.map(fun kv -> DefinitionPath.DefinitionPrefix + kv.Key, kv.Value)
-            |> Map.ofSeq
+        let dict = Collections.Generic.Dictionary<string, IOpenApiSchema>()
+
+        if not(isNull schema.Components) then
+            for kv in schema.Components.Schemas do
+                dict.Add(DefinitionPath.DefinitionPrefix + kv.Key, kv.Value)
+
+        dict
 
     let pathToType = Collections.Generic.Dictionary<_, Type>()
     let nsRoot = NamespaceAbstraction "Root"
@@ -220,14 +221,14 @@ type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: b
         match pathToType.TryGetValue tyPath with
         | true, ty -> ty
         | false, _ ->
-            match pathToSchema.TryFind tyPath with
-            | Some def ->
+            match pathToSchema.TryGetValue tyPath with
+            | true, def ->
                 let ns, tyName = tyPath |> DefinitionPath.Parse |> nsRoot.Resolve
                 let ty = compileBySchema ns tyName def true (registerInNsAndInDef tyPath ns) true
                 ty :> Type
-            | None when tyPath.StartsWith DefinitionPath.DefinitionPrefix ->
+            | false, _ when tyPath.StartsWith DefinitionPath.DefinitionPrefix ->
                 failwithf $"Cannot find definition '%s{tyPath}' in schema definitions %A{pathToType.Keys |> Seq.toArray}"
-            | None -> failwithf $"Cannot find definition '%s{tyPath}' (references to relative documents are not supported yet)"
+            | _ -> failwithf $"Cannot find definition '%s{tyPath}' (references to relative documents are not supported yet)"
 
     and compileBySchema (ns: NamespaceAbstraction) tyName (schemaObj: IOpenApiSchema) isRequired registerNew fromByPathCompiler =
         let compileNewObject() =
@@ -385,6 +386,8 @@ type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: b
                 )
 
                 // Override `.ToString()`
+                // Delegates to the shared RuntimeHelpers.formatObject helper so that
+                // each generated type's method body is a single static call (O(1) IL).
                 let toStr =
                     ProvidedMethod(
                         "ToString",
@@ -394,39 +397,8 @@ type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: b
                         invokeCode =
                             fun args ->
                                 let this = args[0]
-
-                                let pNames, pValues =
-                                    Array.ofList members
-                                    |> Array.map(fun (pField, pProp) ->
-                                        let pValObj = Expr.FieldGet(this, pField)
-                                        pProp.Name, Expr.Coerce(pValObj, typeof<obj>))
-                                    |> Array.unzip
-
-                                let pValuesArr = Expr.NewArray(typeof<obj>, List.ofArray pValues)
-
-                                <@@
-                                    let values = %%pValuesArr: array<obj>
-
-                                    let rec formatValue(v: obj) =
-                                        if isNull v then
-                                            "null"
-                                        else
-                                            let vTy = v.GetType()
-
-                                            if vTy = typeof<string> then
-                                                String.Format("\"{0}\"", v)
-                                            elif vTy.IsArray then
-                                                let elements = (v :?> seq<_>) |> Seq.map formatValue
-                                                String.Format("[{0}]", String.Join("; ", elements))
-                                            else
-                                                v.ToString()
-
-                                    let strs =
-                                        values
-                                        |> Array.mapi(fun i v -> String.Format("{0}={1}", pNames[i], formatValue v))
-
-                                    String.Format("{{{0}}}", String.Join("; ", strs))
-                                @@>
+                                let thisObj = Expr.Coerce(this, typeof<obj>)
+                                <@@ RuntimeHelpers.formatObject(%%thisObj: obj) @@>
                     )
 
                 toStr.SetMethodAttrs(MethodAttributes.Public ||| MethodAttributes.Virtual)
@@ -570,7 +542,10 @@ type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: b
             tyType
 
     // Precompile types defined in the `definitions` part of the schema
-    do pathToSchema |> Seq.iter(fun kv -> compileByPath kv.Key |> ignore)
+    do
+        pathToSchema.Keys
+        |> Seq.sort
+        |> Seq.iter(fun key -> compileByPath key |> ignore)
 
     /// Namespace that represent provided type space
     member _.Namespace = nsRoot

src/SwaggerProvider.Runtime/RuntimeHelpers.fs

@@ -137,6 +137,57 @@ module RuntimeHelpers =
             | :? Option<Guid> as x -> x |> toStrOpt name
             | _ -> [ name, obj.ToString() ]
 
+    /// Cache of sorted declared public instance properties per type, to avoid repeated
+    /// reflection and sorting overhead when formatObject is called frequently.
+    let private propCache =
+        Collections.Concurrent.ConcurrentDictionary<Type, Reflection.PropertyInfo[]>()
+
+    let private getProperties(t: Type) =
+        propCache.GetOrAdd(
+            t,
+            fun ty ->
+                ty.GetProperties(
+                    Reflection.BindingFlags.Public
+                    ||| Reflection.BindingFlags.Instance
+                    ||| Reflection.BindingFlags.DeclaredOnly
+                )
+                |> Array.sortBy(fun p -> p.Name)
+        )
+
+    /// Formats a generated API object as a string in the form `{Prop1=value1; Prop2=value2}`.
+    /// Only declared public instance properties are included, sorted alphabetically by name.
+    /// Used by the emitted ToString() override to keep the generated method body O(1) in size.
+    let formatObject(obj: obj) : string =
+        let props = getProperties(obj.GetType())
+
+        let strs =
+            props
+            |> Array.map(fun p ->
+                let v = p.GetValue(obj)
+
+                let s =
+                    if isNull v then
+                        "null"
+                    else
+                        let vTy = v.GetType()
+
+                        if vTy = typeof<string> then
+                            String.Format("\"{0}\"", v)
+                        elif vTy.IsArray then
+                            let elements =
+                                (v :?> Array)
+                                |> Seq.cast<obj>
+                                |> Seq.map(fun x -> if isNull x then "null" else x.ToString())
+                                |> Array.ofSeq
+
+                            String.Format("[{0}]", String.Join("; ", elements))
+                        else
+                            v.ToString()
+
+                String.Format("{0}={1}", p.Name, s))
+
+        String.Format("{{{0}}}", String.Join("; ", strs))
+
     let getPropertyNameAttribute name =
         { new Reflection.CustomAttributeData() with
             member _.Constructor =

tests/SwaggerProvider.Tests/v3/Schema.V2SchemaCompilationTests.fs

@@ -8,6 +8,8 @@ module SwaggerProvider.Tests.v3_Schema_V2SchemaCompilationTests
 /// OpenApiClientProvider to become the single supported provider for v2 and v3.
 
 open System
+open System.Reflection
+open Microsoft.FSharp.Quotations
 open Microsoft.OpenApi.Reader
 open SwaggerProvider.Internal.v3.Compilers
 open Xunit
@@ -182,3 +184,59 @@ let ``v2 schema with integer enum property compiles``() =
     let codeProp = getProp statusType "Code"
     // integer enum — Microsoft.OpenApi maps this to the integer base type
     codeProp.PropertyType |> shouldEqual typeof<int32>
+
+// ── ToString tests ───────────────────────────────────────────────────────────
+
+[<Fact>]
+let ``v2 compiled object type declares ToString override``() =
+    let types = compileV2Schema minimalPetstoreV2
+    let petType = types |> List.find(fun t -> t.Name = "Pet")
+
+    let toStr =
+        petType.GetMethods(
+            BindingFlags.Public
+            ||| BindingFlags.Instance
+            ||| BindingFlags.DeclaredOnly
+        )
+        |> Array.tryFind(fun m -> m.Name = "ToString" && m.GetParameters().Length = 0)
+
+    toStr.IsSome |> shouldEqual true
+    toStr.Value.ReturnType |> shouldEqual typeof<string>
+
+[<Fact>]
+let ``v2 compiled object type ToString invokeCode does not throw for concrete provided type``() =
+    // This test guards against the FS3033 regression where splicing a concrete provided-type
+    // expression into a quotation expecting obj caused "Type mismatch when splicing expression".
+    let types = compileV2Schema minimalPetstoreV2
+    let petType = types |> List.find(fun t -> t.Name = "Pet")
+
+    let toStr =
+        petType.GetMethods(
+            BindingFlags.Public
+            ||| BindingFlags.Instance
+            ||| BindingFlags.DeclaredOnly
+        )
+        |> Array.find(fun m -> m.Name = "ToString" && m.GetParameters().Length = 0)
+
+    let providedMethod = toStr :?> ProviderImplementation.ProvidedTypes.ProvidedMethod
+
+    // Access GetInvokeCode via reflection to work around internal accessibility
+    let invokeCodeProp =
+        providedMethod.GetType().GetProperty("GetInvokeCode", BindingFlags.Instance ||| BindingFlags.NonPublic)
+
+    if isNull invokeCodeProp then
+        failwith "GetInvokeCode property not found on ProvidedMethod"
+
+    let invokeCodeOpt =
+        invokeCodeProp.GetValue(providedMethod) :?> (Expr list -> Expr) option
+
+    match invokeCodeOpt with
+    | None -> failwith "ToString has no invoke code"
+    | Some invokeCode ->
+        let thisVar = Var("this", petType)
+        let thisExpr = Expr.Var thisVar
+        // Must not throw; original bug threw FS3033 here because %%this was
+        // typed as FileDescription/Pet rather than obj inside the quotation body
+        let body = invokeCode [ thisExpr ]
+        // Expr is a value type; just verifying invokeCode did not throw is sufficient
+        body.Type |> shouldEqual typeof<string>