chore: follow projections on param edges

Author: indietyp

libs/@local/hashql/mir/src/pass/analysis/data_dependency/resolve.rs

@@ -188,6 +188,20 @@ fn traverse<'heap, A: Allocator + Clone>(
 /// constants). This function checks whether all non-cyclic predecessors, from both
 /// sources, resolve to the same value.
 ///
+/// # Projection-aware consensus
+///
+/// When the queried place has a projection suffix (e.g., resolving `x.0` where `x` is a
+/// block parameter), consensus is checked on the *fully resolved* result per predecessor,
+/// not on the partially resolved predecessor bases. This is necessary because different
+/// predecessor locals can still agree on a projected field.
+///
+/// For example, if predecessor A passes `(42, u)` and predecessor B passes `(42, v)`,
+/// the bases disagree but `A.0 == B.0 == 42`. The algorithm resolves each predecessor
+/// through the full projection suffix before comparing, so this case correctly yields
+/// `Resolved(42)` rather than `Incomplete(x.0)`.
+///
+/// # Cycle handling
+///
 /// Cyclic predecessors ([`Backtrack`]) are filtered out before consensus checking.
 /// Since [`Param`] edges are identity transfers, the value is fully determined by
 /// the non-cyclic init edges. If only cyclic predecessors exist (no external source),
@@ -236,12 +250,35 @@ fn resolve_params<'heap, A: Allocator + Clone>(
     };
 
     // Resolve all predecessor candidates and check consensus.
+    //
+    // When the queried place has projections (e.g., `x.field`), each predecessor is resolved
+    // through the full projection suffix before consensus comparison. If `traverse` returns
+    // `Continue(local)` (predecessor base resolved to a bare local), we call `resolve` on
+    // `local.projections` to complete the resolution. This ensures consensus is checked on
+    // the final value, not intermediate bases that may differ structurally but agree on the
+    // projected component.
+    //
     // Cyclic predecessors (Backtrack) are skipped: since Param edges are identity transfers,
     // the value is fully determined by the non-cyclic init edges. If only cyclic predecessors
     // exist, we cannot resolve (the value has no external source).
-    let graph_edges = graph
-        .outgoing_edges(place.local)
-        .map(|edge| traverse(rec_state.cloned(), place, edge));
+    let graph_edges = graph.outgoing_edges(place.local).map(|edge| {
+        let result = traverse(rec_state.cloned(), place, edge);
+
+        match result {
+            // Predecessor resolved to a bare local, but the query has remaining projections.
+            // Finish resolving through the projection suffix so consensus compares final values.
+            ControlFlow::Continue(local) if !place.projections.is_empty() => {
+                ControlFlow::Break(resolve(
+                    rec_state.cloned(),
+                    PlaceRef {
+                        local,
+                        projections: place.projections,
+                    },
+                ))
+            }
+            ControlFlow::Continue(_) | ControlFlow::Break(_) => result,
+        }
+    });
     let constant_edges = graph
         .constant_bindings
         .iter_by_kind(place.local, EdgeKind::Param)
@@ -314,7 +351,11 @@ fn resolve_params<'heap, A: Allocator + Clone>(
 /// the data ultimately originates. The algorithm handles three types of edges:
 ///
 /// - **[`Load`]**: Always followed transitively (a load has exactly one source)
-/// - **[`Param`]**: Followed only if all predecessors agree on the same source (consensus)
+/// - **[`Param`]**: Followed only if all predecessors agree on the same source (consensus).
+///   Consensus is checked on fully resolved results: when the queried place has projections, each
+///   predecessor is resolved through the complete projection suffix before comparison. This allows
+///   resolution through φ-nodes where predecessor bases differ but the projected component agrees
+///   (e.g., `(42, a)` and `(42, b)` agree on field `.0`).
 /// - **[`Index`]/[`Field`]**: Matched against projections to trace through aggregates
 ///
 /// Resolution terminates with:

libs/@local/hashql/mir/src/pass/analysis/data_dependency/tests.rs

@@ -718,3 +718,151 @@ fn load_param_mixed() {
         },
     );
 }
+
+/// Tests that Param consensus resolves through projections when predecessors are
+/// different tuples but the queried field is the same constant.
+///
+/// Both paths construct different tuples (`a = (42, u)`, `b = (42, v)`) but the
+/// `.0` field is the same constant `42` in both. Current algorithm compares the
+/// tuple bases (`a` vs `b`), which disagree, so it returns `Incomplete(x.0)`.
+/// Correct behavior: resolve `a.0` and `b.0` individually, find they both yield
+/// `42`, and return `Resolved(42)`.
+#[test]
+fn param_consensus_projected_field_const() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/0 -> Int {
+        decl u: Int, v: Int, a: (Int, Int), b: (Int, Int), cond: Int, x: (Int, Int), result: Int;
+        @proj x_0 = x.0: Int;
+
+        bb0() {
+            u = input.load! "u";
+            v = input.load! "v";
+            cond = input.load! "cond";
+            a = tuple 42, u;
+            b = tuple 42, v;
+            if cond then bb1() else bb2();
+        },
+        bb1() {
+            goto bb3(a);
+        },
+        bb2() {
+            goto bb3(b);
+        },
+        bb3(x) {
+            result = load x_0;
+            return result;
+        }
+    });
+
+    assert_data_dependency(
+        "param_consensus_projected_field_const",
+        &body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}
+
+/// Tests that Param consensus resolves through projections when predecessors are
+/// different tuples but the queried field is the same place.
+///
+/// Both paths construct different tuples (`a = (src, u)`, `b = (src, v)`) but the
+/// `.0` field is the same local `src` in both. Current algorithm compares the
+/// tuple bases (`a` vs `b`), which disagree, so it returns `Incomplete(x.0)`.
+/// Correct behavior: resolve `a.0` and `b.0` individually, find they both yield
+/// `src`, and return `Resolved(src)`.
+#[test]
+fn param_consensus_projected_field_place() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/0 -> Int {
+        decl src: Int, u: Int, v: Int, a: (Int, Int), b: (Int, Int), cond: Int, x: (Int, Int), result: Int;
+        @proj x_0 = x.0: Int;
+
+        bb0() {
+            src = input.load! "src";
+            u = input.load! "u";
+            v = input.load! "v";
+            cond = input.load! "cond";
+            a = tuple src, u;
+            b = tuple src, v;
+            if cond then bb1() else bb2();
+        },
+        bb1() {
+            goto bb3(a);
+        },
+        bb2() {
+            goto bb3(b);
+        },
+        bb3(x) {
+            result = load x_0;
+            return result;
+        }
+    });
+
+    assert_data_dependency(
+        "param_consensus_projected_field_place",
+        &body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}
+
+/// Tests that a cycle with a loop-invariant projected field resolves correctly.
+///
+/// The cycle is `x -> x` via the back-edge in `bb1`. The init edge provides
+/// `init = (src, other)`. The back-edge reconstructs `t = (x.0, other)`,
+/// preserving `x.0` across iterations. So `x.0` is loop-invariant and should
+/// resolve to `src`. Current algorithm compares `init` vs `t` as bases, which
+/// disagree, yielding `Incomplete(x.0)`. Correct behavior: resolve the full
+/// `init.0 = src` and see that `t.0 = x.0` is a cyclic identity, so the
+/// non-cyclic init determines the answer.
+#[test]
+fn param_cycle_invariant_projected_field() {
+    let heap = Heap::new();
+    let interner = Interner::new(&heap);
+    let env = Environment::new(&heap);
+
+    let body = body!(interner, env; fn@0/0 -> Int {
+        decl src: Int, other: Int, init: (Int, Int), x: (Int, Int), t: (Int, Int), cond: Int, result: Int;
+        @proj x_0 = x.0: Int;
+
+        bb0() {
+            src = input.load! "src";
+            other = input.load! "other";
+            cond = input.load! "cond";
+            init = tuple src, other;
+            goto bb1(init);
+        },
+        bb1(x) {
+            t = tuple x_0, other;
+            if cond then bb1(t) else bb2(x_0);
+        },
+        bb2(result) {
+            return result;
+        }
+    });
+
+    assert_data_dependency(
+        "param_cycle_invariant_projected_field",
+        &body,
+        &mut MirContext {
+            heap: &heap,
+            env: &env,
+            interner: &interner,
+            diagnostics: DiagnosticIssues::new(),
+        },
+    );
+}

libs/@local/hashql/mir/src/pass/transform/inst_simplify/mod.rs

@@ -309,6 +309,8 @@ impl<'heap, A: Allocator> InstSimplifyVisitor<'_, 'heap, A> {
             (BinOp::BitAnd, 0) if is_bool => {
                 Some(RValue::Load(Operand::Constant(Constant::Int(false.into()))))
             }
+            // 0 & rhs => 0 (annihilator)
+            (BinOp::BitAnd, 0) => Some(RValue::Load(Operand::Constant(Constant::Int(0.into())))),
             (BinOp::BitAnd, _) => None,
             // 0 | rhs => rhs (identity)
             (BinOp::BitOr, 0) => Some(RValue::Load(Operand::Place(rhs))),
@@ -369,6 +371,8 @@ impl<'heap, A: Allocator> InstSimplifyVisitor<'_, 'heap, A> {
             (BinOp::BitAnd, 0) if is_bool => {
                 Some(RValue::Load(Operand::Constant(Constant::Int(false.into()))))
             }
+            // 0 & lhs => 0 (annihilator)
+            (BinOp::BitAnd, 0) => Some(RValue::Load(Operand::Constant(Constant::Int(0.into())))),
             (BinOp::BitAnd, _) => None,
             // lhs | 0 => lhs (identity)
             (BinOp::BitOr, 0) => Some(RValue::Load(Operand::Place(lhs))),