Remove IMode.linkSupport and convert to provider

src/vs/editor/common/modes.ts

@@ -211,11 +211,6 @@ export interface IMode {
 	 */
 	emitOutputSupport?:IEmitOutputSupport;
 
-	/**
-	 * Optional adapter to support detecting links.
-	 */
-	linkSupport?:ILinkSupport;
-
 	/**
 	 * Optional adapter to support configuring this mode.
 	 */
@@ -584,26 +579,16 @@ export interface IEmitOutput {
 	content:string;
 }
 
-/**
- * Interface used to detect links.
- */
-export interface ILink {
 
+export interface ILink {
 	range: editorCommon.IRange;
-
-	/**
-	 * The url of the link.
-	 * The url should be absolute and will not get any special treatment.
-	 */
 	url: string;
-
-	extraInlineClassName?: string;
 }
-
 export interface ILinkSupport {
-	computeLinks(resource:URI):TPromise<ILink[]>;
+	provideLinks(model: editorCommon.IReadOnlyModel, token: CancellationToken): ILink[] | Thenable<ILink[]>;
 }
 
+
 /**
  * Interface used to define a configurable editor mode.
  */
@@ -781,3 +766,5 @@ export const DocumentFormattingEditProviderRegistry = new LanguageFeatureRegistr
 export const DocumentRangeFormattingEditProviderRegistry = new LanguageFeatureRegistry<DocumentRangeFormattingEditProvider>();
 
 export const OnTypeFormattingEditProviderRegistry = new LanguageFeatureRegistry<OnTypeFormattingEditProvider>();
+
+export const LinksProviderRegistry = new LanguageFeatureRegistry<ILinkSupport>();

src/vs/editor/contrib/hover/browser/modesContentHover.ts

@@ -16,7 +16,7 @@ import {IEditorRange, IRange} from 'vs/editor/common/editorCommon';
 import {HoverProviderRegistry, Hover, IMode} from 'vs/editor/common/modes';
 import {tokenizeToString} from 'vs/editor/common/modes/textToHtmlTokenizer';
 import {ICodeEditor} from 'vs/editor/browser/editorBrowser';
-import {provideHover} from '../common/hover';
+import {getHover} from '../common/hover';
 import {HoverOperation, IHoverComputer} from './hoverOperation';
 import {ContentHoverWidget} from './hoverWidgets';
 
@@ -47,7 +47,7 @@ class ModesContentComputer implements IHoverComputer<Hover[]> {
 			return TPromise.as(null);
 		}
 
-		return provideHover(model, new Position(
+		return getHover(model, new Position(
 			this._range.startLineNumber,
 			this._range.startColumn
 		));

src/vs/editor/contrib/hover/common/hover.ts

@@ -13,7 +13,7 @@ import {CommonEditorRegistry} from 'vs/editor/common/editorCommonExtensions';
 import {Hover, HoverProviderRegistry} from 'vs/editor/common/modes';
 import {asWinJsPromise} from 'vs/base/common/async';
 
-export function provideHover(model: IReadOnlyModel, position: IEditorPosition): TPromise<Hover[]> {
+export function getHover(model: IReadOnlyModel, position: IEditorPosition): TPromise<Hover[]> {
 
 	const supports = HoverProviderRegistry.ordered(model);
 	const values: Hover[] = [];
@@ -37,4 +37,4 @@ export function provideHover(model: IReadOnlyModel, position: IEditorPosition):
 	return TPromise.join(promises).then(() => coalesce(values));
 }
 
-CommonEditorRegistry.registerDefaultLanguageCommand('_executeHoverProvider', provideHover);
+CommonEditorRegistry.registerDefaultLanguageCommand('_executeHoverProvider', getHover);
\ No newline at end of file

src/vs/editor/contrib/links/browser/links.ts

@@ -22,9 +22,10 @@ import {EditorAction} from 'vs/editor/common/editorAction';
 import {Behaviour} from 'vs/editor/common/editorActionEnablement';
 import * as editorCommon from 'vs/editor/common/editorCommon';
 import {CommonEditorRegistry, EditorActionDescriptor} from 'vs/editor/common/editorCommonExtensions';
-import {ILink} from 'vs/editor/common/modes';
+import {ILink, LinksProviderRegistry} from 'vs/editor/common/modes';
 import {IEditorWorkerService} from 'vs/editor/common/services/editorWorkerService';
 import {IEditorMouseEvent} from 'vs/editor/browser/editorBrowser';
+import {getLinks} from 'vs/editor/contrib/links/common/links';
 
 class LinkOccurence {
 
@@ -42,9 +43,6 @@ class LinkOccurence {
 
 	private static _getOptions(link:ILink, isActive:boolean):editorCommon.IModelDecorationOptions {
 		var result = '';
-		if (link.extraInlineClassName) {
-			result = link.extraInlineClassName + ' ';
-		}
 
 		if (isActive) {
 			result += LinkDetector.CLASS_NAME_ACTIVE;
@@ -79,12 +77,10 @@ class LinkOccurence {
 class Link {
 	range: editorCommon.IEditorRange;
 	url: string;
-	extraInlineClassName: string;
 
 	constructor(source:ILink) {
 		this.range = new Range(source.range.startLineNumber, source.range.startColumn, source.range.endLineNumber, source.range.endColumn);
 		this.url = source.url;
-		this.extraInlineClassName = source.extraInlineClassName || null;
 	}
 }
 
@@ -165,9 +161,8 @@ class LinkDetector {
 		}
 
 		let modePromise:TPromise<ILink[]> = TPromise.as(null);
-		let mode = this.editor.getModel().getMode();
-		if (mode.linkSupport) {
-			modePromise = mode.linkSupport.computeLinks(this.editor.getModel().getAssociatedResource());
+		if (LinksProviderRegistry.has(this.editor.getModel())) {
+			modePromise = getLinks(this.editor.getModel());
 		}
 
 		let standardPromise:TPromise<ILink[]> = this.editorWorkerService.computeLinks(this.editor.getModel().getAssociatedResource());

src/vs/editor/contrib/links/common/links.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';
+
+import {onUnexpectedError} from 'vs/base/common/errors';
+import {TPromise} from 'vs/base/common/winjs.base';
+import {IReadOnlyModel} from 'vs/editor/common/editorCommon';
+import {ILink, LinksProviderRegistry} from 'vs/editor/common/modes';
+import {asWinJsPromise} from 'vs/base/common/async';
+
+export function getLinks(model: IReadOnlyModel): TPromise<ILink[]> {
+
+	const promises = LinksProviderRegistry.ordered(model).map((support) => {
+		return asWinJsPromise((token) => {
+			return support.provideLinks(model, token);
+		}).then((result) => {
+			if (Array.isArray(result)) {
+				return <ILink[]> result;
+			}
+		}, err => {
+			onUnexpectedError(err);
+		});
+	});
+
+	return TPromise.join(promises).then(manyLinks => {
+		let result: ILink[] = [];
+		for (let links of manyLinks) {
+			if (links) {
+				result = result.concat(links);
+			}
+		}
+		return result;
+	});
+}

src/vs/languages/handlebars/common/handlebars.ts

@@ -142,6 +142,12 @@ export class HandlebarsMode extends htmlMode.HTMLMode<htmlWorker.HTMLWorker> {
 				return wireCancellationToken(token, this._provideDocumentHighlights(model.getAssociatedResource(), position));
 			}
 		});
+
+		modes.LinksProviderRegistry.register(this.getId(), {
+			provideLinks: (model, token): Thenable<modes.ILink[]> => {
+				return wireCancellationToken(token, this._provideLinks(model.getAssociatedResource()));
+			}
+		});
 	}
 
 	protected _createRichEditSupport(): modes.IRichEditSupport {

src/vs/languages/html/common/html.ts

@@ -287,7 +287,6 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 
 	public tokenizationSupport: modes.ITokenizationSupport;
 	public richEditSupport: modes.IRichEditSupport;
-	public linkSupport:modes.ILinkSupport;
 	public configSupport: modes.IConfigurationSupport;
 
 	private modeService:IModeService;
@@ -307,7 +306,6 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 		this.threadService = threadService;
 
 		this.tokenizationSupport = new TokenizationSupport(this, this, true, true);
-		this.linkSupport = this;
 		this.configSupport = this;
 
 		this.richEditSupport = this._createRichEditSupport();
@@ -358,6 +356,12 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 				return wireCancellationToken(token, this._provideDocumentRangeFormattingEdits(model.getAssociatedResource(), range, options));
 			}
 		});
+
+		modes.LinksProviderRegistry.register(this.getId(), {
+			provideLinks: (model, token): Thenable<modes.ILink[]> => {
+				return wireCancellationToken(token, this._provideLinks(model.getAssociatedResource()));
+			}
+		});
 	}
 
 	protected _createModeWorkerManager(descriptor:modes.IModeDescriptor, instantiationService: IInstantiationService): ModeWorkerManager<W> {
@@ -484,9 +488,9 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 		return this._worker((w) => w._doConfigure(options));
 	}
 
-	static $computeLinks = OneWorkerAttr(HTMLMode, HTMLMode.prototype.computeLinks);
-	public computeLinks(resource:URI):winjs.TPromise<modes.ILink[]> {
-		return this._worker((w) => w.computeLinks(resource));
+	static $_provideLinks = OneWorkerAttr(HTMLMode, HTMLMode.prototype._provideLinks);
+	protected _provideLinks(resource:URI):winjs.TPromise<modes.ILink[]> {
+		return this._worker((w) => w.provideLinks(resource));
 	}
 
 	static $_provideDocumentRangeFormattingEdits = OneWorkerAttr(HTMLMode, HTMLMode.prototype._provideDocumentRangeFormattingEdits);

src/vs/languages/html/common/htmlWorker.ts

@@ -21,7 +21,7 @@ import {isTag, DELIM_END, DELIM_START, DELIM_ASSIGN, ATTRIB_NAME, ATTRIB_VALUE}
 import {isEmptyElement} from 'vs/languages/html/common/htmlEmptyTagsShared';
 import {filterSuggestions} from 'vs/editor/common/modes/supports/suggestSupport';
 import paths = require('vs/base/common/paths');
-import {provideHover} from 'vs/editor/contrib/hover/common/hover';
+import {getHover} from 'vs/editor/contrib/hover/common/hover';
 import {provideReferences} from 'vs/editor/contrib/referenceSearch/common/referenceSearch';
 import {provideCompletionItems} from 'vs/editor/contrib/suggest/common/suggest';
 
@@ -150,7 +150,7 @@ export class HTMLWorker {
 	public provideHover(resource:URI, position:editorCommon.IPosition): winjs.TPromise<modes.Hover> {
 		return this._delegateToModeAtPosition(resource, position, (isEmbeddedMode, model) => {
 			if (isEmbeddedMode) {
-				return provideHover(model, Position.lift(position)).then((r) => {
+				return getHover(model, Position.lift(position)).then((r) => {
 					return (r.length > 0 ? r[0] : null);
 				});
 			}
@@ -659,7 +659,7 @@ export class HTMLWorker {
 		return newLinks;
 	}
 
-	public computeLinks(resource: URI): winjs.TPromise<modes.ILink[]> {
+	public provideLinks(resource: URI): winjs.TPromise<modes.ILink[]> {
 		let model = this.resourceService.get(resource);
 		return winjs.TPromise.as(this._computeHTMLLinks(model));
 	}

src/vs/languages/razor/common/razor.ts

@@ -91,6 +91,12 @@ export class RAZORMode extends htmlMode.HTMLMode<RAZORWorker> {
 				return wireCancellationToken(token, this._provideDocumentHighlights(model.getAssociatedResource(), position));
 			}
 		});
+
+		modes.LinksProviderRegistry.register(this.getId(), {
+			provideLinks: (model, token): Thenable<modes.ILink[]> => {
+				return wireCancellationToken(token, this._provideLinks(model.getAssociatedResource()));
+			}
+		});
 	}
 
 	protected _createModeWorkerManager(descriptor:modes.IModeDescriptor, instantiationService: IInstantiationService): ModeWorkerManager<RAZORWorker> {

src/vs/workbench/parts/output/common/outputMode.ts

@@ -14,12 +14,13 @@ import {OutputWorker} from 'vs/workbench/parts/output/common/outputWorker';
 import winjs = require('vs/base/common/winjs.base');
 import {OneWorkerAttr} from 'vs/platform/thread/common/threadService';
 import URI from 'vs/base/common/uri';
-import Modes = require('vs/editor/common/modes');
+import * as modes from 'vs/editor/common/modes';
 import {IEditorWorkerService} from 'vs/editor/common/services/editorWorkerService';
 import {AbstractMode, ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
 import {createRichEditSupport} from 'vs/editor/common/modes/monarch/monarchDefinition';
 import {createTokenizationSupport} from 'vs/editor/common/modes/monarch/monarchLexer';
 import {RichEditSupport} from 'vs/editor/common/modes/supports/richEditSupport';
+import {wireCancellationToken} from 'vs/base/common/async';
 
 export const language: types.ILanguage = {
 	displayName: 'Log',
@@ -47,9 +48,8 @@ export const language: types.ILanguage = {
 
 export class OutputMode extends AbstractMode {
 
-	public linkSupport:Modes.ILinkSupport;
-	public tokenizationSupport: Modes.ITokenizationSupport;
-	public richEditSupport: Modes.IRichEditSupport;
+	public tokenizationSupport: modes.ITokenizationSupport;
+	public richEditSupport: modes.IRichEditSupport;
 
 	private _modeWorkerManager: ModeWorkerManager<OutputWorker>;
 
@@ -64,19 +64,23 @@ export class OutputMode extends AbstractMode {
 		let lexer = compile(language);
 		this._modeWorkerManager = new ModeWorkerManager<OutputWorker>(descriptor, 'vs/workbench/parts/output/common/outputWorker', 'OutputWorker', null, instantiationService);
 
-		this.linkSupport = this;
-
 		this.tokenizationSupport = createTokenizationSupport(modeService, this, lexer);
 
 		this.richEditSupport = new RichEditSupport(this.getId(), null, createRichEditSupport(lexer));
+
+		modes.LinksProviderRegistry.register(this.getId(), {
+			provideLinks: (model, token): Thenable<modes.ILink[]> => {
+				return wireCancellationToken(token, this._provideLinks(model.getAssociatedResource()));
+			}
+		});
 	}
 
 	private _worker<T>(runner:(worker:OutputWorker)=>winjs.TPromise<T>): winjs.TPromise<T> {
 		return this._modeWorkerManager.worker(runner);
 	}
 
-	static $computeLinks = OneWorkerAttr(OutputMode, OutputMode.prototype.computeLinks);
-	public computeLinks(resource:URI):winjs.TPromise<Modes.ILink[]> {
-		return this._worker((w) => w.computeLinks(resource));
+	static $_provideLinks = OneWorkerAttr(OutputMode, OutputMode.prototype._provideLinks);
+	private _provideLinks(resource:URI):winjs.TPromise<modes.ILink[]> {
+		return this._worker((w) => w.provideLinks(resource));
 	}
 }

src/vs/workbench/parts/output/common/outputWorker.ts

@@ -44,7 +44,7 @@ export class OutputWorker {
 		return this._contextService;
 	}
 
-	public computeLinks(resource: URI): TPromise<ILink[]> {
+	public provideLinks(resource: URI): TPromise<ILink[]> {
 		let links: ILink[] = [];
 		if (!this.patterns.length) {
 			return TPromise.as(links);

src/vs/workbench/test/node/api/extHostLanguageFeatures.test.ts

@@ -26,7 +26,7 @@ import {getDocumentSymbols} from 'vs/editor/contrib/quickOpen/common/quickOpen';
 import {DocumentSymbolProviderRegistry, DocumentHighlightKind} from 'vs/editor/common/modes';
 import {getCodeLensData} from 'vs/editor/contrib/codelens/common/codelens';
 import {getDeclarationsAtPosition} from 'vs/editor/contrib/goToDeclaration/common/goToDeclaration';
-import {provideHover} from 'vs/editor/contrib/hover/common/hover';
+import {getHover} from 'vs/editor/contrib/hover/common/hover';
 import {getOccurrencesAtPosition} from 'vs/editor/contrib/wordHighlighter/common/wordHighlighter';
 import {provideReferences} from 'vs/editor/contrib/referenceSearch/common/referenceSearch';
 import {getCodeActions} from 'vs/editor/contrib/quickFix/common/quickFix';
@@ -337,7 +337,7 @@ suite('ExtHostLanguageFeatures', function() {
 		}));
 
 		return threadService.sync().then(() => {
-			provideHover(model, new EditorPosition(1, 1)).then(value => {
+			getHover(model, new EditorPosition(1, 1)).then(value => {
 				assert.equal(value.length, 1);
 				let [entry] = value;
 				assert.deepEqual(entry.range, { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 5 });
@@ -356,7 +356,7 @@ suite('ExtHostLanguageFeatures', function() {
 
 		return threadService.sync().then(() => {
 
-			provideHover(model, new EditorPosition(1, 1)).then(value => {
+			getHover(model, new EditorPosition(1, 1)).then(value => {
 				assert.equal(value.length, 1);
 				let [entry] = value;
 				assert.deepEqual(entry.range, { startLineNumber: 4, startColumn: 1, endLineNumber: 9, endColumn: 8 });
@@ -380,7 +380,7 @@ suite('ExtHostLanguageFeatures', function() {
 		}));
 
 		return threadService.sync().then(() => {
-			return provideHover(model, new EditorPosition(1, 1)).then(value => {
+			return getHover(model, new EditorPosition(1, 1)).then(value => {
 				assert.equal(value.length, 2);
 				let [first, second] = value;
 				assert.equal(first.htmlContent[0].markdown, 'registered second');
@@ -405,7 +405,7 @@ suite('ExtHostLanguageFeatures', function() {
 
 		return threadService.sync().then(() => {
 
-			provideHover(model, new EditorPosition(1, 1)).then(value => {
+			getHover(model, new EditorPosition(1, 1)).then(value => {
 
 				assert.equal(value.length, 1);
 			});