debt - don't use marshalling for descriptors

src/vs/editor/browser/standalone/standaloneCodeEditor.ts

@@ -36,7 +36,6 @@ import {IModelService} from 'vs/editor/common/services/modelService';
 import colorizer = require('vs/editor/browser/standalone/colorizer');
 import {IEditorModesRegistry, Extensions} from 'vs/editor/common/modes/modesRegistry';
 import {Registry} from 'vs/platform/platform';
-import {createAsyncDescriptor0} from 'vs/platform/instantiation/common/descriptors';
 import {LanguageExtensions, ILanguageExtensionPoint} from 'vs/editor/common/modes/languageExtensionPoint';
 import {AbstractKeybindingService} from 'vs/platform/keybinding/browser/keybindingServiceImpl';
 import {ICodeEditorService} from 'vs/editor/common/services/codeEditorService';
@@ -407,7 +406,7 @@ export function configureMode(modeId: string, options: any): void {
 
 export function registerWorkerParticipant(modeId:string, moduleName:string, ctorName:string): void {
 	var modeRegistry = <IEditorModesRegistry> Registry.as(Extensions.EditorModes);
-	modeRegistry.registerWorkerParticipant(modeId, createAsyncDescriptor0<Modes.IWorkerParticipant>(moduleName, ctorName));
+	modeRegistry.registerWorkerParticipant(modeId, moduleName, ctorName);
 }
 
 export function getAPI(): typeof vscode {

src/vs/editor/common/modes.ts

@@ -14,8 +14,9 @@ import {IDisposable} from 'vs/base/common/lifecycle';
 import {AsyncDescriptor0} from 'vs/platform/instantiation/common/descriptors';
 
 export interface IWorkerParticipantDescriptor {
-	modeId:string;
-	descriptor: AsyncDescriptor0<IWorkerParticipant>;
+	modeId: string;
+	moduleId: string;
+	ctorName: string;
 }
 
 export interface IWorkerParticipant {

src/vs/editor/common/modes/languageExtensionPoint.ts

@@ -14,7 +14,6 @@ import {IPluginDescription} from 'vs/platform/plugins/common/plugins';
 import {PluginsRegistry, IExtensionPointUser, IMessageCollector} from 'vs/platform/plugins/common/pluginsRegistry';
 import Mime = require('vs/base/common/mime');
 import Errors = require('vs/base/common/errors');
-import {AsyncDescriptor1, createAsyncDescriptor1} from 'vs/platform/instantiation/common/descriptors';
 import {IMode, IModeDescriptor} from 'vs/editor/common/modes';
 import Event, {Emitter} from 'vs/base/common/event';
 
@@ -24,7 +23,7 @@ interface ILanguagePointData {
 	name2LanguageId: { [name: string]: string; };
 	name2Extensions: { [name: string]: string[]; };
 	id2Name: { [id: string]: string; };
-	compatModes: { [id: string]: AsyncDescriptor1<IModeDescriptor, IMode>; };
+	compatModes: { [id: string]: ICompatModeDescriptor; };
 	lowerName2Id: { [name: string]: string; };
 }
 
@@ -177,7 +176,12 @@ export interface ILanguageExtensionPointHandler {
 	extractModeIds(commaSeparatedMimetypesOrCommaSeparatedIdsOrName: string): string[];
 	getModeIdsFromLanguageName(languageName: string): string[];
 	getModeIdsFromFilenameOrFirstLine(filename: string, firstLine?:string): string[];
-	getCompatMode(modeId: string): AsyncDescriptor1<IModeDescriptor, IMode>;
+	getCompatMode(modeId: string): ICompatModeDescriptor;
+}
+
+export interface ICompatModeDescriptor {
+	moduleId: string;
+	ctorName: string;
 }
 
 class LanguageExtensionPointHandler implements IThreadSynchronizableObject<ILanguagePointData>, ILanguageExtensionPointHandler {
@@ -187,7 +191,7 @@ class LanguageExtensionPointHandler implements IThreadSynchronizableObject<ILang
 	private name2LanguageId: { [name: string]: string; };
 	private name2Extensions: { [name: string]: string[]; };
 	private id2Name: { [id: string]: string; };
-	private compatModes: { [id: string]: AsyncDescriptor1<IModeDescriptor, IMode>; };
+	private compatModes: { [id: string]: ICompatModeDescriptor; };
 	private lowerName2Id: { [name: string]: string; };
 	private id2ConfigurationFiles: { [id:string]: string[]; };
 
@@ -252,7 +256,10 @@ class LanguageExtensionPointHandler implements IThreadSynchronizableObject<ILang
 			mimetypes: def.mimetypes
 		});
 
-		this.compatModes[def.id] = createAsyncDescriptor1<IModeDescriptor, IMode>(def.moduleId, def.ctorName);
+		this.compatModes[def.id] = {
+			moduleId: def.moduleId,
+			ctorName: def.ctorName
+		};
 	}
 
 	public _handleLanguagesExtensionPointUsers(extensions:IExtensionPointUser<ILanguageExtensionPoint[]>[]): void {
@@ -471,7 +478,7 @@ class LanguageExtensionPointHandler implements IThreadSynchronizableObject<ILang
 		return this.extractModeIds(mimeTypes.join(','));
 	}
 
-	public getCompatMode(modeId: string): AsyncDescriptor1<IModeDescriptor, IMode> {
+	public getCompatMode(modeId: string): ICompatModeDescriptor {
 		return this.compatModes[modeId] || null;
 	}
 

src/vs/editor/common/modes/modesRegistry.ts

@@ -10,7 +10,6 @@ import Modes = require('vs/editor/common/modes');
 import Strings = require('vs/base/common/strings');
 import EditorCommon = require('vs/editor/common/editorCommon');
 import {Registry} from 'vs/platform/platform';
-import {AsyncDescriptor0, createAsyncDescriptor0} from 'vs/platform/instantiation/common/descriptors';
 import {IPluginDescription} from 'vs/platform/plugins/common/plugins';
 import {PluginsRegistry} from 'vs/platform/plugins/common/pluginsRegistry';
 
@@ -22,8 +21,8 @@ export var Extensions = {
 export interface IEditorModesRegistry {
 
 	// --- worker participants registration
-	registerWorkerParticipant(modeId:string, descriptor:AsyncDescriptor0<Modes.IWorkerParticipant>):void;
-	getWorkerParticipants(modeId:string):AsyncDescriptor0<Modes.IWorkerParticipant>[];
+	registerWorkerParticipant(modeId:string, moduleId:string, ctorName?:string):void;
+	getWorkerParticipants(modeId:string):Modes.IWorkerParticipantDescriptor[];
 
 	_getAllWorkerParticipants(): Modes.IWorkerParticipantDescriptor[];
 	_setWorkerParticipants(participants:Modes.IWorkerParticipantDescriptor[]);
@@ -53,10 +52,11 @@ class EditorModesRegistry implements IEditorModesRegistry {
 
 	// --- worker participants registration
 
-	public registerWorkerParticipant(modeId:string, descriptor:AsyncDescriptor0<Modes.IWorkerParticipant>):void {
+	public registerWorkerParticipant(modeId:string, moduleId:string, ctorName?:string):void {
 		this.workerParticipants.push({
 			modeId: modeId,
-			descriptor: descriptor
+			moduleId: moduleId,
+			ctorName: ctorName
 		});
 	}
 
@@ -68,8 +68,8 @@ class EditorModesRegistry implements IEditorModesRegistry {
 		this.workerParticipants = participants;
 	}
 
-	public getWorkerParticipants(modeId:string):AsyncDescriptor0<Modes.IWorkerParticipant>[] {
-		return this.workerParticipants.filter(p => p.modeId === modeId).map(p => p.descriptor);
+	public getWorkerParticipants(modeId:string):Modes.IWorkerParticipantDescriptor[] {
+		return this.workerParticipants.filter(p => p.modeId === modeId);
 	}
 
 	// --- modes registration
@@ -129,7 +129,7 @@ export function registerMode(def:ILegacyLanguageDefinition): void {
 }
 
 export function registerWorkerParticipant(modeId:string, moduleId:string, ctorName?:string): void {
-	mR.registerWorkerParticipant(modeId, createAsyncDescriptor0<Modes.IWorkerParticipant>(moduleId, ctorName));
+	mR.registerWorkerParticipant(modeId, moduleId, ctorName);
 }
 
 

src/vs/editor/common/services/modeServiceImpl.ts

@@ -24,6 +24,7 @@ import {IEditorModesRegistry, Extensions} from 'vs/editor/common/modes/modesRegi
 import MonarchCommonTypes = require('vs/editor/common/modes/monarch/monarchCommon');
 import {OnEnterSupport, IOnEnterSupportOptions} from 'vs/editor/common/modes/supports/onEnter';
 import {IDisposable, combinedDispose, empty as EmptyDisposable} from 'vs/base/common/lifecycle';
+import {AsyncDescriptor, createAsyncDescriptor0, createAsyncDescriptor1} from 'vs/platform/instantiation/common/descriptors';
 
 interface IModeConfigurationMap { [modeId: string]: any; }
 
@@ -203,11 +204,12 @@ export class ModeServiceImpl implements IModeService {
 	protected _createMode(modeId:string): TPromise<Modes.IMode> {
 		let activationEvent = 'onLanguage:' + modeId;
 
-		let compatModeAsyncDescriptor = LanguageExtensions.getCompatMode(modeId);
+		let compatModeData = LanguageExtensions.getCompatMode(modeId);
 
-		if (compatModeAsyncDescriptor) {
+		if (compatModeData) {
 			return this._pluginService.activateByEvent(activationEvent).then((_) => {
 				var modeDescriptor = this._createModeDescriptor(modeId);
+				let compatModeAsyncDescriptor = createAsyncDescriptor1<Modes.IModeDescriptor, Modes.IMode>(compatModeData.moduleId, compatModeData.ctorName);
 				return this._threadService.createInstance(compatModeAsyncDescriptor, modeDescriptor);
 			}).then((compatMode) => {
 				if (compatMode.configSupport) {
@@ -235,7 +237,7 @@ export class ModeServiceImpl implements IModeService {
 		var workerParticipants = modesRegistry.getWorkerParticipants(modeId);
 		return {
 			id: modeId,
-			workerParticipants: workerParticipants
+			workerParticipants: workerParticipants.map(p => createAsyncDescriptor0(p.moduleId, p.ctorName))
 		};
 	}
 

src/vs/platform/instantiation/common/descriptors.ts

@@ -6,7 +6,6 @@
 
 import errors = require('vs/base/common/errors');
 import objects = require('vs/base/common/objects');
-import marshalling = require('vs/base/common/marshalling');
 import hash = require('vs/base/common/hash');
 import instantiation = require('./instantiation');
 
@@ -198,45 +197,7 @@ export interface SyncDescriptor8<A1, A2, A3, A4, A5, A6, A7, A8, T> {
 	bind(a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): SyncDescriptor0<T>;
 }
 
-export interface IAsyncDescriptor {
-	moduleName:string;
-	ctorName:string;
-}
-
-export interface ISerializedAsyncDescriptor {
-	$isAsyncDescriptor:boolean;
-	$moduleName:string;
-	$ctorName:string;
-	$staticArguments: any[];
-}
-
-marshalling.registerMarshallingContribution({
-
-	canSerialize: (obj:any): boolean => {
-		return obj instanceof AsyncDescriptor;
-	},
-
-	serialize: (asyncDescriptor:AsyncDescriptor<any>, serialize:(obj:any)=>any): ISerializedAsyncDescriptor => {
-		return {
-			$isAsyncDescriptor: true,
-			$moduleName: asyncDescriptor.moduleName,
-			$ctorName: asyncDescriptor.ctorName,
-			$staticArguments: serialize(asyncDescriptor.staticArguments())
-		};
-	},
-
-	canDeserialize: (obj:ISerializedAsyncDescriptor): boolean => {
-		return obj.$isAsyncDescriptor;
-	},
-
-	deserialize: (obj:ISerializedAsyncDescriptor, deserialize:(obj:any)=>any): any => {
-		var r = new AsyncDescriptor<any>(obj.$moduleName, obj.$ctorName);
-		r.appendStaticArguments(deserialize(obj.$staticArguments));
-		return r;
-	}
-});
-
-export class AsyncDescriptor<T> extends AbstractDescriptor<T> implements IAsyncDescriptor, objects.IEqualable {
+export class AsyncDescriptor<T> extends AbstractDescriptor<T> implements objects.IEqualable {
 
 	public static create<T>(moduleName:string, ctorName:string):AsyncDescriptor<T> {
 		return new AsyncDescriptor<T>(moduleName, ctorName);