更好地从集合表达式元素进行转换

支持者问题：https://github.com/dotnet/csharplang/issues/8374

总结

更新更好的转换规则，以与 params更加一致，并更好地处理当前的模糊场景。 例如，ReadOnlySpan<string> 与 ReadOnlySpan<object> 在当前 [""]的重载解析过程中可能会导致歧义。

详细设计

以下是较好的表达式转换规则。 这些规则将替换 https://github.com/dotnet/csharplang/blob/main/proposals/csharp-12.0/collection-expressions.md#overload-resolution中的规则。

这些规则包括：

给定隐式转换 C₁，它将表达式 E 转换为类型 T₁，以及隐式转换 C₂，它将表达式 E 转换为类型 T₂，C₁ 是 比 C₂ 更好的转换，如果满足以下任一条件：

• E 是 集合表达式，C₁ 是比 C₂ 表达式更优的集合转换
• E 不是 集合表达式，并且以下任一条件成立：
  • E 完全匹配 T₁，E 与 T₂ 不完全匹配
  • E 要么与 T₁ 和 T₂完全匹配，要么都不匹配，而 T₁ 是比 T₂ 更好的 转换目标
• E 是方法组...

我们为 添加一个新定义，以便更好地将表达式转换成集合，如下所示：

假定为：

• E 是一个包含元素表达式 [EL₁, EL₂, ..., ELₙ] 的集合表达式
• T₁ 和 T₂ 是集合类型
• E₁ 是 T₁ 的元素类型
• E₂ 是 T₂ 的元素类型
• CE₁ᵢ 是从 ELᵢ 到 E₁ 的一系列转换
• CE₂ᵢ 是从 ELᵢ 到 E₂ 的一系列转换

如果存在从 E₁ 到 E₂的标识转换，则元素之间的转换效果同样出色。 否则，到 E₁ 的元素转换 优于元素转换 到 E₂（如果：

• 对于每个 ELᵢ，CE₁ᵢ 至少和 CE₂ᵢ一样好，而且
• 至少有一个 i，其中 CE₁ᵢ 比 CE₂ᵢ 更好。否则，两组元素转换都不比另一组更好，它们也不如彼此一样好。
  如果 ELᵢ 不是一个 spread 元素，则使用更好的表达式转换进行转换比较。 如果 ELᵢ 是展开元素，我们可以分别更加有效地将展开集合的元素类型转换为 E₁ 或 E₂。

C₁ 是一种表达式更好的集合转换（相较于 C₂），但前提是：

• T₁ 和 T₂ 都不是 跨度类型，T₁ 可隐式转换为 T₂，而 T₂ 不能隐式转换为 T₁，或者...
• E₁ 没有到 E₂ 的标识转换，并且到 E₁ 的元素转换优于到 E₂的元素转换，或者
• E₁ 对 E₂ 进行标识转换，且以下条件之一成立：
  • T₁ 是 System.ReadOnlySpan<E₁>，T₂ 是 System.Span<E₂>，或者
  • T₁ 是 System.ReadOnlySpan<E₁> 或 System.Span<E₁>，且 T₂ 是具有元素类型E₂的 array_or_array_interface

否则，两个集合类型都不更好，结果不明确。

public void M(ReadOnlySpan<int> ros) { ... }
public void M(Span<int?> span) { ... }

M([]); // Ambiguous

场景：

在纯英语中，集合类型本身必须相同， 或明确更好的（即，List<T> 和 List<T> 是相同的，List<T> 明显优于 IEnumerable<T>，并且无法比较 List<T> 和 HashSet<T>），更好的集合类型的元素转换也必须相同或更好（即，我们不能在 ReadOnlySpan<object> 和 Span<string> 之间决定 [""]， 用户需要做出该决定。 更多示例包括：

开放性问题

我们应在多大程度上优先考虑 ReadOnlySpan/Span 而非其他类型？

按照现在的规定，下列重载将是模棱两可的：

C.M1(["Hello world"]); // Ambiguous, no tiebreak between ROS and List
C.M2(["Hello world"]); // Ambiguous, no tiebreak between Span and List

C.M3(["Hello world"]); // Ambiguous, no tiebreak between ROS and MyList.

C.M4(["Hello", "Hello"]); // Ambiguous, no tiebreak between ROS and HashSet. Created collections have different contents

class C
{
    public static void M1(ReadOnlySpan<string> ros) {}
    public static void M1(List<string> list) {}

    public static void M2(Span<string> ros) {}
    public static void M2(List<string> list) {}

    public static void M3(ReadOnlySpan<string> ros) {}
    public static void M3(MyList<string> list) {}

    public static void M4(ReadOnlySpan<string> ros) {}
    public static void M4(HashSet<string> hashset) {}
}

class MyList<T> : List<T> {}

我们打算走多远？ List<T> 变体似乎很合理，List<T> 的子类型存在大量。 但是，HashSet 版本具有截然不同的语义，我们到底有多确定它在这个 API 中比 ReadOnlySpan 更糟糕呢？