Refactor code-style

Author: wooorm

lib/index.js

@@ -1,21 +1,29 @@
 /**
- * @typedef {import('estree').BaseNode} EstreeNode
- * @typedef {import('estree').Comment} EstreeComment
+ * @typedef {import('estree').Comment} Comment
+ * @typedef {import('estree').Node} Nodes
+ */
+
+/**
+ * @typedef Fields
+ *   Fields.
+ * @property {boolean} leading
+ *   Whether it’s leading.
+ * @property {boolean} trailing
+ *   Whether it’s trailing.
  *
  * @typedef State
  *   Info passed around.
- * @property {Array<EstreeComment>} comments
+ * @property {Array<Comment>} comments
  *   Comments.
  * @property {number} index
  *   Index of comment.
- *
- * @typedef Fields
- * @property {boolean} leading
- * @property {boolean} trailing
  */
 
 const own = {}.hasOwnProperty
 
+/** @type {Array<Comment>} */
+const emptyComments = []
+
 /**
  * Attach semistandard estree comment nodes to the tree.
  *
@@ -37,30 +45,30 @@ const own = {}.hasOwnProperty
  * The algorithm supports `loc` fields (line/column), `range` fields (offsets),
  * and direct `start` / `end` fields.
  *
- * @template {EstreeNode} Tree
+ * @template {Nodes} Tree
  *   Node type.
  * @param {Tree} tree
  *   Tree to attach to.
- * @param {Array<EstreeComment> | null | undefined} [comments]
- *   List of comments.
+ * @param {Array<Comment> | null | undefined} [comments]
+ *   List of comments (optional).
  * @returns {Tree}
  *   Given tree.
  */
 // To do: next major: don’t return given `tree`.
 export function attachComments(tree, comments) {
-  const list = (comments || []).concat().sort(compare)
+  const list = comments ? [...comments].sort(compare) : emptyComments
   if (list.length > 0) walk(tree, {comments: list, index: 0})
   return tree
 }
 
 /**
  * Attach semistandard estree comment nodes to the tree.
  *
- * @param {EstreeNode} node
+ * @param {Nodes} node
  *   Node.
  * @param {State} state
  *   Info passed around.
- * @returns {void}
+ * @returns {undefined}
  *   Nothing.
  */
 function walk(node, state) {
@@ -69,17 +77,17 @@ function walk(node, state) {
     return
   }
 
-  /** @type {Array<EstreeNode>} */
+  /** @type {Array<Nodes>} */
   const children = []
-  /** @type {Array<EstreeComment>} */
+  /** @type {Array<Comment>} */
   const comments = []
   /** @type {string} */
   let key
 
   // Find all children of `node`
   for (key in node) {
     if (own.call(node, key)) {
-      /** @type {EstreeNode | Array<EstreeNode>} */
+      /** @type {Array<Nodes> | Nodes} */
       // @ts-expect-error: indexable.
       const value = node[key]
 
@@ -129,17 +137,17 @@ function walk(node, state) {
 /**
  * @param {State} state
  *   Info passed around.
- * @param {EstreeNode} node
+ * @param {Nodes} node
  *   Node.
  * @param {boolean} compareEnd
  *   Whether to compare on the end (default is on start).
  * @param {Fields} fields
  *   Fields.
- * @returns {Array<EstreeComment>}
+ * @returns {Array<Comment>}
  *   Slice from `state.comments`.
  */
 function slice(state, node, compareEnd, fields) {
-  /** @type {Array<EstreeComment>} */
+  /** @type {Array<Comment>} */
   const result = []
 
   while (
@@ -155,12 +163,13 @@ function slice(state, node, compareEnd, fields) {
 /**
  * Sort two nodes (or comments).
  *
- * @param {EstreeNode | EstreeComment} left
+ * @param {Comment | Nodes} left
  *   A node.
- * @param {EstreeNode | EstreeComment} right
+ * @param {Comment | Nodes} right
  *   The other node.
  * @param {boolean | undefined} [compareEnd=false]
- *   Compare on `end` of `right`, default is to compare on `start`.
+ *   Compare on `end` of `right`, default is to compare on `start` (default:
+ *   `false`).
  * @returns {number}
  *   Sorting.
  */