137 lines
5.8 KiB
Plaintext
137 lines
5.8 KiB
Plaintext
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");
|