makeFinallyBlock() {
    const context = this.tryContext;
    let forkContext = this.forkContext;
    const returned = context.returnedForkContext;
    const thrown = context.thrownForkContext;
    const headOfLeavingSegments = forkContext.head;

    // Update state.
    if (context.position === 'catch') {
      // Merges two paths from the `try` block and `catch` block.
      this.popForkContext();
      forkContext = this.forkContext;

      context.lastOfCatchIsReachable = forkContext.reachable;
    } else {
      context.lastOfTryIsReachable = forkContext.reachable;
    }
    context.position = 'finally';

    if (returned.empty && thrown.empty) {
      // This path does not leave.
      return;
    }

    /*
     * Create a parallel segment from merging returned and thrown.
     * This segment will leave at the end of this finally block.
     */
    const segments = forkContext.makeNext(-1, -1);

    for (let i = 0; i < forkContext.count; ++i) {
      const prevSegsOfLeavingSegment = [headOfLeavingSegments[i]];

      for (let j = 0; j < returned.segmentsList.length; ++j) {
        prevSegsOfLeavingSegment.push(returned.segmentsList[j][i]);
      }
      for (let j = 0; j < thrown.segmentsList.length; ++j) {
        prevSegsOfLeavingSegment.push(thrown.segmentsList[j][i]);
      }

      segments.push(
        CodePathSegment.newNext(
          this.idGenerator.next(),
          prevSegsOfLeavingSegment,
        ),
      );
    }

    this.pushForkContext(true);
    this.forkContext.add(segments);
  }
Makes a code path segment 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}