Merge from vscode 966b87dd4013be1a9c06e2b8334522ec61905cc2 (#4696)

src/vs/workbench/api/browser/mainThreadComments.ts

@@ -11,14 +11,14 @@ import { keys } from 'vs/base/common/map';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { ExtHostCommentsShape, ExtHostContext, IExtHostContext, MainContext, MainThreadCommentsShape, CommentProviderFeatures } from '../common/extHost.protocol';
 
-import { ICommentService, ICommentInfo } from 'vs/workbench/contrib/comments/electron-browser/commentService';
-import { COMMENTS_PANEL_ID, CommentsPanel, COMMENTS_PANEL_TITLE } from 'vs/workbench/contrib/comments/electron-browser/commentsPanel';
+import { ICommentService, ICommentInfo } from 'vs/workbench/contrib/comments/browser/commentService';
+import { COMMENTS_PANEL_ID, CommentsPanel, COMMENTS_PANEL_TITLE } from 'vs/workbench/contrib/comments/browser/commentsPanel';
 import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { generateUuid } from 'vs/base/common/uuid';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { ICommentsConfiguration } from 'vs/workbench/contrib/comments/electron-browser/comments.contribution';
+import { ICommentsConfiguration } from 'vs/workbench/contrib/comments/browser/comments.contribution';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { PanelRegistry, Extensions as PanelExtensions, PanelDescriptor } from 'vs/workbench/browser/panel';

src/vs/workbench/api/browser/mainThreadDebugService.ts

@@ -230,7 +230,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 
 	private getSession(sessionId: DebugSessionUUID | undefined): IDebugSession | undefined {
 		if (sessionId) {
-			return this.debugService.getModel().getSessions(true).filter(s => s.getId() === sessionId).pop();
+			return this.debugService.getModel().getSession(sessionId, true);
 		}
 		return undefined;
 	}
@@ -246,7 +246,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 	}
 
 	public $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Promise<any> {
-		const session = this.debugService.getModel().getSessions(true).filter(s => s.getId() === sessionId).pop();
+		const session = this.debugService.getModel().getSession(sessionId, true);
 		if (session) {
 			return session.customRequest(request, args).then(response => {
 				if (response && response.success) {

src/vs/workbench/api/browser/mainThreadSaveParticipant.ts

@@ -21,7 +21,7 @@ import { shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
 import { getCodeActions } from 'vs/editor/contrib/codeAction/codeAction';
 import { applyCodeAction } from 'vs/editor/contrib/codeAction/codeActionCommands';
 import { CodeActionKind } from 'vs/editor/contrib/codeAction/codeActionTrigger';
-import { getRealAndSyntheticDocumentFormattersOrdered, formatDocumentWithProvider } from 'vs/editor/contrib/format/format';
+import { formatDocumentWithFirstProvider } from 'vs/editor/contrib/format/format';
 import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
 import { localize } from 'vs/nls';
 import { ICommandService } from 'vs/platform/commands/common/commands';
@@ -256,24 +256,15 @@ class FormatOnSaveParticipant implements ISaveParticipantParticipant {
 
 		return new Promise<any>((resolve, reject) => {
 			const source = new CancellationTokenSource();
+			const timeout = this._configurationService.getValue<number>('editor.formatOnSaveTimeout', overrides);
+			const request = this._instantiationService.invokeFunction(formatDocumentWithFirstProvider, model, source.token);
 
-			const provider = getRealAndSyntheticDocumentFormattersOrdered(model);
-			if (provider.length !== 1) {
-				// print message for >1 case?
-				resolve();
+			setTimeout(() => {
+				reject(localize('timeout.formatOnSave', "Aborted format on save after {0}ms", timeout));
+				source.cancel();
+			}, timeout);
 
-			} else {
-				// having 1 formatter -> go for it
-				const timeout = this._configurationService.getValue<number>('editor.formatOnSaveTimeout', overrides);
-				const request = this._instantiationService.invokeFunction(formatDocumentWithProvider, provider[0], model, source.token);
-
-				setTimeout(() => {
-					reject(localize('timeout.formatOnSave', "Aborted format on save after {0}ms", timeout));
-					source.cancel();
-				}, timeout);
-
-				request.then(resolve, reject);
-			}
+			request.then(resolve, reject);
 		});
 	}
 }

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

@@ -513,7 +513,7 @@ export interface WebviewPanelShowOptions {
 
 export interface MainThreadWebviewsShape extends IDisposable {
 	$createWebviewPanel(handle: WebviewPanelHandle, viewType: string, title: string, showOptions: WebviewPanelShowOptions, options: modes.IWebviewPanelOptions & modes.IWebviewOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): void;
-	$createWebviewCodeInset(handle: WebviewInsetHandle, symbolId: string, options: modes.IWebviewOptions, extensionLocation: UriComponents | undefined): void;
+	$createWebviewCodeInset(handle: WebviewInsetHandle, symbolId: string, options: modes.IWebviewOptions, extensionId: ExtensionIdentifier | undefined, extensionLocation: UriComponents | undefined): void;
 	$disposeWebview(handle: WebviewPanelHandle): void;
 	$reveal(handle: WebviewPanelHandle, showOptions: WebviewPanelShowOptions): void;
 	$setTitle(handle: WebviewPanelHandle, value: string): void;

src/vs/workbench/api/common/menusExtensionPoint.ts

@@ -34,7 +34,8 @@ namespace schema {
 			case 'explorer/context': return MenuId.ExplorerContext;
 			case 'editor/title/context': return MenuId.EditorTitleContext;
 			case 'debug/callstack/context': return MenuId.DebugCallStackContext;
-			case 'debug/toolbar': return MenuId.DebugToolbar;
+			case 'debug/toolbar': return MenuId.DebugToolBar;
+			case 'debug/toolBar': return MenuId.DebugToolBar;
 			case 'menuBar/file': return MenuId.MenubarFileMenu;
 			case 'scm/title': return MenuId.SCMTitle;
 			case 'scm/sourceControl': return MenuId.SCMSourceControl;
@@ -53,6 +54,15 @@ namespace schema {
 		return undefined;
 	}
 
+	export function isProposedAPI(menuId: MenuId): boolean {
+		switch (menuId) {
+			case MenuId.StatusBarWindowIndicatorMenu:
+			case MenuId.MenubarFileMenu:
+				return true;
+		}
+		return false;
+	}
+
 	export function isValidMenuItems(menu: IUserFriendlyMenuItem[], collector: ExtensionMessageCollector): boolean {
 		if (!Array.isArray(menu)) {
 			collector.error(localize('requirearray', "menu items must be an array"));
@@ -142,8 +152,8 @@ namespace schema {
 				type: 'array',
 				items: menuItem
 			},
-			'debug/toolbar': {
-				description: localize('menus.debugToolbar', "The debug toolbar menu"),
+			'debug/toolBar': {
+				description: localize('menus.debugToolBar', "The debug toolbar menu"),
 				type: 'array',
 				items: menuItem
 			},
@@ -363,6 +373,11 @@ ExtensionsRegistry.registerExtensionPoint<{ [loc: string]: schema.IUserFriendlyM
 				return;
 			}
 
+			if (schema.isProposedAPI(menu) && !extension.description.enableProposedApi) {
+				collector.error(localize('proposedAPI.invalid', "{0} is a proposed menu identifier and is only available when running out of dev or with the following command line switch: --enable-proposed-api {1}", entry.key, extension.description.identifier.value));
+				return;
+			}
+
 			for (let item of entry.value) {
 				let command = MenuRegistry.getCommand(item.command);
 				let alt = item.alt && MenuRegistry.getCommand(item.alt);

src/vs/workbench/api/electron-browser/extensionHost.contribution.ts

@@ -51,8 +51,8 @@ import '../browser/mainThreadTreeViews';
 import '../browser/mainThreadUrls';
 import '../browser/mainThreadWindow';
 import '../browser/mainThreadWorkspace';
-import './mainThreadComments';
-import './mainThreadTask';
+import '../browser/mainThreadComments';
+import '../browser/mainThreadTask';
 import './mainThreadWebview';
 import 'vs/workbench/api/node/apiCommands';
 

src/vs/workbench/api/electron-browser/mainThreadWebview.ts

@@ -94,7 +94,10 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 			mainThreadShowOptions.group = viewColumnToEditorGroup(this._editorGroupService, showOptions.viewColumn);
 		}
 
-		const webview = this._webviewService.createWebview(this.getInternalWebviewId(viewType), title, mainThreadShowOptions, reviveWebviewOptions(options), URI.revive(extensionLocation), this.createWebviewEventDelegate(handle));
+		const webview = this._webviewService.createWebview(this.getInternalWebviewId(viewType), title, mainThreadShowOptions, reviveWebviewOptions(options), {
+			location: URI.revive(extensionLocation),
+			id: extensionId
+		}, this.createWebviewEventDelegate(handle));
 		webview.state = {
 			viewType: viewType,
 			state: undefined
@@ -111,7 +114,13 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 		this._telemetryService.publicLog('webviews:createWebviewPanel', { extensionId: extensionId.value });
 	}
 
-	$createWebviewCodeInset(handle: WebviewInsetHandle, symbolId: string, options: IWebviewOptions, extensionLocation: UriComponents): void {
+	$createWebviewCodeInset(
+		handle: WebviewInsetHandle,
+		symbolId: string,
+		options: IWebviewOptions,
+		extensionId: ExtensionIdentifier,
+		extensionLocation: UriComponents
+	): void {
 		// todo@joh main is for the lack of a code-inset service
 		// which we maybe wanna have... this is how it now works
 		// 1) create webview element
@@ -122,7 +131,10 @@ export class MainThreadWebviews extends Disposable implements MainThreadWebviews
 			WebviewElement,
 			this._layoutService.getContainer(Parts.EDITOR_PART),
 			{
-				extensionLocation: URI.revive(extensionLocation),
+				extension: {
+					location: URI.revive(extensionLocation),
+					id: extensionId
+				},
 				enableFindWidget: false,
 			},
 			{

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

@@ -13,6 +13,8 @@ import { EditorGroupLayout } from 'vs/workbench/services/editor/common/editorGro
 import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { IWindowsService, IOpenSettings } from 'vs/platform/windows/common/windows';
 import { IDownloadService } from 'vs/platform/download/common/download';
+import { IWorkspacesService } from 'vs/platform/workspaces/common/workspaces';
+import { IRecent } from 'vs/platform/history/common/history';
 
 // -----------------------------------------------------------------
 // The following commands are registered on both sides separately.
@@ -34,7 +36,6 @@ function adjustHandler(handler: (executor: ICommandsExecutor, ...args: any[]) =>
 interface IOpenFolderAPICommandOptions {
 	forceNewWindow?: boolean;
 	noRecentEntry?: boolean;
-	recentEntryLabel?: string;
 }
 
 export class OpenFolderAPICommand {
@@ -50,7 +51,7 @@ export class OpenFolderAPICommand {
 		}
 		const options: IOpenSettings = { forceNewWindow: arg.forceNewWindow, noRecentEntry: arg.noRecentEntry };
 		uri = URI.revive(uri);
-		return executor.executeCommand('_files.windowOpen', [{ uri, label: arg.recentEntryLabel }], options);
+		return executor.executeCommand('_files.windowOpen', [{ uri }], options);
 	}
 }
 CommandsRegistry.registerCommand({
@@ -60,12 +61,13 @@ CommandsRegistry.registerCommand({
 		description: 'Open a folder or workspace in the current window or new window depending on the newWindow argument. Note that opening in the same window will shutdown the current extension host process and start a new one on the given folder/workspace unless the newWindow parameter is set to true.',
 		args: [
 			{ name: 'uri', description: '(optional) Uri of the folder or workspace file to open. If not provided, a native dialog will ask the user for the folder', constraint: (value: any) => value === undefined || value instanceof URI },
-			{ name: 'options', description: '(optional) Options. Object with the following properties: `forceNewWindow `: Whether to open the folder/workspace in a new window or the same. Defaults to opening in the same window. `noRecentEntry`: Wheter the opened URI will appear in the \'Open Recent\' list. Defaults to true. `recentEntryLabel`: The label used for \'Open Recent\' list. Note, for backward compatibility, options can also be of type boolean, representing the `forceNewWindow` setting.', constraint: (value: any) => value === undefined || typeof value === 'object' || typeof value === 'boolean' }
+			{ name: 'options', description: '(optional) Options. Object with the following properties: `forceNewWindow `: Whether to open the folder/workspace in a new window or the same. Defaults to opening in the same window. `noRecentEntry`: Wheter the opened URI will appear in the \'Open Recent\' list. Defaults to true.  Note, for backward compatibility, options can also be of type boolean, representing the `forceNewWindow` setting.', constraint: (value: any) => value === undefined || typeof value === 'object' || typeof value === 'boolean' }
 		]
 	}
 });
 
 interface INewWindowAPICommandOptions {
+	reuseWindow?: boolean;
 }
 
 export class NewWindowAPICommand {
@@ -141,6 +143,29 @@ export class RemoveFromRecentlyOpenedAPICommand {
 }
 CommandsRegistry.registerCommand(RemoveFromRecentlyOpenedAPICommand.ID, adjustHandler(RemoveFromRecentlyOpenedAPICommand.execute));
 
+interface RecentEntry {
+	uri: URI;
+	type: 'workspace' | 'folder' | 'file';
+	label?: string;
+}
+
+CommandsRegistry.registerCommand('_workbench.addToRecentlyOpened', async function (accessor: ServicesAccessor, recentEntry: RecentEntry) {
+	const windowsService = accessor.get(IWindowsService);
+	const workspacesService = accessor.get(IWorkspacesService);
+	let recent: IRecent | undefined = undefined;
+	const uri = recentEntry.uri;
+	const label = recentEntry.label;
+	if (recentEntry.type === 'workspace') {
+		const workspace = await workspacesService.getWorkspaceIdentifier(uri);
+		recent = { workspace, label };
+	} else if (recentEntry.type === 'folder') {
+		recent = { folderUri: uri, label };
+	} else {
+		recent = { fileUri: uri, label };
+	}
+	return windowsService.addRecentlyOpened([recent]);
+});
+
 export class SetEditorLayoutAPICommand {
 	public static ID = 'vscode.setEditorLayout';
 	public static execute(executor: ICommandsExecutor, layout: EditorGroupLayout): Promise<any> {

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

@@ -624,14 +624,14 @@ export function createApiFactory(
 			registerFileSystemProvider(scheme, provider, options) {
 				return extHostFileSystem.registerFileSystemProvider(scheme, provider, options);
 			},
-			registerFileSearchProvider: proposedApiFunction(extension, (scheme, provider) => {
+			registerFileSearchProvider: proposedApiFunction(extension, (scheme: string, provider: vscode.FileSearchProvider) => {
 				return extHostSearch.registerFileSearchProvider(scheme, provider);
 			}),
 			registerSearchProvider: proposedApiFunction(extension, () => {
 				// Temp for live share in Insiders
 				return { dispose: () => { } };
 			}),
-			registerTextSearchProvider: proposedApiFunction(extension, (scheme, provider) => {
+			registerTextSearchProvider: proposedApiFunction(extension, (scheme: string, provider: vscode.TextSearchProvider) => {
 				return extHostSearch.registerTextSearchProvider(scheme, provider);
 			}),
 			registerDocumentCommentProvider: proposedApiFunction(extension, (provider: vscode.DocumentCommentProvider) => {
@@ -646,10 +646,10 @@ export function createApiFactory(
 			registerResourceLabelFormatter: proposedApiFunction(extension, (formatter: vscode.ResourceLabelFormatter) => {
 				return extHostFileSystem.registerResourceLabelFormatter(formatter);
 			}),
-			onDidRenameFile: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
+			onDidRenameFile: proposedApiFunction(extension, (listener: (e: vscode.FileRenameEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
 				return extHostFileSystemEvent.onDidRenameFile(listener, thisArg, disposables);
 			}),
-			onWillRenameFile: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
+			onWillRenameFile: proposedApiFunction(extension, (listener: (e: vscode.FileWillRenameEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
 				return extHostFileSystemEvent.getOnWillRenameFileEvent(extension)(listener, thisArg, disposables);
 			})
 		};

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

@@ -7,10 +7,24 @@ import { generateRandomPipeName } from 'vs/base/parts/ipc/node/ipc.net';
 import * as http from 'http';
 import * as fs from 'fs';
 import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { IURIToOpen, URIType } from 'vs/platform/windows/common/windows';
+import { IURIToOpen, URIType, IOpenSettings } from 'vs/platform/windows/common/windows';
 import { URI } from 'vs/base/common/uri';
 import { hasWorkspaceFileExtension } from 'vs/platform/workspaces/common/workspaces';
 
+export interface OpenCommandPipeArgs {
+	type: 'open';
+	fileURIs?: string[];
+	folderURIs: string[];
+	forceNewWindow?: boolean;
+	diffMode?: boolean;
+	addMode?: boolean;
+	forceReuseWindow?: boolean;
+	waitMarkerFilePath?: string;
+}
+
+export interface StatusPipeArgs {
+	type: 'status';
+}
 
 export class CLIServer {
 
@@ -41,7 +55,7 @@ export class CLIServer {
 
 		return this._ipcHandlePath;
 	}
-	private collectURIToOpen(strs: string[], typeHint: URIType, result: IURIToOpen[]): void {
+	private collectURIToOpen(strs: string[] | undefined, typeHint: URIType, result: IURIToOpen[]): void {
 		if (Array.isArray(strs)) {
 			for (const s of strs) {
 				try {
@@ -58,11 +72,14 @@ export class CLIServer {
 		req.setEncoding('utf8');
 		req.on('data', (d: string) => chunks.push(d));
 		req.on('end', () => {
-			const data = JSON.parse(chunks.join(''));
+			const data: OpenCommandPipeArgs | StatusPipeArgs | any = JSON.parse(chunks.join(''));
 			switch (data.type) {
 				case 'open':
 					this.open(data, res);
 					break;
+				case 'status':
+					this.getStatus(data, res);
+					break;
 				default:
 					res.writeHead(404);
 					res.write(`Unkown message type: ${data.type}`, err => {
@@ -76,8 +93,8 @@ export class CLIServer {
 		});
 	}
 
-	private open(data: any, res: http.ServerResponse) {
-		let { fileURIs, folderURIs, forceNewWindow, diffMode, addMode, forceReuseWindow } = data;
+	private open(data: OpenCommandPipeArgs, res: http.ServerResponse) {
+		let { fileURIs, folderURIs, forceNewWindow, diffMode, addMode, forceReuseWindow, waitMarkerFilePath } = data;
 		if (folderURIs && folderURIs.length || fileURIs && fileURIs.length) {
 			const urisToOpen: IURIToOpen[] = [];
 			this.collectURIToOpen(folderURIs, 'folder', urisToOpen);
@@ -85,12 +102,31 @@ export class CLIServer {
 			if (!forceReuseWindow && urisToOpen.some(o => o.typeHint === 'folder' || (o.typeHint === 'file' && hasWorkspaceFileExtension(o.uri.path)))) {
 				forceNewWindow = true;
 			}
-			this._commands.executeCommand('_files.windowOpen', urisToOpen, { forceNewWindow, diffMode, addMode, forceReuseWindow });
+			const waitMarkerFileURI = waitMarkerFilePath ? URI.file(waitMarkerFilePath) : undefined;
+			const windowOpenArgs: IOpenSettings = { forceNewWindow, diffMode, addMode, forceReuseWindow, waitMarkerFileURI };
+			this._commands.executeCommand('_files.windowOpen', urisToOpen, windowOpenArgs);
 		}
 		res.writeHead(200);
 		res.end();
 	}
 
+	private async getStatus(data: StatusPipeArgs, res: http.ServerResponse) {
+		try {
+			const status = await this._commands.executeCommand('_issues.getSystemStatus');
+			res.writeHead(200);
+			res.write(status);
+			res.end();
+		} catch (err) {
+			res.writeHead(500);
+			res.write(String(err), err => {
+				if (err) {
+					console.error(err);
+				}
+			});
+			res.end();
+		}
+	}
+
 	dispose(): void {
 		this._server.close();
 

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

@@ -263,7 +263,7 @@ export class ExtHostConfigProvider {
 			result.set(URI.parse(key), ExtHostConfigProvider.parseConfigurationModel(data.folders[key]));
 			return result;
 		}, new ResourceMap<ConfigurationModel>());
-		return new Configuration(defaultConfiguration, userConfiguration, workspaceConfiguration, folders, new ConfigurationModel(), new ResourceMap<ConfigurationModel>(), false);
+		return new Configuration(defaultConfiguration, userConfiguration, new ConfigurationModel(), workspaceConfiguration, folders, new ConfigurationModel(), new ResourceMap<ConfigurationModel>(), false);
 	}
 
 	private static parseConfigurationModel(model: IConfigurationModel): ConfigurationModel {

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

@@ -998,8 +998,8 @@ class MultiTracker implements vscode.DebugAdapterTracker {
 }
 
 interface IDapTransport {
-	start(cb: (msg: DebugProtocol.ProtocolMessage) => void, errorcb: (event: DebugProtocol.Event) => void);
-	send(message: DebugProtocol.ProtocolMessage);
+	start(cb: (msg: DebugProtocol.ProtocolMessage) => void, errorcb: (event: DebugProtocol.Event) => void): void;
+	send(message: DebugProtocol.ProtocolMessage): void;
 	stop(): void;
 }
 

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

@@ -1211,7 +1211,7 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
 		const webviewHandle = Math.random();
 		const webview = new ExtHostWebview(webviewHandle, this._webviewProxy, { enableScripts: true });
 		return this._withAdapter(handle, CodeInsetAdapter, async (adapter, extension) => {
-			await this._webviewProxy.$createWebviewCodeInset(webviewHandle, symbol.id, { enableCommandUris: true, enableScripts: true }, extension ? extension.extensionLocation : undefined);
+			await this._webviewProxy.$createWebviewCodeInset(webviewHandle, symbol.id, { enableCommandUris: true, enableScripts: true }, extension ? extension.identifier : undefined, extension ? extension.extensionLocation : undefined);
 			return adapter.resolveCodeInset(symbol, webview, token);
 		}, symbol);
 	}

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

@@ -8,7 +8,7 @@ import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import * as extfs from 'vs/base/node/extfs';
 import { ILogService } from 'vs/platform/log/common/log';
-import { IFileQuery, IFolderQuery, IRawFileQuery, IRawQuery, IRawTextQuery, ISearchCompleteStats, ITextQuery, isSerializedFileMatch } from 'vs/workbench/services/search/common/search';
+import { IFileQuery, IFolderQuery, IRawFileQuery, IRawQuery, IRawTextQuery, ISearchCompleteStats, ITextQuery, isSerializedFileMatch, ISerializedSearchProgressItem } from 'vs/workbench/services/search/common/search';
 import { FileSearchManager } from 'vs/workbench/services/search/node/fileSearchManager';
 import { SearchService } from 'vs/workbench/services/search/node/rawSearchService';
 import { RipgrepSearchProvider } from 'vs/workbench/services/search/node/ripgrepSearchProvider';
@@ -107,7 +107,7 @@ export class ExtHostSearch implements ExtHostSearchShape {
 	}
 
 	private doInternalFileSearch(handle: number, session: number, rawQuery: IFileQuery, token: CancellationToken): Promise<ISearchCompleteStats> {
-		const onResult = (ev) => {
+		const onResult = (ev: ISerializedSearchProgressItem) => {
 			if (isSerializedFileMatch(ev)) {
 				ev = [ev];
 			}