Merge pull request #5443 from Microsoft/joh/inst

InstantiationService debt

src/vs/editor/common/commonCodeEditor.ts

@@ -13,6 +13,7 @@ import * as objects from 'vs/base/common/objects';
 import * as timer from 'vs/base/common/timer';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {IKeybindingContextKey, IKeybindingScopeLocation, IKeybindingService} from 'vs/platform/keybinding/common/keybindingService';
 import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
 import {CommonEditorConfiguration} from 'vs/editor/common/config/commonEditorConfig';
@@ -114,9 +115,7 @@ export abstract class CommonCodeEditor extends EventEmitter implements IActionPr
 		this.forcedWidgetFocusCount = 0;
 
 		this._telemetryService = telemetryService;
-		this._instantiationService = instantiationService.createChild({
-			keybindingService: this._keybindingService
-		});
+		this._instantiationService = instantiationService.createChild(new ServiceCollection([IKeybindingService, this._keybindingService]));
 
 		this._attachModel(null);
 

src/vs/editor/common/worker/editorWorkerServer.ts

@@ -12,18 +12,27 @@ import Severity from 'vs/base/common/severity';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {WorkerServer} from 'vs/base/common/worker/workerServer';
 import {EventService} from 'vs/platform/event/common/eventService';
+import {IEventService} from 'vs/platform/event/common/event';
 import {AbstractExtensionService, ActivatedExtension} from 'vs/platform/extensions/common/abstractExtensionService';
-import {IExtensionDescription} from 'vs/platform/extensions/common/extensions';
-import {createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import {IExtensionDescription, IExtensionService} from 'vs/platform/extensions/common/extensions';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
+import {InstantiationService} from 'vs/platform/instantiation/common/instantiationService';
 import {SecondaryMarkerService} from 'vs/platform/markers/common/markerService';
+import {IMarkerService} from 'vs/platform/markers/common/markers';
 import {BaseRequestService} from 'vs/platform/request/common/baseRequestService';
+import {IRequestService} from 'vs/platform/request/common/request';
 import {RemoteTelemetryService} from 'vs/platform/telemetry/common/remoteTelemetryService';
+import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
 import {WorkerThreadService} from 'vs/platform/thread/common/workerThreadService';
+import {IThreadService} from 'vs/platform/thread/common/thread';
 import {BaseWorkspaceContextService} from 'vs/platform/workspace/common/baseWorkspaceContextService';
-import {IWorkspace} from 'vs/platform/workspace/common/workspace';
+import {IWorkspaceContextService, IWorkspace} from 'vs/platform/workspace/common/workspace';
 import {ModeServiceImpl, ModeServiceWorkerHelper} from 'vs/editor/common/services/modeServiceImpl';
+import {IModeService} from 'vs/editor/common/services/modeService';
 import {ModelServiceWorkerHelper} from 'vs/editor/common/services/modelServiceImpl';
 import {ResourceService} from 'vs/editor/common/services/resourceServiceImpl';
+import {IResourceService} from 'vs/editor/common/services/resourceService';
+
 
 export interface IInitData {
 	contextService: {
@@ -86,35 +95,29 @@ export class EditorWorkerServer {
 
 	public initialize(mainThread:WorkerServer, complete:ICallback, error:ICallback, progress:ICallback, initData:IInitData):void {
 
-		var extensionService = new WorkerExtensionService();
-
-		var contextService = new BaseWorkspaceContextService(initData.contextService.workspace, initData.contextService.configuration, initData.contextService.options);
+		const services = new ServiceCollection();
 
+		const extensionService = new WorkerExtensionService();
+		const contextService = new BaseWorkspaceContextService(initData.contextService.workspace, initData.contextService.configuration, initData.contextService.options);
 		this.threadService = new WorkerThreadService(mainThread.getRemoteCom());
-		this.threadService.setInstantiationService(createInstantiationService({ threadService: this.threadService }));
-
-		var telemetryServiceInstance = new RemoteTelemetryService('workerTelemetry', this.threadService);
-
-		var resourceService = new ResourceService();
-		var markerService = new SecondaryMarkerService(this.threadService);
-
-		var modeService = new ModeServiceImpl(this.threadService, extensionService);
-
-		var requestService = new BaseRequestService(contextService, telemetryServiceInstance);
-
-		var _services : any = {
-			threadService: this.threadService,
-			extensionService: extensionService,
-			modeService: modeService,
-			contextService: contextService,
-			eventService: new EventService(),
-			resourceService: resourceService,
-			markerService: markerService,
-			telemetryService: telemetryServiceInstance,
-			requestService: requestService
-		};
-
-		var instantiationService = createInstantiationService(_services);
+		this.threadService.setInstantiationService(new InstantiationService(new ServiceCollection([IThreadService, this.threadService])));
+		const telemetryServiceInstance = new RemoteTelemetryService('workerTelemetry', this.threadService);
+		const resourceService = new ResourceService();
+		const markerService = new SecondaryMarkerService(this.threadService);
+		const modeService = new ModeServiceImpl(this.threadService, extensionService);
+		const requestService = new BaseRequestService(contextService, telemetryServiceInstance);
+
+		services.set(IExtensionService, extensionService);
+		services.set(IThreadService, this.threadService);
+		services.set(IModeService, modeService);
+		services.set(IWorkspaceContextService, contextService);
+		services.set(IEventService, new EventService());
+		services.set(IResourceService, resourceService);
+		services.set(IMarkerService, markerService);
+		services.set(ITelemetryService, telemetryServiceInstance);
+		services.set(IRequestService, requestService);
+
+		const instantiationService = new InstantiationService(services);
 		this.threadService.setInstantiationService(instantiationService);
 
 		// Instantiate thread actors

src/vs/editor/contrib/referenceSearch/browser/referenceSearchWidget.ts

@@ -26,6 +26,7 @@ import {DefaultController, LegacyRenderer} from 'vs/base/parts/tree/browser/tree
 import {Tree} from 'vs/base/parts/tree/browser/treeImpl';
 import {IEditorService} from 'vs/platform/editor/common/editor';
 import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {IKeybindingService} from 'vs/platform/keybinding/common/keybindingService';
 import {IWorkspaceContextService} from 'vs/platform/workspace/common/workspace';
 import {DefaultConfig} from 'vs/editor/common/config/defaultConfig';
@@ -34,7 +35,7 @@ import * as editorCommon from 'vs/editor/common/editorCommon';
 import {Model} from 'vs/editor/common/model/model';
 import {ICodeEditor, IMouseTarget} from 'vs/editor/browser/editorBrowser';
 import {EmbeddedCodeEditorWidget} from 'vs/editor/browser/widget/embeddedCodeEditorWidget';
-import {PeekViewWidget} from 'vs/editor/contrib/zoneWidget/browser/peekViewWidget';
+import {PeekViewWidget, IPeekViewService} from 'vs/editor/contrib/zoneWidget/browser/peekViewWidget';
 import {EventType, FileReferences, OneReference, ReferencesModel} from './referenceSearchModel';
 
 class DecorationsManager implements IDisposable {
@@ -398,7 +399,7 @@ export class ReferenceWidget extends PeekViewWidget {
 		super(editor, keybindingService, ReferenceWidget.INNER_EDITOR_CONTEXT_KEY, { frameColor: '#007ACC', showFrame: false, showArrow: true });
 		this.editorService = editorService;
 		this.contextService = contextService;
-		this.instantiationService = instantiationService.createChild({ peekViewService: this });
+		this.instantiationService = instantiationService.createChild(new ServiceCollection([IPeekViewService, this]));
 
 		this.callOnModel = [];
 

src/vs/platform/instantiation/common/instantiation.ts

@@ -5,27 +5,22 @@
 'use strict';
 
 import {TPromise} from 'vs/base/common/winjs.base';
+import ServiceCollection from './serviceCollection';
 import * as descriptors from './descriptors';
 
-// ----------------------- internal util -----------------------
+// ------ internal util
 
 export namespace _util {
 
 	export const DI_TARGET = '$di$target';
 	export const DI_DEPENDENCIES = '$di$dependencies';
-	export const DI_PROVIDES = '$di$provides_service';
 
-	export function getServiceId(id: ServiceIdentifier<any>): string {
-		return id[DI_PROVIDES];
-	}
-
-	export function getServiceDependencies(ctor: any): { serviceId: string, index: number }[] {
-		return ctor[DI_DEPENDENCIES];
+	export function getServiceDependencies(ctor: any): { id: ServiceIdentifier<any>, index: number }[] {
+		return ctor[DI_DEPENDENCIES] || [];
 	}
 }
 
-// ----------------------- interfaces -----------------------
-
+// --- interfaces ------
 
 export interface IConstructorSignature0<T> {
 	new (...services: { serviceId: ServiceIdentifier<any>; }[]): T;
@@ -103,7 +98,6 @@ export interface IFunctionSignature8<A1, A2, A3, A4, A5, A6, A7, A8, R> {
 	(accessor: ServicesAccessor, first: A1, second: A2, third: A3, forth: A4, fifth: A5, sixth: A6, seventh: A7, eigth: A8): R;
 }
 
-
 export var IInstantiationService = createDecorator<IInstantiationService>('instantiationService');
 
 export interface IInstantiationService {
@@ -175,12 +169,7 @@ export interface IInstantiationService {
 	 * Creates a child of this service which inherts all current services
 	 * and adds/overwrites the given services
 	 */
-	createChild(services: any): IInstantiationService;
-
-	/**
-	 * Registers a new service to this instantation service.
-	 */
-	registerService(name: string, service: any): void;
+	createChild(services: ServiceCollection): IInstantiationService;
 
 	/**
 	 * Adds a service or a descriptor to the collection of services and
@@ -204,29 +193,21 @@ export interface ServiceIdentifier<T> {
  */
 export function createDecorator<T>(serviceId: string): { (...args: any[]): void; type: T; } {
 
-	let ret = function(target: any, key: string, index: number): any {
+	let id = function(target: any, key: string, index: number): any {
 
 		if (arguments.length !== 3) {
 			throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
 		}
 
 		if (target[_util.DI_TARGET] === target) {
-			target[_util.DI_DEPENDENCIES].push({ serviceId, index });
+			target[_util.DI_DEPENDENCIES].push({ id, index });
 		} else {
-			target[_util.DI_DEPENDENCIES] = [{ serviceId, index }];
+			target[_util.DI_DEPENDENCIES] = [{ id, index }];
 			target[_util.DI_TARGET] = target;
 		}
 	};
 
-	ret[_util.DI_PROVIDES] = serviceId;
-	// ret['type'] = undefined;
-	return <any>ret;
-}
+	id.toString = () => serviceId;
 
-/**
- * A service context which can be used to retrieve services
- * given a valid service identifer is being presented
- */
-export interface Context {
-	get<T>(id: ServiceIdentifier<T>): T;
+	return <any>id;
 }

src/vs/platform/instantiation/common/serviceCollection.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {binarySearch} from 'vs/base/common/arrays';
+import {ServiceIdentifier} from 'vs/platform/instantiation/common/instantiation';
+import {SyncDescriptor} from './descriptors';
+
+type Entry = [ServiceIdentifier<any>, any];
+
+export default class ServiceCollection {
+
+	private _entries: Entry[] = [];
+
+	constructor(...entries:[ServiceIdentifier<any>, any][]) {
+		for (let entry of entries) {
+			this.set(entry[0], entry[1]);
+		}
+	}
+
+	set<T>(id: ServiceIdentifier<T>, instanceOrDescriptor: T | SyncDescriptor<T>): T | SyncDescriptor<T> {
+		const entry: Entry = [id, instanceOrDescriptor];
+		const idx = binarySearch(this._entries, entry, ServiceCollection._entryCompare);
+		if (idx < 0) {
+			// new element
+			this._entries.splice(~idx, 0, entry);
+		} else {
+			const old = this._entries[idx];
+			this._entries[idx] = entry;
+			return old[1];
+		}
+	}
+
+	forEach(callback: (id: ServiceIdentifier<any>, instanceOrDescriptor: any) => any): void {
+		for (let entry of this._entries) {
+			let [id, instanceOrDescriptor] = entry;
+			callback(id, instanceOrDescriptor);
+		}
+	}
+
+	has(id: ServiceIdentifier<any>): boolean {
+		return binarySearch(this._entries, ServiceCollection._searchEntry(id), ServiceCollection._entryCompare) >= 0;
+	}
+
+	get<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T> {
+		const idx = binarySearch(this._entries, ServiceCollection._searchEntry(id), ServiceCollection._entryCompare);
+		if (idx >= 0) {
+			return this._entries[idx][1];
+		}
+	}
+
+	private static _dummy: Entry = [undefined, undefined];
+
+	private static _searchEntry(id: ServiceIdentifier<any>): Entry {
+		ServiceCollection._dummy[0] = id;
+		return ServiceCollection._dummy;
+	}
+
+	private static _entryCompare(a: Entry, b: Entry): number {
+		const _a = a[0].toString();
+		const _b = b[0].toString();
+		if (_a < _b) {
+			return -1;
+		} else if (_a > _b) {
+			return 1;
+		} else {
+			return 0;
+		}
+	}
+}

src/vs/platform/instantiation/test/common/instantiationService.test.ts

@@ -7,8 +7,8 @@
 
 import assert = require('assert');
 import instantiation = require('vs/platform/instantiation/common/instantiation');
-import instantiationService = require('vs/platform/instantiation/common/instantiationService');
-
+import {InstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {SyncDescriptor} from 'vs/platform/instantiation/common/descriptors';
 
 let IService1 = instantiation.createDecorator<IService1>('service1');
@@ -63,7 +63,7 @@ class DependentService implements IDependentService {
 	name = 'farboo';
 }
 
-class ParameterTarget {
+class Target1Dep {
 
 	constructor( @IService1 service1: IService1) {
 		assert.ok(service1);
@@ -71,7 +71,15 @@ class ParameterTarget {
 	}
 }
 
-class ParameterTarget2 {
+class Target2Dep {
+
+	constructor( @IService1 service1: IService1, @IService2 service2) {
+		assert.ok(service1 instanceof Service1);
+		assert.ok(service2 instanceof Service2);
+	}
+}
+
+class TargetWithStaticParam {
 	constructor(v: boolean, @IService1 service1: IService1) {
 		assert.ok(v);
 		assert.ok(service1);
@@ -123,27 +131,80 @@ class ServiceLoop2 implements IService2 {
 }
 
 suite('Instantiation Service', () => {
-	test('@Param - simple clase', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new Service1());
-		service.addSingleton(IService2, new Service2());
-		service.addSingleton(IService3, new Service3());
 
-		service.createInstance(ParameterTarget);
+	test('service collection, cannot overwrite', function () {
+		let collection = new ServiceCollection();
+		let result = collection.set(IService1, null);
+		assert.equal(result, undefined);
+		result = collection.set(IService1, new Service1());
+		assert.equal(result, null);
+	});
+
+	test('service collection, add/has', function () {
+		let collection = new ServiceCollection();
+		collection.set(IService1, null);
+		assert.ok(collection.has(IService1));
+
+		collection.set(IService2, null);
+		assert.ok(collection.has(IService1));
+		assert.ok(collection.has(IService2));
+	});
+
+	test('addSingleton - cannot overwrite service', function () {
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
+		assert.throws(() => service.addSingleton(IService1, new Service1()));
 	});
 
-	test('@Param - fixed args', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new Service1());
-		service.addSingleton(IService2, new Service2());
-		service.addSingleton(IService3, new Service3());
+	test('@Param - simple clase', function () {
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
+		collection.set(IService2, new Service2());
+		collection.set(IService3, new Service3());
+
+		service.createInstance(Target1Dep);
+	});
+
+	test('@Param - fixed args', function () {
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
+		collection.set(IService2, new Service2());
+		collection.set(IService3, new Service3());
+
+		service.createInstance(TargetWithStaticParam, true);
+	});
+
+	test('service collection is live', function () {
+
+		let collection = new ServiceCollection();
+		collection.set(IService1, new Service1());
+
+		let service = new InstantiationService(collection);
+		service.createInstance(Target1Dep);
+
+		// no IService2
+		assert.throws(() => service.createInstance(Target2Dep));
+		service.invokeFunction(function (a) {
+			assert.ok(a.get(IService1));
+			assert.ok(!a.get(IService2));
+		});
+
+		collection.set(IService2, new Service2());
 
-		service.createInstance(ParameterTarget2, true);
+		service.createInstance(Target2Dep);
+		service.invokeFunction(function (a) {
+			assert.ok(a.get(IService1));
+			assert.ok(a.get(IService2));
+		});
 	});
 
-	test('@Param - optional', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new Service1());
+	test('@Param - optional', function () {
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
 		// service.addSingleton(IService2, new Service2());
 
 		service.createInstance(TargetOptional);
@@ -169,8 +230,9 @@ suite('Instantiation Service', () => {
 	// });
 
 	test('SyncDesc - no dependencies', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new SyncDescriptor<IService1>(Service1));
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new SyncDescriptor<IService1>(Service1));
 
 		let service1 = service.getInstance(IService1);
 		assert.ok(service1);
@@ -181,9 +243,10 @@ suite('Instantiation Service', () => {
 	});
 
 	test('SyncDesc - service with service dependency', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new SyncDescriptor<IService1>(Service1));
-		service.addSingleton(IDependentService, new SyncDescriptor<IDependentService>(DependentService));
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new SyncDescriptor<IService1>(Service1));
+		collection.set(IDependentService, new SyncDescriptor<IDependentService>(DependentService));
 
 		let d = service.getInstance(IDependentService);
 		assert.ok(d);
@@ -191,9 +254,10 @@ suite('Instantiation Service', () => {
 	});
 
 	test('SyncDesc - target depends on service future', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new SyncDescriptor<IService1>(Service1));
-		service.addSingleton(IDependentService, new SyncDescriptor<IDependentService>(DependentService));
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new SyncDescriptor<IService1>(Service1));
+		collection.set(IDependentService, new SyncDescriptor<IDependentService>(DependentService));
 
 		let d = service.createInstance(DependentServiceTarget);
 		assert.ok(d instanceof DependentServiceTarget);
@@ -203,9 +267,10 @@ suite('Instantiation Service', () => {
 	});
 
 	test('SyncDesc - explode on loop', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new SyncDescriptor<IService1>(ServiceLoop1));
-		service.addSingleton(IService2, new SyncDescriptor<IService2>(ServiceLoop2));
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new SyncDescriptor<IService1>(ServiceLoop1));
+		collection.set(IService2, new SyncDescriptor<IService2>(ServiceLoop2));
 
 		assert.throws(() => service.getInstance(IService1));
 		assert.throws(() => service.getInstance(IService2));
@@ -219,9 +284,10 @@ suite('Instantiation Service', () => {
 	});
 
 	test('Invoke - get services', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new Service1());
-		service.addSingleton(IService2, new Service2());
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
+		collection.set(IService2, new Service2());
 
 		function test(accessor: instantiation.ServicesAccessor) {
 			assert.ok(accessor.get(IService1) instanceof Service1);
@@ -234,9 +300,10 @@ suite('Instantiation Service', () => {
 	});
 
 	test('Invoke - keeping accessor NOT allowed', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new Service1());
-		service.addSingleton(IService2, new Service2());
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
+		collection.set(IService2, new Service2());
 
 		let cached: instantiation.ServicesAccessor;
 
@@ -253,9 +320,10 @@ suite('Instantiation Service', () => {
 	});
 
 	test('Invoke - throw error', function() {
-		let service = instantiationService.createInstantiationService(Object.create(null));
-		service.addSingleton(IService1, new Service1());
-		service.addSingleton(IService2, new Service2());
+		let collection = new ServiceCollection();
+		let service = new InstantiationService(collection);
+		collection.set(IService1, new Service1());
+		collection.set(IService2, new Service2());
 
 		function test(accessor: instantiation.ServicesAccessor) {
 			throw new Error();

src/vs/platform/telemetry/common/telemetry.ts

@@ -4,11 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {Registry} from 'vs/platform/platform';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {IDisposable} from 'vs/base/common/lifecycle';
 import {ITimerEvent, nullEvent} from 'vs/base/common/timer';
-import {createDecorator, ServiceIdentifier, IInstantiationService, IConstructorSignature0} from 'vs/platform/instantiation/common/instantiation';
+import {createDecorator, ServiceIdentifier, IInstantiationService, ServicesAccessor, IConstructorSignature0} from 'vs/platform/instantiation/common/instantiation';
 
 export const ITelemetryService = createDecorator<ITelemetryService>('telemetryService');
 
@@ -37,12 +36,28 @@ export interface ITelemetryService {
 	addTelemetryAppender(appender: ITelemetryAppender): IDisposable;
 }
 
-export const Extenstions = {
-	TelemetryAppenders: 'telemetry.appenders'
+export namespace Extenstions {
+
+	let _telemetryAppenderCtors: IConstructorSignature0<ITelemetryAppender>[] = [];
+
+	export const TelemetryAppenders = {
+		activate(accessor: ServicesAccessor): void {
+			const telemetryService = accessor.get(ITelemetryService);
+			const instantiationService = accessor.get(IInstantiationService);
+			for (let ctor of _telemetryAppenderCtors) {
+				const instance = instantiationService.createInstance(ctor);
+				telemetryService.addTelemetryAppender(instance);
+			}
+			// can only be done once
+			_telemetryAppenderCtors = undefined;
+		},
+		registerTelemetryAppenderDescriptor(ctor: IConstructorSignature0<ITelemetryAppender>): void {
+			_telemetryAppenderCtors.push(ctor);
+		}
+	};
 };
 
 export interface ITelemetryAppendersRegistry {
-	registerTelemetryAppenderDescriptor(ctor: IConstructorSignature0<ITelemetryAppender>): void;
 	activate(instantiationService: IInstantiationService): void;
 }
 
@@ -64,32 +79,6 @@ export interface ITelemetryAppender extends IDisposable {
 	log(eventName: string, data?: any): void;
 }
 
-export class TelemetryAppendersRegistry implements ITelemetryAppendersRegistry {
-
-	private _telemetryAppenderCtors: IConstructorSignature0<ITelemetryAppender>[];
-
-	constructor() {
-		this._telemetryAppenderCtors = [];
-	}
-
-	public registerTelemetryAppenderDescriptor(ctor: IConstructorSignature0<ITelemetryAppender>): void {
-		this._telemetryAppenderCtors.push(ctor);
-	}
-
-	public activate(instantiationService: IInstantiationService): void {
-		const service = instantiationService.getInstance(ITelemetryService);
-		for (let ctor of this._telemetryAppenderCtors) {
-			const instance = instantiationService.createInstance(ctor);
-			service.addTelemetryAppender(instance);
-		}
-
-		// can only be done once
-		this._telemetryAppenderCtors = undefined;
-	}
-}
-
-Registry.add(Extenstions.TelemetryAppenders, new TelemetryAppendersRegistry());
-
 // --- util
 
 export function anonymize(input: string): string {

src/vs/platform/telemetry/test/node/telemetryService.test.ts

@@ -8,7 +8,8 @@ import * as assert from 'assert';
 import IdleMonitor = require('vs/base/browser/idleMonitor');
 import {TelemetryService} from 'vs/platform/telemetry/browser/telemetryService';
 import Telemetry = require('vs/platform/telemetry/common/telemetry');
-import InstantiationService = require('vs/platform/instantiation/common/instantiationService');
+import {InstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import Errors = require('vs/base/common/errors');
 import Timer = require('vs/base/common/timer');
 import * as sinon from 'sinon';
@@ -175,8 +176,7 @@ suite('TelemetryService', () => {
 
 	test('TelemetryAppendersRegistry, activate', function() {
 
-		let registry = new Telemetry.TelemetryAppendersRegistry();
-		registry.registerTelemetryAppenderDescriptor(TestTelemetryAppender);
+		Telemetry.Extenstions.TelemetryAppenders.registerTelemetryAppenderDescriptor(TestTelemetryAppender);
 
 		let callCount = 0;
 		let telemetryService: Telemetry.ITelemetryService = <any> {
@@ -186,14 +186,13 @@ suite('TelemetryService', () => {
 			}
 		};
 
-		let instantiationService = InstantiationService.createInstantiationService();
-		instantiationService.addSingleton(Telemetry.ITelemetryService, telemetryService);
-		registry.activate(instantiationService);
+		let instantiationService = new InstantiationService(new ServiceCollection([Telemetry.ITelemetryService, telemetryService]));
+		instantiationService.invokeFunction(Telemetry.Extenstions.TelemetryAppenders.activate);
 		assert.equal(callCount, 1);
 
 		// registry is now active/read-only
-		assert.throws(() => registry.registerTelemetryAppenderDescriptor(TestTelemetryAppender));
-		assert.throws(() => registry.activate(instantiationService));
+		assert.throws(() => Telemetry.Extenstions.TelemetryAppenders.registerTelemetryAppenderDescriptor(TestTelemetryAppender));
+		assert.throws(() => instantiationService.invokeFunction(Telemetry.Extenstions.TelemetryAppenders.activate));
 	});
 
 	test('Disposing', sinon.test(function() {

src/vs/workbench/browser/parts/compositePart.ts

@@ -31,6 +31,7 @@ import {IStorageService, StorageScope} from 'vs/platform/storage/common/storage'
 import {IContextMenuService} from 'vs/platform/contextview/browser/contextView';
 import {IEventService} from 'vs/platform/event/common/event';
 import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {IMessageService, Severity} from 'vs/platform/message/common/message';
 import {IProgressService} from 'vs/platform/progress/common/progress';
 import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
@@ -176,10 +177,7 @@ export abstract class CompositePart<T extends Composite> extends Part {
 			let loaderPromise = this.compositeLoaderPromises[id];
 			if (!loaderPromise) {
 				let progressService = new WorkbenchProgressService(this.eventService, this.progressBar, compositeDescriptor.id, isActive);
-				let services = {
-					progressService: progressService
-				};
-				let compositeInstantiationService = this.instantiationService.createChild(services);
+				let compositeInstantiationService = this.instantiationService.createChild(new ServiceCollection([IProgressService, progressService]));
 
 				loaderPromise = compositeInstantiationService.createInstance(compositeDescriptor).then((composite: Composite) => {
 					this.mapProgressServiceToComposite[composite.getId()] = progressService;

src/vs/workbench/browser/parts/editor/editorPart.ts

@@ -36,8 +36,10 @@ import {Position, POSITIONS} from 'vs/platform/editor/common/editor';
 import {IStorageService} from 'vs/platform/storage/common/storage';
 import {IEventService} from 'vs/platform/event/common/event';
 import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {IMessageService, IMessageWithAction, Severity} from 'vs/platform/message/common/message';
 import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
+import {IProgressService} from 'vs/platform/progress/common/progress';
 
 const EDITOR_STATE_STORAGE_KEY = 'editorpart.editorState';
 
@@ -755,11 +757,10 @@ export class EditorPart extends Part implements IEditorPart {
 	}
 
 	private createEditor(editorDescriptor: EditorDescriptor, editorDomNode: HTMLElement, position: Position): TPromise<BaseEditor> {
-		let services = {
-			progressService: new WorkbenchProgressService(this.eventService, this.sideBySideControl.getProgressBar(position), editorDescriptor.getId(), true)
-		};
 
-		let editorInstantiationService = this.instantiationService.createChild(services);
+		let progressService = new WorkbenchProgressService(this.eventService, this.sideBySideControl.getProgressBar(position), editorDescriptor.getId(), true);
+
+		let editorInstantiationService = this.instantiationService.createChild(new ServiceCollection([IProgressService, progressService]));
 
 		return editorInstantiationService.createInstance(editorDescriptor);
 	}

src/vs/workbench/browser/parts/editor/textDiffEditor.ts

@@ -32,6 +32,7 @@ import {IStorageService} from 'vs/platform/storage/common/storage';
 import {IConfigurationService} from 'vs/platform/configuration/common/configuration';
 import {IEventService} from 'vs/platform/event/common/event';
 import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {IMessageService} from 'vs/platform/message/common/message';
 import {IWorkbenchEditorService} from 'vs/workbench/services/editor/common/editorService';
 import {IModeService} from 'vs/editor/common/services/modeService';
@@ -111,9 +112,7 @@ export class TextDiffEditor extends BaseTextEditor {
 		});
 
 		// Create a special child of instantiator that will delegate all calls to openEditor() to the same diff editor if the input matches with the modified one
-		let diffEditorInstantiator = this.instantiationService.createChild({
-			editorService: delegatingService
-		});
+		let diffEditorInstantiator = this.instantiationService.createChild(new ServiceCollection([IWorkbenchEditorService, delegatingService]));
 
 		return diffEditorInstantiator.createInstance(DiffEditorWidget, parent.getHTMLElement(), this.getCodeEditorOptions());
 	}

src/vs/workbench/browser/workbench.ts

@@ -427,7 +427,7 @@ export class Workbench implements IPartService {
 		<IWorkbenchContributionsRegistry>Registry.as(WorkbenchExtensions.Workbench).setInstantiationService(this.instantiationService);
 		<IEditorRegistry>Registry.as(EditorExtensions.Editors).setInstantiationService(this.instantiationService);
 
-		Registry.as<{activate(s:IInstantiationService):void}>(TelemetryExtensions.TelemetryAppenders).activate(this.instantiationService);
+		this.instantiationService.invokeFunction(TelemetryExtensions.TelemetryAppenders.activate);
 	}
 
 	private initSettings(): void {

src/vs/workbench/electron-main/sharedProcessMain.ts

@@ -7,21 +7,13 @@ import * as fs from 'fs';
 import platform = require('vs/base/common/platform');
 import { serve, Server, connect } from 'vs/base/node/service.net';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { createInstantiationService as createInstantiationService } from 'vs/platform/instantiation/common/instantiationService';
-import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 
 // Services
-import { IRequestService } from 'vs/platform/request/common/request';
-import { RequestService } from 'vs/workbench/services/request/node/requestService';
-import { IWorkspaceContextService, IConfiguration } from 'vs/platform/workspace/common/workspace';
+import { IConfiguration } from 'vs/platform/workspace/common/workspace';
 import { WorkspaceContextService } from 'vs/workbench/services/workspace/common/contextService';
-import { IEventService } from 'vs/platform/event/common/event';
 import { EventService } from 'vs/platform/event/common/eventService';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { ConfigurationService } from 'vs/workbench/services/configuration/node/configurationService';
 
 // Extra services
-import { IExtensionsService } from 'vs/workbench/parts/extensions/common/extensions';
 import { ExtensionsService } from 'vs/workbench/parts/extensions/node/extensionsService';
 
 interface IInitData {
@@ -51,19 +43,11 @@ function setupPlanB(parentPid: number): void {
 }
 
 function main(server: Server, initData: IInitData): void {
+
 	const eventService = new EventService();
 	const contextService = new WorkspaceContextService(eventService, null, initData.configuration, initData.contextServiceOptions);
-	const configurationService = new ConfigurationService(contextService, eventService);
-	const requestService = new RequestService(contextService, configurationService);
-
-	const instantiationService = createInstantiationService();
-	instantiationService.addSingleton(IEventService, eventService);
-	instantiationService.addSingleton(IWorkspaceContextService, contextService);
-	instantiationService.addSingleton(IConfigurationService, configurationService);
-	instantiationService.addSingleton(IRequestService, requestService);
+	const extensionService = new ExtensionsService(contextService);
 
-	instantiationService.addSingleton(IExtensionsService, new SyncDescriptor(ExtensionsService));
-	const extensionService = <ExtensionsService> instantiationService.getInstance(IExtensionsService);
 	server.registerService('ExtensionService', extensionService);
 
 	// eventually clean up old extensions

src/vs/workbench/node/extensionHostMain.ts

@@ -17,14 +17,15 @@ import {IExtensionService, IExtensionDescription} from 'vs/platform/extensions/c
 import {ExtensionsRegistry} from 'vs/platform/extensions/common/extensionsRegistry';
 import {ExtHostAPIImplementation} from 'vs/workbench/api/node/extHost.api.impl';
 import {IMainProcessExtHostIPC} from 'vs/platform/extensions/common/ipcRemoteCom';
-import {ExtHostModelService} from 'vs/workbench/api/node/extHostDocuments';
+import {ITelemetryService} from 'vs/platform/telemetry/common/telemetry';
 import {IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import InstantiationService = require('vs/platform/instantiation/common/instantiationService');
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
 import {ExtHostExtensionService} from 'vs/platform/extensions/common/nativeExtensionService';
+import {IThreadService} from 'vs/platform/thread/common/thread';
 import {ExtHostThreadService} from 'vs/platform/thread/common/extHostThreadService';
 import {RemoteTelemetryService} from 'vs/platform/telemetry/common/remoteTelemetryService';
 import {BaseWorkspaceContextService} from 'vs/platform/workspace/common/baseWorkspaceContextService';
-import {ModeServiceImpl} from 'vs/editor/common/services/modeServiceImpl';
 import {ExtensionScanner, MessagesCollector} from 'vs/workbench/node/extensionPoints';
 import {IWorkspaceContextService} from 'vs/platform/workspace/common/workspace';
 import {Client} from 'vs/base/node/service.net';
@@ -57,29 +58,22 @@ export function createServices(remoteCom: IMainProcessExtHostIPC, initData: IIni
 
 	let contextService = new BaseWorkspaceContextService(initData.contextService.workspace, initData.contextService.configuration, initData.contextService.options);
 	let threadService = new ExtHostThreadService(remoteCom);
-	threadService.setInstantiationService(InstantiationService.createInstantiationService({ threadService: threadService }));
+	threadService.setInstantiationService(InstantiationService.createInstantiationService(new ServiceCollection([IThreadService, threadService])));
 	let telemetryService = new RemoteTelemetryService('pluginHostTelemetry', threadService);
-	let modelService = threadService.getRemotable(ExtHostModelService);
-
-	let extensionService = new ExtHostExtensionService(threadService, telemetryService);
-	let modeService = new ModeServiceImpl(threadService, extensionService);
-	let _services: any = {
-		contextService,
-		modelService,
-		threadService,
-		modeService,
-		extensionService,
-		telemetryService
-	};
-	let instantiationService = InstantiationService.createInstantiationService(_services);
+
+	let services = new ServiceCollection();
+	services.set(IWorkspaceContextService, contextService);
+	services.set(ITelemetryService, telemetryService);
+	services.set(IThreadService, threadService);
+	services.set(IExtensionService, new ExtHostExtensionService(threadService, telemetryService));
+	services.set(IExtensionsService, sharedProcessClient.getService<IExtensionsService>('ExtensionService', ExtensionsService)); // Connect to shared process services
+
+	let instantiationService = InstantiationService.createInstantiationService(services);
 	threadService.setInstantiationService(instantiationService);
 
 	// Create the monaco API
 	instantiationService.createInstance(ExtHostAPIImplementation);
 
-	// Connect to shared process services
-	instantiationService.addSingleton(IExtensionsService, sharedProcessClient.getService<IExtensionsService>('ExtensionService', ExtensionsService));
-
 	return instantiationService;
 }
 

src/vs/workbench/parts/files/test/browser/fileEditorInput.test.ts

@@ -10,6 +10,7 @@ import URI from 'vs/base/common/uri';
 import {join} from 'vs/base/common/paths';
 import {FileEditorInput} from 'vs/workbench/parts/files/browser/editors/fileEditorInput';
 import {createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import {ITextFileService} from 'vs/workbench/parts/files/common/files';
 import {TextFileService} from 'vs/workbench/parts/files/browser/textFileServices';
 import {NullTelemetryService} from 'vs/platform/telemetry/common/telemetry';
 import {FileTracker} from 'vs/workbench/parts/files/browser/fileTracker';
@@ -42,8 +43,8 @@ suite('Files - FileEditorInput', () => {
 			configurationService: new TestConfigurationService()
 		});
 
-		let textFileServices = instantiationService.createInstance(<any>TextFileService);
-		instantiationService.registerService('textFileService', textFileServices);
+		let textFileServices = <ITextFileService> instantiationService.createInstance(<any> TextFileService);
+		instantiationService.addSingleton(ITextFileService, textFileServices);
 
 		let input = instantiationService.createInstance(FileEditorInput, toResource('/foo/bar/file.js'), 'text/javascript', void 0);
 		let otherInput = instantiationService.createInstance(FileEditorInput, toResource('foo/bar/otherfile.js'), 'text/javascript', void 0);
@@ -133,8 +134,8 @@ suite('Files - FileEditorInput', () => {
 			configurationService: new TestConfigurationService()
 		});
 
-		let textFileServices = instantiationService.createInstance(<any>TextFileService);
-		instantiationService.registerService('textFileService', textFileServices);
+		let textFileServices = <ITextFileService> instantiationService.createInstance(<any>TextFileService);
+		instantiationService.addSingleton(ITextFileService, textFileServices);
 
 		let tracker = instantiationService.createInstance(FileTracker);
 
@@ -177,8 +178,8 @@ suite('Files - FileEditorInput', () => {
 			configurationService: new TestConfigurationService()
 		});
 
-		let textFileServices = instantiationService.createInstance(<any>TextFileService);
-		instantiationService.registerService('textFileService', textFileServices);
+		let textFileServices = <ITextFileService> instantiationService.createInstance(<any>TextFileService);
+		instantiationService.addSingleton(ITextFileService, textFileServices);
 
 		let tracker = instantiationService.createInstance(FileTracker);
 

src/vs/workbench/parts/files/test/browser/fileEditorModel.test.ts

@@ -15,7 +15,7 @@ import {IInstantiationService} from 'vs/platform/instantiation/common/instantiat
 import {NullTelemetryService} from 'vs/platform/telemetry/common/telemetry';
 import {createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
 import {TextFileService} from 'vs/workbench/parts/files/browser/textFileServices';
-import {EventType} from 'vs/workbench/parts/files/common/files';
+import {ITextFileService, EventType} from 'vs/workbench/parts/files/common/files';
 import {TestFileService, TestLifecycleService, TestPartService, TestEditorService, TestConfigurationService, TestUntitledEditorService, TestStorageService, TestContextService, TestMessageService, TestEventService} from 'vs/workbench/test/browser/servicesTestUtils';
 import {createMockModelService, createMockModeService} from 'vs/editor/test/common/servicesTestUtils';
 
@@ -52,7 +52,7 @@ suite('Files - TextFileEditorModel', () => {
 
 		textFileService = <TextFileService>baseInstantiationService.createInstance(<any>TextFileService);
 
-		baseInstantiationService.registerService('textFileService', textFileService);
+		baseInstantiationService.addSingleton(ITextFileService, textFileService);
 	});
 
 	teardown(() => {

src/vs/workbench/parts/telemetry/node/appInsights.telemetry.contribution.ts

@@ -5,9 +5,7 @@
 
 'use strict';
 
-import Platform = require('vs/platform/platform');
-import {Extenstions, ITelemetryAppendersRegistry} from 'vs/platform/telemetry/common/telemetry';
+import {Extenstions} from 'vs/platform/telemetry/common/telemetry';
 import AppInsightsTelemetryAppender = require('vs/workbench/parts/telemetry/node/nodeAppInsightsTelemetryAppender');
 
-Platform.Registry.as<ITelemetryAppendersRegistry>(Extenstions.TelemetryAppenders)
-	.registerTelemetryAppenderDescriptor(AppInsightsTelemetryAppender.NodeAppInsightsTelemetryAppender);
\ No newline at end of file
+Extenstions.TelemetryAppenders.registerTelemetryAppenderDescriptor(AppInsightsTelemetryAppender.NodeAppInsightsTelemetryAppender);
\ No newline at end of file

src/vs/workbench/test/browser/services.test.ts

@@ -16,6 +16,7 @@ import {StringEditorInput} from 'vs/workbench/common/editor/stringEditorInput';
 import {StringEditorModel} from 'vs/workbench/common/editor/stringEditorModel';
 import {FileEditorInput} from 'vs/workbench/parts/files/browser/editors/fileEditorInput';
 import {TextFileEditorModel} from 'vs/workbench/parts/files/common/editors/textFileEditorModel';
+import {ITextFileService} from 'vs/workbench/parts/files/common/files';
 import {TextFileService} from 'vs/workbench/parts/files/browser/textFileServices';
 import {TestEventService, TestLifecycleService, TestPartService, TestStorageService, TestConfigurationService, TestRequestService, TestContextService, TestWorkspace, TestEditorService, MockRequestService} from 'vs/workbench/test/browser/servicesTestUtils';
 import {Viewlet} from 'vs/workbench/browser/viewlet';
@@ -257,8 +258,8 @@ suite('Workbench UI Services', () => {
 		};
 		let inst = createInstantiationService(services);
 
-		let textFileService = inst.createInstance(<any>TextFileService);
-		inst.registerService('textFileService', textFileService);
+		let textFileService = <ITextFileService>inst.createInstance(<any>TextFileService);
+		inst.addSingleton(ITextFileService, textFileService);
 		services['instantiationService'] = inst;
 
 		let activeInput: EditorInput = inst.createInstance(FileEditorInput, toResource('/something.js'), 'text/javascript', void 0);
@@ -358,8 +359,8 @@ suite('Workbench UI Services', () => {
 		};
 
 		let inst = createInstantiationService(services);
-		let textFileService = inst.createInstance(<any>TextFileService);
-		inst.registerService('textFileService', textFileService);
+		let textFileService = <ITextFileService> inst.createInstance(<any>TextFileService);
+		inst.addSingleton(ITextFileService, textFileService);
 		services['instantiationService'] = inst;
 		let activeInput: EditorInput = inst.createInstance(FileEditorInput, toResource('/something.js'), 'text/javascript', void 0);
 

src/vs/workbench/test/node/api/extHostApiCommands.test.ts

@@ -13,7 +13,8 @@ import * as types from 'vs/workbench/api/node/extHostTypes';
 import * as EditorCommon from 'vs/editor/common/editorCommon';
 import {Model as EditorModel} from 'vs/editor/common/model/model';
 import {TestThreadService} from './testThreadService';
-import {createInstantiationService as createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
+import {InstantiationService} from 'vs/platform/instantiation/common/instantiationService';
 import {MainProcessMarkerService} from 'vs/platform/markers/common/markerService';
 import {IMarkerService} from 'vs/platform/markers/common/markers';
 import {IThreadService} from 'vs/platform/thread/common/thread';
@@ -50,18 +51,19 @@ suite('ExtHostLanguageFeatureCommands', function() {
 		originalErrorHandler = errorHandler.getUnexpectedErrorHandler();
 		setUnexpectedErrorHandler(() => { });
 
-		let instantiationService = createInstantiationService();
+		let services = new ServiceCollection();
+		let instantiationService = new InstantiationService(services);
 		threadService = new TestThreadService(instantiationService);
 
-		instantiationService.addSingleton(IKeybindingService, <IKeybindingService>{
+		services.set(IKeybindingService, <IKeybindingService>{
 			executeCommand(id, args): any {
 				let handler = KeybindingsRegistry.getCommands()[id];
 				return TPromise.as(instantiationService.invokeFunction(handler, args));
 			}
 		});
-		instantiationService.addSingleton(IMarkerService, new MainProcessMarkerService(threadService));
-		instantiationService.addSingleton(IThreadService, threadService);
-		instantiationService.addSingleton(IModelService, <IModelService>{
+		services.set(IMarkerService, new MainProcessMarkerService(threadService));
+		services.set(IThreadService, threadService);
+		services.set(IModelService, <IModelService>{
 			serviceId: IModelService,
 			getModel(): any { return model; },
 			createModel(): any { throw new Error(); },

src/vs/workbench/test/node/api/extHostLanguageFeatures.test.ts

@@ -12,7 +12,8 @@ import * as types from 'vs/workbench/api/node/extHostTypes';
 import * as EditorCommon from 'vs/editor/common/editorCommon';
 import {Model as EditorModel} from 'vs/editor/common/model/model';
 import {TestThreadService} from './testThreadService';
-import {createInstantiationService as createInstantiationService} from 'vs/platform/instantiation/common/instantiationService';
+import ServiceCollection from 'vs/platform/instantiation/common/serviceCollection';
+import {InstantiationService} from 'vs/platform/instantiation/common/instantiationService';
 import {MainProcessMarkerService} from 'vs/platform/markers/common/markerService';
 import {IMarkerService} from 'vs/platform/markers/common/markers';
 import {IThreadService} from 'vs/platform/thread/common/thread';
@@ -54,10 +55,11 @@ suite('ExtHostLanguageFeatures', function() {
 
 	suiteSetup(() => {
 
-		let instantiationService = createInstantiationService();
+		let services = new ServiceCollection();
+		let instantiationService = new InstantiationService(services);
 		threadService = new TestThreadService(instantiationService);
-		instantiationService.addSingleton(IMarkerService, new MainProcessMarkerService(threadService));
-		instantiationService.addSingleton(IThreadService, threadService);
+		services.set(IMarkerService, new MainProcessMarkerService(threadService));
+		services.set(IThreadService, threadService);
 
 		originalErrorHandler = errorHandler.getUnexpectedErrorHandler();
 		setUnexpectedErrorHandler(() => { });