remove async.always

fixes #67027

src/vs/base/browser/ui/tree/asyncDataTree.ts

@@ -9,7 +9,7 @@ import { IListVirtualDelegate, IIdentityProvider, IListDragAndDrop, IListDragOve
 import { ITreeElement, ITreeNode, ITreeRenderer, ITreeEvent, ITreeMouseEvent, ITreeContextMenuEvent, ITreeSorter, ICollapseStateChangeEvent, IAsyncDataSource, ITreeDragAndDrop } from 'vs/base/browser/ui/tree/tree';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { Emitter, Event } from 'vs/base/common/event';
-import { timeout, always, CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
+import { timeout, CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
 import { IListStyles } from 'vs/base/browser/ui/list/listWidget';
 import { Iterator } from 'vs/base/common/iterator';
 import { IDragAndDropData } from 'vs/base/browser/dnd';
@@ -673,7 +673,8 @@ export class AsyncDataTree<TInput, T, TFilterData = void> implements IDisposable
 				this._onDidChangeNodeSlowState.fire(node);
 			}, _ => null);
 
-			childrenPromise = always(this.doGetChildren(node), () => slowTimeout.cancel());
+			childrenPromise = this.doGetChildren(node)
+				.finally(() => slowTimeout.cancel());
 		}
 
 		try {
@@ -715,8 +716,10 @@ export class AsyncDataTree<TInput, T, TFilterData = void> implements IDisposable
 
 			return children;
 		});
+
 		this.refreshPromises.set(node, result);
-		return always(result, () => this.refreshPromises.delete(node));
+
+		return result.finally(() => this.refreshPromises.delete(node));
 	}
 
 	private _onDidChangeCollapseState({ node, deep }: ICollapseStateChangeEvent<IAsyncDataTreeNode<TInput, T>, any>): void {

src/vs/base/common/async.ts

@@ -45,7 +45,7 @@ export function createCancelablePromise<T>(callback: (token: CancellationToken)
 			return this.then(undefined, reject);
 		}
 		finally(onfinally?: (() => void) | undefined | null): Promise<T> {
-			return always(promise, onfinally || (() => { }));
+			return promise.finally(onfinally);
 		}
 	};
 }
@@ -326,25 +326,6 @@ export function disposableTimeout(handler: () => void, timeout = 0): IDisposable
 	return toDisposable(() => clearTimeout(timer));
 }
 
-/**
- * Returns a new promise that joins the provided promise. Upon completion of
- * the provided promise the provided function will always be called. This
- * method is comparable to a try-finally code block.
- * @param promise a promise
- * @param callback a function that will be call in the success and error case.
- */
-export function always<T>(promise: Promise<T>, callback: () => void): Promise<T> {
-	function safeCallback() {
-		try {
-			callback();
-		} catch (err) {
-			errors.onUnexpectedError(err);
-		}
-	}
-	promise.then(_ => safeCallback(), _ => safeCallback());
-	return Promise.resolve(promise);
-}
-
 export function ignoreErrors<T>(promise: Promise<T>): Promise<T | undefined> {
 	return promise.then(undefined, _ => undefined);
 }

src/vs/base/common/cache.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
-import { always } from 'vs/base/common/async';
 
 export interface CacheResult<T> {
 	promise: Promise<T>;
@@ -23,7 +22,7 @@ export class Cache<T> {
 
 		const cts = new CancellationTokenSource();
 		const promise = this.task(cts.token);
-		always(promise, () => cts.dispose());
+		promise.finally(() => cts.dispose());
 
 		this.result = {
 			promise,

src/vs/base/parts/ipc/node/ipc.cp.ts

@@ -5,7 +5,7 @@
 
 import { ChildProcess, fork, ForkOptions } from 'child_process';
 import { IDisposable, toDisposable, dispose } from 'vs/base/common/lifecycle';
-import { Delayer, always, createCancelablePromise } from 'vs/base/common/async';
+import { Delayer, createCancelablePromise } from 'vs/base/common/async';
 import { deepClone, assign } from 'vs/base/common/objects';
 import { Emitter, Event } from 'vs/base/common/event';
 import { createQueuedSender } from 'vs/base/node/processes';
@@ -132,7 +132,7 @@ export class Client implements IChannelClient, IDisposable {
 		const disposable = toDisposable(() => result.cancel());
 		this.activeRequests.add(disposable);
 
-		always(result, () => {
+		result.finally(() => {
 			cancellationTokenListener.dispose();
 			this.activeRequests.delete(disposable);
 

src/vs/base/parts/ipc/node/ipc.ts

@@ -5,7 +5,7 @@
 
 import { IDisposable, toDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
 import { Event, Emitter, Relay } from 'vs/base/common/event';
-import { always, CancelablePromise, createCancelablePromise, timeout } from 'vs/base/common/async';
+import { CancelablePromise, createCancelablePromise, timeout } from 'vs/base/common/async';
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
 import * as errors from 'vs/base/common/errors';
 
@@ -448,9 +448,7 @@ export class ChannelClient implements IChannelClient, IDisposable {
 			this.activeRequests.add(disposable);
 		});
 
-		always(result, () => this.activeRequests.delete(disposable));
-
-		return result;
+		return result.finally(() => this.activeRequests.delete(disposable));
 	}
 
 	private requestEvent(channelName: string, name: string, arg?: any): Event<any> {

src/vs/base/parts/ipc/test/node/ipc.cp.test.ts

@@ -5,7 +5,6 @@
 
 import * as assert from 'assert';
 import { Client } from 'vs/base/parts/ipc/node/ipc.cp';
-import { always } from 'vs/base/common/async';
 import { TestServiceClient } from './testService';
 import { getPathFromAmdModule } from 'vs/base/common/amd';
 
@@ -27,7 +26,7 @@ suite('IPC, Child Process', () => {
 			assert.equal(r.outgoing, 'pong');
 		});
 
-		return always(result, () => client.dispose());
+		return result.finally(() => client.dispose());
 	});
 
 	test('events', () => {
@@ -49,7 +48,7 @@ suite('IPC, Child Process', () => {
 		const request = service.marco();
 		const result = Promise.all([request, event]);
 
-		return always(result, () => client.dispose());
+		return result.finally(() => client.dispose());
 	});
 
 	test('event dispose', () => {
@@ -74,6 +73,6 @@ suite('IPC, Child Process', () => {
 			assert.equal(count, 2);
 		});
 
-		return always(result, () => client.dispose());
+		return result.finally(() => client.dispose());
 	});
 });