print: fix intra-func (e.g. values) numbering to use print order instead of breadth-first. (#15)

This is a bit of an abstract problem, but hopefully this comparison
shows the problem:
<table>
<tr><th>Before</th><th>After</th></tr>
<tr>
<td>

```rs
// Note the "leaps" (e.g. v2 -> v5),
// as the indentation level increases.
v1 = …
v2 = …
if v2 {
  v5 = …
  if v5 {
    v9 = …
    v10 = …
  }
  v6 = …
}
v3 = …
if v3 {
  v7 = …
  v8 = …
}
v4 = …
// ^ last top-level is v4 so the
// next level in will start at v5
```
</td>
<td>

```rs
// The value numbering should
// now match the textual order.
v1 = …
v2 = …
if v2 {
  v3 = …
  if v3 {
    v4 = …
    v5 = …
  }
  v6 = …
}
v7 = …
if v7 {
  v8 = …
  v9 = …
}
v10 = …
// ^ last top-level (v10) is
// now the last one overall
```
</td>
</tr>
</table>

While the discrepancy isn't huge on this small artificial example, in
practice the leap could be from e.g. 3-digit to 4-digit numbers, which
wasn't just jarring but also made the dataflow hard to follow.

This entire time I just assumed I was looking at values defined by later
passes, but it turned out to be the result of region-level traversal
(instead of handling all regions and nodes in regular `visit` order),
and I only spotted it while tweaking this code, for a later change
involving debuginfo (inlined call sites etc.).

Author: eddyb

src/print/mod.rs

@@ -938,24 +938,29 @@ impl<'a> Printer<'a> {
                         def.deduped_attrs_across_versions.insert(attrs);
                     }
                 };
-                let visit_region = |func_at_region: FuncAt<'_, Region>| {
-                    let region = func_at_region.position;
-
-                    define(Use::AlignmentAnchorForRegion(region), None);
-                    // FIXME(eddyb) should labels have names?
-                    define(Use::RegionLabel(region), None);
-
-                    let RegionDef { inputs, children, outputs: _ } = func_def_body.at(region).def();
-
-                    for (i, input_decl) in inputs.iter().enumerate() {
-                        define(
-                            Use::RegionInput { region, input_idx: i.try_into().unwrap() },
-                            Some(input_decl.attrs),
-                        );
-                    }
-
-                    for func_at_node in func_def_body.at(*children) {
-                        let node = func_at_node.position;
+                // HACK(eddyb) this is as bad as it is due to the combination of:
+                // - borrowing constraints on `define` (mutable access to maps)
+                // - needing to minimize the changes to allow rebasing further
+                //   refactors (after which it may be easier to clean up anyway)
+                let visit_region_or_node = |func_at_r_or_n: FuncAt<'_, Either<Region, Node>>| {
+                    let region_or_node = func_at_r_or_n.position;
+                    if let Either::Left(region) = region_or_node {
+                        define(Use::AlignmentAnchorForRegion(region), None);
+                        // FIXME(eddyb) should labels have names?
+                        define(Use::RegionLabel(region), None);
+
+                        let RegionDef { inputs, children: _, outputs: _ } =
+                            func_def_body.at(region).def();
+
+                        for (i, input_decl) in inputs.iter().enumerate() {
+                            define(
+                                Use::RegionInput { region, input_idx: i.try_into().unwrap() },
+                                Some(input_decl.attrs),
+                            );
+                        }
+                    } else {
+                        let node = region_or_node.right().unwrap();
+                        let func_at_node = func_at_r_or_n.at(node);
 
                         define(Use::AlignmentAnchorForNode(node), None);
 
@@ -987,8 +992,8 @@ impl<'a> Printer<'a> {
                 };
 
                 // FIXME(eddyb) maybe this should be provided by `visit`.
-                struct VisitAllRegions<F>(F);
-                impl<'a, F: FnMut(FuncAt<'a, Region>)> Visitor<'a> for VisitAllRegions<F> {
+                struct VisitAllRegionsAndNodes<F>(F);
+                impl<'a, F: FnMut(FuncAt<'a, Either<Region, Node>>)> Visitor<'a> for VisitAllRegionsAndNodes<F> {
                     // FIXME(eddyb) this is excessive, maybe different kinds of
                     // visitors should exist for module-level and func-level?
                     fn visit_attr_set_use(&mut self, _: AttrSet) {}
@@ -998,11 +1003,15 @@ impl<'a> Printer<'a> {
                     fn visit_func_use(&mut self, _: Func) {}
 
                     fn visit_region_def(&mut self, func_at_region: FuncAt<'a, Region>) {
-                        self.0(func_at_region);
+                        self.0(func_at_region.at(Either::Left(func_at_region.position)));
                         func_at_region.inner_visit_with(self);
                     }
+                    fn visit_node_def(&mut self, func_at_node: FuncAt<'a, Node>) {
+                        self.0(func_at_node.at(Either::Right(func_at_node.position)));
+                        func_at_node.inner_visit_with(self);
+                    }
                 }
-                func_def_body.inner_visit_with(&mut VisitAllRegions(visit_region));
+                func_def_body.inner_visit_with(&mut VisitAllRegionsAndNodes(visit_region_or_node));
             }
 
             let mut region_label_counter = 0;