Further reduce dependencies to LanguageExtensions

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

@@ -32,12 +32,12 @@ 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 {LanguageExtensions} from 'vs/editor/common/modes/languageExtensionPoint';
 import {AbstractKeybindingService} from 'vs/platform/keybinding/browser/keybindingServiceImpl';
 import {ICodeEditorService} from 'vs/editor/common/services/codeEditorService';
 import {IJSONSchema} from 'vs/base/common/jsonSchema';
 import * as JSONContributionRegistry from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
 import {ILanguageExtensionPoint} from 'vs/editor/common/services/modeService';
+import {registerLanguage} from 'vs/editor/common/modes/modesRegistry';
 
 // Set defaults for standalone editor
 DefaultConfig.editor.wrappingIndent = 'none';
@@ -418,7 +418,7 @@ export function createCustomMode(language:MonarchTypes.ILanguage): TPromise<Mode
 	var modeId = language.name;
 	var name = language.name;
 
-	LanguageExtensions.registerLanguage({
+	registerLanguage({
 		id: modeId,
 		aliases: [name]
 	});
@@ -431,7 +431,7 @@ export function createCustomMode(language:MonarchTypes.ILanguage): TPromise<Mode
 }
 
 export function registerStandaloneLanguage(language:ILanguageExtensionPoint, defModule:string): void {
-	LanguageExtensions.registerLanguage(language);
+	registerLanguage(language);
 
 	PluginsRegistry.registerOneTimeActivationEventListener('onLanguage:' + language.id, () => {
 		require([defModule], (value:{language:MonarchTypes.ILanguage}) => {

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

@@ -15,6 +15,8 @@ import Mime = require('vs/base/common/mime');
 import Errors = require('vs/base/common/errors');
 import Event, {Emitter} from 'vs/base/common/event';
 import {ILanguageExtensionPoint} from 'vs/editor/common/services/modeService';
+import {IEditorModesRegistry, ILegacyLanguageDefinition, Extensions} from 'vs/editor/common/modes/modesRegistry';
+import {Registry} from 'vs/platform/platform';
 
 interface ILanguagePointData {
 	knownModeIds: { [id: string]: boolean; };
@@ -133,17 +135,6 @@ function isValidLanguageExtensionPoint(value:ILanguageExtensionPoint, collector:
 	return true;
 }
 
-export interface ILegacyLanguageDefinition {
-	id: string;
-	extensions: string[];
-	filenames?: string[];
-	firstLine?: string;
-	aliases: string[];
-	mimetypes: string[];
-	moduleId: string;
-	ctorName: string;
-}
-
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
 export interface ILanguageExtensionPointHandler {
@@ -171,6 +162,8 @@ export interface ICompatModeDescriptor {
 	ctorName: string;
 }
 
+let modesRegistry = <IEditorModesRegistry>Registry.as(Extensions.EditorModes);
+
 class LanguageExtensionPointHandler implements IThreadSynchronizableObject<ILanguagePointData>, ILanguageExtensionPointHandler {
 
 	private knownModeIds: { [id: string]: boolean; };
@@ -197,6 +190,12 @@ class LanguageExtensionPointHandler implements IThreadSynchronizableObject<ILang
 		this.lowerName2Id = {};
 		this.id2ConfigurationFiles = {};
 		this._isRegisteredWithThreadService = false;
+
+		modesRegistry.getCompatModes().forEach((m) => this.registerCompatMode(m));
+		modesRegistry.onDidAddCompatMode((m) => this.registerCompatMode(m));
+
+		modesRegistry.getLanguages().forEach((m) => this.registerLanguage(m));
+		modesRegistry.onDidAddLanguage((m) => this.registerLanguage(m));
 	}
 
 	// -- BEGIN IThreadSynchronizableObject

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

@@ -4,12 +4,23 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {LanguageExtensions, ILegacyLanguageDefinition} from 'vs/editor/common/modes/languageExtensionPoint';
 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 {ILanguageExtensionPoint} from 'vs/editor/common/services/modeService';
+import Event, {Emitter} from 'vs/base/common/event';
+
+export interface ILegacyLanguageDefinition {
+	id: string;
+	extensions: string[];
+	filenames?: string[];
+	firstLine?: string;
+	aliases: string[];
+	mimetypes: string[];
+	moduleId: string;
+	ctorName: string;
+}
 
 // Define extension point ids
 export var Extensions = {
@@ -18,6 +29,9 @@ export var Extensions = {
 
 export interface IEditorModesRegistry {
 
+	onDidAddCompatMode: Event<ILegacyLanguageDefinition>;
+	onDidAddLanguage: Event<ILanguageExtensionPoint>;
+
 	// --- worker participants registration
 	registerWorkerParticipant(modeId:string, moduleId:string, ctorName?:string):void;
 	getWorkerParticipants(modeId:string):Modes.IWorkerParticipantDescriptor[];
@@ -27,21 +41,34 @@ export interface IEditorModesRegistry {
 
 	// --- modes registration
 	registerCompatMode(def:ILegacyLanguageDefinition): void;
+	getCompatModes(): ILegacyLanguageDefinition[];
+
 	registerLanguage(def:ILanguageExtensionPoint): void;
+	getLanguages(): ILanguageExtensionPoint[];
 }
 
 class EditorModesRegistry implements IEditorModesRegistry {
 
-	private workerParticipants: Modes.IWorkerParticipantDescriptor[];
+	private _workerParticipants: Modes.IWorkerParticipantDescriptor[];
+	private _compatModes: ILegacyLanguageDefinition[];
+	private _languages: ILanguageExtensionPoint[];
+
+	private _onDidAddCompatMode: Emitter<ILegacyLanguageDefinition> = new Emitter<ILegacyLanguageDefinition>();
+	public onDidAddCompatMode: Event<ILegacyLanguageDefinition> = this._onDidAddCompatMode.event;
+
+	private _onDidAddLanguage: Emitter<ILanguageExtensionPoint> = new Emitter<ILanguageExtensionPoint>();
+	public onDidAddLanguage: Event<ILanguageExtensionPoint> = this._onDidAddLanguage.event;
 
 	constructor() {
-		this.workerParticipants = [];
+		this._workerParticipants = [];
+		this._compatModes = [];
+		this._languages = [];
 	}
 
 	// --- worker participants registration
 
 	public registerWorkerParticipant(modeId:string, moduleId:string, ctorName?:string):void {
-		this.workerParticipants.push({
+		this._workerParticipants.push({
 			modeId: modeId,
 			moduleId: moduleId,
 			ctorName: ctorName
@@ -49,23 +76,35 @@ class EditorModesRegistry implements IEditorModesRegistry {
 	}
 
 	public _getAllWorkerParticipants(): Modes.IWorkerParticipantDescriptor[] {
-		return this.workerParticipants;
+		return this._workerParticipants;
 	}
 
 	public _setWorkerParticipants(participants:Modes.IWorkerParticipantDescriptor[]): void {
-		this.workerParticipants = participants;
+		this._workerParticipants = participants;
 	}
 
 	public getWorkerParticipants(modeId:string):Modes.IWorkerParticipantDescriptor[] {
-		return this.workerParticipants.filter(p => p.modeId === modeId);
+		return this._workerParticipants.filter(p => p.modeId === modeId);
 	}
 
+
 	public registerCompatMode(def:ILegacyLanguageDefinition): void {
-		LanguageExtensions.registerCompatMode(def);
+		this._compatModes.push(def);
+		this._onDidAddCompatMode.fire(def);
 	}
 
+	public getCompatModes(): ILegacyLanguageDefinition[] {
+		return this._compatModes.slice(0);
+	}
+
+
 	public registerLanguage(def:ILanguageExtensionPoint): void {
-		LanguageExtensions.registerLanguage(def);
+		this._languages.push(def);
+		this._onDidAddLanguage.fire(def);
+	}
+
+	public getLanguages(): ILanguageExtensionPoint[] {
+		return this._languages.slice(0);
 	}
 }