sortedList.DeepClone() and immutableDictionary.DeepClone() don't compile (CS0121 ambiguous between the IDictionary and IReadOnlyDictionary overloads)

[matt-edmondson]

What's wrong

SortedList<TKey,TValue>, ImmutableDictionary<TKey,TValue> and ImmutableSortedDictionary<TKey,TValue> each implement both IDictionary<TKey,TValue> and IReadOnlyDictionary<TKey,TValue>. DeepCloneContainerExtensions has an extension for each interface (DeepClone(this IDictionary<,>) at line 148 and DeepClone(this IReadOnlyDictionary<,>) at line 268), and neither is more specific, so calling .DeepClone() directly on these types fails to compile.

#81 (commit dad2dfc) fixed this ambiguity for ConcurrentDictionary and ReadOnlyDictionary by adding concrete overloads. The three types above still have the problem. The existing ImmutableDictionary test avoids it by cloning each value by hand instead of calling the extension, so the tests don't catch it.

Reproduction

using System.Collections.Immutable;
using ktsu.DeepClone;

var a = new SortedList<string, int> { ["a"] = 1 }.DeepClone();
var b = ImmutableDictionary<string, int>.Empty.Add("a", 1).DeepClone();
var c = ImmutableSortedDictionary<string, int>.Empty.Add("a", 1).DeepClone();

error CS0121: The call is ambiguous between the following methods or properties:
'DeepCloneContainerExtensions.DeepClone<TKey, TValue>(IDictionary<TKey, TValue>)' and
'DeepCloneContainerExtensions.DeepClone<TKey, TValue>(IReadOnlyDictionary<TKey, TValue>)'

(Reproduced against the net10.0 build of current main.)

Why it matters

The README says the library clones standard collections, but a caller holding a SortedList or an immutable dictionary has to cast to one of the interfaces first. The IDictionary path then returns a plain Dictionary and loses the comparer and the sort order (tracked in #83). No cast gives back the type they started with.

Suggested fix / acceptance criteria

• Add concrete overloads, matching the dictionary.DeepClone() fails to compile (CS0121 ambiguous call) for Dictionary, SortedDictionary and ConcurrentDictionary, although the XML doc example shows that call #81 fix, that return the same type and keep its comparer:
  • SortedList<K,V> DeepClone(this SortedList<K,V>) built with new SortedList<K,V>(source.Count, source.Comparer)
  • ImmutableDictionary<K,V> DeepClone(this ImmutableDictionary<K,V>) built with ImmutableDictionary.CreateRange(source.KeyComparer, source.ValueComparer, clonedPairs)
  • ImmutableSortedDictionary<K,V> DeepClone(this ImmutableSortedDictionary<K,V>) built with source.KeyComparer and source.ValueComparer
• Add tests that call .DeepClone() directly on each type (so the test fails to compile if the ambiguity comes back), and check the result type, comparer and cloned values.

[matt-edmondson]

Triage

• Category: Bug
• Priority: Medium. Calling .DeepClone() on SortedList, ImmutableDictionary or ImmutableSortedDictionary fails to compile with CS0121. Because it is a compile error, nothing goes wrong silently at runtime. But the only workaround is a cast, and the cast loses the collection type and its comparer (see Deep cloning a ConcurrentDictionary, SortedList or ImmutableDictionary through IDictionary drops its key comparer: lookups start failing, and a reference-equality source throws ArgumentException #83).
• Area / suggested owner: DeepCloneContainerExtensions. Add concrete overloads following the dictionary.DeepClone() fails to compile (CS0121 ambiguous call) for Dictionary, SortedDictionary and ConcurrentDictionary, although the XML doc example shows that call #81 fix (commit dad2dfc).
• Duplicates / in progress: It continues the closed dictionary.DeepClone() fails to compile (CS0121 ambiguous call) for Dictionary, SortedDictionary and ConcurrentDictionary, although the XML doc example shows that call #81. It overlaps with Deep cloning a ConcurrentDictionary, SortedList or ImmutableDictionary through IDictionary drops its key comparer: lookups start failing, and a reference-equality source throws ArgumentException #83, which covers comparer loss for the same types through IDictionary, and with ReadOnlyDictionary.DeepClone() drops the wrapped dictionary's key comparer: a case-insensitive source's clone can't find "KEY" #87. The concrete overloads proposed here would fix the direct-call part of Deep cloning a ConcurrentDictionary, SortedList or ImmutableDictionary through IDictionary drops its key comparer: lookups start failing, and a reference-equality source throws ArgumentException #83 as well. No open PR covers it.
• Notes: The proposed tests call .DeepClone() directly, so the test project stops compiling if the ambiguity comes back. Keep that approach.

---

Generated by Claude Code