Remove MirrorModelEmbedded as it is no longer used

extensions/json/server/src/utils/uri.ts

@@ -329,8 +329,8 @@ export default class URI {
 			path: this.path,
 			fsPath: this.fsPath,
 			query: this.query,
-			fragment: this.fragment.replace(/URL_MARSHAL_REMOVE.*$/, ''), // TODO@Alex: implement derived resources (embedded mirror models) better
-			external: this.toString().replace(/#?URL_MARSHAL_REMOVE.*$/, ''), // TODO@Alex: implement derived resources (embedded mirror models) better
+			fragment: this.fragment,
+			external: this.toString(),
 			$mid: 1
 		};
 	}

src/vs/base/common/uri.ts

@@ -332,8 +332,8 @@ export default class URI {
 			path: this.path,
 			fsPath: this.fsPath,
 			query: this.query,
-			fragment: this.fragment.replace(/URL_MARSHAL_REMOVE.*$/, ''), // TODO@Alex: implement derived resources (embedded mirror models) better
-			external: this.toString().replace(/#?URL_MARSHAL_REMOVE.*$/, ''), // TODO@Alex: implement derived resources (embedded mirror models) better
+			fragment: this.fragment,
+			external: this.toString(),
 			$mid: 1
 		};
 	}

src/vs/editor/common/editorCommon.ts

@@ -2208,9 +2208,6 @@ export interface IRangeWithText {
  * @internal
  */
 export interface IMirrorModel extends IEventEmitter, ITokenizedModel {
-	getEmbeddedAtPosition(position:IPosition): IMirrorModel;
-	getAllEmbedded(): IMirrorModel[];
-
 	uri: URI;
 
 	getOffsetFromPosition(position:IPosition): number;

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

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {dispose} from 'vs/base/common/lifecycle';
 import URI from 'vs/base/common/uri';
 import {TPromise} from 'vs/base/common/winjs.base';
 import * as editorCommon from 'vs/editor/common/editorCommon';
@@ -12,7 +11,6 @@ import {ModelLine} from 'vs/editor/common/model/modelLine';
 import {TextModel} from 'vs/editor/common/model/textModel';
 import {TextModelWithTokens} from 'vs/editor/common/model/textModelWithTokens';
 import {IMode} from 'vs/editor/common/modes';
-import {IResourceService} from 'vs/editor/common/services/resourceService';
 import {Range} from 'vs/editor/common/core/range';
 import {Position} from 'vs/editor/common/core/position';
 
@@ -35,14 +33,6 @@ export class AbstractMirrorModel extends TextModelWithTokens implements editorCo
 		return this.getMode().getId();
 	}
 
-	public getEmbeddedAtPosition(position:editorCommon.IPosition):editorCommon.IMirrorModel {
-		return null;
-	}
-
-	public getAllEmbedded():editorCommon.IMirrorModel[] {
-		return [];
-	}
-
 	public _constructLines(rawText:editorCommon.IRawText):void {
 		super._constructLines(rawText);
 		// Force EOL to be \n
@@ -161,216 +151,17 @@ export class AbstractMirrorModel extends TextModelWithTokens implements editorCo
 	}
 }
 
-export class MirrorModelEmbedded extends AbstractMirrorModel implements editorCommon.IMirrorModel {
-
-	private _actualModel:MirrorModel;
-
-	constructor(actualModel:MirrorModel, includeRanges:editorCommon.IRange[], mode:IMode, url:URI) {
-		super(['changed'], actualModel.getVersionId(), MirrorModelEmbedded._getMirrorValueWithinRanges(actualModel, includeRanges), mode, url);
-		this._actualModel = actualModel;
-	}
-
-	private static _getMirrorValueWithinRanges(actualModel:MirrorModel, includeRanges:editorCommon.IRange[]): editorCommon.IRawText {
-
-		var	resultingText = '',
-			prevLineAdded = 1,
-			prevColumnAdded = 1,
-			i:number;
-
-		for (i = 0; i < includeRanges.length; i++) {
-			var includeRange = includeRanges[i];
-
-			resultingText += actualModel.getEmptiedValueInRange({
-				startLineNumber: prevLineAdded,
-				startColumn: prevColumnAdded,
-				endLineNumber: includeRange.startLineNumber,
-				endColumn: includeRange.startColumn
-			}, ' ');
-
-			resultingText += actualModel.getValueInRange(includeRange);
-
-			prevLineAdded = includeRange.endLineNumber;
-			prevColumnAdded = includeRange.endColumn;
-		}
-
-		var lastLineNumber = actualModel.getLineCount(),
-			lastColumn = actualModel.getLineMaxColumn(lastLineNumber);
-
-		resultingText += actualModel.getEmptiedValueInRange({
-			startLineNumber: prevLineAdded,
-			startColumn: prevColumnAdded,
-			endLineNumber: lastLineNumber,
-			endColumn: lastColumn
-		}, ' ');
-
-		let actualModelOptions = actualModel.getOptions();
-		return TextModel.toRawText(resultingText, {
-			tabSize: actualModelOptions.tabSize,
-			insertSpaces: actualModelOptions.insertSpaces,
-			detectIndentation: false,
-			defaultEOL: actualModelOptions.defaultEOL,
-			trimAutoWhitespace: actualModelOptions.trimAutoWhitespace
-		});
-	}
-
-	public setIncludedRanges(newIncludedRanges:editorCommon.IRange[]): void {
-		var prevVersionId = this.getVersionId();
-
-		// Force recreating of line starts (when used)
-		this._constructLines(MirrorModelEmbedded._getMirrorValueWithinRanges(this._actualModel, newIncludedRanges));
-		this._resetTokenizationState();
-
-		this._setVersionId(prevVersionId + 1);
-
-		this.emit('changed', {});
-	}
-
-}
-
-class EmbeddedModeRange {
-	public mode: IMode;
-	public ranges: editorCommon.IRange[];
-
-	public constructor(mode: IMode) {
-		this.mode = mode;
-		this.ranges = [];
-	}
-}
-
 export function createTestMirrorModelFromString(value:string, mode:IMode = null, associatedResource?:URI): MirrorModel {
-	return new MirrorModel(null, 0, TextModel.toRawText(value, TextModel.DEFAULT_CREATION_OPTIONS), mode, associatedResource);
+	return new MirrorModel(0, TextModel.toRawText(value, TextModel.DEFAULT_CREATION_OPTIONS), mode, associatedResource);
 }
 
 export class MirrorModel extends AbstractMirrorModel implements editorCommon.IMirrorModel {
 
-	private _resourceService: IResourceService;
-	private _embeddedModels: {[modeId:string]:MirrorModelEmbedded;};
-
-	constructor(resourceService:IResourceService, versionId:number, value:editorCommon.IRawText, mode:IMode|TPromise<IMode>, associatedResource?:URI) {
+	constructor(versionId:number, value:editorCommon.IRawText, mode:IMode|TPromise<IMode>, associatedResource?:URI) {
 		super(['changed'], versionId, value, mode, associatedResource);
-
-		this._resourceService = resourceService;
-		this._embeddedModels = {};
-		this._updateEmbeddedModels();
-	}
-
-	public getEmbeddedAtPosition(position:editorCommon.IPosition):editorCommon.IMirrorModel {
-		var modeIdAtPosition = this.getModeIdAtPosition(position.lineNumber, position.column);
-		if (this._embeddedModels.hasOwnProperty(modeIdAtPosition)) {
-			return this._embeddedModels[modeIdAtPosition];
-		}
-		return null;
-	}
-
-	public getAllEmbedded():editorCommon.IMirrorModel[] {
-		return Object.keys(this._embeddedModels).map((embeddedModeId) => this._embeddedModels[embeddedModeId]);
-	}
-
-	public dispose(): void {
-		super.dispose();
-		var embeddedModels = Object.keys(this._embeddedModels).map((modeId) => this._embeddedModels[modeId]);
-		embeddedModels.forEach((embeddedModel) => this._resourceService.remove(embeddedModel.uri));
-		dispose(embeddedModels);
-		this._embeddedModels = {};
-	}
-
-	public setMode(newModeOrPromise:IMode|TPromise<IMode>): void {
-		super.setMode(newModeOrPromise);
-		this._updateEmbeddedModels();
-	}
-
-	private static _getModesRanges(model: editorCommon.IMirrorModel): {[modeId:string]:EmbeddedModeRange} {
-		var encounteredModesRanges:{[modeId:string]:EmbeddedModeRange} = {};
-
-		var getOrCreateEmbeddedModeRange = (modeId:string, mode:IMode) => {
-			if (!encounteredModesRanges.hasOwnProperty(modeId)) {
-				encounteredModesRanges[modeId] = new EmbeddedModeRange(mode);
-			}
-			return encounteredModesRanges[modeId];
-		};
-
-		var lineCount = model.getLineCount();
-		var currentModeId = model.getMode().getId();
-		var currentMode = model.getMode();
-		var currentStartLineNumber = 1, currentStartColumn = 1;
-
-		for (var lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
-			var modeTransitions = model._getLineModeTransitions(lineNumber);
-
-			for (var i = 0; i < modeTransitions.length; i++) {
-				var modeTransition = modeTransitions[i];
-				if (modeTransition.modeId !== currentModeId) {
-
-					var modeRange = getOrCreateEmbeddedModeRange(currentModeId, currentMode);
-					modeRange.ranges.push({
-						startLineNumber: currentStartLineNumber,
-						startColumn: currentStartColumn,
-						endLineNumber: lineNumber,
-						endColumn: modeTransition.startIndex + 1
-					});
-
-					currentModeId = modeTransition.modeId;
-					currentMode = modeTransition.mode;
-					currentStartLineNumber = lineNumber;
-					currentStartColumn = modeTransition.startIndex + 1;
-				}
-			}
-		}
-
-		var lastLineNumber = lineCount;
-		var lastColumn = model.getLineMaxColumn(lastLineNumber);
-
-		if (currentStartLineNumber !== lastLineNumber || currentStartColumn !== lastColumn) {
-			var modeRange = getOrCreateEmbeddedModeRange(currentModeId, currentMode);
-			modeRange.ranges.push({
-				startLineNumber: currentStartLineNumber,
-				startColumn: currentStartColumn,
-				endLineNumber: lastLineNumber,
-				endColumn: lastColumn
-			});
-		}
-
-		return encounteredModesRanges;
-	}
-
-	private _updateEmbeddedModels(): boolean {
-		if (!this._resourceService || !this.getMode().tokenizationSupport || !this.getMode().tokenizationSupport.shouldGenerateEmbeddedModels) {
-			return false;
-		}
-
-		var newModesRanges = MirrorModel._getModesRanges(this);
-
-		// Empty out embedded models that have disappeared
-		var oldNestedModesIds = Object.keys(this._embeddedModels);
-		for (var i = 0; i < oldNestedModesIds.length; i++) {
-			var oldNestedModeId = oldNestedModesIds[i];
-			if (!newModesRanges.hasOwnProperty(oldNestedModeId)) {
-				this._embeddedModels[oldNestedModeId].setIncludedRanges([{
-					startLineNumber: 1,
-					startColumn: 1,
-					endLineNumber: 1,
-					endColumn: 1
-				}]);
-			}
-		}
-
-		var newNestedModesIds = Object.keys(newModesRanges);
-		for (var i = 0; i < newNestedModesIds.length; i++) {
-			var newNestedModeId = newNestedModesIds[i];
-			if (this._embeddedModels.hasOwnProperty(newNestedModeId)) {
-				this._embeddedModels[newNestedModeId].setIncludedRanges(newModesRanges[newNestedModeId].ranges);
-			} else {
-				// TODO@Alex: implement derived resources (embedded mirror models) better
-				var embeddedModelUrl = this.uri.with({ fragment: this.uri.fragment + 'URL_MARSHAL_REMOVE' + newNestedModeId });
-				this._embeddedModels[newNestedModeId] = new MirrorModelEmbedded(this, newModesRanges[newNestedModeId].ranges, newModesRanges[newNestedModeId].mode, embeddedModelUrl);
-				this._resourceService.insert(this._embeddedModels[newNestedModeId].uri, this._embeddedModels[newNestedModeId]);
-			}
-		}
-
-		return false;
 	}
 
-	public onEvents(events:IMirrorModelEvents) : boolean {
+	public onEvents(events:IMirrorModelEvents) : void {
 		let changed = false;
 		for (let i = 0, len = events.contentChanged.length; i < len; i++) {
 			let contentChangedEvent = events.contentChanged[i];
@@ -399,12 +190,9 @@ export class MirrorModel extends AbstractMirrorModel implements editorCommon.IMi
 			}
 		}
 
-		var shouldFlushMarkers = false;
 		if (changed) {
 			this.emit('changed', {});
-			shouldFlushMarkers = this._updateEmbeddedModels();
 		}
-		return shouldFlushMarkers;
 	}
 
 	private _onLinesFlushed(e:editorCommon.IModelContentChangedFlushEvent): void {

src/vs/editor/common/modes.ts

@@ -256,8 +256,6 @@ export interface ILineTokens {
  */
 export interface ITokenizationSupport {
 
-	shouldGenerateEmbeddedModels: boolean;
-
 	getInitialState():IState;
 
 	// add offsetDelta to each of the returned indices

src/vs/editor/common/modes/monarch/monarchLexer.ts

@@ -444,5 +444,5 @@ export function createTokenizationSupport(modeService:IModeService, mode:modes.I
 				stateAfterNestedMode: mstate
 			};
 		}
-	}, lexer.usesEmbedded, false);
+	}, lexer.usesEmbedded);
 }

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

@@ -73,13 +73,12 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 		onReturningFromNestedMode: boolean;
 	};
 
-	public shouldGenerateEmbeddedModels:boolean;
 	public supportsNestedModes:boolean;
 
 	private _mode:modes.IMode;
 	private _embeddedModesListeners: { [modeId:string]: IDisposable; };
 
-	constructor(mode:modes.IMode, customization:ITokenizationCustomization, supportsNestedModes:boolean, shouldGenerateEmbeddedModels:boolean) {
+	constructor(mode:modes.IMode, customization:ITokenizationCustomization, supportsNestedModes:boolean) {
 		this._mode = mode;
 		this.customization = customization;
 		this.supportsNestedModes = supportsNestedModes;
@@ -89,7 +88,6 @@ export class TokenizationSupport implements modes.ITokenizationSupport, IDisposa
 				throw new Error('Cannot be a mode with nested modes unless I can emit a tokenizationSupport changed event!');
 			}
 		}
-		this.shouldGenerateEmbeddedModels = shouldGenerateEmbeddedModels;
 		this.defaults = {
 			enterNestedMode: !isFunction(customization.enterNestedMode),
 			getNestedMode: !isFunction(customization.getNestedMode),

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

@@ -22,7 +22,6 @@ function _getSafeTokenizationSupport(mode: IMode): ITokenizationSupport {
 		return mode.tokenizationSupport;
 	}
 	return {
-		shouldGenerateEmbeddedModels: false,
 		getInitialState: () => new NullState(null, null),
 		tokenize: (buffer:string, state: IState, deltaOffset:number = 0, stopAtOffset?:number) => nullTokenize(null, buffer, state, deltaOffset, stopAtOffset)
 	};

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

@@ -478,8 +478,6 @@ export class TokenizationState2Adapter implements modes.IState {
 
 export class TokenizationSupport2Adapter implements modes.ITokenizationSupport {
 
-	public shouldGenerateEmbeddedModels = false;
-
 	private _mode: modes.IMode;
 	private _actual: modes.TokensProvider;
 

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

@@ -578,7 +578,7 @@ export class ModelServiceWorkerHelper {
 
 	public $_acceptNewModel(data: IRawModelData): TPromise<void> {
 		// Create & insert the mirror model eagerly in the resource service
-		let mirrorModel = new MirrorModel(this._resourceService, data.versionId, data.value, null, data.url);
+		let mirrorModel = new MirrorModel(data.versionId, data.value, null, data.url);
 		this._resourceService.insert(mirrorModel.uri, mirrorModel);
 
 		// Block worker execution until the mode is instantiated

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

@@ -150,7 +150,6 @@ export class MainProcessTextMateSyntax {
 function createTokenizationSupport(mode: IMode, grammar: IGrammar): ITokenizationSupport {
 	var tokenizer = new Tokenizer(mode.getId(), grammar);
 	return {
-		shouldGenerateEmbeddedModels: false,
 		getInitialState: () => new TMState(mode, null, null),
 		tokenize: (line, state, offsetDelta?, stopAtOffset?) => tokenizer.tokenize(line, <TMState> state, offsetDelta, stopAtOffset)
 	};

src/vs/editor/test/common/mocks/mockMode.ts

@@ -60,6 +60,6 @@ export class MockTokenizingMode extends MockMode {
 
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new StateForMockTokenizingMode(this, tokenType)
-		}, false, false);
+		}, false);
 	}
 }

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

@@ -88,7 +88,7 @@ export function assertSyncedModels(text:string, callback:(model:EditableTextMode
 		assertLineMapping(model, 'model');
 	}
 
-	var mirrorModel1 = new MirrorModel(null, model.getVersionId(), model.toRawText(), null);
+	var mirrorModel1 = new MirrorModel(model.getVersionId(), model.toRawText(), null);
 	assertLineMapping(mirrorModel1, 'mirrorModel1');
 	var mirrorModel1PrevVersionId = model.getVersionId();
 

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

@@ -80,6 +80,6 @@ class Mode extends MockMode {
 		super();
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new State(this)
-		}, false, false);
+		}, false);
 	}
 }

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

@@ -37,7 +37,7 @@ export class Mode extends MockMode {
 		super();
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new State(this)
-		}, false, false);
+		}, false);
 	}
 }
 
@@ -101,7 +101,7 @@ export class SwitchingMode extends MockMode {
 	constructor(id:string, descriptor:IModeSwitchingDescriptor) {
 		super(id);
 		this._switchingModeDescriptor = descriptor;
-		this.tokenizationSupport = new TokenizationSupport(this, this, true, false);
+		this.tokenizationSupport = new TokenizationSupport(this, this, true);
 	}
 
 	setTokenizationSupport<T>(callback:(mode:modes.IMode)=>T): IDisposable {

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

@@ -38,7 +38,7 @@ export class CommentMode extends MockMode {
 		super();
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new CommentState(this, 0)
-		}, false, false);
+		}, false);
 
 		LanguageConfigurationRegistry.register(this.getId(), {
 			comments: commentsConfig
@@ -93,7 +93,7 @@ export class ModelMode1 extends MockMode {
 		this.calledFor = [];
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new ModelState1(this)
-		}, false, false);
+		}, false);
 	}
 }
 
@@ -134,7 +134,7 @@ export class ModelMode2 extends MockMode {
 		this.calledFor = null;
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new ModelState2(this, '')
-		}, false, false);
+		}, false);
 	}
 }
 
@@ -193,6 +193,6 @@ export class NMode extends MockMode {
 		this.n = n;
 		this.tokenizationSupport = new TokenizationSupport(this, {
 			getInitialState: () => new NState(this, this.n)
-		}, false, false);
+		}, false);
 	}
 }
\ No newline at end of file

src/vs/languages/handlebars/common/handlebars.ts

@@ -160,18 +160,6 @@ export class HandlebarsMode extends htmlMode.HTMLMode<htmlWorker.HTMLWorker> {
 	}
 
 	protected _registerSupports(): void {
-		modes.HoverProviderRegistry.register(this.getId(), {
-			provideHover: (model, position, token): Thenable<modes.Hover> => {
-				return wireCancellationToken(token, this._provideHover(model.uri, position));
-			}
-		}, true);
-
-		modes.ReferenceProviderRegistry.register(this.getId(), {
-			provideReferences: (model, position, context, token): Thenable<modes.Location[]> => {
-				return wireCancellationToken(token, this._provideReferences(model.uri, position, context));
-			}
-		}, true);
-
 		modes.SuggestRegistry.register(this.getId(), {
 			triggerCharacters: ['.', ':', '<', '"', '=', '/'],
 			shouldAutotriggerSuggest: true,

src/vs/languages/html/common/html.ts

@@ -346,7 +346,7 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 		this.modeService = modeService;
 		this.threadService = threadService;
 
-		this.tokenizationSupport = new TokenizationSupport(this, this, true, true);
+		this.tokenizationSupport = new TokenizationSupport(this, this, true);
 		this.configSupport = this;
 
 		this._registerSupports();
@@ -364,18 +364,6 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 			throw new Error('This method must be overwritten!');
 		}
 
-		modes.HoverProviderRegistry.register(this.getId(), {
-			provideHover: (model, position, token): Thenable<modes.Hover> => {
-				return wireCancellationToken(token, this._provideHover(model.uri, position));
-			}
-		}, true);
-
-		modes.ReferenceProviderRegistry.register(this.getId(), {
-			provideReferences: (model, position, context, token): Thenable<modes.Location[]> => {
-				return wireCancellationToken(token, this._provideReferences(model.uri, position, context));
-			}
-		}, true);
-
 		modes.SuggestRegistry.register(this.getId(), {
 			triggerCharacters: ['.', ':', '<', '"', '=', '/'],
 			shouldAutotriggerSuggest: true,
@@ -492,16 +480,6 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends AbstractMode impl
 		return this._worker((w) => w.provideDocumentRangeFormattingEdits(resource, range, options));
 	}
 
-	static $_provideHover = OneWorkerAttr(HTMLMode, HTMLMode.prototype._provideHover);
-	protected _provideHover(resource:URI, position:editorCommon.IPosition): winjs.TPromise<modes.Hover> {
-		return this._worker((w) => w.provideHover(resource, position));
-	}
-
-	static $_provideReferences = OneWorkerAttr(HTMLMode, HTMLMode.prototype._provideReferences);
-	protected _provideReferences(resource:URI, position:editorCommon.IPosition, context: modes.ReferenceContext): winjs.TPromise<modes.Location[]> {
-		return this._worker((w) => w.provideReferences(resource, position));
-	}
-
 	static $_provideDocumentHighlights = OneWorkerAttr(HTMLMode, HTMLMode.prototype._provideDocumentHighlights);
 	protected _provideDocumentHighlights(resource:URI, position:editorCommon.IPosition, strict:boolean = false): winjs.TPromise<modes.DocumentHighlight[]> {
 		return this._worker((w) => w.provideDocumentHighlights(resource, position, strict));

src/vs/languages/html/common/htmlWorker.ts

@@ -12,7 +12,6 @@ import network = require('vs/base/common/network');
 import editorCommon = require('vs/editor/common/editorCommon');
 import modes = require('vs/editor/common/modes');
 import strings = require('vs/base/common/strings');
-import {Position} from 'vs/editor/common/core/position';
 import {IWorkspaceContextService} from 'vs/platform/workspace/common/workspace';
 import {IMarkerService} from 'vs/platform/markers/common/markers';
 import {IResourceService} from 'vs/editor/common/services/resourceService';
@@ -21,9 +20,6 @@ import {isTag, DELIM_END, DELIM_START, DELIM_ASSIGN, ATTRIB_NAME, ATTRIB_VALUE}
 import {isEmptyElement} from 'vs/languages/html/common/htmlEmptyTagsShared';
 import {filterSuggestions} from 'vs/editor/common/modes/supports/suggestSupport';
 import paths = require('vs/base/common/paths');
-import {getHover} from 'vs/editor/contrib/hover/common/hover';
-import {provideReferences} from 'vs/editor/contrib/referenceSearch/common/referenceSearch';
-import {provideCompletionItems} from 'vs/editor/contrib/suggest/common/suggest';
 
 enum LinkDetectionState {
 	LOOKING_FOR_HREF_OR_SRC = 1,
@@ -122,52 +118,6 @@ export class HTMLWorker {
 		return winjs.TPromise.as(null);
 	}
 
-	_delegateToModeAtPosition<T>(resource:URI, position:editorCommon.IPosition, callback:(isEmbeddedMode:boolean, model:editorCommon.IMirrorModel) => T): T {
-		let model = this.resourceService.get(resource);
-
-		if (!model) {
-			return null;
-		}
-
-		let modelAtPosition = model.getEmbeddedAtPosition(position);
-
-		if (!modelAtPosition) {
-			return callback(false, model);
-		}
-
-		let modeAtPosition = modelAtPosition.getMode();
-
-		return callback(modeAtPosition.getId() !== this._modeId, modelAtPosition);
-	}
-
-	_delegateToAllModes<T>(resource:URI, callback:(models:editorCommon.IMirrorModel[]) => T): T {
-		let model = this.resourceService.get(resource);
-
-		if (!model) {
-			return null;
-		}
-
-		return callback(model.getAllEmbedded());
-	}
-
-	public provideHover(resource:URI, position:editorCommon.IPosition): winjs.TPromise<modes.Hover> {
-		return this._delegateToModeAtPosition(resource, position, (isEmbeddedMode, model) => {
-			if (isEmbeddedMode) {
-				return getHover(model, Position.lift(position)).then((r) => {
-					return (r.length > 0 ? r[0] : null);
-				});
-			}
-		});
-	}
-
-	public provideReferences(resource:URI, position:editorCommon.IPosition): winjs.TPromise<modes.Location[]> {
-		return this._delegateToModeAtPosition(resource, position, (isEmbeddedMode, model) => {
-			if (isEmbeddedMode) {
-				return provideReferences(model, Position.lift(position));
-			}
-		});
-	}
-
 	private findMatchingOpenTag(scanner: IHTMLScanner) : string {
 		let closedTags : { [name:string]: number } = {};
 		let tagClosed = false;
@@ -322,13 +272,13 @@ export class HTMLWorker {
 	}
 
 	public provideCompletionItems(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult[]> {
-		return this._delegateToModeAtPosition(resource, position, (isEmbeddedMode, model) => {
-			if (isEmbeddedMode) {
-				return provideCompletionItems(model, Position.lift(position));
-			}
-
+		let model = this.resourceService.get(resource);
+		let modeIdAtPosition = model.getModeIdAtPosition(position.lineNumber, position.column);
+		if (modeIdAtPosition === this._modeId) {
 			return this.suggestHTML(resource, position);
-		});
+		} else {
+			return winjs.TPromise.as([]);
+		}
 	}
 
 	private suggestHTML(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult[]> {

src/vs/languages/json/common/features/tokenization.ts

@@ -10,7 +10,6 @@ import jsonTokenTypes = require('vs/languages/json/common/features/jsonTokenType
 
 export function createTokenizationSupport(mode:Modes.IMode, supportComments:boolean):Modes.ITokenizationSupport {
 	return {
-		shouldGenerateEmbeddedModels: false,
 		getInitialState: () => new JSONState(mode, null, null, false),
 		tokenize: (line, state, offsetDelta?, stopAtOffset?) => tokenize(mode, supportComments, line, <JSONState> state, offsetDelta, stopAtOffset)
 	};

src/vs/languages/php/common/php.ts

@@ -488,7 +488,7 @@ export class PHPMode extends AbstractMode implements ITokenizationCustomization
 		super(descriptor.id);
 		this.modeService = modeService;
 
-		this.tokenizationSupport = new TokenizationSupport(this, this, true, false);
+		this.tokenizationSupport = new TokenizationSupport(this, this, true);
 
 		LanguageConfigurationRegistry.register(this.getId(), PHPMode.LANG_CONFIG);
 

src/vs/languages/razor/common/razor.ts

@@ -108,18 +108,6 @@ export class RAZORMode extends htmlMode.HTMLMode<RAZORWorker> {
 	}
 
 	protected _registerSupports(): void {
-		modes.HoverProviderRegistry.register(this.getId(), {
-			provideHover: (model, position, token): Thenable<modes.Hover> => {
-				return wireCancellationToken(token, this._provideHover(model.uri, position));
-			}
-		}, true);
-
-		modes.ReferenceProviderRegistry.register(this.getId(), {
-			provideReferences: (model, position, context, token): Thenable<modes.Location[]> => {
-				return wireCancellationToken(token, this._provideReferences(model.uri, position, context));
-			}
-		}, true);
-
 		modes.SuggestRegistry.register(this.getId(), {
 			triggerCharacters: ['.', ':', '<', '"', '=', '/'],
 			shouldAutotriggerSuggest: true,