| /** |
| * @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 { |
| |
| /** |
| * @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; |
