[Proposal] Collection expressions for custom types should call a constructor that takes an int, if possible

[BlinD-HuNTeR]

One of the nice features of collection expressions is the "known length", when the compiler knows the total number of elements in advance, it can use that information to preallocate the resulting storage and avoid reallocations.

But currently this feature works only with the builtin types, you can't construct a custom collection type that takes advantage of it.

The following example demonstrates this:

public class MyList<T> : List<T>
{
    //Doesn't actually need to inherit from List<T>, did it just as an example
    public MyList() { }
    public MyList(int capacity) : base(capacity) { }
}

List<int> list = [1, 2, 3]; //lowered as "new List<int>(3) { 1, 2, 3 }"
MyList<int> myList = [1, 2, 3]; //lowered as "new MyList<int>() { 1, 2, 3 }"

My proposal is that, for types implementing the IEnumerable/Add pattern, collection expressions could also look for a constructor that takes an int, and if the length is known, that constructor will be invoked with the known length.

Another cool consequence of this, is that it will be possible for someone to make a collection type that only exposes the int constructor, and the result is that, such a collection will only be constructible when the length is known. I suppose this could be nice for perf-oriented projects (Roslyn?), to force the developers to write code that avoids reallocations, as it would not compile.

[TahirAhmadov]

There was discussion about this - I don't remember whether it was LDM notes or elsewhere - and they looked into generalizing this and decided against it for now. They considered just int constructor, and int capacity constructor, and a couple of other options if memory serves me right.
Perhaps somebody has the link to that material.

[CyrusNajmabadi]

If we were to do this, we'd require the parameter to be called int capacity. We def found cases where an int could mean somethign else.

[BlinD-HuNTeR]

Alternatively it could also be required that the constructor has some special attribute to identify it as a collection constructor. This it would prevent it from erroneously picking constructors from existing code.