Add structural equality and content hashing for FlatExpression.ExprTree by Copilot · Pull Request #550 · dadhi/FastExpressionCompiler

Copilot · 2026-05-06T10:08:02Z

FlatExpression.ExprTree did not support structural equality or stable hashing, which made it fall short of Light/System expressions for content-addressed use cases. This change adds tree-level equality/hash semantics that treat equivalent flat trees as the same key even when parameter identities differ.

What changed
- Added IEquatable<ExprTree> plus Equals, GetHashCode, and == / != for structural comparison of flat expression trees.
- Introduced a stack-friendly structural comparer that walks the flat node graph without heap allocation in the common case.
Structural semantics
- Compares root lambda shape by delegate type, body, parameter count, and parameter types.
- Matches bound parameters and block/catch locals by scope + position rather than node identity.
- Preserves nested lambda capture semantics by tracking scoped parameter ids across flat nodes.
- Compares label targets structurally while preserving identity pairing across goto/label usage.
- Normalizes constants regardless of storage form (inline, closure constant, or boxed payload) for both equality and hashing.
Hashing
- Added content-addressable hashing aligned with structural equality.
- Bound parameters hash by scoped ordinal, so equivalent lambdas/blocks produce the same hash even with different names or cloned flat nodes.
Coverage
- Added focused tests for:
  - equal lambdas with different parameter names
  - nested lambdas with captured outer parameters
  - standalone parameter non-equality
  - dictionary lookup using ExprTree as a key

var x = Parameter(typeof(int), "x");
var left = Lambda<Func<int, int>>(Add(x, Constant(1)), x).ToFlatExpression();

var y = Parameter(typeof(int), "arg");
var right = Lambda<Func<int, int>>(Add(y, Constant(1)), y).ToFlatExpression();

left.Equals(right);              // true
left.GetHashCode() == right.GetHashCode(); // true

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/8bcf787b-adee-4401-8721-4587fe7cb997 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

dadhi · 2026-05-06T10:26:00Z


+    /// <summary>Reconstructs the boxed constant value from the node's inline 32-bit payload.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static object ReadInlineConstantValue(Type type, uint data)


I do not like boxing here. Instead of returning object let call the GetHash inside the return the GetHash directly.

Updated in f933b56. Inline constant hashing now goes straight through typed hash paths without reconstructing boxed values.

dadhi · 2026-05-06T10:28:22Z

+            return node.Obj?.GetHashCode() ?? 0;
+        }
+
+        private static object GetConstantValue(ExprTree tree, ref ExprNode node)


Let avoid the boxing. If we need to compare and call equals do the switch for the constant type and name method ConstantEquals instead.

Updated in f933b56. Constant comparison now uses a dedicated typed helper (AreConstantsEqual) and avoids boxing for inline primitive constants.

dadhi · 2026-05-06T10:30:47Z

+            if (!EqObj(xTree, ref x, yTree, ref y))
+                return false;
+
+            return EqChildren(xTree.GetChildren(xIdx), xTree, yTree.GetChildren(yIdx), yTree);


EqChildren used once - inline it.

Updated in f933b56. The one-use child comparison helper is gone; the traversal is inlined into the loop-based comparer.

dadhi · 2026-05-06T10:31:40Z

+        private static int Combine(int h1, int h2) =>
+            unchecked(h1 ^ (h2 + (int)0x9e3779b9 + (h1 << 6) + (h1 >> 2)));
+
+        private bool EqNode(ExprTree xTree, int xIdx, ExprTree yTree, int yIdx)


Why do we copy ExprTree structs here?

Updated in f933b56. The comparer/hash entry points now pass ExprTree by ref, so the structural traversal no longer copies the tree structs.

dadhi · 2026-05-06T10:35:58Z

+        private static int Combine(int h1, int h2) =>
+            unchecked(h1 ^ (h2 + (int)0x9e3779b9 + (h1 << 6) + (h1 >> 2)));
+
+        private bool EqNode(ExprTree xTree, int xIdx, ExprTree yTree, int yIdx)


I do not the recursive implementation. In the linked issue I have specifically said that we need to purse loop based comparison because we have natural links ChildId -> NextId (switch to child if it has one) -> back to parent. Please implement the comparison in a single method. Use helper for multiple same blocks of code only.

Updated in f933b56. Equality now uses a single loop-based traversal over the flat links with explicit sibling tracking instead of recursive descent.

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/340a2774-3537-47bb-b6cb-038b55aec114 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

dadhi · 2026-05-06T11:06:10Z

    public int RootIdx;

    /// <summary>Gets or sets the flat node storage.</summary>
    public SmallList<ExprNode, Stack16<ExprNode>, NoArrayPool<ExprNode>> Nodes;


This comparison it too complecated - we already have unified ExprNode representation for expression.
So instead of checking its NodeType we can mask ChildIdx and NextIdx and compare the rest bit by bit.
Please check this approach.
Then we can just go to ChildIdx or to NextIdx - that's it.

Updated in 023bb11. The comparer now uses masked ExprNode shape checks for the common precheck path, so the loop compares unified node layout first and keeps the existing special handling only where structural semantics differ.

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/5b87e13e-991a-4ea4-aab8-266df9dda7fd Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

dadhi

missing public xml comments break ci

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/306086af-4c82-4f97-9286-a3fe568d3f9a Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Copilot · 2026-05-07T10:11:40Z

missing public xml comments break ci

Fixed in 14f0c05. Added the missing XML comments for ExprTree == and !=, and the LightExpression multi-target build now passes cleanly.

dadhi · 2026-05-27T21:42:38Z

+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool GetInlineOrStoredBoolean(ref ExprTree tree, ref ExprNode node) =>


@copilot Is it even possible in our FE design that bool can be stored not inline? If not - why
do we have this unboxing code, the same for other types up to 4 bytes

Fixed in b1874d8. bool and the other <=4-byte primitive constants are now treated as normalized inline values in the FE path, and ExprTree.ConstantInt was updated to inline as well, so those unboxing helpers were removed. The remaining non-inline fallback is only a defensive object-equality path for externally hand-crafted non-normalized nodes.

@copilot Let just Debug.Assert that such nodes can not be constructed - or do some other outline check. We need to assume that the node is correct and the users know what they doing - and if possible make all the necessary check or assert in the constructions time

Addressed in 005b4bf. Small primitive and small-backed enum constants now assert at construction time if they bypass inline storage, and the structural constant compare/hash path no longer keeps the defensive non-inline fallback.

dadhi · 2026-05-28T12:27:43Z

+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool GetInlineBoolean(ref ExprNode node) => node.InlineValue != 0;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static byte GetInlineByte(ref ExprNode node) => (byte)node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static sbyte GetInlineSByte(ref ExprNode node) => (sbyte)(byte)node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static char GetInlineChar(ref ExprNode node) => (char)(ushort)node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static short GetInlineInt16(ref ExprNode node) => (short)(ushort)node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ushort GetInlineUInt16(ref ExprNode node) => (ushort)node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int GetInlineInt32(ref ExprNode node) => (int)node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint GetInlineUInt32(ref ExprNode node) => node.InlineValue;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static float GetInlineSingle(ref ExprNode node) => FloatBits.ToFloat(node.InlineValue);


@copilot Why do we need this methods just to compare the same x.InlineValue == y.InlineData

Updated in 0c059a4. The inline constant comparison now uses the normalized InlineValue directly for the small primitive cases, and keeps only the float path special so structural equality still follows Single.Equals semantics.

Initial plan

8ae2d11

Copilot AI assigned Copilot and dadhi May 6, 2026

Copilot started work on behalf of dadhi May 6, 2026 10:08 View session

Copilot AI linked an issue May 6, 2026 that may be closed by this pull request

FlatExpression: structural equality and hash for content addressing #530

Open

Copilot AI and others added 2 commits May 6, 2026 10:16

feat: add structural equality for flat expressions

176af12

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/8bcf787b-adee-4401-8721-4587fe7cb997 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

docs: clarify flat inline constant decoding

8fc6aff

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/8bcf787b-adee-4401-8721-4587fe7cb997 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Copilot AI changed the title ~~[WIP] Fix structural equality and hash for FlatExpression~~ Add structural equality and content hashing for FlatExpression.ExprTree May 6, 2026

Copilot finished work on behalf of dadhi May 6, 2026 10:19

Copilot AI requested a review from dadhi May 6, 2026 10:19

dadhi requested changes May 6, 2026

View reviewed changes

Copilot started work on behalf of dadhi May 6, 2026 10:36 View session

Copilot AI and others added 3 commits May 6, 2026 10:49

refactor: use loop-based flat expression equality

f933b56

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/340a2774-3537-47bb-b6cb-038b55aec114 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

refactor: simplify flat equality loop control

50deedb

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/340a2774-3537-47bb-b6cb-038b55aec114 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

refactor: rename flat constant comparison helper

a1f952f

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/340a2774-3537-47bb-b6cb-038b55aec114 Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Copilot finished work on behalf of dadhi May 6, 2026 10:56

Copilot AI requested a review from dadhi May 6, 2026 10:56

dadhi requested changes May 6, 2026

View reviewed changes

Copilot started work on behalf of dadhi May 6, 2026 11:06 View session

refactor: simplify expr node equality precheck

023bb11

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/5b87e13e-991a-4ea4-aab8-266df9dda7fd Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Copilot AI requested a review from dadhi May 6, 2026 11:17

Copilot finished work on behalf of dadhi May 6, 2026 11:17

dadhi requested changes May 7, 2026

View reviewed changes

Copilot started work on behalf of dadhi May 7, 2026 10:07 View session

docs: add xml comments for expr tree operators

14f0c05

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/306086af-4c82-4f97-9286-a3fe568d3f9a Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Copilot finished work on behalf of dadhi May 7, 2026 10:12

Copilot AI requested a review from dadhi May 7, 2026 10:12

dadhi requested changes May 27, 2026

View reviewed changes

Copilot started work on behalf of dadhi May 27, 2026 21:43 View session

refactor: inline small flat constants

b1874d8

Copilot finished work on behalf of dadhi May 27, 2026 21:52

Copilot AI requested a review from dadhi May 27, 2026 21:52

Copilot started work on behalf of dadhi May 28, 2026 10:25 View session

refactor: assert normalized flat constants

005b4bf

Copilot finished work on behalf of dadhi May 28, 2026 10:33

dadhi reviewed May 28, 2026

View reviewed changes

dadhi requested changes May 28, 2026

View reviewed changes

Copilot started work on behalf of dadhi May 28, 2026 12:29 View session

refactor: simplify inline constant comparison

0c059a4

Copilot finished work on behalf of dadhi May 28, 2026 12:34

Copilot AI requested a review from dadhi May 28, 2026 12:34

Uh oh!

Conversation

Copilot AI commented May 6, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 6, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 6, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 6, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 6, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 6, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 6, 2026

Choose a reason for hiding this comment

Uh oh!

dadhi left a comment

Choose a reason for hiding this comment

Uh oh!

Copilot AI commented May 7, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 27, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 28, 2026

Choose a reason for hiding this comment

Uh oh!

dadhi May 28, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI May 28, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

Copilot AI commented May 6, 2026 •

edited

Loading

dadhi May 28, 2026 •

edited

Loading