remove cancelableThen, overload timeout

src/vs/base/common/async.ts

@@ -26,8 +26,6 @@ export function toThenable<T>(arg: T | Thenable<T>): Thenable<T> {
 
 export interface CancelablePromise<T> extends Promise<T> {
 	cancel(): void;
-	cancelableThen<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): CancelablePromise<U>;
-	cancelableThen<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => void): CancelablePromise<U>;
 }
 
 export function createCancelablePromise<T>(callback: (token: CancellationToken) => Thenable<T>): CancelablePromise<T> {
@@ -57,13 +55,6 @@ export function createCancelablePromise<T>(callback: (token: CancellationToken)
 		catch<TResult = never>(reject?: ((reason: any) => TResult | Thenable<TResult>) | undefined | null): Promise<T | TResult> {
 			return this.then(undefined, reject);
 		}
-		cancelableThen<TResult1 = T, TResult2 = never>(resolve?: ((value: T) => TResult1 | Thenable<TResult1>) | undefined | null, reject?: ((reason: any) => TResult2 | Thenable<TResult2>) | undefined | null): CancelablePromise<TResult1 | TResult2> {
-			return createCancelablePromise<TResult1 | TResult2>(token => {
-				const listener = token.onCancellationRequested(_ => this.cancel());
-				always(promise, () => listener.dispose());
-				return this.then(resolve, reject);
-			});
-		}
 	};
 }
 
@@ -383,14 +374,18 @@ export class ShallowCancelThenPromise<T> extends TPromise<T> {
 /**
  * Replacement for `WinJS.TPromise.timeout`.
  */
-export function timeout(n: number): CancelablePromise<void> {
-	return createCancelablePromise(token => {
-		return new Promise((resolve, reject) => {
-			const handle = setTimeout(resolve, n);
-			token.onCancellationRequested(_ => {
-				clearTimeout(handle);
-				reject(errors.canceled());
-			});
+export function timeout(millis: number): CancelablePromise<void>;
+export function timeout(millis: number, token: CancellationToken): Thenable<void>;
+export function timeout(millis: number, token?: CancellationToken): CancelablePromise<void> | Thenable<void> {
+	if (!token) {
+		return createCancelablePromise(token => timeout(millis, token));
+	}
+
+	return new Promise((resolve, reject) => {
+		const handle = setTimeout(resolve, millis);
+		token.onCancellationRequested(() => {
+			clearTimeout(handle);
+			reject(errors.canceled());
 		});
 	});
 }

src/vs/base/common/cache.ts

@@ -5,30 +5,34 @@
 
 'use strict';
 
-import { CancelablePromise } from 'vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
+import { always } from 'vs/base/common/async';
 
 export interface CacheResult<T> {
 	promise: Thenable<T>;
 	dispose(): void;
 }
 
-export default class Cache<T> {
+export class Cache<T> {
 
 	private result: CacheResult<T> = null;
-	constructor(private task: () => CancelablePromise<T>) { }
+	constructor(private task: (ct: CancellationToken) => Thenable<T>) { }
 
 	get(): CacheResult<T> {
 		if (this.result) {
 			return this.result;
 		}
 
-		const promise = this.task();
+		const cts = new CancellationTokenSource();
+		const promise = this.task(cts.token);
+		always(promise, () => cts.dispose());
 
 		this.result = {
 			promise,
 			dispose: () => {
 				this.result = null;
-				promise.cancel();
+				cts.cancel();
+				cts.dispose();
 			}
 		};
 

src/vs/base/test/common/cache.test.ts

@@ -6,15 +6,15 @@
 'use strict';
 
 import * as assert from 'assert';
-import Cache from 'vs/base/common/cache';
+import { Cache } from 'vs/base/common/cache';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { createCancelablePromise, timeout } from 'vs/base/common/async';
+import { timeout } from 'vs/base/common/async';
 
 suite('Cache', () => {
 
 	test('simple value', () => {
 		let counter = 0;
-		const cache = new Cache(() => createCancelablePromise(_ => TPromise.as(counter++)));
+		const cache = new Cache(_ => TPromise.as(counter++));
 
 		return cache.get().promise
 			.then(c => assert.equal(c, 0), () => assert.fail('Unexpected assertion error'))
@@ -24,7 +24,7 @@ suite('Cache', () => {
 
 	test('simple error', () => {
 		let counter = 0;
-		const cache = new Cache(() => createCancelablePromise(_ => TPromise.wrapError(new Error(String(counter++)))));
+		const cache = new Cache(_ => TPromise.wrapError(new Error(String(counter++))));
 
 		return cache.get().promise
 			.then(() => assert.fail('Unexpected assertion error'), err => assert.equal(err.message, 0))
@@ -35,9 +35,9 @@ suite('Cache', () => {
 	test('should retry cancellations', () => {
 		let counter1 = 0, counter2 = 0;
 
-		const cache = new Cache(() => {
+		const cache = new Cache(token => {
 			counter1++;
-			return timeout(2).cancelableThen(() => counter2++);
+			return timeout(2, token).then(() => counter2++);
 		});
 
 		assert.equal(counter1, 0);

src/vs/workbench/parts/extensions/electron-browser/extensionEditor.ts

@@ -13,7 +13,7 @@ import { createCancelablePromise, wireCancellationToken } from 'vs/base/common/a
 import * as arrays from 'vs/base/common/arrays';
 import { OS } from 'vs/base/common/platform';
 import { Event, Emitter, once, chain } from 'vs/base/common/event';
-import Cache, { CacheResult } from 'vs/base/common/cache';
+import { Cache, CacheResult } from 'vs/base/common/cache';
 import { Action } from 'vs/base/common/actions';
 import { isPromiseCanceledError } from 'vs/base/common/errors';
 import { IDisposable, dispose, toDisposable } from 'vs/base/common/lifecycle';

src/vs/workbench/services/search/node/rawSearchService.ts

@@ -456,9 +456,6 @@ export class SearchService implements IRawSearchService {
 			catch(reject?) {
 				return this.then(undefined, reject);
 			}
-			cancelableThen(resolve, reject) {
-				return createCancelablePromise(_ => this.then(resolve, reject));
-			}
 		};
 	}
 }