extHost.api.impl.ts 33.6 KB
Newer Older
E
Erich Gamma 已提交
1 2 3 4 5 6
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
'use strict';

7
import { Emitter } from 'vs/base/common/event';
8
import { TernarySearchTree } from 'vs/base/common/map';
J
Johannes Rieken 已提交
9
import { score } from 'vs/editor/common/modes/languageSelector';
10
import * as Platform from 'vs/base/common/platform';
E
Erich Gamma 已提交
11
import * as errors from 'vs/base/common/errors';
12 13
import product from 'vs/platform/node/product';
import pkg from 'vs/platform/node/package';
J
Johannes Rieken 已提交
14
import { ExtHostFileSystemEventService } from 'vs/workbench/api/node/extHostFileSystemEventService';
J
Johannes Rieken 已提交
15
import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/node/extHostDocumentsAndEditors';
J
Johannes Rieken 已提交
16
import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
17
import { ExtHostDocumentContentProvider } from 'vs/workbench/api/node/extHostDocumentContentProviders';
J
Johannes Rieken 已提交
18 19 20
import { ExtHostDocumentSaveParticipant } from 'vs/workbench/api/node/extHostDocumentSaveParticipant';
import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
import { ExtHostDiagnostics } from 'vs/workbench/api/node/extHostDiagnostics';
S
Sandeep Somavarapu 已提交
21
import { ExtHostTreeViews } from 'vs/workbench/api/node/extHostTreeViews';
J
Johannes Rieken 已提交
22 23
import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
import { ExtHostQuickOpen } from 'vs/workbench/api/node/extHostQuickOpen';
24
import { ExtHostProgress } from 'vs/workbench/api/node/extHostProgress';
J
Joao Moreno 已提交
25
import { ExtHostSCM } from 'vs/workbench/api/node/extHostSCM';
J
Johannes Rieken 已提交
26 27 28 29 30 31
import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
import { ExtHostStatusBar } from 'vs/workbench/api/node/extHostStatusBar';
import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
import { ExtHostOutputService } from 'vs/workbench/api/node/extHostOutputService';
import { ExtHostTerminalService } from 'vs/workbench/api/node/extHostTerminalService';
import { ExtHostMessageService } from 'vs/workbench/api/node/extHostMessageService';
J
Johannes Rieken 已提交
32
import { ExtHostEditors } from 'vs/workbench/api/node/extHostTextEditors';
J
Johannes Rieken 已提交
33 34
import { ExtHostLanguages } from 'vs/workbench/api/node/extHostLanguages';
import { ExtHostLanguageFeatures } from 'vs/workbench/api/node/extHostLanguageFeatures';
35
import { ExtHostApiCommands } from 'vs/workbench/api/node/extHostApiCommands';
36
import { ExtHostTask } from 'vs/workbench/api/node/extHostTask';
37
import { ExtHostDebugService } from 'vs/workbench/api/node/extHostDebugService';
38
import { ExtHostWindow } from 'vs/workbench/api/node/extHostWindow';
J
Johannes Rieken 已提交
39
import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
E
Erich Gamma 已提交
40 41 42
import URI from 'vs/base/common/uri';
import Severity from 'vs/base/common/severity';
import EditorCommon = require('vs/editor/common/editorCommon');
J
Johannes Rieken 已提交
43 44 45 46
import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
import { TPromise } from 'vs/base/common/winjs.base';
import { CancellationTokenSource } from 'vs/base/common/cancellation';
47
import * as vscode from 'vscode';
E
Erich Gamma 已提交
48
import * as paths from 'vs/base/common/paths';
49
import { MainContext, ExtHostContext, IInitData } from './extHost.protocol';
50
import * as languageConfiguration from 'vs/editor/common/modes/languageConfiguration';
51
import { TextEditorCursorStyle } from 'vs/editor/common/config/editorOptions';
B
Benjamin Pasero 已提交
52 53 54
import { ExtHostThreadService } from 'vs/workbench/services/thread/node/extHostThreadService';
import { ProxyIdentifier } from 'vs/workbench/services/thread/common/threadService';
import { ExtHostDialogs } from 'vs/workbench/api/node/extHostDialogs';
55 56
import { ExtHostFileSystem } from 'vs/workbench/api/node/extHostFileSystem';
import { FileChangeType, FileType } from 'vs/platform/files/common/files';
57
import { ExtHostDecorations } from 'vs/workbench/api/node/extHostDecorations';
58
import { toGlobPattern, toLanguageSelector } from 'vs/workbench/api/node/extHostTypeConverters';
A
Alex Dima 已提交
59
import { ExtensionActivatedByAPI } from 'vs/workbench/api/node/extHostExtensionActivator';
J
Joao Moreno 已提交
60
import { ILogService } from 'vs/platform/log/common/log';
61
import { isFalsyOrEmpty } from 'vs/base/common/arrays';
E
Erich Gamma 已提交
62

63
export interface IExtensionApiFactory {
64
	(extension: IExtensionDescription): typeof vscode;
65 66
}

67
function proposedApiFunction<T>(extension: IExtensionDescription, fn: T): T {
68
	if (extension.enableProposedApi) {
69 70 71
		return fn;
	} else {
		return <any>(() => {
72
			throw new Error(`[${extension.id}]: Proposed API is only available when running out of dev or with the following command line switch: --enable-proposed-api ${extension.id}`);
73 74 75 76
		});
	}
}

E
Erich Gamma 已提交
77
/**
78
 * This method instantiates and returns the extension API surface
E
Erich Gamma 已提交
79
 */
80 81
export function createApiFactory(
	initData: IInitData,
82
	threadService: ExtHostThreadService,
83 84
	extHostWorkspace: ExtHostWorkspace,
	extHostConfiguration: ExtHostConfiguration,
J
Joao Moreno 已提交
85 86
	extensionService: ExtHostExtensionService,
	logService: ILogService
87
): IExtensionApiFactory {
88

89
	// Addressable instances
90
	const extHostHeapService = threadService.set(ExtHostContext.ExtHostHeapService, new ExtHostHeapService());
91
	const extHostDecorations = threadService.set(ExtHostContext.ExtHostDecorations, new ExtHostDecorations(threadService));
92
	const extHostDocumentsAndEditors = threadService.set(ExtHostContext.ExtHostDocumentsAndEditors, new ExtHostDocumentsAndEditors(threadService));
93 94
	const extHostDocuments = threadService.set(ExtHostContext.ExtHostDocuments, new ExtHostDocuments(threadService, extHostDocumentsAndEditors));
	const extHostDocumentContentProviders = threadService.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(threadService, extHostDocumentsAndEditors));
95
	const extHostDocumentSaveParticipant = threadService.set(ExtHostContext.ExtHostDocumentSaveParticipant, new ExtHostDocumentSaveParticipant(extHostDocuments, threadService.get(MainContext.MainThreadEditors)));
96
	const extHostEditors = threadService.set(ExtHostContext.ExtHostEditors, new ExtHostEditors(threadService, extHostDocumentsAndEditors));
J
Joao Moreno 已提交
97
	const extHostCommands = threadService.set(ExtHostContext.ExtHostCommands, new ExtHostCommands(threadService, extHostHeapService, logService));
98
	const extHostTreeViews = threadService.set(ExtHostContext.ExtHostTreeViews, new ExtHostTreeViews(threadService.get(MainContext.MainThreadTreeViews), extHostCommands));
99
	threadService.set(ExtHostContext.ExtHostWorkspace, extHostWorkspace);
100
	const extHostDebugService = threadService.set(ExtHostContext.ExtHostDebugService, new ExtHostDebugService(threadService, extHostWorkspace));
101
	threadService.set(ExtHostContext.ExtHostConfiguration, extHostConfiguration);
102 103
	const extHostDiagnostics = threadService.set(ExtHostContext.ExtHostDiagnostics, new ExtHostDiagnostics(threadService));
	const languageFeatures = threadService.set(ExtHostContext.ExtHostLanguageFeatures, new ExtHostLanguageFeatures(threadService, extHostDocuments, extHostCommands, extHostHeapService, extHostDiagnostics));
104
	const extHostFileSystem = threadService.set(ExtHostContext.ExtHostFileSystem, new ExtHostFileSystem(threadService));
105
	const extHostFileSystemEvent = threadService.set(ExtHostContext.ExtHostFileSystemEventService, new ExtHostFileSystemEventService());
106
	const extHostQuickOpen = threadService.set(ExtHostContext.ExtHostQuickOpen, new ExtHostQuickOpen(threadService, extHostWorkspace, extHostCommands));
107
	const extHostTerminalService = threadService.set(ExtHostContext.ExtHostTerminalService, new ExtHostTerminalService(threadService));
J
Joao Moreno 已提交
108
	const extHostSCM = threadService.set(ExtHostContext.ExtHostSCM, new ExtHostSCM(threadService, extHostCommands, logService));
D
Dirk Baeumer 已提交
109
	const extHostTask = threadService.set(ExtHostContext.ExtHostTask, new ExtHostTask(threadService, extHostWorkspace));
110
	const extHostWindow = threadService.set(ExtHostContext.ExtHostWindow, new ExtHostWindow(threadService));
111 112 113 114 115
	threadService.set(ExtHostContext.ExtHostExtensionService, extensionService);

	// Check that no named customers are missing
	const expected: ProxyIdentifier<any>[] = Object.keys(ExtHostContext).map((key) => ExtHostContext[key]);
	threadService.assertRegistered(expected);
116

117 118
	// Other instances
	const extHostMessageService = new ExtHostMessageService(threadService);
119
	const extHostDialogs = new ExtHostDialogs(threadService);
120
	const extHostStatusBar = new ExtHostStatusBar(threadService);
121
	const extHostProgress = new ExtHostProgress(threadService.get(MainContext.MainThreadProgress));
122 123
	const extHostOutputService = new ExtHostOutputService(threadService);
	const extHostLanguages = new ExtHostLanguages(threadService);
124

125 126
	// Register API-ish commands
	ExtHostApiCommands.register(extHostCommands);
127

128
	return function (extension: IExtensionDescription): typeof vscode {
129

A
Alex Dima 已提交
130 131
		const EXTENSION_ID = extension.id;

132 133 134 135 136 137
		if (!isFalsyOrEmpty(product.extensionAllowedProposedApi)
			&& product.extensionAllowedProposedApi.indexOf(extension.id) >= 0
		) {
			// fast lane -> proposed api is available to all extensions
			// that are listed in product.json-files
			extension.enableProposedApi = true;
138

139
		} else if (extension.enableProposedApi && !extension.isBuiltin) {
140 141 142 143
			if (
				!initData.environment.enableProposedApiForAll &&
				initData.environment.enableProposedApiFor.indexOf(extension.id) < 0
			) {
144
				extension.enableProposedApi = false;
145
				console.error(`Extension '${extension.id} cannot use PROPOSED API (must started out of dev or enabled via --enable-proposed-api)`);
146 147

			} else {
148 149 150
				// proposed api is available when developing or when an extension was explicitly
				// spelled out via a command line argument
				console.warn(`Extension '${extension.id}' uses PROPOSED API which is subject to change and removal without notice.`);
151
			}
152 153
		}

154 155
		// namespace: commands
		const commands: typeof vscode.commands = {
M
Matt Bierner 已提交
156
			registerCommand(id: string, command: <T>(...args: any[]) => T | Thenable<T>, thisArgs?: any): vscode.Disposable {
157
				return extHostCommands.registerCommand(id, command, thisArgs);
158
			},
159
			registerTextEditorCommand(id: string, callback: (textEditor: vscode.TextEditor, edit: vscode.TextEditorEdit, ...args: any[]) => void, thisArg?: any): vscode.Disposable {
160
				return extHostCommands.registerCommand(id, (...args: any[]): any => {
161 162 163
					let activeTextEditor = extHostEditors.getActiveTextEditor();
					if (!activeTextEditor) {
						console.warn('Cannot execute ' + id + ' because there is no active text editor.');
164
						return undefined;
165
					}
166 167 168 169 170 171 172 173 174 175

					return activeTextEditor.edit((edit: vscode.TextEditorEdit) => {
						args.unshift(activeTextEditor, edit);
						callback.apply(thisArg, args);

					}).then((result) => {
						if (!result) {
							console.warn('Edits from command ' + id + ' were not applied.');
						}
					}, (err) => {
176
						console.warn('An error occurred while running command ' + id, err);
177
					});
178
				});
179 180
			},
			registerDiffInformationCommand: proposedApiFunction(extension, (id: string, callback: (diff: vscode.LineChange[], ...args: any[]) => any, thisArg?: any): vscode.Disposable => {
181 182 183 184 185 186 187 188 189 190
				return extHostCommands.registerCommand(id, async (...args: any[]) => {
					let activeTextEditor = extHostEditors.getActiveTextEditor();
					if (!activeTextEditor) {
						console.warn('Cannot execute ' + id + ' because there is no active text editor.');
						return undefined;
					}

					const diff = await extHostEditors.getDiffInformation(activeTextEditor.id);
					callback.apply(thisArg, [diff, ...args]);
				});
191
			}),
192
			executeCommand<T>(id: string, ...args: any[]): Thenable<T> {
193
				return extHostCommands.executeCommand<T>(id, ...args);
194
			},
195 196 197
			getCommands(filterInternal: boolean = false): Thenable<string[]> {
				return extHostCommands.getCommands(filterInternal);
			}
198
		};
199

200 201
		// namespace: env
		const env: typeof vscode.env = Object.freeze({
202 203
			get machineId() { return initData.telemetryInfo.machineId; },
			get sessionId() { return initData.telemetryInfo.sessionId; },
204
			get language() { return Platform.language; },
J
Johannes Rieken 已提交
205 206
			get appName() { return product.nameLong; },
			get appRoot() { return initData.environment.appRoot; },
207
		});
E
Erich Gamma 已提交
208

209 210 211
		// namespace: extensions
		const extensions: typeof vscode.extensions = {
			getExtension(extensionId: string): Extension<any> {
212
				let desc = extensionService.getExtensionDescription(extensionId);
213 214 215
				if (desc) {
					return new Extension(extensionService, desc);
				}
216
				return undefined;
217 218
			},
			get all(): Extension<any>[] {
219
				return extensionService.getAllExtensionDescriptions().map((desc) => new Extension(extensionService, desc));
E
Erich Gamma 已提交
220
			}
221
		};
E
Erich Gamma 已提交
222

223 224 225 226 227 228 229 230 231
		// namespace: languages
		const languages: typeof vscode.languages = {
			createDiagnosticCollection(name?: string): vscode.DiagnosticCollection {
				return extHostDiagnostics.createDiagnosticCollection(name);
			},
			getLanguages(): TPromise<string[]> {
				return extHostLanguages.getLanguages();
			},
			match(selector: vscode.DocumentSelector, document: vscode.TextDocument): number {
232
				return score(toLanguageSelector(selector), document.uri, document.languageId);
233 234 235 236 237 238 239 240 241 242
			},
			registerCodeActionsProvider(selector: vscode.DocumentSelector, provider: vscode.CodeActionProvider): vscode.Disposable {
				return languageFeatures.registerCodeActionProvider(selector, provider);
			},
			registerCodeLensProvider(selector: vscode.DocumentSelector, provider: vscode.CodeLensProvider): vscode.Disposable {
				return languageFeatures.registerCodeLensProvider(selector, provider);
			},
			registerDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.DefinitionProvider): vscode.Disposable {
				return languageFeatures.registerDefinitionProvider(selector, provider);
			},
M
Matt Bierner 已提交
243 244
			registerImplementationProvider(selector: vscode.DocumentSelector, provider: vscode.ImplementationProvider): vscode.Disposable {
				return languageFeatures.registerImplementationProvider(selector, provider);
245
			},
246 247 248
			registerTypeDefinitionProvider(selector: vscode.DocumentSelector, provider: vscode.TypeDefinitionProvider): vscode.Disposable {
				return languageFeatures.registerTypeDefinitionProvider(selector, provider);
			},
249
			registerHoverProvider(selector: vscode.DocumentSelector, provider: vscode.HoverProvider): vscode.Disposable {
250
				return languageFeatures.registerHoverProvider(selector, provider, extension.id);
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
			},
			registerDocumentHighlightProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentHighlightProvider): vscode.Disposable {
				return languageFeatures.registerDocumentHighlightProvider(selector, provider);
			},
			registerReferenceProvider(selector: vscode.DocumentSelector, provider: vscode.ReferenceProvider): vscode.Disposable {
				return languageFeatures.registerReferenceProvider(selector, provider);
			},
			registerRenameProvider(selector: vscode.DocumentSelector, provider: vscode.RenameProvider): vscode.Disposable {
				return languageFeatures.registerRenameProvider(selector, provider);
			},
			registerDocumentSymbolProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentSymbolProvider): vscode.Disposable {
				return languageFeatures.registerDocumentSymbolProvider(selector, provider);
			},
			registerWorkspaceSymbolProvider(provider: vscode.WorkspaceSymbolProvider): vscode.Disposable {
				return languageFeatures.registerWorkspaceSymbolProvider(provider);
			},
			registerDocumentFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentFormattingEditProvider): vscode.Disposable {
				return languageFeatures.registerDocumentFormattingEditProvider(selector, provider);
			},
			registerDocumentRangeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentRangeFormattingEditProvider): vscode.Disposable {
				return languageFeatures.registerDocumentRangeFormattingEditProvider(selector, provider);
			},
			registerOnTypeFormattingEditProvider(selector: vscode.DocumentSelector, provider: vscode.OnTypeFormattingEditProvider, firstTriggerCharacter: string, ...moreTriggerCharacters: string[]): vscode.Disposable {
				return languageFeatures.registerOnTypeFormattingEditProvider(selector, provider, [firstTriggerCharacter].concat(moreTriggerCharacters));
			},
			registerSignatureHelpProvider(selector: vscode.DocumentSelector, provider: vscode.SignatureHelpProvider, ...triggerCharacters: string[]): vscode.Disposable {
				return languageFeatures.registerSignatureHelpProvider(selector, provider, triggerCharacters);
			},
			registerCompletionItemProvider(selector: vscode.DocumentSelector, provider: vscode.CompletionItemProvider, ...triggerCharacters: string[]): vscode.Disposable {
280
				return languageFeatures.registerCompletionItemProvider(selector, provider, triggerCharacters);
281 282 283 284
			},
			registerDocumentLinkProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentLinkProvider): vscode.Disposable {
				return languageFeatures.registerDocumentLinkProvider(selector, provider);
			},
285 286 287
			registerColorProvider(selector: vscode.DocumentSelector, provider: vscode.DocumentColorProvider): vscode.Disposable {
				return languageFeatures.registerColorProvider(selector, provider);
			},
288 289
			setLanguageConfiguration: (language: string, configuration: vscode.LanguageConfiguration): vscode.Disposable => {
				return languageFeatures.setLanguageConfiguration(language, configuration);
290
			}
291
		};
E
Erich Gamma 已提交
292

293 294 295 296 297 298 299 300
		// namespace: window
		const window: typeof vscode.window = {
			get activeTextEditor() {
				return extHostEditors.getActiveTextEditor();
			},
			get visibleTextEditors() {
				return extHostEditors.getVisibleTextEditors();
			},
J
Johannes Rieken 已提交
301
			showTextDocument(documentOrUri: vscode.TextDocument | vscode.Uri, columnOrOptions?: vscode.ViewColumn | vscode.TextDocumentShowOptions, preserveFocus?: boolean): TPromise<vscode.TextEditor> {
B
Benjamin Pasero 已提交
302
				let documentPromise: TPromise<vscode.TextDocument>;
J
Johannes Rieken 已提交
303 304
				if (URI.isUri(documentOrUri)) {
					documentPromise = TPromise.wrap(workspace.openTextDocument(documentOrUri));
B
Benjamin Pasero 已提交
305
				} else {
J
Johannes Rieken 已提交
306
					documentPromise = TPromise.wrap(<vscode.TextDocument>documentOrUri);
B
Benjamin Pasero 已提交
307 308 309 310
				}
				return documentPromise.then(document => {
					return extHostEditors.showTextDocument(document, columnOrOptions, preserveFocus);
				});
311 312 313 314
			},
			createTextEditorDecorationType(options: vscode.DecorationRenderOptions): vscode.TextEditorDecorationType {
				return extHostEditors.createTextEditorDecorationType(options);
			},
315 316 317
			onDidChangeActiveTextEditor(listener, thisArg?, disposables?) {
				return extHostEditors.onDidChangeActiveTextEditor(listener, thisArg, disposables);
			},
318 319 320
			onDidChangeVisibleTextEditors(listener, thisArg, disposables) {
				return extHostEditors.onDidChangeVisibleTextEditors(listener, thisArg, disposables);
			},
321
			onDidChangeTextEditorSelection(listener: (e: vscode.TextEditorSelectionChangeEvent) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
322 323
				return extHostEditors.onDidChangeTextEditorSelection(listener, thisArgs, disposables);
			},
324
			onDidChangeTextEditorOptions(listener: (e: vscode.TextEditorOptionsChangeEvent) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
325 326 327 328 329
				return extHostEditors.onDidChangeTextEditorOptions(listener, thisArgs, disposables);
			},
			onDidChangeTextEditorViewColumn(listener, thisArg?, disposables?) {
				return extHostEditors.onDidChangeTextEditorViewColumn(listener, thisArg, disposables);
			},
330 331 332
			onDidCloseTerminal(listener, thisArg?, disposables?) {
				return extHostTerminalService.onDidCloseTerminal(listener, thisArg, disposables);
			},
J
Joao Moreno 已提交
333 334
			get state() {
				return extHostWindow.state;
335
			},
J
Joao Moreno 已提交
336
			onDidChangeWindowState(listener, thisArg?, disposables?) {
J
Joao Moreno 已提交
337
				return extHostWindow.onDidChangeWindowState(listener, thisArg, disposables);
J
Joao Moreno 已提交
338
			},
J
Joao Moreno 已提交
339
			showInformationMessage(message, first, ...rest) {
340
				return extHostMessageService.showMessage(extension, Severity.Info, message, first, rest);
341
			},
J
Joao Moreno 已提交
342
			showWarningMessage(message, first, ...rest) {
343
				return extHostMessageService.showMessage(extension, Severity.Warning, message, first, rest);
344
			},
J
Joao Moreno 已提交
345
			showErrorMessage(message, first, ...rest) {
346
				return extHostMessageService.showMessage(extension, Severity.Error, message, first, rest);
347
			},
348
			showQuickPick(items: any, options: vscode.QuickPickOptions, token?: vscode.CancellationToken) {
349 350
				return extHostQuickOpen.showQuickPick(items, options, token);
			},
351
			showWorkspaceFolderPick(options: vscode.WorkspaceFolderPickOptions) {
352
				return extHostQuickOpen.showWorkspaceFolderPick(options);
353
			},
354 355 356
			showInputBox(options?: vscode.InputBoxOptions, token?: vscode.CancellationToken) {
				return extHostQuickOpen.showInput(options, token);
			},
357 358 359 360 361 362
			showOpenDialog(options) {
				return extHostDialogs.showOpenDialog(options);
			},
			showSaveDialog(options) {
				return extHostDialogs.showSaveDialog(options);
			},
363
			createStatusBarItem(position?: vscode.StatusBarAlignment, priority?: number): vscode.StatusBarItem {
364
				return extHostStatusBar.createStatusBarEntry(extension.id, <number>position, priority);
365 366 367 368
			},
			setStatusBarMessage(text: string, timeoutOrThenable?: number | Thenable<any>): vscode.Disposable {
				return extHostStatusBar.setStatusBarMessage(text, timeoutOrThenable);
			},
369
			withScmProgress<R>(task: (progress: vscode.Progress<number>) => Thenable<R>) {
370
				console.warn(`[Deprecation Warning] function 'withScmProgress' is deprecated and should no longer be used. Use 'withProgress' instead.`);
371
				return extHostProgress.withProgress(extension, { location: extHostTypes.ProgressLocation.SourceControl }, (progress, token) => task({ report(n: number) { /*noop*/ } }));
J
Johannes Rieken 已提交
372 373 374
			},
			withProgress<R>(options: vscode.ProgressOptions, task: (progress: vscode.Progress<{ message?: string; percentage?: number }>) => Thenable<R>) {
				return extHostProgress.withProgress(extension, options, task);
375
			},
376 377 378
			createOutputChannel(name: string): vscode.OutputChannel {
				return extHostOutputService.createOutputChannel(name);
			},
379 380 381 382
			createTerminal(nameOrOptions: vscode.TerminalOptions | string, shellPath?: string, shellArgs?: string[]): vscode.Terminal {
				if (typeof nameOrOptions === 'object') {
					return extHostTerminalService.createTerminalFromOptions(<vscode.TerminalOptions>nameOrOptions);
				}
D
Daniel Imms 已提交
383
				return extHostTerminalService.createTerminal(<string>nameOrOptions, shellPath, shellArgs);
384
			},
S
Sandeep Somavarapu 已提交
385 386 387
			registerTreeDataProvider(viewId: string, treeDataProvider: vscode.TreeDataProvider<any>): vscode.Disposable {
				return extHostTreeViews.registerTreeDataProvider(viewId, treeDataProvider);
			},
388 389
			// proposed API
			sampleFunction: proposedApiFunction(extension, () => {
390
				return extHostMessageService.showMessage(extension, Severity.Info, 'Hello Proposed Api!', {}, []);
391
			}),
392 393
			registerDecorationProvider: proposedApiFunction(extension, (provider: vscode.DecorationProvider) => {
				return extHostDecorations.registerDecorationProvider(provider, extension.id);
394
			})
395
		};
E
Erich Gamma 已提交
396

397
		// namespace: workspace
398
		let warnedRootPath = false;
399 400
		const workspace: typeof vscode.workspace = {
			get rootPath() {
401 402 403 404
				if (!warnedRootPath) {
					warnedRootPath = true;
					extensionService.addMessage(EXTENSION_ID, Severity.Warning, 'workspace.rootPath is deprecated');
				}
405 406 407 408 409
				return extHostWorkspace.getPath();
			},
			set rootPath(value) {
				throw errors.readonly();
			},
410 411
			getWorkspaceFolder(resource) {
				return extHostWorkspace.getWorkspaceFolder(resource);
412
			},
413
			get workspaceFolders() {
414
				return extHostWorkspace.getWorkspaceFolders();
415
			},
416 417 418 419 420 421
			get name() {
				return extHostWorkspace.workspace ? extHostWorkspace.workspace.name : undefined;
			},
			set name(value) {
				throw errors.readonly();
			},
422
			onDidChangeWorkspaceFolders: function (listener, thisArgs?, disposables?) {
423
				return extHostWorkspace.onDidChangeWorkspace(listener, thisArgs, disposables);
424
			},
J
Johannes Rieken 已提交
425 426
			asRelativePath: (pathOrUri, includeWorkspace) => {
				return extHostWorkspace.getRelativePath(pathOrUri, includeWorkspace);
427 428
			},
			findFiles: (include, exclude, maxResults?, token?) => {
429
				return extHostWorkspace.findFiles(toGlobPattern(include), toGlobPattern(exclude), maxResults, token);
430 431 432 433 434
			},
			saveAll: (includeUntitled?) => {
				return extHostWorkspace.saveAll(includeUntitled);
			},
			applyEdit(edit: vscode.WorkspaceEdit): TPromise<boolean> {
435
				return extHostEditors.applyWorkspaceEdit(edit);
436 437
			},
			createFileSystemWatcher: (pattern, ignoreCreate, ignoreChange, ignoreDelete): vscode.FileSystemWatcher => {
438
				return extHostFileSystemEvent.createFileSystemWatcher(toGlobPattern(pattern), ignoreCreate, ignoreChange, ignoreDelete);
439 440 441 442 443 444 445
			},
			get textDocuments() {
				return extHostDocuments.getAllDocumentData().map(data => data.document);
			},
			set textDocuments(value) {
				throw errors.readonly();
			},
446
			openTextDocument(uriOrFileNameOrOptions?: vscode.Uri | string | { language?: string; content?: string; }) {
B
Benjamin Pasero 已提交
447 448
				let uriPromise: TPromise<URI>;

449
				let options = uriOrFileNameOrOptions as { language?: string; content?: string; };
B
Benjamin Pasero 已提交
450
				if (typeof uriOrFileNameOrOptions === 'string') {
B
Benjamin Pasero 已提交
451 452
					uriPromise = TPromise.as(URI.file(uriOrFileNameOrOptions));
				} else if (uriOrFileNameOrOptions instanceof URI) {
J
Johannes Rieken 已提交
453
					uriPromise = TPromise.as(uriOrFileNameOrOptions);
B
Benjamin Pasero 已提交
454 455
				} else if (!options || typeof options === 'object') {
					uriPromise = extHostDocuments.createDocumentData(options);
456
				} else {
B
Benjamin Pasero 已提交
457
					throw new Error('illegal argument - uriOrFileNameOrOptions');
458
				}
B
Benjamin Pasero 已提交
459 460 461 462 463 464

				return uriPromise.then(uri => {
					return extHostDocuments.ensureDocumentData(uri).then(() => {
						const data = extHostDocuments.getDocumentData(uri);
						return data && data.document;
					});
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
				});
			},
			onDidOpenTextDocument: (listener, thisArgs?, disposables?) => {
				return extHostDocuments.onDidAddDocument(listener, thisArgs, disposables);
			},
			onDidCloseTextDocument: (listener, thisArgs?, disposables?) => {
				return extHostDocuments.onDidRemoveDocument(listener, thisArgs, disposables);
			},
			onDidChangeTextDocument: (listener, thisArgs?, disposables?) => {
				return extHostDocuments.onDidChangeDocument(listener, thisArgs, disposables);
			},
			onDidSaveTextDocument: (listener, thisArgs?, disposables?) => {
				return extHostDocuments.onDidSaveDocument(listener, thisArgs, disposables);
			},
			onWillSaveTextDocument: (listener, thisArgs?, disposables?) => {
				return extHostDocumentSaveParticipant.onWillSaveTextDocumentEvent(listener, thisArgs, disposables);
481
			},
482
			onDidChangeConfiguration: (listener: (_: any) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) => {
483 484
				return extHostConfiguration.onDidChangeConfiguration(listener, thisArgs, disposables);
			},
485 486
			getConfiguration(section?: string, resource?: vscode.Uri): vscode.WorkspaceConfiguration {
				resource = arguments.length === 1 ? void 0 : resource;
S
Sandeep Somavarapu 已提交
487
				return extHostConfiguration.getConfiguration(section, resource, extension.id);
488
			},
489 490
			registerTextDocumentContentProvider(scheme: string, provider: vscode.TextDocumentContentProvider) {
				return extHostDocumentContentProviders.registerTextDocumentContentProvider(scheme, provider);
491
			},
492
			registerTaskProvider: (type: string, provider: vscode.TaskProvider) => {
493
				return extHostTask.registerTaskProvider(extension, provider);
J
Johannes Rieken 已提交
494 495
			},
			registerFileSystemProvider: proposedApiFunction(extension, (authority, provider) => {
496
				return extHostFileSystem.registerFileSystemProvider(authority, provider);
J
Johannes Rieken 已提交
497
			})
498
		};
499

500 501
		// namespace: scm
		const scm: typeof vscode.scm = {
502
			get inputBox() {
J
Joao Moreno 已提交
503
				return extHostSCM.getLastInputBox(extension);
504
			},
J
Joao Moreno 已提交
505 506
			createSourceControl(id: string, label: string, rootUri?: vscode.Uri) {
				return extHostSCM.createSourceControl(extension, id, label, rootUri);
J
Joao Moreno 已提交
507
			}
508
		};
J
Joao Moreno 已提交
509

510 511
		// namespace: debug
		const debug: typeof vscode.debug = {
512 513 514
			get activeDebugSession() {
				return extHostDebugService.activeDebugSession;
			},
515 516
			get activeDebugConsole() {
				return extHostDebugService.activeDebugConsole;
517
			},
518
			startDebugging(folder: vscode.WorkspaceFolder | undefined, nameOrConfig: string | vscode.DebugConfiguration) {
519
				return extHostDebugService.startDebugging(folder, nameOrConfig);
520
			},
521 522 523
			onDidStartDebugSession(listener, thisArg?, disposables?) {
				return extHostDebugService.onDidStartDebugSession(listener, thisArg, disposables);
			},
524
			onDidTerminateDebugSession(listener, thisArg?, disposables?) {
525
				return extHostDebugService.onDidTerminateDebugSession(listener, thisArg, disposables);
526
			},
A
Andre Weinand 已提交
527
			onDidChangeActiveDebugSession(listener, thisArg?, disposables?) {
528
				return extHostDebugService.onDidChangeActiveDebugSession(listener, thisArg, disposables);
A
Andre Weinand 已提交
529 530
			},
			onDidReceiveDebugSessionCustomEvent(listener, thisArg?, disposables?) {
A
Andre Weinand 已提交
531
				return extHostDebugService.onDidReceiveDebugSessionCustomEvent(listener, thisArg, disposables);
532
			},
A
Andre Weinand 已提交
533
			registerDebugConfigurationProvider(debugType: string, provider: vscode.DebugConfigurationProvider) {
534
				return extHostDebugService.registerDebugConfigurationProvider(debugType, provider);
535
			}
536 537 538
		};


539
		return <typeof vscode>{
540 541 542 543 544 545 546 547
			version: pkg.version,
			// namespaces
			commands,
			env,
			extensions,
			languages,
			window,
			workspace,
J
Joao Moreno 已提交
548
			scm,
549
			debug,
550 551
			// types
			CancellationTokenSource: CancellationTokenSource,
552
			CodeAction: extHostTypes.CodeAction,
553
			CodeLens: extHostTypes.CodeLens,
554
			Color: extHostTypes.Color,
555 556
			ColorPresentation: extHostTypes.ColorPresentation,
			ColorInformation: extHostTypes.ColorInformation,
557
			EndOfLine: extHostTypes.EndOfLine,
558 559 560
			CompletionItem: extHostTypes.CompletionItem,
			CompletionItemKind: extHostTypes.CompletionItemKind,
			CompletionList: extHostTypes.CompletionList,
M
Matt Bierner 已提交
561
			CompletionTriggerKind: extHostTypes.CompletionTriggerKind,
562 563 564 565 566
			Diagnostic: extHostTypes.Diagnostic,
			DiagnosticSeverity: extHostTypes.DiagnosticSeverity,
			Disposable: extHostTypes.Disposable,
			DocumentHighlight: extHostTypes.DocumentHighlight,
			DocumentHighlightKind: extHostTypes.DocumentHighlightKind,
567
			DocumentLink: extHostTypes.DocumentLink,
568 569
			EventEmitter: Emitter,
			Hover: extHostTypes.Hover,
570
			IndentAction: languageConfiguration.IndentAction,
571
			Location: extHostTypes.Location,
572
			MarkdownString: extHostTypes.MarkdownString,
573
			OverviewRulerLane: EditorCommon.OverviewRulerLane,
574 575 576 577 578 579 580 581 582 583 584 585
			ParameterInformation: extHostTypes.ParameterInformation,
			Position: extHostTypes.Position,
			Range: extHostTypes.Range,
			Selection: extHostTypes.Selection,
			SignatureHelp: extHostTypes.SignatureHelp,
			SignatureInformation: extHostTypes.SignatureInformation,
			SnippetString: extHostTypes.SnippetString,
			StatusBarAlignment: extHostTypes.StatusBarAlignment,
			SymbolInformation: extHostTypes.SymbolInformation,
			SymbolKind: extHostTypes.SymbolKind,
			TextDocumentSaveReason: extHostTypes.TextDocumentSaveReason,
			TextEdit: extHostTypes.TextEdit,
586
			TextEditorCursorStyle: TextEditorCursorStyle,
587
			TextEditorLineNumbersStyle: extHostTypes.TextEditorLineNumbersStyle,
588
			TextEditorRevealType: extHostTypes.TextEditorRevealType,
589
			TextEditorSelectionChangeKind: extHostTypes.TextEditorSelectionChangeKind,
590
			DecorationRangeBehavior: extHostTypes.DecorationRangeBehavior,
591
			Uri: URI,
592 593
			ViewColumn: extHostTypes.ViewColumn,
			WorkspaceEdit: extHostTypes.WorkspaceEdit,
J
Johannes Rieken 已提交
594
			ProgressLocation: extHostTypes.ProgressLocation,
S
Sandeep Somavarapu 已提交
595
			TreeItemCollapsibleState: extHostTypes.TreeItemCollapsibleState,
S
Sandeep Somavarapu 已提交
596
			TreeItem: extHostTypes.TreeItem,
597
			ThemeColor: extHostTypes.ThemeColor,
J
Joao Moreno 已提交
598
			// functions
599
			TaskRevealKind: extHostTypes.TaskRevealKind,
600
			TaskPanelKind: extHostTypes.TaskPanelKind,
601
			TaskGroup: extHostTypes.TaskGroup,
D
Dirk Baeumer 已提交
602 603
			ProcessExecution: extHostTypes.ProcessExecution,
			ShellExecution: extHostTypes.ShellExecution,
D
Dirk Baeumer 已提交
604
			TaskScope: extHostTypes.TaskScope,
S
Sandeep Somavarapu 已提交
605
			Task: extHostTypes.Task,
606
			ConfigurationTarget: extHostTypes.ConfigurationTarget,
607
			RelativePattern: extHostTypes.RelativePattern,
608

609
			// TODO@JOH,remote
610 611
			FileChangeType: <any>FileChangeType,
			FileType: <any>FileType
612
		};
613
	};
E
Erich Gamma 已提交
614 615 616 617
}

class Extension<T> implements vscode.Extension<T> {

A
Alex Dima 已提交
618
	private _extensionService: ExtHostExtensionService;
E
Erich Gamma 已提交
619 620 621 622 623

	public id: string;
	public extensionPath: string;
	public packageJSON: any;

J
Johannes Rieken 已提交
624
	constructor(extensionService: ExtHostExtensionService, description: IExtensionDescription) {
A
Alex Dima 已提交
625
		this._extensionService = extensionService;
E
Erich Gamma 已提交
626 627 628 629 630 631
		this.id = description.id;
		this.extensionPath = paths.normalize(description.extensionFolderPath, true);
		this.packageJSON = description;
	}

	get isActive(): boolean {
A
Alex Dima 已提交
632
		return this._extensionService.isActivated(this.id);
E
Erich Gamma 已提交
633 634 635
	}

	get exports(): T {
A
Alex Dima 已提交
636
		return <T>this._extensionService.getExtensionExports(this.id);
E
Erich Gamma 已提交
637 638 639
	}

	activate(): Thenable<T> {
A
Alex Dima 已提交
640
		return this._extensionService.activateById(this.id, new ExtensionActivatedByAPI(false)).then(() => this.exports);
E
Erich Gamma 已提交
641 642 643
	}
}

J
Johannes Rieken 已提交
644
export function initializeExtensionApi(extensionService: ExtHostExtensionService, apiFactory: IExtensionApiFactory): TPromise<void> {
645
	return extensionService.getExtensionPathIndex().then(trie => defineAPI(apiFactory, trie));
J
Johannes Rieken 已提交
646 647
}

648
function defineAPI(factory: IExtensionApiFactory, extensionPaths: TernarySearchTree<IExtensionDescription>): void {
J
Johannes Rieken 已提交
649 650

	// each extension is meant to get its own api implementation
J
Johannes Rieken 已提交
651
	const extApiImpl = new Map<string, typeof vscode>();
J
Johannes Rieken 已提交
652
	let defaultApiImpl: typeof vscode;
653 654 655

	const node_module = <any>require.__$__nodeRequire('module');
	const original = node_module._load;
E
Erich Gamma 已提交
656
	node_module._load = function load(request, parent, isMain) {
657 658 659 660 661
		if (request !== 'vscode') {
			return original.apply(this, arguments);
		}

		// get extension id from filename and api for extension
J
Johannes Rieken 已提交
662
		const ext = extensionPaths.findSubstr(parent.filename);
663
		if (ext) {
J
Johannes Rieken 已提交
664
			let apiImpl = extApiImpl.get(ext.id);
665
			if (!apiImpl) {
J
Johannes Rieken 已提交
666 667
				apiImpl = factory(ext);
				extApiImpl.set(ext.id, apiImpl);
668 669 670 671 672 673
			}
			return apiImpl;
		}

		// fall back to a default implementation
		if (!defaultApiImpl) {
674
			defaultApiImpl = factory(nullExtensionDescription);
E
Erich Gamma 已提交
675
		}
676
		return defaultApiImpl;
E
Erich Gamma 已提交
677 678
	};
}
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693

const nullExtensionDescription: IExtensionDescription = {
	id: 'nullExtensionDescription',
	name: 'Null Extension Description',
	publisher: 'vscode',
	activationEvents: undefined,
	contributes: undefined,
	enableProposedApi: false,
	engines: undefined,
	extensionDependencies: undefined,
	extensionFolderPath: undefined,
	isBuiltin: false,
	main: undefined,
	version: undefined
};