[repo-assist] refactor+test: extract compileSingleRefOrNewObject helper; add text/plain body, octet-stream response, path-level param tests (+

[Content truncated due to length] (#452)

* refactor+test: extract compileSingleRefOrNewObject helper; add text/plain body, octet-stream response, path-level param tests (+9 tests, 465→474)

Task 5: Extract the three identical allOf/oneOf/anyOf single-$ref collapse
match arm bodies into a shared compileSingleRefOrNewObject local helper in
DefinitionCompiler.compileBySchema. The semantics are unchanged — each of the
three guards fires under the same conditions as before, but the 4-line inner
match expression is replaced by a single call. This removes ~18 lines of
duplicated code while keeping the guard conditions explicit and separate.

Task 10: Add 9 unit tests covering three previously untested OperationCompiler
behaviours:
- text/plain request body → parameter named "textPlain"
- application/octet-stream response → return type Task<IO.Stream>
- Path-level parameters on PathItem → inherited by all operations on that path

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

* ci: trigger checks

* fix: use typed field access in generated property getter/setter

Agent-Logs-Url: https://github.com/fsprojects/SwaggerProvider/sessions/b2ed13f0-6603-43f9-a415-011fb299a1b6

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

* fix: revert FieldGet/FieldSet to FieldGetUnchecked/FieldSetUnchecked

The previous commit accidentally changed Expr.FieldGetUnchecked/FieldSetUnchecked
to the checked variants Expr.FieldGet/FieldSet. ProvidedField instances require the
Unchecked variants; the checked variants caused 100 type-inference errors in the
ProviderTests (FS0072) because the generated property accessors produced expressions
with incorrect type information.

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

* ci: trigger checks

* fix: restore typed field expressions for generated properties

* fix: revert FieldGet/FieldSet to FieldGetUnchecked/FieldSetUnchecked

Expr.FieldGet performs strict type-equality checks which rejects array
types where the provided-field type is System.IO.Stream[] but the
expression carries System.IO.Stream[*]. FieldGetUnchecked skips this
check and was the working approach before the previous fix attempt.

All 474 unit tests pass.

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

* ci: trigger checks

* fix: use fresh Var per call in coerceString/coerceQueryString to avoid duplicate quotation variable exceptions

When coerceString or coerceQueryString was called for multiple parameters
in the same operation, the quotation literal `<@ let x = ... @>` reused
the same Var object on every call. Composing multiple such quotations into
one invokeCode expression caused the ProvidedTypes/quotation compiler to
throw "An item with the same key has already been added. Key: x" (or 'o')
for any operation with two or more path/header/cookie/query parameters.

Fix: replace the static quotation literals with Expr.Let + a freshly
constructed Var on each call, ensuring each binding has its own unique
Var identity.

* style: apply Fantomas formatting

* fix: eliminate duplicate Var by building Expr.Call directly instead of let-binding

The original coerceString used a quotation literal:
  <@ let x = (%obj) in RuntimeHelpers.toParam x @>

F# compiles quotation literals to static data, so the Var("x") inside
the literal is the same object on every call. When an operation has two
or more path/header/cookie parameters, coerceString is called once per
parameter and the fold combines the results. The resulting expression
tree contained the same Var object bound by multiple Let nodes.
ProvidedTypes' IL emitter does localsMap.Add(v, lb) for each Let(v,...)
node — since all Let nodes shared the same Var object, the second Add
threw "An item with the same key has already been added. Key: x".

The same problem affected coerceQueryString with Var("o").

Fix: replace the quotation literals entirely with Expr.Call, extracting
the MethodInfo once via a quotation pattern match and then building the
call node directly. This avoids any Let binding and any shared Var, so
each invocation produces a structurally independent expression.

---------

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>
Co-authored-by: Sergey Tihon <sergey.tihon@gmail.com>

Author: 4 people

src/SwaggerProvider.DesignTime/DefinitionCompiler.fs

@@ -441,6 +441,17 @@ type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: b
             else
                 DefinitionPath.DefinitionPrefix + refId
 
+        // Helper for the allOf/oneOf/anyOf single-ref collapse pattern.
+        // When `schemas` has exactly one entry that is a $ref and the outer schema has no
+        // own properties, collapse directly to the referenced type; otherwise fall back to
+        // compileNewObject so composite/inline schemas are handled as usual.
+        let compileSingleRefOrNewObject(schemas: System.Collections.Generic.IList<IOpenApiSchema>) =
+            match schemas.[0] with
+            | :? OpenApiSchemaReference as schemaRef when not(isNull schemaRef.Reference) ->
+                ns.ReleaseNameReservation tyName
+                compileByPath <| getFullPath schemaRef.Reference.Id
+            | _ -> compileNewObject()
+
         let tyType =
             match schemaObj with
             | null -> failwithf $"Cannot compile object '%s{tyName}' when schema is 'null'"
@@ -472,39 +483,26 @@ type DefinitionCompiler(schema: OpenApiDocument, provideNullable, useDateOnly: b
                     compileBySchema ns (ns.ReserveUniqueName tyName "Item") elSchema true ns.RegisterType false
 
                 ProvidedTypeBuilder.MakeGenericType(typedefof<Map<string, obj>>, [ typeof<string>; elTy ])
-            // Handle allOf with single reference (e.g., nullable reference to another type)
+            // Handle allOf/oneOf/anyOf with a single $ref and no own properties:
+            // collapse the wrapper to the referenced type directly.
             | _ when
                 not(isNull schemaObj.AllOf)
                 && schemaObj.AllOf.Count = 1
                 && (schemaObj.Properties |> isNull || schemaObj.Properties.Count = 0)
                 ->
-                match schemaObj.AllOf.[0] with
-                | :? OpenApiSchemaReference as schemaRef when not(isNull schemaRef.Reference) ->
-                    ns.ReleaseNameReservation tyName
-                    compileByPath <| getFullPath schemaRef.Reference.Id
-                | _ -> compileNewObject()
-            // Handle oneOf with single reference (resolves to the referenced type)
+                compileSingleRefOrNewObject schemaObj.AllOf
             | _ when
                 not(isNull schemaObj.OneOf)
                 && schemaObj.OneOf.Count = 1
                 && (schemaObj.Properties |> isNull || schemaObj.Properties.Count = 0)
                 ->
-                match schemaObj.OneOf.[0] with
-                | :? OpenApiSchemaReference as schemaRef when not(isNull schemaRef.Reference) ->
-                    ns.ReleaseNameReservation tyName
-                    compileByPath <| getFullPath schemaRef.Reference.Id
-                | _ -> compileNewObject()
-            // Handle anyOf with single reference (resolves to the referenced type)
+                compileSingleRefOrNewObject schemaObj.OneOf
             | _ when
                 not(isNull schemaObj.AnyOf)
                 && schemaObj.AnyOf.Count = 1
                 && (schemaObj.Properties |> isNull || schemaObj.Properties.Count = 0)
                 ->
-                match schemaObj.AnyOf.[0] with
-                | :? OpenApiSchemaReference as schemaRef when not(isNull schemaRef.Reference) ->
-                    ns.ReleaseNameReservation tyName
-                    compileByPath <| getFullPath schemaRef.Reference.Id
-                | _ -> compileNewObject()
+                compileSingleRefOrNewObject schemaObj.AnyOf
             | _ when
                 resolvedType.IsNone
                 || resolvedType = Some JsonSchemaType.Object

src/SwaggerProvider.DesignTime/OperationCompiler.fs

@@ -7,6 +7,7 @@ open System.Text.Json
 
 open Microsoft.FSharp.Quotations
 open Microsoft.FSharp.Quotations.ExprShape
+open Microsoft.FSharp.Quotations.Patterns
 open Microsoft.OpenApi
 open ProviderImplementation.ProvidedTypes
 open FSharp.Data.Runtime.NameUtils
@@ -319,13 +320,29 @@ type OperationCompiler(schema: OpenApiDocument, defCompiler: DefinitionCompiler,
                                 | _ -> failwithf $"Function '%s{providedMethodName}' does not support functions as arguments.")
 
                         // Makes argument a string // TODO: Make body an exception
+                        // NOTE: avoid `let x = ...` in quotation literals — they share a single Var
+                        // 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.Cast<obj>
-                            <@ let x = (%obj) in RuntimeHelpers.toParam x @>
+                            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>)
-                            <@ let o = (%%obj: obj) in RuntimeHelpers.toQueryParams name o (%this) @>
+
+                            Expr.Call(toQueryParamsMethod, [ Expr.Value name; obj; this ])
+                            |> Expr.Cast<(string * string) list>
 
                         // Partitions arguments based on their locations
                         let path, queryParams, headers =

tests/SwaggerProvider.Tests/Schema.OperationCompilationTests.fs

@@ -1113,6 +1113,162 @@ let ``ignoreOperationId=true does not generate the original operationId as metho
     methodNames |> shouldNotContain "ListAllPets"
     methodNames |> shouldNotContain "GetPetById"
 
+// ── text/plain request body ───────────────────────────────────────────────────
+
+let private textPlainBodySchema =
+    """openapi: "3.0.0"
+info:
+  title: TextPlainBodyTest
+  version: "1.0.0"
+paths:
+  /echo:
+    post:
+      operationId: echoText
+      requestBody:
+        required: true
+        content:
+          text/plain:
+            schema:
+              type: string
+      responses:
+        "200":
+          description: OK
+components:
+  schemas: {}
+"""
+
+[<Fact>]
+let ``text/plain request body generates a method``() =
+    let types = compileTaskSchema textPlainBodySchema
+    let method = findMethod types "EchoText"
+    method.IsSome |> shouldEqual true
+
+[<Fact>]
+let ``text/plain request body parameter is named textPlain``() =
+    let types = compileTaskSchema textPlainBodySchema
+    let method = (findMethod types "EchoText").Value
+    let paramNames = method.GetParameters() |> Array.map(fun p -> p.Name)
+    paramNames |> shouldContain "textPlain"
+
+[<Fact>]
+let ``text/plain request body has CancellationToken as last parameter``() =
+    let types = compileTaskSchema textPlainBodySchema
+    let method = (findMethod types "EchoText").Value
+    let lastParam = method.GetParameters() |> Array.last
+    lastParam.ParameterType |> shouldEqual typeof<CancellationToken>
+
+// ── application/octet-stream response ────────────────────────────────────────
+
+let private octetStreamResponseSchema =
+    """openapi: "3.0.0"
+info:
+  title: OctetStreamResponseTest
+  version: "1.0.0"
+paths:
+  /file:
+    get:
+      operationId: downloadFile
+      responses:
+        "200":
+          description: File contents
+          content:
+            application/octet-stream:
+              schema:
+                type: string
+                format: binary
+components:
+  schemas: {}
+"""
+
+[<Fact>]
+let ``octet-stream response generates a method``() =
+    let types = compileTaskSchema octetStreamResponseSchema
+    let method = findMethod types "DownloadFile"
+    method.IsSome |> shouldEqual true
+
+[<Fact>]
+let ``octet-stream response produces Task<IO.Stream> return type``() =
+    let types = compileTaskSchema octetStreamResponseSchema
+    let method = (findMethod types "DownloadFile").Value
+    method.ReturnType.IsGenericType |> shouldEqual true
+
+    method.ReturnType.GetGenericTypeDefinition()
+    |> shouldEqual typedefof<Task<_>>
+
+    method.ReturnType.GetGenericArguments()[0]
+    |> shouldEqual typeof<IO.Stream>
+
+[<Fact>]
+let ``octet-stream response has CancellationToken as its only parameter``() =
+    let types = compileTaskSchema octetStreamResponseSchema
+    let method = (findMethod types "DownloadFile").Value
+    let parameters = method.GetParameters()
+    parameters.Length |> shouldEqual 1
+    parameters[0].ParameterType |> shouldEqual typeof<CancellationToken>
+
+// ── Path-level parameters (inherited from PathItem) ───────────────────────────
+
+let private pathLevelParamSchema =
+    """openapi: "3.0.0"
+info:
+  title: PathLevelParamTest
+  version: "1.0.0"
+paths:
+  /users/{userId}/posts:
+    parameters:
+      - name: userId
+        in: path
+        required: true
+        schema:
+          type: integer
+    get:
+      operationId: getUserPosts
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string
+    post:
+      operationId: createUserPost
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: string
+      responses:
+        "201":
+          description: Created
+components:
+  schemas: {}
+"""
+
+[<Fact>]
+let ``path-level parameter is inherited by GET operation``() =
+    let types = compileTaskSchema pathLevelParamSchema
+    let method = (findMethod types "GetUserPosts").Value
+    let paramNames = method.GetParameters() |> Array.map(fun p -> p.Name)
+    paramNames |> shouldContain "userId"
+
+[<Fact>]
+let ``path-level parameter is required with correct type``() =
+    let types = compileTaskSchema pathLevelParamSchema
+    let method = (findMethod types "GetUserPosts").Value
+    let userIdParam = method.GetParameters() |> Array.find(fun p -> p.Name = "userId")
+    userIdParam.ParameterType |> shouldEqual typeof<int32>
+    userIdParam.IsOptional |> shouldEqual false
+
+[<Fact>]
+let ``path-level parameter is inherited by POST operation``() =
+    let types = compileTaskSchema pathLevelParamSchema
+    let method = (findMethod types "CreateUserPost").Value
+    let paramNames = method.GetParameters() |> Array.map(fun p -> p.Name)
+    paramNames |> shouldContain "userId"
+
 // ── asAsync=true: octet-stream response produces Async<IO.Stream> ─────────────
 
 let private octetStreamResponseAsyncSchema =