I have a scenario where F# can't decide which overload of a method (function in a class) to call. Basically the problem is that I have two overloads in a C# class, one of them with explicitly typed parameters, the other one with generic parameters. I've done some simplified tests which didn't show the same problem, but I managed to create a basic example that reproduces the issue. There seems to be something relevant about the precise implementation of the methods that makes this come up.
This is the class I have in C#:

public class BaseClass {
public bool SetPropertyValue(string propertyName, ref int property, int newValue) {
return SetEquatablePropertyValue(propertyName, ref property, newValue);
}

private bool SetEquatablePropertyValue<T>(string propertyName, ref T property, T newValue) where T : IEquatable<T> {
T oldValue = property;
if (oldValue.Equals(newValue))
return false;
property = newValue;

// do other stuff, like change notification

return true;
}

public bool SetPropertyValue<T>(string propertyName, ref T property, T newValue) {
// same as above, but using a more complex algorithm for equality checking
return true;
}
}

And this is the F# code I'm trying to use:

type DerivedClass =
inherit BaseClass as base
new() = { inherit BaseClass(); var = 0 }

val mutable private var: int
member public x.Var
with get() = x.var
and set(v) = base.SetPropertyValue("Var", ref x.var, v) |> ignore

let c = new DerivedClass()
c.Var <- 42

When I try to compile this, I get the following error message:

error FS0041: The method 'SetPropertyValue' is overloaded. Possible matches are shown below (or in the Error List window).

Possible overload: 'BaseClass.SetPropertyValue(string propertyName, int byref property, int newValue) : bool'.

Possible overload: 'BaseClass.SetPropertyValue<'T>(string propertyName, 'T byref property, 'T newValue) : bool'.

Why does this problem come up with the precise C# class I have? And how do I resolve that conflict?

Thanks
Oliver