perf: reduce allocations & reflection in generated operation code (#455)

* perf: reduce allocations & reflection in generated operation code

Compile-time (OperationCompiler):
- Hoist toParam / toQueryParams / TaskExtensions.cast / AsyncExtensions.cast
  MethodInfo resolution to the OperationCompiler instance (resolved once
  per provider instead of per generated operation).
- Hoist string-list union-case reflection in Provider.OpenApiClient.
- Build a paramName -> IOpenApiParameter map once per operation and use
  it for O(1) lookups in invokeCode (was Seq.tryFind per ShapeVar).
- Build the fixed Content-Type/Accept headers list at provider-generation
  time instead of emitting a quotation that re-evaluates per call.
- Make response quotations (object / stream / string / unit) lazy so only
  the branch actually used for the operation's return type is built.

Generated code (runtime):
- Emit RuntimeHelpers.createHttpRequestFromQueryLists instead of chained
  List.append / List.concat for query parameter assembly.
- Emit RuntimeHelpers.fillHeadersAndCookies instead of an inline
  Seq.filter / Seq.map / String.concat cookie-building quotation.
- For typed JSON responses, emit a direct generic TaskExtensions.cast<'T> /
  AsyncExtensions.cast<'T> call via ProvidedTypeBuilder.MakeGenericMethod,
  avoiding MethodInfo.Invoke on every API call.
- Avoid the previous shared-quotation Var hazard that caused FS3033
  'An item with the same key has already been added' for operations with
  multiple path/query parameters.

Runtime helpers (RuntimeHelpers):
- Add createHttpRequestFromQueryLists: flattens seq<#seq<string*string>>
  into a ResizeArray, filtering nulls, and delegates to createHttpRequest.
- Add fillHeadersAndCookies: calls fillHeaders, then builds the Cookie
  header imperatively with StringBuilder using the standards-compliant
  '; ' separator and TryAddWithoutValidation.

Tests:
- Add regression tests in Schema.OperationCompilationTests that assert
  generated invokeCode does not reuse the same Quotations.Var instance
  across path/query parameters.

Validated:
- dotnet fantomas --check src/ tests/
- Unit tests: 479 total, 0 failed, 1 skipped
- Provider integration tests (Swashbuckle server): 127 total, 0 failed
- Stripe spec3.json (414 paths, 1422 schemas, 587 operations) compiles
  successfully; generated code contains 0 reflective casts, 0 List.append
  and 0 List.concat calls.

* test: cover createHttpRequestFromQueryLists and fillHeadersAndCookies

Address Copilot review feedback on PR #455 by adding focused
RuntimeHelpersTests for the two new helpers:

createHttpRequestFromQueryLists:
- flattens multiple query lists into the request URI
- strips leading slash when all lists are empty
- strips leading slash when all inner lists are empty
- skips null-valued pairs across multiple lists
- produces no query string when all values are null
- preserves the HTTP method

fillHeadersAndCookies:
- emits Cookie header with canonical '; ' separator
- single cookie has no separator
- skips null cookie values
- omits Cookie header when all values are null
- omits Cookie header when cookie list is empty
- still adds normal headers via fillHeaders
- still skips null-value headers

Author: sergey-tihon

src/SwaggerProvider.DesignTime/OperationCompiler.fs

@@ -3,6 +3,7 @@ namespace SwaggerProvider.Internal.Compilers
 open System
 open System.Collections.Generic
 open System.Net.Http
+open System.Reflection
 open System.Text.Json
 
 open Microsoft.FSharp.Quotations
@@ -60,6 +61,44 @@ type PayloadType =
 
 /// Object for compiling operations.
 type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler, ignoreControllerPrefix, ignoreOperationId, asAsync: bool) =
+    let toParamMethod =
+        match <@@ RuntimeHelpers.toParam(null) @@> with
+        | Call(None, m, _) -> m
+        | _ -> failwith "Cannot extract toParam MethodInfo"
+
+    let toQueryParamsMethod =
+        match <@@ RuntimeHelpers.toQueryParams "" null Unchecked.defaultof<ProvidedApiClientBase> @@> with
+        | Call(None, m, _) -> m
+        | _ -> failwith "Cannot extract toQueryParams MethodInfo"
+
+    let resolveCastMethod(ownerType: Type) =
+        ownerType.GetMethods(BindingFlags.Public ||| BindingFlags.Static)
+        |> Array.tryFind(fun m ->
+            m.Name = "cast"
+            && m.IsGenericMethodDefinition
+            && m.GetGenericArguments().Length = 1
+            && m.GetParameters().Length = 1)
+        |> Option.defaultWith(fun () -> failwithf "Cannot extract %s.cast<'T> MethodInfo" ownerType.FullName)
+
+    let taskCastMethod = resolveCastMethod typeof<TaskExtensions>
+    let asyncCastMethod = resolveCastMethod typeof<AsyncExtensions>
+
+    let stringPairListExpr(items: (string * string) list) : Expr<(string * string) list> =
+        let empty = <@ [] @>
+
+        (empty, List.rev items)
+        ||> List.fold(fun acc (name, value) ->
+            let nameExpr = Expr.Value(name, typeof<string>) |> Expr.Cast<string>
+            let valueExpr = Expr.Value(value, typeof<string>) |> Expr.Cast<string>
+
+            <@ (%nameExpr, %valueExpr) :: %acc @>)
+
+    let typedListExpr(items: Expr<'T> list) : Expr<'T list> =
+        let empty = <@ [] @>
+
+        (empty, List.rev items)
+        ||> List.fold(fun acc item -> <@ %item :: %acc @>)
+
     let compileOperation (providedMethodName: string) (apiCall: ApiCall) =
         let path, pathItem, opTy = apiCall
         let operation = pathItem.Operations[opTy]
@@ -96,7 +135,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
         let (|NoMediaType|_|)(content: IDictionary<string, OpenApiMediaType>) =
             if isNull content || content.Count = 0 then Some() else None
 
-        let payloadTy, payloadMime, parameters, ctArgIndex =
+        let payloadTy, payloadMime, parameters, ctArgIndex, apiParamByProvidedName =
             /// handles de-duplicating Swagger parameter names if the same parameter name
             /// appears in multiple locations in a given operation definition.
             let uniqueParamName usedNames (param: IOpenApiParameter) =
@@ -156,8 +195,8 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                 |> List.partition(_.Required)
 
             let buildProvidedParameters usedNames (paramList: IOpenApiParameter list) =
-                ((usedNames, []), paramList)
-                ||> List.fold(fun (names, parameters) current ->
+                ((usedNames, [], []), paramList)
+                ||> List.fold(fun (names, parameters, lookup) current ->
                     let names, paramName = uniqueParamName names current
 
                     let paramType =
@@ -170,15 +209,20 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                             let paramDefaultValue = defCompiler.GetDefaultValue paramType
                             ProvidedParameter(paramName, paramType, false, paramDefaultValue)
 
-                    (names, providedParam :: parameters))
-                |> fun (finalNames, ps) -> finalNames, List.rev ps
+                    (names, providedParam :: parameters, (paramName, current) :: lookup))
+                |> fun (finalNames, ps, lookup) -> finalNames, List.rev ps, List.rev lookup
 
-            let namesAfterRequired, requiredProvidedParams =
+            let namesAfterRequired, requiredProvidedParams, requiredLookup =
                 buildProvidedParameters Set.empty requiredOpenApiParams
 
-            let _, optionalProvidedParams =
+            let _, optionalProvidedParams, optionalLookup =
                 buildProvidedParameters namesAfterRequired optionalOpenApiParams
 
+            let apiParamByProvidedName =
+                requiredLookup @ optionalLookup
+                |> List.choose(fun (paramName, param) -> if param.In.HasValue then Some(paramName, param) else None)
+                |> Map.ofList
+
             let ctArgIndex, parameters =
                 let scope = UniqueNameGenerator()
 
@@ -196,7 +240,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
 
                 ctArgIndex, requiredProvidedParams @ optionalProvidedParams @ [ ctParam ]
 
-            payloadTy, payloadTy.ToMediaType(), parameters, ctArgIndex
+            payloadTy, payloadTy.ToMediaType(), parameters, ctArgIndex, apiParamByProvidedName
 
         // find the inner type value
         let okResponse =
@@ -258,6 +302,12 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
             |> Seq.toArray
             |> Array.unzip
 
+        let fixedHeaders =
+            [ if not(isNull payloadMime) then
+                  "Content-Type", payloadMime
+              if not(isNull retMime) then
+                  "Accept", retMime ]
+
         let m =
             ProvidedMethod(
                 providedMethodName,
@@ -271,13 +321,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
 
                         let httpMethod = opTy.ToString()
 
-                        let headers =
-                            <@
-                                [ if not(isNull payloadMime) then
-                                      "Content-Type", payloadMime
-                                  if not(isNull retMime) then
-                                      "Accept", retMime ]
-                            @>
+                        let headers = stringPairListExpr fixedHeaders
 
                         // Locates parameters matching the arguments
                         let mutable payloadExp = None
@@ -298,14 +342,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                             apiArgs
                             |> List.choose (function
                                 | ShapeVar sVar as expr ->
-                                    let param =
-                                        openApiParameters
-                                        |> Seq.tryFind(fun x ->
-                                            // pain point: we have to make sure that the set of names we search for here are the same as the set of names generated when we make `parameters` above
-                                            let baseName = niceCamelName x.Name
-                                            baseName = sVar.Name || (unambiguousName x) = sVar.Name)
-
-                                    match param with
+                                    match apiParamByProvidedName |> Map.tryFind sVar.Name with
                                     | Some(par) -> Some(par, expr)
                                     | _ ->
                                         let payloadType = PayloadType.Parse sVar.Name
@@ -324,31 +361,21 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                         // object across all calls, causing "duplicate key" exceptions in ProvidedTypes
                         // when the same helper is called for multiple parameters in one operation.
                         // Instead, build the call expression directly without an intermediate binding.
-                        let toParamMethod =
-                            match <@@ RuntimeHelpers.toParam(null) @@> with
-                            | Call(None, m, _) -> m
-                            | _ -> failwith "Cannot extract toParam MethodInfo"
-
                         let coerceString exp =
                             let obj = Expr.Coerce(exp, typeof<obj>)
                             Expr.Call(toParamMethod, [ obj ]) |> Expr.Cast<string>
 
-                        let toQueryParamsMethod =
-                            match <@@ RuntimeHelpers.toQueryParams "" null (%this) @@> with
-                            | Call(None, m, _) -> m
-                            | _ -> failwith "Cannot extract toQueryParams MethodInfo"
-
                         let rec coerceQueryString name expr =
                             let obj = Expr.Coerce(expr, typeof<obj>)
 
                             Expr.Call(toQueryParamsMethod, [ Expr.Value name; obj; this ])
                             |> Expr.Cast<(string * string) list>
 
                         // Partitions arguments based on their locations
-                        let path, queryParams, headers =
-                            let path, queryParams, headers, cookies =
-                                ((<@ path @>, <@ [] @>, headers, <@ [] @>), parameters)
-                                ||> List.fold(fun (path, query, headers, cookies) (param: IOpenApiParameter, valueExpr) ->
+                        let path, queryParamLists, headers, cookies =
+                            let path, queryParamLists, headers, cookies =
+                                ((<@ path @>, [], headers, <@ [] @>), parameters)
+                                ||> List.fold(fun (path, queryParamLists, headers, cookies) (param: IOpenApiParameter, valueExpr) ->
                                     if param.In.HasValue then
                                         let name = param.Name
 
@@ -357,44 +384,32 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                                             let value = coerceString valueExpr
                                             let pattern = $"{{%s{name}}}"
                                             let path' = <@ (%path).Replace(pattern, %value) @>
-                                            (path', query, headers, cookies)
+                                            (path', queryParamLists, headers, cookies)
                                         | ParameterLocation.Query ->
                                             let listValues = coerceQueryString name valueExpr
-                                            let query' = <@ List.append %query %listValues @>
-                                            (path, query', headers, cookies)
+                                            (path, listValues :: queryParamLists, headers, cookies)
                                         | ParameterLocation.Header ->
                                             let value = coerceString valueExpr
                                             let headers' = <@ (name, %value) :: (%headers) @>
-                                            (path, query, headers', cookies)
+                                            (path, queryParamLists, headers', cookies)
                                         | ParameterLocation.Cookie ->
                                             let value = coerceString valueExpr
                                             let cookies' = <@ (name, %value) :: (%cookies) @>
-                                            (path, query, headers, cookies')
+                                            (path, queryParamLists, headers, cookies')
                                         | x -> failwithf $"Unsupported parameter location '%A{x}'"
                                     else
                                         failwithf "This should not happen, payload expression is already parsed")
 
-                            let headers' =
-                                <@
-                                    let cookieHeader =
-                                        %cookies
-                                        |> Seq.filter(snd >> isNull >> not)
-                                        |> Seq.map(fun (name, value) -> $"{name}={value}")
-                                        |> String.concat ";"
-
-                                    if String.IsNullOrEmpty cookieHeader then
-                                        %headers
-                                    else
-                                        ("Cookie", cookieHeader) :: (%headers)
-                                @>
-
-                            (path, queryParams, headers')
+                            path, List.rev queryParamLists, headers, cookies
 
+                        let queryParamLists = typedListExpr queryParamLists
 
                         let httpRequestMessage =
                             <@
-                                let msg = RuntimeHelpers.createHttpRequest httpMethod %path %queryParams
-                                RuntimeHelpers.fillHeaders msg %headers
+                                let msg =
+                                    RuntimeHelpers.createHttpRequestFromQueryLists httpMethod %path %queryParamLists
+
+                                RuntimeHelpers.fillHeadersAndCookies msg %headers %cookies
                                 msg
                             @>
 
@@ -441,7 +456,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                         let action =
                             <@ (%this).CallAsync(%httpRequestMessageWithPayload, errorCodes, errorDescriptions, %ct) @>
 
-                        let responseObj =
+                        let responseObj() =
                             let innerReturnType = defaultArg retTy null
 
                             <@
@@ -455,7 +470,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                                 }
                             @>
 
-                        let responseStream =
+                        let responseStream() =
                             <@
                                 let x = %action
                                 let ct = %ct
@@ -467,7 +482,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                                 }
                             @>
 
-                        let responseString =
+                        let responseString() =
                             <@
                                 let x = %action
                                 let ct = %ct
@@ -479,7 +494,7 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                                 }
                             @>
 
-                        let responseUnit =
+                        let responseUnit() =
                             <@
                                 let x = %action
 
@@ -489,27 +504,36 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                                 }
                             @>
 
-                        // if we're an async method, then we can just return the above, coerced to the overallReturnType.
-                        // if we're not async, then run that^ through Async.RunSynchronously before doing the coercion.
+                        // Build only the response quotation needed for this operation's return shape.
+                        // For typed JSON responses, emit direct generic cast calls so generated clients
+                        // do not pay MethodInfo.Invoke costs on every API call.
                         if not asAsync then
                             match retTy with
-                            | None -> responseUnit.Raw
-                            | Some t when t = typeof<IO.Stream> -> <@ %responseStream @>.Raw
+                            | None -> (responseUnit()).Raw
+                            | Some t when t = typeof<IO.Stream> -> <@ %(responseStream()) @>.Raw
                             | Some t ->
                                 match retMime with
-                                | TextReturn _ -> <@ %responseString @>.Raw
-                                | _ -> Expr.Coerce(<@ RuntimeHelpers.taskCast t %responseObj @>, overallReturnType)
+                                | TextReturn _ -> <@ %(responseString()) @>.Raw
+                                | _ ->
+                                    let castMethod = ProvidedTypeBuilder.MakeGenericMethod(taskCastMethod, [ t ])
+
+                                    Expr.Call(castMethod, [ responseObj() ])
+                                    |> fun e -> Expr.Coerce(e, overallReturnType)
                         else
                             let awaitTask t =
                                 <@ Async.AwaitTask(%t) @>
 
                             match retTy with
-                            | None -> (awaitTask responseUnit).Raw
-                            | Some t when t = typeof<IO.Stream> -> <@ %(awaitTask responseStream) @>.Raw
+                            | None -> (awaitTask(responseUnit())).Raw
+                            | Some t when t = typeof<IO.Stream> -> <@ %(awaitTask(responseStream())) @>.Raw
                             | Some t ->
                                 match retMime with
-                                | TextReturn _ -> <@ %(awaitTask responseString) @>.Raw
-                                | _ -> Expr.Coerce(<@ RuntimeHelpers.asyncCast t %(awaitTask responseObj) @>, overallReturnType)
+                                | TextReturn _ -> <@ %(awaitTask(responseString())) @>.Raw
+                                | _ ->
+                                    let castMethod = ProvidedTypeBuilder.MakeGenericMethod(asyncCastMethod, [ t ])
+
+                                    Expr.Call(castMethod, [ awaitTask(responseObj()) ])
+                                    |> fun e -> Expr.Coerce(e, overallReturnType)
             )
 
         let xmlDoc =

src/SwaggerProvider.DesignTime/Provider.OpenApiClient.fs

@@ -30,13 +30,14 @@ type public OpenApiClientTypeProvider(cfg: TypeProviderConfig) as this =
     // check we contain a copy of runtime files, and are not referencing the runtime DLL
     do assert (typeof<ProvidedApiClientBase>.Assembly.GetName().Name = asm.GetName().Name)
 
-    let buildStringListExpr(items: string list) : Expr =
+    let stringListNilCase, stringListConsCase =
         let cases = FSharpType.GetUnionCases typeof<string list>
-        let nilCase = cases |> Array.find(fun c -> c.Name = "Empty")
-        let consCase = cases |> Array.find(fun c -> c.Name = "Cons")
-        let nil = Expr.NewUnionCase(nilCase, [])
+        cases |> Array.find(fun c -> c.Name = "Empty"), cases |> Array.find(fun c -> c.Name = "Cons")
+
+    let buildStringListExpr(items: string list) : Expr =
+        let nil = Expr.NewUnionCase(stringListNilCase, [])
 
-        List.foldBack (fun (s: string) acc -> Expr.NewUnionCase(consCase, [ Expr.Value(s, typeof<string>); acc ])) items nil
+        List.foldBack (fun (s: string) acc -> Expr.NewUnionCase(stringListConsCase, [ Expr.Value(s, typeof<string>); acc ])) items nil
 
     let myParamType =
         let t =