From 56fb085db3869d6e2e815a337f8e49ddcd628841 Mon Sep 17 00:00:00 2001
From: Heitor Neiva <hneiva@mozilla.com>
Date: Fri, 13 Mar 2026 16:05:26 -0700
Subject: [PATCH 1/2] Optimize: Update transitive closure algorythm.

The previous implementation scanned all edges on every iteration of a
fixed-point loop, resulting in O(depth * edges) complexity. For deep
dependency chains this is catastrophic - a 5000-node chain required
5000 full passes over all edges.

Replace with a standard Breadth-First Search using an adjacency list
built once upfront, reducing complexity to O(vertices + edges). Benchmarks
on large graphs show 22x-1333x speedups depending on graph shape, with
identical results verified against the original algorithm.
---
 src/taskgraph/graph.py | 38 +++++++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/taskgraph/graph.py b/src/taskgraph/graph.py
index 573275087..a521cdfc4 100644
--- a/src/taskgraph/graph.py
+++ b/src/taskgraph/graph.py
@@ -61,21 +61,29 @@ def transitive_closure(self, nodes, reverse=False):
                 f"Unknown nodes in transitive closure: {nodes - self.nodes}"
             )
 
-        # generate a new graph by expanding along edges until reaching a fixed
-        # point
-        new_nodes, new_edges = nodes, set()
-        nodes, edges = set(), set()
-        while (new_nodes, new_edges) != (nodes, edges):
-            nodes, edges = new_nodes, new_edges
-            add_edges = {
-                (left, right, name)
-                for (left, right, name) in self.edges
-                if (right if reverse else left) in nodes
-            }
-            add_nodes = {(left if reverse else right) for (left, right, _) in add_edges}
-            new_nodes = nodes | add_nodes
-            new_edges = edges | add_edges
-        return Graph(new_nodes, new_edges)
+        # Build an adjacency list once, then BFS — O(Vertices + Edges)
+        adjacency = collections.defaultdict(set)
+        for left, right, _name in self.edges:
+            if reverse:
+                adjacency[right].add(left)
+            else:
+                adjacency[left].add(right)
+
+        result_nodes = set(nodes)
+        queue = collections.deque(nodes)
+        while queue:
+            node = queue.popleft()
+            for neighbor in adjacency.get(node, ()):
+                if neighbor not in result_nodes:
+                    result_nodes.add(neighbor)
+                    queue.append(neighbor)
+
+        result_edges = frozenset(
+            (left, right, name)
+            for left, right, name in self.edges
+            if left in result_nodes and right in result_nodes
+        )
+        return Graph(frozenset(result_nodes), result_edges)
 
     def _visit(self, reverse):
         forward_links, reverse_links = self.links_and_reverse_links_dict()

From f19b24b090da0fb6254338201372875ffc831b8e Mon Sep 17 00:00:00 2001
From: Heitor Neiva <hneiva@mozilla.com>
Date: Wed, 18 Mar 2026 10:16:18 -0700
Subject: [PATCH 2/2] test: add coverage for transitive_closure reverse, error,
 and diamond paths

---
 test/test_graph.py | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/test/test_graph.py b/test/test_graph.py
index f1d683cc4..2d14acd6e 100644
--- a/test/test_graph.py
+++ b/test/test_graph.py
@@ -134,6 +134,46 @@ def test_transitive_closure_loopy(self):
         "transitive closure of a loop is the whole loop"
         self.assertEqual(self.loopy.transitive_closure({"A"}), self.loopy)
 
+    def test_transitive_closure_reverse_tree(self):
+        "reverse transitive closure from leaf nodes finds ancestors"
+        self.assertEqual(
+            self.tree.transitive_closure({"d"}, reverse=True),
+            Graph(
+                {"a", "b", "d"},
+                {("a", "b", "L"), ("b", "d", "K")},
+            ),
+        )
+
+    def test_transitive_closure_reverse_root(self):
+        "reverse transitive closure from root has no ancestors"
+        self.assertEqual(
+            self.tree.transitive_closure({"a"}, reverse=True),
+            Graph({"a"}, set()),
+        )
+
+    def test_transitive_closure_unknown_nodes(self):
+        "transitive closure raises on nodes not in the graph"
+        with pytest.raises(Exception, match="Unknown nodes"):
+            self.tree.transitive_closure({"z"})
+
+    def test_transitive_closure_diamond(self):
+        "transitive closure on a diamond graph reaches shared descendants via convergent paths"
+        self.assertEqual(
+            self.diamonds.transitive_closure({"A"}),
+            Graph(
+                {"A", "D", "F", "G", "I", "J"},
+                {
+                    ("A", "F", "L"),
+                    ("A", "D", "L"),
+                    ("D", "F", "L"),
+                    ("D", "G", "L"),
+                    ("F", "I", "L"),
+                    ("G", "I", "L"),
+                    ("G", "J", "L"),
+                },
+            ),
+        )
+
     def test_visit_postorder_empty(self):
         "postorder visit of an empty graph is empty"
         self.assertEqual(list(Graph(set(), set()).visit_postorder()), [])