Addition operator required by type parameter constraint can't be invoked

[brianberns]

Repro steps

Consider the following code:

let inline add<'T when 'T : (static member (+) : 'T * 'T -> 'T)> (a : 'T) (b : 'T) =
    a + b

Expected behavior

Code should compile and successfully add the two arguments.

Actual behavior

Compiler error: A type parameter is missing a constraint 'when ( ^T or ^?11088896) : (static member (+) : ^T * ^?11088896 -> ^?11088897)'

Known workarounds

The following variation works:

let inline add<'T when 'T : (static member (+) : 'T * 'T -> 'T)> (a : 'T) (b : 'T) =
    (^T : (static member (+) : ^T * ^T -> ^T)(a, b))

However, it also results in a compiler warning: Member constraints with the name 'op_Addition' are given special status by the F# compiler as certain .NET types are implicitly augmented with this member. This may result in runtime failures if you attempt to invoke the member constraint from your own code.

[brianberns]

Note that moving the code into a static member results in a warning with the same text as the original error:

type Example< ^T when ^T : (static member (+) : ^T * ^T -> ^T)> =
    static member inline Add(a : 'T, b : 'T) =
        a + b   // Warning: A type parameter is missing a constraint

This version can be successfully compiled and executed.

[dsyme]

This issue is tracked by #9633. The general problem is that half way through inference a constraint arises that is falsely unified with the explicit consttraint. It's actually fixed in #6805 but that is a long way from going in and it's hard to isolate out the fix and extensive testing.

FWIW you can also omit the explicit type parameter declarations:

let inline addSame (x: 'T) (y: 'T) : 'T = x + y

let inline add<'T when 'T : (static member (+) : 'T * 'T -> 'T)> (a : 'T) (b : 'T) : 'T =
    addSame a b

This actually gives a fairly general technique to avoid this problem -

1. first define a helper function without explicit type parameter declarations, reducing the genericity
2. then call that from your code with explicit type parameter declarations

[dsyme]

I'll close as covered by #9633