/** * @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"); //----------------------------------------------------------------------------- // Contexts //----------------------------------------------------------------------------- /** * Represents the context in which a `break` statement can be used. * * A `break` statement without a label is only valid in a few places in * JavaScript: any type of loop or a `switch` statement. Otherwise, `break` * without a label causes a syntax error. For these contexts, `breakable` is * set to `true` to indicate that a `break` without a label is valid. * * However, a `break` statement with a label is also valid inside of a labeled * statement. For example, this is valid: * * a : { * break a; * } * * The `breakable` property is set false for labeled statements to indicate * that `break` without a label is invalid. */ class BreakContext { /** * Creates a new instance. * @param {BreakContext} upperContext The previous `BreakContext`. * @param {boolean} breakable Indicates if we are inside a statement where * `break` without a label will exit the statement. * @param {string|null} label The label for the statement. * @param {ForkContext} forkContext The current fork context. */ constructor(upperContext, breakable, label, forkContext) { /** * The previous `BreakContext` * @type {BreakContext} */ this.upper = upperContext; /** * Indicates if we are inside a statement where `break` without a label * will exit the statement. * @type {boolean} */ this.breakable = breakable; /** * The label associated with the statement. * @type {string|null} */ this.label = label; /** * The fork context for the `break`. * @type {ForkContext} */ this.brokenForkContext = ForkContext.newEmpty(forkContext); } } /** * Represents the context for `ChainExpression` nodes. */ class ChainContext { /** * Creates a new instance. * @param {ChainContext} upperContext The previous `ChainContext`. */ constructor(upperContext) { /** * The previous `ChainContext` * @type {ChainContext} */ this.upper = upperContext; /** * The number of choice contexts inside of the `ChainContext`. * @type {number} */ this.choiceContextCount = 0; } } /** * Represents a choice in the code path. * * Choices are created by logical operators such as `&&`, loops, conditionals, * and `if` statements. This is the point at which the code path has a choice of * which direction to go. * * The result of a choice might be in the left (test) expression of another choice, * and in that case, may create a new fork. For example, `a || b` is a choice * but does not create a new fork because the result of the expression is * not used as the test expression in another expression. In this case, * `isForkingAsResult` is false. In the expression `a || b || c`, the `a || b` * expression appears as the test expression for `|| c`, so the * result of `a || b` creates a fork because execution may or may not * continue to `|| c`. `isForkingAsResult` for `a || b` in this case is true * while `isForkingAsResult` for `|| c` is false. (`isForkingAsResult` is always * false for `if` statements, conditional expressions, and loops.) * * All of the choices except one (`??`) operate on a true/false fork, meaning if * true go one way and if false go the other (tracked by `trueForkContext` and * `falseForkContext`). The `??` operator doesn't operate on true/false because * the left expression is evaluated to be nullish or not, so only if nullish do * we fork to the right expression (tracked by `nullishForkContext`). */ class ChoiceContext { /** * Creates a new instance. * @param {ChoiceContext} upperContext The previous `ChoiceContext`. * @param {string} kind The kind of choice. If it's a logical or assignment expression, this * is `"&&"` or `"||"` or `"??"`; if it's an `if` statement or * conditional expression, this is `"test"`; otherwise, this is `"loop"`. * @param {boolean} isForkingAsResult Indicates if the result of the choice * creates a fork. * @param {ForkContext} forkContext The containing `ForkContext`. */ constructor(upperContext, kind, isForkingAsResult, forkContext) { /** * The previous `ChoiceContext` * @type {ChoiceContext} */ this.upper = upperContext; /** * The kind of choice. If it's a logical or assignment expression, this * is `"&&"` or `"||"` or `"??"`; if it's an `if` statement or * conditional expression, this is `"test"`; otherwise, this is `"loop"`. * @type {string} */ this.kind = kind; /** * Indicates if the result of the choice forks the code path. * @type {boolean} */ this.isForkingAsResult = isForkingAsResult; /** * The fork context for the `true` path of the choice. * @type {ForkContext} */ this.trueForkContext = ForkContext.newEmpty(forkContext); /** * The fork context for the `false` path of the choice. * @type {ForkContext} */ this.falseForkContext = ForkContext.newEmpty(forkContext); /** * The fork context for when the choice result is `null` or `undefined`. * @type {ForkContext} */ this.nullishForkContext = ForkContext.newEmpty(forkContext); /** * Indicates if any of `trueForkContext`, `falseForkContext`, or * `nullishForkContext` have been updated with segments from a child context. * @type {boolean} */ this.processed = false; } } /** * Base class for all loop contexts. */ class LoopContextBase { /** * Creates a new instance. * @param {LoopContext|null} upperContext The previous `LoopContext`. * @param {string} type The AST node's `type` for the loop. * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. * @param {BreakContext} breakContext The context for breaking the loop. */ constructor(upperContext, type, label, breakContext) { /** * The previous `LoopContext`. * @type {LoopContext} */ this.upper = upperContext; /** * The AST node's `type` for the loop. * @type {string} */ this.type = type; /** * The label for the loop from an enclosing `LabeledStatement`. * @type {string|null} */ this.label = label; /** * The fork context for when `break` is encountered. * @type {ForkContext} */ this.brokenForkContext = breakContext.brokenForkContext; } } /** * Represents the context for a `while` loop. */ class WhileLoopContext extends LoopContextBase { /** * Creates a new instance. * @param {LoopContext|null} upperContext The previous `LoopContext`. * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. * @param {BreakContext} breakContext The context for breaking the loop. */ constructor(upperContext, label, breakContext) { super(upperContext, "WhileStatement", label, breakContext); /** * The hardcoded literal boolean test condition for * the loop. Used to catch infinite or skipped loops. * @type {boolean|undefined} */ this.test = void 0; /** * The segments representing the test condition where `continue` will * jump to. The test condition will typically have just one segment but * it's possible for there to be more than one. * @type {Array|null} */ this.continueDestSegments = null; } } /** * Represents the context for a `do-while` loop. */ class DoWhileLoopContext extends LoopContextBase { /** * Creates a new instance. * @param {LoopContext|null} upperContext The previous `LoopContext`. * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. * @param {BreakContext} breakContext The context for breaking the loop. * @param {ForkContext} forkContext The enclosing fork context. */ constructor(upperContext, label, breakContext, forkContext) { super(upperContext, "DoWhileStatement", label, breakContext); /** * The hardcoded literal boolean test condition for * the loop. Used to catch infinite or skipped loops. * @type {boolean|undefined} */ this.test = void 0; /** * The segments at the start of the loop body. This is the only loop * where the test comes at the end, so the first iteration always * happens and we need a reference to the first statements. * @type {Array|null} */ this.entrySegments = null; /** * The fork context to follow when a `continue` is found. * @type {ForkContext} */ this.continueForkContext = ForkContext.newEmpty(forkContext); } } /** * Represents the context for a `for` loop. */ class ForLoopContext extends LoopContextBase { /** * Creates a new instance. * @param {LoopContext|null} upperContext The previous `LoopContext`. * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. * @param {BreakContext} breakContext The context for breaking the loop. */ constructor(upperContext, label, breakContext) { super(upperContext, "ForStatement", label, breakContext); /** * The hardcoded literal boolean test condition for * the loop. Used to catch infinite or skipped loops. * @type {boolean|undefined} */ this.test = void 0; /** * The end of the init expression. This may change during the lifetime * of the instance as we traverse the loop because some loops don't have * an init expression. * @type {Array|null} */ this.endOfInitSegments = null; /** * The start of the test expression. This may change during the lifetime * of the instance as we traverse the loop because some loops don't have * a test expression. * @type {Array|null} */ this.testSegments = null; /** * The end of the test expression. This may change during the lifetime * of the instance as we traverse the loop because some loops don't have * a test expression. * @type {Array|null} */ this.endOfTestSegments = null; /** * The start of the update expression. This may change during the lifetime * of the instance as we traverse the loop because some loops don't have * an update expression. * @type {Array|null} */ this.updateSegments = null; /** * The end of the update expresion. This may change during the lifetime * of the instance as we traverse the loop because some loops don't have * an update expression. * @type {Array|null} */ this.endOfUpdateSegments = null; /** * The segments representing the test condition where `continue` will * jump to. The test condition will typically have just one segment but * it's possible for there to be more than one. This may change during the * lifetime of the instance as we traverse the loop because some loops * don't have an update expression. When there is an update expression, this * will end up pointing to that expression; otherwise it will end up pointing * to the test expression. * @type {Array|null} */ this.continueDestSegments = null; } } /** * Represents the context for a `for-in` loop. * * Terminology: * - "left" means the part of the loop to the left of the `in` keyword. For * example, in `for (var x in y)`, the left is `var x`. * - "right" means the part of the loop to the right of the `in` keyword. For * example, in `for (var x in y)`, the right is `y`. */ class ForInLoopContext extends LoopContextBase { /** * Creates a new instance. * @param {LoopContext|null} upperContext The previous `LoopContext`. * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. * @param {BreakContext} breakContext The context for breaking the loop. */ constructor(upperContext, label, breakContext) { super(upperContext, "ForInStatement", label, breakContext); /** * The segments that came immediately before the start of the loop. * This allows you to traverse backwards out of the loop into the * surrounding code. This is necessary to evaluate the right expression * correctly, as it must be evaluated in the same way as the left * expression, but the pointer to these segments would otherwise be * lost if not stored on the instance. Once the right expression has * been evaluated, this property is no longer used. * @type {Array|null} */ this.prevSegments = null; /** * Segments representing the start of everything to the left of the * `in` keyword. This can be used to move forward towards * `endOfLeftSegments`. `leftSegments` and `endOfLeftSegments` are * effectively the head and tail of a doubly-linked list. * @type {Array|null} */ this.leftSegments = null; /** * Segments representing the end of everything to the left of the * `in` keyword. This can be used to move backward towards `leftSegments`. * `leftSegments` and `endOfLeftSegments` are effectively the head * and tail of a doubly-linked list. * @type {Array|null} */ this.endOfLeftSegments = null; /** * The segments representing the left expression where `continue` will * jump to. In `for-in` loops, `continue` must always re-execute the * left expression each time through the loop. This contains the same * segments as `leftSegments`, but is duplicated here so each loop * context has the same property pointing to where `continue` should * end up. * @type {Array|null} */ this.continueDestSegments = null; } } /** * Represents the context for a `for-of` loop. */ class ForOfLoopContext extends LoopContextBase { /** * Creates a new instance. * @param {LoopContext|null} upperContext The previous `LoopContext`. * @param {string|null} label The label for the loop from an enclosing `LabeledStatement`. * @param {BreakContext} breakContext The context for breaking the loop. */ constructor(upperContext, label, breakContext) { super(upperContext, "ForOfStatement", label, breakContext); /** * The segments that came immediately before the start of the loop. * This allows you to traverse backwards out of the loop into the * surrounding code. This is necessary to evaluate the right expression * correctly, as it must be evaluated in the same way as the left * expression, but the pointer to these segments would otherwise be * lost if not stored on the instance. Once the right expression has * been evaluated, this property is no longer used. * @type {Array|null} */ this.prevSegments = null; /** * Segments representing the start of everything to the left of the * `of` keyword. This can be used to move forward towards * `endOfLeftSegments`. `leftSegments` and `endOfLeftSegments` are * effectively the head and tail of a doubly-linked list. * @type {Array|null} */ this.leftSegments = null; /** * Segments representing the end of everything to the left of the * `of` keyword. This can be used to move backward towards `leftSegments`. * `leftSegments` and `endOfLeftSegments` are effectively the head * and tail of a doubly-linked list. * @type {Array|null} */ this.endOfLeftSegments = null; /** * The segments representing the left expression where `continue` will * jump to. In `for-in` loops, `continue` must always re-execute the * left expression each time through the loop. This contains the same * segments as `leftSegments`, but is duplicated here so each loop * context has the same property pointing to where `continue` should * end up. * @type {Array|null} */ this.continueDestSegments = null; } } /** * Represents the context for any loop. * @typedef {WhileLoopContext|DoWhileLoopContext|ForLoopContext|ForInLoopContext|ForOfLoopContext} LoopContext */ /** * Represents the context for a `switch` statement. */ class SwitchContext { /** * Creates a new instance. * @param {SwitchContext} upperContext The previous context. * @param {boolean} hasCase Indicates if there is at least one `case` statement. * `default` doesn't count. */ constructor(upperContext, hasCase) { /** * The previous context. * @type {SwitchContext} */ this.upper = upperContext; /** * Indicates if there is at least one `case` statement. `default` doesn't count. * @type {boolean} */ this.hasCase = hasCase; /** * The `default` keyword. * @type {Array|null} */ this.defaultSegments = null; /** * The default case body starting segments. * @type {Array|null} */ this.defaultBodySegments = null; /** * Indicates if a `default` case and is empty exists. * @type {boolean} */ this.foundEmptyDefault = false; /** * Indicates that a `default` exists and is the last case. * @type {boolean} */ this.lastIsDefault = false; /** * The number of fork contexts created. This is equivalent to the * number of `case` statements plus a `default` statement (if present). * @type {number} */ this.forkCount = 0; } } /** * Represents the context for a `try` statement. */ class TryContext { /** * Creates a new instance. * @param {TryContext} upperContext The previous context. * @param {boolean} hasFinalizer Indicates if the `try` statement has a * `finally` block. * @param {ForkContext} forkContext The enclosing fork context. */ constructor(upperContext, hasFinalizer, forkContext) { /** * The previous context. * @type {TryContext} */ this.upper = upperContext; /** * Indicates if the `try` statement has a `finally` block. * @type {boolean} */ this.hasFinalizer = hasFinalizer; /** * Tracks the traversal position inside of the `try` statement. This is * used to help determine the context necessary to create paths because * a `try` statement may or may not have `catch` or `finally` blocks, * and code paths behave differently in those blocks. * @type {"try"|"catch"|"finally"} */ this.position = "try"; /** * If the `try` statement has a `finally` block, this affects how a * `return` statement behaves in the `try` block. Without `finally`, * `return` behaves as usual and doesn't require a fork; with `finally`, * `return` forks into the `finally` block, so we need a fork context * to track it. * @type {ForkContext|null} */ this.returnedForkContext = hasFinalizer ? ForkContext.newEmpty(forkContext) : null; /** * When a `throw` occurs inside of a `try` block, the code path forks * into the `catch` or `finally` blocks, and this fork context tracks * that path. * @type {ForkContext} */ this.thrownForkContext = ForkContext.newEmpty(forkContext); /** * Indicates if the last segment in the `try` block is reachable. * @type {boolean} */ this.lastOfTryIsReachable = false; /** * Indicates if the last segment in the `catch` block is reachable. * @type {boolean} */ this.lastOfCatchIsReachable = false; } } //------------------------------------------------------------------------------ // Helpers //------------------------------------------------------------------------------ /** * Adds given segments into the `dest` array. * If the `others` array does not include 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.includes(segment)) { all.push(segment); } } } /** * Gets a loop context for a `continue` statement based on a given label. * @param {CodePathState} state The state to search within. * @param {string|null} 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; } /* c8 ignore next */ return null; } /** * Gets a context for a `break` statement. * @param {CodePathState} state The state to search within. * @param {string|null} label The label of a `break` statement. * @returns {BreakContext} 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; } /* c8 ignore next */ return null; } /** * Gets a context for a `return` statement. There is just one special case: * if there is a `try` statement with a `finally` block, because that alters * how `return` behaves; otherwise, this just passes through the given state. * @param {CodePathState} state The state to search within * @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. There is just one special case: * if there is a `try` statement with a `finally` block and we are inside of * a `catch` because that changes how `throw` behaves; otherwise, this just * passes through the given state. * @param {CodePathState} state The state to search within. * @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 value from a given array. * @param {any[]} elements An array to remove the specific element. * @param {any} value The value to be removed. * @returns {void} */ function removeFromArray(elements, value) { elements.splice(elements.indexOf(value), 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 disconnectSegments(prevSegments, nextSegments) { for (let i = 0; i < prevSegments.length; ++i) { const prevSegment = prevSegments[i]; const nextSegment = nextSegments[i]; removeFromArray(prevSegment.nextSegments, nextSegment); removeFromArray(prevSegment.allNextSegments, nextSegment); removeFromArray(nextSegment.prevSegments, prevSegment); removeFromArray(nextSegment.allPrevSegments, prevSegment); } } /** * Creates looping path between two arrays of segments, ensuring that there are * paths going between matching segments in the arrays. * @param {CodePathState} state The state to operate on. * @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); /* * This loop effectively updates a doubly-linked list between two collections * of segments making sure that segments in the same array indices are * combined to create a path. */ for (let i = 0; i < end; ++i) { // get the segments in matching array indices const fromSegment = fromSegments[i]; const toSegment = toSegments[i]; /* * If the destination segment is reachable, then create a path from the * source segment to the destination segment. */ if (toSegment.reachable) { fromSegment.nextSegments.push(toSegment); } /* * If the source segment is reachable, then create a path from the * destination segment back to the source segment. */ if (fromSegment.reachable) { toSegment.prevSegments.push(fromSegment); } /* * Also update the arrays that don't care if the segments are reachable * or not. This should always happen regardless of anything else. */ fromSegment.allNextSegments.push(toSegment); toSegment.allPrevSegments.push(fromSegment); /* * If the destination segment has at least two previous segments in its * path then that means there was one previous segment before this iteration * of the loop was executed. So, we need to mark the source segment as * looped. */ if (toSegment.allPrevSegments.length >= 2) { CodePathSegment.markPrevSegmentAsLooped(toSegment, fromSegment); } // let the code path analyzer know that there's been a loop created 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 this choice context doesn't already contain paths from a * child context, then add the current head to each potential path. */ if (!choiceContext.processed) { choiceContext.trueForkContext.add(head); choiceContext.falseForkContext.add(head); choiceContext.nullishForkContext.add(head); } /* * If the test condition isn't a hardcoded truthy value, then `break` * must follow the same path as if the test condition is false. To represent * that, we append the path for when the loop test is false (represented by * `falseForkContext`) to the `brokenForkContext`. */ 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 { /** * Creates a new instance. * @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) { /** * The ID generator to use when creating new segments. * @type {IdGenerator} */ this.idGenerator = idGenerator; /** * A callback function to call when there is a loop. * @type {Function} */ this.notifyLooped = onLooped; /** * The root fork context for this state. * @type {ForkContext} */ this.forkContext = ForkContext.newRoot(idGenerator); /** * Context for logical expressions, conditional expressions, `if` statements, * and loops. * @type {ChoiceContext} */ this.choiceContext = null; /** * Context for `switch` statements. * @type {SwitchContext} */ this.switchContext = null; /** * Context for `try` statements. * @type {TryContext} */ this.tryContext = null; /** * Context for loop statements. * @type {LoopContext} */ this.loopContext = null; /** * Context for `break` statements. * @type {BreakContext} */ this.breakContext = null; /** * Context for `ChainExpression` nodes. * @type {ChainContext} */ this.chainContext = null; /** * An array that tracks the current segments in the state. The array * starts empty and segments are added with each `onCodePathSegmentStart` * event and removed with each `onCodePathSegmentEnd` event. Effectively, * this is tracking the code path segment traversal as the state is * modified. * @type {Array} */ this.currentSegments = []; /** * Tracks the starting segment for this path. This value never changes. * @type {CodePathSegment} */ this.initialSegment = this.forkContext.head[0]; /** * The final segments of the code path which are either `return` or `throw`. * This is a union of the segments in `returnedForkContext` and `thrownForkContext`. * @type {Array} */ this.finalSegments = []; /** * The final segments of the code path which are `return`. These * segments are also contained in `finalSegments`. * @type {Array} */ this.returnedForkContext = []; /** * The final segments of the code path which are `throw`. These * segments are also contained in `finalSegments`. * @type {Array} */ this.thrownForkContext = []; /* * We add an `add` method so that these look more like fork contexts and * can be used interchangeably when a fork context is needed to add more * segments to a path. * * Ultimately, we want anything added to `returned` or `thrown` to also * be added to `final`. We only add reachable and used segments to these * arrays. */ 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); } /** * A passthrough property exposing the current pointer as part of the API. * @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, AssignmentExpression (logical assignments only), * 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 or AssignmentExpression's, this is `"&&"` or `"||"` or `"??"`. * If it's IfStatement's or ConditionalExpression's, this is `"test"`. * Otherwise, this is `"loop"`. * @param {boolean} isForkingAsResult Indicates if the result of the choice * creates a fork. * @returns {void} */ pushChoiceContext(kind, isForkingAsResult) { this.choiceContext = new ChoiceContext(this.choiceContext, kind, isForkingAsResult, this.forkContext); } /** * Pops the last choice context and finalizes it. * This is called upon leaving a node that represents a choice. * @throws {Error} (Unreachable.) * @returns {ChoiceContext} The popped context. */ popChoiceContext() { const poppedChoiceContext = this.choiceContext; const forkContext = this.forkContext; const head = forkContext.head; this.choiceContext = poppedChoiceContext.upper; switch (poppedChoiceContext.kind) { case "&&": case "||": case "??": /* * The `head` are the path of the right-hand operand. * If we haven't previously added segments from child contexts, * then we add these segments to all possible forks. */ if (!poppedChoiceContext.processed) { poppedChoiceContext.trueForkContext.add(head); poppedChoiceContext.falseForkContext.add(head); poppedChoiceContext.nullishForkContext.add(head); } /* * If this context is the left (test) expression for another choice * context, such as `a || b` in the expression `a || b || c`, * then we take the segments for this context and move them up * to the parent context. */ if (poppedChoiceContext.isForkingAsResult) { const parentContext = this.choiceContext; parentContext.trueForkContext.addAll(poppedChoiceContext.trueForkContext); parentContext.falseForkContext.addAll(poppedChoiceContext.falseForkContext); parentContext.nullishForkContext.addAll(poppedChoiceContext.nullishForkContext); parentContext.processed = true; // Exit early so we don't collapse all paths into one. return poppedChoiceContext; } break; case "test": if (!poppedChoiceContext.processed) { /* * The head segments are the path of the `if` block here. * Updates the `true` path with the end of the `if` block. */ poppedChoiceContext.trueForkContext.clear(); poppedChoiceContext.trueForkContext.add(head); } else { /* * The head segments are the path of the `else` block here. * Updates the `false` path with the end of the `else` * block. */ poppedChoiceContext.falseForkContext.clear(); poppedChoiceContext.falseForkContext.add(head); } break; case "loop": /* * Loops are addressed in `popLoopContext()` so just return * the context without modification. */ return poppedChoiceContext; /* c8 ignore next */ default: throw new Error("unreachable"); } /* * Merge the true path with the false path to create a single path. */ const combinedForkContext = poppedChoiceContext.trueForkContext; combinedForkContext.addAll(poppedChoiceContext.falseForkContext); forkContext.replaceHead(combinedForkContext.makeNext(0, -1)); return poppedChoiceContext; } /** * Creates a code path segment to represent right-hand operand of a logical * expression. * This is called in the preprocessing phase when entering a node. * @throws {Error} (Unreachable.) * @returns {void} */ makeLogicalRight() { const currentChoiceContext = this.choiceContext; const forkContext = this.forkContext; if (currentChoiceContext.processed) { /* * This context was already assigned segments from a child * choice context. In this case, we are concerned only about * the path that does not short-circuit and so ends up on the * right-hand operand of the logical expression. */ let prevForkContext; switch (currentChoiceContext.kind) { case "&&": // if true then go to the right-hand side. prevForkContext = currentChoiceContext.trueForkContext; break; case "||": // if false then go to the right-hand side. prevForkContext = currentChoiceContext.falseForkContext; break; case "??": // Both true/false can short-circuit, so needs the third path to go to the right-hand side. That's nullishForkContext. prevForkContext = currentChoiceContext.nullishForkContext; break; default: throw new Error("unreachable"); } /* * Create the segment for the right-hand operand of the logical expression * and adjust the fork context pointer to point there. The right-hand segment * is added at the end of all segments in `prevForkContext`. */ forkContext.replaceHead(prevForkContext.makeNext(0, -1)); /* * We no longer need this list of segments. * * Reset `processed` because we've removed the segments from the child * choice context. This allows `popChoiceContext()` to continue adding * segments later. */ prevForkContext.clear(); currentChoiceContext.processed = false; } else { /* * This choice context was not assigned segments from a child * choice context, which means that it's a terminal logical * expression. * * `head` is the segments for the left-hand operand of the * logical expression. * * Each of the fork contexts below are empty at this point. We choose * the path(s) that will short-circuit and add the segment for the * left-hand operand to it. Ultimately, this will be the only segment * in that path due to the short-circuting, so we are just seeding * these paths to start. */ switch (currentChoiceContext.kind) { case "&&": /* * In most contexts, when a && expression evaluates to false, * it short circuits, so we need to account for that by setting * the `falseForkContext` to the left operand. * * When a && expression is the left-hand operand for a ?? * expression, such as `(a && b) ?? c`, a nullish value will * also short-circuit in a different way than a false value, * so we also set the `nullishForkContext` to the left operand. * This path is only used with a ?? expression and is thrown * away for any other type of logical expression, so it's safe * to always add. */ currentChoiceContext.falseForkContext.add(forkContext.head); currentChoiceContext.nullishForkContext.add(forkContext.head); break; case "||": // the true path can short-circuit. currentChoiceContext.trueForkContext.add(forkContext.head); break; case "??": // both can short-circuit. currentChoiceContext.trueForkContext.add(forkContext.head); currentChoiceContext.falseForkContext.add(forkContext.head); break; default: throw new Error("unreachable"); } /* * Create the segment for the right-hand operand of the logical expression * and adjust the fork context pointer to point there. */ 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.nullishForkContext.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) ); } //-------------------------------------------------------------------------- // ChainExpression //-------------------------------------------------------------------------- /** * Pushes a new `ChainExpression` context to the stack. This method is * called when entering a `ChainExpression` node. A chain context is used to * count forking in the optional chain then merge them on the exiting from the * `ChainExpression` node. * @returns {void} */ pushChainContext() { this.chainContext = new ChainContext(this.chainContext); } /** * Pop a `ChainExpression` context from the stack. This method is called on * exiting from each `ChainExpression` node. This merges all forks of the * last optional chaining. * @returns {void} */ popChainContext() { const context = this.chainContext; this.chainContext = context.upper; // pop all choice contexts of this. for (let i = context.choiceContextCount; i > 0; --i) { this.popChoiceContext(); } } /** * Create a choice context for optional access. * This method is called on entering to each `(Call|Member)Expression[optional=true]` node. * This creates a choice context as similar to `LogicalExpression[operator="??"]` node. * @returns {void} */ makeOptionalNode() { if (this.chainContext) { this.chainContext.choiceContextCount += 1; this.pushChoiceContext("??", false); } } /** * Create a fork. * This method is called on entering to the `arguments|property` property of each `(Call|Member)Expression` node. * @returns {void} */ makeOptionalRight() { if (this.chainContext) { this.makeLogicalRight(); } } //-------------------------------------------------------------------------- // 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 = new SwitchContext(this.switchContext, hasCase); 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.forkCount === 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); /* * Any value that doesn't match a `case` test should flow to the default * case. That happens normally when the default case is last in the `switch`, * but if it's not, we need to rewire some of the paths to be correct. */ if (!context.lastIsDefault) { if (context.defaultBodySegments) { /* * There is a non-empty default case, so remove the path from the `default` * label to its body for an accurate representation. */ disconnectSegments(context.defaultSegments, context.defaultBodySegments); /* * Connect the path from the last non-default case to the body of the * default case. */ makeLooped(this, lastCaseSegments, context.defaultBodySegments); } else { /* * There is no default case, so we treat this as if the last case * had a `break` in it. */ brokenForkContext.add(lastCaseSegments); } } // Traverse up to the original fork context for the `switch` statement for (let i = 0; i < context.forkCount; ++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} isCaseBodyEmpty `true` if the body is empty. * @param {boolean} isDefaultCase `true` if the body is the default case. * @returns {void} */ makeSwitchCaseBody(isCaseBodyEmpty, isDefaultCase) { 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)); /* * Add information about the default case. * * The purpose of this is to identify the starting segments for the * default case to make sure there is a path there. */ if (isDefaultCase) { /* * This is the default case in the `switch`. * * We first save the current pointer as `defaultSegments` to point * to the `default` keyword. */ context.defaultSegments = parentForkContext.head; /* * If the body of the case is empty then we just set * `foundEmptyDefault` to true; otherwise, we save a reference * to the current pointer as `defaultBodySegments`. */ if (isCaseBodyEmpty) { context.foundEmptyDefault = true; } else { context.defaultBodySegments = forkContext.head; } } else { /* * This is not the default case in the `switch`. * * If it's not empty and there is already an empty default case found, * that means the default case actually comes before this case, * and that it will fall through to this case. So, we can now * ignore the previous default case (reset `foundEmptyDefault` to false) * and set `defaultBodySegments` to the current segments because this is * effectively the new default case. */ if (!isCaseBodyEmpty && context.foundEmptyDefault) { context.foundEmptyDefault = false; context.defaultBodySegments = forkContext.head; } } // keep track if the default case ends up last context.lastIsDefault = isDefaultCase; context.forkCount += 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 = new TryContext(this.tryContext, hasFinalizer, this.forkContext); } /** * Pops the last context of TryStatement and finalizes it. * @returns {void} */ popTryContext() { const context = this.tryContext; this.tryContext = context.upper; /* * If we're inside the `catch` block, that means there is no `finally`, * so we can process the `try` and `catch` blocks the simple way and * merge their two paths. */ if (context.position === "catch") { this.popForkContext(); return; } /* * The following process is executed only when there is a `finally` * block. */ const originalReturnedForkContext = context.returnedForkContext; const originalThrownForkContext = context.thrownForkContext; // no `return` or `throw` in `try` or `catch` so there's nothing left to do if (originalReturnedForkContext.empty && originalThrownForkContext.empty) { return; } /* * The following process is executed only when there is a `finally` * block and there was a `return` or `throw` in the `try` or `catch` * blocks. */ // 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 (!originalReturnedForkContext.empty) { getReturnContext(this).returnedForkContext.add(leavingSegments); } if (!originalThrownForkContext.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 originalThrownForkContext = context.thrownForkContext; /* * We are now in a catch block so we need to update the context * with that information. This includes creating a new fork * context in case we encounter any `throw` statements here. */ context.position = "catch"; context.thrownForkContext = ForkContext.newEmpty(forkContext); context.lastOfTryIsReachable = forkContext.reachable; // Merge the thrown paths from the `try` and `catch` blocks originalThrownForkContext.add(forkContext.head); const thrownSegments = originalThrownForkContext.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 originalReturnedForkContext = context.returnedForkContext; const originalThrownForContext = 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 there was no `return` or `throw` in either the `try` or `catch` * blocks, then there's no further code paths to create for `finally`. */ if (originalReturnedForkContext.empty && originalThrownForContext.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 < originalReturnedForkContext.segmentsList.length; ++j) { prevSegsOfLeavingSegment.push(originalReturnedForkContext.segmentsList[j][i]); } for (let j = 0; j < originalThrownForContext.segmentsList.length; ++j) { prevSegsOfLeavingSegment.push(originalThrownForContext.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. * @throws {Error} (Unreachable - unknown type.) * @returns {void} */ pushLoopContext(type, label) { const forkContext = this.forkContext; // All loops need a path to account for `break` statements const breakContext = this.pushBreakContext(true, label); switch (type) { case "WhileStatement": this.pushChoiceContext("loop", false); this.loopContext = new WhileLoopContext(this.loopContext, label, breakContext); break; case "DoWhileStatement": this.pushChoiceContext("loop", false); this.loopContext = new DoWhileLoopContext(this.loopContext, label, breakContext, forkContext); break; case "ForStatement": this.pushChoiceContext("loop", false); this.loopContext = new ForLoopContext(this.loopContext, label, breakContext); break; case "ForInStatement": this.loopContext = new ForInLoopContext(this.loopContext, label, breakContext); break; case "ForOfStatement": this.loopContext = new ForOfLoopContext(this.loopContext, label, breakContext); break; /* c8 ignore next */ default: throw new Error(`unknown type: "${type}"`); } } /** * Pops the last context of a loop statement and finalizes it. * @throws {Error} (Unreachable - unknown type.) * @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(); /* * Creates the path from the end of the loop body up to the * location where `continue` would jump to. */ 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 this isn't a hardcoded `true` condition, then `break` * should continue down the path as if the condition evaluated * to false. */ if (context.test !== true) { brokenForkContext.addAll(choiceContext.falseForkContext); } /* * When the condition is true, the loop continues back to the top, * so create a path from each possible true condition back to the * top of the loop. */ 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); /* * Creates the path from the end of the loop body up to the * left expression (left of `in` or `of`) of the loop. */ makeLooped( this, forkContext.head, context.leftSegments ); break; /* c8 ignore next */ default: throw new Error("unreachable"); } /* * If there wasn't a `break` statement in the loop, then we're at * the end of the loop's path, so we make an unreachable segment * to mark that. * * If there was a `break` statement, then we continue on into the * `brokenForkContext`. */ 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); } /* * If this isn't a hardcoded `true` condition, then `break` * should continue down the path as if the condition evaluated * to false. */ 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; /* * If there is a `continue` statement in the loop then `continueForkContext` * won't be empty. We wire up the path from `continue` to the loop * test condition and then continue the traversal in the root fork context. */ 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 the state. * * The `continueDestSegments` are set to `testSegments` because we * don't yet know if there is an update expression in this loop. So, * from what we already know at this point, a `continue` statement * will jump back to the test expression. */ 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 the state. * * The `continueDestSegments` are now set to `updateSegments` because we * know there is an update expression in this loop. So, a `continue` statement * in the loop will jump to the update expression first, and then to any * test expression the loop might have. */ 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; /* * Determine what to do based on which part of the `for` loop are present. * 1. If there is an update expression, then `updateSegments` is not null and * we need to assign `endOfUpdateSegments`, and if there is a test * expression, we then need to create the looped path to get back to * the test condition. * 2. If there is no update expression but there is a test expression, * then we only need to update the test segment information. * 3. If there is no update expression and no test expression, then we * just save `endOfInitSegments`. */ if (context.updateSegments) { context.endOfUpdateSegments = forkContext.head; /* * In a `for` loop that has both an update expression and a test * condition, execution flows from the test expression into the * loop body, to the update expression, and then back to the test * expression to determine if the loop should continue. * * To account for that, we need to make a path from the end of the * update expression to the start of the test expression. This is * effectively what creates the loop in the code path. */ 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 there is a test condition, then there `endOfTestSegments` is also * the start of the loop body. If there isn't a test condition then * `bodySegments` will be null and we need to look elsewhere to find * the start of the body. * * The body starts at the end of the init expression and ends at the end * of the update expression, so we use those locations to determine the * body segments. */ if (!bodySegments) { const prevForkContext = ForkContext.newEmpty(forkContext); prevForkContext.add(context.endOfInitSegments); if (context.endOfUpdateSegments) { prevForkContext.add(context.endOfUpdateSegments); } bodySegments = prevForkContext.makeNext(0, -1); } /* * If there was no test condition and no update expression, then * `continueDestSegments` will be null. In that case, a * `continue` should skip directly to the body of the loop. * Otherwise, we want to keep the current `continueDestSegments`. */ context.continueDestSegments = context.continueDestSegments || bodySegments; // move pointer to the body 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 in which a `break` statement can be used. This occurs inside of a loop, * labeled statement, or switch statement. * @param {boolean} breakable Indicates if we are inside a statement where * `break` without a label will exit the statement. * @param {string|null} label The label associated with the statement. * @returns {BreakContext} The new context. */ pushBreakContext(breakable, label) { this.breakContext = new BreakContext(this.breakContext, breakable, label, 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|null} label A label of the break statement. * @returns {void} */ makeBreak(label) { const forkContext = this.forkContext; if (!forkContext.reachable) { return; } const context = getBreakContext(this, label); if (context) { context.brokenForkContext.add(forkContext.head); } /* c8 ignore next */ 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|null} label A label of the continue statement. * @returns {void} */ makeContinue(label) { const forkContext = this.forkContext; if (!forkContext.reachable) { return; } const context = getContinueContext(this, label); if (context) { if (context.continueDestSegments) { makeLooped(this, forkContext.head, context.continueDestSegments); // If the context is a for-in/of loop, this affects 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;