Compile-time branch elimination for null/default equality and constant switch expressions

[Copilot]

After inlining invocations (common in AutoMapper), conditional tests like Constant(null) == Default(typeof(X)) appear — statically evaluable to true but previously not reduced, causing both branches to be emitted and their closure info collected unnecessarily. Similarly, switch expressions with a constant switch value were emitting all case branches instead of only the matching one.

Changes

Conditional branch elimination

• TryReduceConditional — extended to eliminate branches when both sides of Equal/NotEqual represent null: a ConstantExpression with Value == null or a DefaultExpression of a reference type, interface, or Nullable<T>.
• IsNullDefault helper — new Tools.IsNullDefault(Type) using Nullable.GetUnderlyingType() (avoids [RequiresUnreferencedCode] unlike IsNullable()).
• Emit phase — adds a TryReduceConditional fallback after TryInterpretBool fails; the latter only handles primitive-typed comparisons, missing reference-type null checks.
• Collect phase — adds TryReduceConditional before collecting closure info, so dead branches never contribute unnecessary closure slots.

Switch branch elimination (#489)

• Interpreter.TryFindSwitchBranch — new method that detects when a switch value is a compile-time constant (or an interpretable arithmetic expression via TryInterpretInt/TryInterpretPrimitiveValue) and returns only the matching case body. Works for integer/char/enum and string switch values with no custom equality method.
• Emit phase — TryEmitSwitch calls TryFindSwitchBranch first; on success, emits only the matched branch body.
• Collect phase — skips collecting closure info for all dead case branches when the switch value is deterministic.
• Refactor — ConvertValueObjectToLong moved from private EmittingVisitor to internal Interpreter for shared use. Added PValueToLong helper in Interpreter.

Examples

// Conditional: null == Default(string) → always true
var expr = Lambda<Func<string>>(
    Condition(
        Equal(Constant(null, typeof(string)), Default(typeof(string))),
        Constant("live"),
        Constant("dead")));
// CompileFast emits: ldstr "live" / ret

// Switch: constant value selects single branch
var expr = Lambda<Func<string>>(
    Switch(Constant(2),
        Constant("Z"),
        SwitchCase(Constant("A"), Constant(1)),
        SwitchCase(Constant("B"), Constant(2)),
        SwitchCase(Constant("C"), Constant(5))));
// CompileFast emits: ldstr "B" / ret

// Switch: interpreted arithmetic selects single branch
var expr = Lambda<Func<string>>(
    Switch(Add(Constant(1), Constant(4)), /* same cases */));
// CompileFast emits: ldstr "C" / ret  (1+4=5 → case 5)

Conditional covers: null == Default(X), Default(X) == null, Default(X) == Default(X), and null == Default(Nullable<T>) — all with both Equal and NotEqual.

Switch covers: constant integer/enum/char/string switch values and integer arithmetic expressions on constants; falls through to default when no case matches.

[dadhi]

Cool. There is tied up ussue #489. Let see how can address it too reusing and compressing the logic and preserving consistency with as fast and memory efficient and possible. General question - we need to weight time/compute on the elimination check vs actual emit and work of eliminating jit - benchmark?

[Copilot]

Cool. There is tied up ussue #489. Let see how can address it too reusing and compressing the logic and preserving consistency with as fast and memory efficient and possible. General question - we nee...

Addressed issue #489 in commit d4423e8 — added Interpreter.TryFindSwitchBranch which detects when a switch value is a compile-time constant (or interpretable arithmetic expression like 1 + 4) and selects only the matching case body, eliminating all dead branches in both the collect phase (skips dead branch closure collection) and emit phase. Works for integer/enum/char and string switch values. Also refactored ConvertValueObjectToLong from private EmittingVisitor into internal Interpreter so both the existing switch table code and the new TryFindSwitchBranch share it cleanly.

On the benchmark question: the elimination check cost is O(n_cases) comparisons, each O(1) — always dominated by the savings of O(n_non-matching_cases × case_body_complexity) in both closure collection and IL emission. The JIT can't help here since FEC's optimization happens at IL-generation time, before any JIT sees the code. For large switches on constant values (common post-inlining), the speedup can be significant. A dedicated benchmark would be a good follow-up if you want numbers.

[dadhi]

Let add a feeling benchamrk were we compare speed of the execution of switch compiled by System.Compile vs compiled by Fec - first for expr. which is not target for Fec branch elimination to introduce a baseline and second for the expr.with some branch eliminated. Use existing benchmark dotnet project in repo. Makes sense?

[dadhi]

Why do we need this comment if it repeats the actual expression below? I would rather see the reasult of PrintCSharp output for the more compact/evident C# reprrsentation.