Fixes #3559: C# folding error

src/vs/editor/browser/viewLayout/layoutProvider.ts

@@ -174,11 +174,8 @@ export class LayoutProvider extends ViewEventHandler implements IDisposable, ILa
 	public addWhitespace(afterLineNumber:number, ordinal:number, height:number): number {
 		return this.linesLayout.insertWhitespace(afterLineNumber, ordinal, height);
 	}
-	public changeWhitespace(id:number, newHeight:number): boolean {
-		return this.linesLayout.changeWhitespace(id, newHeight);
-	}
-	public changeAfterLineNumberForWhitespace(id:number, newAfterLineNumber:number): boolean {
-		return this.linesLayout.changeAfterLineNumberForWhitespace(id, newAfterLineNumber);
+	public changeWhitespace(id:number, newAfterLineNumber:number, newHeight:number): boolean {
+		return this.linesLayout.changeWhitespace(id, newAfterLineNumber, newHeight);
 	}
 	public removeWhitespace(id:number): boolean {
 		return this.linesLayout.removeWhitespace(id);

src/vs/editor/browser/viewParts/contentWidgets/contentWidgets.ts

@@ -297,11 +297,14 @@ export class ViewContentWidgets extends ViewPart {
 		}
 
 		// Do not trust that widgets have a valid position
-		let validModelPosition = this._context.model.validateModelPosition(widgetData.position),
-			position = this._context.model.convertModelPositionToViewPosition(validModelPosition.lineNumber, validModelPosition.column),
-			pref:ContentWidgetPositionPreference,
-			pass:number,
-			i:number;
+		let validModelPosition = this._context.model.validateModelPosition(widgetData.position);
+
+		if (!this._context.model.modelPositionIsVisible(validModelPosition)) {
+			// this position is hidden by the view model
+			return null;
+		}
+
+		let	position = this._context.model.convertModelPositionToViewPosition(validModelPosition.lineNumber, validModelPosition.column);
 
 		let placement: IBoxLayoutResult = null;
 		let fetchPlacement = () => {
@@ -318,9 +321,9 @@ export class ViewContentWidgets extends ViewPart {
 		};
 
 		// Do two passes, first for perfect fit, second picks first option
-		for (pass = 1; pass <= 2; pass++) {
-			for (i = 0; i < widgetData.preference.length; i++) {
-				pref = widgetData.preference[i];
+		for (let pass = 1; pass <= 2; pass++) {
+			for (let i = 0; i < widgetData.preference.length; i++) {
+				let pref = widgetData.preference[i];
 				if (pref === ContentWidgetPositionPreference.ABOVE) {
 					fetchPlacement();
 					if (!placement) {

src/vs/editor/browser/viewParts/viewZones/viewZones.ts

@@ -20,6 +20,11 @@ export interface IMyRenderData {
 	data: editorCommon.IViewWhitespaceViewportData[];
 }
 
+interface IComputedViewZoneProps {
+	afterViewLineNumber: number;
+	heightInPx: number;
+}
+
 export class ViewZones extends ViewPart {
 
 	private _whitespaceManager:editorCommon.IWhitespaceManager;
@@ -46,24 +51,24 @@ export class ViewZones extends ViewPart {
 
 	// ---- begin view event handlers
 
-	public onConfigurationChanged(e:editorCommon.IConfigurationChangedEvent): boolean {
-
-		if (e.lineHeight) {
-			var id:string,
-				zone:IMyViewZone,
-				newComputedHeight:number,
-				zone2Height:{[id:string]:number;} = {};
+	private _recomputeWhitespacesProps(): boolean {
+		let id:string;
+		let zone2Height:{[id:string]:number;} = {};
+		let hadAChange = false;
 
-			for (id in this._zones) {
-				if (this._zones.hasOwnProperty(id)) {
-					zone = this._zones[id];
-					newComputedHeight = this._heightInPixels(zone.delegate);
-					this._safeCallOnComputedHeight(zone.delegate, newComputedHeight);
-					zone2Height[id] = newComputedHeight;
-					this._whitespaceManager.changeWhitespace(parseInt(id, 10), newComputedHeight);
+		for (id in this._zones) {
+			if (this._zones.hasOwnProperty(id)) {
+				let zone = this._zones[id];
+				let props = this._computeWhitespaceProps(zone.delegate);
+				if (this._whitespaceManager.changeWhitespace(parseInt(id, 10), props.afterViewLineNumber, props.heightInPx)) {
+					this._safeCallOnComputedHeight(zone.delegate, props.heightInPx);
+					zone2Height[id] = props.heightInPx;
+					hadAChange = true;
 				}
 			}
+		}
 
+		if (hadAChange) {
 			this._requestModificationFrame(() => {
 				for (id in this._zones) {
 					if (this._zones.hasOwnProperty(id)) {
@@ -74,28 +79,22 @@ export class ViewZones extends ViewPart {
 					}
 				}
 			});
-
-			return true;
 		}
 
-		return false;
+		return hadAChange;
 	}
 
-	public onLineMappingChanged(): boolean {
-
-		var hadAChange = false,
-			zone:IMyViewZone,
-			id:string;
+	public onConfigurationChanged(e:editorCommon.IConfigurationChangedEvent): boolean {
 
-		for (id in this._zones) {
-			if (this._zones.hasOwnProperty(id)) {
-				zone = this._zones[id];
-				var newAfterLineNumber = this._computeWhitespaceAfterLineNumber(zone.delegate);
-				hadAChange = this._whitespaceManager.changeAfterLineNumberForWhitespace(parseInt(id, 10), newAfterLineNumber) || hadAChange;
-			}
+		if (e.lineHeight) {
+			return this._recomputeWhitespacesProps();
 		}
 
-		return hadAChange;
+		return false;
+	}
+
+	public onLineMappingChanged(): boolean {
+		return this._recomputeWhitespacesProps();
 	}
 
 	public onLayoutChanged(layoutInfo:editorCommon.IEditorLayoutInfo): boolean {
@@ -134,19 +133,22 @@ export class ViewZones extends ViewPart {
 	}
 
 
-	private _computeWhitespaceAfterLineNumber(zone:IViewZone): number {
+	private _computeWhitespaceProps(zone:IViewZone): IComputedViewZoneProps {
 		if (zone.afterLineNumber === 0) {
-			return 0;
+			return {
+				afterViewLineNumber: 0,
+				heightInPx: this._heightInPixels(zone)
+			};
 		}
 
-		var zoneAfterModelPosition:editorCommon.IPosition;
+		let zoneAfterModelPosition:editorCommon.IPosition;
 		if (typeof zone.afterColumn !== 'undefined') {
 			zoneAfterModelPosition = this._context.model.validateModelPosition({
 				lineNumber: zone.afterLineNumber,
 				column: zone.afterColumn
 			});
 		} else {
-			var validAfterLineNumber = this._context.model.validateModelPosition({
+			let validAfterLineNumber = this._context.model.validateModelPosition({
 				lineNumber: zone.afterLineNumber,
 				column: 1
 			}).lineNumber;
@@ -157,21 +159,38 @@ export class ViewZones extends ViewPart {
 			};
 		}
 
-		var viewPosition = this._context.model.convertModelPositionToViewPosition(zoneAfterModelPosition.lineNumber, zoneAfterModelPosition.column);
-		return viewPosition.lineNumber;
+		let zoneBeforeModelPosition:editorCommon.IPosition;
+		if (zoneAfterModelPosition.column === this._context.model.getModelLineMaxColumn(zoneAfterModelPosition.lineNumber)) {
+			zoneBeforeModelPosition = this._context.model.validateModelPosition({
+				lineNumber: zoneAfterModelPosition.lineNumber + 1,
+				column: 1
+			});
+		} else {
+			zoneBeforeModelPosition = this._context.model.validateModelPosition({
+				lineNumber: zoneAfterModelPosition.lineNumber,
+				column: zoneAfterModelPosition.column + 1
+			});
+		}
+
+		let viewPosition = this._context.model.convertModelPositionToViewPosition(zoneAfterModelPosition.lineNumber, zoneAfterModelPosition.column);
+		let isVisible = this._context.model.modelPositionIsVisible(zoneBeforeModelPosition);
+		return {
+			afterViewLineNumber: viewPosition.lineNumber,
+			heightInPx: (isVisible ? this._heightInPixels(zone) : 0)
+		};
 	}
 
 	public addZone(zone:IViewZone): number {
-		var computedHeight = this._heightInPixels(zone);
-		var whitespaceId = this._whitespaceManager.addWhitespace(this._computeWhitespaceAfterLineNumber(zone), this._getZoneOrdinal(zone), computedHeight);
+		let props = this._computeWhitespaceProps(zone);
+		let whitespaceId = this._whitespaceManager.addWhitespace(props.afterViewLineNumber, this._getZoneOrdinal(zone), props.heightInPx);
 
-		var myZone:IMyViewZone = {
+		let myZone:IMyViewZone = {
 			whitespaceId: whitespaceId,
 			delegate: zone,
 			isVisible: false
 		};
 
-		this._safeCallOnComputedHeight(myZone.delegate, computedHeight);
+		this._safeCallOnComputedHeight(myZone.delegate, props.heightInPx);
 
 		this._requestModificationFrame(() => {
 			if (!myZone.delegate.domNode.hasAttribute('monaco-view-zone')) {
@@ -179,7 +198,7 @@ export class ViewZones extends ViewPart {
 				return;
 			}
 			myZone.delegate.domNode.style.position = 'absolute';
-			StyleMutator.setHeight(myZone.delegate.domNode, computedHeight);
+			StyleMutator.setHeight(myZone.delegate.domNode, props.heightInPx);
 			myZone.delegate.domNode.style.width = '100%';
 			StyleMutator.setDisplay(myZone.delegate.domNode, 'none');
 		});
@@ -216,16 +235,12 @@ export class ViewZones extends ViewPart {
 	}
 
 	public layoutZone(id: number): boolean {
-		var changed = false;
+		let changed = false;
 		if (this._zones.hasOwnProperty(id.toString())) {
-			var zone = this._zones[id.toString()];
-
-			var newComputedHeight = this._heightInPixels(zone.delegate);
-			var newAfterLineNumber = this._computeWhitespaceAfterLineNumber(zone.delegate);
-			// var newOrdinal = this._getZoneOrdinal(zone.delegate);
-
-			changed = this._whitespaceManager.changeWhitespace(zone.whitespaceId, newComputedHeight) || changed;
-			changed = this._whitespaceManager.changeAfterLineNumberForWhitespace(zone.whitespaceId, newAfterLineNumber) || changed;
+			let zone = this._zones[id.toString()];
+			let props = this._computeWhitespaceProps(zone.delegate);
+			// let newOrdinal = this._getZoneOrdinal(zone.delegate);
+			changed = this._whitespaceManager.changeWhitespace(zone.whitespaceId, props.afterViewLineNumber, props.heightInPx) || changed;
 			// TODO@Alex: change `newOrdinal` too
 		}
 		return changed;

src/vs/editor/common/editorCommon.ts

@@ -2504,16 +2504,10 @@ export interface IWhitespaceManager {
 	addWhitespace(afterLineNumber:number, ordinal:number, height:number): number;
 
 	/**
-	 * Change the height of a whitespace.
+	 * Change the properties of a whitespace.
 	 * @param height is specified in pixels.
 	 */
-	changeWhitespace(id:number, newHeight:number): boolean;
-
-	/**
-	 * Change the `afterLineNumber` of a whitespace.
-	 * @return a boolean indicating if something has actually changed
-	 */
-	changeAfterLineNumberForWhitespace(id:number, newAfterLineNumber:number): boolean;
+	changeWhitespace(id:number, newAfterLineNumber:number, newHeight:number): boolean;
 
 	/**
 	 * Remove rendering space
@@ -2553,6 +2547,7 @@ export interface IViewModel extends IEventEmitter, IDisposable {
 	convertViewRangeToModelRange(viewRange:IRange): IEditorRange;
 	convertModelPositionToViewPosition(modelLineNumber:number, modelColumn:number): IEditorPosition;
 	convertModelSelectionToViewSelection(modelSelection:IEditorSelection): IEditorSelection;
+	modelPositionIsVisible(position:IPosition): boolean;
 }
 
 export interface IViewEventNames {

src/vs/editor/common/viewLayout/linesLayout.ts

@@ -40,26 +40,8 @@ export class LinesLayout {
 		return this.verticalObjects.insertWhitespace(afterLineNumber, ordinal, height);
 	}
 
-	/**
-	 * Change the height of an existing whitespace
-	 *
-	 * @param id The whitespace to change
-	 * @param newHeightInPx The new height of the whitespace, in pixels
-	 * @return Returns true if the whitespace is found and if the new height is different than the old height
-	 */
-	public changeWhitespace(id:number, newHeight:number): boolean {
-		return this.verticalObjects.changeWhitespace(id, newHeight);
-	}
-
-	/**
-	 * Change the line number after which an existing whitespace flows.
-	 *
-	 * @param id The whitespace to change
-	 * @param newAfterLineNumber The new line number the whitespace will follow
-	 * @return Returns true if the whitespace is found and if the new line number is different than the old line number
-	 */
-	public changeAfterLineNumberForWhitespace(id:number, newAfterLineNumber:number): boolean {
-		return this.verticalObjects.changeAfterLineNumberForWhitespace(id, newAfterLineNumber);
+	public changeWhitespace(id:number, newAfterLineNumber:number, newHeight:number): boolean {
+		return this.verticalObjects.changeWhitespace(id, newAfterLineNumber, newHeight);
 	}
 
 	/**

src/vs/editor/common/viewLayout/verticalObjects.ts

@@ -53,26 +53,8 @@ export class VerticalObjects {
 		return this.whitespaces.insertWhitespace(afterLineNumber, ordinal, heightInPx);
 	}
 
-	/**
-	 * Change the height of an existing whitespace
-	 *
-	 * @param id The whitespace to change
-	 * @param newHeightInPx The new height of the whitespace, in pixels
-	 * @return Returns true if the whitespace is found and if the new height is different than the old height
-	 */
-	public changeWhitespace(id:number, newHeightInPx:number): boolean {
-		return this.whitespaces.changeWhitespace(id, newHeightInPx);
-	}
-
-	/**
-	 * Change the line number after which an existing whitespace flows.
-	 *
-	 * @param id The whitespace to change
-	 * @param newAfterLineNumber The new line number the whitespace will follow
-	 * @return Returns true if the whitespace is found and if the new line number is different than the old line number
-	 */
-	public changeAfterLineNumberForWhitespace(id:number, newAfterLineNumber:number): boolean {
-		return this.whitespaces.changeAfterLineNumberForWhitespace(id, newAfterLineNumber);
+	public changeWhitespace(id:number, newAfterLineNumber:number, newHeight:number): boolean {
+		return this.whitespaces.changeWhitespace(id, newAfterLineNumber, newHeight);
 	}
 
 	/**

src/vs/editor/common/viewLayout/whitespaceComputer.ts

@@ -133,6 +133,13 @@ export class WhitespaceComputer {
 		this.prefixSumValidIndex = Math.min(this.prefixSumValidIndex, insertIndex - 1);
 	}
 
+	public changeWhitespace(id:number, newAfterLineNumber:number, newHeight:number): boolean {
+		let hasChanges = false;
+		hasChanges = this.changeWhitespaceHeight(id, newHeight) || hasChanges;
+		hasChanges = this.changeWhitespaceAfterLineNumber(id, newAfterLineNumber) || hasChanges;
+		return hasChanges;
+	}
+
 	/**
 	 * Change the height of an existing whitespace
 	 *
@@ -140,7 +147,7 @@ export class WhitespaceComputer {
 	 * @param newHeightInPx The new height of the whitespace, in pixels
 	 * @return Returns true if the whitespace is found and if the new height is different than the old height
 	 */
-	public changeWhitespace(id:number, newHeightInPx:number): boolean {
+	public changeWhitespaceHeight(id:number, newHeightInPx:number): boolean {
 		var sid = id.toString();
 		if (this.whitespaceId2Index.hasOwnProperty(sid)) {
 			var index = this.whitespaceId2Index[sid];
@@ -160,7 +167,7 @@ export class WhitespaceComputer {
 	 * @param newAfterLineNumber The new line number the whitespace will follow
 	 * @return Returns true if the whitespace is found and if the new line number is different than the old line number
 	 */
-	public changeAfterLineNumberForWhitespace(id:number, newAfterLineNumber:number): boolean {
+	public changeWhitespaceAfterLineNumber(id:number, newAfterLineNumber:number): boolean {
 		var sid = id.toString();
 		if (this.whitespaceId2Index.hasOwnProperty(sid)) {
 			var index = this.whitespaceId2Index[sid];

src/vs/editor/common/viewModel/splitLinesCollection.ts

@@ -362,7 +362,7 @@ export class SplitLinesCollection implements ILinesCollection {
 		return result;
 	}
 
-	public setHiddenAreas(_ranges:editorCommon.IRange[], emit:(evenType:string, payload:any)=>void): void {
+	public setHiddenAreas(_ranges:editorCommon.IRange[], emit:(evenType:string, payload:any)=>void): boolean {
 
 		let newRanges = this._reduceRanges(_ranges);
 
@@ -378,7 +378,7 @@ export class SplitLinesCollection implements ILinesCollection {
 				}
 			}
 			if (!hasDifference) {
-				return;
+				return false;
 			}
 		}
 		// END TODO@Martin: Please stop calling this method on each model change!
@@ -430,6 +430,15 @@ export class SplitLinesCollection implements ILinesCollection {
 		}
 
 		emit(editorCommon.ViewEventNames.ModelFlushedEvent, null);
+		return true;
+	}
+
+	public inputPositionIsVisible(inputLineNumber:number, inputColumn:number): boolean {
+		if (inputLineNumber < 1 || inputLineNumber > this.lines.length) {
+			// invalid arguments
+			return false;
+		}
+		return this.lines[inputLineNumber - 1].isVisible();
 	}
 
 	public setTabSize(newTabSize:number, emit:(evenType:string, payload:any)=>void): boolean {

src/vs/editor/common/viewModel/viewModel.ts

@@ -31,6 +31,7 @@ export interface ILinesCollection {
 	convertOutputPositionToInputPosition(viewLineNumber:number, viewColumn:number): editorCommon.IEditorPosition;
 	convertInputPositionToOutputPosition(inputLineNumber:number, inputColumn:number): editorCommon.IEditorPosition;
 	setHiddenAreas(ranges:editorCommon.IRange[], emit:(evenType:string, payload:any)=>void): void;
+	inputPositionIsVisible(inputLineNumber:number, inputColumn:number): boolean;
 	dispose(): void;
 }
 
@@ -82,12 +83,20 @@ export class ViewModel extends EventEmitter implements editorCommon.IViewModel {
 
 	public setHiddenAreas(ranges:editorCommon.IRange[]): void {
 		this.deferredEmit(() => {
-			this.lines.setHiddenAreas(ranges, (eventType:string, payload:any) => this.emit(eventType, payload));
-			this.decorations.onLineMappingChanged((eventType:string, payload:any) => this.emit(eventType, payload));
-			this.cursors.onLineMappingChanged((eventType:string, payload:any) => this.emit(eventType, payload));
+			let lineMappingChanged = this.lines.setHiddenAreas(ranges, (eventType:string, payload:any) => this.emit(eventType, payload));
+			if (lineMappingChanged) {
+				this.emit(editorCommon.ViewEventNames.LineMappingChangedEvent);
+				this.decorations.onLineMappingChanged((eventType:string, payload:any) => this.emit(eventType, payload));
+				this.cursors.onLineMappingChanged((eventType:string, payload:any) => this.emit(eventType, payload));
+				this._updateShouldForceTokenization();
+			}
 		});
 	}
 
+	public modelPositionIsVisible(position:editorCommon.IPosition): boolean {
+		return this.lines.inputPositionIsVisible(position.lineNumber, position.column);
+	}
+
 	public dispose(): void {
 		this.listenersToRemove.forEach((element) => {
 			element();

src/vs/editor/test/common/viewLayout/verticalObjects.test.ts

@@ -145,7 +145,7 @@ suite('Editor ViewLayout - VerticalObjects', () => {
 		// Change whitespace height
 		// 10 lines
 		// whitespace: - a(2,10)
-		verticalObjects.changeWhitespace(a, 10);
+		verticalObjects.changeWhitespace(a, 2, 10);
 		assert.equal(verticalObjects.getTotalHeight(1), 20);
 		assert.equal(verticalObjects.getVerticalOffsetForLineNumber( 1, 1), 0);
 		assert.equal(verticalObjects.getVerticalOffsetForLineNumber( 2, 1), 1);
@@ -161,7 +161,7 @@ suite('Editor ViewLayout - VerticalObjects', () => {
 		// Change whitespace position
 		// 10 lines
 		// whitespace: - a(5,10)
-		verticalObjects.changeAfterLineNumberForWhitespace(a, 5);
+		verticalObjects.changeWhitespace(a, 5, 10);
 		assert.equal(verticalObjects.getTotalHeight(1), 20);
 		assert.equal(verticalObjects.getVerticalOffsetForLineNumber( 1, 1), 0);
 		assert.equal(verticalObjects.getVerticalOffsetForLineNumber( 2, 1), 1);

src/vs/editor/test/common/viewLayout/whitespaceComputer.test.ts

@@ -43,7 +43,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 30);
 
 		// Change last inserted whitespace height to 30
-		whitespaceComputer.changeWhitespace(b, 30);
+		whitespaceComputer.changeWhitespaceHeight(b, 30);
 		// whitespaces: a(2, 10), b(2, 30)
 		assert.equal(whitespaceComputer.getCount(), 2);
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 2);
@@ -131,7 +131,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(5), 110);
 
 		// Change whitespace after line 2 to height of 100
-		whitespaceComputer.changeWhitespace(a, 100);
+		whitespaceComputer.changeWhitespaceHeight(a, 100);
 		// whitespaces: b(0, 50), a(2, 100), d(3, 30), c(4, 20)
 		assert.equal(whitespaceComputer.getCount(), 4);
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 0);
@@ -376,7 +376,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 		assert.equal(WhitespaceComputer.findInsertionIndex(arr, 16, ordinals, 0), 8);
 	});
 
-	test('WhitespaceComputer changeAfterLineNumberForWhitespace & getFirstWhitespaceIndexAfterLineNumber', () => {
+	test('WhitespaceComputer changeWhitespaceAfterLineNumber & getFirstWhitespaceIndexAfterLineNumber', () => {
 		var whitespaceComputer = new WhitespaceComputer();
 
 		var a = whitespaceComputer.insertWhitespace(0, 0, 1);
@@ -400,7 +400,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 		assert.equal(whitespaceComputer.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
 
 		// Do not really move a
-		whitespaceComputer.changeAfterLineNumberForWhitespace(a, 1);
+		whitespaceComputer.changeWhitespaceAfterLineNumber(a, 1);
 
 		assert.equal(whitespaceComputer.getIdForWhitespaceIndex(0), a); // 1
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 1);
@@ -420,7 +420,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 
 
 		// Do not really move a
-		whitespaceComputer.changeAfterLineNumberForWhitespace(a, 2);
+		whitespaceComputer.changeWhitespaceAfterLineNumber(a, 2);
 
 		assert.equal(whitespaceComputer.getIdForWhitespaceIndex(0), a); // 2
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 2);
@@ -440,7 +440,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 
 
 		// Change a to conflict with c => a gets placed after c
-		whitespaceComputer.changeAfterLineNumberForWhitespace(a, 3);
+		whitespaceComputer.changeWhitespaceAfterLineNumber(a, 3);
 
 		assert.equal(whitespaceComputer.getIdForWhitespaceIndex(0), c); // 3
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 3);
@@ -460,7 +460,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 
 
 		// Make a no-op
-		whitespaceComputer.changeAfterLineNumberForWhitespace(c, 3);
+		whitespaceComputer.changeWhitespaceAfterLineNumber(c, 3);
 
 		assert.equal(whitespaceComputer.getIdForWhitespaceIndex(0), c); // 3
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 3);
@@ -481,7 +481,7 @@ suite('Editor ViewLayout - WhitespaceComputer', () => {
 
 
 		// Conflict c with b => c gets placed after b
-		whitespaceComputer.changeAfterLineNumberForWhitespace(c, 7);
+		whitespaceComputer.changeWhitespaceAfterLineNumber(c, 7);
 
 		assert.equal(whitespaceComputer.getIdForWhitespaceIndex(0), a); // 3
 		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 3);