guard-sass-lint 0.1.0 → 0.1.1

data/node_modules/eslint/lib/code-path-analysis/code-path-segment.js

@@ -0,0 +1,241 @@
+/**
+ * @fileoverview A class of the code path segment.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var debug = require("./debug-helpers");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Replaces unused segments with the previous segments of each unused segment.
+ *
+ * @param {CodePathSegment[]} segments - An array of segments to replace.
+ * @returns {CodePathSegment[]} The replaced array.
+ */
+function flattenUnusedSegments(segments) {
+    var done = Object.create(null);
+    var retv = [];
+
+    for (var i = 0; i < segments.length; ++i) {
+        var segment = segments[i];
+
+        // Ignores duplicated.
+        if (done[segment.id]) {
+            continue;
+        }
+
+        // Use previous segments if unused.
+        if (!segment.internal.used) {
+            for (var j = 0; j < segment.allPrevSegments.length; ++j) {
+                var prevSegment = segment.allPrevSegments[j];
+
+                if (!done[prevSegment.id]) {
+                    done[prevSegment.id] = true;
+                    retv.push(prevSegment);
+                }
+            }
+        } else {
+            done[segment.id] = true;
+            retv.push(segment);
+        }
+    }
+
+    return retv;
+}
+
+/**
+ * Checks whether or not a given segment is reachable.
+ *
+ * @param {CodePathSegment} segment - A segment to check.
+ * @returns {boolean} `true` if the segment is reachable.
+ */
+function isReachable(segment) {
+    return segment.reachable;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * A code path segment.
+ *
+ * @constructor
+ * @param {string} id - An identifier.
+ * @param {CodePathSegment[]} allPrevSegments - An array of the previous segments.
+ *   This array includes unreachable segments.
+ * @param {boolean} reachable - A flag which shows this is reachable.
+ */
+function CodePathSegment(id, allPrevSegments, reachable) {
+
+    /**
+     * The identifier of this code path.
+     * Rules use it to store additional information of each rule.
+     * @type {string}
+     */
+    this.id = id;
+
+    /**
+     * An array of the next segments.
+     * @type {CodePathSegment[]}
+     */
+    this.nextSegments = [];
+
+    /**
+     * An array of the previous segments.
+     * @type {CodePathSegment[]}
+     */
+    this.prevSegments = allPrevSegments.filter(isReachable);
+
+    /**
+     * An array of the next segments.
+     * This array includes unreachable segments.
+     * @type {CodePathSegment[]}
+     */
+    this.allNextSegments = [];
+
+    /**
+     * An array of the previous segments.
+     * This array includes unreachable segments.
+     * @type {CodePathSegment[]}
+     */
+    this.allPrevSegments = allPrevSegments;
+
+    /**
+     * A flag which shows this is reachable.
+     * @type {boolean}
+     */
+    this.reachable = reachable;
+
+    // Internal data.
+    Object.defineProperty(this, "internal", {value: {
+        used: false,
+        loopedPrevSegments: []
+    }});
+
+    /* istanbul ignore if */
+    if (debug.enabled) {
+        this.internal.nodes = [];
+        this.internal.exitNodes = [];
+    }
+}
+
+CodePathSegment.prototype = {
+    constructor: CodePathSegment,
+
+    /**
+     * Checks a given previous segment is coming from the end of a loop.
+     *
+     * @param {CodePathSegment} segment - A previous segment to check.
+     * @returns {boolean} `true` if the segment is coming from the end of a loop.
+     */
+    isLoopedPrevSegment: function(segment) {
+        return this.internal.loopedPrevSegments.indexOf(segment) !== -1;
+    }
+};
+
+/**
+ * Creates the root segment.
+ *
+ * @param {string} id - An identifier.
+ * @returns {CodePathSegment} The created segment.
+ */
+CodePathSegment.newRoot = function(id) {
+    return new CodePathSegment(id, [], true);
+};
+
+/**
+ * Creates a segment that follows given segments.
+ *
+ * @param {string} id - An identifier.
+ * @param {CodePathSegment[]} allPrevSegments - An array of the previous segments.
+ * @returns {CodePathSegment} The created segment.
+ */
+CodePathSegment.newNext = function(id, allPrevSegments) {
+    return new CodePathSegment(
+        id,
+        flattenUnusedSegments(allPrevSegments),
+        allPrevSegments.some(isReachable));
+};
+
+/**
+ * Creates an unreachable segment that follows given segments.
+ *
+ * @param {string} id - An identifier.
+ * @param {CodePathSegment[]} allPrevSegments - An array of the previous segments.
+ * @returns {CodePathSegment} The created segment.
+ */
+CodePathSegment.newUnreachable = function(id, allPrevSegments) {
+    var segment = new CodePathSegment(id, flattenUnusedSegments(allPrevSegments), false);
+
+    // In `if (a) return a; foo();` case, the unreachable segment preceded by
+    // the return statement is not used but must not be remove.
+    CodePathSegment.markUsed(segment);
+
+    return segment;
+};
+
+/**
+ * Creates a segment that follows given segments.
+ * This factory method does not connect with `allPrevSegments`.
+ * But this inherits `reachable` flag.
+ *
+ * @param {string} id - An identifier.
+ * @param {CodePathSegment[]} allPrevSegments - An array of the previous segments.
+ * @returns {CodePathSegment} The created segment.
+ */
+CodePathSegment.newDisconnected = function(id, allPrevSegments) {
+    return new CodePathSegment(id, [], allPrevSegments.some(isReachable));
+};
+
+/**
+ * Makes a given segment being used.
+ *
+ * And this function registers the segment into the previous segments as a next.
+ *
+ * @param {CodePathSegment} segment - A segment to mark.
+ * @returns {void}
+ */
+CodePathSegment.markUsed = function(segment) {
+    if (segment.internal.used) {
+        return;
+    }
+    segment.internal.used = true;
+
+    var i;
+
+    if (segment.reachable) {
+        for (i = 0; i < segment.allPrevSegments.length; ++i) {
+            var prevSegment = segment.allPrevSegments[i];
+
+            prevSegment.allNextSegments.push(segment);
+            prevSegment.nextSegments.push(segment);
+        }
+    } else {
+        for (i = 0; i < segment.allPrevSegments.length; ++i) {
+            segment.allPrevSegments[i].allNextSegments.push(segment);
+        }
+    }
+};
+
+/**
+ * Marks a previous segment as looped.
+ *
+ * @param {CodePathSegment} segment - A segment.
+ * @param {CodePathSegment} prevSegment - A previous segment to mark.
+ * @returns {void}
+ */
+CodePathSegment.markPrevSegmentAsLooped = function(segment, prevSegment) {
+    segment.internal.loopedPrevSegments.push(prevSegment);
+};
+
+module.exports = CodePathSegment;

data/node_modules/eslint/lib/code-path-analysis/code-path-state.js

@@ -0,0 +1,1428 @@
+/**
+ * @fileoverview A class to manage state of generating a code path.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var 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 (var i = 0; i < segments.length; ++i) {
+        var 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;
+    }
+
+    var 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) {
+    var 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) {
+    var 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) {
+    var 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 (var i = 0; i < prevSegments.length; ++i) {
+        var prevSegment = prevSegments[i];
+        var 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[]} fromSegments - Segments which are source.
+ * @param {CodePathSegment[]} toSegments - Segments which are destination.
+ * @returns {void}
+ */
+function makeLooped(state, fromSegments, toSegments) {
+    var end = Math.min(fromSegments.length, toSegments.length);
+
+    for (var i = 0; i < end; ++i) {
+        var fromSegment = fromSegments[i];
+        var 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.
+ *
+ * @constructor
+ * @param {IdGenerator} idGenerator - An id generator to generate id for code
+ *   path segments.
+ * @param {function} onLooped - A callback function to notify looping.
+ */
+function CodePathState(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.
+    var final = this.finalSegments = [];
+    var returned = this.returnedForkContext = [];
+    var thrown = this.thrownForkContext = [];
+
+    returned.add = addToReturnedOrThrown.bind(null, returned, thrown, final);
+    thrown.add = addToReturnedOrThrown.bind(null, thrown, returned, final);
+}
+
+CodePathState.prototype = {
+    constructor: CodePathState,
+
+    /**
+     * 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() {
+        var 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: function(forkLeavingPath) {
+        this.forkContext = ForkContext.newEmpty(
+            this.forkContext,
+            forkLeavingPath
+        );
+
+        return this.forkContext;
+    },
+
+    /**
+     * Pops and merges the last forking context.
+     * @returns {ForkContext} The last context.
+     */
+    popForkContext: function() {
+        var lastContext = this.forkContext;
+
+        this.forkContext = lastContext.upper;
+        this.forkContext.replaceHead(lastContext.makeNext(0, -1));
+
+        return lastContext;
+    },
+
+    /**
+     * Creates a new path.
+     * @returns {void}
+     */
+    forkPath: function() {
+        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: function() {
+        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: function(kind, isForkingAsResult) {
+        this.choiceContext = {
+            upper: this.choiceContext,
+            kind: kind,
+            isForkingAsResult: 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: function() {
+        var context = this.choiceContext;
+
+        this.choiceContext = context.upper;
+
+        var forkContext = this.forkContext;
+        var 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) {
+                    var 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.
+        var 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: function() {
+        var context = this.choiceContext;
+        var 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.
+             */
+            var 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: function() {
+        var context = this.choiceContext;
+        var 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: function() {
+        var context = this.choiceContext;
+        var 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: function(hasCase, label) {
+        this.switchContext = {
+            upper: this.switchContext,
+            hasCase: 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: function() {
+        var context = this.switchContext;
+
+        this.switchContext = context.upper;
+
+        var forkContext = this.forkContext;
+        var 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;
+        }
+
+        var lastSegments = forkContext.head;
+
+        this.forkBypassPath();
+        var 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 (var 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: function(isEmpty, isDefault) {
+        var 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.
+         */
+        var parentForkContext = this.forkContext;
+        var 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: function(hasFinalizer) {
+        this.tryContext = {
+            upper: this.tryContext,
+            position: "try",
+            hasFinalizer: 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: function() {
+        var 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.
+         */
+
+        var returned = context.returnedForkContext;
+        var thrown = context.thrownForkContext;
+
+        if (returned.empty && thrown.empty) {
+            return;
+        }
+
+        // Separate head to normal paths and leaving paths.
+        var headSegments = this.forkContext.head;
+
+        this.forkContext = this.forkContext.upper;
+        var normalSegments = headSegments.slice(0, headSegments.length / 2 | 0);
+        var 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: function() {
+        var context = this.tryContext;
+        var forkContext = this.forkContext;
+        var thrown = context.thrownForkContext;
+
+        // Update state.
+        context.position = "catch";
+        context.thrownForkContext = ForkContext.newEmpty(forkContext);
+        context.lastOfTryIsReachable = forkContext.reachable;
+
+        // Merge thrown paths.
+        thrown.add(forkContext.head);
+        var 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: function() {
+        var context = this.tryContext;
+        var forkContext = this.forkContext;
+        var returned = context.returnedForkContext;
+        var thrown = context.thrownForkContext;
+        var 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.
+         */
+        var segments = forkContext.makeNext(-1, -1);
+        var j;
+
+        for (var i = 0; i < forkContext.count; ++i) {
+            var prevSegsOfLeavingSegment = [headOfLeavingSegments[i]];
+
+            for (j = 0; j < returned.segmentsList.length; ++j) {
+                prevSegsOfLeavingSegment.push(returned.segmentsList[j][i]);
+            }
+            for (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: function() {
+        var forkContext = this.forkContext;
+
+        if (!forkContext.reachable) {
+            return;
+        }
+
+        var 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: function(type, label) {
+        var forkContext = this.forkContext;
+        var breakContext = this.pushBreakContext(true, label);
+
+        switch (type) {
+            case "WhileStatement":
+                this.pushChoiceContext("loop", false);
+                this.loopContext = {
+                    upper: this.loopContext,
+                    type: type,
+                    label: label,
+                    test: void 0,
+                    continueDestSegments: null,
+                    brokenForkContext: breakContext.brokenForkContext
+                };
+                break;
+
+            case "DoWhileStatement":
+                this.pushChoiceContext("loop", false);
+                this.loopContext = {
+                    upper: this.loopContext,
+                    type: type,
+                    label: 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: type,
+                    label: 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: type,
+                    label: 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: function() {
+        var context = this.loopContext;
+
+        this.loopContext = context.upper;
+
+        var forkContext = this.forkContext;
+        var brokenForkContext = this.popBreakContext().brokenForkContext;
+        var choiceContext;
+
+        // Creates a looped path.
+        switch (context.type) {
+            case "WhileStatement":
+            case "ForStatement":
+                choiceContext = this.popChoiceContext();
+                makeLooped(
+                    this,
+                    forkContext.head,
+                    context.continueDestSegments);
+                break;
+
+            case "DoWhileStatement":
+                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.
+                var segmentsList = choiceContext.trueForkContext.segmentsList;
+
+                for (var 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: function(test) {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+        var 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: function() {
+        var context = this.loopContext;
+        var choiceContext = this.choiceContext;
+        var 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: function() {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+        var 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: function(test) {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+
+        context.test = test;
+
+        // Creates paths of `continue` statements.
+        if (!context.continueForkContext.empty) {
+            context.continueForkContext.add(forkContext.head);
+            var 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: function(test) {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+        var endOfInitSegments = forkContext.head;
+        var 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: function() {
+        var context = this.loopContext;
+        var choiceContext = this.choiceContext;
+        var 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.
+        var 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: function() {
+        var context = this.loopContext;
+        var choiceContext = this.choiceContext;
+        var 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;
+        }
+
+        var bodySegments = context.endOfTestSegments;
+
+        if (!bodySegments) {
+
+            /*
+             * If there is not the `test` part, the `body` path comes from the
+             * `init` part and the `update` part.
+             */
+            var 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: function() {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+        var 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: function() {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+        var temp = ForkContext.newEmpty(forkContext);
+
+        temp.add(context.prevSegments);
+        var 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: function() {
+        var context = this.loopContext;
+        var forkContext = this.forkContext;
+        var temp = ForkContext.newEmpty(forkContext);
+
+        temp.add(context.endOfLeftSegments);
+        var 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: function(breakable, label) {
+        this.breakContext = {
+            upper: this.breakContext,
+            breakable: breakable,
+            label: label,
+            brokenForkContext: ForkContext.newEmpty(this.forkContext)
+        };
+        return this.breakContext;
+    },
+
+    /**
+     * Removes the top item of the break context stack.
+     *
+     * @returns {object} The removed context.
+     */
+    popBreakContext: function() {
+        var context = this.breakContext;
+        var forkContext = this.forkContext;
+
+        this.breakContext = context.upper;
+
+        // Process this context here for other than switches and loops.
+        if (!context.breakable) {
+            var 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: function(label) {
+        var forkContext = this.forkContext;
+
+        if (!forkContext.reachable) {
+            return;
+        }
+
+        var 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: function(label) {
+        var forkContext = this.forkContext;
+
+        if (!forkContext.reachable) {
+            return;
+        }
+
+        var 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: function() {
+        var 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: function() {
+        var 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: function() {
+        var segments = this.currentSegments;
+
+        if (segments.length > 0 && segments[0].reachable) {
+            this.returnedForkContext.add(segments);
+        }
+    }
+};
+
+module.exports = CodePathState;