LINQ methods respect the configured casing

[victorr99]

The ExpressionParser was updated with a new method allowing case insensitive compares whenever this was configured in the ParserConfig.

The method CanonicalContains performs a case insensitive check whenever IsCaseSensitive was set to false. It also updates the provided needle parameter to the actual found value. Thus a match on max will be translated to Max.

This fixes issue #967

[StefH]

And will this not break any code where a Class has a property max?

Like

public class X
{
  public string max { get ; set; }

   public string MAX { get ; set; }
}

Maybe add a unit test for this.

[StefH]

no need to use ref

just do:

if (_parsingConfig.IsCaseSensitive)
{
    return haystack.Contains(needle);
}

return haystack.Any(s => string.Equals(s, value, StringComparison.OrdinalIgnoreCase));

[victorr99]

I've changed the method to just Contains. It indeed works without using ref, so I've removed that.
I've tried to add some unit tests with a max property. Is this what you had in mind?

[victorr99]

@StefH can you have a look again at the PR?

[victorr99]

@StefH any updates?

[StefH]

I'm still thinking about backward compatibility...

[victorr99]

The only compatability issue I can think of is that a custom enumerable object is being used which specifies Min and Max methods on its own. Think of the following class:

public class CustomEnumerable<T> : IEnumerable<T>
{
    public int Max { get; set; }

    public int Min()
    {
    }
}

The Max property can easily be distinguished from the method because the parantheses makes it a method, unless it's a delegate like Func<int>. For the Min method and (the Func<int> Max property), the implementation of the CustomEnumerable should be choosen.
I have never needed to use a custom enumerable class, but I can imagine that there are use cases for that. I can add extra tests which checks that the methods of the custom enumerable are choosen over the extension methods, however I don't think proper support for custom enumerables has ever existed. The following code returns 15, but it should return 0:

public class CustomEnumerable<T>(IEnumerable<T> inner) : IEnumerable<T>
{
    public T Max { get; set; }

    public DateTime Min()
    {
        return default;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return inner.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

var parameter = Expression.Parameter(typeof(CustomEnumerable<int>), "list");

var parser = new ExpressionParser(
    [parameter],
    "list.Min()",
    [],
    new ParsingConfig { IsCaseSensitive = false });

var expression = parser.Parse(typeof(int));
var lambda = Expression.Lambda<Func<CustomEnumerable<int>, int>>(expression, parameter);
var method = lambda.CompileFast();

Console.WriteLine(method(new CustomEnumerable<int>([15])));

So, I assume fixing it the right way introduces another backward compatability issue, or the CustomEnumerable example is a new bug.

By the way, you asked for extra tests which covers the Min and Max properties on a class. I don't think it adds extra value to the other test cases since LING is being applied to an enumerable of objects. It is not an extension for that object/class.