Fixes CI (microsoft#189440)

Author: hediet

src/vs/base/common/observableInternal/autorun.ts

@@ -100,15 +100,15 @@ export class AutorunObserver<TChangeSummary = any> implements IObserver, IReader
 			const name = this._debugName();
 			if (name !== undefined) { return name; }
 		}
-		const name = getFunctionName(this.runFn);
+		const name = getFunctionName(this._runFn);
 		if (name !== undefined) { return name; }
 
 		return '(anonymous)';
 	}
 
 	constructor(
 		private readonly _debugName: string | (() => string | undefined) | undefined,
-		private readonly runFn: (reader: IReader, changeSummary: TChangeSummary) => void,
+		public readonly _runFn: (reader: IReader, changeSummary: TChangeSummary) => void,
 		private readonly createChangeSummary: (() => TChangeSummary) | undefined,
 		private readonly _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined,
 	) {
@@ -141,7 +141,7 @@ export class AutorunObserver<TChangeSummary = any> implements IObserver, IReader
 				getLogger()?.handleAutorunTriggered(this);
 				const changeSummary = this.changeSummary!;
 				this.changeSummary = this.createChangeSummary?.();
-				this.runFn(this, changeSummary);
+				this._runFn(this, changeSummary);
 			}
 		} finally {
 			getLogger()?.handleAutorunFinished(this);

src/vs/base/common/observableInternal/base.ts

@@ -225,15 +225,15 @@ export function subtransaction(tx: ITransaction | undefined, fn: (tx: ITransacti
 export class TransactionImpl implements ITransaction {
 	private updatingObservers: { observer: IObserver; observable: IObservable<any> }[] | null = [];
 
-	constructor(private readonly fn: Function, private readonly _getDebugName?: () => string) {
+	constructor(public readonly _fn: Function, private readonly _getDebugName?: () => string) {
 		getLogger()?.handleBeginTransaction(this);
 	}
 
 	public getDebugName(): string | undefined {
 		if (this._getDebugName) {
 			return this._getDebugName();
 		}
-		return getFunctionName(this.fn);
+		return getFunctionName(this._fn);
 	}
 
 	public updateObserver(observer: IObserver, observable: IObservable<any>): void {

src/vs/base/common/observableInternal/derived.ts

@@ -68,14 +68,14 @@ export class Derived<T, TChangeSummary = any> extends BaseObservable<T, void> im
 
 	public override get debugName(): string {
 		if (!this._debugName) {
-			return getFunctionName(this.computeFn) || '(anonymous)';
+			return getFunctionName(this._computeFn) || '(anonymous)';
 		}
 		return typeof this._debugName === 'function' ? this._debugName() : this._debugName;
 	}
 
 	constructor(
 		private readonly _debugName: string | (() => string) | undefined,
-		private readonly computeFn: (reader: IReader, changeSummary: TChangeSummary) => T,
+		public readonly _computeFn: (reader: IReader, changeSummary: TChangeSummary) => T,
 		private readonly createChangeSummary: (() => TChangeSummary) | undefined,
 		private readonly _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined,
 		private readonly _handleLastObserverRemoved: (() => void) | undefined = undefined
@@ -104,7 +104,7 @@ export class Derived<T, TChangeSummary = any> extends BaseObservable<T, void> im
 		if (this.observers.size === 0) {
 			// Without observers, we don't know when to clean up stuff.
 			// Thus, we don't cache anything to prevent memory leaks.
-			const result = this.computeFn(this, this.createChangeSummary?.()!);
+			const result = this._computeFn(this, this.createChangeSummary?.()!);
 			// Clear new dependencies
 			this.onLastObserverRemoved();
 			return result;
@@ -153,7 +153,7 @@ export class Derived<T, TChangeSummary = any> extends BaseObservable<T, void> im
 		this.changeSummary = this.createChangeSummary?.();
 		try {
 			/** might call {@link handleChange} indirectly, which could invalidate us */
-			this.value = this.computeFn(this, changeSummary);
+			this.value = this._computeFn(this, changeSummary);
 		} finally {
 			// We don't want our observed observables to think that they are (not even temporarily) not being observed.
 			// Thus, we only unsubscribe from observables that are definitely not read anymore.

src/vs/base/common/observableInternal/logging.ts

@@ -114,7 +114,7 @@ export class ConsoleObservableLogger implements IObservableLogger {
 			styled(derived.debugName, { color: 'BlueViolet' }),
 			...this.formatInfo(info),
 			this.formatChanges(changedObservables),
-			{ data: [{ fn: derived['computeFn'] }] }
+			{ data: [{ fn: derived._computeFn }] }
 		]));
 		changedObservables.clear();
 	}
@@ -124,7 +124,7 @@ export class ConsoleObservableLogger implements IObservableLogger {
 			formatKind('observable from event triggered'),
 			styled(observable.debugName, { color: 'BlueViolet' }),
 			...this.formatInfo(info),
-			{ data: [{ fn: observable['getValue'] }] }
+			{ data: [{ fn: observable._getValue }] }
 		]));
 	}
 
@@ -143,7 +143,7 @@ export class ConsoleObservableLogger implements IObservableLogger {
 			formatKind('autorun'),
 			styled(autorun.debugName, { color: 'BlueViolet' }),
 			this.formatChanges(changedObservables),
-			{ data: [{ fn: autorun['runFn'] }] }
+			{ data: [{ fn: autorun._runFn }] }
 		]));
 		changedObservables.clear();
 		this.indentation++;
@@ -161,7 +161,7 @@ export class ConsoleObservableLogger implements IObservableLogger {
 		console.log(...this.textToConsoleArgs([
 			formatKind('transaction'),
 			styled(transactionName, { color: 'BlueViolet' }),
-			{ data: [{ fn: transaction['fn'] }] }
+			{ data: [{ fn: transaction._fn }] }
 		]));
 		this.indentation++;
 	}

src/vs/base/common/observableInternal/utils.ts

@@ -89,13 +89,13 @@ export class FromEventObservable<TArgs, T> extends BaseObservable<T> {
 
 	constructor(
 		private readonly event: Event<TArgs>,
-		private readonly getValue: (args: TArgs | undefined) => T
+		public readonly _getValue: (args: TArgs | undefined) => T
 	) {
 		super();
 	}
 
 	private getDebugName(): string | undefined {
-		return getFunctionName(this.getValue);
+		return getFunctionName(this._getValue);
 	}
 
 	public get debugName(): string {
@@ -108,7 +108,7 @@ export class FromEventObservable<TArgs, T> extends BaseObservable<T> {
 	}
 
 	private readonly handleEvent = (args: TArgs | undefined) => {
-		const newValue = this.getValue(args);
+		const newValue = this._getValue(args);
 
 		const didChange = !this.hasValue || this.value !== newValue;
 
@@ -150,7 +150,7 @@ export class FromEventObservable<TArgs, T> extends BaseObservable<T> {
 			return this.value!;
 		} else {
 			// no cache, as there are no subscribers to keep it updated
-			return this.getValue(undefined);
+			return this._getValue(undefined);
 		}
 	}
 }