feat(linter/plugins): comment-related APIs

apps/oxlint/src-js/plugins/source_code.ts

@@ -21,6 +21,8 @@ import type { BufferWithArrays, Comment, Node, NodeOrToken, Ranged, Token } from
 
 const { max } = Math;
 
+const WHITESPACE_ONLY_REGEXP = /^\s*$/;
+
 // Text decoder, for decoding source text from buffer
 const textDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
 
@@ -170,29 +172,145 @@ export const SOURCE_CODE = Object.freeze({
    * @param nodeOrToken - The AST node or token to check for adjacent comment tokens.
    * @returns Array of `Comment`s in occurrence order.
    */
-  // oxlint-disable-next-line no-unused-vars
   getCommentsBefore(nodeOrToken: NodeOrToken): Comment[] {
-    throw new Error('`sourceCode.getCommentsBefore` not implemented yet'); // TODO
+    if (ast === null) initAst();
+
+    const { comments } = ast,
+      commentsLength = comments.length;
+
+    let targetStart = nodeOrToken.range[0]; // start
+
+    let sliceStart = commentsLength;
+    let sliceEnd = 0;
+
+    // Reverse iteration isn't ideal, but this entire implementation may need to be rewritten
+    // with token-based APIs to match eslint.
+    for (let i = commentsLength - 1; i >= 0; i--) {
+      const comment = comments[i];
+      const commentEnd = comment.end;
+
+      if (commentEnd < targetStart) {
+        const gap = sourceText.slice(commentEnd, targetStart);
+        if (WHITESPACE_ONLY_REGEXP.test(gap)) {
+          // Nothing except whitespace between end of comment and start of `nodeOrToken`
+          sliceStart = sliceEnd = i + 1;
+          targetStart = comment.start;
+        }
+        break;
+      }
+    }
+
+    for (let i = sliceEnd - 1; i >= 0; i--) {
+      const comment = comments[i];
+      const gap = sourceText.slice(comment.end, targetStart);
+      if (WHITESPACE_ONLY_REGEXP.test(gap)) {
+        // Nothing except whitespace between end of comment and start of `nodeOrToken`
+        sliceStart = i;
+        targetStart = comment.start;
+      } else {
+        break;
+      }
+    }
+
+    return comments.slice(sliceStart, sliceEnd);
   },
 
   /**
    * Get all comment tokens directly after the given node or token.
    * @param nodeOrToken - The AST node or token to check for adjacent comment tokens.
    * @returns Array of `Comment`s in occurrence order.
    */
-  // oxlint-disable-next-line no-unused-vars
   getCommentsAfter(nodeOrToken: NodeOrToken): Comment[] {
-    throw new Error('`sourceCode.getCommentsAfter` not implemented yet'); // TODO
+    if (ast === null) initAst();
+
+    const { comments } = ast,
+      commentsLength = comments.length;
+
+    let targetEnd = nodeOrToken.range[1]; // end
+
+    const commentsAfter: Comment[] = [];
+    for (let i = 0; i < commentsLength; i++) {
+      const comment = comments[i],
+        commentStart = comment.start;
+
+      if (commentStart < targetEnd) {
+        continue;
+      }
+      const gap = sourceText.slice(targetEnd, commentStart);
+      if (WHITESPACE_ONLY_REGEXP.test(gap)) {
+        // Nothing except whitespace between end of `nodeOrToken` and start of comment
+        commentsAfter.push(comment);
+        targetEnd = comment.end;
+      } else {
+        break;
+      }
+    }
+
+    return commentsAfter;
   },
 
   /**
    * Get all comment tokens inside the given node.
    * @param node - The AST node to get the comments for.
    * @returns Array of `Comment`s in occurrence order.
    */
-  // oxlint-disable-next-line no-unused-vars
   getCommentsInside(node: Node): Comment[] {
-    throw new Error('`sourceCode.getCommentsInside` not implemented yet'); // TODO
+    if (ast === null) initAst();
+
+    const { comments } = ast,
+      commentsLength = comments.length;
+
+    let sliceStart = commentsLength;
+    let sliceEnd: number | undefined = undefined;
+
+    const { range } = node,
+      rangeStart = range[0],
+      rangeEnd = range[1];
+
+    // Linear search for first comment within `node`'s range.
+    // TODO: Use binary search.
+    for (let i = 0; i < commentsLength; i++) {
+      const comment = comments[i];
+      if (comment.start >= rangeStart) {
+        sliceStart = i;
+        break;
+      }
+    }
+
+    // Continued linear search for first comment outside `node`'s range.
+    // Its index is used as `sliceEnd`, which is exclusive of the slice.
+    for (let i = sliceStart; i < commentsLength; i++) {
+      const comment = comments[i];
+      if (comment.start > rangeEnd) {
+        sliceEnd = i;
+        break;
+      }
+    }
+
+    return comments.slice(sliceStart, sliceEnd);
+  },
+
+  /**
+   * Check whether any comments exist or not between the given 2 nodes.
+   * @param nodeOrToken1 - The node to check.
+   * @param nodeOrToken2 - The node to check.
+   * @returns `true` if one or more comments exist.
+   */
+  commentsExistBetween(nodeOrToken1: NodeOrToken, nodeOrToken2: NodeOrToken): boolean {
+    if (ast === null) initAst();
+
+    // Find the first comment after `nodeOrToken1` ends.
+    // Check if it ends before `nodeOrToken2` starts.
+    const { comments } = ast,
+      commentsLength = comments.length;
+    const betweenRangeStart = nodeOrToken1.range[1]; // end
+    for (let i = 0; i < commentsLength; i++) {
+      const comment = comments[i];
+      if (comment.start >= betweenRangeStart) {
+        return comment.end <= nodeOrToken2.range[0]; // start
+      }
+    }
+    return false;
   },
 
   /**
@@ -463,17 +581,6 @@ export const SOURCE_CODE = Object.freeze({
   getLocFromIndex: getLineColumnFromOffset,
   getIndexFromLoc: getOffsetFromLineColumn,
 
-  /**
-   * Check whether any comments exist or not between the given 2 nodes.
-   * @param nodeOrToken1 - The node to check.
-   * @param nodeOrToken2 - The node to check.
-   * @returns `true` if one or more comments exist.
-   */
-  // oxlint-disable-next-line no-unused-vars
-  commentsExistBetween(nodeOrToken1: NodeOrToken, nodeOrToken2: NodeOrToken): boolean {
-    throw new Error('`sourceCode.commentsExistBetween` not implemented yet'); // TODO
-  },
-
   getAncestors,
 
   /**

apps/oxlint/test/e2e.test.ts

@@ -217,7 +217,7 @@ describe('oxlint CLI', () => {
     }
   });
 
-  it('SourceCode.getAllComments() should return all comments', async () => {
-    await testFixture('getAllComments');
+  it('should support comments-related APIs in `context.sourceCode`', async () => {
+    await testFixture('comments');
   });
 });

apps/oxlint/test/fixtures/comments/.oxlintrc.json

@@ -0,0 +1,7 @@
+{
+  "jsPlugins": ["./plugin.ts"],
+  "categories": { "correctness": "off" },
+  "rules": {
+    "test-comments/test-comments": "error"
+  }
+}

apps/oxlint/test/fixtures/comments/files/comments.js

@@ -0,0 +1,32 @@
+const topLevelVariable1 = 1;
+// Line comment 1
+const topLevelVariable2 = 2; /* Block comment 1 */
+
+/**
+ * JSDoc comment
+ */
+export function topLevelFunction() {
+  // Line comment 2
+  /* Block comment 2 */
+  let functionScopedVariable = topLevelVariable;
+  /**
+   * JSDoc comment 2
+   */
+  function nestedFunction() {
+    // Line comment 3
+    return functionScopedVariable;
+  }
+  return nestedFunction(); // Line comment 4
+}
+
+/* Block comment 3 */
+const topLevelVariable3 = /* Block comment 4 */ 3;
+
+const topLevelVariable4 = 4;
+const topLevelVariable5 = 5;
+
+// Line comment 5
+// Line comment 6
+
+const topLevelVariable6 = 6;
+const topLevelVariable7 = 7;

apps/oxlint/test/fixtures/comments/files/no_comments.js

@@ -0,0 +1,16 @@
+const topLevelVariable1 = 1;
+const topLevelVariable2 = 2;
+
+export function topLevelFunction() {
+  let functionScopedVariable = topLevelVariable;
+  function nestedFunction() {
+    return functionScopedVariable;
+  }
+  return nestedFunction();
+}
+
+const topLevelVariable3 = 3;
+const topLevelVariable4 = 4;
+const topLevelVariable5 = 5;
+const topLevelVariable6 = 6;
+const topLevelVariable7 = 7;