Compare types instead of their names to recognize options and lists - #628

The checks for options, value options, skippable values and F# lists compared the full name of a type with the name of the generic type definition through the culture-sensitive String.StartsWith. Input coercion runs them on every coerced value, and execution on every resolved nullable field through Helpers.objectOptionCast. They also took an array of options for an option, since its full name starts with the same name.

This PR compares the types themselves with Type.(=). #625 builds on it.

Benchmark

Each way to tell whether a type is an F# option, measured with BenchmarkDotNet 0.15 on .NET 10, x64 (the source is below):

A second run compared the type comparisons with Type.(=), the Type.op_Equality operator. Other processes loaded the machine during it, so its absolute numbers are higher than above, but the three methods ran under the same load:

None of them allocates. Type.(=) is as fast as comparing references and stays correct for any Type implementation, while the F# equality of types is several times slower, even slower than comparing the names ordinally. The Copilot instructions now require Type.(=) for comparing types. An end-to-end run of SimpleExecutionBenchmark was inconclusive: other processes kept the machine 30–70% busy, and the standard deviation reached 20–60% of the mean.

module Program

open System
open BenchmarkDotNet.Attributes
open BenchmarkDotNet.Running

[<Literal>]
let OptionTypeName = "Microsoft.FSharp.Core.FSharpOption`1"

let optionDefinition = typedefof<_ option>

[<MemoryDiagnoser>]
type OptionTypeCheck () =

    [<ParamsSource("Types")>]
    member val Case = "" with get, set

    member _.Types = [ "int option"; "int voption"; "int option[]"; "string"; "List<int>" ]

    member val Type : Type = null with get, set

    [<GlobalSetup>]
    member this.Setup () =
        this.Type <-
            match this.Case with
            | "int option" -> typeof<int option>
            | "int voption" -> typeof<int voption>
            | "int option[]" -> typeof<int option[]>
            | "string" -> typeof<string>
            | _ -> typeof<Collections.Generic.List<int>>

    [<Benchmark(Baseline = true)>]
    member this.FullNameStartsWith () = this.Type.FullName.StartsWith OptionTypeName

    [<Benchmark>]
    member this.FullNameStartsWithOrdinal () = this.Type.FullName.StartsWith (OptionTypeName, StringComparison.Ordinal)

    [<Benchmark>]
    member this.DefinitionFullNameEquals () =
        this.Type.IsGenericType
        && String.Equals (this.Type.GetGenericTypeDefinition().FullName, OptionTypeName, StringComparison.Ordinal)

    [<Benchmark>]
    member this.DefinitionEquals () =
        this.Type.IsGenericType
        && this.Type.GetGenericTypeDefinition () = optionDefinition

    [<Benchmark>]
    member this.DefinitionTypeEquality () =
        this.Type.IsGenericType
        && Type.(=) (this.Type.GetGenericTypeDefinition (), optionDefinition)

    [<Benchmark>]
    member this.DefinitionReferenceEquals () =
        this.Type.IsGenericType
        && Object.ReferenceEquals (this.Type.GetGenericTypeDefinition (), optionDefinition)

[<EntryPoint>]
let main args =
    BenchmarkRunner.Run<OptionTypeCheck> () |> ignore
    0

Changes

• ReflectionHelper.isConstructedFrom compares the generic type definition of a type with Type.(=), and isOptionType, isValueOptionType, isSkippableType and isListType build on it. They replace every comparison of names in Helpers, the server ReflectionHelper, Values and the ObjectListFilter middleware's TypeCoercion, and the type name literals are removed.
• Helpers.unwrap and Helpers.objectOptionCast no longer take an array of options for an option, for which they threw a NullReferenceException.
• The System.Array`1 check of isAssignableWithUnwrap is dropped: no array type has that name, so it never matched. Input coercion builds an array only for a GraphQL list whose type is an array, which is assignable without it, so matching arrays there would only pass a list to an array parameter.
• Values keeps its two comparisons of the short names, inputType.Name <> outputType.Name. They compare whole strings ordinally, which is fast, and comparing the types instead would change which values get wrapped.
• The Copilot instructions require Type.(=) for comparing types, in a commit of its own.

Breaking changes

The old checks took an int option[] constructor parameter for an optional one, so a nullable GraphQL field bound to it passed the schema validation, while the same field bound to an int option list always failed it with InvalidInputTypeException. Both now fail. Such a parameter must be declared as an option of the array, such as int option[] option. The release notes list it.

Verification

• FSharp.Data.GraphQL.Tests in Release: 769 passed, 5 skipped, 0 failed. The new ReflectionHelperTests cover the type checks, the helpers on an array of options, an input object with an int option[] field, and the rejected nullable field. On dev, the helper test fails with NullReferenceException, and an int option list parameter fails with the same InvalidInputTypeException the int option[] one now fails with.
• Release build of FSharp.Data.GraphQL.slnx with SDK 10.0.401: 0 warnings, 0 errors

🤖 Generated with Claude Code