UNPKG

eslint-plugin-n

Version:
137 lines (135 loc) 5.92 kB
import IdGenerator = require("./id-generator"); export = ForkContext; /** * Manages the forking of code paths. */ declare class ForkContext { /** * Creates a new root context, meaning that there are no parent * fork contexts. * @param {IdGenerator} idGenerator An identifier generator for segments. * @returns {ForkContext} New fork context. */ static newRoot(idGenerator: IdGenerator): ForkContext; /** * Creates an empty fork context preceded by a given context. * @param {ForkContext} parentContext The parent fork context. * @param {boolean} shouldForkLeavingPath Indicates that we are inside of * a `finally` block and should therefore fork the path that leaves * `finally`. * @returns {ForkContext} New fork context. */ static newEmpty(parentContext: ForkContext, shouldForkLeavingPath: boolean): ForkContext; /** * Creates a new instance. * @param {IdGenerator} idGenerator An identifier generator for segments. * @param {ForkContext|null} upper The preceding fork context. * @param {number} count The number of parallel segments in each element * of `segmentsList`. */ constructor(idGenerator: IdGenerator, upper: ForkContext | null, count: number); /** * The ID generator that will generate segment IDs for any new * segments that are created. * @type {IdGenerator} */ idGenerator: IdGenerator; /** * The preceding fork context. * @type {ForkContext|null} */ upper: ForkContext | null; /** * The number of elements in each element of `segmentsList`. In most * cases, this is 1 but can be 2 when there is a `finally` present, * which forks the code path outside of normal flow. In the case of nested * `finally` blocks, this can be a multiple of 2. * @type {number} */ count: number; /** * The segments within this context. Each element in this array has * `count` elements that represent one step in each fork. For example, * when `segmentsList` is `[[a, b], [c, d], [e, f]]`, there is one path * a->c->e and one path b->d->f, and `count` is 2 because each element * is an array with two elements. * @type {Array<Array<CodePathSegment>>} */ segmentsList: Array<Array<CodePathSegment>>; /** * The segments that begin this fork context. * @type {Array<CodePathSegment>} */ get head(): CodePathSegment[]; /** * Indicates if the context contains no segments. * @type {boolean} */ get empty(): boolean; /** * Indicates if there are any segments that are reachable. * @type {boolean} */ get reachable(): boolean; /** * Creates new segments in this context and appends them to the end of the * already existing `CodePathSegment`s specified by `startIndex` and * `endIndex`. * @param {number} startIndex The index of the first segment in the context * that should be specified as previous segments for the newly created segments. * @param {number} endIndex The index of the last segment in the context * that should be specified as previous segments for the newly created segments. * @returns {Array<CodePathSegment>} An array of the newly created segments. */ makeNext(startIndex: number, endIndex: number): Array<CodePathSegment>; /** * Creates new unreachable segments in this context and appends them to the end of the * already existing `CodePathSegment`s specified by `startIndex` and * `endIndex`. * @param {number} startIndex The index of the first segment in the context * that should be specified as previous segments for the newly created segments. * @param {number} endIndex The index of the last segment in the context * that should be specified as previous segments for the newly created segments. * @returns {Array<CodePathSegment>} An array of the newly created segments. */ makeUnreachable(startIndex: number, endIndex: number): Array<CodePathSegment>; /** * Creates new segments in this context and does not append them to the end * of the already existing `CodePathSegment`s specified by `startIndex` and * `endIndex`. The `startIndex` and `endIndex` are only used to determine if * the new segments should be reachable. If any of the segments in this range * are reachable then the new segments are also reachable; otherwise, the new * segments are unreachable. * @param {number} startIndex The index of the first segment in the context * that should be considered for reachability. * @param {number} endIndex The index of the last segment in the context * that should be considered for reachability. * @returns {Array<CodePathSegment>} An array of the newly created segments. */ makeDisconnected(startIndex: number, endIndex: number): Array<CodePathSegment>; /** * Adds segments to the head of this context. * @param {Array<CodePathSegment>} segments The segments to add. * @returns {void} */ add(segments: Array<CodePathSegment>): void; /** * Replaces the head segments with the given segments. * The current head segments are removed. * @param {Array<CodePathSegment>} replacementHeadSegments The new head segments. * @returns {void} */ replaceHead(replacementHeadSegments: Array<CodePathSegment>): void; /** * Adds all segments of a given fork context into this context. * @param {ForkContext} otherForkContext The fork context to add from. * @returns {void} */ addAll(otherForkContext: ForkContext): void; /** * Clears all segments in this context. * @returns {void} */ clear(): void; } import CodePathSegment = require("./code-path-segment");