[folding] move indentRanges out of textModel

src/vs/editor/common/editorCommon.ts

@@ -15,7 +15,6 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import { Position, IPosition } from 'vs/editor/common/core/position';
 import { Range, IRange } from 'vs/editor/common/core/range';
 import { Selection, ISelection } from 'vs/editor/common/core/selection';
-import { IndentRanges } from 'vs/editor/common/model/indentRanges';
 import { ITextSource } from 'vs/editor/common/model/textSource';
 import {
 	ModelRawContentChangedEvent, IModelContentChangedEvent, IModelDecorationsChangedEvent,
@@ -896,11 +895,6 @@ export interface ITokenizedModel extends ITextModel {
 	 */
 	matchBracket(position: IPosition): [Range, Range];
 
-	/**
-	 * @internal
-	 */
-	getIndentRanges(): IndentRanges;
-
 	/**
 	 * @internal
 	 */

src/vs/editor/common/model/editableTextModel.ts

@@ -664,8 +664,6 @@ export class EditableTextModel extends TextModelWithDecorations implements edito
 			};
 			this._eventEmitter.emit(textModelEvents.TextModelEventType.ModelContentChanged, e);
 		}
-
-		this._resetIndentRanges();
 	}
 
 	private _undo(): Selection[] {

src/vs/editor/common/model/textModelWithTokens.ts

@@ -22,7 +22,6 @@ import { getWordAtText } from 'vs/editor/common/model/wordHelper';
 import { TokenizationResult2 } from 'vs/editor/common/core/token';
 import { ITextSource, IRawTextSource } from 'vs/editor/common/model/textSource';
 import * as textModelEvents from 'vs/editor/common/model/textModelEvents';
-import { IndentRanges, computeRanges } from 'vs/editor/common/model/indentRanges';
 import { computeIndentLevel } from 'vs/editor/common/model/modelLine';
 
 class ModelTokensChangedEventBuilder {
@@ -71,7 +70,6 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 	private _invalidLineStartIndex: number;
 	private _lastState: IState;
 
-	private _indentRanges: IndentRanges;
 	private _languageRegistryListener: IDisposable;
 
 	private _revalidateTokensTimeout: number;
@@ -102,13 +100,11 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 
 		this._languageRegistryListener = LanguageConfigurationRegistry.onDidChange((e) => {
 			if (e.languageIdentifier.id === this._languageIdentifier.id) {
-				this._resetIndentRanges();
 				this._emitModelLanguageConfigurationEvent({});
 			}
 		});
 
 		this._resetTokenizationState();
-		this._resetIndentRanges();
 	}
 
 	public dispose(): void {
@@ -128,7 +124,6 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		super._resetValue(newValue);
 		// Cancel tokenization, clear all tokens and begin tokenizing
 		this._resetTokenizationState();
-		this._resetIndentRanges();
 	}
 
 	protected _resetTokenizationState(): void {
@@ -240,7 +235,6 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 
 		// Cancel tokenization, clear all tokens and begin tokenizing
 		this._resetTokenizationState();
-		this._resetIndentRanges();
 
 		this.emitModelTokensChangedEvent({
 			ranges: [{
@@ -838,24 +832,6 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		};
 	}
 
-	protected _resetIndentRanges(): void {
-		this._indentRanges = null;
-	}
-
-	private _getIndentRanges(): IndentRanges {
-		if (!this._indentRanges) {
-			let foldingRules = LanguageConfigurationRegistry.getFoldingRules(this._languageIdentifier.id);
-			let offSide = foldingRules && foldingRules.offSide;
-			let markers = foldingRules && foldingRules.markers;
-			this._indentRanges = computeRanges(this, offSide, markers);
-		}
-		return this._indentRanges;
-	}
-
-	public getIndentRanges(): IndentRanges {
-		return this._getIndentRanges();
-	}
-
 	private _computeIndentLevel(lineIndex: number): number {
 		return computeIndentLevel(this._lines[lineIndex].text, this._options.tabSize);
 	}

src/vs/editor/contrib/folding/common/foldingRanges.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+export interface ILineRange {
+	startLineNumber: number;
+	endLineNumber: number;
+}
+
+export const MAX_FOLDING_REGIONS = 0xFFFF;
+export const MAX_LINE_NUMBER = 0xFFFFFF;
+
+const MASK_INDENT = 0xFF000000;
+
+export class FoldingRanges {
+	private _startIndexes: Uint32Array;
+	private _endIndexes: Uint32Array;
+
+	constructor(startIndexes: Uint32Array, endIndexes: Uint32Array) {
+		if (startIndexes.length !== endIndexes.length || startIndexes.length > MAX_FOLDING_REGIONS) {
+			throw new Error('invalid startIndexes or endIndexes size');
+		}
+		this._startIndexes = startIndexes;
+		this._endIndexes = endIndexes;
+		this._computeParentIndices();
+	}
+
+	private _computeParentIndices() {
+		let parentIndexes = [];
+		let isInsideLast = (startLineNumber: number, endLineNumber: number) => {
+			let index = parentIndexes[parentIndexes.length - 1];
+			return this.getStartLineNumber(index) <= startLineNumber && this.getEndLineNumber(index) >= endLineNumber;
+		};
+		for (let i = 0, len = this._startIndexes.length; i < len; i++) {
+			let startLineNumber = this._startIndexes[i];
+			let endLineNumber = this._endIndexes[i];
+			if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {
+				throw new Error('startLineNumber or endLineNumber must not exceed ' + MAX_LINE_NUMBER);
+			}
+			while (parentIndexes.length > 0 && !isInsideLast(startLineNumber, endLineNumber)) {
+				parentIndexes.pop();
+			}
+			let parentIndex = parentIndexes.length > 0 ? parentIndexes[parentIndexes.length - 1] : -1;
+			parentIndexes.push(i);
+			this._startIndexes[i] = startLineNumber + ((parentIndex & 0xFF) << 24);
+			this._endIndexes[i] = endLineNumber + ((parentIndex & 0xFF00) << 16);
+		}
+	}
+
+	public get length(): number {
+		return this._startIndexes.length;
+	}
+
+	public getStartLineNumber(index: number): number {
+		return this._startIndexes[index] & MAX_LINE_NUMBER;
+	}
+
+	public getEndLineNumber(index: number): number {
+		return this._endIndexes[index] & MAX_LINE_NUMBER;
+	}
+
+	public getParentIndex(index: number) {
+		let parent = ((this._startIndexes[index] & MASK_INDENT) >>> 24) + ((this._endIndexes[index] & MASK_INDENT) >>> 16);
+		if (parent === MAX_FOLDING_REGIONS) {
+			return -1;
+		}
+		return parent;
+	}
+
+	public contains(index: number, line: number) {
+		return this.getStartLineNumber(index) <= line && this.getEndLineNumber(index) >= line;
+	}
+
+	isAfterLine(index: number, lineNumber: number): boolean {
+		return lineNumber < this.getStartLineNumber(index);
+	}
+	isBeforeLine(index: number, lineNumber: number): boolean {
+		return lineNumber > this.getEndLineNumber(index);
+	}
+	containsRange(index: number, range: ILineRange): boolean {
+		return this.getStartLineNumber(index) <= range.startLineNumber && this.getEndLineNumber(index) >= range.endLineNumber;
+	}
+	containedBy(index: number, range: ILineRange): boolean {
+		return range.startLineNumber <= this.getStartLineNumber(index) && range.endLineNumber >= this.getEndLineNumber(index);
+	}
+	containsLine(index: number, lineNumber: number) {
+		return this.getStartLineNumber(index) <= lineNumber && lineNumber <= this.getEndLineNumber(index);
+	}
+	hidesLine(index: number, lineNumber: number) {
+		return this.getStartLineNumber(index) < lineNumber && lineNumber <= this.getEndLineNumber(index);
+	}
+
+	private findIndex(line: number) {
+		let low = 0, high = this._startIndexes.length;
+		if (high === 0) {
+			return -1; // no children
+		}
+		while (low < high) {
+			let mid = Math.floor((low + high) / 2);
+			if (line < this.getStartLineNumber(mid)) {
+				high = mid;
+			} else {
+				low = mid + 1;
+			}
+		}
+		return low - 1;
+	}
+
+
+	public findRange(line: number): number {
+		let index = this.findIndex(line);
+		if (index >= 0) {
+			let endLineNumber = this.getEndLineNumber(index);
+			if (endLineNumber >= line) {
+				return index;
+			}
+			index = this.getParentIndex(index);
+			while (index !== -1) {
+				if (this.contains(index, line)) {
+					return index;
+				}
+				index = this.getParentIndex(index);
+			}
+		}
+		return -1;
+	}
+}
\ No newline at end of file

src/vs/editor/common/model/indentRanges.ts → src/vs/editor/contrib/folding/common/indentRangeProvider.ts

@@ -8,134 +8,28 @@
 import { ITextModel } from 'vs/editor/common/editorCommon';
 import { FoldingMarkers } from 'vs/editor/common/modes/languageConfiguration';
 import { computeIndentLevel } from 'vs/editor/common/model/modelLine';
-
-export const MAX_FOLDING_REGIONS = 0xFFFF;
+import { FoldingRanges, MAX_LINE_NUMBER } from 'vs/editor/contrib/folding/common/foldingRanges';
 
 const MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT = 5000;
-const MASK_LINE_NUMBER = 0xFFFFFF;
-const MASK_INDENT = 0xFF000000;
-
-export class IndentRanges {
-	private _startIndexes: Uint32Array;
-	private _endIndexes: Uint32Array;
-	private _model: ITextModel;
-
-	constructor(startIndexes: Uint32Array, endIndexes: Uint32Array, model: ITextModel) {
-		if (startIndexes.length !== endIndexes.length || startIndexes.length > MAX_FOLDING_REGIONS) {
-			throw new Error('invalid startIndexes or endIndexes size');
-		}
-		this._startIndexes = startIndexes;
-		this._endIndexes = endIndexes;
-		this._model = model;
-		this._computeParentIndices();
-	}
-
-	private _computeParentIndices() {
-		let parentIndexes = [];
-		let isInsideLast = (startLineNumber: number, endLineNumber: number) => {
-			let index = parentIndexes[parentIndexes.length - 1];
-			return this.getStartLineNumber(index) <= startLineNumber && this.getEndLineNumber(index) >= endLineNumber;
-		};
-		for (let i = 0, len = this._startIndexes.length; i < len; i++) {
-			let startLineNumber = this._startIndexes[i];
-			let endLineNumber = this._endIndexes[i];
-			if (startLineNumber > MASK_LINE_NUMBER || endLineNumber > MASK_LINE_NUMBER) {
-				throw new Error('startLineNumber or endLineNumber must not exceed ' + MASK_LINE_NUMBER);
-			}
-			while (parentIndexes.length > 0 && !isInsideLast(startLineNumber, endLineNumber)) {
-				parentIndexes.pop();
-			}
-			let parentIndex = parentIndexes.length > 0 ? parentIndexes[parentIndexes.length - 1] : -1;
-			parentIndexes.push(i);
-			this._startIndexes[i] = startLineNumber + ((parentIndex & 0xFF) << 24);
-			this._endIndexes[i] = endLineNumber + ((parentIndex & 0xFF00) << 16);
-		}
-	}
-
-	public get length(): number {
-		return this._startIndexes.length;
-	}
-
-	public getStartLineNumber(index: number): number {
-		return this._startIndexes[index] & MASK_LINE_NUMBER;
-	}
 
-	public getEndLineNumber(index: number): number {
-		return this._endIndexes[index] & MASK_LINE_NUMBER;
-	}
-
-	public getParentIndex(index: number) {
-		let parent = ((this._startIndexes[index] & MASK_INDENT) >>> 24) + ((this._endIndexes[index] & MASK_INDENT) >>> 16);
-		if (parent === MAX_FOLDING_REGIONS) {
-			return -1;
-		}
-		return parent;
-	}
-
-	public getIndent(index: number) {
-		const lineNumber = this.getStartLineNumber(index);
-		const tabSize = this._model.getOptions().tabSize;
-		const lineContent = this._model.getLineContent(lineNumber);
-		return computeIndentLevel(lineContent, tabSize);
-	}
-
-	public contains(index: number, line: number) {
-		return this.getStartLineNumber(index) <= line && this.getEndLineNumber(index) >= line;
-	}
-
-	private findIndex(line: number) {
-		let low = 0, high = this._startIndexes.length;
-		if (high === 0) {
-			return -1; // no children
-		}
-		while (low < high) {
-			let mid = Math.floor((low + high) / 2);
-			if (line < this.getStartLineNumber(mid)) {
-				high = mid;
-			} else {
-				low = mid + 1;
-			}
-		}
-		return low - 1;
-	}
-
-
-	public findRange(line: number): number {
-		let index = this.findIndex(line);
-		if (index >= 0) {
-			let endLineNumber = this.getEndLineNumber(index);
-			if (endLineNumber >= line) {
-				return index;
-			}
-			index = this.getParentIndex(index);
-			while (index !== -1) {
-				if (this.contains(index, line)) {
-					return index;
-				}
-				index = this.getParentIndex(index);
-			}
-		}
-		return -1;
-	}
-}
 // public only for testing
 export class RangesCollector {
 	private _startIndexes: number[];
 	private _endIndexes: number[];
 	private _indentOccurrences: number[];
 	private _length: number;
-	private _foldingRegionsLimit: number;
+	private _FoldingRangesLimit: number;
 
-	constructor(foldingRegionsLimit: number) {
+	constructor(FoldingRangesLimit: number) {
 		this._startIndexes = [];
 		this._endIndexes = [];
 		this._indentOccurrences = [];
 		this._length = 0;
-		this._foldingRegionsLimit = foldingRegionsLimit;
+		this._FoldingRangesLimit = FoldingRangesLimit;
 	}
 
 	public insertFirst(startLineNumber: number, endLineNumber: number, indent: number) {
-		if (startLineNumber > MASK_LINE_NUMBER || endLineNumber > MASK_LINE_NUMBER) {
+		if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {
 			return;
 		}
 		let index = this._length;
@@ -148,7 +42,7 @@ export class RangesCollector {
 	}
 
 	public toIndentRanges(model: ITextModel) {
-		if (this._length <= this._foldingRegionsLimit) {
+		if (this._length <= this._FoldingRangesLimit) {
 			// reverse and create arrays of the exact length
 			let startIndexes = new Uint32Array(this._length);
 			let endIndexes = new Uint32Array(this._length);
@@ -156,14 +50,14 @@ export class RangesCollector {
 				startIndexes[k] = this._startIndexes[i];
 				endIndexes[k] = this._endIndexes[i];
 			}
-			return new IndentRanges(startIndexes, endIndexes, model);
+			return new FoldingRanges(startIndexes, endIndexes);
 		} else {
 			let entries = 0;
 			let maxIndent = this._indentOccurrences.length;
 			for (let i = 0; i < this._indentOccurrences.length; i++) {
 				let n = this._indentOccurrences[i];
 				if (n) {
-					if (n + entries > this._foldingRegionsLimit) {
+					if (n + entries > this._FoldingRangesLimit) {
 						maxIndent = i;
 						break;
 					}
@@ -184,7 +78,7 @@ export class RangesCollector {
 					k++;
 				}
 			}
-			return new IndentRanges(startIndexes, endIndexes, model);
+			return new FoldingRanges(startIndexes, endIndexes);
 		}
 
 	}
@@ -193,9 +87,9 @@ export class RangesCollector {
 
 interface PreviousRegion { indent: number; line: number; marker: boolean; }
 
-export function computeRanges(model: ITextModel, offSide: boolean, markers?: FoldingMarkers, foldingRegionsLimit = MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT): IndentRanges {
+export function computeRanges(model: ITextModel, offSide: boolean, markers?: FoldingMarkers, FoldingRangesLimit = MAX_FOLDING_REGIONS_FOR_INDENT_LIMIT): FoldingRanges {
 	const tabSize = model.getOptions().tabSize;
-	let result = new RangesCollector(foldingRegionsLimit);
+	let result = new RangesCollector(FoldingRangesLimit);
 
 	let pattern = void 0;
 	if (markers) {

src/vs/editor/contrib/folding/folding.ts

@@ -23,6 +23,8 @@ import { IConfigurationChangedEvent } from 'vs/editor/common/config/editorOption
 import { IMarginData, IEmptyContentData } from 'vs/editor/browser/controller/mouseTarget';
 import { HiddenRangeModel } from 'vs/editor/contrib/folding/hiddenRangeModel';
 import { IRange } from 'vs/editor/common/core/range';
+import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
+import { computeRanges as computeIndentRanges } from 'vs/editor/contrib/folding/common/indentRangeProvider';
 
 export const ID = 'editor.contrib.folding';
 
@@ -164,7 +166,10 @@ export class FoldingController {
 	}
 
 	private computeRanges(editorModel: IModel) {
-		let ranges = editorModel.getIndentRanges();
+		let foldingRules = LanguageConfigurationRegistry.getFoldingRules(editorModel.getLanguageIdentifier().id);
+		let offSide = foldingRules && foldingRules.offSide;
+		let markers = foldingRules && foldingRules.markers;
+		let ranges = computeIndentRanges(editorModel, offSide, markers);
 		return ranges;
 	}
 

src/vs/editor/contrib/folding/foldingModel.ts

@@ -5,12 +5,7 @@
 
 import { IModel, IModelDecorationOptions } from 'vs/editor/common/editorCommon';
 import Event, { Emitter } from 'vs/base/common/event';
-import { IndentRanges } from 'vs/editor/common/model/indentRanges';
-
-export interface ILineRange {
-	startLineNumber: number;
-	endLineNumber: number;
-}
+import { FoldingRanges, ILineRange } from './foldingRanges';
 
 export interface IDecorationProvider {
 	getDecorationOption(region: FoldingRegion): IModelDecorationOptions;
@@ -28,7 +23,7 @@ export class FoldingModel {
 	private _decorationProvider: IDecorationProvider;
 
 	private _regions: FoldingRegion[] = [];
-	private _ranges: IndentRanges;
+	private _ranges: FoldingRanges;
 
 	private _updateEventEmitter = new Emitter<FoldingModelChangeEvent>();
 
@@ -58,7 +53,7 @@ export class FoldingModel {
 		this._updateEventEmitter.fire({ model: this, collapseStateChanged: regions });
 	}
 
-	public update(newRanges: IndentRanges): void {
+	public update(newRanges: FoldingRanges): void {
 		let editorDecorationIds = [];
 		let newEditorDecorations = [];
 
@@ -79,7 +74,7 @@ export class FoldingModel {
 		let recycleBin = this._regions;
 		let newRegions = [];
 
-		let newRegion = (ranges: IndentRanges, index: number, isCollapsed: boolean) => {
+		let newRegion = (ranges: FoldingRanges, index: number, isCollapsed: boolean) => {
 			let region = recycleBin.length ? recycleBin.pop() : new FoldingRegion();
 			region.init(ranges, index, isCollapsed);
 			newRegions.push(region);
@@ -209,9 +204,9 @@ export class FoldingModel {
 		let levelStack: FoldingRegion[] = trackLevel ? [] : null;
 		let index = region ? region.regionIndex + 1 : 0;
 		let endLineNumber = region ? region.endLineNumber : Number.MAX_VALUE;
-		for (let i = index, len = this.regions.length; i < len; i++) {
+		for (let i = index, len = this._ranges.length; i < len; i++) {
 			let current = this.regions[i];
-			if (current.startLineNumber < endLineNumber) {
+			if (this._ranges.getStartLineNumber(i) < endLineNumber) {
 				if (trackLevel) {
 					while (levelStack.length > 0 && !current.containedBy(levelStack[levelStack.length - 1])) {
 						levelStack.pop();
@@ -237,12 +232,12 @@ export class FoldingRegion {
 	public editorDecorationId: string;
 	public isCollapsed: boolean;
 	private index: number;
-	private indentRanges: IndentRanges;
+	private indentRanges: FoldingRanges;
 
 	constructor() {
 	}
 
-	public init(indentRanges: IndentRanges, index: number, isCollapsed: boolean): void {
+	public init(indentRanges: FoldingRanges, index: number, isCollapsed: boolean): void {
 		this.indentRanges = indentRanges;
 		this.index = index;
 		this.isCollapsed = isCollapsed;

src/vs/editor/contrib/folding/test/foldingModel.test.ts

@@ -7,7 +7,7 @@
 import * as assert from 'assert';
 import { FoldingModel, FoldingRegion, setCollapseStateAtLevel, setCollapseStateLevelsDown, setCollapseStateLevelsUp } from 'vs/editor/contrib/folding/foldingModel';
 import { Model } from 'vs/editor/common/model/model';
-import { computeRanges } from 'vs/editor/common/model/indentRanges';
+import { computeRanges } from 'vs/editor/contrib/folding/common/indentRangeProvider';
 import { ModelDecorationOptions } from 'vs/editor/common/model/textModelWithDecorations';
 import { TrackedRangeStickiness } from 'vs/editor/common/editorCommon';
 import { EditOperation } from 'vs/editor/common/core/editOperation';

src/vs/editor/contrib/folding/test/hiddenRangeModel.test.ts

@@ -7,7 +7,7 @@
 import * as assert from 'assert';
 import { FoldingModel } from 'vs/editor/contrib/folding/foldingModel';
 import { Model } from 'vs/editor/common/model/model';
-import { computeRanges } from 'vs/editor/common/model/indentRanges';
+import { computeRanges } from 'vs/editor/contrib/folding/common/indentRangeProvider';
 import { TestDecorationProvider } from './foldingModel.test';
 import { HiddenRangeModel } from 'vs/editor/contrib/folding/hiddenRangeModel';
 import { IRange } from 'vs/editor/common/core/range';

src/vs/editor/contrib/folding/test/indentFold.test.ts

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import { computeRanges } from 'vs/editor/common/model/indentRanges';
+import { computeRanges } from 'vs/editor/contrib/folding/common/indentRangeProvider';
 import { Model } from 'vs/editor/common/model/model';
 
 interface IndentRange {

src/vs/editor/test/common/model/indentRanges.test.ts → src/vs/editor/contrib/folding/test/indentRangeProvider.test.ts

@@ -7,13 +7,13 @@
 
 import * as assert from 'assert';
 import { Model } from 'vs/editor/common/model/model';
-import { computeRanges, MAX_FOLDING_REGIONS } from 'vs/editor/common/model/indentRanges';
+import { computeRanges } from 'vs/editor/contrib/folding/common/indentRangeProvider';
 import { FoldingMarkers } from 'vs/editor/common/modes/languageConfiguration';
+import { MAX_FOLDING_REGIONS } from 'vs/editor/contrib/folding/common/foldingRanges';
 
 export interface ExpectedIndentRange {
 	startLineNumber: number;
 	endLineNumber: number;
-	indent: number;
 	parentIndex: number;
 }
 
@@ -23,14 +23,14 @@ function assertRanges(lines: string[], expected: ExpectedIndentRange[], offside:
 
 	let actualRanges = [];
 	for (let i = 0; i < actual.length; i++) {
-		actualRanges[i] = r(actual.getStartLineNumber(i), actual.getEndLineNumber(i), actual.getIndent(i), actual.getParentIndex(i));
+		actualRanges[i] = r(actual.getStartLineNumber(i), actual.getEndLineNumber(i), actual.getParentIndex(i));
 	}
 	assert.deepEqual(actualRanges, expected);
 	model.dispose();
 }
 
-function r(startLineNumber: number, endLineNumber: number, indent: number, parentIndex: number, marker = false): ExpectedIndentRange {
-	return { startLineNumber, endLineNumber, indent, parentIndex };
+function r(startLineNumber: number, endLineNumber: number, parentIndex: number, marker = false): ExpectedIndentRange {
+	return { startLineNumber, endLineNumber, parentIndex };
 }
 
 suite('Indentation Folding', () => {
@@ -41,8 +41,8 @@ suite('Indentation Folding', () => {
 			'  A',
 			'  A'
 		];
-		assertRanges(range, [r(1, 4, 0, -1)], true);
-		assertRanges(range, [r(1, 4, 0, -1)], false);
+		assertRanges(range, [r(1, 4, -1)], true);
+		assertRanges(range, [r(1, 4, -1)], false);
 	});
 
 	test('Fold two levels', () => {
@@ -53,8 +53,8 @@ suite('Indentation Folding', () => {
 			'    A',
 			'    A'
 		];
-		assertRanges(range, [r(1, 5, 0, -1), r(3, 5, 2, 0)], true);
-		assertRanges(range, [r(1, 5, 0, -1), r(3, 5, 2, 0)], false);
+		assertRanges(range, [r(1, 5, -1), r(3, 5, 0)], true);
+		assertRanges(range, [r(1, 5, -1), r(3, 5, 0)], false);
 	});
 
 	test('Fold three levels', () => {
@@ -65,8 +65,8 @@ suite('Indentation Folding', () => {
 			'      A',
 			'A'
 		];
-		assertRanges(range, [r(1, 4, 0, -1), r(2, 4, 2, 0), r(3, 4, 4, 1)], true);
-		assertRanges(range, [r(1, 4, 0, -1), r(2, 4, 2, 0), r(3, 4, 4, 1)], false);
+		assertRanges(range, [r(1, 4, -1), r(2, 4, 0), r(3, 4, 1)], true);
+		assertRanges(range, [r(1, 4, -1), r(2, 4, 0), r(3, 4, 1)], false);
 	});
 
 	test('Fold decreasing indent', () => {
@@ -94,7 +94,7 @@ suite('Indentation Folding', () => {
 		/*11*/	'interface B {',
 		/*12*/	'  void bar();',
 		/*13*/	'}',
-		], [r(1, 9, 0, -1), r(2, 4, 2, 0), r(7, 8, 2, 0), r(11, 12, 0, -1)], false);
+		], [r(1, 9, -1), r(2, 4, 0), r(7, 8, 0), r(11, 12, -1)], false);
 	});
 
 	test('Fold Javadoc', () => {
@@ -106,7 +106,7 @@ suite('Indentation Folding', () => {
 		/* 5*/	'  void foo() {',
 		/* 6*/	'  }',
 		/* 7*/	'}',
-		], [r(1, 3, 0, -1), r(4, 6, 0, -1)], false);
+		], [r(1, 3, -1), r(4, 6, -1)], false);
 	});
 	test('Fold Whitespace Java', () => {
 		assertRanges([
@@ -118,7 +118,7 @@ suite('Indentation Folding', () => {
 		/* 6*/	'  }',
 		/* 7*/	'      ',
 		/* 8*/	'}',
-		], [r(1, 7, 0, -1), r(3, 5, 2, 0)], false);
+		], [r(1, 7, -1), r(3, 5, 0)], false);
 	});
 
 	test('Fold Whitespace Python', () => {
@@ -131,7 +131,7 @@ suite('Indentation Folding', () => {
 		/* 6*/	'  ',
 		/* 7*/	'      ',
 		/* 8*/	'def c: # since there was a deintent here'
-		], [r(1, 5, 0, -1), r(4, 5, 2, 0)], true);
+		], [r(1, 5, -1), r(4, 5, 0)], true);
 	});
 
 	test('Fold Tabs', () => {
@@ -144,7 +144,7 @@ suite('Indentation Folding', () => {
 		/* 6*/	'  \t}',
 		/* 7*/	'      ',
 		/* 8*/	'}',
-		], [r(1, 7, 0, -1), r(3, 5, 4, 0)], false);
+		], [r(1, 7, -1), r(3, 5, 0)], false);
 	});
 });
 
@@ -164,7 +164,7 @@ suite('Folding with regions', () => {
 		/* 6*/	'  }',
 		/* 7*/	'  #endregion',
 		/* 8*/	'}',
-		], [r(1, 7, 0, -1), r(2, 7, 2, 0, true), r(3, 5, 2, 1)], false, markers);
+		], [r(1, 7, -1), r(2, 7, 0, true), r(3, 5, 1)], false, markers);
 	});
 	test('Inside region, not indented', () => {
 		assertRanges([
@@ -176,7 +176,7 @@ suite('Folding with regions', () => {
 		/* 6*/	'  }',
 		/* 7*/	'#endregion',
 		/* 8*/	'',
-		], [r(2, 7, 0, -1, true), r(3, 6, 0, 0)], false, markers);
+		], [r(2, 7, -1, true), r(3, 6, 0)], false, markers);
 	});
 	test('Empty Regions', () => {
 		assertRanges([
@@ -187,7 +187,7 @@ suite('Folding with regions', () => {
 		/* 5*/	'',
 		/* 6*/	'#endregion',
 		/* 7*/	'var y;',
-		], [r(2, 3, 0, -1, true), r(4, 6, 0, -1, true)], false, markers);
+		], [r(2, 3, -1, true), r(4, 6, -1, true)], false, markers);
 	});
 	test('Nested Regions', () => {
 		assertRanges([
@@ -198,7 +198,7 @@ suite('Folding with regions', () => {
 		/* 5*/	'#endregion',
 		/* 6*/	'#endregion',
 		/* 7*/	'var y;',
-		], [r(2, 6, 0, -1, true), r(3, 5, 0, 0, true)], false, markers);
+		], [r(2, 6, -1, true), r(3, 5, 0, true)], false, markers);
 	});
 	test('Nested Regions 2', () => {
 		assertRanges([
@@ -211,7 +211,7 @@ suite('Folding with regions', () => {
 		/* 7*/	'  // comment',
 		/* 8*/	'  #endregion',
 		/* 9*/	'}',
-		], [r(1, 8, 0, -1), r(2, 8, 2, 0, true), r(4, 6, 2, 1, true)], false, markers);
+		], [r(1, 8, -1), r(2, 8, 0, true), r(4, 6, 1, true)], false, markers);
 	});
 	test('Incomplete Regions', () => {
 		assertRanges([
@@ -219,7 +219,7 @@ suite('Folding with regions', () => {
 		/* 2*/	'#region',
 		/* 3*/	'  // comment',
 		/* 4*/	'}',
-		], [r(2, 3, 0, -1)], false, markers);
+		], [r(2, 3, -1)], false, markers);
 	});
 	test('Incomplete Regions 2', () => {
 		assertRanges([
@@ -231,7 +231,7 @@ suite('Folding with regions', () => {
 		/* 6*/	'#endregion',
 		/* 7*/	'#endregion',
 		/* 8*/	' // hello',
-		], [r(3, 7, 0, -1, true), r(4, 6, 0, 0, true)], false, markers);
+		], [r(3, 7, -1, true), r(4, 6, 0, true)], false, markers);
 	});
 	test('Indented region before', () => {
 		assertRanges([
@@ -241,7 +241,7 @@ suite('Folding with regions', () => {
 		/* 4*/	'#region',
 		/* 5*/	'  // comment',
 		/* 6*/	'#endregion',
-		], [r(1, 3, 0, -1), r(4, 6, 0, -1, true)], false, markers);
+		], [r(1, 3, -1), r(4, 6, -1, true)], false, markers);
 	});
 	test('Indented region before 2', () => {
 		assertRanges([
@@ -251,7 +251,7 @@ suite('Folding with regions', () => {
 		/* 4*/	'    #region',
 		/* 5*/	'      // comment',
 		/* 6*/	'    #endregion',
-		], [r(1, 6, 0, -1), r(2, 6, 2, 0), r(4, 6, 4, 1, true)], false, markers);
+		], [r(1, 6, -1), r(2, 6, 0), r(4, 6, 1, true)], false, markers);
 	});
 	test('Indented region in-between', () => {
 		assertRanges([
@@ -261,7 +261,7 @@ suite('Folding with regions', () => {
 		/* 4*/	'    return;',
 		/* 5*/	'',
 		/* 6*/	'#endregion',
-		], [r(1, 6, 0, -1, true), r(3, 5, 2, 0)], false, markers);
+		], [r(1, 6, -1, true), r(3, 5, 0)], false, markers);
 	});
 	test('Indented region after', () => {
 		assertRanges([
@@ -271,7 +271,7 @@ suite('Folding with regions', () => {
 		/* 4*/	'#endregion',
 		/* 5*/	'  if (x)',
 		/* 6*/	'    return;',
-		], [r(1, 4, 0, -1, true), r(5, 6, 2, -1)], false, markers);
+		], [r(1, 4, -1, true), r(5, 6, -1)], false, markers);
 	});
 	test('With off-side', () => {
 		assertRanges([
@@ -280,7 +280,7 @@ suite('Folding with regions', () => {
 		/* 3*/	'',
 		/* 4*/	'#endregion',
 		/* 5*/	'',
-		], [r(1, 4, 0, -1, true)], true, markers);
+		], [r(1, 4, -1, true)], true, markers);
 	});
 	test('Nested with off-side', () => {
 		assertRanges([
@@ -292,7 +292,7 @@ suite('Folding with regions', () => {
 		/* 6*/	'',
 		/* 7*/	'#endregion',
 		/* 8*/	'',
-		], [r(1, 7, 0, -1, true), r(3, 5, 0, 0, true)], true, markers);
+		], [r(1, 7, -1, true), r(3, 5, 0, true)], true, markers);
 	});
 	test('Issue 35981', () => {
 		assertRanges([
@@ -305,7 +305,7 @@ suite('Folding with regions', () => {
 		/* 7*/	'function thisFoldsProperly() {',
 		/* 8*/	'  const foo = "bar"',
 		/* 9*/	'}',
-		], [r(1, 4, 0, -1), r(2, 4, 2, 0), r(7, 8, 0, -1)], false, markers);
+		], [r(1, 4, -1), r(2, 4, 0), r(7, 8, -1)], false, markers);
 	});
 	test('Misspelled Markers', () => {
 		assertRanges([