IDE0305 recommends collection expression that results in worse IL

[stephentoub]

Version Used:
Version 17.9.0 Preview 1.0 [34231.268.main]

Steps to Reproduce:

static int[] GetArray(List<int> list) => list.ToArray(); 

IDE0305 recommends rewriting this to:

static int[] GetArray(List<int> list) => [.. list];

which would be fine if that still compiled down to a list.ToArray() call, but instead it compiles down to the equivalent of:

int[] array = new int[list.Count];
int num = 0;
foreach (int item in list)
{
    array[num] = item;
    num++;
}

which is significantly less efficient, especially for longer lists where the entire copy would instead be done as a vectorized memcpy invocation.

It's also worse if the list was actually empty: List<T>.ToArray() will return an empty array singleton if the count is 0, but the above code will end up always allocating a new empty array 😦

cc: @cston, @CyrusNajmabadi

[CyrusNajmabadi]

Compiler is allowed to, and should use the best emit here. For bcl types, that should be ToArray. Tagging @RikkiGibson

[RikkiGibson]

I agree that we should fix by improving emit here.

It sounds like this would be a special case for a collection-expr of a single spread expression? Are there any other possible spread types where we should be looking for a ToArray method? e.g. Span<int> span = ...; int[] arr = [..span];?

Also, suppose we have a similar case ImmutableArray<int> ia = [..list]. Should we use ToArray then AsImmutableArray? Should we look for an AsImmutableArray method?

[CyrusNajmabadi]

We should special case as many reasonable cases as possible. But we can do it as bug fixes imo. Generally, if it's a trivial check (checking a few types and a few elements), then we should do it. Ideally in a way that is easy to maintain and enhance in the future! :-)

[RikkiGibson]

I was hoping to take this optimization and generalize it somewhat: instead of just improving the situation for collection-exprs like [..span], improve it for more complex scenarios like [..span1, ..span2, .., spanN] or [..span1, elem1, ..span2, elem2] and so on.

I thought we could do this with 2 changes:

1. Emit a length check on the input collections, when a collection-expr consists only of spreads. When length is 0 use Array.Empty.
2. Use CopyTo where applicable to copy the input collection into the appropriate section of the resulting array.

I tried to benchmark to prove out the viability of this. However, I was surprised by the results, especially that the ToArray case doesn't seem to be allocating. I think there might be something wrong with my benchmark. Results and source below:

edit: out of date.

// * Summary *

BenchmarkDotNet v0.13.10, Windows 11 (10.0.22621.2715/22H2/2022Update/SunValley2)
AMD Ryzen 9 3900X, 1 CPU, 24 logical and 12 physical cores
.NET SDK 8.0.100
  [Host]     : .NET 8.0.0 (8.0.23.53103), X64 RyuJIT AVX2
  DefaultJob : .NET 8.0.0 (8.0.23.53103), X64 RyuJIT AVX2

Method	N	Mean	Error	StdDev	Gen0	Allocated
CopyTo	0	0.2060 ns	0.0151 ns	0.0126 ns	-	-
ToArray	0	0.0436 ns	0.0198 ns	0.0185 ns	-	-
CopyTo	10	8.6380 ns	0.2261 ns	0.5956 ns	0.0076	64 B
ToArray	10	0.0505 ns	0.0143 ns	0.0134 ns	-	-
CopyTo	10000	698.3151 ns	6.7082 ns	15.1415 ns	4.7617	40024 B
ToArray	10000	0.0836 ns	0.0498 ns	0.0466 ns	-	-

using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace MyBenchmarks
{
    [MemoryDiagnoser]
    public class CopyToBenchmarks
    {
        [Params(0, 10, 10000)]
        public int N;
        private readonly int[] data;


        public CopyToBenchmarks()
        {
            data = new int[N];
            var random = new Random();
            for (var i = 0; i < data.Length; i++)
            {
                data[i] = random.Next();
            }
        }

        [Benchmark]
        public int[] CopyTo()
        {
            int[] dest;
            if (N == 0)
            {
                dest = Array.Empty<int>();
            }
            else
            {
                dest = new int[N];
                data.CopyTo(dest.AsSpan());
            }
            return dest;
        }

        [Benchmark]
        public int[] ToArray()
        {
            int[] dest = data.AsSpan().ToArray();
            return dest;
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<CopyToBenchmarks>();
        }
    }
}

Any insight on what could be happening here would be appreciated. I also tried comparing JIT ASM for ToArray versus CopyTo and...yeah, I found they looked totally different and didn't know how to meaningfully compare them.

[CyrusNajmabadi]

@RikkiGibson are you sure the N is set before the constructor runs? If not, you will always have empty arrays.