Dispose instances of test instantiation service (microsoft#187482)

* Dispose instances of test instantiation service
This will call `sinon.restore()` and prevent a memory leak
Part of microsoft#187471

* Fix interfering terminal tests

* Remove `async` from terminal test suite

* Fix `any`

Author: alexr00

src/vs/editor/test/browser/testCodeEditor.ts

@@ -201,7 +201,7 @@ export function createCodeEditorServices(disposables: DisposableStore, services:
 	define(ILanguageFeatureDebounceService, LanguageFeatureDebounceService);
 	define(ILanguageFeaturesService, LanguageFeaturesService);
 
-	const instantiationService = new TestInstantiationService(services, true);
+	const instantiationService = disposables.add(new TestInstantiationService(services, true));
 	disposables.add(toDisposable(() => {
 		for (const id of serviceIdentifiers) {
 			const instanceOrDescriptor = services.get(id);

src/vs/editor/test/common/services/textResourceConfigurationService.test.ts

@@ -15,6 +15,7 @@ import { URI } from 'vs/base/common/uri';
 
 suite('TextResourceConfigurationService - Update', () => {
 
+	let instantiationService: TestInstantiationService;
 	let configurationValue: IConfigurationValue<any> = {};
 	let updateArgs: any[];
 	const configurationService = new class extends TestConfigurationService {
@@ -30,13 +31,17 @@ suite('TextResourceConfigurationService - Update', () => {
 	let testObject: TextResourceConfigurationService;
 
 	setup(() => {
-		const instantiationService = new TestInstantiationService();
+		instantiationService = new TestInstantiationService();
 		instantiationService.stub(IModelService, <Partial<IModelService>>{ getModel() { return null; } });
 		instantiationService.stub(ILanguageService, <Partial<ILanguageService>>{ guessLanguageIdByFilepathOrFirstLine() { return language; } });
 		instantiationService.stub(IConfigurationService, configurationService);
 		testObject = instantiationService.createInstance(TextResourceConfigurationService);
 	});
 
+	teardown(() => {
+		instantiationService.dispose();
+	});
+
 	test('updateValue writes without target and overrides when no language is defined', async () => {
 		const resource = URI.file('someFile');
 		await testObject.updateValue(resource, 'a', 'b');

src/vs/platform/contextkey/test/browser/contextkey.test.ts

@@ -83,22 +83,23 @@ suite('ContextKeyService', () => {
 		const disposables = new DisposableStore();
 		const configurationService: IConfigurationService = new TestConfigurationService();
 		const contextKeyService: IContextKeyService = disposables.add(new ContextKeyService(configurationService));
-		const instantiationService = new TestInstantiationService(new ServiceCollection(
+		const instantiationService = disposables.add(new TestInstantiationService(new ServiceCollection(
 			[IConfigurationService, configurationService],
 			[IContextKeyService, contextKeyService],
 			[ITelemetryService, new class extends mock<ITelemetryService>() {
 				override async publicLog2() {
 					//
 				}
 			}]
-		));
+		)));
 
 		const uri = URI.parse('test://abc');
 		contextKeyService.createKey<string>('notebookCellResource', undefined).set(uri.toString());
 		instantiationService.invokeFunction(setContext, 'jupyter.runByLineCells', JSON.parse(JSON.stringify([uri])));
 
 		const expr = ContextKeyExpr.in('notebookCellResource', 'jupyter.runByLineCells');
 		assert.deepStrictEqual(contextKeyService.contextMatchesRules(expr), true);
+		disposables.dispose();
 	});
 
 	test('suppress update event from parent when one key is overridden by child', () => {

src/vs/platform/extensionManagement/test/common/extensionsProfileScannerService.test.ts

@@ -33,7 +33,7 @@ suite('ExtensionsProfileScannerService', () => {
 	let instantiationService: TestInstantiationService;
 
 	setup(async () => {
-		instantiationService = new TestInstantiationService();
+		instantiationService = disposables.add(new TestInstantiationService());
 		const logService = new NullLogService();
 		const fileService = disposables.add(new FileService(logService));
 		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());

src/vs/platform/extensionManagement/test/node/extensionsScannerService.test.ts

@@ -60,7 +60,7 @@ suite('NativeExtensionsScanerService Test', () => {
 
 	setup(async () => {
 		translations = {};
-		instantiationService = new TestInstantiationService();
+		instantiationService = disposables.add(new TestInstantiationService());
 		const logService = new NullLogService();
 		const fileService = disposables.add(new FileService(logService));
 		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as sinon from 'sinon';
-import { DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
+import { DisposableStore, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
 import { InstantiationService, Trace } from 'vs/platform/instantiation/common/instantiationService';
@@ -17,7 +17,7 @@ interface IServiceMock<T> {
 
 const isSinonSpyLike = (fn: Function): fn is sinon.SinonSpy => fn && 'callCount' in fn;
 
-export class TestInstantiationService extends InstantiationService {
+export class TestInstantiationService extends InstantiationService implements IDisposable {
 
 	private _servciesMap: Map<ServiceIdentifier<any>, any>;
 
@@ -129,6 +129,10 @@ export class TestInstantiationService extends InstantiationService {
 	override createChild(services: ServiceCollection): TestInstantiationService {
 		return new TestInstantiationService(services, false, this);
 	}
+
+	dispose() {
+		sinon.restore();
+	}
 }
 
 interface SinonOptions {
@@ -157,7 +161,7 @@ export function createServices(disposables: DisposableStore, services: ServiceId
 		define(id, ctor);
 	}
 
-	const instantiationService = new TestInstantiationService(serviceCollection, true);
+	const instantiationService = disposables.add(new TestInstantiationService(serviceCollection, true));
 	disposables.add(toDisposable(() => {
 		for (const id of serviceIdentifiers) {
 			const instanceOrDescriptor = serviceCollection.get(id);

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

@@ -93,6 +93,7 @@ suite('TelemetryLogAdapter', () => {
 		const testObject = new TelemetryLogAppender(new NullLogService(), testLoggerService, testInstantiationService.stub(IEnvironmentService, {}), testInstantiationService.stub(IProductService, {}));
 		testObject.log('testEvent', { hello: 'world', isTrue: true, numberBetween1And3: 2 });
 		assert.strictEqual(testLoggerService.createLogger().logs.length, 2);
+		testInstantiationService.dispose();
 	});
 
 	test('Log Telemetry if log level is trace', async () => {
@@ -108,5 +109,6 @@ suite('TelemetryLogAdapter', () => {
 				isTrue: 1, numberBetween1And3: 2
 			}
 		}]));
+		testInstantiationService.dispose();
 	});
 });

src/vs/platform/terminal/test/common/requestStore.test.ts

@@ -17,6 +17,10 @@ suite('RequestStore', () => {
 		instantiationService.stub(ILogService, new LogService(new ConsoleLogger()));
 	});
 
+	teardown(() => {
+		instantiationService.dispose();
+	});
+
 	test('should resolve requests', async () => {
 		const store: RequestStore<{ data: string }, { arg: string }> = instantiationService.createInstance(RequestStore<{ data: string }, { arg: string }>, undefined);
 		let eventArgs: { requestId: number; arg: string } | undefined;

src/vs/workbench/api/test/browser/extHostAuthentication.test.ts

@@ -127,6 +127,10 @@ suite('ExtHostAuthentication', () => {
 			{ supportsMultipleAccounts: true }));
 	});
 
+	suiteTeardown(() => {
+		instantiationService.dispose();
+	});
+
 	teardown(() => {
 		disposables.dispose();
 	});

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

@@ -67,6 +67,7 @@ suite('ExtHostLanguageFeatures', function () {
 	let rpcProtocol: TestRPCProtocol;
 	let languageFeaturesService: ILanguageFeaturesService;
 	let originalErrorHandler: (e: any) => any;
+	let instantiationService: TestInstantiationService;
 
 	suiteSetup(() => {
 
@@ -87,7 +88,7 @@ suite('ExtHostLanguageFeatures', function () {
 		// Use IInstantiationService to get typechecking when instantiating
 		let inst: IInstantiationService;
 		{
-			const instantiationService = new TestInstantiationService();
+			instantiationService = new TestInstantiationService();
 			instantiationService.stub(IMarkerService, MarkerService);
 			instantiationService.set(ILanguageFeaturesService, languageFeaturesService);
 			instantiationService.set(IUriIdentityService, new class extends mock<IUriIdentityService>() {
@@ -140,6 +141,7 @@ suite('ExtHostLanguageFeatures', function () {
 		setUnexpectedErrorHandler(originalErrorHandler);
 		model.dispose();
 		mainThread.dispose();
+		instantiationService.dispose();
 	});
 
 	teardown(() => {