claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.70

package/src/ui/extension/node_modules/eslint/lib/linter/code-path-analysis/code-path-state.js

@@ -2,20 +2,15 @@
  * @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.
  *
@@ -35,7 +30,6 @@ const CodePathSegment = require("./code-path-segment"),
  * that `break` without a label is invalid.
  */
 class BreakContext {
-
     /**
      * Creates a new instance.
      * @param {BreakContext} upperContext The previous `BreakContext`.
@@ -45,26 +39,22 @@ class BreakContext {
      * @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}
@@ -72,33 +62,27 @@ class BreakContext {
         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.
  *
@@ -124,7 +108,6 @@ class ChainContext {
  * we fork to the right expression (tracked by `nullishForkContext`).
  */
 class ChoiceContext {
-
     /**
      * Creates a new instance.
      * @param {ChoiceContext} upperContext The previous `ChoiceContext`.
@@ -136,13 +119,11 @@ class ChoiceContext {
      * @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
@@ -150,31 +131,26 @@ class ChoiceContext {
          * @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.
@@ -182,14 +158,11 @@ class ChoiceContext {
          */
         this.processed = false;
     }
-
 }
-
 /**
  * Base class for all loop contexts.
  */
 class LoopContextBase {
-
     /**
      * Creates a new instance.
      * @param {LoopContext|null} upperContext The previous `LoopContext`.
@@ -198,25 +171,21 @@ class LoopContextBase {
      * @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}
@@ -224,12 +193,10 @@ class LoopContextBase {
         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`.
@@ -238,14 +205,12 @@ class WhileLoopContext extends LoopContextBase {
      */
     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
@@ -255,12 +220,10 @@ class WhileLoopContext extends LoopContextBase {
         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`.
@@ -270,14 +233,12 @@ class DoWhileLoopContext extends LoopContextBase {
      */
     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
@@ -285,7 +246,6 @@ class DoWhileLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|null}
          */
         this.entrySegments = null;
-
         /**
          * The fork context to follow when a `continue` is found.
          * @type {ForkContext}
@@ -293,12 +253,10 @@ class DoWhileLoopContext extends LoopContextBase {
         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`.
@@ -307,14 +265,12 @@ class ForLoopContext extends LoopContextBase {
      */
     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
@@ -322,7 +278,6 @@ class ForLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -330,7 +285,6 @@ class ForLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -338,7 +292,6 @@ class ForLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -346,7 +299,6 @@ class ForLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -354,7 +306,6 @@ class ForLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -368,7 +319,6 @@ class ForLoopContext extends LoopContextBase {
         this.continueDestSegments = null;
     }
 }
-
 /**
  * Represents the context for a `for-in` loop.
  *
@@ -379,7 +329,6 @@ class ForLoopContext extends LoopContextBase {
  *   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`.
@@ -388,7 +337,6 @@ class ForInLoopContext extends LoopContextBase {
      */
     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
@@ -400,7 +348,6 @@ class ForInLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -409,7 +356,6 @@ class ForInLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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`.
@@ -418,7 +364,6 @@ class ForInLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -431,12 +376,10 @@ class ForInLoopContext extends LoopContextBase {
         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`.
@@ -445,7 +388,6 @@ class ForOfLoopContext extends LoopContextBase {
      */
     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
@@ -457,7 +399,6 @@ class ForOfLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -466,7 +407,6 @@ class ForOfLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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`.
@@ -475,7 +415,6 @@ class ForOfLoopContext extends LoopContextBase {
          * @type {Array<CodePathSegment>|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
@@ -488,17 +427,14 @@ class ForOfLoopContext extends LoopContextBase {
         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.
@@ -506,43 +442,36 @@ class SwitchContext {
      *      `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<CodePathSegment>|null}
          */
         this.defaultSegments = null;
-
         /**
          * The default case body starting segments.
          * @type {Array<CodePathSegment>|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).
@@ -551,12 +480,10 @@ class SwitchContext {
         this.forkCount = 0;
     }
 }
-
 /**
  * Represents the context for a `try` statement.
  */
 class TryContext {
-
     /**
      * Creates a new instance.
      * @param {TryContext} upperContext The previous context.
@@ -565,19 +492,16 @@ class TryContext {
      * @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
@@ -586,7 +510,6 @@ class TryContext {
          * @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`,
@@ -598,7 +521,6 @@ class TryContext {
         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
@@ -606,13 +528,11 @@ class TryContext {
          * @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}
@@ -620,11 +540,9 @@ class TryContext {
         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`
@@ -640,14 +558,12 @@ class TryContext {
 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.
@@ -658,20 +574,16 @@ function getContinueContext(state, label) {
     if (!label) {
         return state.loopContext;
     }
-
     let context = state.loopContext;
-
-    while (context) {
+    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.
@@ -680,18 +592,15 @@ function getContinueContext(state, label) {
  */
 function getBreakContext(state, label) {
     let context = state.breakContext;
-
-    while (context) {
+    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
@@ -701,17 +610,14 @@ function getBreakContext(state, label) {
  */
 function getReturnContext(state) {
     let context = state.tryContext;
-
-    while (context) {
+    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
@@ -722,8 +628,7 @@ function getReturnContext(state) {
  */
 function getThrowContext(state) {
     let context = state.tryContext;
-
-    while (context) {
+    while (_context) {
         if (context.position === "try" ||
             (context.hasFinalizer && context.position === "catch")
         ) {
@@ -731,10 +636,8 @@ function getThrowContext(state) {
         }
         context = context.upper;
     }
-
     return state;
 }
-
 /**
  * Removes a given value from a given array.
  * @param {any[]} elements An array to remove the specific element.
@@ -744,7 +647,6 @@ function getThrowContext(state) {
 function removeFromArray(elements, value) {
     elements.splice(elements.indexOf(value), 1);
 }
-
 /**
  * Disconnect given segments.
  *
@@ -759,14 +661,12 @@ 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.
@@ -776,22 +676,18 @@ function disconnectSegments(prevSegments, nextSegments) {
  * @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.
@@ -799,7 +695,6 @@ function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
         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.
@@ -807,14 +702,12 @@ function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
         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
@@ -824,12 +717,10 @@ function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
         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.
  *
@@ -840,8 +731,7 @@ function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
  * @param {CodePathSegment[]} head The current head paths.
  * @returns {void}
  */
-function finalizeTestSegmentsOfFor(context, choiceContext, head) {
-
+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.
@@ -851,7 +741,6 @@ function finalizeTestSegmentsOfFor(context, choiceContext, 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
@@ -861,19 +750,15 @@ function finalizeTestSegmentsOfFor(context, choiceContext, 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 {
-
     /**
      * Creates a new instance.
      * @param {IdGenerator} idGenerator An id generator to generate id for code
@@ -881,62 +766,52 @@ class CodePathState {
      * @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`
@@ -946,34 +821,29 @@ class CodePathState {
          * @type {Array<CodePathSegment>}
          */
         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<CodePathSegment>}
          */
         this.finalSegments = [];
-
         /**
          * The final segments of the code path which are `return`. These
          * segments are also contained in `finalSegments`.
          * @type {Array<CodePathSegment>}
          */
         this.returnedForkContext = [];
-
         /**
          * The final segments of the code path which are `throw`. These
          * segments are also contained in `finalSegments`.
          * @type {Array<CodePathSegment>}
          */
         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
@@ -986,11 +856,9 @@ class CodePathState {
         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[]}
@@ -998,7 +866,6 @@ class CodePathState {
     get headSegments() {
         return this.forkContext.head;
     }
-
     /**
      * The parent forking context.
      * This is used for the root of new forks.
@@ -1006,10 +873,8 @@ class CodePathState {
      */
     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
@@ -1021,23 +886,18 @@ class CodePathState {
             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}
@@ -1045,7 +905,6 @@ class CodePathState {
     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.
@@ -1054,11 +913,9 @@ class CodePathState {
     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.
@@ -1092,7 +949,6 @@ class CodePathState {
     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.
@@ -1103,14 +959,11 @@ class CodePathState {
         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,
@@ -1121,7 +974,6 @@ class CodePathState {
                     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`,
@@ -1130,21 +982,16 @@ class CodePathState {
                  */
                 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.
@@ -1152,7 +999,6 @@ class CodePathState {
                     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`
@@ -1161,33 +1007,25 @@ class CodePathState {
                     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.
@@ -1198,17 +1036,14 @@ class CodePathState {
     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;
-
+            let prevForkContext; // TODO: Remove if unused
             switch (currentChoiceContext.kind) {
                 case "&&": // if true then go to the right-hand side.
                     prevForkContext = currentChoiceContext.trueForkContext;
@@ -1222,14 +1057,12 @@ class CodePathState {
                 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.
              *
@@ -1239,9 +1072,7 @@ class CodePathState {
              */
             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
@@ -1258,7 +1089,6 @@ class CodePathState {
              */
             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
@@ -1285,7 +1115,6 @@ class CodePathState {
                 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.
@@ -1293,7 +1122,6 @@ class CodePathState {
             forkContext.replaceHead(forkContext.makeNext(-1, -1));
         }
     }
-
     /**
      * Makes a code path segment of the `if` block.
      * @returns {void}
@@ -1301,7 +1129,6 @@ class CodePathState {
     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.
@@ -1312,15 +1139,12 @@ class CodePathState {
             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}
@@ -1328,7 +1152,6 @@ class CodePathState {
     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.
@@ -1336,17 +1159,14 @@ class CodePathState {
         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
@@ -1357,7 +1177,6 @@ class CodePathState {
     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
@@ -1366,15 +1185,12 @@ class CodePathState {
      */
     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.
@@ -1387,7 +1203,6 @@ class CodePathState {
             this.pushChoiceContext("??", false);
         }
     }
-
     /**
      * Create a fork.
      * This method is called on entering to the `arguments|property` property of each `(Call|Member)Expression` node.
@@ -1398,11 +1213,9 @@ class CodePathState {
             this.makeLogicalRight();
         }
     }
-
     //--------------------------------------------------------------------------
     // SwitchStatement
     //--------------------------------------------------------------------------
-
     /**
      * Creates a context object of SwitchStatement and stacks it.
      * @param {boolean} hasCase `true` if the switch statement has one or more
@@ -1414,7 +1227,6 @@ class CodePathState {
         this.switchContext = new SwitchContext(this.switchContext, hasCase);
         this.pushBreakContext(true, label);
     }
-
     /**
      * Pops the last context of SwitchStatement and finalizes it.
      *
@@ -1426,14 +1238,10 @@ class CodePathState {
      */
     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
@@ -1443,21 +1251,16 @@ class CodePathState {
                 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`,
@@ -1465,21 +1268,17 @@ class CodePathState {
          */
         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.
@@ -1487,19 +1286,16 @@ class CodePathState {
                 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.
@@ -1508,11 +1304,9 @@ class CodePathState {
      */
     makeSwitchCaseBody(isCaseBodyEmpty, isDefaultCase) {
         const context = this.switchContext;
-
         if (!context.hasCase) {
             return;
         }
-
         /*
          * Merge forks.
          * The parent fork context has two segments.
@@ -1520,9 +1314,7 @@ class CodePathState {
          */
         const parentForkContext = this.forkContext;
         const forkContext = this.pushForkContext();
-
         forkContext.add(parentForkContext.makeNext(0, -1));
-
         /*
          * Add information about the default case.
          *
@@ -1530,7 +1322,6 @@ class CodePathState {
          * default case to make sure there is a path there.
          */
         if (isDefaultCase) {
-
             /*
              * This is the default case in the `switch`.
              *
@@ -1538,7 +1329,6 @@ class CodePathState {
              * 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
@@ -1549,9 +1339,7 @@ class CodePathState {
             } else {
                 context.defaultBodySegments = forkContext.head;
             }
-
         } else {
-
             /*
              * This is not the default case in the `switch`.
              *
@@ -1567,16 +1355,13 @@ class CodePathState {
                 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
@@ -1586,16 +1371,13 @@ class CodePathState {
     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
@@ -1605,33 +1387,26 @@ class CodePathState {
             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);
@@ -1639,10 +1414,8 @@ class CodePathState {
         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.
@@ -1651,7 +1424,6 @@ class CodePathState {
             this.forkContext.makeUnreachable();
         }
     }
-
     /**
      * Makes a code path segment for a `catch` block.
      * @returns {void}
@@ -1660,7 +1432,6 @@ class CodePathState {
         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
@@ -1669,17 +1440,14 @@ class CodePathState {
         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.
      *
@@ -1694,48 +1462,37 @@ class CodePathState {
         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(),
@@ -1743,11 +1500,9 @@ class CodePathState {
                 )
             );
         }
-
         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.
@@ -1755,28 +1510,22 @@ class CodePathState {
      */
     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
@@ -1788,40 +1537,32 @@ class CodePathState {
      */
     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.)
@@ -1829,18 +1570,14 @@ class CodePathState {
      */
     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.
@@ -1851,15 +1588,12 @@ class CodePathState {
                     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
@@ -1868,14 +1602,12 @@ class CodePathState {
                 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,
@@ -1885,11 +1617,9 @@ class CodePathState {
                 }
                 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.
@@ -1900,12 +1630,10 @@ class CodePathState {
                     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
@@ -1920,7 +1648,6 @@ class CodePathState {
             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).
@@ -1930,13 +1657,11 @@ class CodePathState {
         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}
@@ -1945,12 +1670,10 @@ class CodePathState {
         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
@@ -1961,7 +1684,6 @@ class CodePathState {
         }
         forkContext.replaceHead(choiceContext.trueForkContext.makeNext(0, -1));
     }
-
     /**
      * Makes a code path segment for the body part of a DoWhileStatement.
      * @returns {void}
@@ -1970,12 +1692,10 @@ class CodePathState {
         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).
@@ -1984,9 +1704,7 @@ class CodePathState {
     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
@@ -1995,11 +1713,9 @@ class CodePathState {
         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).
@@ -2010,7 +1726,6 @@ class CodePathState {
         const forkContext = this.forkContext;
         const endOfInitSegments = forkContext.head;
         const testSegments = forkContext.makeNext(-1, -1);
-
         /*
          * Update the state.
          *
@@ -2024,7 +1739,6 @@ class CodePathState {
         context.continueDestSegments = context.testSegments = testSegments;
         forkContext.replaceHead(testSegments);
     }
-
     /**
      * Makes a code path segment for the update part of a ForStatement.
      * @returns {void}
@@ -2033,7 +1747,6 @@ class CodePathState {
         const context = this.loopContext;
         const choiceContext = this.choiceContext;
         const forkContext = this.forkContext;
-
         // Make the next paths of the test.
         if (context.testSegments) {
             finalizeTestSegmentsOfFor(
@@ -2044,7 +1757,6 @@ class CodePathState {
         } else {
             context.endOfInitSegments = forkContext.head;
         }
-
         /*
          * Update the state.
          *
@@ -2054,11 +1766,9 @@ class CodePathState {
          * 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}
@@ -2067,7 +1777,6 @@ class CodePathState {
         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
@@ -2081,7 +1790,6 @@ class CodePathState {
          */
         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
@@ -2108,9 +1816,7 @@ class CodePathState {
         } 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
@@ -2122,17 +1828,13 @@ class CodePathState {
          * 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
@@ -2140,11 +1842,9 @@ class CodePathState {
          * 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.
@@ -2154,13 +1854,11 @@ class CodePathState {
         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.
@@ -2170,15 +1868,12 @@ class CodePathState {
         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.
@@ -2188,22 +1883,17 @@ class CodePathState {
         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.
@@ -2216,7 +1906,6 @@ class CodePathState {
         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.
@@ -2224,22 +1913,17 @@ class CodePathState {
     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.
      *
@@ -2250,22 +1934,16 @@ class CodePathState {
      */
     makeBreak(label) {
         const forkContext = this.forkContext;
-
         if (!forkContext.reachable) {
             return;
         }
-
         const context = getBreakContext(this, label);
-
-
-        if (context) {
+        if (_context) {
             context.brokenForkContext.add(forkContext.head);
         }
-
         /* c8 ignore next */
         forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
     }
-
     /**
      * Makes a path for a `continue` statement.
      *
@@ -2276,17 +1954,13 @@ class CodePathState {
      */
     makeContinue(label) {
         const forkContext = this.forkContext;
-
         if (!forkContext.reachable) {
             return;
         }
-
         const context = getContinueContext(this, label);
-
-        if (context) {
+        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"
@@ -2299,7 +1973,6 @@ class CodePathState {
         }
         forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
     }
-
     /**
      * Makes a path for a `return` statement.
      *
@@ -2309,13 +1982,11 @@ class CodePathState {
      */
     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.
      *
@@ -2325,24 +1996,20 @@ class CodePathState {
      */
     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;
+module.exports = CodePathState;