From 0c5fc52c479fd47526997ec1d0bcff23ff623c6f Mon Sep 17 00:00:00 2001
From: Lauren Tan <poteto@users.noreply.github.com>
Date: Sun, 13 Nov 2022 16:07:53 -0500
Subject: [PATCH] Refactor VisualizeHIRMermaid

- Get rid of `indent` as it was making the code hard to read - Remove
unnecessary 2nd iteration over blocks - Remove extra newline between the bb
subgraphs and the jumps section - Remove trailing spaces - Remove newlines
between each subgraph and jump
---
 .../forget/src/HIR/VisualizeHIRMermaid.ts     | 158 +++++++++---------
 .../src/__tests__/fixtures/hir/call.expect.md |  10 +-
 .../fixtures/hir/complex-while.expect.md      |  24 +--
 .../fixtures/hir/component.expect.md          |  64 +++----
 .../fixtures/hir/conditional-break.expect.md  | 117 ++++++-------
 .../hir/conditional-on-mutable.expect.md      |  78 ++++-----
 .../fixtures/hir/constructor.expect.md        |  10 +-
 .../fixtures/hir/frozen-after-alias.expect.md |  13 +-
 .../fixtures/hir/hook-call.expect.md          |  13 +-
 .../hir/hooks-freeze-arguments.expect.md      |  13 +-
 ...reeze-possibly-mutable-arguments.expect.md |  38 ++---
 .../hir/independent-across-if.expect.md       |  36 ++--
 .../fixtures/hir/independent.expect.md        |  16 +-
 .../hir/interdependent-across-if.expect.md    |  33 ++--
 .../fixtures/hir/interdependent.expect.md     |  16 +-
 .../fixtures/hir/jsx-fragment.expect.md       |   7 +-
 .../fixtures/hir/logical-expression.expect.md |  90 ++++------
 .../hir/mutable-lifetime-loops.expect.md      |  58 +++----
 .../mutable-lifetime-with-aliasing.expect.md  |  35 ++--
 .../hir/mutable-liverange-loop.expect.md      |  58 +++----
 .../hir/property-assignment.expect.md         |   7 +-
 .../hir/reassignment-conditional.expect.md    |  24 ++-
 .../fixtures/hir/reassignment.expect.md       |   7 +-
 .../fixtures/hir/reverse-postorder.expect.md  |  68 +++-----
 .../__tests__/fixtures/hir/simple.expect.md   |  19 +--
 .../hir/ssa-arrayexpression.expect.md         |   7 +-
 .../fixtures/hir/ssa-call-jsx-2.expect.md     |  27 ++-
 .../fixtures/hir/ssa-call-jsx.expect.md       |  10 +-
 .../hir/ssa-complex-multiple-if.expect.md     |  40 ++---
 .../hir/ssa-complex-single-if.expect.md       |  24 ++-
 .../fixtures/hir/ssa-for-of.expect.md         |  36 ++--
 .../__tests__/fixtures/hir/ssa-for.expect.md  |  28 ++--
 .../fixtures/hir/ssa-if-else.expect.md        |  28 ++--
 .../ssa-nested-loops-no-reassign.expect.md    |  48 ++----
 .../fixtures/hir/ssa-newexpression.expect.md  |  10 +-
 .../hir/ssa-objectexpression-phi.expect.md    |  32 ++--
 .../hir/ssa-objectexpression.expect.md        |   7 +-
 .../fixtures/hir/ssa-property-call.expect.md  |   7 +-
 .../fixtures/hir/ssa-property.expect.md       |   7 +-
 .../fixtures/hir/ssa-return.expect.md         |  20 +--
 .../fixtures/hir/ssa-shadowing.expect.md      |  35 ++--
 .../fixtures/hir/ssa-simple-phi.expect.md     |  32 ++--
 .../fixtures/hir/ssa-simple.expect.md         |   7 +-
 .../fixtures/hir/ssa-single-if.expect.md      |  20 +--
 .../fixtures/hir/ssa-switch.expect.md         |  40 ++---
 .../fixtures/hir/ssa-throw.expect.md          |  20 +--
 .../hir/ssa-while-no-reassign.expect.md       |  28 ++--
 .../fixtures/hir/ssa-while.expect.md          |  28 ++--
 .../hir/switch-non-final-default.expect.md    |  32 ++--
 .../hir/switch-with-fallthrough.expect.md     |  60 +++----
 .../__tests__/fixtures/hir/switch.expect.md   |  32 ++--
 .../fixtures/hir/while-break.expect.md        |  12 +-
 .../hir/while-conditional-continue.expect.md  |  32 ++--
 53 files changed, 685 insertions(+), 1036 deletions(-)

diff --git a/compiler/forget/src/HIR/VisualizeHIRMermaid.ts b/compiler/forget/src/HIR/VisualizeHIRMermaid.ts
index 4acc79b5d0..5ab7472e69 100644
--- a/compiler/forget/src/HIR/VisualizeHIRMermaid.ts
+++ b/compiler/forget/src/HIR/VisualizeHIRMermaid.ts
@@ -2,6 +2,9 @@ import { assertExhaustive } from "../Common/utils";
 import { BasicBlock, BlockId, HIRFunction, Terminal } from "./HIR";
 import { printInstruction, printPlace } from "./PrintHIR";
 
+const INSTRUCTIONS_NODE_NAME = "instrs";
+const TERMINAL_NODE_NAME = "terminal";
+
 enum MermaidFlowchartDirection {
   TopBottom = "TB", // top to bottom
   TopDown = "TD", // top-down/ same as top to bottom
@@ -10,117 +13,138 @@ enum MermaidFlowchartDirection {
   LeftRight = "LR", // left to right
 }
 
-function indent(str: string, level: number = 1) {
-  const leadingSpaces = " ".repeat(level * 2);
-  return str
-    .split("\n")
-    .map((line) => `${leadingSpaces}${line}`)
-    .join("\n");
-}
-
 function printBlockId(id: BlockId): string {
   return `bb${id}`;
 }
 
-function printJump(from: BlockId, to: BlockId, label: string | null): string {
+/**
+ * Prints a mermaid arrow with optional label connecting BasicBlocks for use in the "Jumps" section.
+ */
+function printJumpArrow(
+  from: BlockId,
+  to: BlockId,
+  label: string | null
+): string {
   const fromId = printBlockId(from);
   const toId = printBlockId(to);
   if (label != null) {
-    return `${fromId}_terminal -- ${label} --> ${toId}\n`;
+    return `${fromId}_${TERMINAL_NODE_NAME} -- ${label} --> ${toId}\n`;
   }
-  return `${fromId}_terminal --> ${toId}\n`;
+  return `${fromId}_${TERMINAL_NODE_NAME} --> ${toId}\n`;
 }
 
-function visualizeInstructions({ id, instructions }: BasicBlock): string {
-  return (
-    `${printBlockId(id)}_instrs["\n` +
-    indent(
-      instructions
-        .map((instr) => printInstruction(instr).replaceAll('"', "'"))
-        .join("\n"),
-      2
-    ) +
-    indent('\n"]')
-  );
+/**
+ * Prints a mermaid arrow connecting a BasicBlock's instructions to its Terminal for use in the
+ * "Basic Blocks" section.
+ */
+function printTerminalArrow(blockId: BlockId, block: BasicBlock) {
+  const bbId = printBlockId(blockId);
+  if (block.instructions.length > 0) {
+    return `${bbId}_${INSTRUCTIONS_NODE_NAME} --> ${bbId}_${TERMINAL_NODE_NAME}(["${printTerminalLabel(
+      block.terminal
+    )}"])`;
+  }
+  return `${bbId}_${TERMINAL_NODE_NAME}(["${printTerminalLabel(
+    block.terminal
+  )}"])`;
 }
 
-function visualizeTerminal(terminal: Terminal) {
-  let buffer = "";
+/**
+ * Prints a BasicBlock as a mermaid `subgraph`, with instructions as a single multiline mermaid node
+ * and the terminal as an arrow connecting the instruction node with the terminal.
+ */
+function printBlockSubgraphs(blockId: BlockId, block: BasicBlock) {
+  const buffer = [];
+  const bbId = printBlockId(blockId);
+  const instructions = block.instructions
+    .map((instr) => `      ${printInstruction(instr).replaceAll('"', "'")}\n`)
+    .join("");
+  buffer.push(`  subgraph ${bbId}\n`);
+  if (block.instructions.length > 0) {
+    buffer.push(`    ${bbId}_${INSTRUCTIONS_NODE_NAME}["\n`);
+    buffer.push(instructions);
+    buffer.push('    "]\n');
+  }
+  buffer.push(`    ${printTerminalArrow(blockId, block)}`);
+  buffer.push("\n  end\n");
+  return buffer.join("");
+}
+
+function printTerminalLabel(terminal: Terminal): string {
+  const buffer = [];
   switch (terminal.kind) {
     case "if": {
-      buffer = buffer.concat(`If (${printPlace(terminal.test)})`);
+      buffer.push(`If (${printPlace(terminal.test)})`);
       break;
     }
     case "goto": {
-      buffer = buffer.concat("Goto");
+      buffer.push("Goto");
       break;
     }
     case "return": {
       if (terminal.value != null) {
-        buffer = buffer.concat(`Return ${printPlace(terminal.value)}`);
+        buffer.push(`Return ${printPlace(terminal.value)}`);
       } else {
-        buffer = buffer.concat("Return");
+        buffer.push("Return");
       }
       break;
     }
     case "switch":
-      buffer = buffer.concat(`Switch (${printPlace(terminal.test)})`);
+      buffer.push(`Switch (${printPlace(terminal.test)})`);
       break;
     case "throw":
-      buffer = buffer.concat(`Throw ${printPlace(terminal.value)}`);
+      buffer.push(`Throw ${printPlace(terminal.value)}`);
       break;
     case "while":
-      buffer = buffer.concat("While");
+      buffer.push("While");
       break;
     default:
       assertExhaustive(terminal, `unhandled terminal ${terminal}`);
   }
-  return buffer;
+  return buffer.join("");
 }
 
-function visualizeJump(blockId: BlockId, terminal: Terminal): string {
-  let buffer = "";
+function printTerminalArrows(blockId: BlockId, terminal: Terminal): string {
+  const buffer = [];
   switch (terminal.kind) {
     case "if": {
-      buffer = buffer.concat(printJump(blockId, terminal.consequent, "then"));
-      buffer = buffer.concat(printJump(blockId, terminal.alternate, "else"));
+      buffer.push(printJumpArrow(blockId, terminal.consequent, "then"));
+      buffer.push(printJumpArrow(blockId, terminal.alternate, "else"));
       if (
         terminal.fallthrough != null &&
         terminal.alternate !== terminal.fallthrough
       ) {
-        buffer = buffer.concat(
-          printJump(blockId, terminal.fallthrough, "fallthrough")
+        buffer.push(
+          printJumpArrow(blockId, terminal.fallthrough, "fallthrough")
         );
       }
       break;
     }
     case "goto": {
-      buffer = buffer.concat(printJump(blockId, terminal.block, null));
+      buffer.push(printJumpArrow(blockId, terminal.block, null));
       break;
     }
     case "switch": {
       terminal.cases.forEach((case_) => {
         if (case_.test != null) {
-          buffer = buffer.concat(
-            printJump(blockId, case_.block, printPlace(case_.test))
+          buffer.push(
+            printJumpArrow(blockId, case_.block, printPlace(case_.test))
           );
         } else {
-          buffer = buffer.concat(printJump(blockId, case_.block, "default"));
+          buffer.push(printJumpArrow(blockId, case_.block, "default"));
         }
       });
       if (terminal.fallthrough != null) {
-        buffer = buffer.concat(
-          printJump(blockId, terminal.fallthrough, "fallthrough")
+        buffer.push(
+          printJumpArrow(blockId, terminal.fallthrough, "fallthrough")
         );
       }
       break;
     }
     case "while": {
-      buffer = buffer.concat(printJump(blockId, terminal.test, "test"));
-      buffer = buffer.concat(printJump(blockId, terminal.loop, "loop"));
-      buffer = buffer.concat(
-        printJump(blockId, terminal.fallthrough, "fallthrough")
-      );
+      buffer.push(printJumpArrow(blockId, terminal.test, "test"));
+      buffer.push(printJumpArrow(blockId, terminal.loop, "loop"));
+      buffer.push(printJumpArrow(blockId, terminal.fallthrough, "fallthrough"));
       break;
     }
     case "throw":
@@ -130,7 +154,7 @@ function visualizeJump(blockId: BlockId, terminal: Terminal): string {
     default:
       assertExhaustive(terminal, `unhandled terminal ${terminal}`);
   }
-  return buffer;
+  return buffer.map((line) => `  ${line}`).join("");
 }
 
 /**
@@ -142,39 +166,21 @@ export default function visualizeHIRMermaid(fn: HIRFunction): string {
   const jumps = [];
 
   for (const [blockId, block] of ir.blocks) {
-    let buffer;
-    const bbId = printBlockId(blockId);
-    buffer = indent(`subgraph ${bbId}\n`);
-    if (block.instructions.length > 0) {
-      buffer = buffer.concat(indent(visualizeInstructions(block)));
-      buffer = buffer.concat(
-        indent(
-          `\n${bbId}_instrs --> ${bbId}_terminal(["${visualizeTerminal(
-            block.terminal
-          )}"])`,
-          2
-        )
-      );
-    } else {
-      buffer = buffer.concat(
-        indent(`${bbId}_terminal(["${visualizeTerminal(block.terminal)}"])`)
-      );
+    const subgraph = printBlockSubgraphs(blockId, block);
+    const jump = printTerminalArrows(blockId, block.terminal);
+
+    if (subgraph.length > 0) {
+      subgraphs.push(subgraph);
     }
-    buffer = buffer.concat(indent("\nend\n"));
-    subgraphs.push(buffer);
-  }
 
-  for (const [blockId, block] of ir.blocks) {
-    const jump = visualizeJump(blockId, block.terminal);
     if (jump.length > 0) {
-      jumps.push(indent(jump));
+      jumps.push(jump);
     }
   }
 
   return `flowchart ${MermaidFlowchartDirection.TopBottom}
   %% Basic Blocks
-${subgraphs.length ? subgraphs.join("\n") : "  %% empty"}
-
+${subgraphs.length ? subgraphs.join("") : "  %% empty"}
   %% Jumps
-${jumps.length ? jumps.join("\n") : "  %% empty"}`;
+${jumps.length ? jumps.join("") : "  %% empty"}`;
 }
diff --git a/compiler/forget/src/__tests__/fixtures/hir/call.expect.md b/compiler/forget/src/__tests__/fixtures/hir/call.expect.md
index f250eadb45..bbbb349027 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/call.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/call.expect.md
@@ -28,9 +28,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -73,11 +72,10 @@ flowchart TB
       [5] Let mutate _$13 = JSX <read $12 a={freeze a$10} ></read $12>
       [6] Call mutate foo$4(mutate b$11)
       [7] Const mutate $14 = 'div'
-      [8] Const mutate $15 = JSX <read $14 a={read a$10} b={freeze b$11} ></read $14>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $15"])  
+      [8] Const mutate $15 = JSX <read $14 a={read a$10} b={freeze b$11} ></read $14>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $15"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/complex-while.expect.md b/compiler/forget/src/__tests__/fixtures/hir/complex-while.expect.md
index b7bff457a3..f1c12213ef 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/complex-while.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/complex-while.expect.md
@@ -42,46 +42,36 @@ bb1:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["If (read a$4)"])  
+    bb0_terminal(["If (read a$4)"])
   end
-  
   subgraph bb3
-    bb3_terminal(["While"])  
+    bb3_terminal(["While"])
   end
-  
   subgraph bb4
-    bb4_terminal(["If (read b$5)"])  
+    bb4_terminal(["If (read b$5)"])
   end
-  
   subgraph bb6
-    bb6_terminal(["If (read c$6)"])  
+    bb6_terminal(["If (read c$6)"])
   end
-  
   subgraph bb7
-    bb7_terminal(["Goto"])  
+    bb7_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return"])  
+    bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb3
   bb0_terminal -- else --> bb1
-  
   bb3_terminal -- test --> bb4
   bb3_terminal -- loop --> bb6
   bb3_terminal -- fallthrough --> bb1
-  
   bb4_terminal -- then --> bb6
   bb4_terminal -- else --> bb1
-  
   bb6_terminal -- then --> bb1
   bb6_terminal -- else --> bb7
-  
   bb7_terminal --> bb4
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/component.expect.md b/compiler/forget/src/__tests__/fixtures/hir/component.expect.md
index b3a672d45d..8a001f0f01 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/component.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/component.expect.md
@@ -101,60 +101,51 @@ flowchart TB
       [3] Const mutate renderedItems$29[3:14] = Array []
       [4] Const mutate seen$30[4:11] = New mutate Set$6()
       [5] Const mutate $31 = 0
-      [6] Const mutate max$32 = Call mutate Math$8.max(read $31, read maxItems$28)  
-    "]    
-    bb0_instrs --> bb0_terminal(["Goto"])  
+      [6] Const mutate max$32 = Call mutate Math$8.max(read $31, read maxItems$28)
+    "]
+    bb0_instrs --> bb0_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read items$27)"])  
+    bb1_terminal(["If (read items$27)"])
   end
-  
   subgraph bb3
     bb3_instrs["
       [7] Const mutate $34 = null
-      [8] Const mutate $36 = Binary read item$10 == read $34  
-    "]    
-    bb3_instrs --> bb3_terminal(["If (read $36)"])  
+      [8] Const mutate $36 = Binary read item$10 == read $34
+    "]
+    bb3_instrs --> bb3_terminal(["If (read $36)"])
   end
-  
   subgraph bb8
     bb8_instrs["
-      [9] Const mutate $13 = read $36  
-    "]    
-    bb8_instrs --> bb8_terminal(["Goto"])  
+      [9] Const mutate $13 = read $36
+    "]
+    bb8_instrs --> bb8_terminal(["Goto"])
   end
-  
   subgraph bb9
     bb9_instrs["
-      [10] Const mutate $13 = Call mutate seen$30.has(mutate item$10)  
-    "]    
-    bb9_instrs --> bb9_terminal(["Goto"])  
+      [10] Const mutate $13 = Call mutate seen$30.has(mutate item$10)
+    "]
+    bb9_instrs --> bb9_terminal(["Goto"])
   end
-  
   subgraph bb7
-    bb7_terminal(["If (read $13)"])  
+    bb7_terminal(["If (read $13)"])
   end
-  
   subgraph bb5
-    bb5_terminal(["Goto"])  
+    bb5_terminal(["Goto"])
   end
-  
   subgraph bb4
     bb4_instrs["
       [11] Call mutate seen$30.add(mutate item$10)
       [12] Const mutate $43 = 'div'
       [13] Const mutate $44 = JSX <read $43>{read item$10}</read $43>
       [14] Call mutate renderedItems$29.push(read $44)
-      [15] Const mutate $49 = Binary read renderedItems$29.length >= read max$32  
-    "]    
-    bb4_instrs --> bb4_terminal(["If (read $49)"])  
+      [15] Const mutate $49 = Binary read renderedItems$29.length >= read max$32
+    "]
+    bb4_instrs --> bb4_terminal(["If (read $49)"])
   end
-  
   subgraph bb10
-    bb10_terminal(["Goto"])  
+    bb10_terminal(["Goto"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [16] Const mutate count$52 = read renderedItems$29.length
@@ -165,36 +156,27 @@ flowchart TB
       [21] Const mutate $57 = JSX <read $55>{freeze count$52}{read $56}</read $55>
       [22] Const mutate $58 = '\n      '
       [23] Const mutate $59 = '\n    '
-      [24] Const mutate $60 = JSX <read $53>{read $54}{read $57}{read $58}{freeze renderedItems$29}{read $59}</read $53>  
-    "]    
-    bb2_instrs --> bb2_terminal(["Return read $60"])  
+      [24] Const mutate $60 = JSX <read $53>{read $54}{read $57}{read $58}{freeze renderedItems$29}{read $59}</read $53>
+    "]
+    bb2_instrs --> bb2_terminal(["Return read $60"])
   end
-  
 
   %% Jumps
   bb0_terminal --> bb1
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal -- then --> bb8
   bb3_terminal -- else --> bb9
   bb3_terminal -- fallthrough --> bb7
-  
   bb8_terminal --> bb7
-  
   bb9_terminal --> bb7
-  
   bb7_terminal -- then --> bb5
   bb7_terminal -- else --> bb4
-  
   bb5_terminal --> bb1
-  
   bb4_terminal -- then --> bb2
   bb4_terminal -- else --> bb10
-  
   bb10_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/conditional-break.expect.md b/compiler/forget/src/__tests__/fixtures/hir/conditional-break.expect.md
index 03e206f78c..1fbf97dcd9 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/conditional-break.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/conditional-break.expect.md
@@ -99,30 +99,27 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a_DEBUG$5[1:4] = Array []
-      [2] Call mutate a_DEBUG$5.push(read props$4.a)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$4.b)"])  
+      [2] Call mutate a_DEBUG$5.push(read props$4.a)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$4.b)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Const mutate $6 = null  
-    "]    
-    bb2_instrs --> bb2_terminal(["Return read $6"])  
+      [3] Const mutate $6 = null
+    "]
+    bb2_instrs --> bb2_terminal(["Return read $6"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [4] Call mutate a_DEBUG$5.push(read props$4.d)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze a_DEBUG$5"])  
+      [4] Call mutate a_DEBUG$5.push(read props$4.d)
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze a_DEBUG$5"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
+
 ```
 
 ## Code
@@ -165,32 +162,28 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$4[1:4] = Array []
-      [2] Call mutate a$4.push(read props$3.a)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$3.b)"])  
+      [2] Call mutate a$4.push(read props$3.a)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$3.b)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Call mutate a$4.push(read props$3.c)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Call mutate a$4.push(read props$3.c)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [4] Call mutate a$4.push(read props$3.d)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze a$4"])  
+      [4] Call mutate a$4.push(read props$3.d)
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze a$4"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
@@ -234,31 +227,28 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$5[1:5] = Array []
-      [2] Call mutate a$5.push(read props$4.a)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$4.b)"])  
+      [2] Call mutate a$5.push(read props$4.a)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$4.b)"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [3] Call mutate a$5.push(read props$4.c)
-      [4] Const mutate $6 = null  
-    "]    
-    bb2_instrs --> bb2_terminal(["Return read $6"])  
+      [4] Const mutate $6 = null
+    "]
+    bb2_instrs --> bb2_terminal(["Return read $6"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [5] Call mutate a$5.push(read props$4.d)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze a$5"])  
+      [5] Call mutate a$5.push(read props$4.d)
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze a$5"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
+
 ```
 
 ## Code
@@ -302,30 +292,27 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$4[1:4] = Array []
-      [2] Call mutate a$4.push(read props$3.a)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$3.b)"])  
+      [2] Call mutate a$4.push(read props$3.a)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$3.b)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Call mutate a$4.push(read props$3.c)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Return freeze a$4"])  
+      [3] Call mutate a$4.push(read props$3.c)
+    "]
+    bb2_instrs --> bb2_terminal(["Return freeze a$4"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [4] Call mutate a$4.push(read props$3.d)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze a$4"])  
+      [4] Call mutate a$4.push(read props$3.d)
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze a$4"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
+
 ```
 
 ## Code
@@ -369,32 +356,28 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$4[1:4] = Array []
-      [2] Call mutate a$4.push(read props$3.a)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$3.b)"])  
+      [2] Call mutate a$4.push(read props$3.a)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$3.b)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Call mutate a$4.push(read props$3.c)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Call mutate a$4.push(read props$3.c)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [4] Call mutate a$4.push(read props$3.d)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze a$4"])  
+      [4] Call mutate a$4.push(read props$3.d)
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze a$4"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb1
   bb0_terminal -- else --> bb2
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/conditional-on-mutable.expect.md b/compiler/forget/src/__tests__/fixtures/hir/conditional-on-mutable.expect.md
index ef548de759..6170e13a7a 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/conditional-on-mutable.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/conditional-on-mutable.expect.md
@@ -95,48 +95,40 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$7[1:3] = Array []
-      [2] Const mutate b$8[2:4] = Array []  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read b$8)"])  
+      [2] Const mutate b$8[2:4] = Array []
+    "]
+    bb0_instrs --> bb0_terminal(["If (read b$8)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Call mutate a$7.push(read props$6.p0)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Call mutate a$7.push(read props$6.p0)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read props$6.p1)"])  
+    bb1_terminal(["If (read props$6.p1)"])
   end
-  
   subgraph bb4
     bb4_instrs["
-      [4] Call mutate b$8.push(read props$6.p2)  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [4] Call mutate b$8.push(read props$6.p2)
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [5] Const mutate $16 = JSX <read Foo$4 a={freeze a$7} b={freeze b$8} ></read Foo$4>  
-    "]    
-    bb3_instrs --> bb3_terminal(["Return read $16"])  
+      [5] Const mutate $16 = JSX <read Foo$4 a={freeze a$7} b={freeze b$8} ></read Foo$4>
+    "]
+    bb3_instrs --> bb3_terminal(["Return read $16"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
   bb1_terminal -- then --> bb4
   bb1_terminal -- else --> bb3
-  
   bb4_terminal --> bb3
-  
+
 ```
 
 ## Code
@@ -191,48 +183,40 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate a$9[1:4] = Array []
       [2] Const mutate b$10[2:5] = Array []
-      [3] Const mutate $11 = Call mutate mayMutate$4(mutate b$10)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $11)"])  
+      [3] Const mutate $11 = Call mutate mayMutate$4(mutate b$10)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $11)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Call mutate a$9.push(read props$8.p0)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Call mutate a$9.push(read props$8.p0)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read props$8.p1)"])  
+    bb1_terminal(["If (read props$8.p1)"])
   end
-  
   subgraph bb4
     bb4_instrs["
-      [5] Call mutate b$10.push(read props$8.p2)  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [5] Call mutate b$10.push(read props$8.p2)
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [6] Const mutate $19 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>  
-    "]    
-    bb3_instrs --> bb3_terminal(["Return read $19"])  
+      [6] Const mutate $19 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>
+    "]
+    bb3_instrs --> bb3_terminal(["Return read $19"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
   bb1_terminal -- then --> bb4
   bb1_terminal -- else --> bb3
-  
   bb4_terminal --> bb3
-  
+
 ```
 
 ## Code
@@ -266,9 +250,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -295,9 +278,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/constructor.expect.md b/compiler/forget/src/__tests__/fixtures/hir/constructor.expect.md
index a12866202b..95f2573218 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/constructor.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/constructor.expect.md
@@ -28,9 +28,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -73,11 +72,10 @@ flowchart TB
       [5] Let mutate _$13 = JSX <read $12 a={freeze a$10} ></read $12>
       [6] New mutate Foo$4(mutate b$11)
       [7] Const mutate $14 = 'div'
-      [8] Const mutate $15 = JSX <read $14 a={read a$10} b={freeze b$11} ></read $14>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $15"])  
+      [8] Const mutate $15 = JSX <read $14 a={read a$10} b={freeze b$11} ></read $14>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $15"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/frozen-after-alias.expect.md b/compiler/forget/src/__tests__/fixtures/hir/frozen-after-alias.expect.md
index 5ed0980796..ab34335f50 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/frozen-after-alias.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/frozen-after-alias.expect.md
@@ -35,11 +35,10 @@ flowchart TB
       [1] Const mutate a$5 = Array []
       [2] Const mutate b$6 = read a$5
       [3] Call read useFreeze$3(freeze a$5)
-      [4] Call mutate foo$4(read b$6)  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return"])  
+      [4] Call mutate foo$4(read b$6)
+    "]
+    bb0_instrs --> bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -70,9 +69,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -99,9 +97,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/hook-call.expect.md b/compiler/forget/src/__tests__/fixtures/hir/hook-call.expect.md
index 276af34db0..fb2b06c58f 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/hook-call.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/hook-call.expect.md
@@ -32,9 +32,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -61,9 +60,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -104,11 +102,10 @@ flowchart TB
       [4] Const mutate $13 = '\n      '
       [5] Const mutate $14 = '\n      '
       [6] Const mutate $15 = '\n    '
-      [7] Const mutate $16 = JSX <read Component$0>{read $13}{read x$11}{read $14}{read y$12}{read $15}</read Component$0>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $16"])  
+      [7] Const mutate $16 = JSX <read Component$0>{read $13}{read x$11}{read $14}{read y$12}{read $15}</read Component$0>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $16"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-arguments.expect.md b/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-arguments.expect.md
index 4c20a077d0..3b80e37e8f 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-arguments.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-arguments.expect.md
@@ -36,11 +36,10 @@ flowchart TB
       [1] Const mutate a$4 = Array []
       [2] Call read useFreeze$2(freeze a$4)
       [3] Call read useFreeze$2(read a$4)
-      [4] Call mutate call$3(read a$4)  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read a$4"])  
+      [4] Call mutate call$3(read a$4)
+    "]
+    bb0_instrs --> bb0_terminal(["Return read a$4"])
   end
-  
 
   %% Jumps
   %% empty
@@ -71,9 +70,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -100,9 +98,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-possibly-mutable-arguments.expect.md b/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-possibly-mutable-arguments.expect.md
index a6683d8e10..4c62d98102 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-possibly-mutable-arguments.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/hooks-freeze-possibly-mutable-arguments.expect.md
@@ -55,44 +55,38 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate cond$8 = read props$7.cond
       [2] Const mutate x$9 = read props$7.x
-      [3] Let mutate a$10 = undefined  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read cond$8)"])  
+      [3] Let mutate a$10 = undefined
+    "]
+    bb0_instrs --> bb0_terminal(["If (read cond$8)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Reassign mutate a$4 = read x$9  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Reassign mutate a$4 = read x$9
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [5] Reassign mutate a$4 = Array []  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [5] Reassign mutate a$4 = Array []
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [6] Call read useFreeze$5(freeze a$4)
       [7] Call read useFreeze$5(read a$4)
-      [8] Call mutate call$6(read a$4)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read a$4"])  
+      [8] Call mutate call$6(read a$4)
+    "]
+    bb1_instrs --> bb1_terminal(["Return read a$4"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
@@ -128,9 +122,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -157,9 +150,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/independent-across-if.expect.md b/compiler/forget/src/__tests__/fixtures/hir/independent-across-if.expect.md
index 7762e9f03d..1fb23c15f7 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/independent-across-if.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/independent-across-if.expect.md
@@ -46,9 +46,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -75,9 +74,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -104,9 +102,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -133,9 +130,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -175,33 +171,29 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$9[1:3] = Call mutate compute$3(read props$8.a)
-      [2] Const mutate b$10[2:4] = Call mutate compute$3(read props$8.b)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$8.c)"])  
+      [2] Const mutate b$10[2:4] = Call mutate compute$3(read props$8.b)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$8.c)"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [3] Call mutate mutate$5(mutate a$9)
-      [4] Call mutate mutate$5(mutate b$10)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Call mutate mutate$5(mutate b$10)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [5] Const mutate $14 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read $14"])  
+      [5] Const mutate $14 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>
+    "]
+    bb1_instrs --> bb1_terminal(["Return read $14"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/independent.expect.md b/compiler/forget/src/__tests__/fixtures/hir/independent.expect.md
index cd1651e27e..3fc21f2e41 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/independent.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/independent.expect.md
@@ -43,11 +43,10 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate a$8 = Call mutate compute$3(read props$7.a)
       [2] Const mutate b$9 = Call mutate compute$3(read props$7.b)
-      [3] Const mutate $10 = JSX <read Foo$5 a={freeze a$8} b={freeze b$9} ></read Foo$5>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $10"])  
+      [3] Const mutate $10 = JSX <read Foo$5 a={freeze a$8} b={freeze b$9} ></read Foo$5>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $10"])
   end
-  
 
   %% Jumps
   %% empty
@@ -76,9 +75,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -105,9 +103,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -134,9 +131,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/interdependent-across-if.expect.md b/compiler/forget/src/__tests__/fixtures/hir/interdependent-across-if.expect.md
index df1683b172..74b275ee77 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/interdependent-across-if.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/interdependent-across-if.expect.md
@@ -40,9 +40,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -69,9 +68,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -98,9 +96,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -139,32 +136,28 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Const mutate a$9[1:3] = Call mutate compute$3(read props$8.a)
-      [2] Const mutate b$10[2:3] = Call mutate compute$3(read props$8.b)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$8.c)"])  
+      [2] Const mutate b$10[2:3] = Call mutate compute$3(read props$8.b)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$8.c)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Call mutate foo$5(mutate a$9, mutate b$10)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Call mutate foo$5(mutate a$9, mutate b$10)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [4] Const mutate $14 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read $14"])  
+      [4] Const mutate $14 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>
+    "]
+    bb1_instrs --> bb1_terminal(["Return read $14"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/interdependent.expect.md b/compiler/forget/src/__tests__/fixtures/hir/interdependent.expect.md
index b2b257b2e3..8d2eb8e627 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/interdependent.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/interdependent.expect.md
@@ -45,11 +45,10 @@ flowchart TB
       [1] Const mutate a$9[1:3] = Call mutate compute$3(read props$8.a)
       [2] Const mutate b$10[2:3] = Call mutate compute$3(read props$8.b)
       [3] Call mutate foo$5(mutate a$9, mutate b$10)
-      [4] Const mutate $11 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $11"])  
+      [4] Const mutate $11 = JSX <read Foo$6 a={freeze a$9} b={freeze b$10} ></read Foo$6>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $11"])
   end
-  
 
   %% Jumps
   %% empty
@@ -79,9 +78,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -108,9 +106,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -137,9 +134,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/jsx-fragment.expect.md b/compiler/forget/src/__tests__/fixtures/hir/jsx-fragment.expect.md
index 8bbbcd46a4..b3f3b244a8 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/jsx-fragment.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/jsx-fragment.expect.md
@@ -50,11 +50,10 @@ flowchart TB
       [8] Const mutate $21 = '\n      '
       [9] Const mutate $22 = JSX <read $17>{read $18}{read $20}{read $21}</read $17>
       [10] Const mutate $23 = '\n    '
-      [11] Const mutate $24 = JsxFragment [read $14, read props$13.greeting, read $15, read $16, read $22, read $23]  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $24"])  
+      [11] Const mutate $24 = JsxFragment [read $14, read props$13.greeting, read $15, read $16, read $22, read $23]
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $24"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/logical-expression.expect.md b/compiler/forget/src/__tests__/fixtures/hir/logical-expression.expect.md
index 21a8527baa..97ed0e8869 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/logical-expression.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/logical-expression.expect.md
@@ -45,39 +45,33 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Const mutate $5 = Call mutate f$1()  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $5)"])  
+      [1] Const mutate $5 = Call mutate f$1()
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $5)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [2] Const mutate $3 = Call mutate g$4()  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [2] Const mutate $3 = Call mutate g$4()
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [3] Const mutate $3 = read $5  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [3] Const mutate $3 = read $5
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return freeze $3"])  
+    bb1_terminal(["Return freeze $3"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
@@ -117,39 +111,33 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Const mutate $5 = Call mutate f$1()  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $5)"])  
+      [1] Const mutate $5 = Call mutate f$1()
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $5)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [2] Const mutate $3 = read $5  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [2] Const mutate $3 = read $5
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [3] Const mutate $3 = Call mutate g$4()  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [3] Const mutate $3 = Call mutate g$4()
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return freeze $3"])  
+    bb1_terminal(["Return freeze $3"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
@@ -193,39 +181,33 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate $9 = Call mutate f$2()
       [2] Const mutate $10 = null
-      [3] Const mutate $11 = Binary read $9 != read $10  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $11)"])  
+      [3] Const mutate $11 = Binary read $9 != read $10
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $11)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Const mutate $6 = read $9  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Const mutate $6 = read $9
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [5] Const mutate $6 = Call mutate g$7()  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [5] Const mutate $6 = Call mutate g$7()
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return freeze $6"])  
+    bb1_terminal(["Return freeze $6"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
@@ -252,9 +234,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -281,9 +262,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-loops.expect.md b/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-loops.expect.md
index 02475b7b45..697005dea7 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-loops.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-loops.expect.md
@@ -52,9 +52,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -81,9 +80,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -152,18 +150,16 @@ flowchart TB
       [1] Let mutate a$2 = Object {  }
       [2] Let mutate b$3 = Object {  }
       [3] Let mutate c$4 = Object {  }
-      [4] Let mutate d$5 = Object {  }  
-    "]    
-    bb0_instrs --> bb0_terminal(["While"])  
+      [4] Let mutate d$5 = Object {  }
+    "]
+    bb0_instrs --> bb0_terminal(["While"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [5] Const mutate $17 = true  
-    "]    
-    bb1_instrs --> bb1_terminal(["If (read $17)"])  
+      [5] Const mutate $17 = true
+    "]
+    bb1_instrs --> bb1_terminal(["If (read $17)"])
   end
-  
   subgraph bb3
     bb3_instrs["
       [6] Let mutate z$19 = read a$2
@@ -172,65 +168,51 @@ flowchart TB
       [9] Reassign mutate c$4 = read d$5
       [10] Reassign mutate d$5 = read z$19
       [11] Call mutate mutate$7(mutate a$2, mutate b$3)
-      [12] Const mutate $29 = Call mutate cond$8(mutate a$2)  
-    "]    
-    bb3_instrs --> bb3_terminal(["If (read $29)"])  
+      [12] Const mutate $29 = Call mutate cond$8(mutate a$2)
+    "]
+    bb3_instrs --> bb3_terminal(["If (read $29)"])
   end
-  
   subgraph bb4
-    bb4_terminal(["Goto"])  
+    bb4_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["If (read a$2)"])  
+    bb2_terminal(["If (read a$2)"])
   end
-  
   subgraph bb7
-    bb7_terminal(["If (read b$3)"])  
+    bb7_terminal(["If (read b$3)"])
   end
-  
   subgraph bb9
-    bb9_terminal(["If (read c$4)"])  
+    bb9_terminal(["If (read c$4)"])
   end
-  
   subgraph bb11
-    bb11_terminal(["If (read d$5)"])  
+    bb11_terminal(["If (read d$5)"])
   end
-  
   subgraph bb13
     bb13_instrs["
       [13] Const mutate $34 = null
-      [14] Call mutate mutate$7(mutate d$5, read $34)  
-    "]    
-    bb13_instrs --> bb13_terminal(["Return"])  
+      [14] Call mutate mutate$7(mutate d$5, read $34)
+    "]
+    bb13_instrs --> bb13_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb3
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal -- then --> bb2
   bb3_terminal -- else --> bb4
-  
   bb4_terminal --> bb1
-  
   bb2_terminal -- then --> bb7
   bb2_terminal -- else --> bb7
-  
   bb7_terminal -- then --> bb9
   bb7_terminal -- else --> bb9
-  
   bb9_terminal -- then --> bb11
   bb9_terminal -- else --> bb11
-  
   bb11_terminal -- then --> bb13
   bb11_terminal -- else --> bb13
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-with-aliasing.expect.md b/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-with-aliasing.expect.md
index c924925a86..180b99ba2e 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-with-aliasing.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/mutable-lifetime-with-aliasing.expect.md
@@ -48,9 +48,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -108,52 +107,42 @@ flowchart TB
       [4] Const mutate d$14[4:7] = Object { c: read c$13 }
       [5] Const mutate x$15[5:9] = Object {  }
       [6] Reassign mutate x$15.b[5:9] = read b$12
-      [7] Const mutate y$16 = Call mutate mutate$8(mutate x$15, mutate d$14)  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read a$11)"])  
+      [7] Const mutate y$16 = Call mutate mutate$8(mutate x$15, mutate d$14)
+    "]
+    bb0_instrs --> bb0_terminal(["If (read a$11)"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read b$12)"])  
+    bb1_terminal(["If (read b$12)"])
   end
-  
   subgraph bb3
-    bb3_terminal(["If (read c$13)"])  
+    bb3_terminal(["If (read c$13)"])
   end
-  
   subgraph bb5
-    bb5_terminal(["If (read d$14)"])  
+    bb5_terminal(["If (read d$14)"])
   end
-  
   subgraph bb7
-    bb7_terminal(["If (read y$16)"])  
+    bb7_terminal(["If (read y$16)"])
   end
-  
   subgraph bb9
     bb9_instrs["
       [8] Const mutate $17 = null
-      [9] Call mutate mutate$8(mutate x$15, read $17)  
-    "]    
-    bb9_instrs --> bb9_terminal(["Return"])  
+      [9] Call mutate mutate$8(mutate x$15, read $17)
+    "]
+    bb9_instrs --> bb9_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb1
   bb0_terminal -- else --> bb1
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb3
-  
   bb3_terminal -- then --> bb5
   bb3_terminal -- else --> bb5
-  
   bb5_terminal -- then --> bb7
   bb5_terminal -- else --> bb7
-  
   bb7_terminal -- then --> bb9
   bb7_terminal -- else --> bb9
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/mutable-liverange-loop.expect.md b/compiler/forget/src/__tests__/fixtures/hir/mutable-liverange-loop.expect.md
index 2f85b7b335..69c9bfa730 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/mutable-liverange-loop.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/mutable-liverange-loop.expect.md
@@ -47,9 +47,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -76,9 +75,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -142,80 +140,64 @@ flowchart TB
       [1] Let mutate a$12[1:7] = Object {  }
       [2] Let mutate b$13[2:6] = Object {  }
       [3] Let mutate c$14 = Object {  }
-      [4] Let mutate d$15[4:9] = Object {  }  
-    "]    
-    bb0_instrs --> bb0_terminal(["While"])  
+      [4] Let mutate d$15[4:9] = Object {  }
+    "]
+    bb0_instrs --> bb0_terminal(["While"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [5] Const mutate $16 = true  
-    "]    
-    bb1_instrs --> bb1_terminal(["If (read $16)"])  
+      [5] Const mutate $16 = true
+    "]
+    bb1_instrs --> bb1_terminal(["If (read $16)"])
   end
-  
   subgraph bb3
     bb3_instrs["
       [6] Call mutate mutate$6(mutate a$12, mutate b$13)
-      [7] Const mutate $21 = Call mutate cond$7(mutate a$12)  
-    "]    
-    bb3_instrs --> bb3_terminal(["If (read $21)"])  
+      [7] Const mutate $21 = Call mutate cond$7(mutate a$12)
+    "]
+    bb3_instrs --> bb3_terminal(["If (read $21)"])
   end
-  
   subgraph bb4
-    bb4_terminal(["Goto"])  
+    bb4_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["If (read a$12)"])  
+    bb2_terminal(["If (read a$12)"])
   end
-  
   subgraph bb7
-    bb7_terminal(["If (read b$13)"])  
+    bb7_terminal(["If (read b$13)"])
   end
-  
   subgraph bb9
-    bb9_terminal(["If (read c$14)"])  
+    bb9_terminal(["If (read c$14)"])
   end
-  
   subgraph bb11
-    bb11_terminal(["If (read d$15)"])  
+    bb11_terminal(["If (read d$15)"])
   end
-  
   subgraph bb13
     bb13_instrs["
       [8] Const mutate $28 = null
-      [9] Call mutate mutate$6(mutate d$15, read $28)  
-    "]    
-    bb13_instrs --> bb13_terminal(["Return"])  
+      [9] Call mutate mutate$6(mutate d$15, read $28)
+    "]
+    bb13_instrs --> bb13_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb3
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal -- then --> bb2
   bb3_terminal -- else --> bb4
-  
   bb4_terminal --> bb1
-  
   bb2_terminal -- then --> bb7
   bb2_terminal -- else --> bb7
-  
   bb7_terminal -- then --> bb9
   bb7_terminal -- else --> bb9
-  
   bb9_terminal -- then --> bb11
   bb9_terminal -- else --> bb11
-  
   bb11_terminal -- then --> bb13
   bb11_terminal -- else --> bb13
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/property-assignment.expect.md b/compiler/forget/src/__tests__/fixtures/hir/property-assignment.expect.md
index 8b81048b0b..1f534c8745 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/property-assignment.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/property-assignment.expect.md
@@ -38,11 +38,10 @@ flowchart TB
       [3] Reassign mutate x$7.y[1:5] = read y$8
       [4] Const mutate child$9 = JSX <read Component$0 data={freeze y$8} ></read Component$0>
       [5] Call mutate x$7.y.push(read props$6.p0)
-      [6] Const mutate $10 = JSX <read Component$0 data={freeze x$7} >{read child$9}</read Component$0>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $10"])  
+      [6] Const mutate $10 = JSX <read Component$0 data={freeze x$7} >{read child$9}</read Component$0>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $10"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/reassignment-conditional.expect.md b/compiler/forget/src/__tests__/fixtures/hir/reassignment-conditional.expect.md
index c63eec5122..0ac3288d20 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/reassignment-conditional.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/reassignment-conditional.expect.md
@@ -48,34 +48,30 @@ flowchart TB
     bb0_instrs["
       [1] Let mutate x$2 = Array []
       [2] Call mutate x$2.push(read props$6.p0)
-      [3] Let mutate y$8 = read x$2  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$6.p1)"])  
+      [3] Let mutate y$8 = read x$2
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$6.p1)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Reassign mutate x$2 = Array []  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Reassign mutate x$2 = Array []
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [5] Let mutate _$12 = JSX <read Component$0 x={freeze x$2} ></read Component$0>
       [6] Call read y$8.push(read props$6.p2)
-      [7] Const mutate $15 = JSX <read Component$0 x={read x$2} y={read y$8} ></read Component$0>  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read $15"])  
+      [7] Const mutate $15 = JSX <read Component$0 x={read x$2} y={read y$8} ></read Component$0>
+    "]
+    bb1_instrs --> bb1_terminal(["Return read $15"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/reassignment.expect.md b/compiler/forget/src/__tests__/fixtures/hir/reassignment.expect.md
index bbe2d9275f..ae67c2047b 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/reassignment.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/reassignment.expect.md
@@ -44,11 +44,10 @@ flowchart TB
       [4] Reassign mutate x$9 = Array []
       [5] Let mutate _$10 = JSX <read Component$0 x={freeze x$9} ></read Component$0>
       [6] Call mutate y$8.push(read props$6.p1)
-      [7] Const mutate $11 = JSX <read Component$0 x={read x$9} y={freeze y$8} ></read Component$0>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $11"])  
+      [7] Const mutate $11 = JSX <read Component$0 x={read x$9} y={freeze y$8} ></read Component$0>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $11"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/reverse-postorder.expect.md b/compiler/forget/src/__tests__/fixtures/hir/reverse-postorder.expect.md
index 994e46d294..df72ecd7dc 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/reverse-postorder.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/reverse-postorder.expect.md
@@ -84,92 +84,76 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate x$7 = undefined  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read props$6.cond)"])  
+      [1] Let mutate x$7 = undefined
+    "]
+    bb0_instrs --> bb0_terminal(["If (read props$6.cond)"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [2] Const mutate $8 = 2
       [3] Const mutate $9 = 1
-      [4] Const mutate $10 = 0  
-    "]    
-    bb2_instrs --> bb2_terminal(["Switch (read props$6.test)"])  
+      [4] Const mutate $10 = 0
+    "]
+    bb2_instrs --> bb2_terminal(["Switch (read props$6.test)"])
   end
-  
   subgraph bb8
     bb8_instrs["
-      [5] Reassign mutate x$2 = read props$6.v0  
-    "]    
-    bb8_instrs --> bb8_terminal(["Goto"])  
+      [5] Reassign mutate x$2 = read props$6.v0
+    "]
+    bb8_instrs --> bb8_terminal(["Goto"])
   end
-  
   subgraph bb6
     bb6_instrs["
-      [6] Reassign mutate x$2 = read props$6.v1  
-    "]    
-    bb6_instrs --> bb6_terminal(["Goto"])  
+      [6] Reassign mutate x$2 = read props$6.v1
+    "]
+    bb6_instrs --> bb6_terminal(["Goto"])
   end
-  
   subgraph bb4
     bb4_instrs["
-      [7] Reassign mutate x$2 = read props$6.v2  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [7] Reassign mutate x$2 = read props$6.v2
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb10
-    bb10_terminal(["If (read props$6.cond2)"])  
+    bb10_terminal(["If (read props$6.cond2)"])
   end
-  
   subgraph bb12
     bb12_instrs["
-      [8] Reassign mutate x$2 = read props$6.b  
-    "]    
-    bb12_instrs --> bb12_terminal(["Goto"])  
+      [8] Reassign mutate x$2 = read props$6.b
+    "]
+    bb12_instrs --> bb12_terminal(["Goto"])
   end
-  
   subgraph bb13
     bb13_instrs["
-      [9] Reassign mutate x$2 = read props$6.c  
-    "]    
-    bb13_instrs --> bb13_terminal(["Goto"])  
+      [9] Reassign mutate x$2 = read props$6.c
+    "]
+    bb13_instrs --> bb13_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [10] read x$2  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return"])  
+      [10] read x$2
+    "]
+    bb1_instrs --> bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb10
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal -- read $10 --> bb8
   bb2_terminal -- read $9 --> bb6
   bb2_terminal -- read $8 --> bb4
   bb2_terminal -- default --> bb4
   bb2_terminal -- fallthrough --> bb1
-  
   bb8_terminal --> bb1
-  
   bb6_terminal --> bb1
-  
   bb4_terminal --> bb1
-  
   bb10_terminal -- then --> bb12
   bb10_terminal -- else --> bb13
   bb10_terminal -- fallthrough --> bb1
-  
   bb12_terminal --> bb1
-  
   bb13_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/simple.expect.md b/compiler/forget/src/__tests__/fixtures/hir/simple.expect.md
index 2675470747..cf335fc551 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/simple.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/simple.expect.md
@@ -35,31 +35,28 @@ bb1:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["If (read x$8)"])  
+    bb0_terminal(["If (read x$8)"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [1] Const mutate $10 = false
-      [2] Const mutate $11 = Call read foo$0(read $10, read y$9)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Return freeze $11"])  
+      [2] Const mutate $11 = Call read foo$0(read $10, read y$9)
+    "]
+    bb2_instrs --> bb2_terminal(["Return freeze $11"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [3] Const mutate $12 = 10
       [4] Const mutate $13 = Binary read y$9 * read $12
-      [5] Const mutate $14 = Array [read $13]  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze $14"])  
+      [5] Const mutate $14 = Array [read $13]
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze $14"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-arrayexpression.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-arrayexpression.expect.md
index 2be25f38a5..fbe4e1592f 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-arrayexpression.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-arrayexpression.expect.md
@@ -30,11 +30,10 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate a$6 = 1
       [2] Const mutate b$7 = 2
-      [3] Const mutate x$8 = Array [read a$6, read b$7]  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return freeze x$8"])  
+      [3] Const mutate x$8 = Array [read a$6, read b$7]
+    "]
+    bb0_instrs --> bb0_terminal(["Return freeze x$8"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx-2.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx-2.expect.md
index b3dcd192ae..9c1f60bd38 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx-2.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx-2.expect.md
@@ -31,9 +31,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -79,35 +78,31 @@ flowchart TB
       [1] Const mutate a$11[1:3] = Array []
       [2] Const mutate b$12[2:7] = Object {  }
       [3] Call mutate foo$4(mutate a$11, mutate b$12)
-      [4] Const mutate $13 = Call mutate foo$4()  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $13)"])  
+      [4] Const mutate $13 = Call mutate foo$4()
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $13)"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [5] Const mutate $14 = 'div'
-      [6] Let mutate _$15 = JSX <read $14 a={freeze a$11} ></read $14>  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [6] Let mutate _$15 = JSX <read $14 a={freeze a$11} ></read $14>
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [7] Call mutate foo$4(read a$11, mutate b$12)
       [8] Const mutate $19 = 'div'
-      [9] Const mutate $20 = JSX <read $19 a={freeze a$11} b={freeze b$12} ></read $19>  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read $20"])  
+      [9] Const mutate $20 = JSX <read $19 a={freeze a$11} b={freeze b$12} ></read $19>
+    "]
+    bb1_instrs --> bb1_terminal(["Return read $20"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx.expect.md
index 32fb32bab9..45e8876d82 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-call-jsx.expect.md
@@ -28,9 +28,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -73,11 +72,10 @@ flowchart TB
       [5] Let mutate _$13 = JSX <read $12 a={freeze a$10} ></read $12>
       [6] Call mutate foo$4(read a$10, mutate b$11)
       [7] Const mutate $14 = 'div'
-      [8] Const mutate $15 = JSX <read $14 a={read a$10} b={freeze b$11} ></read $14>  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return read $15"])  
+      [8] Const mutate $15 = JSX <read $14 a={read a$10} b={freeze b$11} ></read $14>
+    "]
+    bb0_instrs --> bb0_terminal(["Return read $15"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-multiple-if.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-multiple-if.expect.md
index 105ec822f3..a8328cb8c5 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-multiple-if.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-multiple-if.expect.md
@@ -55,52 +55,44 @@ flowchart TB
       [1] Let mutate x$1 = 1
       [2] Let mutate y$8 = 2
       [3] Const mutate $9 = 2
-      [4] Const mutate $10 = Binary read y$8 === read $9  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $10)"])  
+      [4] Const mutate $10 = Binary read y$8 === read $9
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $10)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [5] Reassign mutate x$1 = 3  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [5] Reassign mutate x$1 = 3
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [6] Const mutate $12 = 3
-      [7] Const mutate $14 = Binary read y$8 === read $12  
-    "]    
-    bb1_instrs --> bb1_terminal(["If (read $14)"])  
+      [7] Const mutate $14 = Binary read y$8 === read $12
+    "]
+    bb1_instrs --> bb1_terminal(["If (read $14)"])
   end
-  
   subgraph bb4
     bb4_instrs["
-      [8] Reassign mutate x$1 = 5  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [8] Reassign mutate x$1 = 5
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [9] Reassign mutate y$18 = read x$1  
-    "]    
-    bb3_instrs --> bb3_terminal(["Return"])  
+      [9] Reassign mutate y$18 = read x$1
+    "]
+    bb3_instrs --> bb3_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
   bb1_terminal -- then --> bb4
   bb1_terminal -- else --> bb3
-  
   bb4_terminal --> bb3
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-single-if.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-single-if.expect.md
index d4ade013e5..4950613fa8 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-single-if.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-complex-single-if.expect.md
@@ -43,32 +43,28 @@ flowchart TB
       [1] Let mutate x$1 = 1
       [2] Let mutate y$6 = 2
       [3] Const mutate $7 = 2
-      [4] Const mutate $8 = Binary read y$6 === read $7  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $8)"])  
+      [4] Const mutate $8 = Binary read y$6 === read $7
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $8)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [5] Reassign mutate x$1 = 3  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [5] Reassign mutate x$1 = 3
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [6] Reassign mutate y$11 = read x$1  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return"])  
+      [6] Reassign mutate y$11 = read x$1
+    "]
+    bb1_instrs --> bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-for-of.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-for-of.expect.md
index 0f9d5ae07d..68e83b1c49 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-for-of.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-for-of.expect.md
@@ -47,51 +47,41 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate items$5 = Array []  
-    "]    
-    bb0_instrs --> bb0_terminal(["Goto"])  
+      [1] Let mutate items$5 = Array []
+    "]
+    bb0_instrs --> bb0_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read items$5)"])  
+    bb1_terminal(["If (read items$5)"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [2] Let mutate y$7 = 0  
-    "]    
-    bb3_instrs --> bb3_terminal(["If (read cond$4)"])  
+      [2] Let mutate y$7 = 0
+    "]
+    bb3_instrs --> bb3_terminal(["If (read cond$4)"])
   end
-  
   subgraph bb5
     bb5_instrs["
-      [3] Reassign mutate y$9 = 1  
-    "]    
-    bb5_instrs --> bb5_terminal(["Goto"])  
+      [3] Reassign mutate y$9 = 1
+    "]
+    bb5_instrs --> bb5_terminal(["Goto"])
   end
-  
   subgraph bb4
-    bb4_terminal(["Goto"])  
+    bb4_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["Return freeze items$5"])  
+    bb2_terminal(["Return freeze items$5"])
   end
-  
 
   %% Jumps
   bb0_terminal --> bb1
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal -- then --> bb5
   bb3_terminal -- else --> bb4
-  
   bb5_terminal --> bb4
-  
   bb4_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-for.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-for.expect.md
index fe96c43275..923412fa73 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-for.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-for.expect.md
@@ -40,40 +40,34 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate x$1 = 0  
-    "]    
-    bb0_instrs --> bb0_terminal(["Goto"])  
+      [1] Let mutate x$1 = 0
+    "]
+    bb0_instrs --> bb0_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [2] Const mutate $6 = 10
-      [3] Const mutate $8 = Binary read x$1 < read $6  
-    "]    
-    bb1_instrs --> bb1_terminal(["If (read $8)"])  
+      [3] Const mutate $8 = Binary read x$1 < read $6
+    "]
+    bb1_instrs --> bb1_terminal(["If (read $8)"])
   end
-  
   subgraph bb4
     bb4_instrs["
       [4] Const mutate $9 = 1
-      [5] Reassign mutate x$1 = Binary read x$1 + read $9  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [5] Reassign mutate x$1 = Binary read x$1 + read $9
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["Return read x$1"])  
+    bb2_terminal(["Return read x$1"])
   end
-  
 
   %% Jumps
   bb0_terminal --> bb1
-  
   bb1_terminal -- then --> bb4
   bb1_terminal -- else --> bb2
-  
   bb4_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-if-else.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-if-else.expect.md
index 2eae141d9f..87700561a5 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-if-else.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-if-else.expect.md
@@ -43,39 +43,33 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Let mutate x$5 = 1
-      [2] Let mutate y$6 = 2  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read y$6)"])  
+      [2] Let mutate y$6 = 2
+    "]
+    bb0_instrs --> bb0_terminal(["If (read y$6)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Let mutate z$7 = Binary read x$5 + read y$6  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Let mutate z$7 = Binary read x$5 + read y$6
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [4] Let mutate z$8 = read x$5  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [4] Let mutate z$8 = read x$5
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return"])  
+    bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-nested-loops-no-reassign.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-nested-loops-no-reassign.expect.md
index 2caa9497ce..a7a9861453 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-nested-loops-no-reassign.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-nested-loops-no-reassign.expect.md
@@ -61,80 +61,62 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate x$9 = 0  
-    "]    
-    bb0_instrs --> bb0_terminal(["While"])  
+      [1] Let mutate x$9 = 0
+    "]
+    bb0_instrs --> bb0_terminal(["While"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read a$6)"])  
+    bb1_terminal(["If (read a$6)"])
   end
-  
   subgraph bb3
-    bb3_terminal(["While"])  
+    bb3_terminal(["While"])
   end
-  
   subgraph bb4
-    bb4_terminal(["If (read b$7)"])  
+    bb4_terminal(["If (read b$7)"])
   end
-  
   subgraph bb6
-    bb6_terminal(["While"])  
+    bb6_terminal(["While"])
   end
-  
   subgraph bb7
-    bb7_terminal(["If (read c$8)"])  
+    bb7_terminal(["If (read c$8)"])
   end
-  
   subgraph bb9
     bb9_instrs["
       [2] Const mutate $13 = 1
-      [3] Binary read x$9 + read $13  
-    "]    
-    bb9_instrs --> bb9_terminal(["Goto"])  
+      [3] Binary read x$9 + read $13
+    "]
+    bb9_instrs --> bb9_terminal(["Goto"])
   end
-  
   subgraph bb8
-    bb8_terminal(["Goto"])  
+    bb8_terminal(["Goto"])
   end
-  
   subgraph bb5
-    bb5_terminal(["Goto"])  
+    bb5_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["Return read x$9"])  
+    bb2_terminal(["Return read x$9"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb3
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal -- test --> bb4
   bb3_terminal -- loop --> bb6
   bb3_terminal -- fallthrough --> bb5
-  
   bb4_terminal -- then --> bb6
   bb4_terminal -- else --> bb5
-  
   bb6_terminal -- test --> bb7
   bb6_terminal -- loop --> bb9
   bb6_terminal -- fallthrough --> bb8
-  
   bb7_terminal -- then --> bb9
   bb7_terminal -- else --> bb8
-  
   bb9_terminal --> bb7
-  
   bb8_terminal --> bb4
-  
   bb5_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-newexpression.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-newexpression.expect.md
index ff5b40d288..04c681cf42 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-newexpression.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-newexpression.expect.md
@@ -26,9 +26,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -61,11 +60,10 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate a$7[1:3] = Array []
       [2] Const mutate b$8[2:3] = Object {  }
-      [3] Let mutate c$9 = New mutate Foo$5(mutate a$7, mutate b$8)  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return freeze c$9"])  
+      [3] Let mutate c$9 = New mutate Foo$5(mutate a$7, mutate b$8)
+    "]
+    bb0_instrs --> bb0_terminal(["Return freeze c$9"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression-phi.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression-phi.expect.md
index 2d4996bb6e..d6292cecb6 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression-phi.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression-phi.expect.md
@@ -51,42 +51,36 @@ flowchart TB
       [1] Let mutate x$1 = 1
       [2] Let mutate y$2 = 2
       [3] Const mutate $8 = 1
-      [4] Const mutate $9 = Binary read x$1 > read $8  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $9)"])  
+      [4] Const mutate $9 = Binary read x$1 > read $8
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $9)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [5] Reassign mutate x$1 = 2  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [5] Reassign mutate x$1 = 2
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [6] Reassign mutate y$2 = 3  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [6] Reassign mutate y$2 = 3
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [7] Let mutate t$14 = Object { x: read x$1, y: read y$2 }  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return freeze t$14"])  
+      [7] Let mutate t$14 = Object { x: read x$1, y: read y$2 }
+    "]
+    bb1_instrs --> bb1_terminal(["Return freeze t$14"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression.expect.md
index 612af99973..d7c3714dde 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-objectexpression.expect.md
@@ -30,11 +30,10 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate a$6 = 1
       [2] Const mutate b$7 = 2
-      [3] Const mutate x$8 = Object { a: read a$6, b: read b$7 }  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return freeze x$8"])  
+      [3] Const mutate x$8 = Object { a: read a$6, b: read b$7 }
+    "]
+    bb0_instrs --> bb0_terminal(["Return freeze x$8"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-property-call.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-property-call.expect.md
index bd485766a8..93e49d06b4 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-property-call.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-property-call.expect.md
@@ -32,11 +32,10 @@ flowchart TB
       [1] Const mutate x$4 = Array []
       [2] Const mutate y$5[2:4] = Object { x: read x$4 }
       [3] Const mutate $6[3:4] = Array []
-      [4] Call mutate y$5.x.push(mutate $6)  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return freeze y$5"])  
+      [4] Call mutate y$5.x.push(mutate $6)
+    "]
+    bb0_instrs --> bb0_terminal(["Return freeze y$5"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-property.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-property.expect.md
index 505b8b3186..2f2802774b 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-property.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-property.expect.md
@@ -30,11 +30,10 @@ flowchart TB
     bb0_instrs["
       [1] Const mutate x$3 = Array []
       [2] Const mutate y$4[2:3] = Object {  }
-      [3] Reassign mutate y$4.x[2:3] = read x$3  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return freeze y$4"])  
+      [3] Reassign mutate y$4.x[2:3] = read x$3
+    "]
+    bb0_instrs --> bb0_terminal(["Return freeze y$4"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-return.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-return.expect.md
index 2b17eee52a..31d6467c73 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-return.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-return.expect.md
@@ -39,29 +39,25 @@ flowchart TB
     bb0_instrs["
       [1] Let mutate x$1 = 1
       [2] Const mutate $5 = 1
-      [3] Const mutate $6 = Binary read x$1 === read $5  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $6)"])  
+      [3] Const mutate $6 = Binary read x$1 === read $5
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $6)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Reassign mutate x$1 = 2  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Reassign mutate x$1 = 2
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return read x$1"])  
+    bb1_terminal(["Return read x$1"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-shadowing.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-shadowing.expect.md
index 2e4ee343d9..ff025d41a8 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-shadowing.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-shadowing.expect.md
@@ -30,9 +30,8 @@ bb0:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["Return"])  
+    bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
@@ -74,43 +73,37 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate str$2 = ''  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read cond$5)"])  
+      [1] Let mutate str$2 = ''
+    "]
+    bb0_instrs --> bb0_terminal(["If (read cond$5)"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [2] Let mutate str$7 = 'other test'
-      [3] Call mutate log$4(read str$7)  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Call mutate log$4(read str$7)
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [4] Reassign mutate str$2 = 'fallthrough test'  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [4] Reassign mutate str$2 = 'fallthrough test'
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [5] Call mutate log$4(read str$2)  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return"])  
+      [5] Call mutate log$4(read str$2)
+    "]
+    bb1_instrs --> bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-simple-phi.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-simple-phi.expect.md
index 5ab6e1e0d3..aa5ae198ca 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-simple-phi.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-simple-phi.expect.md
@@ -47,42 +47,36 @@ flowchart TB
     bb0_instrs["
       [1] Let mutate y$5 = 2
       [2] Const mutate $6 = 1
-      [3] Const mutate $7 = Binary read y$5 > read $6  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $7)"])  
+      [3] Const mutate $7 = Binary read y$5 > read $6
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $7)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Reassign mutate y$1 = 1  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Reassign mutate y$1 = 1
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [5] Reassign mutate y$1 = 2  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [5] Reassign mutate y$1 = 2
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [6] Let mutate x$11 = read y$1  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return"])  
+      [6] Let mutate x$11 = read y$1
+    "]
+    bb1_instrs --> bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb3
   bb0_terminal -- fallthrough --> bb1
-  
   bb2_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-simple.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-simple.expect.md
index 800c8e6bf5..14ea6238ad 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-simple.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-simple.expect.md
@@ -26,11 +26,10 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Let mutate x$3 = 1
-      [2] Let mutate y$4 = 2  
-    "]    
-    bb0_instrs --> bb0_terminal(["Return"])  
+      [2] Let mutate y$4 = 2
+    "]
+    bb0_instrs --> bb0_terminal(["Return"])
   end
-  
 
   %% Jumps
   %% empty
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-single-if.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-single-if.expect.md
index 38da735009..54aceb7c2a 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-single-if.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-single-if.expect.md
@@ -37,29 +37,25 @@ flowchart TB
   subgraph bb0
     bb0_instrs["
       [1] Let mutate x$4 = 1
-      [2] Let mutate y$5 = 2  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read y$5)"])  
+      [2] Let mutate y$5 = 2
+    "]
+    bb0_instrs --> bb0_terminal(["If (read y$5)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [3] Let mutate z$6 = Binary read x$4 + read y$5  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [3] Let mutate z$6 = Binary read x$4 + read y$5
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return"])  
+    bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-switch.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-switch.expect.md
index c0caf481ec..db676235d2 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-switch.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-switch.expect.md
@@ -69,55 +69,47 @@ flowchart TB
       [2] Const mutate $11 = 2
       [3] Const mutate $12 = Binary read x$10 === read $11
       [4] Const mutate $13 = 1
-      [5] Const mutate $14 = Binary read x$10 === read $13  
-    "]    
-    bb0_instrs --> bb0_terminal(["Switch (read x$10)"])  
+      [5] Const mutate $14 = Binary read x$10 === read $13
+    "]
+    bb0_instrs --> bb0_terminal(["Switch (read x$10)"])
   end
-  
   subgraph bb5
     bb5_instrs["
       [6] Const mutate $15 = 1
-      [7] Reassign mutate x$1 = Binary read x$10 + read $15  
-    "]    
-    bb5_instrs --> bb5_terminal(["Goto"])  
+      [7] Reassign mutate x$1 = Binary read x$10 + read $15
+    "]
+    bb5_instrs --> bb5_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
       [8] Const mutate $17 = 2
-      [9] Reassign mutate x$1 = Binary read x$10 + read $17  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [9] Reassign mutate x$1 = Binary read x$10 + read $17
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb2
     bb2_instrs["
       [10] Const mutate $19 = 3
-      [11] Reassign mutate x$1 = Binary read x$10 + read $19  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [11] Reassign mutate x$1 = Binary read x$10 + read $19
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
-      [12] Let mutate y$22 = read x$1  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return"])  
+      [12] Let mutate y$22 = read x$1
+    "]
+    bb1_instrs --> bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- read $14 --> bb5
   bb0_terminal -- read $12 --> bb3
   bb0_terminal -- default --> bb2
   bb0_terminal -- fallthrough --> bb1
-  
   bb5_terminal --> bb1
-  
   bb3_terminal --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-throw.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-throw.expect.md
index f14988f164..cf1ee8a153 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-throw.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-throw.expect.md
@@ -38,29 +38,25 @@ flowchart TB
     bb0_instrs["
       [1] Let mutate x$1 = 1
       [2] Const mutate $5 = 1
-      [3] Const mutate $6 = Binary read x$1 === read $5  
-    "]    
-    bb0_instrs --> bb0_terminal(["If (read $6)"])  
+      [3] Const mutate $6 = Binary read x$1 === read $5
+    "]
+    bb0_instrs --> bb0_terminal(["If (read $6)"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [4] Reassign mutate x$1 = 2  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [4] Reassign mutate x$1 = 2
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Throw read x$1"])  
+    bb1_terminal(["Throw read x$1"])
   end
-  
 
   %% Jumps
   bb0_terminal -- then --> bb2
   bb0_terminal -- else --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-while-no-reassign.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-while-no-reassign.expect.md
index 30fa94128b..32f90f7cec 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-while-no-reassign.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-while-no-reassign.expect.md
@@ -41,42 +41,36 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate x$5 = 1  
-    "]    
-    bb0_instrs --> bb0_terminal(["While"])  
+      [1] Let mutate x$5 = 1
+    "]
+    bb0_instrs --> bb0_terminal(["While"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [2] Const mutate $6 = 10
-      [3] Const mutate $8 = Binary read x$5 < read $6  
-    "]    
-    bb1_instrs --> bb1_terminal(["If (read $8)"])  
+      [3] Const mutate $8 = Binary read x$5 < read $6
+    "]
+    bb1_instrs --> bb1_terminal(["If (read $8)"])
   end
-  
   subgraph bb3
     bb3_instrs["
       [4] Const mutate $9 = 1
-      [5] Binary read x$5 + read $9  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [5] Binary read x$5 + read $9
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["Return read x$5"])  
+    bb2_terminal(["Return read x$5"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb3
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/ssa-while.expect.md b/compiler/forget/src/__tests__/fixtures/hir/ssa-while.expect.md
index 6f4024db87..cec06d758b 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/ssa-while.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/ssa-while.expect.md
@@ -41,42 +41,36 @@ flowchart TB
   %% Basic Blocks
   subgraph bb0
     bb0_instrs["
-      [1] Let mutate x$1 = 1  
-    "]    
-    bb0_instrs --> bb0_terminal(["While"])  
+      [1] Let mutate x$1 = 1
+    "]
+    bb0_instrs --> bb0_terminal(["While"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [2] Const mutate $6 = 10
-      [3] Const mutate $8 = Binary read x$1 < read $6  
-    "]    
-    bb1_instrs --> bb1_terminal(["If (read $8)"])  
+      [3] Const mutate $8 = Binary read x$1 < read $6
+    "]
+    bb1_instrs --> bb1_terminal(["If (read $8)"])
   end
-  
   subgraph bb3
     bb3_instrs["
       [4] Const mutate $9 = 1
-      [5] Reassign mutate x$1 = Binary read x$1 + read $9  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [5] Reassign mutate x$1 = Binary read x$1 + read $9
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb2
-    bb2_terminal(["Return read x$1"])  
+    bb2_terminal(["Return read x$1"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb3
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/switch-non-final-default.expect.md b/compiler/forget/src/__tests__/fixtures/hir/switch-non-final-default.expect.md
index 225ca677b6..4c061df8cb 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/switch-non-final-default.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/switch-non-final-default.expect.md
@@ -70,35 +70,31 @@ flowchart TB
       [2] Let mutate y$3 = undefined
       [3] Const mutate $12 = false
       [4] Const mutate $13 = true
-      [5] Const mutate $14 = 1  
-    "]    
-    bb0_instrs --> bb0_terminal(["Switch (read props$9.p0)"])  
+      [5] Const mutate $14 = 1
+    "]
+    bb0_instrs --> bb0_terminal(["Switch (read props$9.p0)"])
   end
-  
   subgraph bb6
     bb6_instrs["
       [6] Call mutate x$10.push(read props$9.p2)
-      [7] Reassign mutate y$3 = Array []  
-    "]    
-    bb6_instrs --> bb6_terminal(["Goto"])  
+      [7] Reassign mutate y$3 = Array []
+    "]
+    bb6_instrs --> bb6_terminal(["Goto"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [8] Reassign mutate y$3 = read x$10  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [8] Reassign mutate y$3 = read x$10
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [9] Const mutate child$19 = JSX <read Component$0 data={freeze x$10} ></read Component$0>
       [10] Call read y$3.push(read props$9.p4)
-      [11] Const mutate $22 = JSX <read Component$0 data={freeze y$3} >{read child$19}</read Component$0>  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read $22"])  
+      [11] Const mutate $22 = JSX <read Component$0 data={freeze y$3} >{read child$19}</read Component$0>
+    "]
+    bb1_instrs --> bb1_terminal(["Return read $22"])
   end
-  
 
   %% Jumps
   bb0_terminal -- read $14 --> bb1
@@ -106,11 +102,9 @@ flowchart TB
   bb0_terminal -- default --> bb1
   bb0_terminal -- read $12 --> bb2
   bb0_terminal -- fallthrough --> bb1
-  
   bb6_terminal --> bb1
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/switch-with-fallthrough.expect.md b/compiler/forget/src/__tests__/fixtures/hir/switch-with-fallthrough.expect.md
index 4a65868526..db35e21478 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/switch-with-fallthrough.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/switch-with-fallthrough.expect.md
@@ -93,57 +93,49 @@ flowchart TB
       [4] Const mutate $13 = 3
       [5] Const mutate $14 = 2
       [6] Const mutate $15 = 1
-      [7] Const mutate $16 = 0  
-    "]    
-    bb0_instrs --> bb0_terminal(["Switch (read x$9)"])  
+      [7] Const mutate $16 = 0
+    "]
+    bb0_instrs --> bb0_terminal(["Switch (read x$9)"])
   end
-  
   subgraph bb10
     bb10_instrs["
-      [8] Reassign mutate y$17 = 0  
-    "]    
-    bb10_instrs --> bb10_terminal(["Goto"])  
+      [8] Reassign mutate y$17 = 0
+    "]
+    bb10_instrs --> bb10_terminal(["Goto"])
   end
-  
   subgraph bb9
     bb9_instrs["
-      [9] Reassign mutate y$18 = 1  
-    "]    
-    bb9_instrs --> bb9_terminal(["Goto"])  
+      [9] Reassign mutate y$18 = 1
+    "]
+    bb9_instrs --> bb9_terminal(["Goto"])
   end
-  
   subgraph bb5
     bb5_instrs["
-      [10] Reassign mutate y$19 = 3  
-    "]    
-    bb5_instrs --> bb5_terminal(["Goto"])  
+      [10] Reassign mutate y$19 = 3
+    "]
+    bb5_instrs --> bb5_terminal(["Goto"])
   end
-  
   subgraph bb4
     bb4_instrs["
-      [11] Reassign mutate y$20 = 4  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [11] Reassign mutate y$20 = 4
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb3
     bb3_instrs["
-      [12] Reassign mutate y$21 = 5  
-    "]    
-    bb3_instrs --> bb3_terminal(["Goto"])  
+      [12] Reassign mutate y$21 = 5
+    "]
+    bb3_instrs --> bb3_terminal(["Goto"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [13] Reassign mutate y$22 = 0  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [13] Reassign mutate y$22 = 0
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
-    bb1_terminal(["Return"])  
+    bb1_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- read $16 --> bb10
@@ -154,19 +146,13 @@ flowchart TB
   bb0_terminal -- read $11 --> bb3
   bb0_terminal -- default --> bb2
   bb0_terminal -- fallthrough --> bb1
-  
   bb10_terminal --> bb9
-  
   bb9_terminal --> bb1
-  
   bb5_terminal --> bb1
-  
   bb4_terminal --> bb3
-  
   bb3_terminal --> bb2
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/switch.expect.md b/compiler/forget/src/__tests__/fixtures/hir/switch.expect.md
index 3dca25095e..249a93c107 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/switch.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/switch.expect.md
@@ -64,47 +64,41 @@ flowchart TB
       [1] Let mutate x$9[1:6] = Array []
       [2] Let mutate y$3 = undefined
       [3] Const mutate $11 = false
-      [4] Const mutate $12 = true  
-    "]    
-    bb0_instrs --> bb0_terminal(["Switch (read props$8.p0)"])  
+      [4] Const mutate $12 = true
+    "]
+    bb0_instrs --> bb0_terminal(["Switch (read props$8.p0)"])
   end
-  
   subgraph bb4
     bb4_instrs["
       [5] Call mutate x$9.push(read props$8.p2)
       [6] Call mutate x$9.push(read props$8.p3)
-      [7] Reassign mutate y$13 = Array []  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [7] Reassign mutate y$13 = Array []
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [8] Reassign mutate y$3 = read x$9  
-    "]    
-    bb2_instrs --> bb2_terminal(["Goto"])  
+      [8] Reassign mutate y$3 = read x$9
+    "]
+    bb2_instrs --> bb2_terminal(["Goto"])
   end
-  
   subgraph bb1
     bb1_instrs["
       [9] Const mutate child$19 = JSX <read Component$0 data={freeze x$9} ></read Component$0>
       [10] Call read y$3.push(read props$8.p4)
-      [11] Const mutate $23 = JSX <read Component$0 data={read y$3} >{read child$19}</read Component$0>  
-    "]    
-    bb1_instrs --> bb1_terminal(["Return read $23"])  
+      [11] Const mutate $23 = JSX <read Component$0 data={read y$3} >{read child$19}</read Component$0>
+    "]
+    bb1_instrs --> bb1_terminal(["Return read $23"])
   end
-  
 
   %% Jumps
   bb0_terminal -- read $12 --> bb4
   bb0_terminal -- read $11 --> bb2
   bb0_terminal -- default --> bb1
   bb0_terminal -- fallthrough --> bb1
-  
   bb4_terminal --> bb2
-  
   bb2_terminal --> bb1
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/while-break.expect.md b/compiler/forget/src/__tests__/fixtures/hir/while-break.expect.md
index eb7abed67b..17b95ce7ca 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/while-break.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/while-break.expect.md
@@ -30,26 +30,22 @@ bb2:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["While"])  
+    bb0_terminal(["While"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read a$3)"])  
+    bb1_terminal(["If (read a$3)"])
   end
-  
   subgraph bb2
-    bb2_terminal(["Return read b$4"])  
+    bb2_terminal(["Return read b$4"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb2
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb2
   bb1_terminal -- else --> bb2
-  
+
 ```
 
 ## Code
diff --git a/compiler/forget/src/__tests__/fixtures/hir/while-conditional-continue.expect.md b/compiler/forget/src/__tests__/fixtures/hir/while-conditional-continue.expect.md
index c5a552225d..bbc02f51c8 100644
--- a/compiler/forget/src/__tests__/fixtures/hir/while-conditional-continue.expect.md
+++ b/compiler/forget/src/__tests__/fixtures/hir/while-conditional-continue.expect.md
@@ -45,51 +45,41 @@ bb2:
 flowchart TB
   %% Basic Blocks
   subgraph bb0
-    bb0_terminal(["While"])  
+    bb0_terminal(["While"])
   end
-  
   subgraph bb1
-    bb1_terminal(["If (read a$5)"])  
+    bb1_terminal(["If (read a$5)"])
   end
-  
   subgraph bb3
-    bb3_terminal(["If (read b$6)"])  
+    bb3_terminal(["If (read b$6)"])
   end
-  
   subgraph bb5
-    bb5_terminal(["Goto"])  
+    bb5_terminal(["Goto"])
   end
-  
   subgraph bb4
     bb4_instrs["
-      [1] Call read c$7()  
-    "]    
-    bb4_instrs --> bb4_terminal(["Goto"])  
+      [1] Call read c$7()
+    "]
+    bb4_instrs --> bb4_terminal(["Goto"])
   end
-  
   subgraph bb2
     bb2_instrs["
-      [2] Call read d$8()  
-    "]    
-    bb2_instrs --> bb2_terminal(["Return"])  
+      [2] Call read d$8()
+    "]
+    bb2_instrs --> bb2_terminal(["Return"])
   end
-  
 
   %% Jumps
   bb0_terminal -- test --> bb1
   bb0_terminal -- loop --> bb3
   bb0_terminal -- fallthrough --> bb2
-  
   bb1_terminal -- then --> bb3
   bb1_terminal -- else --> bb2
-  
   bb3_terminal -- then --> bb5
   bb3_terminal -- else --> bb4
-  
   bb5_terminal --> bb1
-  
   bb4_terminal --> bb1
-  
+
 ```
 
 ## Code