+++ /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