Proposal: Opt-out attribute for collection initialization

[louthy]

Collection initializers look for the Add method on a type so that they can repeatedly call Add to initialise a collection. This is problematic for immutable collections that have a default constructor (or are structs).

Example:

    public class Seq<A> : IEnumerable<A>
    {
        A[] values;

        public Seq() =>
            values = new A[0];

        Seq(A[] values) =>
            this.values = values;
        
        public Seq<A> Add(A x)
        {
            var nvalues = new A[values.Length + 1];
            Array.Copy(values, nvalues, values.Length);
            nvalues[values.Length] = x;
            return new Seq<A>(nvalues);
        }

        public IEnumerator<A> GetEnumerator() =>
            values.AsEnumerable().GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() =>
            values.GetEnumerator();
    }

The following will result in an empty collection:

var xs = new Seq<int> { 1, 2, 3, 4 };

My proposal is to allow an attribute called [NoCollectionInitialization] to be applied to the Add method and for the compiler to then ignore it when resolving:

    public class Seq<A> : IEnumerable<A>
    {
        [NoCollectionInitialization]
        public Seq<A> Add(A x)
        {
            var nvalues = new A[values.Length + 1];
            Array.Copy(values, nvalues, values.Length);
            nvalues[values.Length] = x;
            return new Seq<A>(nvalues);
        }
    }

This proposal has no backward compatibility issues and, one would assume, be the lowest impact in terms of code-change.

[CyrusNajmabadi]

Note. This needs no compiler/Roslyn work. Everything above can be handled today already using the analyzer subsystem.

[reflectronic]

Conversely, such a feature could be used to enable collection initializers for arbitrary types, as suggested a few times.