Refactor internals of algo

Author: wooorm

lib/index.js

@@ -1,6 +1,5 @@
 /**
- * @typedef {import('estree-jsx').Node} EstreeNode
- * @typedef {import('unist').Node} UnistNode
+ * @typedef {import('estree-jsx').Node} Nodes
  */
 
 /**
@@ -10,119 +9,112 @@
  *   Leave discouraged fields in the tree (default: `false`).
  */
 
-import {ok as assert} from 'devlop'
+/**
+ * @template T
+ * @template U
+ * @typedef {{[K in keyof T]: T[K] extends U ? K : never}[keyof T]} KeysOfType
+ */
+
+/**
+ * @template T
+ * @typedef {Exclude<KeysOfType<T, Exclude<T[keyof T], undefined>>, undefined>} RequiredKeys
+ */
+
+/**
+ * @template T
+ * @typedef {Exclude<keyof T, RequiredKeys<T>>} OptionalKeys
+ */
+
 import {visit} from 'estree-util-visit'
 import {positionFromEstree} from 'unist-util-position-from-estree'
 
-const own = {}.hasOwnProperty
+/** @type {Options} */
+const emptyOptions = {}
 
 /**
  * Turn an estree into an esast.
  *
- * @param {EstreeNode} estree
+ * @template {Nodes} Kind
+ * @param {Kind} estree
  *   estree.
  * @param {Options | null | undefined} [options]
  *   Configuration (optional).
- * @returns {UnistNode}
- *   esast.
+ * @returns {Kind}
+ *   Clean clone of `estree`.
  */
-export function fromEstree(estree, options = {}) {
-  /** @type {UnistNode | undefined} */
-  let tail
-
-  visit(estree, {
-    // eslint-disable-next-line complexity
-    leave(node, field, index, parents) {
-      const parent = parents[parents.length - 1]
-      /** @type {EstreeNode} */
-      const context =
-        field === undefined || index === undefined
-          ? parent
-          : // @ts-expect-error: indexable.
-            parent[field]
-      /** @type {number | string | undefined} */
-      const prop = index === undefined ? field : index
-      /** @type {UnistNode} */
-      const copy = {}
-      /** @type {string} */
-      let key
-
-      for (key in node) {
-        if (
-          own.call(node, key) &&
-          ((options && options.dirty) ||
-            (key !== 'start' &&
-              key !== 'end' &&
-              key !== 'loc' &&
-              key !== 'raw'))
-        ) {
-          if (
-            node.type === 'JSXOpeningFragment' &&
-            (key === 'attributes' || key === 'selfClosing')
-          ) {
-            continue
-          }
-
-          indexable(node)
-          let value = node[key]
-
-          // If this is a bigint or regex literal, reset value.
-          if (
-            (!options || !options.dirty) &&
-            node.type === 'Literal' &&
-            key === 'value' &&
-            ('bigint' in node || 'regex' in node)
-          ) {
-            value = null
-          }
-          // Normalize `.bigint` to use int notation.
-          else if (
-            node.type === 'Literal' &&
-            key === 'bigint' &&
-            typeof value === 'string'
-          ) {
-            const match = /0[box]/.exec(value.slice(0, 2).toLowerCase())
-
-            if (match) {
-              const code = match[0].charCodeAt(1)
-              value = Number.parseInt(
-                value.slice(2),
-                code === 98 /* `x` */ ? 2 : code === 111 /* `o` */ ? 8 : 16
-              ).toString()
-            }
-          }
-
-          indexable(copy)
-          copy[key] = value
+export function fromEstree(estree, options) {
+  const settings = options || emptyOptions
+  /** @type {Kind} */
+  // Drop the `Node` and such constructors on Acorn nodes.
+  const esast = JSON.parse(JSON.stringify(estree, ignoreBigint))
+
+  visit(esast, {
+    leave(node) {
+      const position = positionFromEstree(node)
+
+      if (!settings.dirty) {
+        // Acorn specific.
+        // @ts-expect-error: acorn adds this.
+        if ('end' in node) remove(node, 'end')
+        // @ts-expect-error: acorn adds this.
+        if ('start' in node) remove(node, 'start')
+        if (node.type === 'JSXOpeningFragment') {
+          // @ts-expect-error: acorn adds this, but it should not exist.
+          if ('attributes' in node) remove(node, 'attributes')
+          // @ts-expect-error: acorn adds this, but it should not exist.
+          if ('selfClosing' in node) remove(node, 'selfClosing')
+        }
+
+        // Estree.
+        if ('loc' in node) remove(node, 'loc')
+        // @ts-expect-error: `JSXText` types are wrong: `raw` is optional.
+        if ('raw' in node) remove(node, 'raw')
+
+        if (node.type === 'Literal') {
+          // These `value`s on bigint/regex literals represent a raw value,
+          // which is an antipattern.
+          if ('bigint' in node) remove(node, 'value')
+          if ('regex' in node) remove(node, 'value')
         }
       }
 
-      copy.position = positionFromEstree(node)
+      if (node.type === 'Literal' && 'bigint' in node) {
+        const bigint = node.bigint
+        const match = /0[box]/.exec(bigint.slice(0, 2).toLowerCase())
 
-      if (prop === undefined) {
-        tail = copy
-      } else {
-        indexable(context)
-        context[prop] = copy
+        if (match) {
+          const code = match[0].charCodeAt(1)
+          const base =
+            code === 98 /* `x` */ ? 2 : code === 111 /* `o` */ ? 8 : 16
+          node.bigint = Number.parseInt(bigint.slice(2), base).toString()
+        }
       }
+
+      // @ts-expect-error: `position` is not in `Node`, but we add it anyway
+      // because it’s useful.
+      node.position = position
     }
   })
 
-  assert(tail, 'expected a node')
-  return tail
+  return esast
+}
+
+/**
+ * @template {Nodes} Kind
+ * @param {Kind} value
+ * @param {OptionalKeys<Kind>} key
+ * @returns {undefined}
+ */
+function remove(value, key) {
+  delete value[key]
 }
 
 /**
- * TypeScript helper to check if something is indexable (any object is
- * indexable in JavaScript).
  *
+ * @param {string} _
  * @param {unknown} value
- *   Thing to check.
- * @returns {asserts value is Record<string, unknown>}
- *   Nothing.
- * @throws {Error}
- *   When `value` is not an object.
+ * @returns {unknown}
  */
-function indexable(value) {
-  assert(value && typeof value === 'object', 'expected object')
+function ignoreBigint(_, value) {
+  return typeof value === 'bigint' ? undefined : value
 }

readme.md

@@ -74,13 +74,15 @@ import {fromEstree} from 'esast-util-from-estree'
 
 // Make acorn support comments and positional info.
 const comments = []
-const esast = parse(
+const estree = parse(
   'export function x() { /* Something senseless */ console.log(/(?:)/ + 1n) }',
   {sourceType: 'module', locations: true, onComment: comments}
 )
-esast.comments = comments
+estree.comments = comments
 
-console.log(fromEstree(esast))
+const esast = fromEstree(estree)
+
+console.log(esast)
 ```
 
 Yields:
@@ -130,7 +132,7 @@ Turn an estree into an esast.
 
 ###### Returns
 
-esast ([`UnistNode`][esast]).
+Clean clone of `estree` ([`UnistNode`][esast]).
 
 ### `Options`
 

test.js

@@ -20,12 +20,14 @@ test('fromEstree', async function (t) {
   await t.test('should transform', async function () {
     /** @type {EstreeProgram} */
     // @ts-expect-error: acorn looks like estree.
-    const tree = parser.parse('console.log(1)', {
+    let tree = parser.parse('console.log(1)', {
       locations: true,
       ecmaVersion: 2021
     })
 
-    assert.deepEqual(fromEstree(tree), {
+    tree = fromEstree(tree)
+
+    assert.deepEqual(tree, {
       type: 'Program',
       body: [
         {
@@ -90,13 +92,15 @@ test('fromEstree', async function (t) {
   await t.test('should transform regexes', async function () {
     /** @type {EstreeProgram} */
     // @ts-expect-error: acorn looks like estree.
-    const tree = parser.parse('/(?:)/', {locations: true, ecmaVersion: 2021})
+    let tree = parser.parse('/(?:)/', {locations: true, ecmaVersion: 2021})
+
+    tree = fromEstree(tree)
+
     const statement = tree.body[0]
     assert(statement.type === 'ExpressionStatement')
 
-    assert.deepEqual(fromEstree(statement.expression), {
+    assert.deepEqual(statement.expression, {
       type: 'Literal',
-      value: null,
       regex: {pattern: '(?:)', flags: ''},
       position: {
         start: {line: 1, column: 1, offset: 0},
@@ -108,11 +112,14 @@ test('fromEstree', async function (t) {
   await t.test('should transform jsx fragments', async function () {
     /** @type {EstreeProgram} */
     // @ts-expect-error: acorn looks like estree.
-    const tree = parser.parse('<>b</>', {locations: true, ecmaVersion: 2021})
+    let tree = parser.parse('<>b</>', {locations: true, ecmaVersion: 2021})
+
+    tree = fromEstree(tree)
+
     const statement = tree.body[0]
     assert(statement.type === 'ExpressionStatement')
 
-    assert.deepEqual(fromEstree(statement.expression), {
+    assert.deepEqual(statement.expression, {
       type: 'JSXFragment',
       openingFragment: {
         type: 'JSXOpeningFragment',
@@ -160,11 +167,13 @@ test('fromEstree', async function (t) {
     while (++index < bigInts.length) {
       /** @type {EstreeProgram} */
       // @ts-expect-error: acorn looks like estree.
-      const tree = parser.parse(bigInts[index][0], {
+      let tree = parser.parse(bigInts[index][0], {
         locations: true,
         ecmaVersion: 2021
       })
-      fromEstree(tree)
+
+      tree = fromEstree(tree)
+
       const statement = tree.body[0]
       assert(statement.type === 'ExpressionStatement')
       const expression = statement.expression