move rest code code inset to workbench out of (monaco) editor

src/vs/editor/common/modes.ts

@@ -9,7 +9,7 @@ import { Event } from 'vs/base/common/event';
 import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { isObject } from 'vs/base/common/types';
-import { URI, UriComponents } from 'vs/base/common/uri';
+import { URI } from 'vs/base/common/uri';
 import { Position } from 'vs/editor/common/core/position';
 import { IRange, Range } from 'vs/editor/common/core/range';
 import { Selection } from 'vs/editor/common/core/selection';
@@ -1321,19 +1321,6 @@ export interface CodeLensProvider {
 	resolveCodeLens?(model: model.ITextModel, codeLens: ICodeLensSymbol, token: CancellationToken): ProviderResult<ICodeLensSymbol>;
 }
 
-export interface ICodeInsetSymbol {
-	range: IRange;
-	id?: string;
-	height?: number;
-	webviewHandle?: string;
-}
-export interface CodeInsetProvider {
-	onDidChange?: Event<this>;
-	extensionLocation: UriComponents;
-	provideCodeInsets(model: model.ITextModel, token: CancellationToken): ProviderResult<ICodeInsetSymbol[]>;
-	resolveCodeInset?(model: model.ITextModel, codeInset: ICodeInsetSymbol, token: CancellationToken): ProviderResult<ICodeInsetSymbol>;
-}
-
 // --- feature registries ------
 
 /**
@@ -1396,11 +1383,6 @@ export const TypeDefinitionProviderRegistry = new LanguageFeatureRegistry<TypeDe
  */
 export const CodeLensProviderRegistry = new LanguageFeatureRegistry<CodeLensProvider>();
 
-/**
- * @internal
- */
-export const CodeInsetProviderRegistry = new LanguageFeatureRegistry<CodeInsetProvider>();
-
 /**
  * @internal
  */

src/vs/monaco.d.ts

@@ -5414,20 +5414,6 @@ declare namespace monaco.languages {
 		resolveCodeLens?(model: editor.ITextModel, codeLens: ICodeLensSymbol, token: CancellationToken): ProviderResult<ICodeLensSymbol>;
 	}
 
-	export interface ICodeInsetSymbol {
-		range: IRange;
-		id?: string;
-		height?: number;
-		webviewHandle?: string;
-	}
-
-	export interface CodeInsetProvider {
-		onDidChange?: IEvent<this>;
-		extensionLocation: UriComponents;
-		provideCodeInsets(model: editor.ITextModel, token: CancellationToken): ProviderResult<ICodeInsetSymbol[]>;
-		resolveCodeInset?(model: editor.ITextModel, codeInset: ICodeInsetSymbol, token: CancellationToken): ProviderResult<ICodeInsetSymbol>;
-	}
-
 	export interface ILanguageExtensionPoint {
 		id: string;
 		extensions?: string[];

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

@@ -21,6 +21,7 @@ import * as typeConverters from 'vs/workbench/api/node/extHostTypeConverters';
 import { URI } from 'vs/base/common/uri';
 import { Selection } from 'vs/editor/common/core/selection';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
+import * as codeInset from 'vs/workbench/parts/codeinset/codeInset';
 
 @extHostNamedCustomer(MainContext.MainThreadLanguageFeatures)
 export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesShape {
@@ -165,7 +166,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 
 	$registerCodeInsetSupport(handle: number, selector: ISerializedDocumentFilter[], eventHandle: number, extension: IExtensionDescription): void {
 
-		const provider = <modes.CodeInsetProvider>{
+		const provider = <codeInset.CodeInsetProvider>{
 			provideCodeInsets: (model: ITextModel, token: CancellationToken): CodeInsetDto[] | Thenable<CodeInsetDto[]> => {
 				return this._proxy.$provideCodeInsets(handle, model.uri, token).then(dto => {
 					if (dto) { dto.forEach(obj => this._heapService.trackObject(obj)); }
@@ -182,13 +183,13 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 		};
 
 		if (typeof eventHandle === 'number') {
-			const emitter = new Emitter<modes.CodeInsetProvider>();
+			const emitter = new Emitter<codeInset.CodeInsetProvider>();
 			this._registrations[eventHandle] = emitter;
 			provider.onDidChange = emitter.event;
 		}
 
 		const langSelector = typeConverters.LanguageSelector.from(selector);
-		this._registrations[handle] = modes.CodeInsetProviderRegistry.register(langSelector, provider);
+		this._registrations[handle] = codeInset.CodeInsetProviderRegistry.register(langSelector, provider);
 	}
 
 	// --- declaration

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

@@ -45,6 +45,7 @@ import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { ResolvedAuthority } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { IRemoteConsoleLog } from 'vs/base/node/console';
+import * as codeInset from 'vs/workbench/parts/codeinset/codeInset';
 
 export interface IEnvironment {
 	isExtensionDevelopmentDebug: boolean;
@@ -905,7 +906,7 @@ export interface CodeLensDto extends ObjectIdentifier {
 	command?: CommandDto;
 }
 
-export type CodeInsetDto = ObjectIdentifier & modes.ICodeInsetSymbol;
+export type CodeInsetDto = ObjectIdentifier & codeInset.ICodeInsetSymbol;
 
 export interface ExtHostLanguageFeaturesShape {
 	$provideDocumentSymbols(handle: number, resource: UriComponents, token: CancellationToken): Promise<modes.DocumentSymbol[] | undefined>;

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

@@ -18,6 +18,7 @@ import { CustomCodeAction } from 'vs/workbench/api/node/extHostLanguageFeatures'
 import { ICommandsExecutor, PreviewHTMLAPICommand, OpenFolderAPICommand, DiffAPICommand, OpenAPICommand, RemoveFromRecentlyOpenedAPICommand, SetEditorLayoutAPICommand } from './apiCommands';
 import { EditorGroupLayout } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
+import * as codeInset from 'vs/workbench/parts/codeinset/codeInset';
 
 export class ExtHostApiCommands {
 
@@ -523,7 +524,7 @@ export class ExtHostApiCommands {
 
 	private _executeCodeInsetProvider(resource: URI): Thenable<vscode.CodeInset[]> {
 		const args = { resource };
-		return this._commands.executeCommand<modes.ICodeInsetSymbol[]>('_executeCodeInsetProvider', args)
+		return this._commands.executeCommand<codeInset.ICodeInsetSymbol[]>('_executeCodeInsetProvider', args)
 			.then(tryMapWith(item =>
 				new types.CodeInset(
 					typeConverters.Range.to(item.range))));

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

@@ -27,6 +27,7 @@ import { ILogService } from 'vs/platform/log/common/log';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { ExtHostWebview } from 'vs/workbench/api/node/extHostWebview';
+import * as codeInset from 'vs/workbench/parts/codeinset/codeInset';
 
 // --- adapter
 
@@ -153,7 +154,7 @@ class CodeInsetAdapter {
 		private readonly _provider: vscode.CodeInsetProvider
 	) { }
 
-	provideCodeInsets(resource: URI, token: CancellationToken): Promise<modes.ICodeInsetSymbol[]> {
+	provideCodeInsets(resource: URI, token: CancellationToken): Promise<codeInset.ICodeInsetSymbol[]> {
 		const doc = this._documents.getDocumentData(resource).document;
 		return asPromise(() => this._provider.provideCodeInsets(doc, token)).then(insets => {
 			if (Array.isArray(insets)) {
@@ -170,7 +171,7 @@ class CodeInsetAdapter {
 		});
 	}
 
-	resolveCodeInset(symbol: modes.ICodeInsetSymbol, webview: vscode.Webview, token: CancellationToken): Promise<modes.ICodeInsetSymbol> {
+	resolveCodeInset(symbol: codeInset.ICodeInsetSymbol, webview: vscode.Webview, token: CancellationToken): Promise<codeInset.ICodeInsetSymbol> {
 
 		const inset = this._heapService.get<vscode.CodeInset>(ObjectIdentifier.of(symbol));
 		if (!inset) {
@@ -1151,11 +1152,11 @@ export class ExtHostLanguageFeatures implements ExtHostLanguageFeaturesShape {
 		return result;
 	}
 
-	$provideCodeInsets(handle: number, resource: UriComponents, token: CancellationToken): Promise<modes.ICodeInsetSymbol[]> {
+	$provideCodeInsets(handle: number, resource: UriComponents, token: CancellationToken): Promise<codeInset.ICodeInsetSymbol[]> {
 		return this._withAdapter(handle, CodeInsetAdapter, adapter => adapter.provideCodeInsets(URI.revive(resource), token));
 	}
 
-	$resolveCodeInset(handle: number, resource: UriComponents, symbol: modes.ICodeInsetSymbol, token: CancellationToken): Promise<modes.ICodeInsetSymbol> {
+	$resolveCodeInset(handle: number, resource: UriComponents, symbol: codeInset.ICodeInsetSymbol, token: CancellationToken): Promise<codeInset.ICodeInsetSymbol> {
 		const webview = new ExtHostWebview(symbol.webviewHandle, this._webviewProxy, { enableScripts: true });
 		webview.html = '<html><body></body></html>';
 		const x = this._withAdapter(handle, CodeInsetAdapter, adapter => adapter.resolveCodeInset(symbol, webview, token));

src/vs/workbench/parts/codeinset/codeInset.contribution.ts

@@ -3,21 +3,17 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-// import { Registry } from 'vs/platform/registry/common/platform';
-// import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
-// import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
 import { CancelablePromise, createCancelablePromise, RunOnceScheduler } from 'vs/base/common/async';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { dispose, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { StableEditorScrollState } from 'vs/editor/browser/core/editorState';
 import * as editorBrowser from 'vs/editor/browser/editorBrowser';
 import * as editorCommon from 'vs/editor/common/editorCommon';
 import { IModelDecorationsChangeAccessor } from 'vs/editor/common/model';
-import { CodeInsetProviderRegistry } from 'vs/editor/common/modes';
+import { CodeInsetProviderRegistry, getCodeInsetData, ICodeInsetData } from './codeInset';
 import { CodeInsetWidget, CodeInsetHelper } from './codeInsetWidget';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 import { INotificationService } from 'vs/platform/notification/common/notification';
-import { getCodeInsetData, ICodeInsetData } from './codeinset';
 import { registerEditorContribution } from 'vs/editor/browser/editorExtensions';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { MainThreadWebviews } from 'vs/workbench/api/electron-browser/mainThreadWebview';

src/vs/workbench/parts/codeinset/codeInset.ts

@@ -4,13 +4,32 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { registerLanguageCommand } from 'vs/editor/browser/editorExtensions';
-import { ICodeInsetSymbol, CodeInsetProvider, CodeInsetProviderRegistry } from 'vs/editor/common/modes';
 import { ITextModel } from 'vs/editor/common/model';
 import { onUnexpectedExternalError, illegalArgument } from 'vs/base/common/errors';
 import { mergeSort } from 'vs/base/common/arrays';
-import { URI } from 'vs/base/common/uri';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { Event } from 'vs/base/common/event';
 import { IModelService } from 'vs/editor/common/services/modelService';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { LanguageFeatureRegistry } from 'vs/editor/common/modes/languageFeatureRegistry';
+import { ProviderResult } from 'vs/editor/common/modes';
+import { IRange } from 'vs/editor/common/core/range';
+
+export interface ICodeInsetSymbol {
+	range: IRange;
+	id?: string;
+	height?: number;
+	webviewHandle?: string;
+}
+
+export interface CodeInsetProvider {
+	onDidChange?: Event<this>;
+	extensionLocation: UriComponents;
+	provideCodeInsets(model: ITextModel, token: CancellationToken): ProviderResult<ICodeInsetSymbol[]>;
+	resolveCodeInset?(model: ITextModel, codeInset: ICodeInsetSymbol, token: CancellationToken): ProviderResult<ICodeInsetSymbol>;
+}
+
+export const CodeInsetProviderRegistry = new LanguageFeatureRegistry<CodeInsetProvider>();
 
 export interface ICodeInsetData {
 	symbol: ICodeInsetSymbol;