debt remove TPromise from extHost-files #53526

2026-04-25 19:18:59 +01:00 · 2018-10-19 09:49:05 +02:00
parent 66b397316d
commit 45f4904378
15 changed files with 152 additions and 175 deletions
--- a/src/vs/workbench/api/node/extHost.api.impl.ts
+++ b/src/vs/workbench/api/node/extHost.api.impl.ts
@@ -40,7 +40,6 @@ import { URI } from 'vs/base/common/uri';
 import Severity from 'vs/base/common/severity';
 import { IExtensionDescription } from 'vs/workbench/services/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';
 import * as vscode from 'vscode';
 import * as paths from 'vs/base/common/paths';
@@ -363,11 +362,11 @@ export function createApiFactory(
 				return extHostTerminalService.terminals;
 			},
 			showTextDocument(documentOrUri: vscode.TextDocument | vscode.Uri, columnOrOptions?: vscode.ViewColumn | vscode.TextDocumentShowOptions, preserveFocus?: boolean): Thenable<vscode.TextEditor> {
-				let documentPromise: TPromise<vscode.TextDocument>;
+				let documentPromise: Promise<vscode.TextDocument>;
 				if (URI.isUri(documentOrUri)) {
-					documentPromise = TPromise.wrap(workspace.openTextDocument(documentOrUri));
+					documentPromise = Promise.resolve(workspace.openTextDocument(documentOrUri));
 				} else {
-					documentPromise = TPromise.wrap(<vscode.TextDocument>documentOrUri);
+					documentPromise = Promise.resolve(<vscode.TextDocument>documentOrUri);
 				}
 				return documentPromise.then(document => {
 					return extHostEditors.showTextDocument(document, columnOrOptions, preserveFocus);
@@ -555,9 +554,9 @@ export function createApiFactory(

 				let options = uriOrFileNameOrOptions as { language?: string; content?: string; };
 				if (typeof uriOrFileNameOrOptions === 'string') {
-					uriPromise = TPromise.as(URI.file(uriOrFileNameOrOptions));
+					uriPromise = Promise.resolve(URI.file(uriOrFileNameOrOptions));
 				} else if (uriOrFileNameOrOptions instanceof URI) {
-					uriPromise = TPromise.as(uriOrFileNameOrOptions);
+					uriPromise = Promise.resolve(uriOrFileNameOrOptions);
 				} else if (!options || typeof options === 'object') {
 					uriPromise = extHostDocuments.createDocumentData(options);
 				} else {
@@ -844,7 +843,7 @@ class Extension<T> implements vscode.Extension<T> {
 	}
 }

-export function initializeExtensionApi(extensionService: ExtHostExtensionService, apiFactory: IExtensionApiFactory): TPromise<void> {
+export function initializeExtensionApi(extensionService: ExtHostExtensionService, apiFactory: IExtensionApiFactory): Promise<void> {
 	return extensionService.getExtensionPathIndex().then(trie => defineAPI(apiFactory, trie));
 }

--- a/src/vs/workbench/api/node/extHostComments.ts
+++ b/src/vs/workbench/api/node/extHostComments.ts
@@ -5,7 +5,6 @@

 import { asThenable } from 'vs/base/common/async';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import * as modes from 'vs/editor/common/modes';
 import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
 import * as extHostTypeConverter from 'vs/workbench/api/node/extHostTypeConverters';
@@ -68,7 +67,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 		const ran = <vscode.Range>extHostTypeConverter.Range.to(range);

 		if (!data || !data.document) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		const provider = this._documentProviders.get(handle);
@@ -82,7 +81,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 		const ran = <vscode.Range>extHostTypeConverter.Range.to(range);

 		if (!data || !data.document) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		const provider = this._documentProviders.get(handle);
@@ -120,7 +119,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 	$provideDocumentComments(handle: number, uri: UriComponents): Thenable<modes.CommentInfo> {
 		const data = this._documents.getDocumentData(URI.revive(uri));
 		if (!data || !data.document) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		const provider = this._documentProviders.get(handle);
@@ -132,7 +131,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 	$provideWorkspaceComments(handle: number): Thenable<modes.CommentThread[]> {
 		const provider = this._workspaceProviders.get(handle);
 		if (!provider) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		return asThenable(() => {
--- a/src/vs/workbench/api/node/extHostDebugService.ts
+++ b/src/vs/workbench/api/node/extHostDebugService.ts
@@ -6,7 +6,6 @@
 import * as paths from 'vs/base/common/paths';
 import { Schemas } from 'vs/base/common/network';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { Event, Emitter } from 'vs/base/common/event';
 import { asThenable } from 'vs/base/common/async';
 import * as nls from 'vs/nls';
@@ -287,7 +286,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {

 	// RPC methods (ExtHostDebugServiceShape)

-	public $runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, config: ITerminalSettings): TPromise<void> {
+	public $runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, config: ITerminalSettings): Thenable<void> {

 		if (args.kind === 'integrated') {

@@ -300,7 +299,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 				});
 			}

-			return new TPromise(resolve => {
+			return new Promise(resolve => {
 				if (this._integratedTerminalInstance) {
 					this._integratedTerminalInstance.processId.then(pid => {
 						resolve(hasChildprocesses(pid));
@@ -318,7 +317,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {

 				this._integratedTerminalInstance.show();

-				return new TPromise((resolve, error) => {
+				return new Promise((resolve) => {
 					setTimeout(_ => {
 						const command = prepareCommand(args, config);
 						this._integratedTerminalInstance.sendText(command, true);
@@ -337,7 +336,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 		return void 0;
 	}

-	public $substituteVariables(folderUri: UriComponents | undefined, config: IConfig): TPromise<IConfig> {
+	public $substituteVariables(folderUri: UriComponents | undefined, config: IConfig): Promise<IConfig> {
 		if (!this._variableResolver) {
 			this._variableResolver = new ExtHostVariableResolverService(this._workspaceService, this._editorsService, this._configurationService);
 		}
@@ -353,10 +352,10 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 				}
 			};
 		}
-		return TPromise.wrap(this._variableResolver.resolveAny(ws, config));
+		return Promise.resolve(this._variableResolver.resolveAny(ws, config));
 	}

-	public $startDASession(handle: number, sessionDto: IDebugSessionDto, folderUri: UriComponents | undefined, config: vscode.DebugConfiguration): TPromise<void> {
+	public $startDASession(handle: number, sessionDto: IDebugSessionDto, folderUri: UriComponents | undefined, config: vscode.DebugConfiguration): Thenable<void> {
 		const mythis = this;

 		return this.getAdapterDescriptor(this._providerByType.get(config.type), sessionDto, folderUri, config).then(adapter => {
@@ -429,7 +428,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 		});
 	}

-	public $sendDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): TPromise<void> {
+	public $sendDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): Promise<void> {
 		// VS Code -> DA
 		convertToDAPaths(message, source => uriToString(source));

@@ -445,7 +444,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 		return void 0;
 	}

-	public $stopDASession(handle: number): TPromise<void> {
+	public $stopDASession(handle: number): Thenable<void> {

 		const tracker = this._debugAdaptersTrackers.get(handle);
 		this._debugAdaptersTrackers.delete(handle);
@@ -526,10 +525,10 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 	public $provideDebugConfigurations(handle: number, folderUri: UriComponents | undefined): Thenable<vscode.DebugConfiguration[]> {
 		let provider = this._providerByHandle.get(handle);
 		if (!provider) {
-			return TPromise.wrapError<vscode.DebugConfiguration[]>(new Error('no handler found'));
+			return Promise.reject(new Error('no handler found'));
 		}
 		if (!provider.provideDebugConfigurations) {
-			return TPromise.wrapError<vscode.DebugConfiguration[]>(new Error('handler has no method provideDebugConfigurations'));
+			return Promise.reject(new Error('handler has no method provideDebugConfigurations'));
 		}
 		return asThenable(() => provider.provideDebugConfigurations(this.getFolder(folderUri), CancellationToken.None));
 	}
@@ -537,10 +536,10 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 	public $resolveDebugConfiguration(handle: number, folderUri: UriComponents | undefined, debugConfiguration: vscode.DebugConfiguration): Thenable<vscode.DebugConfiguration> {
 		let provider = this._providerByHandle.get(handle);
 		if (!provider) {
-			return TPromise.wrapError<vscode.DebugConfiguration>(new Error('no handler found'));
+			return Promise.reject(new Error('no handler found'));
 		}
 		if (!provider.resolveDebugConfiguration) {
-			return TPromise.wrapError<vscode.DebugConfiguration>(new Error('handler has no method resolveDebugConfiguration'));
+			return Promise.reject(new Error('handler has no method resolveDebugConfiguration'));
 		}
 		return asThenable(() => provider.resolveDebugConfiguration(this.getFolder(folderUri), debugConfiguration, CancellationToken.None));
 	}
@@ -548,10 +547,10 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 	public $provideDebugAdapter(handle: number, sessionDto: IDebugSessionDto, folderUri: UriComponents | undefined, config: vscode.DebugConfiguration): Thenable<vscode.DebugAdapterDescriptor> {
 		let provider = this._providerByHandle.get(handle);
 		if (!provider) {
-			return TPromise.wrapError<vscode.DebugAdapterExecutable>(new Error('no handler found'));
+			return Promise.reject(new Error('no handler found'));
 		}
 		if (!provider.debugAdapterExecutable && !provider.provideDebugAdapter) {
-			return TPromise.wrapError<vscode.DebugAdapterExecutable>(new Error('handler has no methods provideDebugAdapter or debugAdapterExecutable'));
+			return Promise.reject(new Error('handler has no methods provideDebugAdapter or debugAdapterExecutable'));
 		}
 		return this.getAdapterDescriptor(provider, this.getSession(sessionDto), folderUri, config);
 	}
@@ -602,7 +601,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 		return false;
 	}

-	private getDebugAdapterTrackers(sessionDto: IDebugSessionDto, folderUri: UriComponents | undefined, config: vscode.DebugConfiguration): TPromise<vscode.IDebugAdapterTracker> {
+	private getDebugAdapterTrackers(sessionDto: IDebugSessionDto, folderUri: UriComponents | undefined, config: vscode.DebugConfiguration): Promise<vscode.IDebugAdapterTracker> {

 		const session = this.getSession(sessionDto);
 		const folder = this.getFolder(folderUri);
@@ -612,7 +611,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 			.filter(pair => pair.provider.provideDebugAdapterTracker && (pair.type === type || pair.type === '*'))
 			.map(pair => pair.provider.provideDebugAdapterTracker(session, folder, config, CancellationToken.None));

-		return TPromise.join(promises).then(trackers => {
+		return Promise.all(promises).then(trackers => {
 			if (trackers.length > 0) {
 				return new MultiTracker(trackers);
 			}
@@ -624,7 +623,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {

 		// a "debugServer" attribute in the launch config takes precedence
 		if (typeof config.debugServer === 'number') {
-			return TPromise.wrap(new DebugAdapterServer(config.debugServer));
+			return Promise.resolve(new DebugAdapterServer(config.debugServer));
 		}

 		if (debugConfigProvider) {
@@ -649,7 +648,7 @@ export class ExtHostDebugService implements ExtHostDebugServiceShape {
 		}

 		// fallback: use executable information from package.json
-		return TPromise.wrap(ExecutableDebugAdapter.platformAdapterExecutable(this._extensionService.getAllExtensionDescriptions(), config.type));
+		return Promise.resolve(ExecutableDebugAdapter.platformAdapterExecutable(this._extensionService.getAllExtensionDescriptions(), config.type));
 	}

 	private startBreakpoints() {
@@ -869,8 +868,8 @@ class DirectDebugAdapter extends AbstractDebugAdapter {
 		}
 	}

-	startSession(): TPromise<void> {
-		return TPromise.wrap(void 0);
+	startSession(): Promise<void> {
+		return Promise.resolve(void 0);
 	}

 	// VSCode -> DA
@@ -878,8 +877,8 @@ class DirectDebugAdapter extends AbstractDebugAdapter {
 		this.transport.sendUp(message);
 	}

-	stopSession(): TPromise<void> {
+	stopSession(): Promise<void> {
 		this.transport.stop();
-		return TPromise.wrap(void 0);
+		return Promise.resolve(void 0);
 	}
 }
--- a/src/vs/workbench/api/node/extHostExtensionActivator.ts
+++ b/src/vs/workbench/api/node/extHostExtensionActivator.ts
@@ -6,12 +6,11 @@
 import * as nls from 'vs/nls';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import Severity from 'vs/base/common/severity';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';

 const hasOwnProperty = Object.hasOwnProperty;
-const NO_OP_VOID_PROMISE = TPromise.wrap<void>(void 0);
+const NO_OP_VOID_PROMISE = Promise.resolve<void>(void 0);

 export interface IExtensionMemento {
 	get<T>(key: string, defaultValue: T): T;
@@ -32,7 +31,7 @@ export interface IExtensionContext {
 * Represents the source code (module) of an extension.
 */
 export interface IExtensionModule {
-	activate(ctx: IExtensionContext): TPromise<IExtensionAPI>;
+	activate(ctx: IExtensionContext): Promise<IExtensionAPI>;
 	deactivate(): void;
 }

@@ -162,7 +161,7 @@ export class FailedExtension extends ActivatedExtension {
 export interface IExtensionsActivatorHost {
 	showMessage(severity: Severity, message: string): void;

-	actualActivateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): TPromise<ActivatedExtension>;
+	actualActivateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension>;
 }

 export class ExtensionActivatedByEvent {
@@ -184,7 +183,7 @@ export class ExtensionsActivator {

 	private readonly _registry: ExtensionDescriptionRegistry;
 	private readonly _host: IExtensionsActivatorHost;
-	private readonly _activatingExtensions: { [extensionId: string]: TPromise<void>; };
+	private readonly _activatingExtensions: { [extensionId: string]: Promise<void>; };
 	private readonly _activatedExtensions: { [extensionId: string]: ActivatedExtension; };
 	/**
 	 * A map of already activated events to speed things up if the same activation event is triggered multiple times.
@@ -210,7 +209,7 @@ export class ExtensionsActivator {
 		return this._activatedExtensions[extensionId];
 	}

-	public activateByEvent(activationEvent: string, reason: ExtensionActivationReason): TPromise<void> {
+	public activateByEvent(activationEvent: string, reason: ExtensionActivationReason): Promise<void> {
 		if (this._alreadyActivatedEvents[activationEvent]) {
 			return NO_OP_VOID_PROMISE;
 		}
@@ -220,7 +219,7 @@ export class ExtensionsActivator {
 		});
 	}

-	public activateById(extensionId: string, reason: ExtensionActivationReason): TPromise<void> {
+	public activateById(extensionId: string, reason: ExtensionActivationReason): Promise<void> {
 		let desc = this._registry.getExtensionDescription(extensionId);
 		if (!desc) {
 			throw new Error('Extension `' + extensionId + '` is not known');
@@ -273,15 +272,15 @@ export class ExtensionsActivator {
 		}
 	}

-	private _activateExtensions(extensionDescriptions: IExtensionDescription[], reason: ExtensionActivationReason, recursionLevel: number): TPromise<void> {
+	private _activateExtensions(extensionDescriptions: IExtensionDescription[], reason: ExtensionActivationReason, recursionLevel: number): Promise<void> {
 		// console.log(recursionLevel, '_activateExtensions: ', extensionDescriptions.map(p => p.id));
 		if (extensionDescriptions.length === 0) {
-			return TPromise.as(void 0);
+			return Promise.resolve(void 0);
 		}

 		extensionDescriptions = extensionDescriptions.filter((p) => !hasOwnProperty.call(this._activatedExtensions, p.id));
 		if (extensionDescriptions.length === 0) {
-			return TPromise.as(void 0);
+			return Promise.resolve(void 0);
 		}

 		if (recursionLevel > 10) {
@@ -292,7 +291,7 @@ export class ExtensionsActivator {
 				const error = new Error('More than 10 levels of dependencies (most likely a dependency loop)');
 				this._activatedExtensions[extensionDescriptions[i].id] = new FailedExtension(error);
 			}
-			return TPromise.as(void 0);
+			return Promise.resolve(void 0);
 		}

 		let greenMap: { [id: string]: IExtensionDescription; } = Object.create(null),
@@ -316,7 +315,7 @@ export class ExtensionsActivator {

 		if (red.length === 0) {
 			// Finally reached only leafs!
-			return TPromise.join(green.map((p) => this._activateExtension(p, reason))).then(_ => void 0);
+			return Promise.all(green.map((p) => this._activateExtension(p, reason))).then(_ => void 0);
 		}

 		return this._activateExtensions(green, reason, recursionLevel + 1).then(_ => {
@@ -324,9 +323,9 @@ export class ExtensionsActivator {
 		});
 	}

-	private _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): TPromise<void> {
+	private _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<void> {
 		if (hasOwnProperty.call(this._activatedExtensions, extensionDescription.id)) {
-			return TPromise.as(void 0);
+			return Promise.resolve(void 0);
 		}

 		if (hasOwnProperty.call(this._activatingExtensions, extensionDescription.id)) {
--- a/src/vs/workbench/api/node/extHostExtensionService.ts
+++ b/src/vs/workbench/api/node/extHostExtensionService.ts
@@ -7,7 +7,6 @@ import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { join } from 'path';
 import { mkdirp, dirExists, realpath, writeFile } from 'vs/base/node/pfs';
 import Severity from 'vs/base/common/severity';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/node/extensionDescriptionRegistry';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtHostStorage } from 'vs/workbench/api/node/extHostStorage';
@@ -100,7 +99,7 @@ class ExtensionStoragePath {

 	private async _getOrCreateWorkspaceStoragePath(): Promise<string> {
 		if (!this._workspace) {
-			return TPromise.as(undefined);
+			return Promise.resolve(undefined);
 		}

 		const storageName = this._workspace.id;
@@ -141,7 +140,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	private readonly _proxy: MainThreadExtensionServiceShape;
 	private readonly _extHostLogService: ExtHostLogService;
 	private _activator: ExtensionsActivator;
-	private _extensionPathIndex: TPromise<TernarySearchTree<IExtensionDescription>>;
+	private _extensionPathIndex: Promise<TernarySearchTree<IExtensionDescription>>;
 	/**
 	 * This class is constructed manually because it is a service, so it doesn't use any ctor injection
 	 */
@@ -181,7 +180,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 					}
 				},

-				actualActivateExtension: (extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): TPromise<ActivatedExtension> => {
+				actualActivateExtension: (extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension> => {
 					return this._activateExtension(extensionDescription, reason);
 				}
 			});
@@ -190,7 +189,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		});
 	}

-	public onExtensionAPIReady(): TPromise<boolean> {
+	public onExtensionAPIReady(): Thenable<boolean> {
 		return this._barrier.wait();
 	}

@@ -201,7 +200,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		return false;
 	}

-	public activateByEvent(activationEvent: string, startup: boolean): TPromise<void> {
+	public activateByEvent(activationEvent: string, startup: boolean): Thenable<void> {
 		const reason = new ExtensionActivatedByEvent(startup, activationEvent);
 		if (this._barrier.isOpen()) {
 			return this._activator.activateByEvent(activationEvent, reason);
@@ -210,7 +209,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		}
 	}

-	public activateById(extensionId: string, reason: ExtensionActivationReason): TPromise<void> {
+	public activateById(extensionId: string, reason: ExtensionActivationReason): Thenable<void> {
 		if (this._barrier.isOpen()) {
 			return this._activator.activateById(extensionId, reason);
 		} else {
@@ -218,12 +217,12 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		}
 	}

-	public activateByIdWithErrors(extensionId: string, reason: ExtensionActivationReason): TPromise<void> {
+	public activateByIdWithErrors(extensionId: string, reason: ExtensionActivationReason): Thenable<void> {
 		return this.activateById(extensionId, reason).then(() => {
 			const extension = this._activator.getActivatedExtension(extensionId);
 			if (extension.activationFailed) {
 				// activation failed => bubble up the error as the promise result
-				return TPromise.wrapError(extension.activationFailedError);
+				return Promise.reject(extension.activationFailedError);
 			}
 			return void 0;
 		});
@@ -246,7 +245,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	}

 	// create trie to enable fast 'filename -> extension id' look up
-	public getExtensionPathIndex(): TPromise<TernarySearchTree<IExtensionDescription>> {
+	public getExtensionPathIndex(): Promise<TernarySearchTree<IExtensionDescription>> {
 		if (!this._extensionPathIndex) {
 			const tree = TernarySearchTree.forPaths<IExtensionDescription>();
 			const extensions = this.getAllExtensionDescriptions().map(ext => {
@@ -255,14 +254,14 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 				}
 				return realpath(ext.extensionLocation.fsPath).then(value => tree.set(URI.file(value).fsPath, ext));
 			});
-			this._extensionPathIndex = TPromise.join(extensions).then(() => tree);
+			this._extensionPathIndex = Promise.all(extensions).then(() => tree);
 		}
 		return this._extensionPathIndex;
 	}


-	public deactivate(extensionId: string): TPromise<void> {
-		let result: TPromise<void> = TPromise.as(void 0);
+	public deactivate(extensionId: string): Thenable<void> {
+		let result = Promise.resolve(void 0);

 		if (!this._barrier.isOpen()) {
 			return result;
@@ -280,9 +279,9 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		// call deactivate if available
 		try {
 			if (typeof extension.module.deactivate === 'function') {
-				result = TPromise.wrap(extension.module.deactivate()).then(null, (err) => {
+				result = Promise.resolve(extension.module.deactivate()).then(null, (err) => {
 					// TODO: Do something with err if this is not the shutdown case
-					return TPromise.as(void 0);
+					return Promise.resolve(void 0);
 				});
 			}
 		} catch (err) {
@@ -305,7 +304,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {

 	// --- impl

-	private _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): TPromise<ActivatedExtension> {
+	private _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension> {
 		return this._doActivateExtension(extensionDescription, reason).then((activatedExtension) => {
 			const activationTimes = activatedExtension.activationTimes;
 			let activationEvent = (reason instanceof ExtensionActivatedByEvent ? reason.activationEvent : null);
@@ -317,7 +316,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		});
 	}

-	private _doActivateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): TPromise<ActivatedExtension> {
+	private _doActivateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension> {
 		let event = getTelemetryActivationEvent(extensionDescription, reason);
 		/* __GDPR__
 			"activatePlugin" : {
@@ -329,36 +328,27 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		this._mainThreadTelemetry.$publicLog('activatePlugin', event);
 		if (!extensionDescription.main) {
 			// Treat the extension as being empty => NOT AN ERROR CASE
-			return TPromise.as(new EmptyExtension(ExtensionActivationTimes.NONE));
+			return Promise.resolve(new EmptyExtension(ExtensionActivationTimes.NONE));
 		}

 		this._extHostLogService.info(`ExtensionService#_doActivateExtension ${extensionDescription.id} ${JSON.stringify(reason)}`);

 		const activationTimesBuilder = new ExtensionActivationTimesBuilder(reason.startup);
-		return TPromise.join<any>([
+		return Promise.all<any>([
 			loadCommonJSModule(this._extHostLogService, extensionDescription.main, activationTimesBuilder),
 			this._loadExtensionContext(extensionDescription)
 		]).then(values => {
 			return ExtHostExtensionService._callActivate(this._extHostLogService, extensionDescription.id, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
-		}, (errors: any[]) => {
-			// Avoid failing with an array of errors, fail with a single error
-			if (errors[0]) {
-				return TPromise.wrapError<ActivatedExtension>(errors[0]);
-			}
-			if (errors[1]) {
-				return TPromise.wrapError<ActivatedExtension>(errors[1]);
-			}
-			return undefined;
 		});
 	}

-	private _loadExtensionContext(extensionDescription: IExtensionDescription): TPromise<IExtensionContext> {
+	private _loadExtensionContext(extensionDescription: IExtensionDescription): Promise<IExtensionContext> {

 		let globalState = new ExtensionMemento(extensionDescription.id, true, this._storage);
 		let workspaceState = new ExtensionMemento(extensionDescription.id, false, this._storage);

 		this._extHostLogService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.id}`);
-		return TPromise.join([
+		return Promise.all([
 			globalState.whenReady,
 			workspaceState.whenReady,
 			this._storagePath.whenReady
@@ -393,20 +383,20 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 			try {
 				activationTimesBuilder.activateCallStart();
 				logService.trace(`ExtensionService#_callActivateOptional ${extensionId}`);
-				const activateResult: TPromise<IExtensionAPI> = extensionModule.activate.apply(global, [context]);
+				const activateResult: Thenable<IExtensionAPI> = extensionModule.activate.apply(global, [context]);
 				activationTimesBuilder.activateCallStop();

 				activationTimesBuilder.activateResolveStart();
-				return TPromise.as(activateResult).then((value) => {
+				return Promise.resolve(activateResult).then((value) => {
 					activationTimesBuilder.activateResolveStop();
 					return value;
 				});
 			} catch (err) {
-				return TPromise.wrapError(err);
+				return Promise.reject(err);
 			}
 		} else {
 			// No activate found => the module is the extension's exports
-			return TPromise.as<IExtensionAPI>(extensionModule);
+			return Promise.resolve<IExtensionAPI>(extensionModule);
 		}
 	}

@@ -417,18 +407,18 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 	}
 }

-function loadCommonJSModule<T>(logService: ILogService, modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): TPromise<T> {
+function loadCommonJSModule<T>(logService: ILogService, modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T> {
 	let r: T | null = null;
 	activationTimesBuilder.codeLoadingStart();
 	logService.info(`ExtensionService#loadCommonJSModule ${modulePath}`);
 	try {
 		r = require.__$__nodeRequire<T>(modulePath);
 	} catch (e) {
-		return TPromise.wrapError<T>(e);
+		return Promise.reject(e);
 	} finally {
 		activationTimesBuilder.codeLoadingStop();
 	}
-	return TPromise.as(r);
+	return Promise.resolve(r);
 }

 function getTelemetryActivationEvent(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): any {
--- a/src/vs/workbench/api/node/extHostQuickOpen.ts
+++ b/src/vs/workbench/api/node/extHostQuickOpen.ts
@@ -7,7 +7,6 @@ import { asThenable } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter } from 'vs/base/common/event';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
 import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
 import { InputBox, InputBoxOptions, QuickInput, QuickInputButton, QuickPick, QuickPickItem, QuickPickOptions, WorkspaceFolder, WorkspaceFolderPickOptions } from 'vscode';
@@ -43,7 +42,7 @@ export class ExtHostQuickOpen implements ExtHostQuickOpenShape {
 		// clear state from last invocation
 		this._onDidSelectItem = undefined;

-		const itemsPromise = <TPromise<Item[]>>TPromise.wrap(itemsOrItemsPromise);
+		const itemsPromise = <Promise<Item[]>>Promise.resolve(itemsOrItemsPromise);

 		const quickPickWidget = this._proxy.$show({
 			placeHolder: options && options.placeHolder,
@@ -120,7 +119,7 @@ export class ExtHostQuickOpen implements ExtHostQuickOpenShape {

 			this._proxy.$setError(err);

-			return TPromise.wrapError(err);
+			return Promise.reject(err);
 		});
 	}

@@ -145,7 +144,7 @@ export class ExtHostQuickOpen implements ExtHostQuickOpenShape {

 				this._proxy.$setError(err);

-				return TPromise.wrapError(err);
+				return Promise.reject(err);
 			});
 	}

--- a/src/vs/workbench/api/node/extHostSCM.ts
+++ b/src/vs/workbench/api/node/extHostSCM.ts
@@ -4,7 +4,6 @@
 *--------------------------------------------------------------------------------------------*/

 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { Event, Emitter, once } from 'vs/base/common/event';
 import { debounce } from 'vs/base/common/decorators';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
@@ -604,23 +603,23 @@ export class ExtHostSCM implements ExtHostSCMShape {
 		const sourceControl = this._sourceControls.get(sourceControlHandle);

 		if (!sourceControl || !sourceControl.quickDiffProvider) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		return asThenable(() => sourceControl.quickDiffProvider.provideOriginalResource(uri, token));
 	}

-	$onInputBoxValueChange(sourceControlHandle: number, value: string): TPromise<void> {
+	$onInputBoxValueChange(sourceControlHandle: number, value: string): Promise<void> {
 		this.logService.trace('ExtHostSCM#$onInputBoxValueChange', sourceControlHandle);

 		const sourceControl = this._sourceControls.get(sourceControlHandle);

 		if (!sourceControl) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		sourceControl.inputBox.$onInputBoxValueChange(value);
-		return TPromise.as(null);
+		return Promise.resolve(null);
 	}

 	$executeResourceCommand(sourceControlHandle: number, groupHandle: number, handle: number): Thenable<void> {
@@ -629,13 +628,13 @@ export class ExtHostSCM implements ExtHostSCMShape {
 		const sourceControl = this._sourceControls.get(sourceControlHandle);

 		if (!sourceControl) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		const group = sourceControl.getResourceGroup(groupHandle);

 		if (!group) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}

 		return group.$executeResourceCommand(handle);
@@ -647,19 +646,19 @@ export class ExtHostSCM implements ExtHostSCMShape {
 		const sourceControl = this._sourceControls.get(sourceControlHandle);

 		if (!sourceControl) {
-			return TPromise.as(undefined);
+			return Promise.resolve(undefined);
 		}

 		if (!sourceControl.inputBox.validateInput) {
-			return TPromise.as(undefined);
+			return Promise.resolve(undefined);
 		}

 		return asThenable(() => sourceControl.inputBox.validateInput(value, cursorPosition)).then(result => {
 			if (!result) {
-				return TPromise.as(undefined);
+				return Promise.resolve(undefined);
 			}

-			return TPromise.as<[string, number]>([result.message, result.type]);
+			return Promise.resolve<[string, number]>([result.message, result.type]);
 		});
 	}

@@ -697,6 +696,6 @@ export class ExtHostSCM implements ExtHostSCMShape {
 		});

 		this._selectedSourceControlHandles = set;
-		return TPromise.as(null);
+		return Promise.resolve(null);
 	}
 }
--- a/src/vs/workbench/api/node/extHostSearch.fileIndex.ts
+++ b/src/vs/workbench/api/node/extHostSearch.fileIndex.ts
@@ -111,7 +111,7 @@ export class FileIndexSearchEngine {
 				}

 				errs = errs.filter(e => !!e);
-				return TPromise.wrapError(errs[0]);
+				return Promise.reject(errs[0]);
 			});
 		});
 	}
@@ -381,7 +381,7 @@ export class FileIndexSearchManager {
 			allResultsPromise = this.preventCancellation(allResultsPromise);
 		}

-		return TPromise.wrap<IInternalSearchComplete>(
+		return Promise.resolve<IInternalSearchComplete>(
 			allResultsPromise.then(complete => {
 				const scorerCache: ScorerCache = cache ? cache.scorerCache : Object.create(null);
 				const sortSW = (typeof config.maxResults !== 'number' || config.maxResults > 0) && StopWatch.create();
@@ -555,7 +555,7 @@ export class FileIndexSearchManager {

 	public clearCache(cacheKey: string): TPromise<void> {
 		if (!this.folderCacheKeys.has(cacheKey)) {
-			return TPromise.wrap(undefined);
+			return Promise.resolve(undefined);
 		}

 		const expandedKeys = this.folderCacheKeys.get(cacheKey);
@@ -563,7 +563,7 @@ export class FileIndexSearchManager {

 		this.folderCacheKeys.delete(cacheKey);

-		return TPromise.as(undefined);
+		return Promise.resolve(undefined);
 	}

 	private preventCancellation<C>(promise: CancelablePromise<C>): CancelablePromise<C> {
--- a/src/vs/workbench/api/node/extHostSearch.ts
+++ b/src/vs/workbench/api/node/extHostSearch.ts
@@ -6,7 +6,6 @@
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import * as extfs from 'vs/base/node/extfs';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IFileQuery, IFolderQuery, IRawFileQuery, IRawQuery, IRawTextQuery, ISearchCompleteStats, ITextQuery } from 'vs/platform/search/common/search';
@@ -181,7 +180,7 @@ export class ExtHostSearch implements ExtHostSearchShape {
 	$provideTextSearchResults(handle: number, session: number, rawQuery: IRawTextQuery, token: CancellationToken): Thenable<ISearchCompleteStats> {
 		const provider = this._textSearchProvider.get(handle);
 		if (!provider.provideTextSearchResults) {
-			return TPromise.as(undefined);
+			return Promise.resolve(undefined);
 		}

 		const query = reviveQuery(rawQuery);
--- a/src/vs/workbench/api/node/extHostTreeViews.ts
+++ b/src/vs/workbench/api/node/extHostTreeViews.ts
@@ -8,7 +8,6 @@ import * as vscode from 'vscode';
 import { basename } from 'vs/base/common/paths';
 import { URI } from 'vs/base/common/uri';
 import { debounceEvent, Emitter, Event } from 'vs/base/common/event';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { ExtHostTreeViewsShape, MainThreadTreeViewsShape } from './extHost.protocol';
 import { ITreeItem, TreeViewItemHandleArg } from 'vs/workbench/common/views';
@@ -70,7 +69,7 @@ export class ExtHostTreeViews implements ExtHostTreeViewsShape {
 	$getChildren(treeViewId: string, treeItemHandle?: string): Thenable<ITreeItem[]> {
 		const treeView = this.treeViews.get(treeViewId);
 		if (!treeView) {
-			return TPromise.wrapError<ITreeItem[]>(new Error(localize('treeView.notRegistered', 'No tree view with id \'{0}\' registered.', treeViewId)));
+			return Promise.reject(new Error(localize('treeView.notRegistered', 'No tree view with id \'{0}\' registered.', treeViewId)));
 		}
 		return treeView.getChildren(treeItemHandle);
 	}
@@ -144,7 +143,7 @@ class ExtHostTreeView<T> extends Disposable {
 	private _onDidChangeVisibility: Emitter<vscode.TreeViewVisibilityChangeEvent> = this._register(new Emitter<vscode.TreeViewVisibilityChangeEvent>());
 	readonly onDidChangeVisibility: Event<vscode.TreeViewVisibilityChangeEvent> = this._onDidChangeVisibility.event;

-	private refreshPromise: TPromise<void> = TPromise.as(null);
+	private refreshPromise: Promise<void> = Promise.resolve(null);

 	constructor(private viewId: string, private dataProvider: vscode.TreeDataProvider<T>, private proxy: MainThreadTreeViewsShape, private commands: CommandsConverter, private logService: ILogService) {
 		super();
@@ -154,7 +153,7 @@ class ExtHostTreeView<T> extends Disposable {
 			this._register(debounceEvent<T, T[]>(this.dataProvider.onDidChangeTreeData, (last, current) => {
 				if (!refreshingPromise) {
 					// New refresh has started
-					refreshingPromise = new TPromise((c, e) => promiseCallback = c);
+					refreshingPromise = new Promise(c => promiseCallback = c);
 					this.refreshPromise = this.refreshPromise.then(() => refreshingPromise);
 				}
 				return last ? [...last, current] : [current];
@@ -170,11 +169,11 @@ class ExtHostTreeView<T> extends Disposable {
 		const parentElement = parentHandle ? this.getExtensionElement(parentHandle) : void 0;
 		if (parentHandle && !parentElement) {
 			console.error(`No tree item with id \'${parentHandle}\' found.`);
-			return TPromise.as([]);
+			return Promise.resolve([]);
 		}

 		const childrenNodes = this.getChildrenNodes(parentHandle); // Get it from cache
-		return (childrenNodes ? TPromise.as(childrenNodes) : this.fetchChildrenNodes(parentElement))
+		return (childrenNodes ? Promise.resolve(childrenNodes) : this.fetchChildrenNodes(parentElement))
 			.then(nodes => nodes.map(n => n.item));
 	}

@@ -182,13 +181,13 @@ class ExtHostTreeView<T> extends Disposable {
 		return this.elements.get(treeItemHandle);
 	}

-	reveal(element: T, options?: { select?: boolean, focus?: boolean }): TPromise<void> {
+	reveal(element: T, options?: { select?: boolean, focus?: boolean }): Promise<void> {
 		options = options ? options : { select: true, focus: false };
 		const select = isUndefinedOrNull(options.select) ? true : options.select;
 		const focus = isUndefinedOrNull(options.focus) ? false : options.focus;

 		if (typeof this.dataProvider.getParent !== 'function') {
-			return TPromise.wrapError(new Error(`Required registered TreeDataProvider to implement 'getParent' method to access 'reveal' method`));
+			return Promise.reject(new Error(`Required registered TreeDataProvider to implement 'getParent' method to access 'reveal' method`));
 		}
 		return this.refreshPromise
 			.then(() => this.resolveUnknownParentChain(element))
@@ -225,7 +224,7 @@ class ExtHostTreeView<T> extends Disposable {
 		return this.resolveParent(element)
 			.then((parent) => {
 				if (!parent) {
-					return TPromise.as([]);
+					return Promise.resolve([]);
 				}
 				return this.resolveUnknownParentChain(parent)
 					.then(result => this.resolveTreeNode(parent, result[result.length - 1])
@@ -239,7 +238,7 @@ class ExtHostTreeView<T> extends Disposable {
 	private resolveParent(element: T): Thenable<T> {
 		const node = this.nodes.get(element);
 		if (node) {
-			return TPromise.as(node.parent ? this.elements.get(node.parent.item.handle) : null);
+			return Promise.resolve(node.parent ? this.elements.get(node.parent.item.handle) : null);
 		}
 		return asThenable(() => this.dataProvider.getParent(element));
 	}
@@ -253,7 +252,7 @@ class ExtHostTreeView<T> extends Disposable {
 					if (cachedElement) {
 						const node = this.nodes.get(cachedElement);
 						if (node) {
-							return TPromise.as(node);
+							return Promise.resolve(node);
 						}
 					}
 					throw new Error(`Cannot resolve tree item for element ${handle}`);
@@ -280,7 +279,7 @@ class ExtHostTreeView<T> extends Disposable {

 		const parentNode = parentElement ? this.nodes.get(parentElement) : void 0;
 		return asThenable(() => this.dataProvider.getChildren(parentElement))
-			.then(elements => TPromise.join(
+			.then(elements => Promise.all(
 				(elements || [])
 					.filter(element => !!element)
 					.map(element => asThenable(() => this.dataProvider.getTreeItem(element))
@@ -299,7 +298,7 @@ class ExtHostTreeView<T> extends Disposable {
 				return this.refreshHandles(handlesToRefresh);
 			}
 		}
-		return TPromise.as(null);
+		return Promise.resolve(null);
 	}

 	private getHandlesToRefresh(elements: T[]): TreeItemHandle[] {
@@ -332,9 +331,9 @@ class ExtHostTreeView<T> extends Disposable {
 		return handlesToUpdate;
 	}

-	private refreshHandles(itemHandles: TreeItemHandle[]): TPromise<void> {
+	private refreshHandles(itemHandles: TreeItemHandle[]): Promise<void> {
 		const itemsToRefresh: { [treeItemHandle: string]: ITreeItem } = {};
-		return TPromise.join(itemHandles.map(treeItemHandle =>
+		return Promise.all(itemHandles.map(treeItemHandle =>
 			this.refreshNode(treeItemHandle)
 				.then(node => {
 					if (node) {
--- a/src/vs/workbench/api/node/extHostUrls.ts
+++ b/src/vs/workbench/api/node/extHostUrls.ts
@@ -6,7 +6,6 @@
 import * as vscode from 'vscode';
 import { MainContext, IMainContext, ExtHostUrlsShape, MainThreadUrlsShape } from './extHost.protocol';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { toDisposable } from 'vs/base/common/lifecycle';
 import { onUnexpectedError } from 'vs/base/common/errors';

@@ -45,7 +44,7 @@ export class ExtHostUrls implements ExtHostUrlsShape {
 		const handler = this.handlers.get(handle);

 		if (!handler) {
-			return TPromise.as(null);
+			return Promise.resolve(null);
 		}
 		try {
 			handler.handleUri(URI.revive(uri));
@@ -53,6 +52,6 @@ export class ExtHostUrls implements ExtHostUrlsShape {
 			onUnexpectedError(err);
 		}

-		return TPromise.as(null);
+		return Promise.resolve(null);
 	}
 }
--- a/src/vs/workbench/api/node/extHostWebview.ts
+++ b/src/vs/workbench/api/node/extHostWebview.ts
@@ -5,7 +5,6 @@

 import { Emitter, Event } from 'vs/base/common/event';
 import { URI } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
 import { EditorViewColumn } from 'vs/workbench/api/shared/editor';
 import * as vscode from 'vscode';
@@ -311,7 +310,7 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 			panel.dispose();
 			this._webviewPanels.delete(handle);
 		}
-		return TPromise.as(void 0);
+		return Promise.resolve(void 0);
 	}

 	$deserializeWebviewPanel(
@@ -324,7 +323,7 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 	): Thenable<void> {
 		const serializer = this._serializers.get(viewType);
 		if (!serializer) {
-			return TPromise.wrapError(new Error(`No serializer found for '${viewType}'`));
+			return Promise.reject(new Error(`No serializer found for '${viewType}'`));
 		}

 		const webview = new ExtHostWebview(webviewHandle, this._proxy, options);