Change to yield undefined

Author: wooorm

lib/index.js

@@ -51,14 +51,13 @@ const emptyComments = []
  *   Tree to attach to.
  * @param {Array<Comment> | null | undefined} [comments]
  *   List of comments (optional).
- * @returns {Tree}
- *   Given tree.
+ * @returns {undefined}
+ *   Nothing.
  */
 // To do: next major: don’t return given `tree`.
 export function attachComments(tree, comments) {
   const list = comments ? [...comments].sort(compare) : emptyComments
   if (list.length > 0) walk(tree, {comments: list, index: 0})
-  return tree
 }
 
 /**

readme.md

@@ -66,23 +66,29 @@ In browsers with [`esm.sh`][esmsh]:
 
 ## Use
 
-Say our document `index.js` contains:
+Say our document `x.js` contains:
 
 ```js
-/* 1 */ function /* 2 */ a /* 3 */ (/* 4 */b) /* 5 */ { /* 6 */ return /* 7 */ b + /* 8 */ 1 /* 9 */ }
+/* 1 */ function /* 2 */ a /* 3 */(/* 4 */ b) /* 5 */ {
+  /* 6 */ return /* 7 */ b + /* 8 */ 1 /* 9 */
+}
 ```
 
 …and our module `example.js` looks as follows:
 
 ```js
 import fs from 'node:fs/promises'
-import * as acorn from 'acorn'
-import recast from 'recast'
+import {parse} from 'acorn'
 import {attachComments} from 'estree-util-attach-comments'
+import recast from 'recast'
 
-const code = String(await fs.readFile('index.js'))
+const code = String(await fs.readFile('x.js'))
 const comments = []
-const tree = acorn.parse(code, {ecmaVersion: 2020, onComment: comments})
+const tree = parse(code, {
+  sourceType: 'module',
+  ecmaVersion: 2020,
+  onComment: comments
+})
 
 attachComments(tree, comments)
 
@@ -148,7 +154,7 @@ and direct `start` / `end` fields.
 
 ###### Returns
 
-The given `tree` ([`Program`][program]).
+Nothing (`undefined`).
 
 ## Types
 

test.js

@@ -19,69 +19,67 @@ test('attachComments', async function (t) {
   })
 
   await t.test('should support an empty document', async function () {
-    assert.equal(recast.print(attachComments(...parse(''))).code, '')
+    const [tree, comments] = parse('')
+    attachComments(tree, comments)
+    assert.equal(recast.print(tree).code, '')
   })
 
   await t.test('should support no comments', async function () {
-    assert.equal(recast.print(attachComments(...parse('a + 1'))).code, 'a + 1;')
+    const [tree, comments] = parse('a + 1')
+    attachComments(tree, comments)
+    assert.equal(recast.print(tree).code, 'a + 1;')
   })
 
   await t.test('should support a single block comment', async function () {
-    assert.equal(
-      recast.print(attachComments(...parse('/* ! */'))).code,
-      '/* ! */\n'
-    )
+    const [tree, comments] = parse('/* ! */')
+    attachComments(tree, comments)
+    assert.equal(recast.print(tree).code, '/* ! */\n')
   })
 
   await t.test('should support a single line comment', async function () {
-    assert.equal(recast.print(attachComments(...parse('// !'))).code, '// !\n')
+    const [tree, comments] = parse('// !')
+    attachComments(tree, comments)
+    assert.equal(recast.print(tree).code, '// !\n')
   })
 
   await t.test('should support some comments', async function () {
+    const [tree, comments] = parse(
+      '/* 1 */ function a (/* 2 */b) { return b + 1 }'
+    )
+    attachComments(tree, comments)
     assert.equal(
-      recast.print(
-        attachComments(
-          ...parse('/* 1 */ function a (/* 2 */b) { return b + 1 }')
-        )
-      ).code,
+      recast.print(tree).code,
       '/* 1 */\nfunction a(\n    /* 2 */\n    b\n) {\n    return b + 1;\n}'
     )
   })
 
   await t.test('should support a bunch of block comments', async function () {
+    const [tree, comments] = parse(
+      '/* 1 */ function /* 2 */ a /* 3 */ (/* 4 */b) /* 5 */ { /* 6 */ return /* 7 */ b + /* 8 */ 1 /* 9 */ }'
+    )
+    attachComments(tree, comments)
     assert.equal(
-      recast.print(
-        attachComments(
-          ...parse(
-            '/* 1 */ function /* 2 */ a /* 3 */ (/* 4 */b) /* 5 */ { /* 6 */ return /* 7 */ b + /* 8 */ 1 /* 9 */ }'
-          )
-        )
-      ).code,
+      recast.print(tree).code,
       '/* 1 */\nfunction /* 2 */\na(\n    /* 3 */\n    /* 4 */\n    b\n) /* 5 */\n{\n    /* 6 */\n    return (\n        /* 7 */\n        b + /* 8 */\n        1\n    );\n}/* 9 */'
     )
   })
 
   await t.test('should support some more comments', async function () {
+    const [tree, comments] = parse('/* 1 */ a /* 2 */ = /* 3 */ { /* 4 */ }')
+    attachComments(tree, comments)
     // Recast parses `4` as “dangling”:
     // <https://github.com/benjamn/recast/blob/dd7c5ec/lib/comments.ts#L255-L256>
     // But apprently doesn’t serialize it?
-    assert.equal(
-      recast.print(
-        attachComments(...parse('/* 1 */ a /* 2 */ = /* 3 */ { /* 4 */ }'))
-      ).code,
-      '/* 1 */\na = /* 2 */\n/* 3 */\n{};'
-    )
+    assert.equal(recast.print(tree).code, '/* 1 */\na = /* 2 */\n/* 3 */\n{};')
   })
 
   await t.test('should support a bunch of line comments', async function () {
+    const [tree, comments] = parse(
+      '// 1\nfunction // 2\na // 3\n(// 4\nb) // 5\n { // 6\n return b + // 7\n 1 // 8\n }'
+    )
+    attachComments(tree, comments)
     assert.equal(
-      recast.print(
-        attachComments(
-          ...parse(
-            '// 1\nfunction // 2\na // 3\n(// 4\nb) // 5\n { // 6\n return b + // 7\n 1 // 8\n }'
-          )
-        )
-      ).code,
+      recast.print(tree).code,
       '// 1\nfunction // 2\na(\n    // 3\n    // 4\n    b\n) // 5\n{\n    // 6\n    return b + // 7\n    1;\n}// 8'
     )
   })
@@ -100,8 +98,9 @@ test('attachComments', async function (t) {
       })
 
       removePositions(tree)
+      attachComments(tree, comments)
 
-      assert.equal(recast.print(attachComments(tree, comments)).code, 'a + 1;')
+      assert.equal(recast.print(tree).code, 'a + 1;')
     }
   )
 
@@ -116,7 +115,9 @@ test('attachComments', async function (t) {
       onComment: comments
     })
 
-    assert.equal(recast.print(attachComments(tree)).code, '1 + 1;')
+    attachComments(tree)
+
+    assert.equal(recast.print(tree).code, '1 + 1;')
   })
 
   await t.test(
@@ -134,7 +135,9 @@ test('attachComments', async function (t) {
 
       removePositions(comments)
 
-      assert.equal(recast.print(attachComments(tree, comments)).code, 'a + 1;')
+      attachComments(tree, comments)
+
+      assert.equal(recast.print(tree).code, 'a + 1;')
     }
   )
 
@@ -152,10 +155,9 @@ test('attachComments', async function (t) {
 
     removePositions(tree)
 
-    assert.equal(
-      recast.print(attachComments(tree, comments)).code,
-      '/* 1 */\na + /* 2 */\n/* 3 */\n1;'
-    )
+    attachComments(tree, comments)
+
+    assert.equal(recast.print(tree).code, '/* 1 */\na + /* 2 */\n/* 3 */\n1;')
   })
 
   await t.test('should use `loc`s', async function () {
@@ -171,11 +173,9 @@ test('attachComments', async function (t) {
     })
 
     removePositions(tree)
+    attachComments(tree, comments)
 
-    assert.equal(
-      recast.print(attachComments(tree, comments)).code,
-      '/* 1 */\na + /* 2 */\n/* 3 */\n1;'
-    )
+    assert.equal(recast.print(tree).code, '/* 1 */\na + /* 2 */\n/* 3 */\n1;')
   })
 })