Merge branch 'master' into sandy081/wip

2026-04-27 12:04:04 +01:00 · 2019-12-12 23:22:00 +01:00
parent 78b8a7e56d dfd849b915
commit 707d8e9fc5
170 changed files with 6035 additions and 13715 deletions
--- a/src/vs/workbench/api/common/extHost.protocol.ts
+++ b/src/vs/workbench/api/common/extHost.protocol.ts
@@ -47,6 +47,7 @@ import { createExtHostContextProxyIdentifier as createExtId, createMainContextPr
 import * as search from 'vs/workbench/services/search/common/search';
 import { SaveReason } from 'vs/workbench/common/editor';
 import { ExtensionActivationReason } from 'vs/workbench/api/common/extHostExtensionActivator';
+import { TunnelOptions, TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';

 export interface IEnvironment {
 	isExtensionDevelopmentDebug: boolean;
@@ -86,6 +87,7 @@ export interface IInitData {
 	telemetryInfo: ITelemetryInfo;
 	logLevel: LogLevel;
 	logsLocation: URI;
+	logFile: URI;
 	autoStart: boolean;
 	remote: { isRemote: boolean; authority: string | undefined; };
 	uiKind: UIKind;
@@ -771,6 +773,13 @@ export interface MainThreadWindowShape extends IDisposable {
 	$asExternalUri(uri: UriComponents, options: IOpenUriOptions): Promise<UriComponents>;
 }

+export interface MainThreadTunnelServiceShape extends IDisposable {
+	$openTunnel(tunnelOptions: TunnelOptions): Promise<TunnelDto | undefined>;
+	$closeTunnel(remotePort: number): Promise<void>;
+	$addDetected(tunnels: { remote: { port: number, host: string }, localAddress: string }[]): Promise<void>;
+	$registerCandidateFinder(): Promise<void>;
+}
+
 // -- extension host

 export interface ExtHostCommandsShape {
@@ -1387,7 +1396,7 @@ export interface ExtHostStorageShape {


 export interface ExtHostTunnelServiceShape {
-
+	$findCandidatePorts(): Promise<{ port: number, detail: string }[]>;
 }

 // --- proxy identifiers
@@ -1430,7 +1439,8 @@ export const MainContext = {
 	MainThreadSearch: createMainId<MainThreadSearchShape>('MainThreadSearch'),
 	MainThreadTask: createMainId<MainThreadTaskShape>('MainThreadTask'),
 	MainThreadWindow: createMainId<MainThreadWindowShape>('MainThreadWindow'),
-	MainThreadLabelService: createMainId<MainThreadLabelServiceShape>('MainThreadLabelService')
+	MainThreadLabelService: createMainId<MainThreadLabelServiceShape>('MainThreadLabelService'),
+	MainThreadTunnelService: createMainId<MainThreadTunnelServiceShape>('MainThreadTunnelService')
 };

 export const ExtHostContext = {
--- a/src/vs/workbench/api/common/extHostApiCommands.ts
+++ b/src/vs/workbench/api/common/extHostApiCommands.ts
@@ -27,6 +27,7 @@ export class ApiCommandArgument<V, O = V> {

 	static readonly Uri = new ApiCommandArgument<URI>('uri', 'Uri of a text document', v => URI.isUri(v), v => v);
 	static readonly Position = new ApiCommandArgument<types.Position, IPosition>('position', 'A position in a text document', v => types.Position.isPosition(v), typeConverters.Position.from);
+	static readonly Range = new ApiCommandArgument<types.Range, IRange>('range', 'A range in a text document', v => types.Range.isRange(v), typeConverters.Range.from);

 	static readonly CallHierarchyItem = new ApiCommandArgument('item', 'A call hierarchy item', v => v instanceof types.CallHierarchyItem, typeConverters.CallHierarchyItem.to);

@@ -42,7 +43,7 @@ export class ApiCommandResult<V, O = V> {

 	constructor(
 		readonly description: string,
-		readonly convert: (v: V) => O
+		readonly convert: (v: V, apiArgs: any[]) => O
 	) { }
 }

@@ -68,7 +69,7 @@ export class ApiCommand {
 			});

 			const internalResult = await commands.executeCommand(this.internalId, ...internalArgs);
-			return this.result.convert(internalResult);
+			return this.result.convert(internalResult, apiArgs);
 		}, undefined, this._getCommandHandlerDesc());
 	}

@@ -83,6 +84,123 @@ export class ApiCommand {


 const newCommands: ApiCommand[] = [
+	// -- document highlights
+	new ApiCommand(
+		'vscode.executeDocumentHighlights', '_executeDocumentHighlights', 'Execute document highlight provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.DocumentHighlight[], types.DocumentHighlight[] | undefined>('A promise that resolves to an array of SymbolInformation and DocumentSymbol instances.', tryMapWith(typeConverters.DocumentHighlight.to))
+	),
+	// -- document symbols
+	new ApiCommand(
+		'vscode.executeDocumentSymbolProvider', '_executeDocumentSymbolProvider', 'Execute document symbol provider.',
+		[ApiCommandArgument.Uri],
+		new ApiCommandResult<modes.DocumentSymbol[], vscode.SymbolInformation[] | undefined>('A promise that resolves to an array of DocumentHighlight-instances.', (value, apiArgs) => {
+
+			if (isFalsyOrEmpty(value)) {
+				return undefined;
+			}
+			class MergedInfo extends types.SymbolInformation implements vscode.DocumentSymbol {
+				static to(symbol: modes.DocumentSymbol): MergedInfo {
+					const res = new MergedInfo(
+						symbol.name,
+						typeConverters.SymbolKind.to(symbol.kind),
+						symbol.containerName || '',
+						new types.Location(apiArgs[0], typeConverters.Range.to(symbol.range))
+					);
+					res.detail = symbol.detail;
+					res.range = res.location.range;
+					res.selectionRange = typeConverters.Range.to(symbol.selectionRange);
+					res.children = symbol.children ? symbol.children.map(MergedInfo.to) : [];
+					return res;
+				}
+
+				detail!: string;
+				range!: vscode.Range;
+				selectionRange!: vscode.Range;
+				children!: vscode.DocumentSymbol[];
+				containerName!: string;
+			}
+			return value.map(MergedInfo.to);
+
+		})
+	),
+	// -- formatting
+	new ApiCommand(
+		'vscode.executeFormatDocumentProvider', '_executeFormatDocumentProvider', 'Execute document format provider.',
+		[ApiCommandArgument.Uri, new ApiCommandArgument('options', 'Formatting options', _ => true, v => v)],
+		new ApiCommandResult<ISingleEditOperation[], types.TextEdit[] | undefined>('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))
+	),
+	new ApiCommand(
+		'vscode.executeFormatRangeProvider', '_executeFormatRangeProvider', 'Execute range format provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Range, new ApiCommandArgument('options', 'Formatting options', _ => true, v => v)],
+		new ApiCommandResult<ISingleEditOperation[], types.TextEdit[] | undefined>('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))
+	),
+	new ApiCommand(
+		'vscode.executeFormatOnTypeProvider', '_executeFormatOnTypeProvider', 'Execute format on type provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position, new ApiCommandArgument('ch', 'Trigger character', v => typeof v === 'string', v => v), new ApiCommandArgument('options', 'Formatting options', _ => true, v => v)],
+		new ApiCommandResult<ISingleEditOperation[], types.TextEdit[] | undefined>('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))
+	),
+	// -- go to symbol (definition, type definition, declaration, impl, references)
+	new ApiCommand(
+		'vscode.executeDefinitionProvider', '_executeDefinitionProvider', 'Execute all definition provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Location[], types.Location[] | undefined>('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))
+	),
+	new ApiCommand(
+		'vscode.executeTypeDefinitionProvider', '_executeTypeDefinitionProvider', 'Execute all type definition providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Location[], types.Location[] | undefined>('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))
+	),
+	new ApiCommand(
+		'vscode.executeDeclarationProvider', '_executeDeclarationProvider', 'Execute all declaration providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Location[], types.Location[] | undefined>('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))
+	),
+	new ApiCommand(
+		'vscode.executeImplementationProvider', '_executeImplementationProvider', 'Execute all implementation providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Location[], types.Location[] | undefined>('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))
+	),
+	new ApiCommand(
+		'vscode.executeReferenceProvider', '_executeReferenceProvider', 'Execute all reference providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Location[], types.Location[] | undefined>('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))
+	),
+	// -- hover
+	new ApiCommand(
+		'vscode.executeHoverProvider', '_executeHoverProvider', 'Execute all hover provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Hover[], types.Hover[] | undefined>('A promise that resolves to an array of Hover-instances.', tryMapWith(typeConverters.Hover.to))
+	),
+	// -- selection range
+	new ApiCommand(
+		'vscode.executeSelectionRangeProvider', '_executeSelectionRangeProvider', 'Execute selection range provider.',
+		[ApiCommandArgument.Uri, new ApiCommandArgument('position', 'A positions in a text document', v => Array.isArray(v) && v.every(v => types.Position.isPosition(v)), v => v.map(typeConverters.Position.from))],
+		new ApiCommandResult<IRange[][], types.SelectionRange[]>('A promise that resolves to an array of ranges.', result => {
+			return result.map(ranges => {
+				let node: types.SelectionRange | undefined;
+				for (const range of ranges.reverse()) {
+					node = new types.SelectionRange(typeConverters.Range.to(range), node);
+				}
+				return node!;
+			});
+		})
+	),
+	// -- symbol search
+	new ApiCommand(
+		'vscode.executeWorkspaceSymbolProvider', '_executeWorkspaceSymbolProvider', 'Execute all workspace symbol provider.',
+		[new ApiCommandArgument('query', 'Search string', v => typeof v === 'string', v => v)],
+		new ApiCommandResult<[search.IWorkspaceSymbolProvider, search.IWorkspaceSymbol[]][], types.SymbolInformation[]>('A promise that resolves to an array of SymbolInformation-instances.', value => {
+			const result: types.SymbolInformation[] = [];
+			if (Array.isArray(value)) {
+				for (let tuple of value) {
+					result.push(...tuple[1].map(typeConverters.WorkspaceSymbol.to));
+				}
+			}
+			return result;
+		})
+	),
+	// --- call hierarchy
 	new ApiCommand(
 		'vscode.prepareCallHierarchy', '_executePrepareCallHierarchy', 'Prepare call hierarchy at a position inside a document',
 		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
@@ -121,68 +239,6 @@ export class ExtHostApiCommands {
 	}

 	registerCommands() {
-		this._register('vscode.executeWorkspaceSymbolProvider', this._executeWorkspaceSymbolProvider, {
-			description: 'Execute all workspace symbol provider.',
-			args: [{ name: 'query', description: 'Search string', constraint: String }],
-			returns: 'A promise that resolves to an array of SymbolInformation-instances.'
-
-		});
-		this._register('vscode.executeDefinitionProvider', this._executeDefinitionProvider, {
-			description: 'Execute all definition provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position of a symbol', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of Location-instances.'
-		});
-		this._register('vscode.executeDeclarationProvider', this._executeDeclaraionProvider, {
-			description: 'Execute all declaration provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position of a symbol', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of Location-instances.'
-		});
-		this._register('vscode.executeTypeDefinitionProvider', this._executeTypeDefinitionProvider, {
-			description: 'Execute all type definition providers.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position of a symbol', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of Location-instances.'
-		});
-		this._register('vscode.executeImplementationProvider', this._executeImplementationProvider, {
-			description: 'Execute all implementation providers.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position of a symbol', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of Location-instance.'
-		});
-		this._register('vscode.executeHoverProvider', this._executeHoverProvider, {
-			description: 'Execute all hover provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position of a symbol', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of Hover-instances.'
-		});
-		this._register('vscode.executeDocumentHighlights', this._executeDocumentHighlights, {
-			description: 'Execute document highlight provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position in a text document', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of DocumentHighlight-instances.'
-		});
-		this._register('vscode.executeReferenceProvider', this._executeReferenceProvider, {
-			description: 'Execute reference provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position in a text document', constraint: types.Position }
-			],
-			returns: 'A promise that resolves to an array of Location-instances.'
-		});
 		this._register('vscode.executeDocumentRenameProvider', this._executeDocumentRenameProvider, {
 			description: 'Execute rename provider.',
 			args: [
@@ -201,13 +257,6 @@ export class ExtHostApiCommands {
 			],
 			returns: 'A promise that resolves to SignatureHelp.'
 		});
-		this._register('vscode.executeDocumentSymbolProvider', this._executeDocumentSymbolProvider, {
-			description: 'Execute document symbol provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI }
-			],
-			returns: 'A promise that resolves to an array of SymbolInformation and DocumentSymbol instances.'
-		});
 		this._register('vscode.executeCompletionItemProvider', this._executeCompletionItemProvider, {
 			description: 'Execute completion item provider.',
 			args: [
@@ -235,33 +284,7 @@ export class ExtHostApiCommands {
 			],
 			returns: 'A promise that resolves to an array of CodeLens-instances.'
 		});
-		this._register('vscode.executeFormatDocumentProvider', this._executeFormatDocumentProvider, {
-			description: 'Execute document format provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'options', description: 'Formatting options' }
-			],
-			returns: 'A promise that resolves to an array of TextEdits.'
-		});
-		this._register('vscode.executeFormatRangeProvider', this._executeFormatRangeProvider, {
-			description: 'Execute range format provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'range', description: 'Range in a text document', constraint: types.Range },
-				{ name: 'options', description: 'Formatting options' }
-			],
-			returns: 'A promise that resolves to an array of TextEdits.'
-		});
-		this._register('vscode.executeFormatOnTypeProvider', this._executeFormatOnTypeProvider, {
-			description: 'Execute document format provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position in a text document', constraint: types.Position },
-				{ name: 'ch', description: 'Character that got typed', constraint: String },
-				{ name: 'options', description: 'Formatting options' }
-			],
-			returns: 'A promise that resolves to an array of TextEdits.'
-		});
+
 		this._register('vscode.executeLinkProvider', this._executeDocumentLinkProvider, {
 			description: 'Execute document link provider.',
 			args: [
@@ -284,14 +307,6 @@ export class ExtHostApiCommands {
 			],
 			returns: 'A promise that resolves to an array of ColorPresentation objects.'
 		});
-		this._register('vscode.executeSelectionRangeProvider', this._executeSelectionRangeProvider, {
-			description: 'Execute selection range provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'positions', description: 'Positions in a text document', constraint: Array.isArray }
-			],
-			returns: 'A promise that resolves to an array of ranges.'
-		});

 		// -----------------------------------------------------------------
 		// The following commands are registered on both sides separately.
@@ -362,87 +377,6 @@ export class ExtHostApiCommands {
 		this._disposables.add(disposable);
 	}

-	/**
-	 * Execute workspace symbol provider.
-	 *
-	 * @param query Search string to match query symbol names
-	 * @return A promise that resolves to an array of symbol information.
-	 */
-	private _executeWorkspaceSymbolProvider(query: string): Promise<types.SymbolInformation[]> {
-		return this._commands.executeCommand<[search.IWorkspaceSymbolProvider, search.IWorkspaceSymbol[]][]>('_executeWorkspaceSymbolProvider', { query }).then(value => {
-			const result: types.SymbolInformation[] = [];
-			if (Array.isArray(value)) {
-				for (let tuple of value) {
-					result.push(...tuple[1].map(typeConverters.WorkspaceSymbol.to));
-				}
-			}
-			return result;
-		});
-	}
-
-	private _executeDefinitionProvider(resource: URI, position: types.Position): Promise<types.Location[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.Location[]>('_executeDefinitionProvider', args)
-			.then(tryMapWith(typeConverters.location.to));
-	}
-
-	private _executeDeclaraionProvider(resource: URI, position: types.Position): Promise<types.Location[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.Location[]>('_executeDeclarationProvider', args)
-			.then(tryMapWith(typeConverters.location.to));
-	}
-
-	private _executeTypeDefinitionProvider(resource: URI, position: types.Position): Promise<types.Location[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.Location[]>('_executeTypeDefinitionProvider', args)
-			.then(tryMapWith(typeConverters.location.to));
-	}
-
-	private _executeImplementationProvider(resource: URI, position: types.Position): Promise<types.Location[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.Location[]>('_executeImplementationProvider', args)
-			.then(tryMapWith(typeConverters.location.to));
-	}
-
-	private _executeHoverProvider(resource: URI, position: types.Position): Promise<types.Hover[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.Hover[]>('_executeHoverProvider', args)
-			.then(tryMapWith(typeConverters.Hover.to));
-	}
-
-	private _executeDocumentHighlights(resource: URI, position: types.Position): Promise<types.DocumentHighlight[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.DocumentHighlight[]>('_executeDocumentHighlights', args)
-			.then(tryMapWith(typeConverters.DocumentHighlight.to));
-	}
-
-	private _executeReferenceProvider(resource: URI, position: types.Position): Promise<types.Location[] | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position)
-		};
-		return this._commands.executeCommand<modes.Location[]>('_executeReferenceProvider', args)
-			.then(tryMapWith(typeConverters.location.to));
-	}
-
 	private _executeDocumentRenameProvider(resource: URI, position: types.Position, newName: string): Promise<types.WorkspaceEdit> {
 		const args = {
 			resource,
@@ -502,24 +436,6 @@ export class ExtHostApiCommands {
 		});
 	}

-	private _executeSelectionRangeProvider(resource: URI, positions: types.Position[]): Promise<vscode.SelectionRange[]> {
-		const pos = positions.map(typeConverters.Position.from);
-		const args = {
-			resource,
-			position: pos[0],
-			positions: pos
-		};
-		return this._commands.executeCommand<IRange[][]>('_executeSelectionRangeProvider', args).then(result => {
-			return result.map(ranges => {
-				let node: types.SelectionRange | undefined;
-				for (const range of ranges.reverse()) {
-					node = new types.SelectionRange(typeConverters.Range.to(range), node);
-				}
-				return node!;
-			});
-		});
-	}
-
 	private _executeColorPresentationProvider(color: types.Color, context: { uri: URI, range: types.Range; }): Promise<types.ColorPresentation[]> {
 		const args = {
 			resource: context.uri,
@@ -534,38 +450,6 @@ export class ExtHostApiCommands {
 		});
 	}

-	private _executeDocumentSymbolProvider(resource: URI): Promise<vscode.SymbolInformation[] | undefined> {
-		const args = {
-			resource
-		};
-		return this._commands.executeCommand<modes.DocumentSymbol[]>('_executeDocumentSymbolProvider', args).then((value): vscode.SymbolInformation[] | undefined => {
-			if (isFalsyOrEmpty(value)) {
-				return undefined;
-			}
-			class MergedInfo extends types.SymbolInformation implements vscode.DocumentSymbol {
-				static to(symbol: modes.DocumentSymbol): MergedInfo {
-					const res = new MergedInfo(
-						symbol.name,
-						typeConverters.SymbolKind.to(symbol.kind),
-						symbol.containerName || '',
-						new types.Location(resource, typeConverters.Range.to(symbol.range))
-					);
-					res.detail = symbol.detail;
-					res.range = res.location.range;
-					res.selectionRange = typeConverters.Range.to(symbol.selectionRange);
-					res.children = symbol.children ? symbol.children.map(MergedInfo.to) : [];
-					return res;
-				}
-
-				detail!: string;
-				range!: vscode.Range;
-				selectionRange!: vscode.Range;
-				children!: vscode.DocumentSymbol[];
-				containerName!: string;
-			}
-			return value.map(MergedInfo.to);
-		});
-	}

 	private _executeCodeActionProvider(resource: URI, rangeOrSelection: types.Range | types.Selection, kind?: string): Promise<(vscode.CodeAction | vscode.Command | undefined)[] | undefined> {
 		const args = {
@@ -610,36 +494,6 @@ export class ExtHostApiCommands {

 	}

-	private _executeFormatDocumentProvider(resource: URI, options: vscode.FormattingOptions): Promise<vscode.TextEdit[] | undefined> {
-		const args = {
-			resource,
-			options
-		};
-		return this._commands.executeCommand<ISingleEditOperation[]>('_executeFormatDocumentProvider', args)
-			.then(tryMapWith(edit => new types.TextEdit(typeConverters.Range.to(edit.range), edit.text)));
-	}
-
-	private _executeFormatRangeProvider(resource: URI, range: types.Range, options: vscode.FormattingOptions): Promise<vscode.TextEdit[] | undefined> {
-		const args = {
-			resource,
-			range: typeConverters.Range.from(range),
-			options
-		};
-		return this._commands.executeCommand<ISingleEditOperation[]>('_executeFormatRangeProvider', args)
-			.then(tryMapWith(edit => new types.TextEdit(typeConverters.Range.to(edit.range), edit.text)));
-	}
-
-	private _executeFormatOnTypeProvider(resource: URI, position: types.Position, ch: string, options: vscode.FormattingOptions): Promise<vscode.TextEdit[] | undefined> {
-		const args = {
-			resource,
-			position: typeConverters.Position.from(position),
-			ch,
-			options
-		};
-		return this._commands.executeCommand<ISingleEditOperation[]>('_executeFormatOnTypeProvider', args)
-			.then(tryMapWith(edit => new types.TextEdit(typeConverters.Range.to(edit.range), edit.text)));
-	}
-
 	private _executeDocumentLinkProvider(resource: URI): Promise<vscode.DocumentLink[] | undefined> {
 		return this._commands.executeCommand<modes.ILink[]>('_executeLinkProvider', resource)
 			.then(tryMapWith(typeConverters.DocumentLink.to));
--- a/src/vs/workbench/api/common/extHostContributions.ts
+++ b/src/vs/workbench/api/common/extHostContributions.ts
@@ -1,82 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { BrandedService, IInstantiationService, ServicesAccessor, IConstructorSignature0 } from 'vs/platform/instantiation/common/instantiation';
-import { Registry } from 'vs/platform/registry/common/platform';
-import { IDisposable, dispose } from 'vs/base/common/lifecycle';
-
-/**
- * An ext host contribution that will be loaded when the extension host starts and disposed when the extension host shuts down.
- */
-export interface IExtHostContribution extends IDisposable {
-	// Marker Interface
-}
-
-export namespace Extensions {
-	export const ExtHost = 'exthost.contributions.kind';
-}
-
-type IExtHostContributionSignature<Service extends BrandedService[]> = new (...services: Service) => IExtHostContribution;
-
-export interface IExtHostContributionsRegistry {
-
-	/**
-	 * Registers a ext host contribution to the platform that will be loaded when the extension host starts and disposed when the extension host shuts down.
-	 */
-	registerExtHostContribution<Services extends BrandedService[]>(contribution: IExtHostContributionSignature<Services>): void;
-
-	/**
-	 * Starts the registry by providing the required services.
-	 */
-	start(accessor: ServicesAccessor): void;
-
-	/**
-	 * Stops the registry by disposing the instantiated contributions
-	 */
-	stop(): void;
-}
-
-class ExtHostContributionsRegistry implements IExtHostContributionsRegistry {
-
-	private instantiationService: IInstantiationService | undefined;
-	private readonly contributions: IConstructorSignature0<IExtHostContribution>[] = [];
-	private toBeInstantiated: IConstructorSignature0<IExtHostContribution>[] = [];
-	private instantiated: IExtHostContribution[] = [];
-
-	registerExtHostContribution<Services extends BrandedService[]>(ctor: { new(...services: Services): IExtHostContribution }): void {
-		this.contributions.push(ctor);
-
-		// Instantiate directly if started
-		if (this.instantiationService) {
-			this.instantiate(ctor);
-		}
-
-		// Otherwise keep contributions to be instantiated
-		else {
-			this.toBeInstantiated.push(ctor);
-		}
-	}
-
-	start(accessor: ServicesAccessor): void {
-		this.instantiationService = accessor.get(IInstantiationService);
-		this.toBeInstantiated.forEach(ctor => this.instantiate(ctor), this);
-		this.toBeInstantiated = [];
-	}
-
-	private instantiate<Services extends BrandedService[]>(ctor: { new(...services: Services): IExtHostContribution }) {
-		this.instantiated.push(this.instantiationService!.createInstance(ctor));
-	}
-
-	stop(): void {
-		this.instantiationService = undefined;
-		this.instantiated.forEach(dispose);
-		this.instantiated = [];
-		this.toBeInstantiated = [...this.contributions];
-	}
-
-}
-
-Registry.add(Extensions.ExtHost, new ExtHostContributionsRegistry());
-
--- a/src/vs/workbench/api/common/extHostDebugService.ts
+++ b/src/vs/workbench/api/common/extHostDebugService.ts
@@ -825,7 +825,7 @@ export class ExtHostDebugServiceBase implements IExtHostDebugService, ExtHostDeb
 		if (aex) {
 			const folder = session.workspaceFolder;
 			const rootFolder = folder ? folder.uri.toString() : undefined;
-			return this._commandService.executeCommand(aex, rootFolder).then((ae: { command: string, args: string[] }) => {
+			return this._commandService.executeCommand(aex, rootFolder).then((ae: any) => {
 				return new DebugAdapterExecutable(ae.command, ae.args || []);
 			});
 		}
@@ -1049,9 +1049,9 @@ class DirectDebugAdapter extends AbstractDebugAdapter {
 	constructor(private implementation: vscode.DebugAdapter) {
 		super();

-		if (this.implementation.onSendMessage) {
-			implementation.onSendMessage((message: DebugProtocol.ProtocolMessage) => {
-				this.acceptMessage(message);
+		if (this.implementation.onDidSendMessage) {
+			implementation.onDidSendMessage((message: vscode.DebugProtocolMessage) => {
+				this.acceptMessage(message as DebugProtocol.ProtocolMessage);
 			});
 		}
 	}
--- a/src/vs/workbench/api/common/extHostExtensionService.ts
+++ b/src/vs/workbench/api/common/extHostExtensionService.ts
@@ -32,6 +32,7 @@ import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitData
 import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePaths';
 import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
 import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { IExtHostTunnelService } from 'vs/workbench/api/common/extHostTunnelService';

 interface ITestRunner {
 	/** Old test runner API, as exported from `vscode/lib/testrunner` */
@@ -76,6 +77,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	protected readonly _extHostWorkspace: ExtHostWorkspace;
 	protected readonly _extHostConfiguration: ExtHostConfiguration;
 	protected readonly _logService: ILogService;
+	protected readonly _extHostTunnelService: IExtHostTunnelService;

 	protected readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
 	protected readonly _mainThreadTelemetryProxy: MainThreadTelemetryShape;
@@ -104,7 +106,8 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 		@IExtHostConfiguration extHostConfiguration: IExtHostConfiguration,
 		@ILogService logService: ILogService,
 		@IExtHostInitDataService initData: IExtHostInitDataService,
-		@IExtensionStoragePaths storagePath: IExtensionStoragePaths
+		@IExtensionStoragePaths storagePath: IExtensionStoragePaths,
+		@IExtHostTunnelService extHostTunnelService: IExtHostTunnelService
 	) {
 		this._hostUtils = hostUtils;
 		this._extHostContext = extHostContext;
@@ -113,6 +116,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 		this._extHostWorkspace = extHostWorkspace;
 		this._extHostConfiguration = extHostConfiguration;
 		this._logService = logService;
+		this._extHostTunnelService = extHostTunnelService;
 		this._disposables = new DisposableStore();

 		this._mainThreadWorkspaceProxy = this._extHostContext.getProxy(MainContext.MainThreadWorkspace);
@@ -652,6 +656,8 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 				extensionHostEnv: result.extensionHostEnv
 			};

+			await this._extHostTunnelService.addDetected(result.detectedTunnels);
+
 			return {
 				type: 'ok',
 				value: {
--- a/src/vs/workbench/api/common/extHostInitDataService.ts
+++ b/src/vs/workbench/api/common/extHostInitDataService.ts
@@ -5,12 +5,10 @@

 import { IInitData } from './extHost.protocol';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
-import { URI } from 'vs/base/common/uri';

 export const IExtHostInitDataService = createDecorator<IExtHostInitDataService>('IExtHostInitDataService');

 export interface IExtHostInitDataService extends Readonly<IInitData> {
 	_serviceBrand: undefined;
-	readonly logFile: URI;
 }

--- a/src/vs/workbench/api/common/extHostLanguageFeatures.ts
+++ b/src/vs/workbench/api/common/extHostLanguageFeatures.ts
@@ -389,7 +389,7 @@ class CodeActionAdapter {
 						edit: candidate.edit && typeConvert.WorkspaceEdit.from(candidate.edit),
 						kind: candidate.kind && candidate.kind.value,
 						isPreferred: candidate.isPreferred,
-						disabled: candidate.disabled
+						disabled: candidate.disabled?.reason
 					});
 				}
 			}
--- a/src/vs/workbench/api/common/extHostTunnelService.ts
+++ b/src/vs/workbench/api/common/extHostTunnelService.ts
@@ -4,18 +4,25 @@
 *--------------------------------------------------------------------------------------------*/

 import { ExtHostTunnelServiceShape } from 'vs/workbench/api/common/extHost.protocol';
-import * as vscode from 'vscode';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import * as vscode from 'vscode';
+
+export interface TunnelOptions {
+	remote: { port: number, host: string };
+	localPort?: number;
+	name?: string;
+	closeable?: boolean;
+}
+
+export interface TunnelDto {
+	remote: { port: number, host: string };
+	localAddress: string;
+}

 export interface IExtHostTunnelService extends ExtHostTunnelServiceShape {
-	makeTunnel(forward: vscode.TunnelOptions): Promise<vscode.Tunnel>;
+	readonly _serviceBrand: undefined;
+	makeTunnel(forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
+	addDetected(tunnels: { remote: { port: number, host: string }, localAddress: string }[] | undefined): Promise<void>;
 }

 export const IExtHostTunnelService = createDecorator<IExtHostTunnelService>('IExtHostTunnelService');
-
-export class ExtHostTunnelService implements IExtHostTunnelService {
-	makeTunnel(forward: vscode.TunnelOptions): Promise<vscode.Tunnel> {
-		throw new Error('Method not implemented.');
-	}
-}
-
--- a/src/vs/workbench/api/common/extHostTypeConverters.ts
+++ b/src/vs/workbench/api/common/extHostTypeConverters.ts
@@ -309,7 +309,7 @@ export namespace MarkdownString {
 	}

 	export function to(value: htmlContent.IMarkdownString): vscode.MarkdownString {
-		return new htmlContent.MarkdownString(value.value, value.isTrusted);
+		return new htmlContent.MarkdownString(value.value, { isTrusted: value.isTrusted, supportThemeIcons: value.supportThemeIcons });
 	}

 	export function fromStrict(value: string | types.MarkdownString): undefined | string | htmlContent.IMarkdownString {
--- a/src/vs/workbench/api/common/extHostTypes.ts
+++ b/src/vs/workbench/api/common/extHostTypes.ts
@@ -14,6 +14,7 @@ import { generateUuid } from 'vs/base/common/uuid';
 import * as vscode from 'vscode';
 import { FileSystemProviderErrorCode, markAsFileSystemProviderError } from 'vs/platform/files/common/files';
 import { RemoteAuthorityResolverErrorCode } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { markdownUnescapeCodicons, escapeCodicons } from 'vs/base/common/codicons';

 function es5ClassCompat(target: Function): any {
 	///@ts-ignore
@@ -1231,21 +1232,26 @@ export class MarkdownString {

 	value: string;
 	isTrusted?: boolean;
+	readonly supportThemeIcons?: boolean;

-	constructor(value?: string) {
-		this.value = value || '';
+	constructor(value?: string, { supportThemeIcons }: { supportThemeIcons?: boolean } = {}) {
+		this.value = value ?? '';
+		this.supportThemeIcons = supportThemeIcons ?? false;
 	}

 	appendText(value: string): MarkdownString {
 		// escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
-		this.value += value
+		value = value
 			.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&')
 			.replace('\n', '\n\n');
+		this.value += this.supportThemeIcons ? markdownUnescapeCodicons(value) : value;
+
 		return this;
 	}

 	appendMarkdown(value: string): MarkdownString {
 		this.value += value;
+
 		return this;
 	}

@@ -1257,6 +1263,10 @@ export class MarkdownString {
 		this.value += '\n```\n';
 		return this;
 	}
+
+	static escapeThemeIcons(value: string): string {
+		return escapeCodicons(value);
+	}
 }

@es5ClassCompat