fix: format

Author: indietyp

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/basic-constant-folding.jsonc

@@ -2,4 +2,4 @@
 //@ description: Pre-pass CP + CFG folds constant branch and simplifies control flow
 // The `if true` should be folded away by the initial CP + CFG simplification pass,
 // leaving only the "then" branch.
-["if", {"#literal": true}, {"#literal": "then"}, {"#literal": "else"}]
+["if", { "#literal": true }, { "#literal": "then" }, { "#literal": "else" }]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/chain-simplification.jsonc

@@ -8,16 +8,23 @@
 //   Iter 2: FS propagates `b = true`, CFG folds second if → `c = true`
 //   Iter 3: FS propagates `c = true`, CFG folds final if → "yes"
 [
-  "if", {"#literal": true},
+  "if",
+  { "#literal": true },
   [
-    "let", "a", {"#literal": true},
+    "let",
+    "a",
+    { "#literal": true },
     [
-      "let", "b", ["if", "a", {"#literal": true}, {"#literal": false}],
+      "let",
+      "b",
+      ["if", "a", { "#literal": true }, { "#literal": false }],
       [
-        "let", "c", ["if", "b", {"#literal": true}, {"#literal": false}],
-        ["if", "c", {"#literal": "yes"}, {"#literal": "no"}]
+        "let",
+        "c",
+        ["if", "b", { "#literal": true }, { "#literal": false }],
+        ["if", "c", { "#literal": "yes" }, { "#literal": "no" }]
       ]
     ]
   ],
-  {"#literal": 0}
+  { "#literal": 0 }
 ]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/closure-with-dead-branch.jsonc

@@ -3,12 +3,13 @@
 // A closure that returns a constant is defined and called with a constant condition.
 // AR inlines the closure, then CP + CFG simplifies the constant branch.
 [
-  "let", "identity",
-  ["fn", {"#tuple": []}, {"#struct": {"x": "Boolean"}}, "_", "x"],
+  "let",
+  "identity",
+  ["fn", { "#tuple": [] }, { "#struct": { "x": "Boolean" } }, "_", "x"],
   [
     "if",
-    ["identity", {"#literal": true}],
-    {"#literal": "yes"},
-    {"#literal": "no"}
+    ["identity", { "#literal": true }],
+    { "#literal": "yes" },
+    { "#literal": "no" }
   ]
 ]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/dead-code-after-propagation.jsonc

@@ -4,10 +4,8 @@
 // FS propagates `x` into the result, then DSE removes the dead assignment to `dead`.
 // Wrapped in `if true` to keep as a single body rather than separate thunks.
 [
-  "if", {"#literal": true},
-  [
-    "let", "x", {"#literal": 42},
-    ["let", "dead", {"#literal": 100}, "x"]
-  ],
-  {"#literal": 0}
+  "if",
+  { "#literal": true },
+  ["let", "x", { "#literal": 42 }, ["let", "dead", { "#literal": 100 }, "x"]],
+  { "#literal": 0 }
 ]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/inst-simplify-with-propagation.jsonc

@@ -3,10 +3,8 @@
 // A let binding stores a value that is used in a comparison.
 // InstSimplify can fold the comparison after FS propagates the constant.
 [
-  "let", "x", {"#literal": true},
-  [
-    "if", "x",
-    {"#literal": "was-true"},
-    {"#literal": "was-false"}
-  ]
+  "let",
+  "x",
+  { "#literal": true },
+  ["if", "x", { "#literal": "was-true" }, { "#literal": "was-false" }]
 ]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/nested-if-constant.jsonc

@@ -3,15 +3,18 @@
 // Multiple levels of constant if-then-else that should all fold away.
 // Tests that CFG simplification works across multiple iterations.
 [
-  "if", {"#literal": true},
+  "if",
+  { "#literal": true },
   [
-    "if", {"#literal": false},
-    {"#literal": "unreachable"},
+    "if",
+    { "#literal": false },
+    { "#literal": "unreachable" },
     [
-      "if", {"#literal": true},
-      {"#literal": "result"},
-      {"#literal": "also-unreachable"}
+      "if",
+      { "#literal": true },
+      { "#literal": "result" },
+      { "#literal": "also-unreachable" }
     ]
   ],
-  {"#literal": "outer-else"}
+  { "#literal": "outer-else" }
 ]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/nested-let-cleanup.jsonc

@@ -4,19 +4,23 @@
 // CP propagates used values, DSE removes dead stores, CFG cleans up the result.
 // Wrapped in `if true` to keep as a single body rather than separate thunks.
 [
-  "if", {"#literal": true},
+  "if",
+  { "#literal": true },
   [
-    "let", "a", {"#literal": 1},
+    "let",
+    "a",
+    { "#literal": 1 },
     [
-      "let", "b", {"#literal": 2},
+      "let",
+      "b",
+      { "#literal": 2 },
       [
-        "let", "c", {"#literal": 3},
-        [
-          "let", "unused1", "a",
-          ["let", "unused2", "b", "c"]
-        ]
+        "let",
+        "c",
+        { "#literal": 3 },
+        ["let", "unused1", "a", ["let", "unused2", "b", "c"]]
       ]
     ]
   ],
-  {"#literal": 0}
+  { "#literal": 0 }
 ]

libs/@local/hashql/mir/tests/ui/pass/pre_inlining/thunk-with-dead-code.jsonc

@@ -3,17 +3,18 @@
 // A thunk (zero-argument closure) is called, and its result used in a branch.
 // AR inlines the thunk, then the constant propagates and dead code is eliminated.
 [
-  "let", "get_flag",
-  ["fn", {"#tuple": []}, {"#struct": {}}, "_", {"#literal": true}],
+  "let",
+  "get_flag",
+  ["fn", { "#tuple": [] }, { "#struct": {} }, "_", { "#literal": true }],
   [
-    "let", "flag", ["get_flag"],
+    "let",
+    "flag",
+    ["get_flag"],
     [
-      "let", "unused", {"#literal": "dead"},
-      [
-        "if", "flag",
-        {"#literal": "active"},
-        {"#literal": "inactive"}
-      ]
+      "let",
+      "unused",
+      { "#literal": "dead" },
+      ["if", "flag", { "#literal": "active" }, { "#literal": "inactive" }]
     ]
   ]
 ]