rename (#19282)

extensions/typescript/src/features/typeImplementationProvider.ts → extensions/typescript/src/features/implementationProvider.ts

@@ -5,18 +5,18 @@
 
 'use strict';
 
-import { TypeImplementationProvider, TextDocument, Position, CancellationToken, Definition } from 'vscode';
+import { ImplementationProvider, TextDocument, Position, CancellationToken, Definition } from 'vscode';
 
 import { ITypescriptServiceClient } from '../typescriptService';
 import DefinitionProviderBase from './definitionProviderBase';
 
-export default class TypeScriptTypeImplementationProvider extends DefinitionProviderBase implements TypeImplementationProvider {
+export default class TypeScriptImplementationProvider extends DefinitionProviderBase implements ImplementationProvider {
 
 	constructor(client: ITypescriptServiceClient) {
 		super(client);
 	}
 
-	public provideTypeImplementation(document: TextDocument, position: Position, token: CancellationToken | boolean): Promise<Definition | null> {
+	public provideImplementation(document: TextDocument, position: Position, token: CancellationToken | boolean): Promise<Definition | null> {
 		return this.getSymbolLocations('implementation', document, position, token);
 	}
 }

extensions/typescript/src/typescriptMain.ts

@@ -25,7 +25,7 @@ import { ITypescriptServiceClientHost } from './typescriptService';
 
 import HoverProvider from './features/hoverProvider';
 import DefinitionProvider from './features/definitionProvider';
-import TypeImplementationProvider from './features/TypeImplementationProvider';
+import ImplementationProvider from './features/ImplementationProvider';
 import DocumentHighlightProvider from './features/documentHighlightProvider';
 import ReferenceProvider from './features/referenceProvider';
 import DocumentSymbolProvider from './features/documentSymbolProvider';
@@ -149,7 +149,7 @@ class LanguageProvider {
 
 		let hoverProvider = new HoverProvider(client);
 		let definitionProvider = new DefinitionProvider(client);
-		let typeImplementationProvider = new TypeImplementationProvider(client);
+		let implementationProvider = new ImplementationProvider(client);
 		let documentHighlightProvider = new DocumentHighlightProvider(client);
 		let referenceProvider = new ReferenceProvider(client);
 		let documentSymbolProvider = new DocumentSymbolProvider(client);
@@ -174,7 +174,7 @@ class LanguageProvider {
 			languages.registerDefinitionProvider(selector, definitionProvider);
 			if (client.apiVersion.has220Features()) {
 				// TODO: TS 2.1.5 returns incorrect results for implementation locations.
-				languages.registerTypeImplementationProvider(selector, typeImplementationProvider);
+				languages.registerImplementationProvider(selector, implementationProvider);
 			}
 			languages.registerDocumentHighlightProvider(selector, documentHighlightProvider);
 			languages.registerReferenceProvider(selector, referenceProvider);

src/vs/editor/browser/standalone/standaloneLanguages.ts

@@ -277,8 +277,8 @@ export function registerDefinitionProvider(languageId: string, provider: modes.D
 /**
  * Register a type implementation provider (used by e.g. go to implementation).
  */
-export function registerTypeImplementationProvider(languageId: string, provider: modes.TypeImplementationProvider): IDisposable {
-	return modes.TypeImplementationProviderRegistry.register(languageId, provider);
+export function registerImplementationProvider(languageId: string, provider: modes.ImplementationProvider): IDisposable {
+	return modes.ImplementationProviderRegistry.register(languageId, provider);
 }
 
 /**
@@ -681,7 +681,7 @@ export function createMonacoLanguagesAPI(): typeof monaco.languages {
 		registerDocumentSymbolProvider: registerDocumentSymbolProvider,
 		registerDocumentHighlightProvider: registerDocumentHighlightProvider,
 		registerDefinitionProvider: registerDefinitionProvider,
-		registerTypeImplementationProvider: registerTypeImplementationProvider,
+		registerImplementationProvider: registerImplementationProvider,
 		registerCodeLensProvider: registerCodeLensProvider,
 		registerCodeActionProvider: registerCodeActionProvider,
 		registerDocumentFormattingEditProvider: registerDocumentFormattingEditProvider,

src/vs/editor/common/editorCommon.ts

@@ -3096,7 +3096,7 @@ export namespace ModeContextKeys {
 	/**
 	 * @internal
 	 */
-	export const hasTypeImplementationProvider = new RawContextKey<boolean>('editorHasTypeImplementationProvider', undefined);
+	export const hasImplementationProvider = new RawContextKey<boolean>('editorHasImplementationProvider', undefined);
 	/**
 	 * @internal
 	 */

src/vs/editor/common/modes.ts

@@ -435,11 +435,11 @@ export interface DefinitionProvider {
  * The type definition provider interface defines the contract between extensions and
  * the go to implementation feature.
  */
-export interface TypeImplementationProvider {
+export interface ImplementationProvider {
 	/**
 	 * Provide the implementation of the symbol at the given position and document.
 	 */
-	provideTypeImplementation(model: editorCommon.IReadOnlyModel, position: Position, token: CancellationToken): Definition | Thenable<Definition>;
+	provideImplementation(model: editorCommon.IReadOnlyModel, position: Position, token: CancellationToken): Definition | Thenable<Definition>;
 }
 
 /**
@@ -752,7 +752,7 @@ export const DefinitionProviderRegistry = new LanguageFeatureRegistry<Definition
 /**
  * @internal
  */
-export const TypeImplementationProviderRegistry = new LanguageFeatureRegistry<TypeImplementationProvider>();
+export const ImplementationProviderRegistry = new LanguageFeatureRegistry<ImplementationProvider>();
 
 /**
  * @internal

src/vs/editor/common/modes/editorModeContext.ts

@@ -20,7 +20,7 @@ export class EditorModeContext {
 	private _hasCodeActionsProvider: IContextKey<boolean>;
 	private _hasCodeLensProvider: IContextKey<boolean>;
 	private _hasDefinitionProvider: IContextKey<boolean>;
-	private _hasTypeImplementationProvider: IContextKey<boolean>;
+	private _hasImplementationProvider: IContextKey<boolean>;
 	private _hasHoverProvider: IContextKey<boolean>;
 	private _hasDocumentHighlightProvider: IContextKey<boolean>;
 	private _hasDocumentSymbolProvider: IContextKey<boolean>;
@@ -42,7 +42,7 @@ export class EditorModeContext {
 		this._hasCodeActionsProvider = ModeContextKeys.hasCodeActionsProvider.bindTo(contextKeyService);
 		this._hasCodeLensProvider = ModeContextKeys.hasCodeLensProvider.bindTo(contextKeyService);
 		this._hasDefinitionProvider = ModeContextKeys.hasDefinitionProvider.bindTo(contextKeyService);
-		this._hasTypeImplementationProvider = ModeContextKeys.hasTypeImplementationProvider.bindTo(contextKeyService);
+		this._hasImplementationProvider = ModeContextKeys.hasImplementationProvider.bindTo(contextKeyService);
 		this._hasHoverProvider = ModeContextKeys.hasHoverProvider.bindTo(contextKeyService);
 		this._hasDocumentHighlightProvider = ModeContextKeys.hasDocumentHighlightProvider.bindTo(contextKeyService);
 		this._hasDocumentSymbolProvider = ModeContextKeys.hasDocumentSymbolProvider.bindTo(contextKeyService);
@@ -62,7 +62,7 @@ export class EditorModeContext {
 		modes.CodeActionProviderRegistry.onDidChange(this._update, this, this._disposables);
 		modes.CodeLensProviderRegistry.onDidChange(this._update, this, this._disposables);
 		modes.DefinitionProviderRegistry.onDidChange(this._update, this, this._disposables);
-		modes.TypeImplementationProviderRegistry.onDidChange(this._update, this, this._disposables);
+		modes.ImplementationProviderRegistry.onDidChange(this._update, this, this._disposables);
 		modes.HoverProviderRegistry.onDidChange(this._update, this, this._disposables);
 		modes.DocumentHighlightProviderRegistry.onDidChange(this._update, this, this._disposables);
 		modes.DocumentSymbolProviderRegistry.onDidChange(this._update, this, this._disposables);
@@ -85,7 +85,7 @@ export class EditorModeContext {
 		this._hasCodeActionsProvider.reset();
 		this._hasCodeLensProvider.reset();
 		this._hasDefinitionProvider.reset();
-		this._hasTypeImplementationProvider.reset();
+		this._hasImplementationProvider.reset();
 		this._hasHoverProvider.reset();
 		this._hasDocumentHighlightProvider.reset();
 		this._hasDocumentSymbolProvider.reset();
@@ -108,7 +108,7 @@ export class EditorModeContext {
 		this._hasCodeActionsProvider.set(modes.CodeActionProviderRegistry.has(model));
 		this._hasCodeLensProvider.set(modes.CodeLensProviderRegistry.has(model));
 		this._hasDefinitionProvider.set(modes.DefinitionProviderRegistry.has(model));
-		this._hasTypeImplementationProvider.set(modes.TypeImplementationProviderRegistry.has(model));
+		this._hasImplementationProvider.set(modes.ImplementationProviderRegistry.has(model));
 		this._hasHoverProvider.set(modes.HoverProviderRegistry.has(model));
 		this._hasDocumentHighlightProvider.set(modes.DocumentHighlightProviderRegistry.has(model));
 		this._hasDocumentSymbolProvider.set(modes.DocumentSymbolProviderRegistry.has(model));

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

@@ -26,7 +26,7 @@ import { editorAction, IActionOptions, ServicesAccessor, EditorAction } from 'vs
 import { Location, DefinitionProviderRegistry } from 'vs/editor/common/modes';
 import { ICodeEditor, IEditorMouseEvent, IMouseTarget } from 'vs/editor/browser/editorBrowser';
 import { editorContribution } from 'vs/editor/browser/editorBrowserExtensions';
-import { getDeclarationsAtPosition, getTypeImplementationAtPosition } from 'vs/editor/contrib/goToDeclaration/common/goToDeclaration';
+import { getDeclarationsAtPosition, getImplementationAtPosition } from 'vs/editor/contrib/goToDeclaration/common/goToDeclaration';
 import { ReferencesController } from 'vs/editor/contrib/referenceSearch/browser/referencesController';
 import { ReferencesModel } from 'vs/editor/contrib/referenceSearch/browser/referencesModel';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
@@ -241,7 +241,7 @@ export class GoToImplementationAction extends DefinitionAction {
 			label: nls.localize('actions.goToImplementation.label', "Go to Implementation"),
 			alias: 'Go to Implementation',
 			precondition: ContextKeyExpr.and(
-				ModeContextKeys.hasTypeImplementationProvider,
+				ModeContextKeys.hasImplementationProvider,
 				ModeContextKeys.isInEmbeddedEditor.toNegated()),
 			kbOpts: {
 				kbExpr: EditorContextKeys.TextFocus,
@@ -255,7 +255,7 @@ export class GoToImplementationAction extends DefinitionAction {
 	}
 
 	protected getDeclarationsAtPosition(model: editorCommon.IModel, position: corePosition.Position): TPromise<Location[]> {
-		return getTypeImplementationAtPosition(model, position);
+		return getImplementationAtPosition(model, position);
 	}
 }
 
@@ -270,7 +270,7 @@ export class PeekImplementationAction extends DefinitionAction {
 			label: nls.localize('actions.peekImplementation.label', "Peek Implementation"),
 			alias: 'Peek Implementation',
 			precondition: ContextKeyExpr.and(
-				ModeContextKeys.hasTypeImplementationProvider,
+				ModeContextKeys.hasImplementationProvider,
 				ModeContextKeys.isInEmbeddedEditor.toNegated()),
 			kbOpts: {
 				kbExpr: EditorContextKeys.TextFocus,
@@ -284,7 +284,7 @@ export class PeekImplementationAction extends DefinitionAction {
 	}
 
 	protected getDeclarationsAtPosition(model: editorCommon.IModel, position: corePosition.Position): TPromise<Location[]> {
-		return getTypeImplementationAtPosition(model, position);
+		return getImplementationAtPosition(model, position);
 	}
 }
 

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

@@ -9,7 +9,7 @@ import { onUnexpectedExternalError } from 'vs/base/common/errors';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IReadOnlyModel } from 'vs/editor/common/editorCommon';
 import { CommonEditorRegistry } from 'vs/editor/common/editorCommonExtensions';
-import { DefinitionProviderRegistry, TypeImplementationProviderRegistry, Location } from 'vs/editor/common/modes';
+import { DefinitionProviderRegistry, ImplementationProviderRegistry, Location } from 'vs/editor/common/modes';
 import { asWinJsPromise } from 'vs/base/common/async';
 import { Position } from 'vs/editor/common/core/position';
 
@@ -44,14 +44,14 @@ export function getDeclarationsAtPosition(model: IReadOnlyModel, position: Posit
 	return outputResults(promises);
 }
 
-export function getTypeImplementationAtPosition(model: IReadOnlyModel, position: Position): TPromise<Location[]> {
+export function getImplementationAtPosition(model: IReadOnlyModel, position: Position): TPromise<Location[]> {
 
-	const provider = TypeImplementationProviderRegistry.ordered(model);
+	const provider = ImplementationProviderRegistry.ordered(model);
 
 	// get results
 	const promises = provider.map((provider, idx) => {
 		return asWinJsPromise((token) => {
-			return provider.provideTypeImplementation(model, position, token);
+			return provider.provideImplementation(model, position, token);
 		}).then(result => {
 			return result;
 		}, err => {
@@ -62,4 +62,4 @@ export function getTypeImplementationAtPosition(model: IReadOnlyModel, position:
 }
 
 CommonEditorRegistry.registerDefaultLanguageCommand('_executeDefinitionProvider', getDeclarationsAtPosition);
-CommonEditorRegistry.registerDefaultLanguageCommand('_executeTypeImplementationProvider', getTypeImplementationAtPosition);
+CommonEditorRegistry.registerDefaultLanguageCommand('_executeImplementationProvider', getImplementationAtPosition);

src/vs/monaco.d.ts

@@ -3939,7 +3939,7 @@ declare module monaco.languages {
     /**
      * Register a type implementation provider (used by e.g. go to implementation).
      */
-    export function registerTypeImplementationProvider(languageId: string, provider: TypeImplementationProvider): IDisposable;
+    export function registerImplementationProvider(languageId: string, provider: ImplementationProvider): IDisposable;
 
     /**
      * Register a code lens provider (used by e.g. inline code lenses).
@@ -4557,11 +4557,11 @@ declare module monaco.languages {
      * The type definition provider interface defines the contract between extensions and
      * the go to implementation feature.
      */
-    export interface TypeImplementationProvider {
+    export interface ImplementationProvider {
         /**
          * Provide the implementation of the symbol at the given position and document.
          */
-        provideTypeImplementation(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Definition | Thenable<Definition>;
+        provideImplementation(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Definition | Thenable<Definition>;
     }
 
     /**

src/vs/vscode.d.ts

@@ -1649,7 +1649,7 @@ declare module 'vscode' {
 	 * The type implemenetation provider interface defines the contract between extensions and
 	 * the go to implementation feature.
 	 */
-	export interface TypeImplementationProvider {
+	export interface ImplementationProvider {
 
 		/**
 		 * Provide the implementations of the symbol at the given position and document.
@@ -1660,7 +1660,7 @@ declare module 'vscode' {
 		 * @return A definition or a thenable that resolves to such. The lack of a result can be
 		 * signaled by returning `undefined` or `null`.
 		 */
-		provideTypeImplementation(document: TextDocument, position: Position, token: CancellationToken): ProviderResult<Definition>;
+		provideImplementation(document: TextDocument, position: Position, token: CancellationToken): ProviderResult<Definition>;
 	}
 
 	/**
@@ -4164,7 +4164,7 @@ declare module 'vscode' {
 		 * @param provider An implementation provider.
 		 * @return A [disposable](#Disposable) that unregisters this provider when being disposed.
 		 */
-		export function registerTypeImplementationProvider(selector: DocumentSelector, provider: TypeImplementationProvider): Disposable;
+		export function registerImplementationProvider(selector: DocumentSelector, provider: ImplementationProvider): Disposable;
 
 		/**
 		 * Register a hover provider.

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -211,8 +211,8 @@ export function createApiFactory(initData: IInitData, threadService: IThreadServ
 			registerDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.DefinitionProvider): vscode.Disposable {
 				return languageFeatures.registerDefinitionProvider(selector, provider);
 			},
-			registerTypeImplementationProvider(selector: vscode.DocumentSelector, provider: vscode.TypeImplementationProvider): vscode.Disposable {
-				return languageFeatures.registerTypeImplementationProvider(selector, provider);
+			registerImplementationProvider(selector: vscode.DocumentSelector, provider: vscode.ImplementationProvider): vscode.Disposable {
+				return languageFeatures.registerImplementationProvider(selector, provider);
 			},
 			registerHoverProvider(selector: vscode.DocumentSelector, provider: vscode.HoverProvider): vscode.Disposable {
 				return languageFeatures.registerHoverProvider(selector, provider);

src/vs/workbench/api/node/extHost.protocol.ts

@@ -361,7 +361,7 @@ export abstract class ExtHostLanguageFeaturesShape {
 	$provideCodeLenses(handle: number, resource: URI): TPromise<modes.ICodeLensSymbol[]> { throw ni(); }
 	$resolveCodeLens(handle: number, resource: URI, symbol: modes.ICodeLensSymbol): TPromise<modes.ICodeLensSymbol> { throw ni(); }
 	$provideDefinition(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.Definition> { throw ni(); }
-	$provideTypeImplementation(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.Definition> { throw ni(); }
+	$provideImplementation(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.Definition> { throw ni(); }
 	$provideHover(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.Hover> { throw ni(); }
 	$provideDocumentHighlights(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.DocumentHighlight[]> { throw ni(); }
 	$provideReferences(handle: number, resource: URI, position: editorCommon.IPosition, context: modes.ReferenceContext): TPromise<modes.Location[]> { throw ni(); }

src/vs/workbench/api/node/extHostApiCommands.ts

@@ -46,7 +46,7 @@ export class ExtHostApiCommands {
 			],
 			returns: 'A promise that resolves to an array of Location-instances.'
 		});
-		this._register('vscode.executeTypeImplementationProvider', this._executeTypeImplementationProvider, {
+		this._register('vscode.executeImplementationProvider', this._executeImplementationProvider, {
 			description: 'Execute all implementation providers.',
 			args: [
 				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
@@ -273,12 +273,12 @@ export class ExtHostApiCommands {
 		});
 	}
 
-	private _executeTypeImplementationProvider(resource: URI, position: types.Position): Thenable<types.Location[]> {
+	private _executeImplementationProvider(resource: URI, position: types.Position): Thenable<types.Location[]> {
 		const args = {
 			resource,
 			position: position && typeConverters.fromPosition(position)
 		};
-		return this._commands.executeCommand<modes.Location[]>('_executeTypeImplementationProvider', args).then(value => {
+		return this._commands.executeCommand<modes.Location[]>('_executeImplementationProvider', args).then(value => {
 			if (Array.isArray(value)) {
 				return value.map(typeConverters.location.to);
 			}