Prefer defining variables before they are referenced

This reduces the number of finalizers needed.

Author: remcohaszing

fixtures/object-reference-sort/input.js

@@ -0,0 +1,64 @@
+// Used as input
+// { preserveReferences: true }
+export default (() => {
+  const $0 = {
+      name: 'variable 0'
+    },
+    $2 = {
+      name: 'variable 2'
+    },
+    $1 = {
+      name: 'variable 1',
+      $0: $0,
+      $2: $2
+    }
+  return {
+    name: 'variable 2',
+    $0: $0,
+    $1: $1,
+    var1: $1,
+    variable1: $1,
+    $2: $2
+  }
+})()
+
+// -------------------------------------------------------------------------------------------------
+
+// Default output
+// { preserveReferences: false }
+const withoutPreserveReferences = {
+  name: 'variable 2',
+  $0: {
+    name: 'variable 0'
+  },
+  $1: {
+    name: 'variable 1',
+    $0: {
+      name: 'variable 0'
+    },
+    $2: {
+      name: 'variable 2'
+    }
+  },
+  var1: {
+    name: 'variable 1',
+    $0: {
+      name: 'variable 0'
+    },
+    $2: {
+      name: 'variable 2'
+    }
+  },
+  variable1: {
+    name: 'variable 1',
+    $0: {
+      name: 'variable 0'
+    },
+    $2: {
+      name: 'variable 2'
+    }
+  },
+  $2: {
+    name: 'variable 2'
+  }
+}

src/estree-util-value-to-estree.ts

@@ -191,6 +191,11 @@ interface Context {
    */
   recursive: boolean
 
+  /**
+   * A set of values that reference the value in this context.
+   */
+  referencedBy: Set<unknown>
+
   /**
    * The value this context belongs to.
    */
@@ -208,6 +213,19 @@ interface Context {
  *   The count of context a minus the count of context b.
  */
 function compareContexts(a: Context, b: Context): number {
+  const aReferencedByB = a.referencedBy.has(b.value)
+  const bReferencedByA = b.referencedBy.has(a.value)
+
+  if (aReferencedByB) {
+    if (bReferencedByA) {
+      return a.count - b.count
+    }
+    return -1
+  }
+  if (bReferencedByA) {
+    return 1
+  }
+
   return a.count - b.count
 }
 
@@ -269,6 +287,9 @@ export function valueToEstree(value: unknown, options: Options = {}): Expression
       if (options.preserveReferences) {
         context.count += 1
       }
+      for (const ancestor of stack) {
+        context.referencedBy.add(ancestor)
+      }
       if (stack.includes(val)) {
         if (!options.preserveReferences) {
           throw new Error(`Found circular reference: ${val}`, { cause: val })
@@ -281,7 +302,12 @@ export function valueToEstree(value: unknown, options: Options = {}): Expression
       return
     }
 
-    collectedContexts.set(val, { count: 1, recursive: false, value: val })
+    collectedContexts.set(val, {
+      count: 1,
+      recursive: false,
+      referencedBy: new Set(stack),
+      value: val
+    })
 
     if (isTypedArray(val)) {
       return