Merge branch 'master' into ben/ws-storage

2026-04-25 11:08:51 +01:00 · 2018-10-22 08:59:00 +02:00
parent 404f6cd543 4d9f1d23a5
commit c760849845
179 changed files with 2621 additions and 1732 deletions
--- a/src/vs/workbench/api/browser/viewsExtensionPoint.ts
+++ b/src/vs/workbench/api/browser/viewsExtensionPoint.ts
@@ -111,7 +111,7 @@ class ViewsContainersExtensionHandler implements IWorkbenchContribution {
 						container = this.viewContainersRegistry.get(EXPLORER);
 					}
 					const registeredViews = ViewsRegistry.getViews(container);
-					const viewIds = [];
+					const viewIds: string[] = [];
 					const viewDescriptors = coalesce(entry.value.map((item, index) => {
 						// validate
 						if (viewIds.indexOf(item.id) !== -1) {
--- a/src/vs/workbench/api/electron-browser/mainThreadConfiguration.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadConfiguration.ts
@@ -4,7 +4,6 @@
 *--------------------------------------------------------------------------------------------*/

 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope } from 'vs/platform/configuration/common/configurationRegistry';
@@ -45,7 +44,7 @@ export class MainThreadConfiguration implements MainThreadConfigurationShape {
 		return this.writeConfiguration(target, key, undefined, resource);
 	}

-	private writeConfiguration(target: ConfigurationTarget, key: string, value: any, resource: URI): TPromise<void> {
+	private writeConfiguration(target: ConfigurationTarget, key: string, value: any, resource: URI): Promise<void> {
 		target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, resource);
 		return this.configurationService.updateValue(key, value, { resource }, target, true);
 	}
--- a/src/vs/workbench/api/electron-browser/mainThreadSearch.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadSearch.ts
@@ -8,7 +8,7 @@ import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { values } from 'vs/base/common/map';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IFileMatch, IRawFileMatch2, ISearchComplete, ISearchCompleteStats, ISearchProgressItem, ISearchQuery, ISearchResultProvider, ISearchService, QueryType, SearchProviderType } from 'vs/platform/search/common/search';
+import { IFileMatch, IRawFileMatch2, ISearchComplete, ISearchCompleteStats, ISearchProgressItem, ISearchResultProvider, ISearchService, QueryType, SearchProviderType, ITextQuery, IFileQuery } from 'vs/platform/search/common/search';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { ExtHostContext, ExtHostSearchShape, IExtHostContext, MainContext, MainThreadSearchShape } from '../node/extHost.protocol';
@@ -68,7 +68,7 @@ class SearchOperation {
 	private static _idPool = 0;

 	constructor(
-		readonly progress: (match: IFileMatch) => any,
+		readonly progress?: (match: IFileMatch) => any,
 		readonly id: number = ++SearchOperation._idPool,
 		readonly matches = new Map<string, IFileMatch>()
 	) {
@@ -83,7 +83,9 @@ class SearchOperation {
 			this.matches.set(match.resource.toString(), match);
 		}

-		this.progress(match);
+		if (this.progress) {
+			this.progress(match);
+		}
 	}
 }

@@ -106,7 +108,15 @@ class RemoteSearchProvider implements ISearchResultProvider, IDisposable {
 		dispose(this._registrations);
 	}

-	search(query: ISearchQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): TPromise<ISearchComplete> {
+	fileSearch(query: IFileQuery, token: CancellationToken = CancellationToken.None): TPromise<ISearchComplete> {
+		return this.doSearch(query, null, token);
+	}
+
+	textSearch(query: ITextQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): TPromise<ISearchComplete> {
+		return this.doSearch(query, onProgress, token);
+	}
+
+	doSearch(query: ITextQuery | IFileQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): TPromise<ISearchComplete> {
 		if (isFalsyOrEmpty(query.folderQueries)) {
 			return TPromise.as(undefined);
 		}
@@ -116,7 +126,7 @@ class RemoteSearchProvider implements ISearchResultProvider, IDisposable {

 		const searchP = query.type === QueryType.File
 			? this._proxy.$provideFileSearchResults(this._handle, search.id, query, token)
-			: this._proxy.$provideTextSearchResults(this._handle, search.id, query.contentPattern, query, token);
+			: this._proxy.$provideTextSearchResults(this._handle, search.id, query, token);

 		return TPromise.wrap(searchP).then((result: ISearchCompleteStats) => {
 			this._searches.delete(search.id);
--- a/src/vs/workbench/api/electron-browser/mainThreadTreeViews.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadTreeViews.ts
@@ -133,7 +133,7 @@ class TreeViewDataProvider implements ITreeViewDataProvider {
 	}

 	private postGetChildren(elements: ITreeItem[]): ITreeItem[] {
-		const result = [];
+		const result: ITreeItem[] = [];
 		if (elements) {
 			for (const element of elements) {
 				this.itemsMap.set(element.handle, element);
--- a/src/vs/workbench/api/electron-browser/mainThreadWorkspace.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadWorkspace.ts
@@ -6,19 +6,18 @@
 import { isPromiseCanceledError } from 'vs/base/common/errors';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { localize } from 'vs/nls';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { ILabelService } from 'vs/platform/label/common/label';
-import { IFolderQuery, IPatternInfo, IQueryOptions, ISearchConfiguration, ISearchProgressItem, ISearchQuery, ISearchService, QueryType } from 'vs/platform/search/common/search';
+import { IFolderQuery, IPatternInfo, ISearchConfiguration, ISearchProgressItem, ISearchService, QueryType, IFileQuery } from 'vs/platform/search/common/search';
 import { IStatusbarService } from 'vs/platform/statusbar/common/statusbar';
 import { IWindowService } from 'vs/platform/windows/common/windows';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
-import { QueryBuilder } from 'vs/workbench/parts/search/common/queryBuilder';
+import { QueryBuilder, ITextQueryBuilderOptions } from 'vs/workbench/parts/search/common/queryBuilder';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
 import { IWorkspaceEditingService } from 'vs/workbench/services/workspace/common/workspaceEditing';
@@ -141,13 +140,18 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 			return !folderConfig.search.followSymlinks;
 		});

-		const query: ISearchQuery = {
+		// TODO replace wth QueryBuilder
+		folderQueries.forEach(fq => {
+			fq.ignoreSymlinks = ignoreSymlinks;
+		});
+
+		const query: IFileQuery = {
 			folderQueries,
 			type: QueryType.File,
 			maxResults,
 			disregardExcludeSettings: excludePatternOrDisregardExcludes === false,
 			useRipgrep,
-			ignoreSymlinks
+			_reason: 'startFileSearch'
 		};
 		if (typeof includePattern === 'string') {
 			query.includePattern = { [includePattern]: true };
@@ -159,22 +163,23 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {

 		this._searchService.extendQuery(query);

-		return this._searchService.search(query, token).then(result => {
+		return this._searchService.fileSearch(query, token).then(result => {
 			return result.results.map(m => m.resource);
 		}, err => {
 			if (!isPromiseCanceledError(err)) {
-				return TPromise.wrapError(err);
+				return Promise.reject(err);
 			}
 			return undefined;
 		});
 	}

-	$startTextSearch(pattern: IPatternInfo, options: IQueryOptions, requestId: number, token: CancellationToken): Thenable<TextSearchComplete> {
+	$startTextSearch(pattern: IPatternInfo, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Thenable<TextSearchComplete> {
 		const workspace = this._contextService.getWorkspace();
 		const folders = workspace.folders.map(folder => folder.uri);

 		const queryBuilder = this._instantiationService.createInstance(QueryBuilder);
 		const query = queryBuilder.text(pattern, folders, options);
+		query._reason = 'startTextSearch';

 		const onProgress = (p: ISearchProgressItem) => {
 			if (p.matches) {
@@ -182,13 +187,13 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 			}
 		};

-		const search = this._searchService.search(query, token, onProgress).then(
+		const search = this._searchService.textSearch(query, token, onProgress).then(
 			result => {
 				return { limitHit: result.limitHit };
 			},
 			err => {
 				if (!isPromiseCanceledError(err)) {
-					return TPromise.wrapError(err);
+					return Promise.reject(err);
 				}

 				return undefined;
@@ -201,17 +206,18 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 		const queryBuilder = this._instantiationService.createInstance(QueryBuilder);
 		const folders = this._contextService.getWorkspace().folders.map(folder => folder.uri);
 		const query = queryBuilder.file(folders, {
+			_reason: 'checkExists',
 			includePattern: includes.join(', '),
 			exists: true
 		});

-		return this._searchService.search(query, token).then(
+		return this._searchService.fileSearch(query, token).then(
 			result => {
 				return result.limitHit;
 			},
 			err => {
 				if (!isPromiseCanceledError(err)) {
-					return TPromise.wrapError(err);
+					return Promise.reject(err);
 				}

 				return undefined;
--- 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/extHost.protocol.ts
+++ b/src/vs/workbench/api/node/extHost.protocol.ts
@@ -24,7 +24,7 @@ import { LabelRules } from 'vs/platform/label/common/label';
 import { LogLevel } from 'vs/platform/log/common/log';
 import { IMarkerData } from 'vs/platform/markers/common/markers';
 import { IPickOptions, IQuickInputButton, IQuickPickItem } from 'vs/platform/quickinput/common/quickInput';
-import { IPatternInfo, IQueryOptions, IRawFileMatch2, IRawSearchQuery, ISearchCompleteStats } from 'vs/platform/search/common/search';
+import { IPatternInfo, IRawFileMatch2, IRawQuery, ISearchCompleteStats, IRawTextQuery } from 'vs/platform/search/common/search';
 import { StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/platform/statusbar/common/statusbar';
 import { ITelemetryInfo } from 'vs/platform/telemetry/common/telemetry';
 import { ThemeColor } from 'vs/platform/theme/common/themeService';
@@ -41,6 +41,7 @@ import { IProgressOptions, IProgressStep } from 'vs/workbench/services/progress/
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import * as vscode from 'vscode';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { ITextQueryBuilderOptions } from 'vs/workbench/parts/search/common/queryBuilder';

 export interface IEnvironment {
 	isExtensionDevelopmentDebug: boolean;
@@ -483,7 +484,7 @@ export interface ExtHostUrlsShape {

 export interface MainThreadWorkspaceShape extends IDisposable {
 	$startFileSearch(includePattern: string, includeFolder: URI, excludePatternOrDisregardExcludes: string | false, maxResults: number, token: CancellationToken): Thenable<UriComponents[]>;
-	$startTextSearch(query: IPatternInfo, options: IQueryOptions, requestId: number, token: CancellationToken): Thenable<vscode.TextSearchComplete>;
+	$startTextSearch(query: IPatternInfo, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Thenable<vscode.TextSearchComplete>;
 	$checkExists(includes: string[], token: CancellationToken): Thenable<boolean>;
 	$saveAll(includeUntitled?: boolean): Thenable<boolean>;
 	$updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, workspaceFoldersToAdd: { uri: UriComponents, name?: string }[]): Thenable<void>;
@@ -708,9 +709,9 @@ export interface ExtHostFileSystemShape {
 }

 export interface ExtHostSearchShape {
-	$provideFileSearchResults(handle: number, session: number, query: IRawSearchQuery, token: CancellationToken): Thenable<ISearchCompleteStats>;
+	$provideFileSearchResults(handle: number, session: number, query: IRawQuery, token: CancellationToken): Thenable<ISearchCompleteStats>;
+	$provideTextSearchResults(handle: number, session: number, query: IRawTextQuery, token: CancellationToken): Thenable<ISearchCompleteStats>;
 	$clearCache(cacheKey: string): Thenable<void>;
-	$provideTextSearchResults(handle: number, session: number, pattern: IPatternInfo, query: IRawSearchQuery, token: CancellationToken): Thenable<ISearchCompleteStats>;
 }

 export interface ExtHostExtensionServiceShape {
--- 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 { realpath } 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';
@@ -83,7 +82,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
 	 */
@@ -123,7 +122,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);
 				}
 			});
@@ -132,7 +131,7 @@ export class ExtHostExtensionService implements ExtHostExtensionServiceShape {
 		});
 	}

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

@@ -143,7 +142,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);
@@ -152,7 +151,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 {
@@ -160,12 +159,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;
 		});
@@ -188,7 +187,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 => {
@@ -197,14 +196,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;
@@ -222,9 +221,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) {
@@ -247,7 +246,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);
@@ -259,7 +258,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" : {
@@ -271,36 +270,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
 		]).then(() => {
@@ -334,20 +324,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);
 		}
 	}

@@ -358,18 +348,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
@@ -15,7 +15,7 @@ import * as strings from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { compareItemsByScore, IItemAccessor, prepareQuery, ScorerCache } from 'vs/base/parts/quickopen/common/quickOpenScorer';
-import { ICachedSearchStats, IFileIndexProviderStats, IFileMatch, IFileSearchStats, IFolderQuery, IRawSearchQuery, ISearchCompleteStats, ISearchQuery } from 'vs/platform/search/common/search';
+import { ICachedSearchStats, IFileIndexProviderStats, IFileMatch, IFileQuery, IFileSearchStats, IFolderQuery, ISearchCompleteStats } from 'vs/platform/search/common/search';
 import { IDirectoryEntry, IDirectoryTree, IInternalFileMatch } from 'vs/workbench/services/search/node/fileSearchManager';
 import { QueryGlobTester, resolvePatternsForProvider } from 'vs/workbench/services/search/node/search';
 import * as vscode from 'vscode';
@@ -43,7 +43,7 @@ export class FileIndexSearchEngine {

 	private globalExcludePattern: glob.ParsedExpression;

-	constructor(private config: ISearchQuery, private provider: vscode.FileIndexProvider) {
+	constructor(private config: IFileQuery, private provider: vscode.FileIndexProvider) {
 		this.filePattern = config.filePattern;
 		this.includePattern = config.includePattern && glob.parse(config.includePattern);
 		this.maxResults = config.maxResults || null;
@@ -111,7 +111,7 @@ export class FileIndexSearchEngine {
 				}

 				errs = errs.filter(e => !!e);
-				return TPromise.wrapError(errs[0]);
+				return Promise.reject(errs[0]);
 			});
 		});
 	}
@@ -190,9 +190,9 @@ export class FileIndexSearchEngine {
 			folder: fq.folder,
 			excludes,
 			includes,
-			useIgnoreFiles: !this.config.disregardIgnoreFiles,
-			useGlobalIgnoreFiles: !this.config.disregardGlobalIgnoreFiles,
-			followSymlinks: !this.config.ignoreSymlinks
+			useIgnoreFiles: !fq.disregardIgnoreFiles,
+			useGlobalIgnoreFiles: !fq.disregardGlobalIgnoreFiles,
+			followSymlinks: !fq.ignoreSymlinks
 		};
 	}

@@ -304,7 +304,7 @@ export class FileIndexSearchManager {

 	private readonly folderCacheKeys = new Map<string, Set<string>>();

-	public fileSearch(config: ISearchQuery, provider: vscode.FileIndexProvider, onBatch: (matches: IFileMatch[]) => void, token: CancellationToken): TPromise<ISearchCompleteStats> {
+	public fileSearch(config: IFileQuery, provider: vscode.FileIndexProvider, onBatch: (matches: IFileMatch[]) => void, token: CancellationToken): TPromise<ISearchCompleteStats> {
 		if (config.sortByScore) {
 			let sortedSearch = this.trySortedSearchFromCache(config, token);
 			if (!sortedSearch) {
@@ -341,7 +341,7 @@ export class FileIndexSearchManager {
 			});
 	}

-	private getFolderCacheKey(config: ISearchQuery): string {
+	private getFolderCacheKey(config: IFileQuery): string {
 		const uri = config.folderQueries[0].folder.toString();
 		const folderCacheKey = config.cacheKey && `${uri}_${config.cacheKey}`;
 		if (!this.folderCacheKeys.get(config.cacheKey)) {
@@ -359,7 +359,7 @@ export class FileIndexSearchManager {
 		};
 	}

-	private doSortedSearch(engine: FileIndexSearchEngine, config: ISearchQuery, token: CancellationToken): TPromise<IInternalSearchComplete> {
+	private doSortedSearch(engine: FileIndexSearchEngine, config: IFileQuery, token: CancellationToken): TPromise<IInternalSearchComplete> {
 		let allResultsPromise = createCancelablePromise<IInternalSearchComplete<IFileIndexProviderStats>>(token => {
 			return this.doSearch(engine, token);
 		});
@@ -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();
@@ -413,7 +413,7 @@ export class FileIndexSearchManager {
 		return this.caches[cacheKey] = new Cache();
 	}

-	private trySortedSearchFromCache(config: ISearchQuery, token: CancellationToken): TPromise<IInternalSearchComplete> {
+	private trySortedSearchFromCache(config: IFileQuery, token: CancellationToken): TPromise<IInternalSearchComplete> {
 		const folderCacheKey = this.getFolderCacheKey(config);
 		const cache = folderCacheKey && this.caches[folderCacheKey];
 		if (!cache) {
@@ -447,7 +447,7 @@ export class FileIndexSearchManager {
 		return undefined;
 	}

-	private sortResults(config: IRawSearchQuery, results: IInternalFileMatch[], scorerCache: ScorerCache, token: CancellationToken): TPromise<IInternalFileMatch[]> {
+	private sortResults(config: IFileQuery, results: IInternalFileMatch[], scorerCache: ScorerCache, token: CancellationToken): TPromise<IInternalFileMatch[]> {
 		// we use the same compare function that is used later when showing the results using fuzzy scoring
 		// this is very important because we are also limiting the number of results by config.maxResults
 		// and as such we want the top items to be included in this result set if the number of items
@@ -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,17 +6,17 @@
 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 { IFolderQuery, IPatternInfo, IRawSearchQuery, ISearchCompleteStats, ISearchQuery } from 'vs/platform/search/common/search';
+import { IFileQuery, IFolderQuery, IRawFileQuery, IRawQuery, IRawTextQuery, ISearchCompleteStats, ITextQuery } from 'vs/platform/search/common/search';
 import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
 import { FileIndexSearchManager } from 'vs/workbench/api/node/extHostSearch.fileIndex';
 import { FileSearchManager } from 'vs/workbench/services/search/node/fileSearchManager';
+import { IFolderSearch, IRawSearch } from 'vs/workbench/services/search/node/legacy/search';
 import { SearchService } from 'vs/workbench/services/search/node/rawSearchService';
 import { RipgrepSearchProvider } from 'vs/workbench/services/search/node/ripgrepSearchProvider';
 import { OutputChannel } from 'vs/workbench/services/search/node/ripgrepSearchUtils';
-import { IFolderSearch, IRawSearch, isSerializedFileMatch, isSerializedSearchComplete, isSerializedSearchSuccess } from 'vs/workbench/services/search/node/search';
+import { isSerializedFileMatch, isSerializedSearchComplete, isSerializedSearchSuccess } from 'vs/workbench/services/search/node/search';
 import { TextSearchManager } from 'vs/workbench/services/search/node/textSearchManager';
 import * as vscode from 'vscode';
 import { ExtHostSearchShape, IMainContext, MainContext, MainThreadSearchShape } from './extHost.protocol';
@@ -29,8 +29,11 @@ export class ExtHostSearch implements ExtHostSearchShape {

 	private readonly _proxy: MainThreadSearchShape;
 	private readonly _textSearchProvider = new Map<number, vscode.TextSearchProvider>();
+	private readonly _textSearchUsedSchemes = new Set<string>();
 	private readonly _fileSearchProvider = new Map<number, vscode.FileSearchProvider>();
+	private readonly _fileSearchUsedSchemes = new Set<string>();
 	private readonly _fileIndexProvider = new Map<number, vscode.FileIndexProvider>();
+	private readonly _fileIndexUsedSchemes = new Set<string>();
 	private _handlePool: number = 0;

 	private _internalFileSearchHandle: number;
@@ -55,20 +58,32 @@ export class ExtHostSearch implements ExtHostSearchShape {
 	}

 	registerTextSearchProvider(scheme: string, provider: vscode.TextSearchProvider): IDisposable {
+		if (this._textSearchUsedSchemes.has(scheme)) {
+			throw new Error(`a provider for the scheme '${scheme}' is already registered`);
+		}
+
+		this._textSearchUsedSchemes.add(scheme);
 		const handle = this._handlePool++;
 		this._textSearchProvider.set(handle, provider);
 		this._proxy.$registerTextSearchProvider(handle, this._transformScheme(scheme));
 		return toDisposable(() => {
+			this._textSearchUsedSchemes.delete(scheme);
 			this._textSearchProvider.delete(handle);
 			this._proxy.$unregisterProvider(handle);
 		});
 	}

 	registerFileSearchProvider(scheme: string, provider: vscode.FileSearchProvider): IDisposable {
+		if (this._fileSearchUsedSchemes.has(scheme)) {
+			throw new Error(`a provider for the scheme '${scheme}' is already registered`);
+		}
+
+		this._fileSearchUsedSchemes.add(scheme);
 		const handle = this._handlePool++;
 		this._fileSearchProvider.set(handle, provider);
 		this._proxy.$registerFileSearchProvider(handle, this._transformScheme(scheme));
 		return toDisposable(() => {
+			this._fileSearchUsedSchemes.delete(scheme);
 			this._fileSearchProvider.delete(handle);
 			this._proxy.$unregisterProvider(handle);
 		});
@@ -86,16 +101,22 @@ export class ExtHostSearch implements ExtHostSearchShape {
 	}

 	registerFileIndexProvider(scheme: string, provider: vscode.FileIndexProvider): IDisposable {
+		if (this._fileIndexUsedSchemes.has(scheme)) {
+			throw new Error(`a provider for the scheme '${scheme}' is already registered`);
+		}
+
+		this._fileIndexUsedSchemes.add(scheme);
 		const handle = this._handlePool++;
 		this._fileIndexProvider.set(handle, provider);
 		this._proxy.$registerFileIndexProvider(handle, this._transformScheme(scheme));
 		return toDisposable(() => {
+			this._fileIndexUsedSchemes.delete(scheme);
 			this._fileSearchProvider.delete(handle);
 			this._proxy.$unregisterProvider(handle); // TODO@roblou - unregisterFileIndexProvider
 		});
 	}

-	$provideFileSearchResults(handle: number, session: number, rawQuery: IRawSearchQuery, token: CancellationToken): Thenable<ISearchCompleteStats> {
+	$provideFileSearchResults(handle: number, session: number, rawQuery: IRawFileQuery, token: CancellationToken): Thenable<ISearchCompleteStats> {
 		const query = reviveQuery(rawQuery);
 		if (handle === this._internalFileSearchHandle) {
 			return this.doInternalFileSearch(handle, session, query, token);
@@ -114,24 +135,21 @@ export class ExtHostSearch implements ExtHostSearchShape {
 		}
 	}

-	private doInternalFileSearch(handle: number, session: number, rawQuery: ISearchQuery, token: CancellationToken): Thenable<ISearchCompleteStats> {
+	private doInternalFileSearch(handle: number, session: number, rawQuery: IFileQuery, token: CancellationToken): Thenable<ISearchCompleteStats> {
 		return new Promise((resolve, reject) => {
 			const query: IRawSearch = {
 				folderQueries: [],
-				ignoreSymlinks: rawQuery.ignoreSymlinks,
+				ignoreSymlinks: rawQuery.folderQueries.some(fq => fq.ignoreSymlinks),
 				filePattern: rawQuery.filePattern,
 				excludePattern: rawQuery.excludePattern,
 				includePattern: rawQuery.includePattern,
-				contentPattern: rawQuery.contentPattern,
 				maxResults: rawQuery.maxResults,
 				exists: rawQuery.exists,
 				sortByScore: rawQuery.sortByScore,
 				cacheKey: rawQuery.cacheKey,
-				maxFilesize: rawQuery.maxFileSize,
 				useRipgrep: rawQuery.useRipgrep,
-				disregardIgnoreFiles: rawQuery.disregardIgnoreFiles,
-				previewOptions: rawQuery.previewOptions,
-				disregardGlobalIgnoreFiles: rawQuery.disregardGlobalIgnoreFiles
+				disregardIgnoreFiles: rawQuery.folderQueries.some(fq => fq.disregardIgnoreFiles),
+				disregardGlobalIgnoreFiles: rawQuery.folderQueries.some(fq => fq.disregardGlobalIgnoreFiles),
 			};
 			query.folderQueries = rawQuery.folderQueries.map(fq => (<IFolderSearch>{
 				disregardGlobalIgnoreFiles: fq.disregardGlobalIgnoreFiles,
@@ -180,14 +198,14 @@ export class ExtHostSearch implements ExtHostSearchShape {
 		return this._fileIndexSearchManager.clearCache(cacheKey);
 	}

-	$provideTextSearchResults(handle: number, session: number, pattern: IPatternInfo, rawQuery: IRawSearchQuery, token: CancellationToken): Thenable<ISearchCompleteStats> {
+	$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);
-		const engine = new TextSearchManager(pattern, query, provider, this._extfs);
+		const engine = new TextSearchManager(query, provider, this._extfs);
 		return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token);
 	}
 }
@@ -201,9 +219,9 @@ function registerEHProviders(extHostSearch: ExtHostSearch, logService: ILogServi
 	}
 }

-function reviveQuery(rawQuery: IRawSearchQuery): ISearchQuery {
+function reviveQuery<U extends IRawQuery>(rawQuery: U): U extends IRawTextQuery ? ITextQuery : IFileQuery {
 	return {
-		...rawQuery,
+		...<any>rawQuery, // TODO
 		...{
 			folderQueries: rawQuery.folderQueries && rawQuery.folderQueries.map(reviveFolderQuery),
 			extraFileResources: rawQuery.extraFileResources && rawQuery.extraFileResources.map(components => URI.revive(components))
--- 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);
--- a/src/vs/workbench/api/node/extHostWorkspace.ts
+++ b/src/vs/workbench/api/node/extHostWorkspace.ts
@@ -16,13 +16,14 @@ import { URI } from 'vs/base/common/uri';
 import { localize } from 'vs/nls';
 import { ILogService } from 'vs/platform/log/common/log';
 import { Severity } from 'vs/platform/notification/common/notification';
-import { IQueryOptions, IRawFileMatch2 } from 'vs/platform/search/common/search';
+import { IRawFileMatch2 } from 'vs/platform/search/common/search';
 import { Workspace, WorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { Range, RelativePattern } from 'vs/workbench/api/node/extHostTypes';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import * as vscode from 'vscode';
 import { ExtHostWorkspaceShape, IMainContext, IWorkspaceData, MainContext, MainThreadMessageServiceShape, MainThreadWorkspaceShape } from './extHost.protocol';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { ITextQueryBuilderOptions } from 'vs/workbench/parts/search/common/queryBuilder';

 function isFolderEqual(folderA: URI, folderB: URI): boolean {
 	return isEqual(folderA, folderB, !isLinux);
@@ -399,7 +400,7 @@ export class ExtHostWorkspace implements ExtHostWorkspaceShape {
 			} :
 			options.previewOptions;

-		const queryOptions: IQueryOptions = {
+		const queryOptions: ITextQueryBuilderOptions = {
 			ignoreSymlinks: typeof options.followSymlinks === 'boolean' ? !options.followSymlinks : undefined,
 			disregardIgnoreFiles: typeof options.useIgnoreFiles === 'boolean' ? !options.useIgnoreFiles : undefined,
 			disregardGlobalIgnoreFiles: typeof options.useGlobalIgnoreFiles === 'boolean' ? !options.useGlobalIgnoreFiles : undefined,