--- /dev/null
+/**
+ * @fileoverview A class to manage state of generating a code path.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const CodePathSegment = require("./code-path-segment"),
+ ForkContext = require("./fork-context");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Adds given segments into the `dest` array.
+ * If the `others` array does not includes the given segments, adds to the `all`
+ * array as well.
+ *
+ * This adds only reachable and used segments.
+ * @param {CodePathSegment[]} dest A destination array (`returnedSegments` or `thrownSegments`).
+ * @param {CodePathSegment[]} others Another destination array (`returnedSegments` or `thrownSegments`).
+ * @param {CodePathSegment[]} all The unified destination array (`finalSegments`).
+ * @param {CodePathSegment[]} segments Segments to add.
+ * @returns {void}
+ */
+function addToReturnedOrThrown(dest, others, all, segments) {
+ for (let i = 0; i < segments.length; ++i) {
+ const segment = segments[i];
+
+ dest.push(segment);
+ if (others.indexOf(segment) === -1) {
+ all.push(segment);
+ }
+ }
+}
+
+/**
+ * Gets a loop-context for a `continue` statement.
+ * @param {CodePathState} state A state to get.
+ * @param {string} label The label of a `continue` statement.
+ * @returns {LoopContext} A loop-context for a `continue` statement.
+ */
+function getContinueContext(state, label) {
+ if (!label) {
+ return state.loopContext;
+ }
+
+ let context = state.loopContext;
+
+ while (context) {
+ if (context.label === label) {
+ return context;
+ }
+ context = context.upper;
+ }
+
+ /* istanbul ignore next: foolproof (syntax error) */
+ return null;
+}
+
+/**
+ * Gets a context for a `break` statement.
+ * @param {CodePathState} state A state to get.
+ * @param {string} label The label of a `break` statement.
+ * @returns {LoopContext|SwitchContext} A context for a `break` statement.
+ */
+function getBreakContext(state, label) {
+ let context = state.breakContext;
+
+ while (context) {
+ if (label ? context.label === label : context.breakable) {
+ return context;
+ }
+ context = context.upper;
+ }
+
+ /* istanbul ignore next: foolproof (syntax error) */
+ return null;
+}
+
+/**
+ * Gets a context for a `return` statement.
+ * @param {CodePathState} state A state to get.
+ * @returns {TryContext|CodePathState} A context for a `return` statement.
+ */
+function getReturnContext(state) {
+ let context = state.tryContext;
+
+ while (context) {
+ if (context.hasFinalizer && context.position !== "finally") {
+ return context;
+ }
+ context = context.upper;
+ }
+
+ return state;
+}
+
+/**
+ * Gets a context for a `throw` statement.
+ * @param {CodePathState} state A state to get.
+ * @returns {TryContext|CodePathState} A context for a `throw` statement.
+ */
+function getThrowContext(state) {
+ let context = state.tryContext;
+
+ while (context) {
+ if (context.position === "try" ||
+ (context.hasFinalizer && context.position === "catch")
+ ) {
+ return context;
+ }
+ context = context.upper;
+ }
+
+ return state;
+}
+
+/**
+ * Removes a given element from a given array.
+ * @param {any[]} xs An array to remove the specific element.
+ * @param {any} x An element to be removed.
+ * @returns {void}
+ */
+function remove(xs, x) {
+ xs.splice(xs.indexOf(x), 1);
+}
+
+/**
+ * Disconnect given segments.
+ *
+ * This is used in a process for switch statements.
+ * If there is the "default" chunk before other cases, the order is different
+ * between node's and running's.
+ * @param {CodePathSegment[]} prevSegments Forward segments to disconnect.
+ * @param {CodePathSegment[]} nextSegments Backward segments to disconnect.
+ * @returns {void}
+ */
+function removeConnection(prevSegments, nextSegments) {
+ for (let i = 0; i < prevSegments.length; ++i) {
+ const prevSegment = prevSegments[i];
+ const nextSegment = nextSegments[i];
+
+ remove(prevSegment.nextSegments, nextSegment);
+ remove(prevSegment.allNextSegments, nextSegment);
+ remove(nextSegment.prevSegments, prevSegment);
+ remove(nextSegment.allPrevSegments, prevSegment);
+ }
+}
+
+/**
+ * Creates looping path.
+ * @param {CodePathState} state The instance.
+ * @param {CodePathSegment[]} unflattenedFromSegments Segments which are source.
+ * @param {CodePathSegment[]} unflattenedToSegments Segments which are destination.
+ * @returns {void}
+ */
+function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
+ const fromSegments = CodePathSegment.flattenUnusedSegments(unflattenedFromSegments);
+ const toSegments = CodePathSegment.flattenUnusedSegments(unflattenedToSegments);
+
+ const end = Math.min(fromSegments.length, toSegments.length);
+
+ for (let i = 0; i < end; ++i) {
+ const fromSegment = fromSegments[i];
+ const toSegment = toSegments[i];
+
+ if (toSegment.reachable) {
+ fromSegment.nextSegments.push(toSegment);
+ }
+ if (fromSegment.reachable) {
+ toSegment.prevSegments.push(fromSegment);
+ }
+ fromSegment.allNextSegments.push(toSegment);
+ toSegment.allPrevSegments.push(fromSegment);
+
+ if (toSegment.allPrevSegments.length >= 2) {
+ CodePathSegment.markPrevSegmentAsLooped(toSegment, fromSegment);
+ }
+
+ state.notifyLooped(fromSegment, toSegment);
+ }
+}
+
+/**
+ * Finalizes segments of `test` chunk of a ForStatement.
+ *
+ * - Adds `false` paths to paths which are leaving from the loop.
+ * - Sets `true` paths to paths which go to the body.
+ * @param {LoopContext} context A loop context to modify.
+ * @param {ChoiceContext} choiceContext A choice context of this loop.
+ * @param {CodePathSegment[]} head The current head paths.
+ * @returns {void}
+ */
+function finalizeTestSegmentsOfFor(context, choiceContext, head) {
+ if (!choiceContext.processed) {
+ choiceContext.trueForkContext.add(head);
+ choiceContext.falseForkContext.add(head);
+ }
+
+ if (context.test !== true) {
+ context.brokenForkContext.addAll(choiceContext.falseForkContext);
+ }
+ context.endOfTestSegments = choiceContext.trueForkContext.makeNext(0, -1);
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * A class which manages state to analyze code paths.
+ */
+class CodePathState {
+
+ // eslint-disable-next-line jsdoc/require-description
+ /**
+ * @param {IdGenerator} idGenerator An id generator to generate id for code
+ * path segments.
+ * @param {Function} onLooped A callback function to notify looping.
+ */
+ constructor(idGenerator, onLooped) {
+ this.idGenerator = idGenerator;
+ this.notifyLooped = onLooped;
+ this.forkContext = ForkContext.newRoot(idGenerator);
+ this.choiceContext = null;
+ this.switchContext = null;
+ this.tryContext = null;
+ this.loopContext = null;
+ this.breakContext = null;
+
+ this.currentSegments = [];
+ this.initialSegment = this.forkContext.head[0];
+
+ // returnedSegments and thrownSegments push elements into finalSegments also.
+ const final = this.finalSegments = [];
+ const returned = this.returnedForkContext = [];
+ const thrown = this.thrownForkContext = [];
+
+ returned.add = addToReturnedOrThrown.bind(null, returned, thrown, final);
+ thrown.add = addToReturnedOrThrown.bind(null, thrown, returned, final);
+ }
+
+ /**
+ * The head segments.
+ * @type {CodePathSegment[]}
+ */
+ get headSegments() {
+ return this.forkContext.head;
+ }
+
+ /**
+ * The parent forking context.
+ * This is used for the root of new forks.
+ * @type {ForkContext}
+ */
+ get parentForkContext() {
+ const current = this.forkContext;
+
+ return current && current.upper;
+ }
+
+ /**
+ * Creates and stacks new forking context.
+ * @param {boolean} forkLeavingPath A flag which shows being in a
+ * "finally" block.
+ * @returns {ForkContext} The created context.
+ */
+ pushForkContext(forkLeavingPath) {
+ this.forkContext = ForkContext.newEmpty(
+ this.forkContext,
+ forkLeavingPath
+ );
+
+ return this.forkContext;
+ }
+
+ /**
+ * Pops and merges the last forking context.
+ * @returns {ForkContext} The last context.
+ */
+ popForkContext() {
+ const lastContext = this.forkContext;
+
+ this.forkContext = lastContext.upper;
+ this.forkContext.replaceHead(lastContext.makeNext(0, -1));
+
+ return lastContext;
+ }
+
+ /**
+ * Creates a new path.
+ * @returns {void}
+ */
+ forkPath() {
+ this.forkContext.add(this.parentForkContext.makeNext(-1, -1));
+ }
+
+ /**
+ * Creates a bypass path.
+ * This is used for such as IfStatement which does not have "else" chunk.
+ * @returns {void}
+ */
+ forkBypassPath() {
+ this.forkContext.add(this.parentForkContext.head);
+ }
+
+ //--------------------------------------------------------------------------
+ // ConditionalExpression, LogicalExpression, IfStatement
+ //--------------------------------------------------------------------------
+
+ /**
+ * Creates a context for ConditionalExpression, LogicalExpression,
+ * IfStatement, WhileStatement, DoWhileStatement, or ForStatement.
+ *
+ * LogicalExpressions have cases that it goes different paths between the
+ * `true` case and the `false` case.
+ *
+ * For Example:
+ *
+ * if (a || b) {
+ * foo();
+ * } else {
+ * bar();
+ * }
+ *
+ * In this case, `b` is evaluated always in the code path of the `else`
+ * block, but it's not so in the code path of the `if` block.
+ * So there are 3 paths.
+ *
+ * a -> foo();
+ * a -> b -> foo();
+ * a -> b -> bar();
+ * @param {string} kind A kind string.
+ * If the new context is LogicalExpression's, this is `"&&"` or `"||"`.
+ * If it's IfStatement's or ConditionalExpression's, this is `"test"`.
+ * Otherwise, this is `"loop"`.
+ * @param {boolean} isForkingAsResult A flag that shows that goes different
+ * paths between `true` and `false`.
+ * @returns {void}
+ */
+ pushChoiceContext(kind, isForkingAsResult) {
+ this.choiceContext = {
+ upper: this.choiceContext,
+ kind,
+ isForkingAsResult,
+ trueForkContext: ForkContext.newEmpty(this.forkContext),
+ falseForkContext: ForkContext.newEmpty(this.forkContext),
+ processed: false
+ };
+ }
+
+ /**
+ * Pops the last choice context and finalizes it.
+ * @returns {ChoiceContext} The popped context.
+ */
+ popChoiceContext() {
+ const context = this.choiceContext;
+
+ this.choiceContext = context.upper;
+
+ const forkContext = this.forkContext;
+ const headSegments = forkContext.head;
+
+ switch (context.kind) {
+ case "&&":
+ case "||":
+
+ /*
+ * If any result were not transferred from child contexts,
+ * this sets the head segments to both cases.
+ * The head segments are the path of the right-hand operand.
+ */
+ if (!context.processed) {
+ context.trueForkContext.add(headSegments);
+ context.falseForkContext.add(headSegments);
+ }
+
+ /*
+ * Transfers results to upper context if this context is in
+ * test chunk.
+ */
+ if (context.isForkingAsResult) {
+ const parentContext = this.choiceContext;
+
+ parentContext.trueForkContext.addAll(context.trueForkContext);
+ parentContext.falseForkContext.addAll(context.falseForkContext);
+ parentContext.processed = true;
+
+ return context;
+ }
+
+ break;
+
+ case "test":
+ if (!context.processed) {
+
+ /*
+ * The head segments are the path of the `if` block here.
+ * Updates the `true` path with the end of the `if` block.
+ */
+ context.trueForkContext.clear();
+ context.trueForkContext.add(headSegments);
+ } else {
+
+ /*
+ * The head segments are the path of the `else` block here.
+ * Updates the `false` path with the end of the `else`
+ * block.
+ */
+ context.falseForkContext.clear();
+ context.falseForkContext.add(headSegments);
+ }
+
+ break;
+
+ case "loop":
+
+ /*
+ * Loops are addressed in popLoopContext().
+ * This is called from popLoopContext().
+ */
+ return context;
+
+ /* istanbul ignore next */
+ default:
+ throw new Error("unreachable");
+ }
+
+ // Merges all paths.
+ const prevForkContext = context.trueForkContext;
+
+ prevForkContext.addAll(context.falseForkContext);
+ forkContext.replaceHead(prevForkContext.makeNext(0, -1));
+
+ return context;
+ }
+
+ /**
+ * Makes a code path segment of the right-hand operand of a logical
+ * expression.
+ * @returns {void}
+ */
+ makeLogicalRight() {
+ const context = this.choiceContext;
+ const forkContext = this.forkContext;
+
+ if (context.processed) {
+
+ /*
+ * This got segments already from the child choice context.
+ * Creates the next path from own true/false fork context.
+ */
+ const prevForkContext =
+ context.kind === "&&" ? context.trueForkContext
+ /* kind === "||" */ : context.falseForkContext;
+
+ forkContext.replaceHead(prevForkContext.makeNext(0, -1));
+ prevForkContext.clear();
+
+ context.processed = false;
+ } else {
+
+ /*
+ * This did not get segments from the child choice context.
+ * So addresses the head segments.
+ * The head segments are the path of the left-hand operand.
+ */
+ if (context.kind === "&&") {
+
+ // The path does short-circuit if false.
+ context.falseForkContext.add(forkContext.head);
+ } else {
+
+ // The path does short-circuit if true.
+ context.trueForkContext.add(forkContext.head);
+ }
+
+ forkContext.replaceHead(forkContext.makeNext(-1, -1));
+ }
+ }
+
+ /**
+ * Makes a code path segment of the `if` block.
+ * @returns {void}
+ */
+ makeIfConsequent() {
+ const context = this.choiceContext;
+ const forkContext = this.forkContext;
+
+ /*
+ * If any result were not transferred from child contexts,
+ * this sets the head segments to both cases.
+ * The head segments are the path of the test expression.
+ */
+ if (!context.processed) {
+ context.trueForkContext.add(forkContext.head);
+ context.falseForkContext.add(forkContext.head);
+ }
+
+ context.processed = false;
+
+ // Creates new path from the `true` case.
+ forkContext.replaceHead(
+ context.trueForkContext.makeNext(0, -1)
+ );
+ }
+
+ /**
+ * Makes a code path segment of the `else` block.
+ * @returns {void}
+ */
+ makeIfAlternate() {
+ const context = this.choiceContext;
+ const forkContext = this.forkContext;
+
+ /*
+ * The head segments are the path of the `if` block.
+ * Updates the `true` path with the end of the `if` block.
+ */
+ context.trueForkContext.clear();
+ context.trueForkContext.add(forkContext.head);
+ context.processed = true;
+
+ // Creates new path from the `false` case.
+ forkContext.replaceHead(
+ context.falseForkContext.makeNext(0, -1)
+ );
+ }
+
+ //--------------------------------------------------------------------------
+ // SwitchStatement
+ //--------------------------------------------------------------------------
+
+ /**
+ * Creates a context object of SwitchStatement and stacks it.
+ * @param {boolean} hasCase `true` if the switch statement has one or more
+ * case parts.
+ * @param {string|null} label The label text.
+ * @returns {void}
+ */
+ pushSwitchContext(hasCase, label) {
+ this.switchContext = {
+ upper: this.switchContext,
+ hasCase,
+ defaultSegments: null,
+ defaultBodySegments: null,
+ foundDefault: false,
+ lastIsDefault: false,
+ countForks: 0
+ };
+
+ this.pushBreakContext(true, label);
+ }
+
+ /**
+ * Pops the last context of SwitchStatement and finalizes it.
+ *
+ * - Disposes all forking stack for `case` and `default`.
+ * - Creates the next code path segment from `context.brokenForkContext`.
+ * - If the last `SwitchCase` node is not a `default` part, creates a path
+ * to the `default` body.
+ * @returns {void}
+ */
+ popSwitchContext() {
+ const context = this.switchContext;
+
+ this.switchContext = context.upper;
+
+ const forkContext = this.forkContext;
+ const brokenForkContext = this.popBreakContext().brokenForkContext;
+
+ if (context.countForks === 0) {
+
+ /*
+ * When there is only one `default` chunk and there is one or more
+ * `break` statements, even if forks are nothing, it needs to merge
+ * those.
+ */
+ if (!brokenForkContext.empty) {
+ brokenForkContext.add(forkContext.makeNext(-1, -1));
+ forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
+ }
+
+ return;
+ }
+
+ const lastSegments = forkContext.head;
+
+ this.forkBypassPath();
+ const lastCaseSegments = forkContext.head;
+
+ /*
+ * `brokenForkContext` is used to make the next segment.
+ * It must add the last segment into `brokenForkContext`.
+ */
+ brokenForkContext.add(lastSegments);
+
+ /*
+ * A path which is failed in all case test should be connected to path
+ * of `default` chunk.
+ */
+ if (!context.lastIsDefault) {
+ if (context.defaultBodySegments) {
+
+ /*
+ * Remove a link from `default` label to its chunk.
+ * It's false route.
+ */
+ removeConnection(context.defaultSegments, context.defaultBodySegments);
+ makeLooped(this, lastCaseSegments, context.defaultBodySegments);
+ } else {
+
+ /*
+ * It handles the last case body as broken if `default` chunk
+ * does not exist.
+ */
+ brokenForkContext.add(lastCaseSegments);
+ }
+ }
+
+ // Pops the segment context stack until the entry segment.
+ for (let i = 0; i < context.countForks; ++i) {
+ this.forkContext = this.forkContext.upper;
+ }
+
+ /*
+ * Creates a path from all brokenForkContext paths.
+ * This is a path after switch statement.
+ */
+ this.forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
+ }
+
+ /**
+ * Makes a code path segment for a `SwitchCase` node.
+ * @param {boolean} isEmpty `true` if the body is empty.
+ * @param {boolean} isDefault `true` if the body is the default case.
+ * @returns {void}
+ */
+ makeSwitchCaseBody(isEmpty, isDefault) {
+ const context = this.switchContext;
+
+ if (!context.hasCase) {
+ return;
+ }
+
+ /*
+ * Merge forks.
+ * The parent fork context has two segments.
+ * Those are from the current case and the body of the previous case.
+ */
+ const parentForkContext = this.forkContext;
+ const forkContext = this.pushForkContext();
+
+ forkContext.add(parentForkContext.makeNext(0, -1));
+
+ /*
+ * Save `default` chunk info.
+ * If the `default` label is not at the last, we must make a path from
+ * the last `case` to the `default` chunk.
+ */
+ if (isDefault) {
+ context.defaultSegments = parentForkContext.head;
+ if (isEmpty) {
+ context.foundDefault = true;
+ } else {
+ context.defaultBodySegments = forkContext.head;
+ }
+ } else {
+ if (!isEmpty && context.foundDefault) {
+ context.foundDefault = false;
+ context.defaultBodySegments = forkContext.head;
+ }
+ }
+
+ context.lastIsDefault = isDefault;
+ context.countForks += 1;
+ }
+
+ //--------------------------------------------------------------------------
+ // TryStatement
+ //--------------------------------------------------------------------------
+
+ /**
+ * Creates a context object of TryStatement and stacks it.
+ * @param {boolean} hasFinalizer `true` if the try statement has a
+ * `finally` block.
+ * @returns {void}
+ */
+ pushTryContext(hasFinalizer) {
+ this.tryContext = {
+ upper: this.tryContext,
+ position: "try",
+ hasFinalizer,
+
+ returnedForkContext: hasFinalizer
+ ? ForkContext.newEmpty(this.forkContext)
+ : null,
+
+ thrownForkContext: ForkContext.newEmpty(this.forkContext),
+ lastOfTryIsReachable: false,
+ lastOfCatchIsReachable: false
+ };
+ }
+
+ /**
+ * Pops the last context of TryStatement and finalizes it.
+ * @returns {void}
+ */
+ popTryContext() {
+ const context = this.tryContext;
+
+ this.tryContext = context.upper;
+
+ if (context.position === "catch") {
+
+ // Merges two paths from the `try` block and `catch` block merely.
+ this.popForkContext();
+ return;
+ }
+
+ /*
+ * The following process is executed only when there is the `finally`
+ * block.
+ */
+
+ const returned = context.returnedForkContext;
+ const thrown = context.thrownForkContext;
+
+ if (returned.empty && thrown.empty) {
+ return;
+ }
+
+ // Separate head to normal paths and leaving paths.
+ const headSegments = this.forkContext.head;
+
+ this.forkContext = this.forkContext.upper;
+ const normalSegments = headSegments.slice(0, headSegments.length / 2 | 0);
+ const leavingSegments = headSegments.slice(headSegments.length / 2 | 0);
+
+ // Forwards the leaving path to upper contexts.
+ if (!returned.empty) {
+ getReturnContext(this).returnedForkContext.add(leavingSegments);
+ }
+ if (!thrown.empty) {
+ getThrowContext(this).thrownForkContext.add(leavingSegments);
+ }
+
+ // Sets the normal path as the next.
+ this.forkContext.replaceHead(normalSegments);
+
+ /*
+ * If both paths of the `try` block and the `catch` block are
+ * unreachable, the next path becomes unreachable as well.
+ */
+ if (!context.lastOfTryIsReachable && !context.lastOfCatchIsReachable) {
+ this.forkContext.makeUnreachable();
+ }
+ }
+
+ /**
+ * Makes a code path segment for a `catch` block.
+ * @returns {void}
+ */
+ makeCatchBlock() {
+ const context = this.tryContext;
+ const forkContext = this.forkContext;
+ const thrown = context.thrownForkContext;
+
+ // Update state.
+ context.position = "catch";
+ context.thrownForkContext = ForkContext.newEmpty(forkContext);
+ context.lastOfTryIsReachable = forkContext.reachable;
+
+ // Merge thrown paths.
+ thrown.add(forkContext.head);
+ const thrownSegments = thrown.makeNext(0, -1);
+
+ // Fork to a bypass and the merged thrown path.
+ this.pushForkContext();
+ this.forkBypassPath();
+ this.forkContext.add(thrownSegments);
+ }
+
+ /**
+ * Makes a code path segment for a `finally` block.
+ *
+ * In the `finally` block, parallel paths are created. The parallel paths
+ * are used as leaving-paths. The leaving-paths are paths from `return`
+ * statements and `throw` statements in a `try` block or a `catch` block.
+ * @returns {void}
+ */
+ makeFinallyBlock() {
+ const context = this.tryContext;
+ let forkContext = this.forkContext;
+ const returned = context.returnedForkContext;
+ const thrown = context.thrownForkContext;
+ const headOfLeavingSegments = forkContext.head;
+
+ // Update state.
+ if (context.position === "catch") {
+
+ // Merges two paths from the `try` block and `catch` block.
+ this.popForkContext();
+ forkContext = this.forkContext;
+
+ context.lastOfCatchIsReachable = forkContext.reachable;
+ } else {
+ context.lastOfTryIsReachable = forkContext.reachable;
+ }
+ context.position = "finally";
+
+ if (returned.empty && thrown.empty) {
+
+ // This path does not leave.
+ return;
+ }
+
+ /*
+ * Create a parallel segment from merging returned and thrown.
+ * This segment will leave at the end of this finally block.
+ */
+ const segments = forkContext.makeNext(-1, -1);
+
+ for (let i = 0; i < forkContext.count; ++i) {
+ const prevSegsOfLeavingSegment = [headOfLeavingSegments[i]];
+
+ for (let j = 0; j < returned.segmentsList.length; ++j) {
+ prevSegsOfLeavingSegment.push(returned.segmentsList[j][i]);
+ }
+ for (let j = 0; j < thrown.segmentsList.length; ++j) {
+ prevSegsOfLeavingSegment.push(thrown.segmentsList[j][i]);
+ }
+
+ segments.push(
+ CodePathSegment.newNext(
+ this.idGenerator.next(),
+ prevSegsOfLeavingSegment
+ )
+ );
+ }
+
+ this.pushForkContext(true);
+ this.forkContext.add(segments);
+ }
+
+ /**
+ * Makes a code path segment from the first throwable node to the `catch`
+ * block or the `finally` block.
+ * @returns {void}
+ */
+ makeFirstThrowablePathInTryBlock() {
+ const forkContext = this.forkContext;
+
+ if (!forkContext.reachable) {
+ return;
+ }
+
+ const context = getThrowContext(this);
+
+ if (context === this ||
+ context.position !== "try" ||
+ !context.thrownForkContext.empty
+ ) {
+ return;
+ }
+
+ context.thrownForkContext.add(forkContext.head);
+ forkContext.replaceHead(forkContext.makeNext(-1, -1));
+ }
+
+ //--------------------------------------------------------------------------
+ // Loop Statements
+ //--------------------------------------------------------------------------
+
+ /**
+ * Creates a context object of a loop statement and stacks it.
+ * @param {string} type The type of the node which was triggered. One of
+ * `WhileStatement`, `DoWhileStatement`, `ForStatement`, `ForInStatement`,
+ * and `ForStatement`.
+ * @param {string|null} label A label of the node which was triggered.
+ * @returns {void}
+ */
+ pushLoopContext(type, label) {
+ const forkContext = this.forkContext;
+ const breakContext = this.pushBreakContext(true, label);
+
+ switch (type) {
+ case "WhileStatement":
+ this.pushChoiceContext("loop", false);
+ this.loopContext = {
+ upper: this.loopContext,
+ type,
+ label,
+ test: void 0,
+ continueDestSegments: null,
+ brokenForkContext: breakContext.brokenForkContext
+ };
+ break;
+
+ case "DoWhileStatement":
+ this.pushChoiceContext("loop", false);
+ this.loopContext = {
+ upper: this.loopContext,
+ type,
+ label,
+ test: void 0,
+ entrySegments: null,
+ continueForkContext: ForkContext.newEmpty(forkContext),
+ brokenForkContext: breakContext.brokenForkContext
+ };
+ break;
+
+ case "ForStatement":
+ this.pushChoiceContext("loop", false);
+ this.loopContext = {
+ upper: this.loopContext,
+ type,
+ label,
+ test: void 0,
+ endOfInitSegments: null,
+ testSegments: null,
+ endOfTestSegments: null,
+ updateSegments: null,
+ endOfUpdateSegments: null,
+ continueDestSegments: null,
+ brokenForkContext: breakContext.brokenForkContext
+ };
+ break;
+
+ case "ForInStatement":
+ case "ForOfStatement":
+ this.loopContext = {
+ upper: this.loopContext,
+ type,
+ label,
+ prevSegments: null,
+ leftSegments: null,
+ endOfLeftSegments: null,
+ continueDestSegments: null,
+ brokenForkContext: breakContext.brokenForkContext
+ };
+ break;
+
+ /* istanbul ignore next */
+ default:
+ throw new Error(`unknown type: "${type}"`);
+ }
+ }
+
+ /**
+ * Pops the last context of a loop statement and finalizes it.
+ * @returns {void}
+ */
+ popLoopContext() {
+ const context = this.loopContext;
+
+ this.loopContext = context.upper;
+
+ const forkContext = this.forkContext;
+ const brokenForkContext = this.popBreakContext().brokenForkContext;
+
+ // Creates a looped path.
+ switch (context.type) {
+ case "WhileStatement":
+ case "ForStatement":
+ this.popChoiceContext();
+ makeLooped(
+ this,
+ forkContext.head,
+ context.continueDestSegments
+ );
+ break;
+
+ case "DoWhileStatement": {
+ const choiceContext = this.popChoiceContext();
+
+ if (!choiceContext.processed) {
+ choiceContext.trueForkContext.add(forkContext.head);
+ choiceContext.falseForkContext.add(forkContext.head);
+ }
+ if (context.test !== true) {
+ brokenForkContext.addAll(choiceContext.falseForkContext);
+ }
+
+ // `true` paths go to looping.
+ const segmentsList = choiceContext.trueForkContext.segmentsList;
+
+ for (let i = 0; i < segmentsList.length; ++i) {
+ makeLooped(
+ this,
+ segmentsList[i],
+ context.entrySegments
+ );
+ }
+ break;
+ }
+
+ case "ForInStatement":
+ case "ForOfStatement":
+ brokenForkContext.add(forkContext.head);
+ makeLooped(
+ this,
+ forkContext.head,
+ context.leftSegments
+ );
+ break;
+
+ /* istanbul ignore next */
+ default:
+ throw new Error("unreachable");
+ }
+
+ // Go next.
+ if (brokenForkContext.empty) {
+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
+ } else {
+ forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
+ }
+ }
+
+ /**
+ * Makes a code path segment for the test part of a WhileStatement.
+ * @param {boolean|undefined} test The test value (only when constant).
+ * @returns {void}
+ */
+ makeWhileTest(test) {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+ const testSegments = forkContext.makeNext(0, -1);
+
+ // Update state.
+ context.test = test;
+ context.continueDestSegments = testSegments;
+ forkContext.replaceHead(testSegments);
+ }
+
+ /**
+ * Makes a code path segment for the body part of a WhileStatement.
+ * @returns {void}
+ */
+ makeWhileBody() {
+ const context = this.loopContext;
+ const choiceContext = this.choiceContext;
+ const forkContext = this.forkContext;
+
+ if (!choiceContext.processed) {
+ choiceContext.trueForkContext.add(forkContext.head);
+ choiceContext.falseForkContext.add(forkContext.head);
+ }
+
+ // Update state.
+ if (context.test !== true) {
+ context.brokenForkContext.addAll(choiceContext.falseForkContext);
+ }
+ forkContext.replaceHead(choiceContext.trueForkContext.makeNext(0, -1));
+ }
+
+ /**
+ * Makes a code path segment for the body part of a DoWhileStatement.
+ * @returns {void}
+ */
+ makeDoWhileBody() {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+ const bodySegments = forkContext.makeNext(-1, -1);
+
+ // Update state.
+ context.entrySegments = bodySegments;
+ forkContext.replaceHead(bodySegments);
+ }
+
+ /**
+ * Makes a code path segment for the test part of a DoWhileStatement.
+ * @param {boolean|undefined} test The test value (only when constant).
+ * @returns {void}
+ */
+ makeDoWhileTest(test) {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+
+ context.test = test;
+
+ // Creates paths of `continue` statements.
+ if (!context.continueForkContext.empty) {
+ context.continueForkContext.add(forkContext.head);
+ const testSegments = context.continueForkContext.makeNext(0, -1);
+
+ forkContext.replaceHead(testSegments);
+ }
+ }
+
+ /**
+ * Makes a code path segment for the test part of a ForStatement.
+ * @param {boolean|undefined} test The test value (only when constant).
+ * @returns {void}
+ */
+ makeForTest(test) {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+ const endOfInitSegments = forkContext.head;
+ const testSegments = forkContext.makeNext(-1, -1);
+
+ // Update state.
+ context.test = test;
+ context.endOfInitSegments = endOfInitSegments;
+ context.continueDestSegments = context.testSegments = testSegments;
+ forkContext.replaceHead(testSegments);
+ }
+
+ /**
+ * Makes a code path segment for the update part of a ForStatement.
+ * @returns {void}
+ */
+ makeForUpdate() {
+ const context = this.loopContext;
+ const choiceContext = this.choiceContext;
+ const forkContext = this.forkContext;
+
+ // Make the next paths of the test.
+ if (context.testSegments) {
+ finalizeTestSegmentsOfFor(
+ context,
+ choiceContext,
+ forkContext.head
+ );
+ } else {
+ context.endOfInitSegments = forkContext.head;
+ }
+
+ // Update state.
+ const updateSegments = forkContext.makeDisconnected(-1, -1);
+
+ context.continueDestSegments = context.updateSegments = updateSegments;
+ forkContext.replaceHead(updateSegments);
+ }
+
+ /**
+ * Makes a code path segment for the body part of a ForStatement.
+ * @returns {void}
+ */
+ makeForBody() {
+ const context = this.loopContext;
+ const choiceContext = this.choiceContext;
+ const forkContext = this.forkContext;
+
+ // Update state.
+ if (context.updateSegments) {
+ context.endOfUpdateSegments = forkContext.head;
+
+ // `update` -> `test`
+ if (context.testSegments) {
+ makeLooped(
+ this,
+ context.endOfUpdateSegments,
+ context.testSegments
+ );
+ }
+ } else if (context.testSegments) {
+ finalizeTestSegmentsOfFor(
+ context,
+ choiceContext,
+ forkContext.head
+ );
+ } else {
+ context.endOfInitSegments = forkContext.head;
+ }
+
+ let bodySegments = context.endOfTestSegments;
+
+ if (!bodySegments) {
+
+ /*
+ * If there is not the `test` part, the `body` path comes from the
+ * `init` part and the `update` part.
+ */
+ const prevForkContext = ForkContext.newEmpty(forkContext);
+
+ prevForkContext.add(context.endOfInitSegments);
+ if (context.endOfUpdateSegments) {
+ prevForkContext.add(context.endOfUpdateSegments);
+ }
+
+ bodySegments = prevForkContext.makeNext(0, -1);
+ }
+ context.continueDestSegments = context.continueDestSegments || bodySegments;
+ forkContext.replaceHead(bodySegments);
+ }
+
+ /**
+ * Makes a code path segment for the left part of a ForInStatement and a
+ * ForOfStatement.
+ * @returns {void}
+ */
+ makeForInOfLeft() {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+ const leftSegments = forkContext.makeDisconnected(-1, -1);
+
+ // Update state.
+ context.prevSegments = forkContext.head;
+ context.leftSegments = context.continueDestSegments = leftSegments;
+ forkContext.replaceHead(leftSegments);
+ }
+
+ /**
+ * Makes a code path segment for the right part of a ForInStatement and a
+ * ForOfStatement.
+ * @returns {void}
+ */
+ makeForInOfRight() {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+ const temp = ForkContext.newEmpty(forkContext);
+
+ temp.add(context.prevSegments);
+ const rightSegments = temp.makeNext(-1, -1);
+
+ // Update state.
+ context.endOfLeftSegments = forkContext.head;
+ forkContext.replaceHead(rightSegments);
+ }
+
+ /**
+ * Makes a code path segment for the body part of a ForInStatement and a
+ * ForOfStatement.
+ * @returns {void}
+ */
+ makeForInOfBody() {
+ const context = this.loopContext;
+ const forkContext = this.forkContext;
+ const temp = ForkContext.newEmpty(forkContext);
+
+ temp.add(context.endOfLeftSegments);
+ const bodySegments = temp.makeNext(-1, -1);
+
+ // Make a path: `right` -> `left`.
+ makeLooped(this, forkContext.head, context.leftSegments);
+
+ // Update state.
+ context.brokenForkContext.add(forkContext.head);
+ forkContext.replaceHead(bodySegments);
+ }
+
+ //--------------------------------------------------------------------------
+ // Control Statements
+ //--------------------------------------------------------------------------
+
+ /**
+ * Creates new context for BreakStatement.
+ * @param {boolean} breakable The flag to indicate it can break by
+ * an unlabeled BreakStatement.
+ * @param {string|null} label The label of this context.
+ * @returns {Object} The new context.
+ */
+ pushBreakContext(breakable, label) {
+ this.breakContext = {
+ upper: this.breakContext,
+ breakable,
+ label,
+ brokenForkContext: ForkContext.newEmpty(this.forkContext)
+ };
+ return this.breakContext;
+ }
+
+ /**
+ * Removes the top item of the break context stack.
+ * @returns {Object} The removed context.
+ */
+ popBreakContext() {
+ const context = this.breakContext;
+ const forkContext = this.forkContext;
+
+ this.breakContext = context.upper;
+
+ // Process this context here for other than switches and loops.
+ if (!context.breakable) {
+ const brokenForkContext = context.brokenForkContext;
+
+ if (!brokenForkContext.empty) {
+ brokenForkContext.add(forkContext.head);
+ forkContext.replaceHead(brokenForkContext.makeNext(0, -1));
+ }
+ }
+
+ return context;
+ }
+
+ /**
+ * Makes a path for a `break` statement.
+ *
+ * It registers the head segment to a context of `break`.
+ * It makes new unreachable segment, then it set the head with the segment.
+ * @param {string} label A label of the break statement.
+ * @returns {void}
+ */
+ makeBreak(label) {
+ const forkContext = this.forkContext;
+
+ if (!forkContext.reachable) {
+ return;
+ }
+
+ const context = getBreakContext(this, label);
+
+ /* istanbul ignore else: foolproof (syntax error) */
+ if (context) {
+ context.brokenForkContext.add(forkContext.head);
+ }
+
+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
+ }
+
+ /**
+ * Makes a path for a `continue` statement.
+ *
+ * It makes a looping path.
+ * It makes new unreachable segment, then it set the head with the segment.
+ * @param {string} label A label of the continue statement.
+ * @returns {void}
+ */
+ makeContinue(label) {
+ const forkContext = this.forkContext;
+
+ if (!forkContext.reachable) {
+ return;
+ }
+
+ const context = getContinueContext(this, label);
+
+ /* istanbul ignore else: foolproof (syntax error) */
+ if (context) {
+ if (context.continueDestSegments) {
+ makeLooped(this, forkContext.head, context.continueDestSegments);
+
+ // If the context is a for-in/of loop, this effects a break also.
+ if (context.type === "ForInStatement" ||
+ context.type === "ForOfStatement"
+ ) {
+ context.brokenForkContext.add(forkContext.head);
+ }
+ } else {
+ context.continueForkContext.add(forkContext.head);
+ }
+ }
+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
+ }
+
+ /**
+ * Makes a path for a `return` statement.
+ *
+ * It registers the head segment to a context of `return`.
+ * It makes new unreachable segment, then it set the head with the segment.
+ * @returns {void}
+ */
+ makeReturn() {
+ const forkContext = this.forkContext;
+
+ if (forkContext.reachable) {
+ getReturnContext(this).returnedForkContext.add(forkContext.head);
+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
+ }
+ }
+
+ /**
+ * Makes a path for a `throw` statement.
+ *
+ * It registers the head segment to a context of `throw`.
+ * It makes new unreachable segment, then it set the head with the segment.
+ * @returns {void}
+ */
+ makeThrow() {
+ const forkContext = this.forkContext;
+
+ if (forkContext.reachable) {
+ getThrowContext(this).thrownForkContext.add(forkContext.head);
+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
+ }
+ }
+
+ /**
+ * Makes the final path.
+ * @returns {void}
+ */
+ makeFinal() {
+ const segments = this.currentSegments;
+
+ if (segments.length > 0 && segments[0].reachable) {
+ this.returnedForkContext.add(segments);
+ }
+ }
+}
+
+module.exports = CodePathState;
projects / dotfiles / .git / blobdiff