Cannot infer generic usage (But should be able to as far as I can tell?)

[thomhurst]

I am working on an assertion library, and I have some generic constraints which are fairly complicated, in order to chain calls, and only show methods relevant for the object they're asserting on.

I have an issue where I'm trying to create an extension method for a dictionary to assert that it contains a key.

For this method, I only really care about the type of Key for the dictionary. But to keep the generic information, I also need to expose a generic TValue type, even though I don't care about that. This is where it starts falling apart, as this TValue type is causing my problems with inferring the usage.

Here's my method:

    public static BaseAssertCondition<TDictionary, TAnd, TOr> ContainKey<TDictionary, TKey, TValue, TAnd, TOr>(this Does<TDictionary, TAnd, TOr> does, TKey expected, [CallerArgumentExpression("expected")] string doNotPopulateThisValue = "") 
        where TDictionary : IDictionary<TKey, TValue>
        where TAnd : And<TDictionary, TAnd, TOr>, IAnd<TAnd, TDictionary, TAnd, TOr>
        where TOr : Or<TDictionary, TAnd, TOr>, IOr<TOr, TDictionary, TAnd, TOr>
    {
        return AssertionConditionCombiner.Combine(does, new DelegateAssertCondition<TDictionary, TKey, TAnd, TOr>(
            does.AssertionBuilder.AppendCallerMethod(doNotPopulateThisValue),
            expected,
            (actual, _, _, self) =>
            {
                ArgumentNullException.ThrowIfNull(actual);
                return actual.ContainsKey(expected);
            },
            (actual, _) => $"The key \"{expected}\" was not found in the dictionary"));
    }

Now because there is not TValue parameter being passed into that method, the compiler tells me it can't infer the type properly.

However, you can see that this method is an extension method. So surely it already knows that it's working off of a Dictionary<string, byte[] object, so why do I need to tell it the types again? As far as I can see, it should already know every type available based off of the dictionary object that it has been passed?

Because the compiler is now asking the user to pass the generic types in (and this obviously being a complicated generic constraint) it makes my library very unfriendly to use for users.

Edit:
Here's a much more simple constraint but still shows the compiler can't work it out:

public static class Program
{
    public static void Main(string[] args)
    {
        var dictionary = new Dictionary<string, byte[]>
        {
            ["Blah"] = []
        };
        
        dictionary.CustomContainsKey("1");
    }
}

public static class Extensions
{
    public static void CustomContainsKey<TDictionary, TKey, TValue>(this TDictionary dictionary, TKey key)
        where TDictionary : IDictionary<TKey, TValue>
    {
        // ...
    }
}

[ufcpp]

#6930