Allowing object initializers for readonly struct properties (CS1918)

[exyi]

Suppose I have a class with a value type property:

class C {
    public S Property { get; set; }
}

Now, C# sensibly disallow using an object/collection initializer when creating C — neither new C { Property = { Another = 1 } } or new C { Property = { 1, 2, 3, 4 } } compiles, it reports: "CS1918: Members of property 'Property' of type 'S' cannot be assigned with an object initializer because it is of a value type.". That is good, because I'd be modifying the copy returned from the getter.

However, if the struct is only a value-type proxy for another object, this error is limiting. Furthermore, if the struct is marked readonly, the pitfall this error prevents cannot ever happen. (Same if just the Another property / Add(X) method are readonly members, but that's beyond my issue).

Is there any change that this limitation could be lifted? Has this been discussed before? I only found a similar issue dotnet/roslyn#29877 about ref properties. Shall I make another one in dotnet/roslyn for this?

---

Why would I want it?

I'd like to migrate a property from List to a different data structure (an intrusive linked list). Making it possible to replace the List with a readonly struct "ListWrapper" would make the change mostly backwards compatible (on source code level). The only working option I found is to keep the List a reference type, but that defeats the main objective of allocating less objects (it won't get optimized away). It would also work change the property to field, but the same error prevent it from being readonly :|

In case you'd want to try it, this is a sharplabable snippet with the mentioned options:

using System.Collections.Generic; using System.Collections;
public class C {
    public static void Test()
    {
        _ = new C { XsProp = { 1, 2 } };
        _ = new C { XsRef = { 1, 2 } };
        _ = new C { XsField = { 1, 2 } };
        _ = new C { XsSetter = { 1, 2 } };
        _ = new C { XsSetter = [ 1, 2 ] }; // requires small code change + is harder to implement for me
    }
    
    private List<int> _xs = [];
    private ListWrapper wrapper;
    public ListWrapper XsProp => new ListWrapper(_xs);
    public ref ListWrapper XsRef => ref wrapper;
    public readonly ListWrapper XsField;
    public ListWrapper XsSetter { get; set; }
}

public struct ListWrapper: IEnumerable<int>
{
    readonly List<int> _xs;
    public ListWrapper(List<int> xs) { this._xs = xs; }
    public void Add(int x) { _xs.Add(x); }

    public IEnumerator<int> GetEnumerator() => _xs.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => _xs.GetEnumerator();
}

[huoyaoyuan]

The properties of (normal) readonly structs can't even have setters. The compiler has no way to know how they can be initialized at all.

Instead, it's more applicable to readonly record struct. Being records, the compiler has have better knowledge about properties and their underlying storage. There are also reusable logic from with operator. The syntax can also use the with operator:

            var c = new C
            {
                Property with { A = 1, B = 2 }
            };

[exyi]

Automatic properties sure cannot have setters, but if I manually implement the setter, it works fine.

public class C {
    public int A;
}

public readonly struct S(C storage) {
    
    public int Property
    {
        get => storage.A;
        set { storage.A = value; }
    }
}

I can even use the object initializer expression on such struct: new S(something) { Property = 1 } also works