Wrong ref expression : CS8374

[CreateAndInject]

Original:

using System;
using System.Collections.Generic;

namespace Lsj.Util.Collections
{
    public static class ArrayHelper
    {
        public static (T value, int row, int col)[] ToThreeValueTuples<T>(this T[][] array)
        {
            var result = new List<ValueTuple<T, int, int>>();
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = 0; j < array[i].Length; j++)
                {
                    if (!array[i][j].Equals(default(T)))
                        result.Add((array[i][j], i, j));
                }
            }
            return result.ToArray();
        }
    }
}

ILSpy:

	public static (T value, int row, int col)[] ToThreeValueTuples<T>(this T[][] array)
	{
		List<(T, int, int)> result = new List<(T, int, int)>();
		for (int i = 0; i < array.Length; i++)
		{
			for (int j = 0; j < array[i].Length; j++)
			{
				ref readonly T reference = ref array[i][j];
				T val = default(T);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				if (!reference.Equals(default(T)))
				{
					result.Add((array[i][j], i, j));
				}
			}
		}
		return result.ToArray();
	}

[greenozon]

is it somehow similar to this ? #3419

[CreateAndInject]

is it somehow similar to this ? #3419

Yes, it's the same issue, but now it can be reproduced from source file rather than binary file.

[CreateAndInject]

2 more samples:

      public static void DirectInsertionSort<T>(this IList<T> list) where T : IComparable
      {
          var length = list.Count;
          for (int i = 1; i < length; i++)
          {
              var currentvalue = list[i];
              int j;
              for (j = i - 1; currentvalue.CompareTo(list[j]) < 0 && j > 0; j--)
              {
                  list[j] = list[j - 1];
              }
              if (j + 1 != i)
              {
                  list[j + 1] = currentvalue;
              }
          }
      }

    public class PriorityQueue<T> where T : IComparable<T>
    {
        private T[] data;
        private int maxSize = 7;
        private int nextLayerCount = 8;

        /// <summary>
        /// Initializes a new instance of the <see cref="Lsj.Util.Collections.PriorityQueue{T}"/> class.
        /// </summary>
        public PriorityQueue() => this.data = new T[maxSize];

        /// <summary>
        /// Count
        /// </summary>
        public int Count { get; private set; } = 0;

        /// <summary>
        /// Dequeue
        /// </summary>
        /// <returns></returns>
        public T Dequeue()
        {
            if (Count == 0)
            {
                throw new InvalidOperationException();
            }
            else
            {
                var result = data[0];

                Count--;
                var temp = data[Count];
                var currentIndex = 0;
                while (currentIndex < Count)
                {
                    var rightIndex = (currentIndex + 1) << 1;
                    if (rightIndex < Count && this.data[rightIndex].CompareTo(temp) > 0)
                    {
                        if (this.data[rightIndex - 1].CompareTo(this.data[rightIndex]) > 0)
                        {
                            this.data[currentIndex] = this.data[rightIndex - 1];
                            currentIndex = rightIndex - 1;
                        }
                        else
                        {
                            this.data[currentIndex] = this.data[rightIndex];
                            currentIndex = rightIndex;
                        }
                    }
                    else if (rightIndex - 1 < Count && (this.data[rightIndex - 1].CompareTo(temp) > 0))
                    {
                        this.data[currentIndex] = this.data[rightIndex - 1];
                        currentIndex = rightIndex - 1;
                    }
                    else
                    {
                        break;
                    }
                }
                this.data[currentIndex] = temp;
                return result;
            }
        }

        /// <summary>
        /// Enqueue
        /// </summary>
        /// <param name="value"></param>
        public void Enqueue(T value)
        {
            if (Count == maxSize)
            {
                maxSize += nextLayerCount;
                nextLayerCount *= 2;
                var newBuffer = new T[maxSize];
                Array.Copy(this.data, 0, newBuffer, 0, Count);
                this.data = newBuffer;
            }
            var currentIndex = Count;
            while (currentIndex != 0)
            {
                var topIndex = (currentIndex - 1) >> 1;
                if (this.data[topIndex].CompareTo(value) < 0)
                {
                    this.data[currentIndex] = this.data[topIndex];
                    currentIndex = topIndex;
                }
                else
                {
                    break;
                }
            }
            this.data[currentIndex] = value;
            Count++;
        }
    }