fix: Add types for "process-exit-as-throw"

Author: scagood

lib/rules/process-exit-as-throw.js

@@ -5,26 +5,28 @@
  */
 "use strict"
 
+/** @type {typeof import('../types-code-path-analysis/code-path-analyzer.js')} */
 const CodePathAnalyzer = safeRequire(
     "eslint/lib/linter/code-path-analysis/code-path-analyzer",
     "eslint/lib/code-path-analysis/code-path-analyzer"
 )
+/** @type {typeof import('../types-code-path-analysis/code-path-segment.js')} */
 const CodePathSegment = safeRequire(
     "eslint/lib/linter/code-path-analysis/code-path-segment",
     "eslint/lib/code-path-analysis/code-path-segment"
 )
+/** @type {typeof import('../types-code-path-analysis/code-path.js')} */
 const CodePath = safeRequire(
     "eslint/lib/linter/code-path-analysis/code-path",
     "eslint/lib/code-path-analysis/code-path"
 )
 
-const originalLeaveNode =
-    CodePathAnalyzer && CodePathAnalyzer.prototype.leaveNode
+const originalLeaveNode = CodePathAnalyzer?.prototype?.leaveNode
 
 /**
  * Imports a specific module.
  * @param {...string} moduleNames - module names to import.
- * @returns {object|null} The imported object, or null.
+ * @returns {*} The imported object, or null.
  */
 function safeRequire(...moduleNames) {
     for (const moduleName of moduleNames) {
@@ -41,8 +43,8 @@ function safeRequire(...moduleNames) {
 /**
  * Copied from https://github.com/eslint/eslint/blob/16fad5880bb70e9dddbeab8ed0f425ae51f5841f/lib/code-path-analysis/code-path-analyzer.js#L137
  *
- * @param {CodePathAnalyzer} analyzer - The instance.
- * @param {ASTNode} node - The current AST node.
+ * @param {import('../types-code-path-analysis/code-path-analyzer.js')} analyzer - The instance.
+ * @param {import('eslint').Rule.Node} node - The current AST node.
  * @returns {void}
  */
 function forwardCurrentToHead(analyzer, node) {
@@ -95,7 +97,7 @@ function forwardCurrentToHead(analyzer, node) {
 /**
  * Checks whether a given node is `process.exit()` or not.
  *
- * @param {ASTNode} node - A node to check.
+ * @param {import('eslint').Rule.Node} node - A node to check.
  * @returns {boolean} `true` if the node is `process.exit()`.
  */
 function isProcessExit(node) {
@@ -114,8 +116,8 @@ function isProcessExit(node) {
  * The function to override `CodePathAnalyzer.prototype.leaveNode` in order to
  * address `process.exit()` as throw.
  *
- * @this CodePathAnalyzer
- * @param {ASTNode} node - A node to be left.
+ * @this {import('../types-code-path-analysis/code-path-analyzer.js')}
+ * @param {import('eslint').Rule.Node} node - A node to be left.
  * @returns {void}
  */
 function overrideLeaveNode(node) {

lib/types-code-path-analysis/code-path-analyzer.d.ts

@@ -0,0 +1,47 @@
+export = CodePathAnalyzer;
+
+interface EventGenerator {
+    emitter: import('node:events').EventEmitter;
+    enterNode(node: import('eslint').Rule.Node): void;
+    leaveNode(node: import('eslint').Rule.Node): void;
+}
+
+/**
+ * The class to analyze code paths.
+ * This class implements the EventGenerator interface.
+ */
+declare class CodePathAnalyzer {
+    /**
+     * @param {EventGenerator} eventGenerator An event generator to wrap.
+     */
+    constructor(eventGenerator: EventGenerator);
+    original: EventGenerator;
+    emitter: any;
+    codePath: any;
+    idGenerator: IdGenerator;
+    currentNode: any;
+    /**
+     * This is called on a code path looped.
+     * Then this raises a looped event.
+     * @param {CodePathSegment} fromSegment A segment of prev.
+     * @param {CodePathSegment} toSegment A segment of next.
+     * @returns {void}
+     */
+    onLooped(fromSegment: CodePathSegment, toSegment: CodePathSegment): void;
+    /**
+     * Does the process to enter a given AST node.
+     * This updates state of analysis and calls `enterNode` of the wrapped.
+     * @param {ASTNode} node A node which is entering.
+     * @returns {void}
+     */
+    enterNode(node: import('eslint').Rule.Node): void;
+    /**
+     * Does the process to leave a given AST node.
+     * This updates state of analysis and calls `leaveNode` of the wrapped.
+     * @param {ASTNode} node A node which is leaving.
+     * @returns {void}
+     */
+    leaveNode(node: import('eslint').Rule.Node): void;
+}
+import IdGenerator = require("./id-generator");
+import CodePathSegment = require("./code-path-segment");

lib/types-code-path-analysis/code-path-segment.d.ts

@@ -0,0 +1,115 @@
+export = CodePathSegment;
+/**
+ * A code path segment.
+ *
+ * Each segment is arranged in a series of linked lists (implemented by arrays)
+ * that keep track of the previous and next segments in a code path. In this way,
+ * you can navigate between all segments in any code path so long as you have a
+ * reference to any segment in that code path.
+ *
+ * When first created, the segment is in a detached state, meaning that it knows the
+ * segments that came before it but those segments don't know that this new segment
+ * follows it. Only when `CodePathSegment#markUsed()` is called on a segment does it
+ * officially become part of the code path by updating the previous segments to know
+ * that this new segment follows.
+ */
+declare class CodePathSegment {
+    /**
+     * Creates the root segment.
+     * @param {string} id An identifier.
+     * @returns {CodePathSegment} The created segment.
+     */
+    static newRoot(id: string): CodePathSegment;
+    /**
+     * Creates a new segment and appends it after the given segments.
+     * @param {string} id An identifier.
+     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments
+     *      to append to.
+     * @returns {CodePathSegment} The created segment.
+     */
+    static newNext(id: string, allPrevSegments: CodePathSegment[]): CodePathSegment;
+    /**
+     * Creates an unreachable segment and appends it after the given segments.
+     * @param {string} id An identifier.
+     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.
+     * @returns {CodePathSegment} The created segment.
+     */
+    static newUnreachable(id: string, allPrevSegments: CodePathSegment[]): CodePathSegment;
+    /**
+     * Creates a segment that follows given segments.
+     * This factory method does not connect with `allPrevSegments`.
+     * But this inherits `reachable` flag.
+     * @param {string} id An identifier.
+     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.
+     * @returns {CodePathSegment} The created segment.
+     */
+    static newDisconnected(id: string, allPrevSegments: CodePathSegment[]): CodePathSegment;
+    /**
+     * Marks a given segment as used.
+     *
+     * And this function registers the segment into the previous segments as a next.
+     * @param {CodePathSegment} segment A segment to mark.
+     * @returns {void}
+     */
+    static markUsed(segment: CodePathSegment): void;
+    /**
+     * Marks a previous segment as looped.
+     * @param {CodePathSegment} segment A segment.
+     * @param {CodePathSegment} prevSegment A previous segment to mark.
+     * @returns {void}
+     */
+    static markPrevSegmentAsLooped(segment: CodePathSegment, prevSegment: CodePathSegment): void;
+    /**
+     * Creates a new array based on an array of segments. If any segment in the
+     * array is unused, then it is replaced by all of its previous segments.
+     * All used segments are returned as-is without replacement.
+     * @param {CodePathSegment[]} segments The array of segments to flatten.
+     * @returns {CodePathSegment[]} The flattened array.
+     */
+    static flattenUnusedSegments(segments: CodePathSegment[]): CodePathSegment[];
+    /**
+     * Creates a new instance.
+     * @param {string} id An identifier.
+     * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.
+     *   This array includes unreachable segments.
+     * @param {boolean} reachable A flag which shows this is reachable.
+     */
+    constructor(id: string, allPrevSegments: CodePathSegment[], reachable: boolean);
+    /**
+     * The identifier of this code path.
+     * Rules use it to store additional information of each rule.
+     * @type {string}
+     */
+    id: string;
+    /**
+     * An array of the next reachable segments.
+     * @type {CodePathSegment[]}
+     */
+    nextSegments: CodePathSegment[];
+    /**
+     * An array of the previous reachable segments.
+     * @type {CodePathSegment[]}
+     */
+    prevSegments: CodePathSegment[];
+    /**
+     * An array of all next segments including reachable and unreachable.
+     * @type {CodePathSegment[]}
+     */
+    allNextSegments: CodePathSegment[];
+    /**
+     * An array of all previous segments including reachable and unreachable.
+     * @type {CodePathSegment[]}
+     */
+    allPrevSegments: CodePathSegment[];
+    /**
+     * A flag which shows this is reachable.
+     * @type {boolean}
+     */
+    reachable: boolean;
+    /**
+     * Checks a given previous segment is coming from the end of a loop.
+     * @param {CodePathSegment} segment A previous segment to check.
+     * @returns {boolean} `true` if the segment is coming from the end of a loop.
+     */
+    isLoopedPrevSegment(segment: CodePathSegment): boolean;
+}