From 329bb555a0bfd99d22eb8374835699c2278224f9 Mon Sep 17 00:00:00 2001
From: Joe Savona <joesavona@fb.com>
Date: Wed, 6 Mar 2024 11:07:08 -0800
Subject: [PATCH] [RFC] Stabilize naming of promoted temporaries

When the compiler promotes temporary values to named variables, we currently
eagerly assign a name using the temporary's IdentifierId. This means that we're
sort of stuck with this name later in compilation, and RenameVariables can't be
100% sure whether a 't0' variable is a temporary or not. As a result, the names
of these promoted temporaries is influenced by how many temporaries we happened
to create during compilation (and what the next available identifier id was),
making them fluctuate more as we iterate on the compiler.

This is an RFC for showing how we can stabilize these names. The key elements:

* Distinguish promoted temporaries from other named identifiers. Here we use a
hack, naming them starting with '#t' or '#T', since '#' isn't a valid identifier
starting point. This lets us keep all of our logic that looks for non-null
identifiers names to distinguish named/unnamed, while also distinguishing real
names from generated names (if this was Rust, we'd use an Enum and have a
"isNamed()" method on it that was true for real/temporary names and false
otherwise)

* In RenameVariables, detect generated names and fall back to generating the
next available `tN`-style name (or `TN` for JSX tags).

* To reduce thrash overall, RenameVariables no longer keeps a global "next id"
value that uses to distinguish all conflicting identifiers, instead we restart
at 0 whenever we find a conflict, and keep bumping until we find a free name.
Thus if both `foo` and `bar` had conflicts, we previously would end up with
`foo$0` and `bar$1` as the deduped names, but now will end up with `foo$0` and
`bar$0`.

## RFC

I'm open to feedback on the approach. Two main questions:

* How to annotate promoted temporaries. The most type-safe option is to change
`Identifier.name` to be a union of `{kind: 'named', value: string} | `{kind:
'promoted', value: string} | `{kind: 'temporary'}` though TS then wouldn't allow
`identifier.name.value` (even as nullable) since it doesn't exist on one of the
variants. Maybe we could type the temporary one as `{kind: 'temporary', value?:
null}` so the value has to be null but you can always access that property?

* ?? Other concerns about the approach? We could keep the global
auto-incrementing id rather than attempting to reset to 0 for each conflict.
---
 ...neImmediatelyInvokedFunctionExpressions.ts |   2 +-
 ...tractScopeDeclarationsFromDestructuring.ts |   2 +-
 .../ReactiveScopes/PromoteUsedTemporaries.ts  |   4 +-
 .../ReactiveScopes/PropagateEarlyReturns.ts   |   2 +-
 .../src/ReactiveScopes/RenameVariables.ts     |  89 ++++++---
 ...ng-primitive-as-dep-nested-scope.expect.md |  10 +-
 .../array-access-assignment.expect.md         |  10 +-
 .../compiler/array-at-effect.expect.md        |  18 +-
 .../babel-existing-react-import.expect.md     |  64 +++----
 ...xisting-react-kitchensink-import.expect.md |  64 +++----
 ...-existing-react-namespace-import.expect.md |  32 ++--
 ...-scoping-switch-variable-scoping.expect.md |  14 +-
 ...g.useMemo-deps-array-not-cleared.expect.md |  12 +-
 ...ith-independently-memoizable-arg.expect.md |  18 +-
 .../conditional-early-return.expect.md        |  42 ++---
 .../compiler/createElement-freeze.expect.md   |  18 +-
 ...and-local-variables-with-default.expect.md |  48 ++---
 ...ed-scope-declarations-and-locals.expect.md |  24 +--
 .../drop-methodcall-usememo.expect.md         |   6 +-
 ...rly-return-within-reactive-scope.expect.md |  28 +--
 ...tions-reassignments-dependencies.expect.md |  24 +--
 ...rly-return-within-reactive-scope.expect.md |  24 +--
 ...alysis-destructured-rest-element.expect.md |   8 +-
 .../compiler/hooks-with-prefix.expect.md      |  40 ++---
 ...fe-return-modified-later-logical.expect.md |  10 +-
 .../iife-return-modified-later-phi.expect.md  |   8 +-
 .../iife-return-modified-later.expect.md      |  10 +-
 ...-promoted-to-outer-scope-dynamic.expect.md |  94 +++++-----
 ...-tag-evaluation-order-non-global.expect.md |  40 ++---
 .../jsx-tag-evaluation-order.expect.md        |  16 +-
 ...ction-with-param-as-captured-dep.expect.md |  12 +-
 .../noAlias-filter-on-array-prop.expect.md    |  18 +-
 .../obj-literal-cached-in-if-else.expect.md   |  10 +-
 .../object-shorthand-method-2.expect.md       |  20 +--
 ...rly-return-within-reactive-scope.expect.md |  26 +--
 .../primitive-as-dep-nested-scope.expect.md   |  10 +-
 .../readonly-object-method-calls.expect.md    |  10 +-
 .../reassignment-conditional.expect.md        |  10 +-
 .../fixtures/compiler/reassignment.expect.md  |  10 +-
 .../compiler/regexp-literal.expect.md         |  10 +-
 .../remove-memoization-kitchen-sink.expect.md |   6 +-
 ...rray-with-mutable-map-after-hook.expect.md |  16 +-
 ...epro-hoisting-variable-collision.expect.md |  28 +--
 ...o-variable-without-mutable-range.expect.md |  10 +-
 ...repro-renaming-conflicting-decls.expect.md | 170 +++++++++---------
 ...ession-of-jsxexpressioncontainer.expect.md |  32 ++--
 .../allow-locals-named-like-hooks.expect.md   |  10 +-
 .../allow-props-named-like-hooks.expect.md    |  10 +-
 ...assignment-to-scope-declarations.expect.md |   4 +-
 ...ixed-local-and-scope-declaration.expect.md |   8 +-
 .../fixtures/compiler/simple.expect.md        |  16 +-
 .../compiler/ssa-property-alias-if.expect.md  |  10 +-
 .../switch-non-final-default.expect.md        |  20 +--
 ...o.unnecessary-lambda-memoization.expect.md |  28 +--
 ...tive-freeze-function-expressions.expect.md |  18 +-
 ...atch-try-value-modified-in-catch.expect.md |  16 +-
 .../try-catch-with-catch-param.expect.md      |  16 +-
 .../compiler/try-catch-with-return.expect.md  |  16 +-
 .../try-catch-within-mutable-range.expect.md  |  10 +-
 .../todo_type-annotations-props.expect.md     |  18 +-
 .../unused-object-element-with-rest.expect.md |   4 +-
 .../useMemo-if-else-multiple-return.expect.md |  16 +-
 ...seMemo-independently-memoizeable.expect.md |  50 +++---
 .../useMemo-inlining-block-return.expect.md   |  16 +-
 .../compiler/useMemo-inverted-if.expect.md    |   8 +-
 ...d-statement-unconditional-return.expect.md |   6 +-
 .../compiler/useMemo-logical.expect.md        |   6 +-
 ...-preserve-memoization-guarantees.expect.md |   6 +-
 ...-preserve-memoization-guarantees.expect.md |   6 +-
 ...-preserve-memoization-guarantees.expect.md |  10 +-
 ...-preserve-memoization-guarantees.expect.md |  12 +-
 .../useMemo-multiple-if-else.expect.md        |  12 +-
 .../compiler/useMemo-simple.expect.md         |  32 ++--
 .../useMemo-switch-no-fallthrough.expect.md   |   8 +-
 .../compiler/useMemo-switch-return.expect.md  |   8 +-
 ...tion-with-mutable-range-is-valid.expect.md |  28 +--
 76 files changed, 820 insertions(+), 787 deletions(-)

diff --git a/compiler/packages/babel-plugin-react-forget/src/Inference/InlineImmediatelyInvokedFunctionExpressions.ts b/compiler/packages/babel-plugin-react-forget/src/Inference/InlineImmediatelyInvokedFunctionExpressions.ts
index 607c2430cc..7c654b82e1 100644
--- a/compiler/packages/babel-plugin-react-forget/src/Inference/InlineImmediatelyInvokedFunctionExpressions.ts
+++ b/compiler/packages/babel-plugin-react-forget/src/Inference/InlineImmediatelyInvokedFunctionExpressions.ts
@@ -295,5 +295,5 @@ function declareTemporary(
 }
 
 function promoteTemporary(temp: Identifier): void {
-  temp.name = `t${temp.id}`;
+  temp.name = `#t${temp.id}`;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/ExtractScopeDeclarationsFromDestructuring.ts b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/ExtractScopeDeclarationsFromDestructuring.ts
index 7bcd3d3c06..7341cc5f22 100644
--- a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/ExtractScopeDeclarationsFromDestructuring.ts
+++ b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/ExtractScopeDeclarationsFromDestructuring.ts
@@ -152,7 +152,7 @@ function transformDestructuring(
     const tempId = state.env.nextIdentifierId;
     const temporary = {
       ...place,
-      identifier: { ...place.identifier, id: tempId, name: `t${tempId}` },
+      identifier: { ...place.identifier, id: tempId, name: `#t${tempId}` },
     };
     renamed.set(place, temporary);
     return temporary;
diff --git a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PromoteUsedTemporaries.ts b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PromoteUsedTemporaries.ts
index 1df0cd6d67..319bf7f930 100644
--- a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PromoteUsedTemporaries.ts
+++ b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PromoteUsedTemporaries.ts
@@ -85,8 +85,8 @@ function promoteTemporary(identifier: Identifier, state: VisitorState): void {
     suggestions: null,
   });
   if (state.tags.has(identifier.id)) {
-    identifier.name = `T${state.nextId++}`;
+    identifier.name = `#T${state.nextId++}`;
   } else {
-    identifier.name = `t${state.nextId++}`;
+    identifier.name = `#t${state.nextId++}`;
   }
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PropagateEarlyReturns.ts b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PropagateEarlyReturns.ts
index 6854593da9..609df8fb57 100644
--- a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PropagateEarlyReturns.ts
+++ b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/PropagateEarlyReturns.ts
@@ -274,7 +274,7 @@ class Transform extends ReactiveFunctionTransform<State> {
         earlyReturnValue = state.earlyReturnValue;
       } else {
         const identifier = createTemporaryPlace(this.env).identifier;
-        identifier.name = `t${identifier.id}`;
+        identifier.name = `#t${identifier.id}`;
         earlyReturnValue = {
           label: this.env.nextBlockId,
           loc,
diff --git a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/RenameVariables.ts b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/RenameVariables.ts
index 22e6c7fd0e..5cf68659a0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/RenameVariables.ts
+++ b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/RenameVariables.ts
@@ -13,26 +13,38 @@ import {
   Place,
   ReactiveBlock,
   ReactiveFunction,
-  ReactiveInstruction,
   ReactiveScopeBlock,
 } from "../HIR/HIR";
-import { eachInstructionLValue } from "../HIR/visitors";
-import {
-  ReactiveFunctionVisitor,
-  eachReactiveValueOperand,
-  visitReactiveFunction,
-} from "./visitors";
+import { ReactiveFunctionVisitor, visitReactiveFunction } from "./visitors";
 
-/*
+/**
  * Ensures that each named variable in the given function has a unique name
  * that does not conflict with any other variables in the same block scope.
  * Note that the scoping is based on the final inferred blocks, not the
  * block scopes that were present in the original source. Thus variables
  * that shadowed in the original source may end up with unique names in the
  * output, if Forget would merge those two blocks into a single scope.
+ *
+ * Variables are renamed using their original name followed by a number,
+ * starting with 0 and incrementing until a unique name is found. Eg if the
+ * compiler collapses three scopes that each had their own `foo` declaration,
+ * they will be renamed to `foo`, `foo0`, and `foo1`, assuming that no conflicts'
+ * exist for `foo0` and `foo1`.
+ *
+ * For temporary values that are promoted to named variables, the starting name
+ * is "T0" for values that appear in JSX tag position and "t0" otherwise. If this
+ * name conflicts, the number portion increments until the name is unique (t1, t2, etc).
  */
 export function renameVariables(fn: ReactiveFunction): void {
   const scopes = new Scopes();
+  renameVariablesImpl(fn, new Visitor(), scopes);
+}
+
+function renameVariablesImpl(
+  fn: ReactiveFunction,
+  visitor: Visitor,
+  scopes: Scopes
+): void {
   scopes.enter(() => {
     for (const param of fn.params) {
       if (param.kind === "Identifier") {
@@ -41,11 +53,14 @@ export function renameVariables(fn: ReactiveFunction): void {
         scopes.visit(param.place.identifier);
       }
     }
-    visitReactiveFunction(fn, new Visitor(), scopes);
+    visitReactiveFunction(fn, visitor, scopes);
   });
 }
 
 class Visitor extends ReactiveFunctionVisitor<Scopes> {
+  override visitLValue(_id: InstructionId, lvalue: Place, state: Scopes): void {
+    state.visit(lvalue.identifier);
+  }
   override visitPlace(id: InstructionId, place: Place, state: Scopes): void {
     state.visit(place.identifier);
   }
@@ -54,40 +69,58 @@ class Visitor extends ReactiveFunctionVisitor<Scopes> {
       this.traverseBlock(block, state);
     });
   }
-  override visitInstruction(instr: ReactiveInstruction, state: Scopes): void {
-    for (const operand of eachReactiveValueOperand(instr.value)) {
-      state.visit(operand.identifier);
-    }
-    for (const operand of eachInstructionLValue(instr)) {
-      this.visitPlace(instr.id, operand, state);
-    }
-  }
+
   override visitScope(scope: ReactiveScopeBlock, state: Scopes): void {
-    /*
-     * Intentionally bypass visitBlock() since scopes do not introduce a new
-     * block scope
-     */
-    this.traverseBlock(scope.instructions, state);
+    for (const [_, declaration] of scope.scope.declarations) {
+      state.visit(declaration.identifier);
+    }
+    this.traverseScope(scope, state);
+  }
+
+  override visitReactiveFunctionValue(
+    _id: InstructionId,
+    _dependencies: Place[],
+    _fn: ReactiveFunction,
+    _state: Scopes
+  ): void {
+    renameVariablesImpl(_fn, this, _state);
   }
 }
 
 class Scopes {
-  #nextId: number = 0;
-  #seen: Set<IdentifierId> = new Set();
+  #seen: Map<IdentifierId, string> = new Map();
   #stack: Array<Map<string, IdentifierId>> = [new Map()];
 
   visit(identifier: Identifier): void {
-    if (identifier.name === null || this.#seen.has(identifier.id)) {
+    const originalName = identifier.name;
+    if (originalName === null) {
       return;
     }
-    this.#seen.add(identifier.id);
-    let name = identifier.name;
+    const mappedName = this.#seen.get(identifier.id);
+    if (mappedName !== undefined) {
+      identifier.name = mappedName;
+      return;
+    }
+    let name = originalName;
+    let id = 0;
+    if (name.startsWith("#t")) {
+      name = `t${id++}`;
+    } else if (name.startsWith("#T")) {
+      name = `T${id++}`;
+    }
     let previous = this.#lookup(name);
     while (previous !== null) {
-      name = `${identifier.name}$${this.#nextId++}`;
+      if (originalName.startsWith("#t")) {
+        name = `t${id++}`;
+      } else if (originalName.startsWith("#T")) {
+        name = `T${id++}`;
+      } else {
+        name = `${identifier.name}$${id++}`;
+      }
       previous = this.#lookup(name);
     }
     identifier.name = name;
+    this.#seen.set(identifier.id, name);
     this.#stack.at(-1)!.set(name, identifier.id);
   }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md
index d321e844b3..394362a11c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md
@@ -49,16 +49,16 @@ function AllocatingPrimitiveAsDepNested(props) {
     x = $[2];
     y = $[3];
   }
-  let t2;
+  let t0;
   if ($[6] !== x || $[7] !== y) {
-    t2 = [x, y];
+    t0 = [x, y];
     $[6] = x;
     $[7] = y;
-    $[8] = t2;
+    $[8] = t0;
   } else {
-    t2 = $[8];
+    t0 = $[8];
   }
-  return t2;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md
index 888a795075..24f090a26b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md
@@ -50,16 +50,16 @@ function foo(a, b, c) {
     x = $[3];
     z = $[4];
   }
-  let t1;
+  let t0;
   if ($[7] !== x || $[8] !== z) {
-    t1 = [x, z];
+    t0 = [x, z];
     $[7] = x;
     $[8] = z;
-    $[9] = t1;
+    $[9] = t0;
   } else {
-    t1 = $[9];
+    t0 = $[9];
   }
-  return t1;
+  return t0;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md
index e551b5d439..c7af0e05ff 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md
@@ -40,24 +40,24 @@ function ArrayAtTest(props) {
     t1 = $[3];
   }
   const arr = t1;
-  let t3;
+  let t2;
   if ($[4] !== props.y || $[5] !== arr) {
-    let t2;
+    let t3;
     if ($[7] !== props.y) {
-      t2 = bar(props.y);
+      t3 = bar(props.y);
       $[7] = props.y;
-      $[8] = t2;
+      $[8] = t3;
     } else {
-      t2 = $[8];
+      t3 = $[8];
     }
-    t3 = arr.at(t2);
+    t2 = arr.at(t3);
     $[4] = props.y;
     $[5] = arr;
-    $[6] = t3;
+    $[6] = t2;
   } else {
-    t3 = $[6];
+    t2 = $[6];
   }
-  const result = t3;
+  const result = t2;
   return result;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md
index 09414c0d66..31a06dd6ce 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md
@@ -32,51 +32,51 @@ import {
 function Component(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
-  let t15;
   let t0;
-  if ($[0] !== x) {
-    t0 = calculateExpensiveNumber(x);
-    $[0] = x;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  t15 = t0;
-  const expensiveNumber = t15;
   let t1;
-  if ($[2] !== expensiveNumber) {
-    t1 = <div>{expensiveNumber}</div>;
-    $[2] = expensiveNumber;
-    $[3] = t1;
+  if ($[0] !== x) {
+    t1 = calculateExpensiveNumber(x);
+    $[0] = x;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  return t1;
+  t0 = t1;
+  const expensiveNumber = t0;
+  let t2;
+  if ($[2] !== expensiveNumber) {
+    t2 = <div>{expensiveNumber}</div>;
+    $[2] = expensiveNumber;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
 }
 
 function Component2(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
-  let t15;
   let t0;
-  if ($[0] !== x) {
-    t0 = calculateExpensiveNumber(x);
-    $[0] = x;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  t15 = t0;
-  const expensiveNumber = t15;
   let t1;
-  if ($[2] !== expensiveNumber) {
-    t1 = <div>{expensiveNumber}</div>;
-    $[2] = expensiveNumber;
-    $[3] = t1;
+  if ($[0] !== x) {
+    t1 = calculateExpensiveNumber(x);
+    $[0] = x;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  return t1;
+  t0 = t1;
+  const expensiveNumber = t0;
+  let t2;
+  if ($[2] !== expensiveNumber) {
+    t2 = <div>{expensiveNumber}</div>;
+    $[2] = expensiveNumber;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md
index 33034d1768..165b04b81e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md
@@ -34,51 +34,51 @@ import {
 function Component(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
-  let t15;
   let t0;
-  if ($[0] !== x) {
-    t0 = calculateExpensiveNumber(x);
-    $[0] = x;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  t15 = t0;
-  const expensiveNumber = t15;
   let t1;
-  if ($[2] !== expensiveNumber) {
-    t1 = <div>{expensiveNumber}</div>;
-    $[2] = expensiveNumber;
-    $[3] = t1;
+  if ($[0] !== x) {
+    t1 = calculateExpensiveNumber(x);
+    $[0] = x;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  return t1;
+  t0 = t1;
+  const expensiveNumber = t0;
+  let t2;
+  if ($[2] !== expensiveNumber) {
+    t2 = <div>{expensiveNumber}</div>;
+    $[2] = expensiveNumber;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
 }
 
 function Component2(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
-  let t15;
   let t0;
-  if ($[0] !== x) {
-    t0 = calculateExpensiveNumber(x);
-    $[0] = x;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  t15 = t0;
-  const expensiveNumber = t15;
   let t1;
-  if ($[2] !== expensiveNumber) {
-    t1 = <div>{expensiveNumber}</div>;
-    $[2] = expensiveNumber;
-    $[3] = t1;
+  if ($[0] !== x) {
+    t1 = calculateExpensiveNumber(x);
+    $[0] = x;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  return t1;
+  t0 = t1;
+  const expensiveNumber = t0;
+  let t2;
+  if ($[2] !== expensiveNumber) {
+    t2 = <div>{expensiveNumber}</div>;
+    $[2] = expensiveNumber;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md
index 60d08f81ea..2029e93686 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md
@@ -29,26 +29,26 @@ import { calculateExpensiveNumber } from "shared-runtime";
 function Component(props) {
   const $ = useMemoCache(4);
   const [x] = React.useState(0);
-  let t17;
   let t0;
-  if ($[0] !== x) {
-    t0 = calculateExpensiveNumber(x);
-    $[0] = x;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  t17 = t0;
-  const expensiveNumber = t17;
   let t1;
-  if ($[2] !== expensiveNumber) {
-    t1 = <div>{expensiveNumber}</div>;
-    $[2] = expensiveNumber;
-    $[3] = t1;
+  if ($[0] !== x) {
+    t1 = calculateExpensiveNumber(x);
+    $[0] = x;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  return t1;
+  t0 = t1;
+  const expensiveNumber = t0;
+  let t2;
+  if ($[2] !== expensiveNumber) {
+    t2 = <div>{expensiveNumber}</div>;
+    $[2] = expensiveNumber;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/block-scoping-switch-variable-scoping.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/block-scoping-switch-variable-scoping.expect.md
index 6b77b6bf00..afa30b2e92 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/block-scoping-switch-variable-scoping.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/block-scoping-switch-variable-scoping.expect.md
@@ -34,16 +34,16 @@ import { useMemo, unstable_useMemoCache as useMemoCache } from "react";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  let t22;
   let t0;
+  let t1;
   if ($[0] !== props.value) {
-    t0 = { value: props.value };
+    t1 = { value: props.value };
     $[0] = props.value;
-    $[1] = t0;
+    $[1] = t1;
   } else {
-    t0 = $[1];
+    t1 = $[1];
   }
-  const handlers = t0;
+  const handlers = t1;
   bb2: switch (props.test) {
     case true: {
       console.log(handlers.value);
@@ -53,8 +53,8 @@ function Component(props) {
     }
   }
 
-  t22 = handlers;
-  const outerHandlers = t22;
+  t0 = handlers;
+  const outerHandlers = t0;
   return outerHandlers;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md
index c65dc3cef7..7231221e31 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md
@@ -29,17 +29,17 @@ function App(t25) {
   const { text, hasDeps } = t25;
 
   hasDeps ? null : [text];
-  let t18;
   let t0;
+  let t1;
   if ($[0] !== text) {
-    t0 = text.toUpperCase();
+    t1 = text.toUpperCase();
     $[0] = text;
-    $[1] = t0;
+    $[1] = t1;
   } else {
-    t0 = $[1];
+    t1 = $[1];
   }
-  t18 = t0;
-  const resolvedText = t18;
+  t0 = t1;
+  const resolvedText = t0;
   return resolvedText;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md
index 052b76f042..2107913315 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md
@@ -20,28 +20,28 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
-  let t1;
+  let t0;
   if ($[0] !== props) {
     const x = makeFunction(props);
-    let t0;
+    let t1;
     if ($[2] !== props.text) {
-      t0 = (
+      t1 = (
         <div>
           <span>{props.text}</span>
         </div>
       );
       $[2] = props.text;
-      $[3] = t0;
+      $[3] = t1;
     } else {
-      t0 = $[3];
+      t1 = $[3];
     }
-    t1 = x(t0);
+    t0 = x(t1);
     $[0] = props;
-    $[1] = t1;
+    $[1] = t0;
   } else {
-    t1 = $[1];
+    t0 = $[1];
   }
-  const y = t1;
+  const y = t0;
   return y;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-early-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-early-return.expect.md
index 29074d3508..41f5bc32cc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-early-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-early-return.expect.md
@@ -73,14 +73,14 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function ComponentA(props) {
   const $ = useMemoCache(5);
   let a_DEBUG;
-  let t37;
+  let t0;
   if ($[0] !== props.a || $[1] !== props.b || $[2] !== props.d) {
-    t37 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb7: {
       a_DEBUG = [];
       a_DEBUG.push(props.a);
       if (props.b) {
-        t37 = null;
+        t0 = null;
         break bb7;
       }
 
@@ -90,13 +90,13 @@ function ComponentA(props) {
     $[1] = props.b;
     $[2] = props.d;
     $[3] = a_DEBUG;
-    $[4] = t37;
+    $[4] = t0;
   } else {
     a_DEBUG = $[3];
-    t37 = $[4];
+    t0 = $[4];
   }
-  if (t37 !== Symbol.for("react.early_return_sentinel")) {
-    return t37;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
   return a_DEBUG;
 }
@@ -129,15 +129,15 @@ function ComponentB(props) {
 function ComponentC(props) {
   const $ = useMemoCache(3);
   let a;
-  let t47;
+  let t0;
   if ($[0] !== props) {
-    t47 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb7: {
       a = [];
       a.push(props.a);
       if (props.b) {
         a.push(props.c);
-        t47 = null;
+        t0 = null;
         break bb7;
       }
 
@@ -145,13 +145,13 @@ function ComponentC(props) {
     }
     $[0] = props;
     $[1] = a;
-    $[2] = t47;
+    $[2] = t0;
   } else {
     a = $[1];
-    t47 = $[2];
+    t0 = $[2];
   }
-  if (t47 !== Symbol.for("react.early_return_sentinel")) {
-    return t47;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
   return a;
 }
@@ -162,15 +162,15 @@ function ComponentC(props) {
 function ComponentD(props) {
   const $ = useMemoCache(3);
   let a;
-  let t47;
+  let t0;
   if ($[0] !== props) {
-    t47 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb7: {
       a = [];
       a.push(props.a);
       if (props.b) {
         a.push(props.c);
-        t47 = a;
+        t0 = a;
         break bb7;
       }
 
@@ -178,13 +178,13 @@ function ComponentD(props) {
     }
     $[0] = props;
     $[1] = a;
-    $[2] = t47;
+    $[2] = t0;
   } else {
     a = $[1];
-    t47 = $[2];
+    t0 = $[2];
   }
-  if (t47 !== Symbol.for("react.early_return_sentinel")) {
-    return t47;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
   return a;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/createElement-freeze.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/createElement-freeze.expect.md
index 158edcf8ad..80594b8137 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/createElement-freeze.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/createElement-freeze.expect.md
@@ -37,22 +37,22 @@ function Component(props) {
     t0 = $[1];
   }
   const childProps = t0;
-  let t2;
+  let t1;
   if ($[2] !== childProps) {
-    let t1;
+    let t2;
     if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
-      t1 = ["hello world"];
-      $[4] = t1;
+      t2 = ["hello world"];
+      $[4] = t2;
     } else {
-      t1 = $[4];
+      t2 = $[4];
     }
-    t2 = React.createElement("div", childProps, t1);
+    t1 = React.createElement("div", childProps, t2);
     $[2] = childProps;
-    $[3] = t2;
+    $[3] = t1;
   } else {
-    t2 = $[3];
+    t1 = $[3];
   }
-  const element = t2;
+  const element = t1;
   shallowCopy(childProps);
   return element;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
index 2deccae240..60b8b74221 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
@@ -64,29 +64,29 @@ function Component(props) {
   if ($[0] !== post) {
     allUrls = [];
 
-    const { media: t0, comments: t2, urls: t4 } = post;
-    let t1;
-    if ($[4] !== t0) {
-      t1 = t0 === undefined ? null : t0;
-      $[4] = t0;
-      $[5] = t1;
-    } else {
-      t1 = $[5];
-    }
-    media = t1;
+    const { media: t0, comments: t1, urls: t2 } = post;
     let t3;
-    if ($[6] !== t2) {
-      t3 = t2 === undefined ? [] : t2;
-      $[6] = t2;
-      $[7] = t3;
+    if ($[4] !== t0) {
+      t3 = t0 === undefined ? null : t0;
+      $[4] = t0;
+      $[5] = t3;
     } else {
-      t3 = $[7];
+      t3 = $[5];
     }
-    const comments = t3;
+    media = t3;
+    let t4;
+    if ($[6] !== t1) {
+      t4 = t1 === undefined ? [] : t1;
+      $[6] = t1;
+      $[7] = t4;
+    } else {
+      t4 = $[7];
+    }
+    const comments = t4;
     let t5;
-    if ($[8] !== t4) {
-      t5 = t4 === undefined ? [] : t4;
-      $[8] = t4;
+    if ($[8] !== t2) {
+      t5 = t2 === undefined ? [] : t2;
+      $[8] = t2;
       $[9] = t5;
     } else {
       t5 = $[9];
@@ -118,17 +118,17 @@ function Component(props) {
     allUrls = $[2];
     onClick = $[3];
   }
-  let t7;
+  let t0;
   if ($[12] !== media || $[13] !== allUrls || $[14] !== onClick) {
-    t7 = <Stringify media={media} allUrls={allUrls} onClick={onClick} />;
+    t0 = <Stringify media={media} allUrls={allUrls} onClick={onClick} />;
     $[12] = media;
     $[13] = allUrls;
     $[14] = onClick;
-    $[15] = t7;
+    $[15] = t0;
   } else {
-    t7 = $[15];
+    t0 = $[15];
   }
-  return t7;
+  return t0;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
index 83f9bb28a8..e67b488bbd 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
@@ -37,11 +37,11 @@ function Component(props) {
   if ($[0] !== post) {
     const allUrls = [];
 
-    const { media: t83, comments, urls } = post;
-    media = t83;
-    let t0;
+    const { media: t0, comments, urls } = post;
+    media = t0;
+    let t1;
     if ($[3] !== comments.length) {
-      t0 = (e) => {
+      t1 = (e) => {
         if (!comments.length) {
           return;
         }
@@ -49,11 +49,11 @@ function Component(props) {
         console.log(comments.length);
       };
       $[3] = comments.length;
-      $[4] = t0;
+      $[4] = t1;
     } else {
-      t0 = $[4];
+      t1 = $[4];
     }
-    onClick = t0;
+    onClick = t1;
 
     allUrls.push(...urls);
     $[0] = post;
@@ -63,16 +63,16 @@ function Component(props) {
     media = $[1];
     onClick = $[2];
   }
-  let t1;
+  let t0;
   if ($[5] !== media || $[6] !== onClick) {
-    t1 = <Media media={media} onClick={onClick} />;
+    t0 = <Media media={media} onClick={onClick} />;
     $[5] = media;
     $[6] = onClick;
-    $[7] = t1;
+    $[7] = t0;
   } else {
-    t1 = $[7];
+    t0 = $[7];
   }
-  return t1;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md
index 75c8dc41d5..9da6025aa0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md
@@ -28,7 +28,7 @@ import * as React from "react";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  let t19;
+  let t0;
   let x;
   if ($[0] !== props.value) {
     x = [];
@@ -38,8 +38,8 @@ function Component(props) {
   } else {
     x = $[1];
   }
-  t19 = x;
-  const x_0 = t19;
+  t0 = x;
+  const x_0 = t0;
   return x_0;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-nested-early-return-within-reactive-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-nested-early-return-within-reactive-scope.expect.md
index 5a6ced61b7..4a55cb243e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-nested-early-return-within-reactive-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-nested-early-return-within-reactive-scope.expect.md
@@ -32,29 +32,29 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(5);
-  let t53;
+  let t0;
   if ($[0] !== props) {
-    t53 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb11: {
       const x = [];
       if (props.cond) {
         x.push(props.a);
         if (props.b) {
-          let t0;
+          let t1;
           if ($[2] !== props.b) {
-            t0 = [props.b];
+            t1 = [props.b];
             $[2] = props.b;
-            $[3] = t0;
+            $[3] = t1;
           } else {
-            t0 = $[3];
+            t1 = $[3];
           }
-          const y = t0;
+          const y = t1;
           x.push(y);
-          t53 = x;
+          t0 = x;
           break bb11;
         }
 
-        t53 = x;
+        t0 = x;
         break bb11;
       } else {
         let t1;
@@ -64,17 +64,17 @@ function Component(props) {
         } else {
           t1 = $[4];
         }
-        t53 = t1;
+        t0 = t1;
         break bb11;
       }
     }
     $[0] = props;
-    $[1] = t53;
+    $[1] = t0;
   } else {
-    t53 = $[1];
+    t0 = $[1];
   }
-  if (t53 !== Symbol.for("react.early_return_sentinel")) {
-    return t53;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-no-declarations-reassignments-dependencies.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-no-declarations-reassignments-dependencies.expect.md
index 63df1742d0..50e4da268a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-no-declarations-reassignments-dependencies.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-no-declarations-reassignments-dependencies.expect.md
@@ -70,35 +70,35 @@ let ENABLE_FEATURE = false;
 
 function Component(props) {
   const $ = useMemoCache(3);
-  let t37;
+  let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t37 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb8: {
       const x = [];
       if (ENABLE_FEATURE) {
         x.push(42);
-        t37 = x;
+        t0 = x;
         break bb8;
       } else {
         console.log("fallthrough");
       }
     }
-    $[0] = t37;
+    $[0] = t0;
   } else {
-    t37 = $[0];
+    t0 = $[0];
   }
-  if (t37 !== Symbol.for("react.early_return_sentinel")) {
-    return t37;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
-  let t0;
+  let t1;
   if ($[1] !== props.a) {
-    t0 = makeArray(props.a);
+    t1 = makeArray(props.a);
     $[1] = props.a;
-    $[2] = t0;
+    $[2] = t1;
   } else {
-    t0 = $[2];
+    t1 = $[2];
   }
-  return t0;
+  return t1;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-within-reactive-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-within-reactive-scope.expect.md
index 1996b38494..30cdc84b95 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-within-reactive-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/early-return-within-reactive-scope.expect.md
@@ -46,35 +46,35 @@ import { makeArray } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(4);
-  let t33;
+  let t0;
   if ($[0] !== props) {
-    t33 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb8: {
       const x = [];
       if (props.cond) {
         x.push(props.a);
-        t33 = x;
+        t0 = x;
         break bb8;
       } else {
-        let t0;
+        let t1;
         if ($[2] !== props.b) {
-          t0 = makeArray(props.b);
+          t1 = makeArray(props.b);
           $[2] = props.b;
-          $[3] = t0;
+          $[3] = t1;
         } else {
-          t0 = $[3];
+          t1 = $[3];
         }
-        t33 = t0;
+        t0 = t1;
         break bb8;
       }
     }
     $[0] = props;
-    $[1] = t33;
+    $[1] = t0;
   } else {
-    t33 = $[1];
+    t0 = $[1];
   }
-  if (t33 !== Symbol.for("react.early_return_sentinel")) {
-    return t33;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md
index b2167c3b55..87a4a736d7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md
@@ -26,8 +26,8 @@ function Component(props) {
   const $ = useMemoCache(7);
   let b;
   if ($[0] !== props.a) {
-    const { a, ...t29 } = props.a;
-    b = t29;
+    const { a, ...t0 } = props.a;
+    b = t0;
     $[0] = props.a;
     $[1] = b;
   } else {
@@ -35,8 +35,8 @@ function Component(props) {
   }
   let d;
   if ($[2] !== props.c) {
-    const [c, ...t30] = props.c;
-    d = t30;
+    const [c, ...t0] = props.c;
+    d = t0;
     $[2] = props.c;
     $[3] = d;
   } else {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hooks-with-prefix.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hooks-with-prefix.expect.md
index 8127d8dd93..b0e29c337d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hooks-with-prefix.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hooks-with-prefix.expect.md
@@ -50,35 +50,35 @@ function Component() {
   const [state] = React$useState(0);
   const object = Internal$Reassigned$useHook();
   const json = JSON.stringify(object);
-  let t25;
   let t0;
-  if ($[0] !== state) {
-    t25 = makeArray(state);
-    const doubledArray = t25;
-
-    t0 = doubledArray.join("");
-    $[0] = state;
-    $[1] = t0;
-    $[2] = t25;
-  } else {
-    t0 = $[1];
-    t25 = $[2];
-  }
   let t1;
-  if ($[3] !== t0 || $[4] !== json) {
-    t1 = (
+  if ($[0] !== state) {
+    t0 = makeArray(state);
+    const doubledArray = t0;
+
+    t1 = doubledArray.join("");
+    $[0] = state;
+    $[1] = t1;
+    $[2] = t0;
+  } else {
+    t1 = $[1];
+    t0 = $[2];
+  }
+  let t2;
+  if ($[3] !== t1 || $[4] !== json) {
+    t2 = (
       <div>
-        {t0}
+        {t1}
         {json}
       </div>
     );
-    $[3] = t0;
+    $[3] = t1;
     $[4] = json;
-    $[5] = t1;
+    $[5] = t2;
   } else {
-    t1 = $[5];
+    t2 = $[5];
   }
-  return t1;
+  return t2;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-logical.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-logical.expect.md
index fa418e1522..9d2ae0047e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-logical.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-logical.expect.md
@@ -27,19 +27,19 @@ import { getNull } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(3);
-  let t10;
+  let t0;
   let items;
   if ($[0] !== props.a) {
-    t10 = getNull() ?? [];
-    items = t10;
+    t0 = getNull() ?? [];
+    items = t0;
 
     items.push(props.a);
     $[0] = props.a;
     $[1] = items;
-    $[2] = t10;
+    $[2] = t0;
   } else {
     items = $[1];
-    t10 = $[2];
+    t0 = $[2];
   }
   return items;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-phi.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-phi.expect.md
index 8b1e2452ff..bb44b2a218 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-phi.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later-phi.expect.md
@@ -29,13 +29,13 @@ function Component(props) {
   const $ = useMemoCache(2);
   let items;
   if ($[0] !== props) {
-    let t9;
+    let t0;
     if (props.cond) {
-      t9 = [];
+      t0 = [];
     } else {
-      t9 = null;
+      t0 = null;
     }
-    items = t9;
+    items = t0;
 
     items?.push(props.a);
     $[0] = props;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later.expect.md
index 95abbbdfc1..dcfe2856be 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/iife-return-modified-later.expect.md
@@ -23,19 +23,19 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  let t4;
+  let t0;
   let items;
   if ($[0] !== props.a) {
-    t4 = [];
-    items = t4;
+    t0 = [];
+    items = t0;
 
     items.push(props.a);
     $[0] = props.a;
     $[1] = items;
-    $[2] = t4;
+    $[2] = t0;
   } else {
     items = $[1];
-    t4 = $[2];
+    t0 = $[2];
   }
   return items;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md
index 97c6f6bae5..017ce9eb92 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md
@@ -27,66 +27,66 @@ function Component(props) {
   const $ = useMemoCache(15);
   const item = useFragment(FRAGMENT, props.item);
   useFreeze(item);
-  let t1;
-  let T2;
   let t0;
-  let T3;
+  let T0;
+  let t1;
+  let T1;
   if ($[0] !== item) {
     const count = new MaybeMutable(item);
 
-    T3 = View;
-    T2 = View;
+    T1 = View;
+    T0 = View;
     if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
-      t0 = <span>Text</span>;
-      $[5] = t0;
+      t1 = <span>Text</span>;
+      $[5] = t1;
     } else {
-      t0 = $[5];
+      t1 = $[5];
     }
-    t1 = maybeMutate(count);
+    t0 = maybeMutate(count);
     $[0] = item;
-    $[1] = t1;
-    $[2] = T2;
-    $[3] = t0;
-    $[4] = T3;
+    $[1] = t0;
+    $[2] = T0;
+    $[3] = t1;
+    $[4] = T1;
   } else {
-    t1 = $[1];
-    T2 = $[2];
-    t0 = $[3];
-    T3 = $[4];
+    t0 = $[1];
+    T0 = $[2];
+    t1 = $[3];
+    T1 = $[4];
+  }
+  let t2;
+  if ($[6] !== t0) {
+    t2 = <span>{t0}</span>;
+    $[6] = t0;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  let t3;
+  if ($[8] !== T0 || $[9] !== t1 || $[10] !== t2) {
+    t3 = (
+      <T0>
+        {t1}
+        {t2}
+      </T0>
+    );
+    $[8] = T0;
+    $[9] = t1;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
   }
   let t4;
-  if ($[6] !== t1) {
-    t4 = <span>{t1}</span>;
-    $[6] = t1;
-    $[7] = t4;
+  if ($[12] !== T1 || $[13] !== t3) {
+    t4 = <T1>{t3}</T1>;
+    $[12] = T1;
+    $[13] = t3;
+    $[14] = t4;
   } else {
-    t4 = $[7];
+    t4 = $[14];
   }
-  let t5;
-  if ($[8] !== T2 || $[9] !== t0 || $[10] !== t4) {
-    t5 = (
-      <T2>
-        {t0}
-        {t4}
-      </T2>
-    );
-    $[8] = T2;
-    $[9] = t0;
-    $[10] = t4;
-    $[11] = t5;
-  } else {
-    t5 = $[11];
-  }
-  let t6;
-  if ($[12] !== T3 || $[13] !== t5) {
-    t6 = <T3>{t5}</T3>;
-    $[12] = T3;
-    $[13] = t5;
-    $[14] = t6;
-  } else {
-    t6 = $[14];
-  }
-  return t6;
+  return t4;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md
index 7c435203c0..50bf79555d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md
@@ -55,47 +55,47 @@ function Component(props) {
   const $ = useMemoCache(11);
   let Tag;
   let T0;
-  let t1;
+  let t0;
   if ($[0] !== props.component || $[1] !== props.alternateComponent) {
     const maybeMutable = new MaybeMutable();
     Tag = props.component;
 
     T0 = Tag;
-    t1 = ((Tag = props.alternateComponent), maybeMutate(maybeMutable));
+    t0 = ((Tag = props.alternateComponent), maybeMutate(maybeMutable));
     $[0] = props.component;
     $[1] = props.alternateComponent;
     $[2] = Tag;
     $[3] = T0;
-    $[4] = t1;
+    $[4] = t0;
   } else {
     Tag = $[2];
     T0 = $[3];
-    t1 = $[4];
+    t0 = $[4];
+  }
+  let t1;
+  if ($[5] !== Tag) {
+    t1 = <Tag />;
+    $[5] = Tag;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
   }
   let t2;
-  if ($[5] !== Tag) {
-    t2 = <Tag />;
-    $[5] = Tag;
-    $[6] = t2;
-  } else {
-    t2 = $[6];
-  }
-  let t3;
-  if ($[7] !== T0 || $[8] !== t1 || $[9] !== t2) {
-    t3 = (
+  if ($[7] !== T0 || $[8] !== t0 || $[9] !== t1) {
+    t2 = (
       <T0>
+        {t0}
         {t1}
-        {t2}
       </T0>
     );
     $[7] = T0;
-    $[8] = t1;
-    $[9] = t2;
-    $[10] = t3;
+    $[8] = t0;
+    $[9] = t1;
+    $[10] = t2;
   } else {
-    t3 = $[10];
+    t2 = $[10];
   }
-  return t3;
+  return t2;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md
index ae16f4eec0..c69870b3af 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md
@@ -31,23 +31,23 @@ import { StaticText1, StaticText2 } from "shared-runtime";
 function Component(props) {
   const $ = useMemoCache(3);
 
-  const t1 = props.value;
-  let t0;
+  const t0 = props.value;
+  let t1;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = <StaticText2 />;
-    $[0] = t0;
+    t1 = <StaticText2 />;
+    $[0] = t1;
   } else {
-    t0 = $[0];
+    t1 = $[0];
   }
   let t2;
-  if ($[1] !== t1) {
+  if ($[1] !== t0) {
     t2 = (
       <StaticText1>
-        {t1}
         {t0}
+        {t1}
       </StaticText1>
     );
-    $[1] = t1;
+    $[1] = t0;
     $[2] = t2;
   } else {
     t2 = $[2];
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-with-param-as-captured-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-with-param-as-captured-dep.expect.md
index 531c10b931..bfa76bf899 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-with-param-as-captured-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-with-param-as-captured-dep.expect.md
@@ -25,19 +25,19 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Foo() {
   const $ = useMemoCache(1);
-  let t18;
   let t0;
+  let t1;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = function a(t28) {
+    t1 = function a(t28) {
       const x_0 = t28 === undefined ? () => {} : t28;
       return x_0;
     };
-    $[0] = t0;
+    $[0] = t1;
   } else {
-    t0 = $[0];
+    t1 = $[0];
   }
-  t18 = t0;
-  return t18;
+  t0 = t1;
+  return t0;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md
index 17b3897c8d..d00658ecaf 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md
@@ -34,22 +34,22 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  let t1;
+  let t0;
   if ($[0] !== props.items) {
-    let t0;
+    let t1;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-      t0 = (item) => item != null;
-      $[2] = t0;
+      t1 = (item) => item != null;
+      $[2] = t1;
     } else {
-      t0 = $[2];
+      t1 = $[2];
     }
-    t1 = props.items.filter(t0);
+    t0 = props.items.filter(t1);
     $[0] = props.items;
-    $[1] = t1;
+    $[1] = t0;
   } else {
-    t1 = $[1];
+    t0 = $[1];
   }
-  const filtered = t1;
+  const filtered = t0;
   return filtered;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md
index 9b3444a00a..94a7a9d196 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md
@@ -33,15 +33,15 @@ function foo(a, b, c, d) {
     }
     x = t0;
   } else {
-    let t1;
+    let t0;
     if ($[2] !== c) {
-      t1 = { c };
+      t0 = { c };
       $[2] = c;
-      $[3] = t1;
+      $[3] = t0;
     } else {
-      t1 = $[3];
+      t0 = $[3];
     }
-    x = t1;
+    x = t0;
   }
   return x;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md
index 552522e514..e595d3583b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md
@@ -38,31 +38,31 @@ function useHook(t16) {
   } else {
     t0 = $[1];
   }
-  let t2;
+  let t1;
   if ($[2] !== b || $[3] !== c || $[4] !== t0) {
-    let t1;
+    let t2;
     if ($[6] !== c) {
-      t1 = { c };
+      t2 = { c };
       $[6] = c;
-      $[7] = t1;
+      $[7] = t2;
     } else {
-      t1 = $[7];
+      t2 = $[7];
     }
-    t2 = {
+    t1 = {
       x: t0,
       y() {
         return [b];
       },
-      z: t1,
+      z: t2,
     };
     $[2] = b;
     $[3] = c;
     $[4] = t0;
-    $[5] = t2;
+    $[5] = t1;
   } else {
-    t2 = $[5];
+    t1 = $[5];
   }
-  return t2;
+  return t1;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/partial-early-return-within-reactive-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/partial-early-return-within-reactive-scope.expect.md
index c4f26fe8f7..b9b7a31440 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/partial-early-return-within-reactive-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/partial-early-return-within-reactive-scope.expect.md
@@ -32,39 +32,39 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
   let y;
-  let t46;
+  let t0;
   if ($[0] !== props) {
-    t46 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb11: {
       const x = [];
       if (props.cond) {
         x.push(props.a);
-        t46 = x;
+        t0 = x;
         break bb11;
       } else {
-        let t0;
+        let t1;
         if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
-          t0 = foo();
-          $[3] = t0;
+          t1 = foo();
+          $[3] = t1;
         } else {
-          t0 = $[3];
+          t1 = $[3];
         }
-        y = t0;
+        y = t1;
         if (props.b) {
-          t46 = undefined;
+          t0 = undefined;
           break bb11;
         }
       }
     }
     $[0] = props;
     $[1] = y;
-    $[2] = t46;
+    $[2] = t0;
   } else {
     y = $[1];
-    t46 = $[2];
+    t0 = $[2];
   }
-  if (t46 !== Symbol.for("react.early_return_sentinel")) {
-    return t46;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
   return y;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md
index 9f834b9cf5..6ab32ad29d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md
@@ -51,16 +51,16 @@ function PrimitiveAsDepNested(props) {
     x = $[2];
     y = $[3];
   }
-  let t2;
+  let t0;
   if ($[6] !== x || $[7] !== y) {
-    t2 = [x, y];
+    t0 = [x, y];
     $[6] = x;
     $[7] = y;
-    $[8] = t2;
+    $[8] = t0;
   } else {
-    t2 = $[8];
+    t0 = $[8];
   }
-  return t2;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md
index 510cbcd93a..4180315a7a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md
@@ -46,15 +46,15 @@ function Component(props) {
   }
   const count = posts.length;
   foo(count);
-  let t1;
+  let t0;
   if ($[3] !== posts) {
-    t1 = <>{posts}</>;
+    t0 = <>{posts}</>;
     $[3] = posts;
-    $[4] = t1;
+    $[4] = t0;
   } else {
-    t1 = $[4];
+    t0 = $[4];
   }
-  return t1;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md
index ea814d9cf9..fe59fd025e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md
@@ -51,16 +51,16 @@ function Component(props) {
     x = $[3];
     y = $[4];
   }
-  let t1;
+  let t0;
   if ($[6] !== x || $[7] !== y) {
-    t1 = <Component x={x} y={y} />;
+    t0 = <Component x={x} y={y} />;
     $[6] = x;
     $[7] = y;
-    $[8] = t1;
+    $[8] = t0;
   } else {
-    t1 = $[8];
+    t0 = $[8];
   }
-  return t1;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md
index 72e6704a6b..a552e9d8fa 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md
@@ -47,16 +47,16 @@ function Component(props) {
     x = $[2];
     y = $[3];
   }
-  let t1;
+  let t0;
   if ($[5] !== x || $[6] !== y) {
-    t1 = <Component x={x} y={y} />;
+    t0 = <Component x={x} y={y} />;
     $[5] = x;
     $[6] = y;
-    $[7] = t1;
+    $[7] = t0;
   } else {
-    t1 = $[7];
+    t0 = $[7];
   }
-  return t1;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/regexp-literal.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/regexp-literal.expect.md
index 8d84236c61..f8fe2bbda4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/regexp-literal.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/regexp-literal.expect.md
@@ -44,14 +44,14 @@ function Component(props) {
     }
     return t1;
   }
-  let t2;
+  let t1;
   if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
-    t2 = <div>Default</div>;
-    $[3] = t2;
+    t1 = <div>Default</div>;
+    $[3] = t1;
   } else {
-    t2 = $[3];
+    t1 = $[3];
   }
-  return t2;
+  return t1;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/remove-memoization-kitchen-sink.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/remove-memoization-kitchen-sink.expect.md
index ec757524f9..2d85dfc595 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/remove-memoization-kitchen-sink.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/remove-memoization-kitchen-sink.expect.md
@@ -28,11 +28,11 @@ function Component(props) {
   };
 
   const object = { x, onChange };
-  let t43;
+  let t0;
 
   const { x: x_0, onChange: onChange_0 } = object;
-  t43 = <input value={x_0} onChange={onChange_0} />;
-  return t43;
+  t0 = <input value={x_0} onChange={onChange_0} />;
+  return t0;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-dont-memoize-array-with-mutable-map-after-hook.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-dont-memoize-array-with-mutable-map-after-hook.expect.md
index c869711dae..6119ee447d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-dont-memoize-array-with-mutable-map-after-hook.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-dont-memoize-array-with-mutable-map-after-hook.expect.md
@@ -62,27 +62,27 @@ function Component(props) {
 
   let y;
 
-  const t3 = x.map((item) => {
+  const t2 = x.map((item) => {
     item.flag = true;
     return <span key={item.id}>{item.text}</span>;
   });
-  let t2;
+  let t3;
   if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-    t2 = mutate(y);
-    $[2] = t2;
+    t3 = mutate(y);
+    $[2] = t3;
   } else {
-    t2 = $[2];
+    t3 = $[2];
   }
   let t4;
-  if ($[3] !== onClick || $[4] !== t3) {
+  if ($[3] !== onClick || $[4] !== t2) {
     t4 = (
       <div onClick={onClick}>
-        {t3}
         {t2}
+        {t3}
       </div>
     );
     $[3] = onClick;
-    $[4] = t3;
+    $[4] = t2;
     $[5] = t4;
   } else {
     t4 = $[5];
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-hoisting-variable-collision.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-hoisting-variable-collision.expect.md
index b3f4a3f0c3..8ba29e178b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-hoisting-variable-collision.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-hoisting-variable-collision.expect.md
@@ -21,31 +21,31 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(5);
-  let t1;
+  let t0;
   if ($[0] !== props.items) {
-    let t0;
+    let t1;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-      t0 = (x) => x;
-      $[2] = t0;
+      t1 = (x) => x;
+      $[2] = t1;
     } else {
-      t0 = $[2];
+      t1 = $[2];
     }
-    t1 = props.items.map(t0);
+    t0 = props.items.map(t1);
     $[0] = props.items;
-    $[1] = t1;
+    $[1] = t0;
   } else {
-    t1 = $[1];
+    t0 = $[1];
   }
-  const items = t1;
-  let t2;
+  const items = t0;
+  let t1;
   if ($[3] !== items) {
-    t2 = [42, items];
+    t1 = [42, items];
     $[3] = items;
-    $[4] = t2;
+    $[4] = t1;
   } else {
-    t2 = $[4];
+    t1 = $[4];
   }
-  return t2;
+  return t1;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md
index 7a271c5f3d..b32a35cb95 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md
@@ -60,16 +60,16 @@ function Component(a, b) {
     x = $[4];
     y = $[5];
   }
-  let t3;
+  let t2;
   if ($[8] !== x || $[9] !== y) {
-    t3 = [x, y];
+    t2 = [x, y];
     $[8] = x;
     $[9] = y;
-    $[10] = t3;
+    $[10] = t2;
   } else {
-    t3 = $[10];
+    t2 = $[10];
   }
-  return t3;
+  return t2;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-renaming-conflicting-decls.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-renaming-conflicting-decls.expect.md
index 202733de2c..43b3a00969 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-renaming-conflicting-decls.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-renaming-conflicting-decls.expect.md
@@ -46,123 +46,123 @@ import { useMemo, unstable_useMemoCache as useMemoCache } from "react";
 
 function Component(props) {
   const $ = useMemoCache(29);
-  let t10;
   let t0;
-  let t92;
+  let t1;
+  let t2;
   if ($[0] !== props) {
-    t92 = Symbol.for("react.early_return_sentinel");
+    t2 = Symbol.for("react.early_return_sentinel");
     bb10: {
-      t10 = toJSON(props);
-      const propsString = t10;
+      t0 = toJSON(props);
+      const propsString = t0;
       if (propsString.length <= 2) {
-        t92 = null;
+        t2 = null;
         break bb10;
       }
 
-      t0 = identity(propsString);
+      t1 = identity(propsString);
     }
     $[0] = props;
-    $[1] = t0;
-    $[2] = t92;
-    $[3] = t10;
+    $[1] = t1;
+    $[2] = t2;
+    $[3] = t0;
   } else {
-    t0 = $[1];
-    t92 = $[2];
-    t10 = $[3];
+    t1 = $[1];
+    t2 = $[2];
+    t0 = $[3];
   }
-  if (t92 !== Symbol.for("react.early_return_sentinel")) {
-    return t92;
+  if (t2 !== Symbol.for("react.early_return_sentinel")) {
+    return t2;
   }
-  let t1;
-  if ($[4] !== t0) {
-    t1 = { url: t0 };
-    $[4] = t0;
-    $[5] = t1;
-  } else {
-    t1 = $[5];
-  }
-  const linkProps = t1;
-  let T7;
-  let t8;
-  let t2;
   let t3;
+  if ($[4] !== t1) {
+    t3 = { url: t1 };
+    $[4] = t1;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const linkProps = t3;
+  let T0;
   let t4;
   let t5;
   let t6;
+  let t7;
+  let t8;
   let t9;
+  let t10;
   if ($[6] !== linkProps) {
     const x = {};
 
-    T7 = Stringify;
-    t8 = linkProps;
+    T0 = Stringify;
+    t4 = linkProps;
     if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
-      t2 = [1];
-      t3 = [2];
-      t4 = [3];
-      t5 = [4];
-      t6 = [5];
-      $[15] = t2;
-      $[16] = t3;
-      $[17] = t4;
-      $[18] = t5;
-      $[19] = t6;
+      t5 = [1];
+      t6 = [2];
+      t7 = [3];
+      t8 = [4];
+      t9 = [5];
+      $[15] = t5;
+      $[16] = t6;
+      $[17] = t7;
+      $[18] = t8;
+      $[19] = t9;
     } else {
-      t2 = $[15];
-      t3 = $[16];
-      t4 = $[17];
-      t5 = $[18];
-      t6 = $[19];
+      t5 = $[15];
+      t6 = $[16];
+      t7 = $[17];
+      t8 = $[18];
+      t9 = $[19];
     }
 
-    t9 = makeArray(x, 2);
+    t10 = makeArray(x, 2);
     $[6] = linkProps;
-    $[7] = T7;
-    $[8] = t8;
-    $[9] = t2;
-    $[10] = t3;
-    $[11] = t4;
-    $[12] = t5;
-    $[13] = t6;
-    $[14] = t9;
+    $[7] = T0;
+    $[8] = t4;
+    $[9] = t5;
+    $[10] = t6;
+    $[11] = t7;
+    $[12] = t8;
+    $[13] = t9;
+    $[14] = t10;
   } else {
-    T7 = $[7];
-    t8 = $[8];
-    t2 = $[9];
-    t3 = $[10];
-    t4 = $[11];
-    t5 = $[12];
-    t6 = $[13];
-    t9 = $[14];
+    T0 = $[7];
+    t4 = $[8];
+    t5 = $[9];
+    t6 = $[10];
+    t7 = $[11];
+    t8 = $[12];
+    t9 = $[13];
+    t10 = $[14];
   }
-  let t10$0;
+  let t11;
   if (
-    $[20] !== T7 ||
-    $[21] !== t8 ||
-    $[22] !== t2 ||
-    $[23] !== t3 ||
-    $[24] !== t4 ||
-    $[25] !== t5 ||
-    $[26] !== t6 ||
-    $[27] !== t9
+    $[20] !== T0 ||
+    $[21] !== t4 ||
+    $[22] !== t5 ||
+    $[23] !== t6 ||
+    $[24] !== t7 ||
+    $[25] !== t8 ||
+    $[26] !== t9 ||
+    $[27] !== t10
   ) {
-    t10$0 = (
-      <T7 link={t8} val1={t2} val2={t3} val3={t4} val4={t5} val5={t6}>
-        {t9}
-      </T7>
+    t11 = (
+      <T0 link={t4} val1={t5} val2={t6} val3={t7} val4={t8} val5={t9}>
+        {t10}
+      </T0>
     );
-    $[20] = T7;
-    $[21] = t8;
-    $[22] = t2;
-    $[23] = t3;
-    $[24] = t4;
-    $[25] = t5;
-    $[26] = t6;
-    $[27] = t9;
-    $[28] = t10$0;
+    $[20] = T0;
+    $[21] = t4;
+    $[22] = t5;
+    $[23] = t6;
+    $[24] = t7;
+    $[25] = t8;
+    $[26] = t9;
+    $[27] = t10;
+    $[28] = t11;
   } else {
-    t10$0 = $[28];
+    t11 = $[28];
   }
-  return t10$0;
+  return t11;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-undefined-expression-of-jsxexpressioncontainer.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-undefined-expression-of-jsxexpressioncontainer.expect.md
index 1db889796f..6cc2dbfca9 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-undefined-expression-of-jsxexpressioncontainer.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-undefined-expression-of-jsxexpressioncontainer.expect.md
@@ -52,18 +52,18 @@ function Component(props) {
   const { buttons } = props;
   let nonPrimaryButtons;
   if ($[0] !== buttons) {
-    const [primaryButton, ...t79] = buttons;
-    nonPrimaryButtons = t79;
+    const [primaryButton, ...t0] = buttons;
+    nonPrimaryButtons = t0;
     $[0] = buttons;
     $[1] = nonPrimaryButtons;
   } else {
     nonPrimaryButtons = $[1];
   }
-  let t1;
+  let t0;
   if ($[2] !== nonPrimaryButtons) {
-    let t0;
+    let t1;
     if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
-      t0 = (buttonProps, i) => (
+      t1 = (buttonProps, i) => (
         <Stringify
           {...buttonProps}
           key={`button-${i}`}
@@ -74,26 +74,26 @@ function Component(props) {
           }
         />
       );
-      $[4] = t0;
+      $[4] = t1;
     } else {
-      t0 = $[4];
+      t1 = $[4];
     }
-    t1 = nonPrimaryButtons.map(t0);
+    t0 = nonPrimaryButtons.map(t1);
     $[2] = nonPrimaryButtons;
-    $[3] = t1;
+    $[3] = t0;
   } else {
-    t1 = $[3];
+    t0 = $[3];
   }
-  const renderedNonPrimaryButtons = t1;
-  let t2;
+  const renderedNonPrimaryButtons = t0;
+  let t1;
   if ($[5] !== renderedNonPrimaryButtons) {
-    t2 = <StaticText1>{renderedNonPrimaryButtons}</StaticText1>;
+    t1 = <StaticText1>{renderedNonPrimaryButtons}</StaticText1>;
     $[5] = renderedNonPrimaryButtons;
-    $[6] = t2;
+    $[6] = t1;
   } else {
-    t2 = $[6];
+    t1 = $[6];
   }
-  return t2;
+  return t1;
 }
 
 const styles = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-locals-named-like-hooks.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-locals-named-like-hooks.expect.md
index 0224cf3662..a4d3dc6ac2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-locals-named-like-hooks.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-locals-named-like-hooks.expect.md
@@ -51,20 +51,20 @@ function Component(props) {
 
   const y = useFeature;
   const z = useFeature.useProperty;
-  let t1;
+  let t0;
   if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = (
+    t0 = (
       <Stringify val={useFeature}>
         {x}
         {y}
         {z}
       </Stringify>
     );
-    $[1] = t1;
+    $[1] = t0;
   } else {
-    t1 = $[1];
+    t0 = $[1];
   }
-  return t1;
+  return t0;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-props-named-like-hooks.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-props-named-like-hooks.expect.md
index 58f24fe35f..e98597bc80 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-props-named-like-hooks.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/allow-props-named-like-hooks.expect.md
@@ -53,9 +53,9 @@ function Component(t29) {
 
   const y = useFeature;
   const z = useFeature.useProperty;
-  let t2;
+  let t0;
   if ($[3] !== useFeature || $[4] !== x || $[5] !== y || $[6] !== z) {
-    t2 = (
+    t0 = (
       <Stringify val={useFeature}>
         {x}
         {y}
@@ -66,11 +66,11 @@ function Component(t29) {
     $[4] = x;
     $[5] = y;
     $[6] = z;
-    $[7] = t2;
+    $[7] = t0;
   } else {
-    t2 = $[7];
+    t0 = $[7];
   }
-  return t2;
+  return t0;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-assignment-to-scope-declarations.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-assignment-to-scope-declarations.expect.md
index c27aea1fee..bdb91a0e26 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-assignment-to-scope-declarations.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-assignment-to-scope-declarations.expect.md
@@ -47,8 +47,8 @@ function Component(statusName) {
   let t0;
   let t1;
   if ($[0] !== statusName) {
-    const { status, text: t47 } = foo(statusName);
-    text = t47;
+    const { status, text: t2 } = foo(statusName);
+    text = t2;
     const { bg, color } = getStyles(status);
 
     t1 = identity(bg);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-both-mixed-local-and-scope-declaration.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-both-mixed-local-and-scope-declaration.expect.md
index a184412caa..9c30a623fc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-both-mixed-local-and-scope-declaration.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/sequential-destructuring-both-mixed-local-and-scope-declaration.expect.md
@@ -50,11 +50,11 @@ function Component(statusName) {
   let text;
   let font;
   if ($[0] !== statusName) {
-    const { status, text: t49 } = foo(statusName);
-    text = t49;
+    const { status, text: t1 } = foo(statusName);
+    text = t1;
 
-    const { color, font: t50 } = getStyles(status);
-    font = t50;
+    const { color, font: t2 } = getStyles(status);
+    font = t2;
 
     t0 = identity(color);
     $[0] = statusName;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md
index f9db864301..641bd5aea9 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md
@@ -29,16 +29,16 @@ export default function foo(x, y) {
     return t0;
   }
 
-  const t1 = y * 10;
-  let t2;
-  if ($[2] !== t1) {
-    t2 = [t1];
-    $[2] = t1;
-    $[3] = t2;
+  const t0 = y * 10;
+  let t1;
+  if ($[2] !== t0) {
+    t1 = [t0];
+    $[2] = t0;
+    $[3] = t1;
   } else {
-    t2 = $[3];
+    t1 = $[3];
   }
-  return t2;
+  return t1;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md
index 204e141965..29b4bd1beb 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md
@@ -42,14 +42,14 @@ function foo(a) {
       const y = t0;
       x.y = y;
     } else {
-      let t1;
+      let t0;
       if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
-        t1 = {};
-        $[3] = t1;
+        t0 = {};
+        $[3] = t0;
       } else {
-        t1 = $[3];
+        t0 = $[3];
       }
-      const z = t1;
+      const z = t0;
       x.z = z;
     }
     $[0] = a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md
index 6b7125dd10..21a091a6ff 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md
@@ -67,26 +67,26 @@ function Component(props) {
     x = $[1];
     y = $[2];
   }
-  let t1;
+  let t0;
   if ($[4] !== x) {
-    t1 = <Component data={x} />;
+    t0 = <Component data={x} />;
     $[4] = x;
-    $[5] = t1;
+    $[5] = t0;
   } else {
-    t1 = $[5];
+    t0 = $[5];
   }
-  const child = t1;
+  const child = t0;
   y.push(props.p4);
-  let t2;
+  let t1;
   if ($[6] !== y || $[7] !== child) {
-    t2 = <Component data={y}>{child}</Component>;
+    t1 = <Component data={y}>{child}</Component>;
     $[6] = y;
     $[7] = child;
-    $[8] = t2;
+    $[8] = t1;
   } else {
-    t2 = $[8];
+    t1 = $[8];
   }
-  return t2;
+  return t1;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo.unnecessary-lambda-memoization.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo.unnecessary-lambda-memoization.expect.md
index ab141a1d6d..22fd973889 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo.unnecessary-lambda-memoization.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo.unnecessary-lambda-memoization.expect.md
@@ -26,31 +26,31 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(5);
   const data = useFreeze();
-  let t1;
+  let t0;
   if ($[0] !== data.items) {
-    let t0;
+    let t1;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-      t0 = (item) => <Item item={item} />;
-      $[2] = t0;
+      t1 = (item) => <Item item={item} />;
+      $[2] = t1;
     } else {
-      t0 = $[2];
+      t1 = $[2];
     }
-    t1 = data.items.map(t0);
+    t0 = data.items.map(t1);
     $[0] = data.items;
-    $[1] = t1;
+    $[1] = t0;
   } else {
-    t1 = $[1];
+    t0 = $[1];
   }
-  const items = t1;
-  let t2;
+  const items = t0;
+  let t1;
   if ($[3] !== items) {
-    t2 = <div>{items}</div>;
+    t1 = <div>{items}</div>;
     $[3] = items;
-    $[4] = t2;
+    $[4] = t1;
   } else {
-    t2 = $[4];
+    t1 = $[4];
   }
-  return t2;
+  return t1;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/transitive-freeze-function-expressions.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/transitive-freeze-function-expressions.expect.md
index 009fe6d34d..a822fc31ab 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/transitive-freeze-function-expressions.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/transitive-freeze-function-expressions.expect.md
@@ -72,22 +72,22 @@ function Component(props) {
     t2 = $[6];
   }
   useEffect(t1, t2);
-  let t4;
+  let t3;
   if ($[7] !== data) {
-    let t3;
+    let t4;
     if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
-      t3 = (x) => x;
-      $[9] = t3;
+      t4 = (x) => x;
+      $[9] = t4;
     } else {
-      t3 = $[9];
+      t4 = $[9];
     }
-    t4 = data.map(t3);
+    t3 = data.map(t4);
     $[7] = data;
-    $[8] = t4;
+    $[8] = t3;
   } else {
-    t4 = $[8];
+    t3 = $[8];
   }
-  const items = t4;
+  const items = t3;
   return items;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch.expect.md
index 022605becd..b10bce221b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch.expect.md
@@ -31,9 +31,9 @@ const { throwInput } = require("shared-runtime");
 
 function Component(props) {
   const $ = useMemoCache(3);
-  let t49;
+  let t0;
   if ($[0] !== props.y || $[1] !== props.e) {
-    t49 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb18: {
       try {
         const y = [];
@@ -42,21 +42,21 @@ function Component(props) {
       } catch (t25) {
         const e = t25;
         e.push(props.e);
-        t49 = e;
+        t0 = e;
         break bb18;
       }
 
-      t49 = null;
+      t0 = null;
       break bb18;
     }
     $[0] = props.y;
     $[1] = props.e;
-    $[2] = t49;
+    $[2] = t0;
   } else {
-    t49 = $[2];
+    t0 = $[2];
   }
-  if (t49 !== Symbol.for("react.early_return_sentinel")) {
-    return t49;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-catch-param.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-catch-param.expect.md
index a067460741..c4ff0295df 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-catch-param.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-catch-param.expect.md
@@ -32,9 +32,9 @@ const { throwInput } = require("shared-runtime");
 
 function Component(props) {
   const $ = useMemoCache(1);
-  let t36;
+  let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t36 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb11: {
       const x = [];
       try {
@@ -42,19 +42,19 @@ function Component(props) {
       } catch (t22) {
         const e = t22;
         e.push(null);
-        t36 = e;
+        t0 = e;
         break bb11;
       }
 
-      t36 = x;
+      t0 = x;
       break bb11;
     }
-    $[0] = t36;
+    $[0] = t0;
   } else {
-    t36 = $[0];
+    t0 = $[0];
   }
-  if (t36 !== Symbol.for("react.early_return_sentinel")) {
-    return t36;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-return.expect.md
index e27d9fe584..ec26e252b7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-with-return.expect.md
@@ -34,32 +34,32 @@ const { shallowCopy, throwInput } = require("shared-runtime");
 function Component(props) {
   const $ = useMemoCache(2);
   let x;
-  let t43;
+  let t0;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t43 = Symbol.for("react.early_return_sentinel");
+    t0 = Symbol.for("react.early_return_sentinel");
     bb25: {
       x = [];
       try {
         const y = shallowCopy({});
         if (y == null) {
-          t43 = undefined;
+          t0 = undefined;
           break bb25;
         }
 
         x.push(throwInput(y));
       } catch {
-        t43 = null;
+        t0 = null;
         break bb25;
       }
     }
     $[0] = x;
-    $[1] = t43;
+    $[1] = t0;
   } else {
     x = $[0];
-    t43 = $[1];
+    t0 = $[1];
   }
-  if (t43 !== Symbol.for("react.early_return_sentinel")) {
-    return t43;
+  if (t0 !== Symbol.for("react.early_return_sentinel")) {
+    return t0;
   }
   return x;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md
index 5ebb8b62dd..b52dfe6dd4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md
@@ -43,14 +43,14 @@ function Component(props) {
       }
       x.push(t0);
     } catch {
-      let t1;
+      let t0;
       if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
-        t1 = shallowCopy({});
-        $[3] = t1;
+        t0 = shallowCopy({});
+        $[3] = t0;
       } else {
-        t1 = $[3];
+        t0 = $[3];
       }
-      x.push(t1);
+      x.push(t0);
     }
 
     x.push(props.value);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-annotations/todo_type-annotations-props.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-annotations/todo_type-annotations-props.expect.md
index 8bd9db8a26..e3f3a806c5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-annotations/todo_type-annotations-props.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-annotations/todo_type-annotations-props.expect.md
@@ -23,22 +23,22 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react"; // @enableUseTypeAnnotations
 function useArray(items) {
   const $ = useMemoCache(3);
-  let t1;
+  let t0;
   if ($[0] !== items) {
-    let t0;
+    let t1;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-      t0 = (x) => x !== 0;
-      $[2] = t0;
+      t1 = (x) => x !== 0;
+      $[2] = t1;
     } else {
-      t0 = $[2];
+      t1 = $[2];
     }
-    t1 = items.filter(t0);
+    t0 = items.filter(t1);
     $[0] = items;
-    $[1] = t1;
+    $[1] = t0;
   } else {
-    t1 = $[1];
+    t0 = $[1];
   }
-  return t1;
+  return t0;
 }
 
 export const FIXTURE_ENTRYPOINT = {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md
index 4ed82d43ae..48fa42eb6f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md
@@ -24,8 +24,8 @@ function Foo(props) {
   const $ = useMemoCache(2);
   let rest;
   if ($[0] !== props.a) {
-    const { unused, ...t15 } = props.a;
-    rest = t15;
+    const { unused, ...t0 } = props.a;
+    rest = t0;
     $[0] = props.a;
     $[1] = rest;
   } else {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md
index 138c2e643d..325cf9479b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md
@@ -20,18 +20,18 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
-  let t20;
+  let t0;
   bb7: {
     if (props.cond) {
-      let t0;
+      let t1;
       if ($[0] !== props.a) {
-        t0 = makeObject(props.a);
+        t1 = makeObject(props.a);
         $[0] = props.a;
-        $[1] = t0;
+        $[1] = t1;
       } else {
-        t0 = $[1];
+        t1 = $[1];
       }
-      t20 = t0;
+      t0 = t1;
       break bb7;
     }
     let t1;
@@ -42,9 +42,9 @@ function Component(props) {
     } else {
       t1 = $[3];
     }
-    t20 = t1;
+    t0 = t1;
   }
-  const x = t20;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md
index 8c0f09ea51..96986e2cf0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md
@@ -20,46 +20,46 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(10);
-  let t26;
   let t0;
-  if ($[0] !== props.a) {
-    t0 = makeObject(props.a);
-    $[0] = props.a;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  const a = t0;
   let t1;
-  if ($[2] !== props.b) {
-    t1 = makeObject(props.b);
-    $[2] = props.b;
-    $[3] = t1;
+  if ($[0] !== props.a) {
+    t1 = makeObject(props.a);
+    $[0] = props.a;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  const b = t1;
+  const a = t1;
   let t2;
+  if ($[2] !== props.b) {
+    t2 = makeObject(props.b);
+    $[2] = props.b;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const b = t2;
+  let t3;
   if ($[4] !== a || $[5] !== b) {
-    t2 = [a, b];
+    t3 = [a, b];
     $[4] = a;
     $[5] = b;
-    $[6] = t2;
+    $[6] = t3;
   } else {
-    t2 = $[6];
+    t3 = $[6];
   }
-  t26 = t2;
-  const [a_0, b_0] = t26;
-  let t3;
+  t0 = t3;
+  const [a_0, b_0] = t0;
+  let t4;
   if ($[7] !== a_0 || $[8] !== b_0) {
-    t3 = [a_0, b_0];
+    t4 = [a_0, b_0];
     $[7] = a_0;
     $[8] = b_0;
-    $[9] = t3;
+    $[9] = t4;
   } else {
-    t3 = $[9];
+    t4 = $[9];
   }
-  return t3;
+  return t4;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md
index 61031e1ab0..2d32ce9c9d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md
@@ -25,23 +25,23 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(2);
-  let t13;
+  let t0;
   bb6: {
     if (a) {
-      let t0;
+      let t1;
       if ($[0] !== b) {
-        t0 = { b };
+        t1 = { b };
         $[0] = b;
-        $[1] = t0;
+        $[1] = t1;
       } else {
-        t0 = $[1];
+        t1 = $[1];
       }
-      t13 = t0;
+      t0 = t1;
       break bb6;
     }
-    t13 = undefined;
+    t0 = undefined;
   }
-  const x = t13;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inverted-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inverted-if.expect.md
index 38a3a09b08..672bb6cc45 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inverted-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inverted-if.expect.md
@@ -27,20 +27,20 @@ export const FIXTURE_ENTRYPOINT = {
 
 ```javascript
 function Component(props) {
-  let t16;
+  let t0;
   bb10: {
     bb2: {
       if (props.cond) {
         break bb2;
       }
 
-      t16 = props.a;
+      t0 = props.a;
       break bb10;
     }
 
-    t16 = props.b;
+    t0 = props.b;
   }
-  const x = t16;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-labeled-statement-unconditional-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-labeled-statement-unconditional-return.expect.md
index 3f589279e2..dfbefecffe 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-labeled-statement-unconditional-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-labeled-statement-unconditional-return.expect.md
@@ -23,10 +23,10 @@ export const FIXTURE_ENTRYPOINT = {
 
 ```javascript
 function Component(props) {
-  let t8;
+  let t0;
 
-  t8 = props.value;
-  const x = t8;
+  t0 = props.value;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-logical.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-logical.expect.md
index 34fe5a8de3..bf10ff649c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-logical.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-logical.expect.md
@@ -19,9 +19,9 @@ export const FIXTURE_ENTRYPOINT = {
 
 ```javascript
 function Component(props) {
-  let t16;
-  t16 = props.a && props.b;
-  const x = t16;
+  let t0;
+  t0 = props.a && props.b;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-dont-preserve-memoization-guarantees.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-dont-preserve-memoization-guarantees.expect.md
index c113410428..b4cbfe60d6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-dont-preserve-memoization-guarantees.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-dont-preserve-memoization-guarantees.expect.md
@@ -56,13 +56,13 @@ function Component(props) {
   const part = free2.part;
 
   useHook();
-  let t39;
+  let t0;
 
   const x = makeObject_Primitives();
   x.value = props.value;
   mutate(x, free, part);
-  t39 = x;
-  const object = t39;
+  t0 = x;
+  const object = t0;
 
   identity(free);
   identity(part);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-preserve-memoization-guarantees.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-preserve-memoization-guarantees.expect.md
index 1d351ee2be..b49247e9c7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-preserve-memoization-guarantees.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-mabye-modified-free-variable-preserve-memoization-guarantees.expect.md
@@ -76,7 +76,7 @@ function Component(props) {
   const part = free2.part;
 
   useHook();
-  let t39;
+  let t2;
   let x;
   if ($[2] !== props.value) {
     x = makeObject_Primitives();
@@ -87,8 +87,8 @@ function Component(props) {
   } else {
     x = $[3];
   }
-  t39 = x;
-  const object = t39;
+  t2 = x;
+  const object = t2;
 
   identity(free);
   identity(part);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-dont-preserve-memoization-guarantees.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-dont-preserve-memoization-guarantees.expect.md
index 7da8ef440c..53ca5660ab 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-dont-preserve-memoization-guarantees.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-dont-preserve-memoization-guarantees.expect.md
@@ -28,17 +28,17 @@ import { identity, makeObject_Primitives, mutate } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  let t7;
+  let t0;
   let object;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t7 = makeObject_Primitives();
-    object = t7;
+    t0 = makeObject_Primitives();
+    object = t0;
     identity(object);
     $[0] = object;
-    $[1] = t7;
+    $[1] = t0;
   } else {
     object = $[0];
-    t7 = $[1];
+    t0 = $[1];
   }
   return object;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-preserve-memoization-guarantees.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-preserve-memoization-guarantees.expect.md
index e2ab6a86bf..5198ec12ae 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-preserve-memoization-guarantees.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-maybe-modified-later-preserve-memoization-guarantees.expect.md
@@ -28,16 +28,16 @@ import { identity, makeObject_Primitives, mutate } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(1);
-  let t7;
   let t0;
+  let t1;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = makeObject_Primitives();
-    $[0] = t0;
+    t1 = makeObject_Primitives();
+    $[0] = t1;
   } else {
-    t0 = $[0];
+    t1 = $[0];
   }
-  t7 = t0;
-  const object = t7;
+  t0 = t1;
+  const object = t0;
   identity(object);
   return object;
 }
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md
index 3ce6550027..f96b4a7bb6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md
@@ -33,7 +33,7 @@ import { useMemo, unstable_useMemoCache as useMemoCache } from "react";
 
 function Component(props) {
   const $ = useMemoCache(3);
-  let t31;
+  let t0;
   bb9: {
     let y;
     if ($[0] !== props) {
@@ -42,21 +42,21 @@ function Component(props) {
         y.push(props.a);
       }
       if (props.cond2) {
-        t31 = y;
+        t0 = y;
         break bb9;
       }
 
       y.push(props.b);
       $[0] = props;
       $[1] = y;
-      $[2] = t31;
+      $[2] = t0;
     } else {
       y = $[1];
-      t31 = $[2];
+      t0 = $[2];
     }
-    t31 = y;
+    t0 = y;
   }
-  const x = t31;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md
index eac323a512..6d703d2540 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md
@@ -15,26 +15,26 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  let t9;
   let t0;
-  if ($[0] !== a) {
-    t0 = [a];
-    $[0] = a;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  t9 = t0;
-  const x = t9;
   let t1;
-  if ($[2] !== x) {
-    t1 = <Foo x={x} />;
-    $[2] = x;
-    $[3] = t1;
+  if ($[0] !== a) {
+    t1 = [a];
+    $[0] = a;
+    $[1] = t1;
   } else {
-    t1 = $[3];
+    t1 = $[1];
   }
-  return t1;
+  t0 = t1;
+  const x = t0;
+  let t2;
+  if ($[2] !== x) {
+    t2 = <Foo x={x} />;
+    $[2] = x;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
 }
 
 ```
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-no-fallthrough.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-no-fallthrough.expect.md
index dc20920ed3..be9ff2ef50 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-no-fallthrough.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-no-fallthrough.expect.md
@@ -28,17 +28,17 @@ export const FIXTURE_ENTRYPOINT = {
 
 ```javascript
 function Component(props) {
-  let t17;
+  let t0;
   bb8: switch (props.key) {
     case "key": {
-      t17 = props.value;
+      t0 = props.value;
       break bb8;
     }
     default: {
-      t17 = props.defaultValue;
+      t0 = props.defaultValue;
     }
   }
-  const x = t17;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-return.expect.md
index 75c233f743..782db27c4f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-switch-return.expect.md
@@ -34,12 +34,12 @@ export const FIXTURE_ENTRYPOINT = {
 
 ```javascript
 function Component(props) {
-  let t21;
+  let t0;
   bb10: {
     let y;
     bb2: switch (props.switch) {
       case "foo": {
-        t21 = "foo";
+        t0 = "foo";
         break bb10;
       }
       case "bar": {
@@ -51,9 +51,9 @@ function Component(props) {
       }
     }
 
-    t21 = y;
+    t0 = y;
   }
-  const x = t21;
+  const x = t0;
   return x;
 }
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/validate-no-set-state-in-render-uncalled-function-with-mutable-range-is-valid.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/validate-no-set-state-in-render-uncalled-function-with-mutable-range-is-valid.expect.md
index 6fce8dfa1c..cba57a4509 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/validate-no-set-state-in-render-uncalled-function-with-mutable-range-is-valid.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/validate-no-set-state-in-render-uncalled-function-with-mutable-range-is-valid.expect.md
@@ -62,33 +62,33 @@ function Component(props) {
       return t1;
     }
     case 1: {
-      let t2;
+      let t1;
       if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
-        t2 = { foo: "joe" };
-        $[3] = t2;
+        t1 = { foo: "joe" };
+        $[3] = t1;
       } else {
-        t2 = $[3];
+        t1 = $[3];
       }
-      let t3;
+      let t2;
       if ($[4] !== onSubmit) {
-        t3 = <OtherComponent data={t2} onSubmit={onSubmit} />;
+        t2 = <OtherComponent data={t1} onSubmit={onSubmit} />;
         $[4] = onSubmit;
-        $[5] = t3;
+        $[5] = t2;
       } else {
-        t3 = $[5];
+        t2 = $[5];
       }
-      return t3;
+      return t2;
     }
     default: {
       logEvent("Invalid step");
-      let t4;
+      let t1;
       if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
-        t4 = <OtherComponent data={null} />;
-        $[6] = t4;
+        t1 = <OtherComponent data={null} />;
+        $[6] = t1;
       } else {
-        t4 = $[6];
+        t1 = $[6];
       }
-      return t4;
+      return t1;
     }
   }
 }