code: 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);
  		}
docs: 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}