graph: don't overcount dependents

Fixes #69 (nice)

Author: euclidianAce

build/cyan/graph.lua

@@ -56,26 +56,40 @@ local function mark_for_compile(n: Node)
    end
 end
 
+local function collect_recursive_dependents(of: Node, set: {Node:boolean})
+   if set[of] then return end
+   set[of] = true
+   for dependent in keys(of.dependents) do
+      set[dependent] = true
+      collect_recursive_dependents(dependent, set)
+   end
+end
+
 local function make_dependent_counter(): function(Node): integer
    local cache <const>: {Node:integer} = {}
+
    local function count_dependents(n: Node): integer
       if cache[n] then return cache[n] end
-      local deps = 0
-      for v in keys(n.dependents) do
-         deps = deps + count_dependents(v) + 1
-      end
-      cache[n] = deps
-      return deps
+      local set <const> = {}
+      collect_recursive_dependents(n, set)
+      set[n] = false
+      local count = 0
+      for _ in next, set do count = count + 1 end
+      cache[n] = count
+      return count
    end
    return count_dependents
 end
 
 ---@desc
---- Iterate over nodes in order of dependents
+--- Collect the nodes of this graph into a mapping from the number of
+--- dependents to lists of nodes with that number of dependents
+---
+--- Returns that map of lists and the most dependents that any node had
 ---
 --- If two nodes have the same number of dependent nodes, they are sorted by
 --- input filename lexicographically
-function Dag:nodes(): function(): Node
+function Dag:collect_by_dependent_count(): {integer:{Node}}, integer
    local count <const> = make_dependent_counter()
    local most_deps = 0
    local nodes_by_deps <const>: {integer:{Node}} = setmetatable({}, {
@@ -91,18 +105,23 @@ function Dag:nodes(): function(): Node
    for n in values(self._nodes_by_filename) do
       table.insert(nodes_by_deps[count(n)], n)
    end
-
    setmetatable(nodes_by_deps, nil)
-
    for i = 0, most_deps do
       if nodes_by_deps[i] then
          table.sort(nodes_by_deps[i], function(a: Node, b: Node): boolean
             return a.input:to_string() < b.input:to_string()
          end)
       end
    end
+   return nodes_by_deps, most_deps
+end
 
-   local i = most_deps
+---@desc
+--- Iterate over nodes in order of dependents
+---
+--- This is a convenience wrapper over `collect_by_dependent_count`
+function Dag:nodes(): function(): Node
+   local nodes_by_deps <const>, i = self:collect_by_dependent_count()
    if not nodes_by_deps[i] then
       return function(): nil end
    end