Clean up repairable

• Clean up the prototype repairable / function editor implementation done by @xrouth2.
• Core interface is edit method on a FunctionEditor struct, which contains a &mut Function. edit takes a closure that implements a single edit on the function. edit is passed a FunctionEdit, on which there are methods delete_node, add_node, and replace_all_uses_with. Per-edit, an entry is added to a list internal to the FunctionEditor containing each edit, where one edit contains a deleted node set and an added node set.
  • The FunctionEditor also contains a mutable def_use map that it incrementally updates based off of replace_all_uses_with. This def_use map is available to use by passes.
• Each transformation is passed a FunctionEditor, on which it accumulates edits to the function using edit. After the transformation, the pass manager 1. uses the edit list to repair partitions and debug info and 2. recompacts node IDs by deleting gravestone nodes and updating side data structures containing node IDs (partitions and debug info)
• Partitions are repaired in the following way:
  1. Collapse all of the edits in the edit list into a single edit
  2. Compute the reverse postorder of the function, and assign added nodes to partitions in order that they're in the rev po - this logic is per-node specific
  3. Delete deleted nodes from partitions
• Closes #3 (closed)

hercules_ir/src/antideps.rs

 use crate::*;
 
-/*
- * Top level function to get all anti-dependencies.
- */
-pub fn antideps(function: &Function, def_use: &ImmutableDefUseMap) -> Vec<(NodeID, NodeID)> {
-    generic_antideps(
-        function,
-        def_use,
-        (0..function.nodes.len()).map(NodeID::new),
-    )
-}
-
-/*
- * Sometimes, we are only interested in anti-dependence edges involving arrays.
- */
-pub fn array_antideps(
-    function: &Function,
-    def_use: &ImmutableDefUseMap,
-    types: &Vec<Type>,
-    typing: &Vec<TypeID>,
-) -> Vec<(NodeID, NodeID)> {
-    generic_antideps(
-        function,
-        def_use,
-        (0..function.nodes.len())
-            .map(NodeID::new)
-            .filter(|id| types[typing[id.idx()].idx()].is_array()),
-    )
-}
-
 /*
  * Function to assemble anti-dependence edges. Returns a list of pairs of nodes.
  * The first item in the pair is the read node, and the second item is the write
- * node. Take an iterator of nodes in case we want a subset of all anti-
- * dependencies.
+ * node.
  */
-fn generic_antideps<I: Iterator<Item = NodeID>>(
-    function: &Function,
-    def_use: &ImmutableDefUseMap,
-    nodes: I,
-) -> Vec<(NodeID, NodeID)> {
+pub fn antideps(function: &Function, def_use: &ImmutableDefUseMap) -> Vec<(NodeID, NodeID)> {
     // Anti-dependence edges are between a write node and a read node, where
     // each node uses the same array value. The read must be scheduled before
     // the write to avoid incorrect compilation.
     let mut antideps = vec![];
 
-    for id in nodes {
+    for id in (0..function.nodes.len()).map(NodeID::new) {
         // Collect the reads and writes to / from this collection.
         let users = def_use.get_users(id);
         let reads = users.iter().filter(|user| {
@@ -78,9 +44,6 @@ fn generic_antideps<I: Iterator<Item = NodeID>>(
                 antideps.push((*read, *write));
             }
         }
-
-        // TODO: Multiple write uses should clone the collection for N - 1 of the writes.
-        assert!(writes.next() == None, "Can't form anti-dependencies when there are two independent writes depending on a single collection value.");
     }
 
     antideps