Support for for null-coalescing assignment (??=, C# 8)

[greenozon]

Are there any plans to add support for for null-coalescing assignment(??=, C# 8).

Right now ILSpy produces correct code, but it's huge and not very readable

eg:

orig:

        public void test2()
        {
            List<int> nums = null;
            int? i = null;
            // need C# 8.0+
            nums ??= new List<int>();
            nums.Add(i ??= 12);
            nums.Add(i ??= 122);
            Console.WriteLine(string.Join(" ", nums));
            Console.WriteLine(i);
            
        }

Decompiled as:

public void test2()
{
	List<int> nums = null;
	int? i = null;
	if (nums == null)
	{
		nums = new List<int>();
	}
	List<int> list = nums;
	int valueOrDefault = i.GetValueOrDefault();
	int item;
	if (!i.HasValue)
	{
		valueOrDefault = 12;
		i = valueOrDefault;
		item = valueOrDefault;
	}
	else
	{
		item = valueOrDefault;
	}
	list.Add(item);
	List<int> list2 = nums;
	valueOrDefault = i.GetValueOrDefault();
	int item2;
	if (!i.HasValue)
	{
		valueOrDefault = 122;
		i = valueOrDefault;
		item2 = valueOrDefault;
	}
	else
	{
		item2 = valueOrDefault;
	}
	list2.Add(item2);
	Console.WriteLine(string.Join(" ", nums));
	Console.WriteLine(i);
}

[dgrunwald]

Currently there are no plans.

The case with reference types is quite readable and I don't see much reason to implement ??= for those.
But the case with value types looks more messy than I would have expected, so that's a good reason to implement support for this feature.

[dgrunwald]

In total there are four different pattern here:

1. Statement-level ??= with reference type

	text ??= "Hello";

turns into

	if (text == null)
	{
		text = "Hello";
	}

2. Statement-level ??= with value type

	i ??= 42;

turns into

	int valueOrDefault = i.GetValueOrDefault();
	if (!i.HasValue)
	{
		valueOrDefault = 42;
		i = valueOrDefault;
	}

Not sure why Roslyn generates the i.GetValueOrDefault() call here, it seems to be completely redundant.

3. Expression-level ??= with reference type

	Use(text ??= "Hello");

This currently turns into:

	Use(text ?? (text = "Hello"));

4. Expression-level ??= with value type

	Use(i ??= 42);

This turns into:

	int valueOrDefault = i.GetValueOrDefault();
	int t;
	if (!i.HasValue)
	{
		valueOrDefault = 42;
		i = valueOrDefault;
		t = valueOrDefault;
	}
	else
	{
		t = valueOrDefault;
	}
	Use(t);

[dgrunwald]

Actually there are many more patterns depending on what the target of the assignment is (local, static field, instance field, array element, property, reference).
Like compound assignments, I expect this will turn out surprisingly tricky to implement.

[dgrunwald]

Trying all of those combinations

ArrayElements and RefReturn both use the same code pattern, just using a different source to obtain the reference.
Field accesses do not re-use a reference to the field, they merely cache the object in a compiler-generated local and repeatedly access the field.
Properties look even more messy, with several compiler generated redundant local variables holding the object instance.
Locals I already discussed above.

[dgrunwald]

Comparing with compound assignments, I forgot one case:

            Get<dynamic>().X ??= "Hello";
            Get<dynamic>().Y ??= 42;
            Use(Get<dynamic>().X ??= "Hello");
            Use(Get<dynamic>().Y ??= 42);

Surprisingly this is the case where ILSpy currently produces the most readable code!

	dynamic val = Get<object>();
	if ((object)val.X == null)
	{
		val.X = "Hello";
	}
	val = Get<object>();
	if ((object)val.Y == null)
	{
		val.Y = 42;
	}
	val = Get<object>();
	Use(val.X ?? (val.X = "Hello"));
	val = Get<object>();
	Use(val.Y ?? (val.Y = 42));

This is not too bad, probably rarely used, and sufficiently different from the other cases that I think we should skip dynamic in our implementation.