ModeTransition only needs a mode's id

src/vs/editor/common/core/modeTransition.ts

@@ -4,11 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {IMode, IModeTransition} from 'vs/editor/common/modes';
 import {Arrays} from 'vs/editor/common/core/arrays';
 
-export class ReducedModeTransition {
-	_reducedModeTransitionBrand: void;
+export class ModeTransition {
+	_modeTransitionBrand: void;
 
 	public startIndex:number;
 	public modeId: string;
@@ -18,31 +17,7 @@ export class ReducedModeTransition {
 		this.modeId = modeId;
 	}
 
-	public static findIndexInSegmentsArray(arr:ReducedModeTransition[], desiredIndex: number): number {
-		return Arrays.findIndexInSegmentsArray(arr, desiredIndex);
-	}
-}
-
-export class ModeTransition extends ReducedModeTransition {
-	_modeTransitionBrand: void;
-
-	public mode:IMode;
-
-	constructor(startIndex:number, mode:IMode) {
-		super(startIndex, mode.getId());
-		this.mode = mode;
-	}
-
 	public static findIndexInSegmentsArray(arr:ModeTransition[], desiredIndex: number): number {
 		return Arrays.findIndexInSegmentsArray(arr, desiredIndex);
 	}
-
-	public static create(modeTransitions:IModeTransition[]): ModeTransition[] {
-		let result:ModeTransition[] = [];
-		for (let i = 0, len = modeTransitions.length; i < len; i++) {
-			let modeTransition = modeTransitions[i];
-			result.push(new ModeTransition(modeTransition.startIndex, modeTransition.mode));
-		}
-		return result;
-	}
 }

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

@@ -105,10 +105,6 @@ export class Model extends EditableTextModel implements IModel {
 		// console.log('ALIVE MODELS: ' + Object.keys(aliveModels).join('\n'));
 	}
 
-	public getModeId(): string {
-		return this.getMode().getId();
-	}
-
 	public destroy(): void {
 		this.dispose();
 	}

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

@@ -6,7 +6,7 @@
 
 import * as strings from 'vs/base/common/strings';
 import {ILineTokens, IReadOnlyLineMarker} from 'vs/editor/common/editorCommon';
-import {IMode, IState} from 'vs/editor/common/modes';
+import {IState} from 'vs/editor/common/modes';
 import {TokensBinaryEncoding, TokensInflatorMap} from 'vs/editor/common/model/tokensBinaryEncoding';
 import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 import {LineToken} from 'vs/editor/common/model/lineToken';
@@ -178,11 +178,11 @@ export class ModelLine {
 
 	// --- BEGIN MODE TRANSITIONS
 
-	public getModeTransitions(topLevelMode:IMode): ModeTransition[] {
+	public getModeTransitions(topLevelModeId:string): ModeTransition[] {
 		if (this._modeTransitions) {
 			return this._modeTransitions;
 		} else {
-			return [new ModeTransition(0, topLevelMode)];
+			return [new ModeTransition(0, topLevelModeId)];
 		}
 	}
 
@@ -190,9 +190,9 @@ export class ModelLine {
 
 	// --- BEGIN TOKENS
 
-	public setTokens(map: TokensInflatorMap, tokens: LineToken[], topLevelMode:IMode, modeTransitions:ModeTransition[]): void {
+	public setTokens(map: TokensInflatorMap, tokens: LineToken[], topLevelModeId:string, modeTransitions:ModeTransition[]): void {
 		this._lineTokens = toLineTokensFromInflated(map, tokens, this._text.length);
-		this._modeTransitions = toModeTransitions(topLevelMode, modeTransitions);
+		this._modeTransitions = toModeTransitions(topLevelModeId, modeTransitions);
 	}
 
 	private _setLineTokensFromDeflated(tokens:number[]): void {
@@ -874,11 +874,11 @@ export class DefaultLineTokens implements ILineTokens {
 
 }
 
-function toModeTransitions(topLevelMode:IMode, modeTransitions:ModeTransition[]): ModeTransition[] {
+function toModeTransitions(topLevelModeId:string, modeTransitions:ModeTransition[]): ModeTransition[] {
 
 	if (!modeTransitions || modeTransitions.length === 0) {
 		return null;
-	} else if (modeTransitions.length === 1 && modeTransitions[0].startIndex === 0 && modeTransitions[0].mode === topLevelMode) {
+	} else if (modeTransitions.length === 1 && modeTransitions[0].startIndex === 0 && modeTransitions[0].modeId === topLevelModeId) {
 		return null;
 	}
 

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

@@ -17,7 +17,7 @@ import {ModelLine} from 'vs/editor/common/model/modelLine';
 import {TextModel} from 'vs/editor/common/model/textModel';
 import {WordHelper} from 'vs/editor/common/model/textModelWithTokensHelpers';
 import {TokenIterator} from 'vs/editor/common/model/tokenIterator';
-import {ILineContext, ILineTokens, IToken, IModeTransition, IMode, IState} from 'vs/editor/common/modes';
+import {ILineContext, ILineTokens, IToken, IMode, IState} from 'vs/editor/common/modes';
 import {NullMode, NullState, nullTokenize} from 'vs/editor/common/modes/nullMode';
 import {ignoreBracketsInToken} from 'vs/editor/common/modes/supports';
 import {BracketsUtils} from 'vs/editor/common/modes/supports/richEditBrackets';
@@ -131,8 +131,8 @@ class LineContext implements ILineContext {
 	private _text:string;
 	private _lineTokens:editorCommon.ILineTokens;
 
-	constructor (topLevelMode:IMode, line:ModelLine, map:TokensInflatorMap) {
-		this.modeTransitions = line.getModeTransitions(topLevelMode);
+	constructor (topLevelModeId:string, line:ModelLine, map:TokensInflatorMap) {
+		this.modeTransitions = line.getModeTransitions(topLevelModeId);
 		this._text = line.text;
 		this._lineTokens = line.getTokens(map);
 	}
@@ -404,7 +404,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 
 		this._updateTokensUntilLine(lineNumber, true);
 
-		return new LineContext(this._mode, this._lines[lineNumber - 1], this._tokensInflatorMap);
+		return new LineContext(this.getModeId(), this._lines[lineNumber - 1], this._tokensInflatorMap);
 	}
 
 	_getInternalTokens(lineNumber:number): editorCommon.ILineTokens {
@@ -416,6 +416,10 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		return this._mode;
 	}
 
+	public getModeId(): string {
+		return this.getMode().getId();
+	}
+
 	public setMode(newModeOrPromise:IMode|TPromise<IMode>): void {
 		if (!newModeOrPromise) {
 			// There's nothing to do
@@ -485,24 +489,6 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		return result;
 	}
 
-	private static _toModeTransitions(modeTransitions:IModeTransition[]): ModeTransition[] {
-		if (!modeTransitions || modeTransitions.length === 0) {
-			return [];
-		}
-		if (modeTransitions[0] instanceof ModeTransition) {
-			return <ModeTransition[]>modeTransitions;
-		}
-		let result:ModeTransition[] = [];
-		for (let i = 0, len = modeTransitions.length; i < len; i++) {
-			result[i] = new ModeTransition(modeTransitions[i].startIndex, modeTransitions[i].mode);
-		}
-		return result;
-	}
-
-	private _updateLineTokens(lineIndex:number, map:TokensInflatorMap, topLevelMode:IMode, r:ILineTokens): void {
-		this._lines[lineIndex].setTokens(map, TextModelWithTokens._toLineTokens(r.tokens), topLevelMode, TextModelWithTokens._toModeTransitions(r.modeTransitions));
-	}
-
 	private _beginBackgroundTokenization(): void {
 		if (this._shouldAutoTokenize() && this._revalidateTokensTimeout === -1) {
 			this._revalidateTokensTimeout = setTimeout(() => {
@@ -601,7 +587,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 			throw new Error('Illegal value ' + lineNumber + ' for `lineNumber`');
 		}
 		this._updateTokensUntilLine(lineNumber, true);
-		return this._lines[lineNumber - 1].getModeTransitions(this._mode);
+		return this._lines[lineNumber - 1].getModeTransitions(this.getModeId());
 	}
 
 	private _updateTokensUntilLine(lineNumber:number, emitEvents:boolean): void {
@@ -648,19 +634,16 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 			}
 
 			if (!r) {
-				r = nullTokenize(this._mode, text, this._lines[lineIndex].getState());
+				r = nullTokenize(this.getModeId(), text, this._lines[lineIndex].getState());
 			}
 			if (!r.modeTransitions) {
 				r.modeTransitions = [];
 			}
 			if (r.modeTransitions.length === 0) {
 				// Make sure there is at least the transition to the top-most mode
-				r.modeTransitions.push({
-					startIndex: 0,
-					mode: this._mode
-				});
+				r.modeTransitions.push(new ModeTransition(0, this.getModeId()));
 			}
-			this._updateLineTokens(lineIndex, this._tokensInflatorMap, this._mode, r);
+			this._lines[lineIndex].setTokens(this._tokensInflatorMap, TextModelWithTokens._toLineTokens(r.tokens), this.getModeId(), r.modeTransitions);
 
 			if (this._lines[lineIndex].isInvalid) {
 				this._lines[lineIndex].isInvalid = false;
@@ -730,7 +713,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 	}
 
 	_getWordDefinition(): RegExp {
-		return WordHelper.massageWordDefinitionOf(this._mode);
+		return WordHelper.massageWordDefinitionOf(this.getModeId());
 	}
 
 	public getWordAtPosition(position:editorCommon.IPosition): editorCommon.IWordAtPosition {
@@ -762,7 +745,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 
 	public findMatchingBracketUp(bracket:string, _position:editorCommon.IPosition): Range {
 		let position = this.validatePosition(_position);
-		let modeTransitions = this._lines[position.lineNumber - 1].getModeTransitions(this._mode);
+		let modeTransitions = this._lines[position.lineNumber - 1].getModeTransitions(this.getModeId());
 		let currentModeIndex = ModeTransition.findIndexInSegmentsArray(modeTransitions, position.column - 1);
 		let currentMode = modeTransitions[currentModeIndex];
 		let currentModeBrackets = LanguageConfigurationRegistry.getBracketsSupport(currentMode.modeId);
@@ -792,7 +775,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		let currentTokenIndex = lineTokens.findIndexOfOffset(position.column - 1);
 		let currentTokenStart = lineTokens.getTokenStartIndex(currentTokenIndex);
 
-		let modeTransitions = this._lines[lineNumber - 1].getModeTransitions(this._mode);
+		let modeTransitions = this._lines[lineNumber - 1].getModeTransitions(this.getModeId());
 		let currentModeIndex = ModeTransition.findIndexInSegmentsArray(modeTransitions, position.column - 1);
 		let currentMode = modeTransitions[currentModeIndex];
 		let currentModeBrackets = LanguageConfigurationRegistry.getBracketsSupport(currentMode.modeId);
@@ -898,7 +881,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		for (let lineNumber = position.lineNumber; lineNumber >= 1; lineNumber--) {
 			let lineTokens = this._lines[lineNumber - 1].getTokens(this._tokensInflatorMap);
 			let lineText = this._lines[lineNumber - 1].text;
-			let modeTransitions = this._lines[lineNumber - 1].getModeTransitions(this._mode);
+			let modeTransitions = this._lines[lineNumber - 1].getModeTransitions(this.getModeId());
 			let currentModeIndex = modeTransitions.length - 1;
 			let currentModeStart = modeTransitions[currentModeIndex].startIndex;
 			let currentModeId = modeTransitions[currentModeIndex].modeId;
@@ -965,7 +948,7 @@ export class TextModelWithTokens extends TextModel implements editorCommon.IToke
 		for (let lineNumber = position.lineNumber, lineCount = this.getLineCount(); lineNumber <= lineCount; lineNumber++) {
 			let lineTokens = this._lines[lineNumber - 1].getTokens(this._tokensInflatorMap);
 			let lineText = this._lines[lineNumber - 1].text;
-			let modeTransitions = this._lines[lineNumber - 1].getModeTransitions(this._mode);
+			let modeTransitions = this._lines[lineNumber - 1].getModeTransitions(this.getModeId());
 			let currentModeIndex = 0;
 			let nextModeStart = (currentModeIndex + 1 < modeTransitions.length ? modeTransitions[currentModeIndex + 1].startIndex : lineText.length + 1);
 			let currentModeId = modeTransitions[currentModeIndex].modeId;

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

@@ -5,7 +5,6 @@
 'use strict';
 
 import {IPosition, IWordAtPosition} from 'vs/editor/common/editorCommon';
-import {IMode, IModeTransition} from 'vs/editor/common/modes';
 import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 import {LanguageConfigurationRegistry} from 'vs/editor/common/modes/languageConfigurationRegistry';
 import {getWordAtText, ensureValidWordDefinition} from 'vs/editor/common/model/wordHelper';
@@ -16,32 +15,28 @@ export interface ITextSource {
 
 	getLineContent(lineNumber:number): string;
 
-	getMode(): IMode;
+	getModeId(): string;
 
 	_getLineModeTransitions(lineNumber:number): ModeTransition[];
 }
 
-export interface INonWordTokenMap {
-	[key:string]:boolean;
-}
-
 export class WordHelper {
 
-	private static _safeGetWordDefinition(mode:IMode): RegExp {
-		return LanguageConfigurationRegistry.getWordDefinition(mode.getId());
+	private static _safeGetWordDefinition(modeId:string): RegExp {
+		return LanguageConfigurationRegistry.getWordDefinition(modeId);
 	}
 
-	public static massageWordDefinitionOf(mode:IMode): RegExp {
-		return ensureValidWordDefinition(WordHelper._safeGetWordDefinition(mode));
+	public static massageWordDefinitionOf(modeId:string): RegExp {
+		return ensureValidWordDefinition(WordHelper._safeGetWordDefinition(modeId));
 	}
 
-	private static _getWordAtColumn(txt:string, column:number, modeIndex: number, modeTransitions:IModeTransition[]): IWordAtPosition {
-		var modeStartIndex = modeTransitions[modeIndex].startIndex,
-			modeEndIndex = (modeIndex + 1 < modeTransitions.length ? modeTransitions[modeIndex + 1].startIndex : txt.length),
-			mode = modeTransitions[modeIndex].mode;
+	private static _getWordAtColumn(txt:string, column:number, modeIndex: number, modeTransitions:ModeTransition[]): IWordAtPosition {
+		let modeStartIndex = modeTransitions[modeIndex].startIndex;
+		let modeEndIndex = (modeIndex + 1 < modeTransitions.length ? modeTransitions[modeIndex + 1].startIndex : txt.length);
+		let modeId = modeTransitions[modeIndex].modeId;
 
 		return getWordAtText(
-			column, WordHelper.massageWordDefinitionOf(mode),
+			column, WordHelper.massageWordDefinitionOf(modeId),
 			txt.substring(modeStartIndex, modeEndIndex), modeStartIndex
 		);
 	}
@@ -49,14 +44,14 @@ export class WordHelper {
 	public static getWordAtPosition(textSource:ITextSource, position:IPosition): IWordAtPosition {
 
 		if (!textSource._lineIsTokenized(position.lineNumber)) {
-			return getWordAtText(position.column, WordHelper.massageWordDefinitionOf(textSource.getMode()), textSource.getLineContent(position.lineNumber), 0);
+			return getWordAtText(position.column, WordHelper.massageWordDefinitionOf(textSource.getModeId()), textSource.getLineContent(position.lineNumber), 0);
 		}
 
-		var result: IWordAtPosition = null;
-		var txt = textSource.getLineContent(position.lineNumber),
-			modeTransitions = textSource._getLineModeTransitions(position.lineNumber),
-			columnIndex = position.column - 1,
-			modeIndex = ModeTransition.findIndexInSegmentsArray(modeTransitions, columnIndex);
+		let result: IWordAtPosition = null;
+		let txt = textSource.getLineContent(position.lineNumber);
+		let modeTransitions = textSource._getLineModeTransitions(position.lineNumber);
+		let columnIndex = position.column - 1;
+		let modeIndex = ModeTransition.findIndexInSegmentsArray(modeTransitions, columnIndex);
 
 		result = WordHelper._getWordAtColumn(txt, position.column, modeIndex, modeTransitions);
 

src/vs/editor/common/modes.ts

@@ -10,7 +10,7 @@ import URI from 'vs/base/common/uri';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {IFilter} from 'vs/base/common/filters';
 import * as editorCommon from 'vs/editor/common/editorCommon';
-import {ReducedModeTransition} from 'vs/editor/common/core/modeTransition';
+import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 import LanguageFeatureRegistry from 'vs/editor/common/modes/languageFeatureRegistry';
 import {CancellationToken} from 'vs/base/common/cancellation';
 import {Position} from 'vs/editor/common/core/position';
@@ -170,7 +170,7 @@ export interface IModeDescriptor {
 export interface ILineContext {
 	getLineContent(): string;
 
-	modeTransitions: ReducedModeTransition[];
+	modeTransitions: ModeTransition[];
 
 	getTokenCount(): number;
 	getTokenStartIndex(tokenIndex:number): number;
@@ -220,14 +220,6 @@ export interface IToken {
 	type:string;
 }
 
-/**
- * @internal
- */
-export interface IModeTransition {
-	startIndex: number;
-	mode: IMode;
-}
-
 /**
  * @internal
  */
@@ -235,7 +227,7 @@ export interface ILineTokens {
 	tokens: IToken[];
 	actualStopOffset: number;
 	endState: IState;
-	modeTransitions: IModeTransition[];
+	modeTransitions: ModeTransition[];
 	retokenize?:TPromise<void>;
 }
 

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

@@ -4,28 +4,29 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as modes from 'vs/editor/common/modes';
+import {IMode, IState, IStream, ITokenizationResult, ILineTokens, IToken} from 'vs/editor/common/modes';
+import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 
-export class NullState implements modes.IState {
+export class NullState implements IState {
 
-	private mode: modes.IMode;
-	private stateData: modes.IState;
+	private mode: IMode;
+	private stateData: IState;
 
-	constructor(mode: modes.IMode, stateData: modes.IState) {
+	constructor(mode: IMode, stateData: IState) {
 		this.mode = mode;
 		this.stateData = stateData;
 	}
 
-	public clone(): modes.IState {
-		var stateDataClone:modes.IState = (this.stateData ? this.stateData.clone() : null);
+	public clone(): IState {
+		let stateDataClone:IState = (this.stateData ? this.stateData.clone() : null);
 		return new NullState(this.mode, stateDataClone);
 	}
 
-	public equals(other:modes.IState): boolean {
+	public equals(other:IState): boolean {
 		if (this.mode !== other.getMode()) {
 			return false;
 		}
-		var otherStateData = other.getStateData();
+		let otherStateData = other.getStateData();
 		if (!this.stateData && !otherStateData) {
 			return true;
 		}
@@ -35,28 +36,28 @@ export class NullState implements modes.IState {
 		return false;
 	}
 
-	public getMode(): modes.IMode {
+	public getMode(): IMode {
 		return this.mode;
 	}
 
-	public tokenize(stream:modes.IStream):modes.ITokenizationResult {
+	public tokenize(stream:IStream):ITokenizationResult {
 		stream.advanceToEOS();
 		return { type:'' };
 	}
 
-	public getStateData(): modes.IState {
+	public getStateData(): IState {
 		return this.stateData;
 	}
 
-	public setStateData(stateData:modes.IState):void {
+	public setStateData(stateData:IState):void {
 		this.stateData = stateData;
 	}
 }
 
-export class NullMode implements modes.IMode {
+export class NullMode implements IMode {
 
 
-	public static ID = 'vs.editor.modes.nullMode';
+	public static ID = 'vs.editor.nullMode';
 
 	constructor() {
 	}
@@ -65,25 +66,20 @@ export class NullMode implements modes.IMode {
 		return NullMode.ID;
 	}
 
-	public toSimplifiedMode(): modes.IMode {
+	public toSimplifiedMode(): IMode {
 		return this;
 	}
 }
 
-export function nullTokenize(mode: modes.IMode, buffer:string, state: modes.IState, deltaOffset:number = 0, stopAtOffset?:number): modes.ILineTokens {
-	var tokens:modes.IToken[] = [
+export function nullTokenize(modeId: string, buffer:string, state: IState, deltaOffset:number = 0, stopAtOffset?:number): ILineTokens {
+	let tokens:IToken[] = [
 		{
 			startIndex: deltaOffset,
 			type: ''
 		}
 	];
 
-	var modeTransitions:modes.IModeTransition[] = [
-		{
-			startIndex: deltaOffset,
-			mode: mode
-		}
-	];
+	let modeTransitions:ModeTransition[] = [new ModeTransition(deltaOffset, modeId)];
 
 	return {
 		tokens: tokens,

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

@@ -6,7 +6,7 @@
 
 import {TPromise} from 'vs/base/common/winjs.base';
 import * as modes from 'vs/editor/common/modes';
-import {ModeTransition, ReducedModeTransition} from 'vs/editor/common/core/modeTransition';
+import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 
 export class Token implements modes.IToken {
 	_tokenBrand: void;
@@ -48,7 +48,7 @@ export function handleEvent<T>(context:modes.ILineContext, offset:number, runner
 		return runner(modeTransitions[0].modeId, context, offset);
 	}
 
-	let modeIndex = ReducedModeTransition.findIndexInSegmentsArray(modeTransitions, offset);
+	let modeIndex = ModeTransition.findIndexInSegmentsArray(modeTransitions, offset);
 	let nestedModeId = modeTransitions[modeIndex].modeId;
 	let modeStartIndex = modeTransitions[modeIndex].startIndex;
 
@@ -70,7 +70,7 @@ export function handleEvent<T>(context:modes.ILineContext, offset:number, runner
 
 export class FilteredLineContext implements modes.ILineContext {
 
-	public modeTransitions: ReducedModeTransition[];
+	public modeTransitions: ModeTransition[];
 
 	private _actual:modes.ILineContext;
 	private _firstTokenInModeIndex:number;
@@ -82,7 +82,7 @@ export class FilteredLineContext implements modes.ILineContext {
 			firstTokenInModeIndex:number, nextTokenAfterMode:number,
 			firstTokenCharacterOffset:number, nextCharacterAfterModeIndex:number) {
 
-		this.modeTransitions = [new ReducedModeTransition(0, modeId)];
+		this.modeTransitions = [new ModeTransition(0, modeId)];
 		this._actual = actual;
 		this._firstTokenInModeIndex = firstTokenInModeIndex;
 		this._nextTokenAfterMode = nextTokenAfterMode;

src/vs/editor/common/modes/supports/tokenizationSupport.ts

@@ -10,7 +10,7 @@ import * as modes from 'vs/editor/common/modes';
 import {LineStream} from 'vs/editor/common/modes/lineStream';
 import {NullMode, NullState, nullTokenize} from 'vs/editor/common/modes/nullMode';
 import {Token} from 'vs/editor/common/modes/supports';
-import {ModeTransition} from 'vs/editor/common/core/ModeTransition';
+import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 
 export interface ILeavingNestedModeData {
 	/**
@@ -77,10 +77,12 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 	public supportsNestedModes:boolean;
 
 	private _mode:modes.IMode;
+	private _modeId:string;
 	private _embeddedModesListeners: { [modeId:string]: IDisposable; };
 
 	constructor(mode:modes.IMode, customization:ITokenizationCustomization, supportsNestedModes:boolean) {
 		this._mode = mode;
+		this._modeId = this._mode.getId();
 		this.customization = customization;
 		this.supportsNestedModes = supportsNestedModes;
 		this._embeddedModesListeners = {};
@@ -99,7 +101,7 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 	}
 
 	public dispose() : void {
-		for (var listener in this._embeddedModesListeners) {
+		for (let listener in this._embeddedModesListeners) {
 			this._embeddedModesListeners[listener].dispose();
 			delete this._embeddedModesListeners[listener];
 		}
@@ -121,44 +123,44 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 	 * Precondition is: nestedModeState.getMode() !== this
 	 * This means we are in a nested mode when parsing starts on this line.
 	 */
-	private _nestedTokenize(buffer:string, nestedModeState:modes.IState, deltaOffset:number, stopAtOffset:number, prependTokens:modes.IToken[], prependModeTransitions:modes.IModeTransition[]):modes.ILineTokens {
-		var myStateBeforeNestedMode = nestedModeState.getStateData();
-		var leavingNestedModeData = this.getLeavingNestedModeData(buffer, myStateBeforeNestedMode);
+	private _nestedTokenize(buffer:string, nestedModeState:modes.IState, deltaOffset:number, stopAtOffset:number, prependTokens:modes.IToken[], prependModeTransitions:ModeTransition[]):modes.ILineTokens {
+		let myStateBeforeNestedMode = nestedModeState.getStateData();
+		let leavingNestedModeData = this.getLeavingNestedModeData(buffer, myStateBeforeNestedMode);
 
 		// Be sure to give every embedded mode the
 		// opportunity to leave nested mode.
 		// i.e. Don't go straight to the most nested mode
-		var stepOnceNestedState = nestedModeState;
+		let stepOnceNestedState = nestedModeState;
 		while (stepOnceNestedState.getStateData() && stepOnceNestedState.getStateData().getMode() !== this._mode) {
 			stepOnceNestedState = stepOnceNestedState.getStateData();
 		}
-		var nestedMode = stepOnceNestedState.getMode();
+		let nestedMode = stepOnceNestedState.getMode();
 
 		if (!leavingNestedModeData) {
 			// tokenization will not leave nested mode
-			var result:modes.ILineTokens;
+			let result:modes.ILineTokens;
 			if (nestedMode.tokenizationSupport) {
 				result = nestedMode.tokenizationSupport.tokenize(buffer, nestedModeState, deltaOffset, stopAtOffset);
 			} else {
 				// The nested mode doesn't have tokenization support,
 				// unfortunatelly this means we have to fake it
-				result = nullTokenize(nestedMode, buffer, nestedModeState, deltaOffset);
+				result = nullTokenize(nestedMode.getId(), buffer, nestedModeState, deltaOffset);
 			}
 			result.tokens = prependTokens.concat(result.tokens);
 			result.modeTransitions = prependModeTransitions.concat(result.modeTransitions);
 			return result;
 		}
 
-		var nestedModeBuffer = leavingNestedModeData.nestedModeBuffer;
+		let nestedModeBuffer = leavingNestedModeData.nestedModeBuffer;
 		if (nestedModeBuffer.length > 0) {
 			// Tokenize with the nested mode
-			var nestedModeLineTokens:modes.ILineTokens;
+			let nestedModeLineTokens:modes.ILineTokens;
 			if (nestedMode.tokenizationSupport) {
 				nestedModeLineTokens = nestedMode.tokenizationSupport.tokenize(nestedModeBuffer, nestedModeState, deltaOffset, stopAtOffset);
 			} else {
 				// The nested mode doesn't have tokenization support,
 				// unfortunatelly this means we have to fake it
-				nestedModeLineTokens = nullTokenize(nestedMode, nestedModeBuffer, nestedModeState, deltaOffset);
+				nestedModeLineTokens = nullTokenize(nestedMode.getId(), nestedModeBuffer, nestedModeState, deltaOffset);
 			}
 
 			// Save last state of nested mode
@@ -169,8 +171,8 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 			prependModeTransitions = prependModeTransitions.concat(nestedModeLineTokens.modeTransitions);
 		}
 
-		var bufferAfterNestedMode = leavingNestedModeData.bufferAfterNestedMode;
-		var myStateAfterNestedMode = leavingNestedModeData.stateAfterNestedMode;
+		let bufferAfterNestedMode = leavingNestedModeData.bufferAfterNestedMode;
+		let myStateAfterNestedMode = leavingNestedModeData.stateAfterNestedMode;
 		myStateAfterNestedMode.setStateData(myStateBeforeNestedMode.getStateData());
 		this.onReturningFromNestedMode(myStateAfterNestedMode, nestedModeState);
 
@@ -181,19 +183,19 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 	 * Precondition is: state.getMode() === this
 	 * This means we are in the current mode when parsing starts on this line.
 	 */
-	private _myTokenize(buffer:string, myState:modes.IState, deltaOffset:number, stopAtOffset:number, prependTokens:modes.IToken[], prependModeTransitions:modes.IModeTransition[]):modes.ILineTokens {
-		var lineStream = new LineStream(buffer);
-		var tokenResult:modes.ITokenizationResult, beforeTokenizeStreamPos:number;
-		var previousType:string = null;
-		var retokenize:TPromise<void> = null;
+	private _myTokenize(buffer:string, myState:modes.IState, deltaOffset:number, stopAtOffset:number, prependTokens:modes.IToken[], prependModeTransitions:ModeTransition[]):modes.ILineTokens {
+		let lineStream = new LineStream(buffer);
+		let tokenResult:modes.ITokenizationResult, beforeTokenizeStreamPos:number;
+		let previousType:string = null;
+		let retokenize:TPromise<void> = null;
 
 		myState = myState.clone();
-		if (prependModeTransitions.length <= 0 || prependModeTransitions[prependModeTransitions.length-1].mode !== this._mode) {
+		if (prependModeTransitions.length <= 0 || prependModeTransitions[prependModeTransitions.length-1].modeId !== this._modeId) {
 			// Avoid transitioning to the same mode (this can happen in case of empty embedded modes)
-			prependModeTransitions.push(new ModeTransition(deltaOffset,this._mode));
+			prependModeTransitions.push(new ModeTransition(deltaOffset,this._modeId));
 		}
 
-		var maxPos = Math.min(stopAtOffset - deltaOffset, buffer.length);
+		let maxPos = Math.min(stopAtOffset - deltaOffset, buffer.length);
 		while (lineStream.pos() < maxPos) {
 			beforeTokenizeStreamPos = lineStream.pos();
 
@@ -210,7 +212,7 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 					myState = tokenResult.nextState;
 				}
 				if (lineStream.pos() <= beforeTokenizeStreamPos) {
-					throw new Error('Stream did not advance while tokenizing. Mode id is ' + this._mode.getId() + ' (stuck at token type: "' + tokenResult.type + '", prepend tokens: "' + (prependTokens.map(t => t.type).join(',')) + '").');
+					throw new Error('Stream did not advance while tokenizing. Mode id is ' + this._modeId + ' (stuck at token type: "' + tokenResult.type + '", prepend tokens: "' + (prependTokens.map(t => t.type).join(',')) + '").');
 				}
 			} while (!tokenResult.type && tokenResult.type !== '');
 
@@ -221,14 +223,14 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 			previousType = tokenResult.type;
 
 			if (this.supportsNestedModes && this.enterNestedMode(myState)) {
-				var currentEmbeddedLevels = this._getEmbeddedLevel(myState);
+				let currentEmbeddedLevels = this._getEmbeddedLevel(myState);
 				if (currentEmbeddedLevels < TokenizationSupport.MAX_EMBEDDED_LEVELS) {
-					var nestedModeState = this.getNestedModeInitialState(myState);
+					let nestedModeState = this.getNestedModeInitialState(myState);
 
 					// Re-emit tokenizationSupport change events from all modes that I ever embedded
-					var embeddedMode = nestedModeState.state.getMode();
+					let embeddedMode = nestedModeState.state.getMode();
 					if (typeof embeddedMode.addSupportChangedListener === 'function' && !this._embeddedModesListeners.hasOwnProperty(embeddedMode.getId())) {
-						var emitting = false;
+						let emitting = false;
 						this._embeddedModesListeners[embeddedMode.getId()] = embeddedMode.addSupportChangedListener((e) => {
 							if (emitting) {
 								return;
@@ -246,8 +248,8 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 
 					if (!lineStream.eos()) {
 						// There is content from the embedded mode
-						var restOfBuffer = buffer.substr(lineStream.pos());
-						var result = this._nestedTokenize(restOfBuffer, nestedModeState.state, deltaOffset + lineStream.pos(), stopAtOffset, prependTokens, prependModeTransitions);
+						let restOfBuffer = buffer.substr(lineStream.pos());
+						let result = this._nestedTokenize(restOfBuffer, nestedModeState.state, deltaOffset + lineStream.pos(), stopAtOffset, prependTokens, prependModeTransitions);
 						result.retokenize = result.retokenize || nestedModeState.missingModePromise;
 						return result;
 					} else {
@@ -269,7 +271,7 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 	}
 
 	private _getEmbeddedLevel(state:modes.IState): number {
-		var result = -1;
+		let result = -1;
 		while(state) {
 			result++;
 			state = state.getStateData();
@@ -293,7 +295,7 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 	}
 
 	private static _validatedNestedMode(input:IEnteringNestedModeData): IEnteringNestedModeData {
-		var mode: modes.IMode = new NullMode(),
+		let mode: modes.IMode = new NullMode(),
 			missingModePromise: TPromise<void> = null;
 
 		if (input && input.mode) {
@@ -311,9 +313,9 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 
 	private getNestedModeInitialState(state:modes.IState): { state:modes.IState; missingModePromise:TPromise<void>; } {
 		if (this.defaults.getNestedModeInitialState) {
-			var nestedMode = TokenizationSupport._validatedNestedMode(this.getNestedMode(state));
-			var missingModePromise = nestedMode.missingModePromise;
-			var nestedModeState: modes.IState;
+			let nestedMode = TokenizationSupport._validatedNestedMode(this.getNestedMode(state));
+			let missingModePromise = nestedMode.missingModePromise;
+			let nestedModeState: modes.IState;
 
 			if (nestedMode.mode.tokenizationSupport) {
 				nestedModeState = nestedMode.mode.tokenizationSupport.getInitialState();

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

@@ -322,7 +322,7 @@ export class EditorWorkerClient extends Disposable {
 			if (!model) {
 				return null;
 			}
-			let wordDefRegExp = WordHelper.massageWordDefinitionOf(model.getMode());
+			let wordDefRegExp = WordHelper.massageWordDefinitionOf(model.getModeId());
 			let wordDef = wordDefRegExp.source;
 			let wordDefFlags = (wordDefRegExp.global ? 'g' : '') + (wordDefRegExp.ignoreCase ? 'i' : '') + (wordDefRegExp.multiline ? 'm' : '');
 			return proxy.textualSuggest(resource.toString(), position, wordDef, wordDefFlags);
@@ -335,7 +335,7 @@ export class EditorWorkerClient extends Disposable {
 			if (!model) {
 				return null;
 			}
-			let wordDefRegExp = WordHelper.massageWordDefinitionOf(model.getMode());
+			let wordDefRegExp = WordHelper.massageWordDefinitionOf(model.getModeId());
 			let wordDef = wordDefRegExp.source;
 			let wordDefFlags = (wordDefRegExp.global ? 'g' : '') + (wordDefRegExp.ignoreCase ? 'i' : '') + (wordDefRegExp.multiline ? 'm' : '');
 			return proxy.navigateValueSet(resource.toString(), range, up, wordDef, wordDefFlags);

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

@@ -24,6 +24,7 @@ import {ILanguageExtensionPoint, IValidLanguageExtensionPoint, IModeLookupResult
 import {IConfigurationService} from 'vs/platform/configuration/common/configuration';
 import {AbstractState} from 'vs/editor/common/modes/abstractState';
 import {Token} from 'vs/editor/common/modes/supports';
+import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 
 let languagesExtPoint = ExtensionsRegistry.registerExtensionPoint<ILanguageExtensionPoint[]>('languages', {
 	description: nls.localize('vscode.extension.contributes.languages', 'Contributes language declarations.'),
@@ -468,7 +469,7 @@ export class TokenizationSupport2Adapter implements modes.ITokenizationSupport {
 				tokens: tokens,
 				actualStopOffset: offsetDelta + line.length,
 				endState: new TokenizationState2Adapter(state.getMode(), actualResult.endState, state.getStateData()),
-				modeTransitions: [{ startIndex: offsetDelta, mode: state.getMode() }],
+				modeTransitions: [new ModeTransition(offsetDelta, state.getMode().getId())],
 			};
 		}
 		throw new Error('Unexpected state to tokenize with!');
@@ -547,7 +548,7 @@ export class MainThreadModeServiceImpl extends ModeServiceImpl {
 			Object.keys(configuration.files.associations).forEach(pattern => {
 				const langId = configuration.files.associations[pattern];
 				const mimetype = this.getMimeForMode(langId) || `text/x-${langId}`;
-				
+
 				mime.registerTextMime({ mime: mimetype, filepattern: pattern, userConfigured: true });
 			});
 		}

src/vs/editor/node/textMate/TMSyntax.ts

@@ -251,7 +251,7 @@ class Tokenizer {
 		if (line.length >= 20000 || depth(state.getRuleStack()) > 30) {
 			return new LineTokens(
 				[new Token(offsetDelta, '')],
-				[new ModeTransition(offsetDelta, state.getMode())],
+				[new ModeTransition(offsetDelta, state.getMode().getId())],
 				offsetDelta,
 				state
 			);
@@ -278,7 +278,7 @@ class Tokenizer {
 
 		return new LineTokens(
 			tokens,
-			[new ModeTransition(offsetDelta, freshState.getMode())],
+			[new ModeTransition(offsetDelta, freshState.getMode().getId())],
 			offsetDelta + line.length,
 			freshState
 		);

src/vs/editor/test/common/modes/tokenization.test.ts

@@ -13,6 +13,7 @@ import {handleEvent} from 'vs/editor/common/modes/supports';
 import {IEnteringNestedModeData, ILeavingNestedModeData, TokenizationSupport} from 'vs/editor/common/modes/supports/tokenizationSupport';
 import {createMockLineContext} from 'vs/editor/test/common/modesTestUtils';
 import {MockMode} from 'vs/editor/test/common/mocks/mockMode';
+import {ModeTransition} from 'vs/editor/common/core/modeTransition';
 
 export class State extends AbstractState {
 
@@ -162,12 +163,12 @@ interface ITestModeTransition {
 	startIndex:number;
 	id:string;
 }
-function assertModeTransitions(actual:modes.IModeTransition[], expected:ITestModeTransition[], message?:string) {
+function assertModeTransitions(actual:ModeTransition[], expected:ITestModeTransition[], message?:string) {
 	var massagedActual:ITestModeTransition[] = [];
 	for (var i = 0; i < actual.length; i++) {
 		massagedActual.push({
 			startIndex: actual[i].startIndex,
-			id: actual[i].mode.getId()
+			id: actual[i].modeId
 		});
 	}
 	assert.deepEqual(massagedActual, expected, message);

src/vs/editor/test/common/modesTestUtils.ts

@@ -14,11 +14,11 @@ export interface TokenText {
 }
 
 export function createLineContextFromTokenText(tokens: TokenText[]): modes.ILineContext {
-	var line = '';
-	var processedTokens: modes.IToken[] = [];
+	let line = '';
+	let processedTokens: modes.IToken[] = [];
 
-	var indexSoFar = 0;
-	for (var i = 0; i < tokens.length; ++i){
+	let indexSoFar = 0;
+	for (let i = 0; i < tokens.length; ++i){
 		processedTokens.push({ startIndex: indexSoFar, type: tokens[i].type });
 		line += tokens[i].text;
 		indexSoFar += tokens[i].text.length;
@@ -28,7 +28,7 @@ export function createLineContextFromTokenText(tokens: TokenText[]): modes.ILine
 }
 
 export function createMockLineContext(line:string, tokens:modes.ILineTokens): modes.ILineContext {
-	return new TestLineContext(line, tokens.tokens, ModeTransition.create(tokens.modeTransitions));
+	return new TestLineContext(line, tokens.tokens, tokens.modeTransitions);
 }
 
 class TestLineContext implements modes.ILineContext {
@@ -71,8 +71,8 @@ class TestLineContext implements modes.ILineContext {
 	}
 
 	public getTokenText(tokenIndex:number): string {
-		var startIndex = this._tokens[tokenIndex].startIndex;
-		var endIndex = tokenIndex + 1 < this._tokens.length ? this._tokens[tokenIndex + 1].startIndex : this._line.length;
+		let startIndex = this._tokens[tokenIndex].startIndex;
+		let endIndex = tokenIndex + 1 < this._tokens.length ? this._tokens[tokenIndex + 1].startIndex : this._line.length;
 		return this._line.substring(startIndex, endIndex);
 	}
 }
\ No newline at end of file