Each mode manages the worker code loading
This commit is contained in:
Alex Dima
parent
68e6224a64
commit
12248e50b9
|
|
@ -20,53 +20,52 @@ export function createWordRegExp(allowInWords:string = ''): RegExp {
|
|||
return NullMode.createWordRegExp(allowInWords);
|
||||
}
|
||||
|
||||
export abstract class AbstractMode<W> implements Modes.IMode {
|
||||
|
||||
_instantiationService:IInstantiationService;
|
||||
_threadService:IThreadService;
|
||||
private _descriptor:Modes.IModeDescriptor;
|
||||
export class ModeWorkerManager<W> {
|
||||
|
||||
private _descriptor: Modes.IModeDescriptor;
|
||||
private _workerDescriptor: AsyncDescriptor2<string, Modes.IWorkerParticipant[], W>;
|
||||
private _superWorkerModuleId: string;
|
||||
private _instantiationService: IInstantiationService;
|
||||
private _workerPiecePromise:TPromise<W>;
|
||||
|
||||
private _eventEmitter = new EventEmitter();
|
||||
private _simplifiedMode: Modes.IMode;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
instantiationService: IInstantiationService,
|
||||
threadService: IThreadService
|
||||
workerModuleId:string,
|
||||
workerClassName:string,
|
||||
superWorkerModuleId:string,
|
||||
instantiationService: IInstantiationService
|
||||
) {
|
||||
this._instantiationService = instantiationService;
|
||||
this._threadService = threadService;
|
||||
this._descriptor = descriptor;
|
||||
|
||||
this._workerDescriptor = createAsyncDescriptor2(workerModuleId, workerClassName);
|
||||
this._superWorkerModuleId = superWorkerModuleId;
|
||||
this._instantiationService = instantiationService;
|
||||
this._workerPiecePromise = null;
|
||||
this._simplifiedMode = null;
|
||||
}
|
||||
|
||||
public getId(): string {
|
||||
return this._descriptor.id;
|
||||
}
|
||||
|
||||
public toSimplifiedMode(): Modes.IMode {
|
||||
if (!this._simplifiedMode) {
|
||||
this._simplifiedMode = new SimplifiedMode(this);
|
||||
}
|
||||
return this._simplifiedMode;
|
||||
public worker<T>(runner:(worker:W)=>TPromise<T>): TPromise<T>
|
||||
public worker<T>(runner:(worker:W)=>T): TPromise<T> {
|
||||
return this._getOrCreateWorker().then(runner);
|
||||
}
|
||||
|
||||
private _getOrCreateWorker(): TPromise<W> {
|
||||
if (!this._workerPiecePromise) {
|
||||
var workerDescriptor: AsyncDescriptor2<string, Modes.IWorkerParticipant[], W> = this._getWorkerDescriptor();
|
||||
// First, load the code of the worker (without instantiating it)
|
||||
this._workerPiecePromise = AbstractMode._loadModule(workerDescriptor.moduleName).then(() => {
|
||||
// TODO@Alex: workaround for missing `bundles` config
|
||||
|
||||
// First, load the code of the worker super class
|
||||
let superWorkerCodePromise = (this._superWorkerModuleId ? ModeWorkerManager._loadModule(this._superWorkerModuleId) : TPromise.as(null));
|
||||
|
||||
this._workerPiecePromise = superWorkerCodePromise.then(() => {
|
||||
// Second, load the code of the worker (without instantiating it)
|
||||
return ModeWorkerManager._loadModule(this._workerDescriptor.moduleName);
|
||||
}).then(() => {
|
||||
// Then, load & instantiate all the participants
|
||||
var participants = this._descriptor.workerParticipants;
|
||||
return TPromise.join<Modes.IWorkerParticipant>(participants.map((participant) => {
|
||||
return this._instantiationService.createInstance(participant);
|
||||
}));
|
||||
}).then((participants:Modes.IWorkerParticipant[]) => {
|
||||
return this._instantiationService.createInstance<string, Modes.IWorkerParticipant[], W>(workerDescriptor, this.getId(), participants);
|
||||
// Finally, create the mode worker instance
|
||||
return this._instantiationService.createInstance<string, Modes.IWorkerParticipant[], W>(this._workerDescriptor, this._descriptor.id, participants);
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -80,15 +79,37 @@ export abstract class AbstractMode<W> implements Modes.IMode {
|
|||
// Cannot cancel loading code
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], W> {
|
||||
return createAsyncDescriptor2('vs/editor/common/modes/nullWorker', 'NullWorker');
|
||||
export abstract class AbstractMode<W> implements Modes.IMode {
|
||||
|
||||
_instantiationService:IInstantiationService;
|
||||
_threadService:IThreadService;
|
||||
private _descriptor:Modes.IModeDescriptor;
|
||||
|
||||
private _eventEmitter = new EventEmitter();
|
||||
private _simplifiedMode: Modes.IMode;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
instantiationService: IInstantiationService,
|
||||
threadService: IThreadService
|
||||
) {
|
||||
this._instantiationService = instantiationService;
|
||||
this._threadService = threadService;
|
||||
this._descriptor = descriptor;
|
||||
this._simplifiedMode = null;
|
||||
}
|
||||
|
||||
_worker<T>(runner:(worker:W)=>TPromise<T>): TPromise<T>;
|
||||
_worker<T>(runner:(worker:W)=>T): TPromise<T>;
|
||||
_worker<T>(runner:(worker:W)=>any): TPromise<T> {
|
||||
return this._getOrCreateWorker().then(runner);
|
||||
public getId(): string {
|
||||
return this._descriptor.id;
|
||||
}
|
||||
|
||||
public toSimplifiedMode(): Modes.IMode {
|
||||
if (!this._simplifiedMode) {
|
||||
this._simplifiedMode = new SimplifiedMode(this);
|
||||
}
|
||||
return this._simplifiedMode;
|
||||
}
|
||||
|
||||
// START mics interface implementations
|
||||
|
|
|
|||
|
|
@ -12,9 +12,8 @@ import Modes = require('vs/editor/common/modes');
|
|||
import {OneWorkerAttr, AllWorkersAttr} from 'vs/platform/thread/common/threadService';
|
||||
import cssWorker = require('vs/languages/css/common/cssWorker');
|
||||
import cssTokenTypes = require('vs/languages/css/common/cssTokenTypes');
|
||||
import {AbstractMode} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AbstractMode, ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AbstractState} from 'vs/editor/common/modes/abstractState';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IMarker} from 'vs/platform/markers/common/markers';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
import {IThreadService, ThreadAffinity} from 'vs/platform/thread/common/thread';
|
||||
|
|
@ -283,7 +282,6 @@ export class CSSMode extends AbstractMode<cssWorker.CSSWorker> {
|
|||
|
||||
public tokenizationSupport: Modes.ITokenizationSupport;
|
||||
public richEditSupport: Modes.IRichEditSupport;
|
||||
|
||||
public inplaceReplaceSupport:Modes.IInplaceReplaceSupport;
|
||||
public configSupport:Modes.IConfigurationSupport;
|
||||
public referenceSupport: Modes.IReferenceSupport;
|
||||
|
|
@ -295,12 +293,15 @@ export class CSSMode extends AbstractMode<cssWorker.CSSWorker> {
|
|||
public suggestSupport: Modes.ISuggestSupport;
|
||||
public quickFixSupport: Modes.IQuickFixSupport;
|
||||
|
||||
private _modeWorkerManager: ModeWorkerManager<cssWorker.CSSWorker>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
@IInstantiationService instantiationService: IInstantiationService,
|
||||
@IThreadService threadService: IThreadService
|
||||
) {
|
||||
super(descriptor, instantiationService, threadService);
|
||||
this._modeWorkerManager = new ModeWorkerManager<cssWorker.CSSWorker>(descriptor, 'vs/languages/css/common/cssWorker', 'CSSWorker', null, instantiationService);
|
||||
|
||||
this.tokenizationSupport = new TokenizationSupport(this, {
|
||||
getInitialState: () => new State(this, States.Selector, false, null, false, 0)
|
||||
|
|
@ -366,8 +367,8 @@ export class CSSMode extends AbstractMode<cssWorker.CSSWorker> {
|
|||
}
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], cssWorker.CSSWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/css/common/cssWorker', 'CSSWorker');
|
||||
private _worker<T>(runner:(worker:cssWorker.CSSWorker)=>WinJS.TPromise<T>): WinJS.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
public configure(options:any): WinJS.TPromise<void> {
|
||||
|
|
|
|||
|
|
@ -5,12 +5,11 @@
|
|||
'use strict';
|
||||
|
||||
import URI from 'vs/base/common/uri';
|
||||
import { AsyncDescriptor2, createAsyncDescriptor2 } from 'vs/platform/instantiation/common/descriptors';
|
||||
import winjs = require('vs/base/common/winjs.base');
|
||||
import EditorCommon = require('vs/editor/common/editorCommon');
|
||||
import Modes = require('vs/editor/common/modes');
|
||||
import htmlWorker = require('vs/languages/html/common/htmlWorker');
|
||||
import { AbstractMode, createWordRegExp } from 'vs/editor/common/modes/abstractMode';
|
||||
import { AbstractMode, createWordRegExp, ModeWorkerManager } from 'vs/editor/common/modes/abstractMode';
|
||||
import { AbstractState } from 'vs/editor/common/modes/abstractState';
|
||||
import {OneWorkerAttr} from 'vs/platform/thread/common/threadService';
|
||||
import {IModeService} from 'vs/editor/common/services/modeService';
|
||||
|
|
@ -284,6 +283,7 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode<W> i
|
|||
public suggestSupport: Modes.ISuggestSupport;
|
||||
|
||||
private modeService:IModeService;
|
||||
private _modeWorkerManager: ModeWorkerManager<W>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
|
|
@ -292,6 +292,7 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode<W> i
|
|||
@IModeService modeService: IModeService
|
||||
) {
|
||||
super(descriptor, instantiationService, threadService);
|
||||
this._modeWorkerManager = this._createModeWorkerManager(descriptor, instantiationService);
|
||||
|
||||
this.modeService = modeService;
|
||||
|
||||
|
|
@ -330,6 +331,14 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode<W> i
|
|||
});
|
||||
}
|
||||
|
||||
protected _createModeWorkerManager(descriptor:Modes.IModeDescriptor, instantiationService: IInstantiationService): ModeWorkerManager<W> {
|
||||
return new ModeWorkerManager<W>(descriptor, 'vs/languages/html/common/htmlWorker', 'HTMLWorker', null, instantiationService);
|
||||
}
|
||||
|
||||
private _worker<T>(runner:(worker:W)=>winjs.TPromise<T>): winjs.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
protected _createRichEditSupport(embeddedAutoClosingPairs: Modes.IAutoClosingPair[]): Modes.IRichEditSupport {
|
||||
return new RichEditSupport(this.getId(), {
|
||||
|
||||
|
|
@ -464,10 +473,6 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode<W> i
|
|||
return null;
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], htmlWorker.HTMLWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/html/common/htmlWorker', 'HTMLWorker');
|
||||
}
|
||||
|
||||
static $computeLinks = OneWorkerAttr(HTMLMode, HTMLMode.prototype.computeLinks);
|
||||
public computeLinks(resource:URI):winjs.TPromise<Modes.ILink[]> {
|
||||
return this._worker((w) => w.computeLinks(resource));
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
|
||||
import winjs = require('vs/base/common/winjs.base');
|
||||
import tokenization = require('vs/languages/typescript/common/features/tokenization');
|
||||
import javascriptWorker = require('vs/languages/javascript/common/javascriptWorker');
|
||||
import typescriptMode = require('vs/languages/typescript/common/typescriptMode');
|
||||
|
|
@ -12,8 +11,8 @@ import typescript = require('vs/languages/typescript/common/typescript');
|
|||
import EditorCommon = require('vs/editor/common/editorCommon');
|
||||
import Modes = require('vs/editor/common/modes');
|
||||
import extensions = require('vs/languages/javascript/common/javascript.extensions');
|
||||
import {createWordRegExp} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AsyncDescriptor, AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {createWordRegExp, ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AsyncDescriptor} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IThreadService} from 'vs/platform/thread/common/thread';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
|
||||
|
|
@ -120,17 +119,8 @@ export class JSMode extends typescriptMode.TypeScriptMode<javascriptWorker.JavaS
|
|||
getSuggestionDetails: (resource, position, suggestion) => this.getSuggestionDetails(resource, position, suggestion)});
|
||||
}
|
||||
|
||||
public asyncCtor(): winjs.Promise {
|
||||
if (!this._threadService.isInMainThread) {
|
||||
return new winjs.Promise((c, e, p) => {
|
||||
// TODO@Alex: workaround for missing `bundles` config, before instantiating the javascriptWorker, we ensure the typescriptWorker has been loaded
|
||||
(<any>require)(['vs/languages/typescript/common/typescriptWorker2'], (worker:any) => {
|
||||
c(this);
|
||||
});
|
||||
});
|
||||
} else {
|
||||
return winjs.TPromise.as(this);
|
||||
}
|
||||
protected _createModeWorkerManager(descriptor:Modes.IModeDescriptor, instantiationService: IInstantiationService): ModeWorkerManager<javascriptWorker.JavaScriptWorker> {
|
||||
return new ModeWorkerManager<javascriptWorker.JavaScriptWorker>(descriptor, 'vs/languages/javascript/common/javascriptWorker', 'JavaScriptWorker', 'vs/languages/typescript/common/typescriptWorker2', instantiationService);
|
||||
}
|
||||
|
||||
// ---- specialize by override
|
||||
|
|
@ -143,10 +133,6 @@ export class JSMode extends typescriptMode.TypeScriptMode<javascriptWorker.JavaS
|
|||
return model.getMode() === this || /\.(d\.ts|js)$/.test(model.getAssociatedResource().fsPath);
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], javascriptWorker.JavaScriptWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/javascript/common/javascriptWorker', 'JavaScriptWorker');
|
||||
}
|
||||
|
||||
public get filter() {
|
||||
return void 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,10 +12,9 @@ import Platform = require('vs/platform/platform');
|
|||
import nls = require('vs/nls');
|
||||
import jsonWorker = require('vs/languages/json/common/jsonWorker');
|
||||
import tokenization = require('vs/languages/json/common/features/tokenization');
|
||||
import {AbstractMode, createWordRegExp} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AbstractMode, createWordRegExp, ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import {OneWorkerAttr, AllWorkersAttr} from 'vs/platform/thread/common/threadService';
|
||||
import {IThreadService, IThreadSynchronizableObject, ThreadAffinity} from 'vs/platform/thread/common/thread';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IJSONContributionRegistry, Extensions, ISchemaContributions} from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
import {RichEditSupport} from 'vs/editor/common/modes/supports/richEditSupport';
|
||||
|
|
@ -25,23 +24,24 @@ export class JSONMode extends AbstractMode<jsonWorker.JSONWorker> implements Mod
|
|||
|
||||
public tokenizationSupport: Modes.ITokenizationSupport;
|
||||
public richEditSupport: Modes.IRichEditSupport;
|
||||
|
||||
public configSupport:Modes.IConfigurationSupport;
|
||||
public inplaceReplaceSupport:Modes.IInplaceReplaceSupport;
|
||||
public extraInfoSupport: Modes.IExtraInfoSupport;
|
||||
public outlineSupport: Modes.IOutlineSupport;
|
||||
public formattingSupport: Modes.IFormattingSupport;
|
||||
|
||||
public suggestSupport: Modes.ISuggestSupport;
|
||||
|
||||
public outlineGroupLabel : { [name: string]: string; };
|
||||
|
||||
private _modeWorkerManager: ModeWorkerManager<jsonWorker.JSONWorker>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
@IInstantiationService instantiationService: IInstantiationService,
|
||||
@IThreadService threadService: IThreadService
|
||||
) {
|
||||
super(descriptor, instantiationService, threadService);
|
||||
this._modeWorkerManager = new ModeWorkerManager<jsonWorker.JSONWorker>(descriptor, 'vs/languages/json/common/jsonWorker', 'JSONWorker', null, instantiationService);
|
||||
|
||||
this.tokenizationSupport = tokenization.createTokenizationSupport(this, true);
|
||||
|
||||
|
|
@ -111,6 +111,10 @@ export class JSONMode extends AbstractMode<jsonWorker.JSONWorker> implements Mod
|
|||
}
|
||||
}
|
||||
|
||||
private _worker<T>(runner:(worker:jsonWorker.JSONWorker)=>WinJS.TPromise<T>): WinJS.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
private getSchemaConfiguration() : ISchemaContributions {
|
||||
var contributionRegistry = <IJSONContributionRegistry> Platform.Registry.as(Extensions.JSONContribution);
|
||||
return contributionRegistry.getSchemaContributions();
|
||||
|
|
@ -127,10 +131,6 @@ export class JSONMode extends AbstractMode<jsonWorker.JSONWorker> implements Mod
|
|||
this._worker((w) => w.setSchemaContributions(data));
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], jsonWorker.JSONWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/json/common/jsonWorker', 'JSONWorker');
|
||||
}
|
||||
|
||||
public configure(options:any): WinJS.TPromise<void> {
|
||||
if (this._threadService.isInMainThread) {
|
||||
return this._configureWorkers(options);
|
||||
|
|
|
|||
|
|
@ -13,9 +13,8 @@ import Types = require('vs/editor/common/modes/monarch/monarchTypes');
|
|||
import Compile = require('vs/editor/common/modes/monarch/monarchCompile');
|
||||
import lessWorker = require('vs/languages/less/common/lessWorker');
|
||||
import * as lessTokenTypes from 'vs/languages/less/common/lessTokenTypes';
|
||||
import {AbstractMode} from 'vs/editor/common/modes/abstractMode';
|
||||
import {ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import {OneWorkerAttr, AllWorkersAttr} from 'vs/platform/thread/common/threadService';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IModeService} from 'vs/editor/common/services/modeService';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
import {IThreadService, ThreadAffinity} from 'vs/platform/thread/common/thread';
|
||||
|
|
@ -189,6 +188,7 @@ export class LESSMode extends Monarch.MonarchMode<lessWorker.LessWorker> impleme
|
|||
public suggestSupport: Modes.ISuggestSupport;
|
||||
|
||||
private modeService: IModeService;
|
||||
private _modeWorkerManager: ModeWorkerManager<lessWorker.LessWorker>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
|
|
@ -199,6 +199,7 @@ export class LESSMode extends Monarch.MonarchMode<lessWorker.LessWorker> impleme
|
|||
@IEditorWorkerService editorWorkerService: IEditorWorkerService
|
||||
) {
|
||||
super(descriptor, Compile.compile(language), instantiationService, threadService, modeService, modelService, editorWorkerService);
|
||||
this._modeWorkerManager = new ModeWorkerManager<lessWorker.LessWorker>(descriptor, 'vs/languages/less/common/lessWorker', 'LessWorker', 'vs/languages/css/common/cssWorker', instantiationService);
|
||||
|
||||
this.modeService = modeService;
|
||||
|
||||
|
|
@ -227,17 +228,8 @@ export class LESSMode extends Monarch.MonarchMode<lessWorker.LessWorker> impleme
|
|||
}
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], lessWorker.LessWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/less/common/lessWorker', 'LessWorker');
|
||||
}
|
||||
|
||||
_worker<T>(runner:(worker:lessWorker.LessWorker)=>winjs.TPromise<T>): winjs.TPromise<T> {
|
||||
// TODO@Alex: workaround for missing `bundles` config, before instantiating the lessWorker, we ensure the cssWorker has been loaded
|
||||
return this.modeService.getOrCreateMode('css').then((cssMode) => {
|
||||
return (<AbstractMode<any>>cssMode)._worker((worker) => winjs.TPromise.as(true));
|
||||
}).then(() => {
|
||||
return super._worker(runner);
|
||||
});
|
||||
private _worker<T>(runner:(worker:lessWorker.LessWorker)=>winjs.TPromise<T>): winjs.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
public configure(options:any): winjs.TPromise<void> {
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@ import Compile = require('vs/editor/common/modes/monarch/monarchCompile');
|
|||
import Modes = require('vs/editor/common/modes');
|
||||
import MarkdownWorker = require('vs/languages/markdown/common/markdownWorker');
|
||||
import {OneWorkerAttr, AllWorkersAttr} from 'vs/platform/thread/common/threadService';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {htmlTokenTypes} from 'vs/languages/html/common/html';
|
||||
import markdownTokenTypes = require('vs/languages/markdown/common/markdownTokenTypes');
|
||||
import {IModeService} from 'vs/editor/common/services/modeService';
|
||||
|
|
@ -21,6 +20,7 @@ import {IThreadService} from 'vs/platform/thread/common/thread';
|
|||
import {IModelService} from 'vs/editor/common/services/modelService';
|
||||
import {IWorkspaceContextService} from 'vs/platform/workspace/common/workspace';
|
||||
import {IEditorWorkerService} from 'vs/editor/common/services/editorWorkerService';
|
||||
import {ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
|
||||
export const language =
|
||||
<Types.ILanguage>{
|
||||
|
|
@ -211,6 +211,8 @@ export class MarkdownMode extends Monarch.MonarchMode<MarkdownWorker.MarkdownWor
|
|||
public emitOutputSupport: Modes.IEmitOutputSupport;
|
||||
public configSupport:Modes.IConfigurationSupport;
|
||||
|
||||
private _modeWorkerManager: ModeWorkerManager<MarkdownWorker.MarkdownWorker>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
@IInstantiationService instantiationService: IInstantiationService,
|
||||
|
|
@ -221,11 +223,16 @@ export class MarkdownMode extends Monarch.MonarchMode<MarkdownWorker.MarkdownWor
|
|||
@IEditorWorkerService editorWorkerService: IEditorWorkerService
|
||||
) {
|
||||
super(descriptor, Compile.compile(language), instantiationService, threadService, modeService, modelService, editorWorkerService);
|
||||
this._modeWorkerManager = new ModeWorkerManager<MarkdownWorker.MarkdownWorker>(descriptor, 'vs/languages/markdown/common/markdownWorker', 'MarkdownWorker', null, instantiationService);
|
||||
|
||||
this.emitOutputSupport = this;
|
||||
this.configSupport = this;
|
||||
}
|
||||
|
||||
private _worker<T>(runner:(worker:MarkdownWorker.MarkdownWorker)=>WinJS.TPromise<T>): WinJS.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
public configure(options:any): WinJS.TPromise<void> {
|
||||
if (this._threadService.isInMainThread) {
|
||||
return this._configureWorkers(options);
|
||||
|
|
@ -243,8 +250,4 @@ export class MarkdownMode extends Monarch.MonarchMode<MarkdownWorker.MarkdownWor
|
|||
public getEmitOutput(resource: URI, absoluteWorkerResourcesPath?: string): WinJS.TPromise<Modes.IEmitOutput> { // TODO@Ben technical debt: worker cannot resolve paths absolute
|
||||
return this._worker((w) => w.getEmitOutput(resource, absoluteWorkerResourcesPath));
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], MarkdownWorker.MarkdownWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/markdown/common/markdownWorker', 'MarkdownWorker');
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,8 +7,7 @@
|
|||
import Modes = require('vs/editor/common/modes');
|
||||
import htmlMode = require('vs/languages/html/common/html');
|
||||
import csharpTokenization = require('vs/languages/razor/common/csharpTokenization');
|
||||
import {createWordRegExp} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {createWordRegExp, ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import razorTokenTypes = require('vs/languages/razor/common/razorTokenTypes');
|
||||
import {RAZORWorker} from 'vs/languages/razor/common/razorWorker';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
|
|
@ -67,6 +66,10 @@ export class RAZORMode extends htmlMode.HTMLMode<RAZORWorker> {
|
|||
this.formattingSupport = null;
|
||||
}
|
||||
|
||||
protected _createModeWorkerManager(descriptor:Modes.IModeDescriptor, instantiationService: IInstantiationService): ModeWorkerManager<RAZORWorker> {
|
||||
return new ModeWorkerManager<RAZORWorker>(descriptor, 'vs/languages/razor/common/razorWorker', 'RAZORWorker', 'vs/languages/html/common/htmlWorker', instantiationService);
|
||||
}
|
||||
|
||||
protected _createRichEditSupport(embeddedAutoClosingPairs: Modes.IAutoClosingPair[]): Modes.IRichEditSupport {
|
||||
return new RichEditSupport(this.getId(), {
|
||||
|
||||
|
|
@ -110,10 +113,6 @@ export class RAZORMode extends htmlMode.HTMLMode<RAZORWorker> {
|
|||
});
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], RAZORWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/razor/common/razorWorker', 'RAZORWorker');
|
||||
}
|
||||
|
||||
public getInitialState(): Modes.IState {
|
||||
return new RAZORState(this, htmlMode.States.Content, '', '', '', '', '');
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,9 +13,8 @@ import EditorCommon = require('vs/editor/common/editorCommon');
|
|||
import Modes = require('vs/editor/common/modes');
|
||||
import sassWorker = require('vs/languages/sass/common/sassWorker');
|
||||
import * as sassTokenTypes from 'vs/languages/sass/common/sassTokenTypes';
|
||||
import {AbstractMode} from 'vs/editor/common/modes/abstractMode';
|
||||
import {ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import {OneWorkerAttr, AllWorkersAttr} from 'vs/platform/thread/common/threadService';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IModeService} from 'vs/editor/common/services/modeService';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
import {IThreadService, ThreadAffinity} from 'vs/platform/thread/common/thread';
|
||||
|
|
@ -291,6 +290,7 @@ export class SASSMode extends Monarch.MonarchMode<sassWorker.SassWorker> impleme
|
|||
public suggestSupport: Modes.ISuggestSupport;
|
||||
|
||||
private modeService: IModeService;
|
||||
private _modeWorkerManager: ModeWorkerManager<sassWorker.SassWorker>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
|
|
@ -301,6 +301,7 @@ export class SASSMode extends Monarch.MonarchMode<sassWorker.SassWorker> impleme
|
|||
@IEditorWorkerService editorWorkerService: IEditorWorkerService
|
||||
) {
|
||||
super(descriptor, Compile.compile(language), instantiationService, threadService, modeService, modelService, editorWorkerService);
|
||||
this._modeWorkerManager = new ModeWorkerManager<sassWorker.SassWorker>(descriptor, 'vs/languages/sass/common/sassWorker', 'SassWorker', 'vs/languages/css/common/cssWorker', instantiationService);
|
||||
|
||||
this.modeService = modeService;
|
||||
|
||||
|
|
@ -329,17 +330,8 @@ export class SASSMode extends Monarch.MonarchMode<sassWorker.SassWorker> impleme
|
|||
}
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], sassWorker.SassWorker> {
|
||||
return createAsyncDescriptor2('vs/languages/sass/common/sassWorker', 'SassWorker');
|
||||
}
|
||||
|
||||
_worker<T>(runner:(worker:sassWorker.SassWorker)=>winjs.TPromise<T>): winjs.TPromise<T> {
|
||||
// TODO@Alex: workaround for missing `bundles` config, before instantiating the sassWorker, we ensure the cssWorker has been loaded
|
||||
return this.modeService.getOrCreateMode('css').then((cssMode) => {
|
||||
return (<AbstractMode<any>>cssMode)._worker((worker) => winjs.TPromise.as(true));
|
||||
}).then(() => {
|
||||
return super._worker(runner);
|
||||
});
|
||||
private _worker<T>(runner:(worker:sassWorker.SassWorker)=>winjs.TPromise<T>): winjs.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
public configure(options:any): winjs.TPromise<void> {
|
||||
|
|
|
|||
|
|
@ -16,10 +16,10 @@ import quickFixMainActions = require('vs/languages/typescript/common/features/qu
|
|||
import typescriptWorker = require('vs/languages/typescript/common/typescriptWorker2');
|
||||
import typescript = require('vs/languages/typescript/common/typescript');
|
||||
import ts = require('vs/languages/typescript/common/lib/typescriptServices');
|
||||
import {AbstractMode, createWordRegExp} from 'vs/editor/common/modes/abstractMode';
|
||||
import {AbstractMode, createWordRegExp, ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
import {IModelService} from 'vs/editor/common/services/modelService';
|
||||
import {OneWorkerAttr, AllWorkersAttr} from 'vs/platform/thread/common/threadService';
|
||||
import {AsyncDescriptor, AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {AsyncDescriptor} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IMarker} from 'vs/platform/markers/common/markers';
|
||||
import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
|
||||
import {IThreadService, ThreadAffinity} from 'vs/platform/thread/common/thread';
|
||||
|
|
@ -150,6 +150,7 @@ export class TypeScriptMode<W extends typescriptWorker.TypeScriptWorker2> extend
|
|||
private _disposables: lifecycle.IDisposable[] = [];
|
||||
private _projectResolver: WinJS.TPromise<typescript.IProjectResolver2>;
|
||||
private _semanticValidator: SemanticValidator;
|
||||
private _modeWorkerManager: ModeWorkerManager<W>;
|
||||
|
||||
constructor(
|
||||
descriptor:Modes.IModeDescriptor,
|
||||
|
|
@ -159,6 +160,7 @@ export class TypeScriptMode<W extends typescriptWorker.TypeScriptWorker2> extend
|
|||
) {
|
||||
super(descriptor, instantiationService, threadService);
|
||||
this._telemetryService = telemetryService;
|
||||
this._modeWorkerManager = this._createModeWorkerManager(descriptor, instantiationService);
|
||||
|
||||
if (this._threadService && this._threadService.isInMainThread) {
|
||||
|
||||
|
|
@ -283,6 +285,16 @@ export class TypeScriptMode<W extends typescriptWorker.TypeScriptWorker2> extend
|
|||
}
|
||||
}
|
||||
|
||||
protected _createModeWorkerManager(descriptor:Modes.IModeDescriptor, instantiationService: IInstantiationService): ModeWorkerManager<W> {
|
||||
return new ModeWorkerManager<W>(descriptor, 'vs/languages/typescript/common/typescriptWorker2', 'TypeScriptWorker2', null, instantiationService);
|
||||
}
|
||||
|
||||
protected _worker<T>(runner:(worker:W)=>WinJS.TPromise<T>): WinJS.TPromise<T>;
|
||||
protected _worker<T>(runner:(worker:W)=>T): WinJS.TPromise<T>;
|
||||
protected _worker<T>(runner:(worker:W)=>any): WinJS.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
public dispose(): void {
|
||||
this._disposables = lifecycle.disposeAll(this._disposables);
|
||||
}
|
||||
|
|
@ -395,10 +407,6 @@ export class TypeScriptMode<W extends typescriptWorker.TypeScriptWorker2> extend
|
|||
|
||||
// ---- worker talk
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, Modes.IWorkerParticipant[], typescriptWorker.TypeScriptWorker2> {
|
||||
return createAsyncDescriptor2('vs/languages/typescript/common/typescriptWorker2', 'TypeScriptWorker2');
|
||||
}
|
||||
|
||||
static $_pickAWorkerToValidate = OneWorkerAttr(TypeScriptMode, TypeScriptMode.prototype._pickAWorkerToValidate, TypeScriptMode.prototype._syncProjects, ThreadAffinity.Group3);
|
||||
private _pickAWorkerToValidate(): WinJS.Promise {
|
||||
return this._worker((w) => w.enableValidator());
|
||||
|
|
|
|||
|
|
@ -7,8 +7,7 @@
|
|||
import {MonarchMode} from 'vs/editor/common/modes/monarch/monarch';
|
||||
import types = require('vs/editor/common/modes/monarch/monarchTypes');
|
||||
import {compile} from 'vs/editor/common/modes/monarch/monarchCompile';
|
||||
import {IModeDescriptor, IWorkerParticipant} from 'vs/editor/common/modes';
|
||||
import {AsyncDescriptor2, createAsyncDescriptor2} from 'vs/platform/instantiation/common/descriptors';
|
||||
import {IModeDescriptor} from 'vs/editor/common/modes';
|
||||
import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
|
||||
import {IThreadService} from 'vs/platform/thread/common/thread';
|
||||
import {IModelService} from 'vs/editor/common/services/modelService';
|
||||
|
|
@ -19,6 +18,7 @@ import {OneWorkerAttr} from 'vs/platform/thread/common/threadService';
|
|||
import URI from 'vs/base/common/uri';
|
||||
import Modes = require('vs/editor/common/modes');
|
||||
import {IEditorWorkerService} from 'vs/editor/common/services/editorWorkerService';
|
||||
import {ModeWorkerManager} from 'vs/editor/common/modes/abstractMode';
|
||||
|
||||
export const language: types.ILanguage = {
|
||||
displayName: 'Log',
|
||||
|
|
@ -48,6 +48,8 @@ export class OutputMode extends MonarchMode<OutputWorker> {
|
|||
|
||||
public linkSupport:Modes.ILinkSupport;
|
||||
|
||||
private _modeWorkerManager: ModeWorkerManager<OutputWorker>;
|
||||
|
||||
constructor(
|
||||
descriptor:IModeDescriptor,
|
||||
@IInstantiationService instantiationService: IInstantiationService,
|
||||
|
|
@ -57,12 +59,13 @@ export class OutputMode extends MonarchMode<OutputWorker> {
|
|||
@IEditorWorkerService editorWorkerService: IEditorWorkerService
|
||||
) {
|
||||
super(descriptor, compile(language), instantiationService, threadService, modeService, modelService, editorWorkerService);
|
||||
this._modeWorkerManager = new ModeWorkerManager<OutputWorker>(descriptor, 'vs/workbench/parts/output/common/outputWorker', 'OutputWorker', null, instantiationService);
|
||||
|
||||
this.linkSupport = this;
|
||||
}
|
||||
|
||||
protected _getWorkerDescriptor(): AsyncDescriptor2<string, IWorkerParticipant[], OutputWorker> {
|
||||
return createAsyncDescriptor2('vs/workbench/parts/output/common/outputWorker', 'OutputWorker');
|
||||
private _worker<T>(runner:(worker:OutputWorker)=>winjs.TPromise<T>): winjs.TPromise<T> {
|
||||
return this._modeWorkerManager.worker(runner);
|
||||
}
|
||||
|
||||
static $computeLinks = OneWorkerAttr(OutputMode, OutputMode.prototype.computeLinks);
|
||||
|
|
|
|||
Loading…
Reference in a new issue