Can you check if this impacts size with NativeAOT?

The dead branch elimination in NativeAOT only considers things that have feature switches. It doesn't attempt to inline things.

I think this is changing things from if (false && CanInterpret && preferInterpretation) to if (CanInterpret && preferInterpretation) (no longer a known constant).

Could be fixed by creating a substitution rule for CanInterpret as well.

(Either that or beefing up the dead branch elimination in NativeAOT. The dead branch elimination in NativeAOT is simpler than in linker because: 1. linker's one is super scary and I don't want to have to deal with the bugs in it that I would get by porting it, and 2. longer term, we should have RyuJIT do the dead branch elimination. RyuJIT is much better at it than anything we would write specifically for trimming.)

Or maybe this is fine now that I look at it for longer?

There are 2 reasons why I'm proposing this change.

1. Logically, the condition doesn't make sense. Why would CanCompileToIL need to be true in order for preferInterpretation be respected?
2. Looking at what it functionally does:
   

   runtime/src/libraries/System.Linq.Expressions/src/System/Linq/Expressions/LambdaExpression.cs

   Lines 137 to 163 in 7392fb7

   	public Delegate Compile()
   	{
   	if (CanCompileToIL)
   	{
   	return Compiler.LambdaCompiler.Compile(this);
   	}
   	else
   	{
   	Debug.Assert(CanInterpret);
   	return new Interpreter.LightCompiler().CompileTop(this).CreateDelegate();
   	}
   	}
   	/// <summary>
   	/// Produces a delegate that represents the lambda expression.
   	/// </summary>
   	/// <param name="preferInterpretation">A <see cref="bool"/> that indicates if the expression should be compiled to an interpreted form, if available.</param>
   	/// <returns>A delegate containing the compiled version of the lambda.</returns>
   	public Delegate Compile(bool preferInterpretation)
   	{
   	if (CanCompileToIL && CanInterpret && preferInterpretation)
   	{
   	return new Interpreter.LightCompiler().CompileTop(this).CreateDelegate();
   	}
   	return Compile();
   	}

   
   If CanCompileToIL == false, the same code (return new Interpreter.LightCompiler().CompileTop(this).CreateDelegate();) is going to be executed regardless.

Yes, I think it makes sense to do. I'm responsible for introducing this in #61952.

That pull request was a mechanical replacement of #defines. The code originally looked like:

        public Delegate Compile(bool preferInterpretation)
        {
#if FEATURE_COMPILE && FEATURE_INTERPRET
            if (preferInterpretation)
            {
                return new Interpreter.LightCompiler().CompileTop(this).CreateDelegate();
            }
#endif
            return Compile();
        }

On a second look, the original code doesn't make that much more sense either...