@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/linter/code-path-analysis/code-path.js

@@ -1,332 +0,0 @@
-/**
- * @fileoverview A class of the code path.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const CodePathState = require("./code-path-state");
-const IdGenerator = require("./id-generator");
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * A code path.
- */
-class CodePath {
-	/**
-	 * Creates a new instance.
-	 * @param {Object} options Options for the function (see below).
-	 * @param {string} options.id An identifier.
-	 * @param {string} options.origin The type of code path origin.
-	 * @param {CodePath|null} options.upper The code path of the upper function scope.
-	 * @param {Function} options.onLooped A callback function to notify looping.
-	 */
-	constructor({ id, origin, upper, onLooped }) {
-		/**
-		 * The identifier of this code path.
-		 * Rules use it to store additional information of each rule.
-		 * @type {string}
-		 */
-		this.id = id;
-
-		/**
-		 * The reason that this code path was started. May be "program",
-		 * "function", "class-field-initializer", or "class-static-block".
-		 * @type {string}
-		 */
-		this.origin = origin;
-
-		/**
-		 * The code path of the upper function scope.
-		 * @type {CodePath|null}
-		 */
-		this.upper = upper;
-
-		/**
-		 * The code paths of nested function scopes.
-		 * @type {CodePath[]}
-		 */
-		this.childCodePaths = [];
-
-		// Initializes internal state.
-		Object.defineProperty(this, "internal", {
-			value: new CodePathState(new IdGenerator(`${id}_`), onLooped),
-		});
-
-		// Adds this into `childCodePaths` of `upper`.
-		if (upper) {
-			upper.childCodePaths.push(this);
-		}
-	}
-
-	/**
-	 * Gets the state of a given code path.
-	 * @param {CodePath} codePath A code path to get.
-	 * @returns {CodePathState} The state of the code path.
-	 */
-	static getState(codePath) {
-		return codePath.internal;
-	}
-
-	/**
-	 * The initial code path segment. This is the segment that is at the head
-	 * of the code path.
-	 * This is a passthrough to the underlying `CodePathState`.
-	 * @type {CodePathSegment}
-	 */
-	get initialSegment() {
-		return this.internal.initialSegment;
-	}
-
-	/**
-	 * Final code path segments. These are the terminal (tail) segments in the
-	 * code path, which is the combination of `returnedSegments` and `thrownSegments`.
-	 * All segments in this array are reachable.
-	 * This is a passthrough to the underlying `CodePathState`.
-	 * @type {CodePathSegment[]}
-	 */
-	get finalSegments() {
-		return this.internal.finalSegments;
-	}
-
-	/**
-	 * Final code path segments that represent normal completion of the code path.
-	 * For functions, this means both explicit `return` statements and implicit returns,
-	 * such as the last reachable segment in a function that does not have an
-	 * explicit `return` as this implicitly returns `undefined`. For scripts,
-	 * modules, class field initializers, and class static blocks, this means
-	 * all lines of code have been executed.
-	 * These segments are also present in `finalSegments`.
-	 * This is a passthrough to the underlying `CodePathState`.
-	 * @type {CodePathSegment[]}
-	 */
-	get returnedSegments() {
-		return this.internal.returnedForkContext;
-	}
-
-	/**
-	 * Final code path segments that represent `throw` statements.
-	 * This is a passthrough to the underlying `CodePathState`.
-	 * These segments are also present in `finalSegments`.
-	 * @type {CodePathSegment[]}
-	 */
-	get thrownSegments() {
-		return this.internal.thrownForkContext;
-	}
-
-	/**
-	 * Traverses all segments in this code path.
-	 *
-	 *     codePath.traverseSegments((segment, controller) => {
-	 *         // do something.
-	 *     });
-	 *
-	 * This method enumerates segments in order from the head.
-	 *
-	 * The `controller` argument has two methods:
-	 *
-	 * - `skip()` - skips the following segments in this branch
-	 * - `break()` - skips all following segments in the traversal
-	 *
-	 * A note on the parameters: the `options` argument is optional. This means
-	 * the first argument might be an options object or the callback function.
-	 * @param {Object} [optionsOrCallback] Optional first and last segments to traverse.
-	 * @param {CodePathSegment} [optionsOrCallback.first] The first segment to traverse.
-	 * @param {CodePathSegment} [optionsOrCallback.last] The last segment to traverse.
-	 * @param {Function} callback A callback function.
-	 * @returns {void}
-	 */
-	traverseSegments(optionsOrCallback, callback) {
-		// normalize the arguments into a callback and options
-		let resolvedOptions;
-		let resolvedCallback;
-
-		if (typeof optionsOrCallback === "function") {
-			resolvedCallback = optionsOrCallback;
-			resolvedOptions = {};
-		} else {
-			resolvedOptions = optionsOrCallback || {};
-			resolvedCallback = callback;
-		}
-
-		// determine where to start traversing from based on the options
-		const startSegment =
-			resolvedOptions.first || this.internal.initialSegment;
-		const lastSegment = resolvedOptions.last;
-
-		// set up initial location information
-		let record;
-		let index;
-		let end;
-		let segment = null;
-
-		// segments that have already been visited during traversal
-		const visited = new Set();
-
-		// tracks the traversal steps
-		const stack = [[startSegment, 0]];
-
-		// segments that have been skipped during traversal
-		const skipped = new Set();
-
-		// indicates if we exited early from the traversal
-		let broken = false;
-
-		/**
-		 * Maintains traversal state.
-		 */
-		const controller = {
-			/**
-			 * Skip the following segments in this branch.
-			 * @returns {void}
-			 */
-			skip() {
-				skipped.add(segment);
-			},
-
-			/**
-			 * Stop traversal completely - do not traverse to any
-			 * other segments.
-			 * @returns {void}
-			 */
-			break() {
-				broken = true;
-			},
-		};
-
-		/**
-		 * Checks if a given previous segment has been visited.
-		 * @param {CodePathSegment} prevSegment A previous segment to check.
-		 * @returns {boolean} `true` if the segment has been visited.
-		 */
-		function isVisited(prevSegment) {
-			return (
-				visited.has(prevSegment) ||
-				segment.isLoopedPrevSegment(prevSegment)
-			);
-		}
-
-		/**
-		 * Checks if a given previous segment has been skipped.
-		 * @param {CodePathSegment} prevSegment A previous segment to check.
-		 * @returns {boolean} `true` if the segment has been skipped.
-		 */
-		function isSkipped(prevSegment) {
-			return (
-				skipped.has(prevSegment) ||
-				segment.isLoopedPrevSegment(prevSegment)
-			);
-		}
-
-		// the traversal
-		while (stack.length > 0) {
-			/*
-			 * This isn't a pure stack. We use the top record all the time
-			 * but don't always pop it off. The record is popped only if
-			 * one of the following is true:
-			 *
-			 * 1) We have already visited the segment.
-			 * 2) We have not visited *all* of the previous segments.
-			 * 3) We have traversed past the available next segments.
-			 *
-			 * Otherwise, we just read the value and sometimes modify the
-			 * record as we traverse.
-			 */
-			record = stack.at(-1);
-			segment = record[0];
-			index = record[1];
-
-			if (index === 0) {
-				// Skip if this segment has been visited already.
-				if (visited.has(segment)) {
-					stack.pop();
-					continue;
-				}
-
-				// Skip if all previous segments have not been visited.
-				if (
-					segment !== startSegment &&
-					segment.prevSegments.length > 0 &&
-					!segment.prevSegments.every(isVisited)
-				) {
-					stack.pop();
-					continue;
-				}
-
-				visited.add(segment);
-
-				// Skips the segment if all previous segments have been skipped.
-				const shouldSkip =
-					skipped.size > 0 &&
-					segment.prevSegments.length > 0 &&
-					segment.prevSegments.every(isSkipped);
-
-				/*
-				 * If the most recent segment hasn't been skipped, then we call
-				 * the callback, passing in the segment and the controller.
-				 */
-				if (!shouldSkip) {
-					resolvedCallback.call(this, segment, controller);
-
-					// exit if we're at the last segment
-					if (segment === lastSegment) {
-						controller.skip();
-					}
-
-					/*
-					 * If the previous statement was executed, or if the callback
-					 * called a method on the controller, we might need to exit the
-					 * loop, so check for that and break accordingly.
-					 */
-					if (broken) {
-						break;
-					}
-				} else {
-					// If the most recent segment has been skipped, then mark it as skipped.
-					skipped.add(segment);
-				}
-			}
-
-			// Update the stack.
-			end = segment.nextSegments.length - 1;
-			if (index < end) {
-				/*
-				 * If we haven't yet visited all of the next segments, update
-				 * the current top record on the stack to the next index to visit
-				 * and then push a record for the current segment on top.
-				 *
-				 * Setting the current top record's index lets us know how many
-				 * times we've been here and ensures that the segment won't be
-				 * reprocessed (because we only process segments with an index
-				 * of 0).
-				 */
-				record[1] += 1;
-				stack.push([segment.nextSegments[index], 0]);
-			} else if (index === end) {
-				/*
-				 * If we are at the last next segment, then reset the top record
-				 * in the stack to next segment and set its index to 0 so it will
-				 * be processed next.
-				 */
-				record[0] = segment.nextSegments[index];
-				record[1] = 0;
-			} else {
-				/*
-				 * If index > end, that means we have no more segments that need
-				 * processing. So, we pop that record off of the stack in order to
-				 * continue traversing at the next level up.
-				 */
-				stack.pop();
-			}
-		}
-	}
-}
-
-module.exports = CodePath;

package/packages/config-eslint/node_modules/eslint/lib/linter/code-path-analysis/debug-helpers.js

@@ -1,223 +0,0 @@
-/**
- * @fileoverview Helpers to debug for code path analysis.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const debug = require("debug")("eslint:code-path");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets id of a given segment.
- * @param {CodePathSegment} segment A segment to get.
- * @returns {string} Id of the segment.
- */
-/* c8 ignore next */
-// eslint-disable-next-line jsdoc/require-jsdoc -- Ignoring
-function getId(segment) {
-	return segment.id + (segment.reachable ? "" : "!");
-}
-
-/**
- * Get string for the given node and operation.
- * @param {ASTNode} node The node to convert.
- * @param {"enter" | "exit" | undefined} label The operation label.
- * @returns {string} The string representation.
- */
-function nodeToString(node, label) {
-	const suffix = label ? `:${label}` : "";
-
-	switch (node.type) {
-		case "Identifier":
-			return `${node.type}${suffix} (${node.name})`;
-		case "Literal":
-			return `${node.type}${suffix} (${node.value})`;
-		default:
-			return `${node.type}${suffix}`;
-	}
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = {
-	/**
-	 * A flag that debug dumping is enabled or not.
-	 * @type {boolean}
-	 */
-	enabled: debug.enabled,
-
-	/**
-	 * Dumps given objects.
-	 * @param {...any} args objects to dump.
-	 * @returns {void}
-	 */
-	dump: debug,
-
-	/**
-	 * Dumps the current analyzing state.
-	 * @param {ASTNode} node A node to dump.
-	 * @param {CodePathState} state A state to dump.
-	 * @param {boolean} leaving A flag whether or not it's leaving
-	 * @returns {void}
-	 */
-	dumpState: !debug.enabled
-		? debug
-		: /* c8 ignore next */ function (node, state, leaving) {
-				for (let i = 0; i < state.currentSegments.length; ++i) {
-					const segInternal = state.currentSegments[i].internal;
-
-					if (leaving) {
-						const last = segInternal.nodes.length - 1;
-
-						if (
-							last >= 0 &&
-							segInternal.nodes[last] ===
-								nodeToString(node, "enter")
-						) {
-							segInternal.nodes[last] = nodeToString(
-								node,
-								void 0,
-							);
-						} else {
-							segInternal.nodes.push(nodeToString(node, "exit"));
-						}
-					} else {
-						segInternal.nodes.push(nodeToString(node, "enter"));
-					}
-				}
-
-				debug(
-					[
-						`${state.currentSegments.map(getId).join(",")})`,
-						`${node.type}${leaving ? ":exit" : ""}`,
-					].join(" "),
-				);
-			},
-
-	/**
-	 * Dumps a DOT code of a given code path.
-	 * The DOT code can be visualized with Graphvis.
-	 * @param {CodePath} codePath A code path to dump.
-	 * @returns {void}
-	 * @see http://www.graphviz.org
-	 * @see http://www.webgraphviz.com
-	 */
-	dumpDot: !debug.enabled
-		? debug
-		: /* c8 ignore next */ function (codePath) {
-				let text =
-					"\n" +
-					"digraph {\n" +
-					'node[shape=box,style="rounded,filled",fillcolor=white];\n' +
-					'initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];\n';
-
-				if (codePath.returnedSegments.length > 0) {
-					text +=
-						'final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];\n';
-				}
-				if (codePath.thrownSegments.length > 0) {
-					text +=
-						'thrown[label="✘",shape=circle,width=0.3,height=0.3,fixedsize=true];\n';
-				}
-
-				const traceMap = Object.create(null);
-				const arrows = this.makeDotArrows(codePath, traceMap);
-
-				// eslint-disable-next-line guard-for-in -- Want ability to traverse prototype
-				for (const id in traceMap) {
-					const segment = traceMap[id];
-
-					text += `${id}[`;
-
-					if (segment.reachable) {
-						text += 'label="';
-					} else {
-						text +=
-							'style="rounded,dashed,filled",fillcolor="#FF9800",label="<<unreachable>>\\n';
-					}
-
-					if (segment.internal.nodes.length > 0) {
-						text += segment.internal.nodes.join("\\n");
-					} else {
-						text += "????";
-					}
-
-					text += '"];\n';
-				}
-
-				text += `${arrows}\n`;
-				text += "}";
-				debug("DOT", text);
-			},
-
-	/**
-	 * Makes a DOT code of a given code path.
-	 * The DOT code can be visualized with Graphvis.
-	 * @param {CodePath} codePath A code path to make DOT.
-	 * @param {Object} traceMap Optional. A map to check whether or not segments had been done.
-	 * @returns {string} A DOT code of the code path.
-	 */
-	makeDotArrows(codePath, traceMap) {
-		const stack = [[codePath.initialSegment, 0]];
-		const done = traceMap || Object.create(null);
-		let lastId = codePath.initialSegment.id;
-		let text = `initial->${codePath.initialSegment.id}`;
-
-		while (stack.length > 0) {
-			const item = stack.pop();
-			const segment = item[0];
-			const index = item[1];
-
-			if (done[segment.id] && index === 0) {
-				continue;
-			}
-			done[segment.id] = segment;
-
-			const nextSegment = segment.allNextSegments[index];
-
-			if (!nextSegment) {
-				continue;
-			}
-
-			if (lastId === segment.id) {
-				text += `->${nextSegment.id}`;
-			} else {
-				text += `;\n${segment.id}->${nextSegment.id}`;
-			}
-			lastId = nextSegment.id;
-
-			stack.unshift([segment, 1 + index]);
-			stack.push([nextSegment, 0]);
-		}
-
-		codePath.returnedSegments.forEach(finalSegment => {
-			if (lastId === finalSegment.id) {
-				text += "->final";
-			} else {
-				text += `;\n${finalSegment.id}->final`;
-			}
-			lastId = null;
-		});
-
-		codePath.thrownSegments.forEach(finalSegment => {
-			if (lastId === finalSegment.id) {
-				text += "->thrown";
-			} else {
-				text += `;\n${finalSegment.id}->thrown`;
-			}
-			lastId = null;
-		});
-
-		return `${text};`;
-	},
-};