add IModelLanguageConfigurationChangedEvent and ViewLanguageConfigurationEvent

src/vs/editor/common/commonCodeEditor.ts

@@ -23,7 +23,7 @@ import { hash } from 'vs/base/common/hash';
 import { EditorModeContext } from 'vs/editor/common/modes/editorModeContext';
 import {
 	IModelContentChangedEvent, IModelDecorationsChangedEvent,
-	IModelLanguageChangedEvent, IModelOptionsChangedEvent, TextModelEventType
+	IModelLanguageChangedEvent, IModelOptionsChangedEvent, TextModelEventType, IModelLanguageConfigurationChangedEvent
 } from 'vs/editor/common/model/textModelEvents';
 import * as editorOptions from 'vs/editor/common/config/editorOptions';
 import { ICursorPositionChangedEvent, ICursorSelectionChangedEvent } from 'vs/editor/common/controller/cursorEvents';
@@ -44,6 +44,9 @@ export abstract class CommonCodeEditor extends Disposable implements editorCommo
 	private readonly _onDidChangeModelLanguage: Emitter<IModelLanguageChangedEvent> = this._register(new Emitter<IModelLanguageChangedEvent>());
 	public readonly onDidChangeModelLanguage: Event<IModelLanguageChangedEvent> = this._onDidChangeModelLanguage.event;
 
+	private readonly _onDidChangeModelLanguageConfiguration: Emitter<IModelLanguageConfigurationChangedEvent> = this._register(new Emitter<IModelLanguageConfigurationChangedEvent>());
+	public readonly onDidChangeModelLanguageConfiguration: Event<IModelLanguageConfigurationChangedEvent> = this._onDidChangeModelLanguage.event;
+
 	private readonly _onDidChangeModelOptions: Emitter<IModelOptionsChangedEvent> = this._register(new Emitter<IModelOptionsChangedEvent>());
 	public readonly onDidChangeModelOptions: Event<IModelOptionsChangedEvent> = this._onDidChangeModelOptions.event;
 
@@ -901,6 +904,10 @@ export abstract class CommonCodeEditor extends Disposable implements editorCommo
 							this._onDidChangeModelLanguage.fire(e);
 							break;
 
+						case TextModelEventType.ModelLanguageConfigurationChanged:
+							this._onDidChangeModelLanguageConfiguration.fire(e);
+							break;
+
 						case TextModelEventType.ModelContentChanged:
 							this._onDidChangeModelContent.fire(e);
 							break;

src/vs/editor/common/controller/cursor.ts

@@ -13,7 +13,6 @@ import { Range } from 'vs/editor/common/core/range';
 import { Selection, SelectionDirection, ISelection } from 'vs/editor/common/core/selection';
 import * as editorCommon from 'vs/editor/common/editorCommon';
 import { CursorColumns, CursorConfiguration, EditOperationResult, CursorContext, CursorState, RevealTarget, IColumnSelectData, ICursors } from 'vs/editor/common/controller/cursorCommon';
-import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
 import { DeleteOperations } from 'vs/editor/common/controller/cursorDeleteOperations';
 import { TypeOperations } from 'vs/editor/common/controller/cursorTypeOperations';
 import { TextModelEventType, ModelRawContentChangedEvent, RawContentChangedType } from 'vs/editor/common/model/textModelEvents';
@@ -150,11 +149,10 @@ export class Cursor extends viewEvents.ViewEventEmitter implements ICursors {
 			this.context = new CursorContext(this._configuration, this._model, this._viewModel);
 			this._cursors.updateContext(this.context);
 		};
-		this._register(this._model.onDidChangeLanguage((e) => {
+		this._register(model.onDidChangeLanguage((e) => {
 			updateCursorContext();
 		}));
-		this._register(LanguageConfigurationRegistry.onDidChange(() => {
-			// TODO@Alex: react only if certain supports changed? (and if my model's mode changed)
+		this._register(model.onDidChangeLanguageConfiguration(() => {
 			updateCursorContext();
 		}));
 		this._register(model.onDidChangeOptions(() => {

src/vs/editor/common/editorCommon.ts

@@ -19,7 +19,7 @@ import { IndentRange } from 'vs/editor/common/model/indentRanges';
 import { ITextSource } from 'vs/editor/common/model/textSource';
 import {
 	ModelRawContentChangedEvent, IModelContentChangedEvent, IModelDecorationsChangedEvent,
-	IModelLanguageChangedEvent, IModelOptionsChangedEvent
+	IModelLanguageChangedEvent, IModelOptionsChangedEvent, IModelLanguageConfigurationChangedEvent
 } from 'vs/editor/common/model/textModelEvents';
 import * as editorOptions from 'vs/editor/common/config/editorOptions';
 import { ICursorPositionChangedEvent, ICursorSelectionChangedEvent } from 'vs/editor/common/controller/cursorEvents';
@@ -1150,6 +1150,11 @@ export interface IModel extends IReadOnlyModel, IEditableTextModel, ITextModelWi
 	 * @event
 	 */
 	onDidChangeLanguage(listener: (e: IModelLanguageChangedEvent) => void): IDisposable;
+	/**
+	 * An event emitted when the language configuration associated with the model has changed.
+	 * @event
+	 */
+	onDidChangeLanguageConfiguration(listener: (e: IModelLanguageConfigurationChangedEvent) => void): IDisposable;
 	/**
 	 * An event emitted right before disposing the model.
 	 * @event
@@ -1749,6 +1754,11 @@ export interface ICommonCodeEditor extends IEditor {
 	 * @event
 	 */
 	onDidChangeModelLanguage(listener: (e: IModelLanguageChangedEvent) => void): IDisposable;
+	/**
+	 * An event emitted when the language configuration of the current model has changed.
+	 * @event
+	 */
+	onDidChangeModelLanguageConfiguration(listener: (e: IModelLanguageConfigurationChangedEvent) => void): IDisposable;
 	/**
 	 * An event emitted when the options of the current model has changed.
 	 * @event

src/vs/editor/common/model/model.ts

@@ -34,7 +34,9 @@ export class Model extends EditableTextModel implements IModel {
 	public onDidChangeLanguage(listener: (e: textModelEvents.IModelLanguageChangedEvent) => void): IDisposable {
 		return this._eventEmitter.addListener(textModelEvents.TextModelEventType.ModelLanguageChanged, listener);
 	}
-
+	public onDidChangeLanguageConfiguration(listener: (e: textModelEvents.IModelLanguageConfigurationChangedEvent) => void): IDisposable {
+		return this._eventEmitter.addListener(textModelEvents.TextModelEventType.ModelLanguageConfigurationChanged, listener);
+	}
 	public static createFromString(text: string, options: ITextModelCreationOptions = TextModel.DEFAULT_CREATION_OPTIONS, languageIdentifier: LanguageIdentifier = null, uri: URI = null): Model {
 		return new Model(RawTextSource.fromString(text), options, languageIdentifier, uri);
 	}

src/vs/editor/common/model/textModelEvents.ts

@@ -18,6 +18,7 @@ export const TextModelEventType = {
 	ModelContentChanged: 'contentChanged',
 	ModelRawContentChanged2: 'rawContentChanged2',
 	ModelDecorationsChanged: 'decorationsChanged',
+	ModelLanguageConfigurationChanged: 'modelLanguageConfigurationChanged'
 };
 
 /**
@@ -34,6 +35,12 @@ export interface IModelLanguageChangedEvent {
 	readonly newLanguage: string;
 }
 
+/**
+ * An event describing that the language configuration associated with a model has changed.
+ */
+export interface IModelLanguageConfigurationChangedEvent {
+}
+
 export interface IModelContentChange {
 	/**
 	 * The range that got replaced.

src/vs/editor/common/model/textModelWithTokens.ts

@@ -71,6 +71,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 	private _lastState: IState;
 
 	private _indentRanges: IndentRange[];
+	private _languageRegistryListener: IDisposable;
 
 	private _revalidateTokensTimeout: number;
 
@@ -98,12 +99,20 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 
 		this._revalidateTokensTimeout = -1;
 
+		this._languageRegistryListener = LanguageConfigurationRegistry.onDidChange((e) => {
+			if (e.languageIdentifier.id === this._languageIdentifier.id) {
+				this._resetIndentRanges();
+				this._emitModelLanguageConfigurationEvent({});
+			}
+		});
+
 		this._resetTokenizationState();
 		this._resetIndentRanges();
 	}
 
 	public dispose(): void {
 		this._tokenizationListener.dispose();
+		this._languageRegistryListener.dispose();
 		this._clearTimers();
 		this._lastState = null;
 
@@ -239,6 +248,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 			}]
 		});
 		this._emitModelModeChangedEvent(e);
+		this._emitModelLanguageConfigurationEvent({});
 	}
 
 	public getLanguageIdAtPosition(_lineNumber: number, _column: number): LanguageId {
@@ -404,6 +414,12 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		}
 	}
 
+	private _emitModelLanguageConfigurationEvent(e: textModelEvents.IModelLanguageConfigurationChangedEvent): void {
+		if (!this._isDisposing) {
+			this._eventEmitter.emit(textModelEvents.TextModelEventType.ModelLanguageConfigurationChanged, e);
+		}
+	}
+
 	private _emitModelModeChangedEvent(e: textModelEvents.IModelLanguageChangedEvent): void {
 		if (!this._isDisposing) {
 			this._eventEmitter.emit(textModelEvents.TextModelEventType.ModelLanguageChanged, e);

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

@@ -143,12 +143,16 @@ export class RichEditSupport {
 	}
 }
 
+export class LanguageConfigurationChangeEvent {
+	languageIdentifier: LanguageIdentifier;
+}
+
 export class LanguageConfigurationRegistryImpl {
 
 	private _entries: RichEditSupport[];
 
-	private _onDidChange: Emitter<void> = new Emitter<void>();
-	public onDidChange: Event<void> = this._onDidChange.event;
+	private _onDidChange: Emitter<LanguageConfigurationChangeEvent> = new Emitter<LanguageConfigurationChangeEvent>();
+	public onDidChange: Event<LanguageConfigurationChangeEvent> = this._onDidChange.event;
 
 	constructor() {
 		this._entries = [];
@@ -158,12 +162,12 @@ export class LanguageConfigurationRegistryImpl {
 		let previous = this._getRichEditSupport(languageIdentifier.id);
 		let current = new RichEditSupport(languageIdentifier, previous, configuration);
 		this._entries[languageIdentifier.id] = current;
-		this._onDidChange.fire(void 0);
+		this._onDidChange.fire({ languageIdentifier });
 		return {
 			dispose: () => {
 				if (this._entries[languageIdentifier.id] === current) {
 					this._entries[languageIdentifier.id] = previous;
-					this._onDidChange.fire(void 0);
+					this._onDidChange.fire({ languageIdentifier });
 				}
 			}
 		};

src/vs/editor/common/view/viewEvents.ts

@@ -27,7 +27,8 @@ export const enum ViewEventType {
 	ViewTokensChanged = 12,
 	ViewTokensColorsChanged = 13,
 	ViewZonesChanged = 14,
-	ViewThemeChanged = 15
+	ViewThemeChanged = 15,
+	ViewLanguageConfigurationChanged = 16
 }
 
 export class ViewConfigurationChangedEvent {
@@ -282,6 +283,14 @@ export class ViewZonesChangedEvent {
 	}
 }
 
+export class ViewLanguageConfigurationEvent {
+
+	public readonly type = ViewEventType.ViewLanguageConfigurationChanged;
+
+	constructor() {
+	}
+}
+
 export type ViewEvent = (
 	ViewConfigurationChangedEvent
 	| ViewCursorStateChangedEvent
@@ -298,6 +307,7 @@ export type ViewEvent = (
 	| ViewTokensColorsChangedEvent
 	| ViewZonesChangedEvent
 	| ViewThemeChangedEvent
+	| ViewLanguageConfigurationEvent
 );
 
 export interface IViewEventListener {

src/vs/editor/common/viewModel/viewEventHandler.ts

@@ -49,6 +49,9 @@ export class ViewEventHandler extends Disposable {
 	public onFocusChanged(e: viewEvents.ViewFocusChangedEvent): boolean {
 		return false;
 	}
+	public onLanguageConfigurationChanged(e: viewEvents.ViewLanguageConfigurationEvent): boolean {
+		return false;
+	}
 	public onLineMappingChanged(e: viewEvents.ViewLineMappingChangedEvent): boolean {
 		return false;
 	}
@@ -121,6 +124,12 @@ export class ViewEventHandler extends Disposable {
 					}
 					break;
 
+				case viewEvents.ViewEventType.ViewLanguageConfigurationChanged:
+					if (this.onLanguageConfigurationChanged(e)) {
+						shouldRender = true;
+					}
+					break;
+
 				case viewEvents.ViewEventType.ViewLineMappingChanged:
 					if (this.onLineMappingChanged(e)) {
 						shouldRender = true;
@@ -175,7 +184,6 @@ export class ViewEventHandler extends Disposable {
 					}
 					break;
 
-
 				case viewEvents.ViewEventType.ViewThemeChanged:
 					if (this.onThemeChanged(e)) {
 						shouldRender = true;

src/vs/editor/common/viewModel/viewModelImpl.ts

@@ -261,6 +261,10 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 					// That's ok, a model tokens changed event will follow shortly
 					break;
 				}
+				case textModelEvents.TextModelEventType.ModelLanguageConfigurationChanged: {
+					eventsCollector.emit(new viewEvents.ViewLanguageConfigurationEvent());
+					break;
+				}
 				case textModelEvents.TextModelEventType.ModelContentChanged: {
 					// Ignore
 					break;

src/vs/monaco.d.ts

@@ -1787,6 +1787,11 @@ declare module monaco.editor {
 		 * @event
 		 */
 		onDidChangeLanguage(listener: (e: IModelLanguageChangedEvent) => void): IDisposable;
+		/**
+		 * An event emitted when the language configuration associated with the model has changed.
+		 * @event
+		 */
+		onDidChangeLanguageConfiguration(listener: (e: IModelLanguageConfigurationChangedEvent) => void): IDisposable;
 		/**
 		 * An event emitted right before disposing the model.
 		 * @event
@@ -2185,6 +2190,11 @@ declare module monaco.editor {
 		 * @event
 		 */
 		onDidChangeModelLanguage(listener: (e: IModelLanguageChangedEvent) => void): IDisposable;
+		/**
+		 * An event emitted when the language configuration of the current model has changed.
+		 * @event
+		 */
+		onDidChangeModelLanguageConfiguration(listener: (e: IModelLanguageConfigurationChangedEvent) => void): IDisposable;
 		/**
 		 * An event emitted when the options of the current model has changed.
 		 * @event
@@ -2419,6 +2429,12 @@ declare module monaco.editor {
 		readonly newLanguage: string;
 	}
 
+	/**
+	 * An event describing that the language configuration associated with a model has changed.
+	 */
+	export interface IModelLanguageConfigurationChangedEvent {
+	}
+
 	export interface IModelContentChange {
 		/**
 		 * The range that got replaced.