Add `diffEditor.maximumComputationTime`

src/vs/editor/browser/widget/diffEditorWidget.ts

@@ -203,6 +203,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
 	private _originalIsEditable: boolean;
 
 	private _renderSideBySide: boolean;
+	private _maximumComputationTime: number;
 	private _renderIndicators: boolean;
 	private _enableSplitViewResizing: boolean;
 	private _strategy!: IDiffEditorWidgetStyle;
@@ -252,6 +253,12 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
 			this._renderSideBySide = options.renderSideBySide;
 		}
 
+		// maximumComputationTime
+		this._maximumComputationTime = 5000;
+		if (typeof options.maximumComputationTime !== 'undefined') {
+			this._maximumComputationTime = options.maximumComputationTime;
+		}
+
 		// ignoreTrimWhitespace
 		this._ignoreTrimWhitespace = true;
 		if (typeof options.ignoreTrimWhitespace !== 'undefined') {
@@ -623,6 +630,10 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
 			}
 		}
 
+		if (typeof newOptions.maximumComputationTime !== 'undefined') {
+			this._maximumComputationTime = newOptions.maximumComputationTime;
+		}
+
 		let beginUpdateDecorations = false;
 
 		if (typeof newOptions.ignoreTrimWhitespace !== 'undefined') {
@@ -968,7 +979,7 @@ export class DiffEditorWidget extends Disposable implements editorBrowser.IDiffE
 			return;
 		}
 
-		this._editorWorkerService.computeDiff(currentOriginalModel.uri, currentModifiedModel.uri, this._ignoreTrimWhitespace).then((result) => {
+		this._editorWorkerService.computeDiff(currentOriginalModel.uri, currentModifiedModel.uri, this._ignoreTrimWhitespace, this._maximumComputationTime).then((result) => {
 			if (currentToken === this._diffComputationToken
 				&& currentOriginalModel === this.originalEditor.getModel()
 				&& currentModifiedModel === this.modifiedEditor.getModel()

src/vs/editor/common/config/commonEditorConfig.ts

@@ -462,6 +462,11 @@ const editorConfiguration: IConfigurationNode = {
 			default: 750,
 			description: nls.localize('codeActionsOnSaveTimeout', "Timeout in milliseconds after which the code actions that are run on save are cancelled.")
 		},
+		'diffEditor.maximumComputationTime': {
+			type: 'number',
+			default: 5000,
+			description: nls.localize('maximumComputationTime', "Timeout in milliseconds after which diff computation is cancelled.")
+		},
 		'diffEditor.renderSideBySide': {
 			type: 'boolean',
 			default: true,

src/vs/editor/common/config/editorOptions.ts

@@ -538,6 +538,11 @@ export interface IDiffEditorOptions extends IEditorOptions {
 	 * Defaults to true.
 	 */
 	renderSideBySide?: boolean;
+	/**
+	 * Timeout in milliseconds after which diff computation is cancelled.
+	 * Defaults to 5000.
+	 */
+	maximumComputationTime?: number;
 	/**
 	 * Compute the diff by ignoring leading/trailing whitespace
 	 * Defaults to true.

src/vs/editor/common/diff/diffComputer.ts

@@ -7,7 +7,6 @@ import { IDiffChange, ISequence, LcsDiff, IDiffResult } from 'vs/base/common/dif
 import * as strings from 'vs/base/common/strings';
 import { ICharChange, ILineChange } from 'vs/editor/common/editorCommon';
 
-const MAXIMUM_RUN_TIME = 5000; // 5 seconds
 const MINIMUM_MATCHING_CHARACTER_LENGTH = 3;
 
 export interface IDiffComputerResult {
@@ -280,6 +279,7 @@ export interface IDiffComputerOpts {
 	shouldPostProcessCharChanges: boolean;
 	shouldIgnoreTrimWhitespace: boolean;
 	shouldMakePrettyDiff: boolean;
+	maximumComputationTime: number;
 }
 
 export class DiffComputer {
@@ -305,8 +305,8 @@ export class DiffComputer {
 		this.original = new LineSequence(originalLines);
 		this.modified = new LineSequence(modifiedLines);
 
-		this.continueLineDiff = createContinueProcessingPredicate(MAXIMUM_RUN_TIME);
-		this.continueCharDiff = createContinueProcessingPredicate(MAXIMUM_RUN_TIME);
+		this.continueLineDiff = createContinueProcessingPredicate(opts.maximumComputationTime);
+		this.continueCharDiff = createContinueProcessingPredicate(opts.maximumComputationTime === 0 ? 0 : Math.min(opts.maximumComputationTime, 5000)); // never run after 5s for character changes...
 	}
 
 	public computeDiff(): IDiffComputerResult {

src/vs/editor/common/services/editorSimpleWorker.ts

@@ -377,7 +377,7 @@ export class EditorSimpleWorker implements IRequestHandler, IDisposable {
 
 	// ---- BEGIN diff --------------------------------------------------------------------------
 
-	public async computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): Promise<IDiffComputationResult | null> {
+	public async computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean, maximumComputationTime: number): Promise<IDiffComputationResult | null> {
 		const original = this._getModel(originalUrl);
 		const modified = this._getModel(modifiedUrl);
 		if (!original || !modified) {
@@ -390,7 +390,8 @@ export class EditorSimpleWorker implements IRequestHandler, IDisposable {
 			shouldComputeCharChanges: true,
 			shouldPostProcessCharChanges: true,
 			shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
-			shouldMakePrettyDiff: true
+			shouldMakePrettyDiff: true,
+			maximumComputationTime: maximumComputationTime
 		});
 
 		const diffResult = diffComputer.computeDiff();
@@ -431,7 +432,8 @@ export class EditorSimpleWorker implements IRequestHandler, IDisposable {
 			shouldComputeCharChanges: false,
 			shouldPostProcessCharChanges: false,
 			shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
-			shouldMakePrettyDiff: true
+			shouldMakePrettyDiff: true,
+			maximumComputationTime: 1000
 		});
 		return diffComputer.computeDiff().changes;
 	}

src/vs/editor/common/services/editorWorkerService.ts

@@ -22,7 +22,7 @@ export interface IEditorWorkerService {
 	_serviceBrand: undefined;
 
 	canComputeDiff(original: URI, modified: URI): boolean;
-	computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IDiffComputationResult | null>;
+	computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean, maximumComputationTime: number): Promise<IDiffComputationResult | null>;
 
 	canComputeDirtyDiff(original: URI, modified: URI): boolean;
 	computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;

src/vs/editor/common/services/editorWorkerServiceImpl.ts

@@ -82,8 +82,8 @@ export class EditorWorkerServiceImpl extends Disposable implements IEditorWorker
 		return (canSyncModel(this._modelService, original) && canSyncModel(this._modelService, modified));
 	}
 
-	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IDiffComputationResult | null> {
-		return this._workerManager.withWorker().then(client => client.computeDiff(original, modified, ignoreTrimWhitespace));
+	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean, maximumComputationTime: number): Promise<IDiffComputationResult | null> {
+		return this._workerManager.withWorker().then(client => client.computeDiff(original, modified, ignoreTrimWhitespace, maximumComputationTime));
 	}
 
 	public canComputeDirtyDiff(original: URI, modified: URI): boolean {
@@ -409,9 +409,9 @@ export class EditorWorkerClient extends Disposable {
 		});
 	}
 
-	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IDiffComputationResult | null> {
+	public computeDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean, maximumComputationTime: number): Promise<IDiffComputationResult | null> {
 		return this._withSyncedResources([original, modified]).then(proxy => {
-			return proxy.computeDiff(original.toString(), modified.toString(), ignoreTrimWhitespace);
+			return proxy.computeDiff(original.toString(), modified.toString(), ignoreTrimWhitespace, maximumComputationTime);
 		});
 	}
 

src/vs/editor/test/common/diff/diffComputer.test.ts

@@ -55,7 +55,8 @@ function assertDiff(originalLines: string[], modifiedLines: string[], expectedCh
 		shouldComputeCharChanges,
 		shouldPostProcessCharChanges,
 		shouldIgnoreTrimWhitespace,
-		shouldMakePrettyDiff: true
+		shouldMakePrettyDiff: true,
+		maximumComputationTime: 0
 	});
 	let changes = diffComputer.computeDiff().changes;
 

src/vs/monaco.d.ts

@@ -2941,6 +2941,11 @@ declare namespace monaco.editor {
 		 * Defaults to true.
 		 */
 		renderSideBySide?: boolean;
+		/**
+		 * Timeout in milliseconds after which diff computation is cancelled.
+		 * Defaults to 5000.
+		 */
+		maximumComputationTime?: number;
 		/**
 		 * Compute the diff by ignoring leading/trailing whitespace
 		 * Defaults to true.