Issue comparing Expressions when one value is a constant

[QTom01]

I have discovered an issue when using Expressions in a Setup on a mock object.

It seems using a simple comparison Expression fails to match properly when comparing to a string constant.

The below code should reproduce it:

[Test]
public async Task ExpressionTest()
{
    var s1 = "example";

    // Does not work
    const string s2 = "example";

    // Works
    //var s2 = "example";

    var mock = new Mock<IMockObject>();

    mock.Setup(x => x.Method(y => y.Id == s1))
        .ReturnsAsync("mockResult");

    var result = await mock.Object.Method(x => x.Id == s2);
    // Exprect result to be "mockResult", instead it is null

    Assert.AreEqual(result, "mockResult");
}

public class MyObject
{
    public string Id { get; set; }
}

public interface IMockObject
{
    public Task<string> Method(Expression<Func<MyObject, bool>> expression);
}

The two strings s1 and s2 are the same, however when one of them is a constant then it fails to match the two expressions.

I would expect it should work the same when the string is a constant?

This is on a .NET Core 3.1 test project using Moq 4.14.5 and NUnit 3.12.

[QTom01]

For now I can work around by simply assigning a local variable in the test from the constant and using that instead.

[stakx]

Referencing a constant vs. a variable results in slightly different LINQ expression trees: in the former case, the string value gets embedded as a constant, while in the latter case, the variable gets captured in the form of a reference to an anonymous object's field.

We've had a few similar issues in the past, and the approach followed most recently was that captured variables should be evaluated down to a constant value at the time when two LINQ expression trees get compared.

If we applied this rule here, this present issue would be resolved.

However, at present I am not sure whether this rule should apply in this case. The added complication here is that we have a setup LINQ expression tree that embeds another LINQ expression tree (the argument passed to Method)... and we need to know whether we're allowed to "touch" (here: partially reduce) embedded expression trees or whether we should treat them as constants and always leave them unmodified.

This is probably related to the two principal ways how expression trees can reference other expression trees: Expression.Constant and Expression.Quote. I'm not positively certain that Moq makes this distinction correctly in all situations.

TL;DR: I'll look into it, but this will take some thought and time.