Merge from vscode fb5dc0083bfa9a0e3da7ed1f86e1ecb9836fcc8b

src/vs/platform/actions/browser/menuEntryActionViewItem.ts

@@ -12,7 +12,7 @@ import { IdGenerator } from 'vs/base/common/idGenerator';
 import { IDisposable, toDisposable, MutableDisposable, DisposableStore, dispose } from 'vs/base/common/lifecycle';
 import { isLinux, isWindows } from 'vs/base/common/platform';
 import { localize } from 'vs/nls';
-import { ICommandAction, IMenu, IMenuActionOptions, MenuItemAction, SubmenuItemAction } from 'vs/platform/actions/common/actions';
+import { ICommandAction, IMenu, IMenuActionOptions, MenuItemAction, SubmenuItemAction, Icon } from 'vs/platform/actions/common/actions';
 import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { INotificationService } from 'vs/platform/notification/common/notification';
@@ -217,9 +217,10 @@ export class MenuEntryActionViewItem extends ActionViewItem {
 			const keybinding = this._keybindingService.lookupKeybinding(this._commandAction.id);
 			const keybindingLabel = keybinding && keybinding.getLabel();
 
+			const tooltip = this._commandAction.tooltip || this._commandAction.label;
 			this.label.title = keybindingLabel
-				? localize('titleAndKb', "{0} ({1})", this._commandAction.label, keybindingLabel)
-				: this._commandAction.label;
+				? localize('titleAndKb', "{0} ({1})", tooltip, keybindingLabel)
+				: tooltip;
 		}
 	}
 
@@ -238,9 +239,11 @@ export class MenuEntryActionViewItem extends ActionViewItem {
 	_updateItemClass(item: ICommandAction): void {
 		this._itemClassDispose.value = undefined;
 
-		if (ThemeIcon.isThemeIcon(item.icon)) {
+		const icon = this._commandAction.checked && (item.toggled as { icon?: Icon })?.icon ? (item.toggled as { icon: Icon }).icon : item.icon;
+
+		if (ThemeIcon.isThemeIcon(icon)) {
 			// theme icons
-			const iconClass = ThemeIcon.asClassName(item.icon);
+			const iconClass = ThemeIcon.asClassName(icon);
 			if (this.label && iconClass) {
 				addClasses(this.label, iconClass);
 				this._itemClassDispose.value = toDisposable(() => {
@@ -250,20 +253,20 @@ export class MenuEntryActionViewItem extends ActionViewItem {
 				});
 			}
 
-		} else if (item.icon) {
+		} else if (icon) {
 			// icon path
 			let iconClass: string;
 
-			if (item.icon?.dark?.scheme) {
+			if (icon?.dark?.scheme) {
 
-				const iconPathMapKey = item.icon.dark.toString();
+				const iconPathMapKey = icon.dark.toString();
 
 				if (MenuEntryActionViewItem.ICON_PATH_TO_CSS_RULES.has(iconPathMapKey)) {
 					iconClass = MenuEntryActionViewItem.ICON_PATH_TO_CSS_RULES.get(iconPathMapKey)!;
 				} else {
 					iconClass = ids.nextId();
-					createCSSRule(`.icon.${iconClass}`, `background-image: ${asCSSUrl(item.icon.light || item.icon.dark)}`);
-					createCSSRule(`.vs-dark .icon.${iconClass}, .hc-black .icon.${iconClass}`, `background-image: ${asCSSUrl(item.icon.dark)}`);
+					createCSSRule(`.icon.${iconClass}`, `background-image: ${asCSSUrl(icon.light || icon.dark)}`);
+					createCSSRule(`.vs-dark .icon.${iconClass}, .hc-black .icon.${iconClass}`, `background-image: ${asCSSUrl(icon.dark)}`);
 					MenuEntryActionViewItem.ICON_PATH_TO_CSS_RULES.set(iconPathMapKey, iconClass);
 				}
 

src/vs/platform/actions/common/actions.ts

@@ -20,13 +20,16 @@ export interface ILocalizedString {
 	original: string;
 }
 
+export type Icon = { dark?: URI; light?: URI; } | ThemeIcon;
+
 export interface ICommandAction {
 	id: string;
 	title: string | ILocalizedString;
 	category?: string | ILocalizedString;
-	icon?: { dark?: URI; light?: URI; } | ThemeIcon;
+	tooltip?: string | ILocalizedString;
+	icon?: Icon;
 	precondition?: ContextKeyExpression;
-	toggled?: ContextKeyExpression;
+	toggled?: ContextKeyExpression | { condition: ContextKeyExpression, icon?: Icon, tooltip?: string | ILocalizedString };
 }
 
 export type ISerializableCommandAction = UriDto<ICommandAction>;
@@ -280,9 +283,20 @@ export class MenuItemAction extends ExecuteCommandAction {
 		@ICommandService commandService: ICommandService
 	) {
 		typeof item.title === 'string' ? super(item.id, item.title, commandService) : super(item.id, item.title.value, commandService);
+
 		this._cssClass = undefined;
 		this._enabled = !item.precondition || contextKeyService.contextMatchesRules(item.precondition);
-		this._checked = Boolean(item.toggled && contextKeyService.contextMatchesRules(item.toggled));
+		this._tooltip = item.tooltip ? typeof item.tooltip === 'string' ? item.tooltip : item.tooltip.value : undefined;
+
+		if (item.toggled) {
+			const toggled = ((item.toggled as { condition: ContextKeyExpression }).condition ? item.toggled : { condition: item.toggled }) as {
+				condition: ContextKeyExpression, icon?: Icon, tooltip?: string | ILocalizedString
+			};
+			this._checked = contextKeyService.contextMatchesRules(toggled.condition);
+			if (this._checked && toggled.tooltip) {
+				this._tooltip = typeof toggled.tooltip === 'string' ? toggled.tooltip : toggled.tooltip.value;
+			}
+		}
 
 		this._options = options || {};
 

src/vs/platform/actions/common/menuService.ts

@@ -94,7 +94,8 @@ class Menu implements IMenu {
 
 			// keep toggled keys for event if applicable
 			if (isIMenuItem(item) && item.command.toggled) {
-				Menu._fillInKbExprKeys(item.command.toggled, this._contextKeys);
+				const toggledExpression: ContextKeyExpression = (item.command.toggled as { condition: ContextKeyExpression }).condition || item.command.toggled as ContextKeyExpression; // {{SQL CARBON EDIT}} strict-null-checks
+				Menu._fillInKbExprKeys(toggledExpression, this._contextKeys);
 			}
 		}
 		this._onDidChange.fire(this);

src/vs/platform/contextkey/common/contextkey.ts

@@ -1051,7 +1051,7 @@ export class ContextKeyLessThanEqualsExpr implements IContextKeyExpression {
 	}
 
 	public equals(other: ContextKeyExpression): boolean {
-		if (other instanceof ContextKeyLessThanEqualsExpr) {
+		if (other.type === this.type) {
 			return (this.key === other.key && this.value === other.value);
 		}
 		return false;

src/vs/platform/environment/common/environment.ts

@@ -39,7 +39,6 @@ export interface ParsedArgs {
 	'builtin-extensions-dir'?: string;
 	extensionDevelopmentPath?: string[]; // // undefined or array of 1 or more local paths or URIs
 	extensionTestsPath?: string; // either a local path or a URI
-	'extension-development-confirm-save'?: boolean;
 	'inspect-extensions'?: string;
 	'inspect-brk-extensions'?: string;
 	debugId?: string;

src/vs/platform/environment/node/argv.ts

@@ -80,7 +80,6 @@ export const OPTIONS: OptionDescriptions<Required<ParsedArgs>> = {
 	'locate-extension': { type: 'string[]' },
 	'extensionDevelopmentPath': { type: 'string[]' },
 	'extensionTestsPath': { type: 'string' },
-	'extension-development-confirm-save': { type: 'boolean' },
 	'debugId': { type: 'string' },
 	'inspect-search': { type: 'string', deprecates: 'debugSearch' },
 	'inspect-brk-search': { type: 'string', deprecates: 'debugBrkSearch' },

src/vs/platform/quickinput/browser/commandsQuickAccess.ts

@@ -0,0 +1,305 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { IQuickPickSeparator } from 'vs/platform/quickinput/common/quickInput';
+import { PickerQuickAccessProvider, IPickerQuickAccessItem } from 'vs/platform/quickinput/common/quickAccess';
+import { distinct } from 'vs/base/common/arrays';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { DisposableStore, Disposable, IDisposable } from 'vs/base/common/lifecycle';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString } from 'vs/base/common/filters';
+import { withNullAsUndefined } from 'vs/base/common/types';
+import { LRUCache } from 'vs/base/common/map';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { WorkbenchActionExecutedEvent, WorkbenchActionExecutedClassification } from 'vs/base/common/actions';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { isPromiseCanceledError } from 'vs/base/common/errors';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { isFirefox } from 'vs/base/browser/browser';
+import { timeout } from 'vs/base/common/async';
+
+export interface ICommandQuickPick extends IPickerQuickAccessItem {
+	commandId: string;
+	commandAlias: string | undefined;
+}
+
+export interface ICommandsQuickAccessOptions {
+	showAlias: boolean;
+}
+
+export abstract class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider<ICommandQuickPick> implements IDisposable {
+
+	static PREFIX = '>';
+
+	private static WORD_FILTER = or(matchesPrefix, matchesWords, matchesContiguousSubString);
+
+	private readonly disposables = new DisposableStore();
+
+	private readonly commandsHistory = this.disposables.add(this.instantiationService.createInstance(CommandsHistory));
+
+	constructor(
+		private options: ICommandsQuickAccessOptions,
+		@IInstantiationService private readonly instantiationService: IInstantiationService,
+		@IKeybindingService private readonly keybindingService: IKeybindingService,
+		@ICommandService private readonly commandService: ICommandService,
+		@ITelemetryService private readonly telemetryService: ITelemetryService,
+		@INotificationService private readonly notificationService: INotificationService
+	) {
+		super(AbstractCommandsQuickAccessProvider.PREFIX);
+	}
+
+	protected async getPicks(filter: string, disposables: DisposableStore, token: CancellationToken): Promise<Array<ICommandQuickPick | IQuickPickSeparator>> {
+
+		// Ask subclass for all command picks
+		const allCommandPicks = await this.getCommandPicks(disposables, token);
+
+		// Filter
+		const filteredCommandPicks: ICommandQuickPick[] = [];
+		for (const commandPick of allCommandPicks) {
+			const labelHighlights = withNullAsUndefined(AbstractCommandsQuickAccessProvider.WORD_FILTER(filter, commandPick.label));
+			const aliasHighlights = commandPick.commandAlias ? withNullAsUndefined(AbstractCommandsQuickAccessProvider.WORD_FILTER(filter, commandPick.commandAlias)) : undefined;
+
+			if (labelHighlights || aliasHighlights) {
+				commandPick.highlights = {
+					label: labelHighlights,
+					detail: this.options.showAlias ? aliasHighlights : undefined
+				};
+
+				filteredCommandPicks.push(commandPick);
+			}
+		}
+
+		// Remove duplicates
+		const distinctCommandPicks = distinct(filteredCommandPicks, pick => `${pick.label}${pick.commandId}`);
+
+		// Add description to commands that have duplicate labels
+		const mapLabelToCommand = new Map<string, ICommandQuickPick>();
+		for (const commandPick of distinctCommandPicks) {
+			const existingCommandForLabel = mapLabelToCommand.get(commandPick.label);
+			if (existingCommandForLabel) {
+				commandPick.description = commandPick.commandId;
+				existingCommandForLabel.description = existingCommandForLabel.commandId;
+			} else {
+				mapLabelToCommand.set(commandPick.label, commandPick);
+			}
+		}
+
+		// Sort by MRU order and fallback to name otherwise
+		distinctCommandPicks.sort((commandPickA, commandPickB) => {
+			const commandACounter = this.commandsHistory.peek(commandPickA.commandId);
+			const commandBCounter = this.commandsHistory.peek(commandPickB.commandId);
+
+			if (commandACounter && commandBCounter) {
+				return commandACounter > commandBCounter ? -1 : 1; // use more recently used command before older
+			}
+
+			if (commandACounter) {
+				return -1; // first command was used, so it wins over the non used one
+			}
+
+			if (commandBCounter) {
+				return 1; // other command was used so it wins over the command
+			}
+
+			// both commands were never used, so we sort by name
+			return commandPickA.label.localeCompare(commandPickB.label);
+		});
+
+		const commandPicks: Array<ICommandQuickPick | IQuickPickSeparator> = [];
+
+		let addSeparator = false;
+		for (let i = 0; i < distinctCommandPicks.length; i++) {
+			const commandPick = distinctCommandPicks[i];
+			const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
+			const ariaLabel = keybinding ?
+				localize('commandPickAriaLabelWithKeybinding', "{0}, {1}, commands picker", commandPick.label, keybinding.getAriaLabel()) :
+				localize('commandPickAriaLabel', "{0}, commands picker", commandPick.label);
+
+			// Separator: recently used
+			if (i === 0 && this.commandsHistory.peek(commandPick.commandId)) {
+				commandPicks.push({ type: 'separator', label: localize('recentlyUsed', "recently used") });
+				addSeparator = true;
+			}
+
+			// Separator: other commands
+			if (i !== 0 && addSeparator && !this.commandsHistory.peek(commandPick.commandId)) {
+				commandPicks.push({ type: 'separator', label: localize('morecCommands', "other commands") });
+				addSeparator = false; // only once
+			}
+
+			// Command
+			commandPicks.push({
+				...commandPick,
+				ariaLabel,
+				detail: this.options.showAlias ? commandPick.commandAlias : undefined,
+				keybinding,
+				accept: async () => {
+
+					// Add to history
+					this.commandsHistory.push(commandPick.commandId);
+
+					if (!isFirefox) {
+						// Use a timeout to give the quick open widget a chance to close itself first
+						// Firefox: since the browser is quite picky for certain commands, we do not
+						// use a timeout (https://github.com/microsoft/vscode/issues/83288)
+						await timeout(50);
+					}
+
+					// Telementry
+					this.telemetryService.publicLog2<WorkbenchActionExecutedEvent, WorkbenchActionExecutedClassification>('workbenchActionExecuted', {
+						id: commandPick.commandId,
+						from: 'quick open'
+					});
+
+					// Run
+					try {
+						await this.commandService.executeCommand(commandPick.commandId);
+					} catch (error) {
+						if (!isPromiseCanceledError(error)) {
+							this.notificationService.error(localize('canNotRun', "Command '{0}' resulted in an error ({1})", commandPick.label, toErrorMessage(error)));
+						}
+					}
+				}
+			});
+		}
+
+		return commandPicks;
+	}
+
+	protected abstract getCommandPicks(disposables: DisposableStore, token: CancellationToken): Promise<Array<ICommandQuickPick>>;
+
+	dispose(): void {
+		this.disposables.dispose();
+	}
+}
+
+interface ISerializedCommandHistory {
+	usesLRU?: boolean;
+	entries: { key: string; value: number }[];
+}
+
+interface ICommandsQuickAccessConfiguration {
+	workbench: {
+		commandPalette: {
+			history: number;
+			preserveInput: boolean;
+		}
+	};
+}
+
+class CommandsHistory extends Disposable {
+
+	static readonly DEFAULT_COMMANDS_HISTORY_LENGTH = 50;
+
+	private static readonly PREF_KEY_CACHE = 'commandPalette.mru.cache';
+	private static readonly PREF_KEY_COUNTER = 'commandPalette.mru.counter';
+
+	private static cache: LRUCache<string, number> | undefined;
+	private static counter = 1;
+
+	private configuredCommandsHistoryLength = 0;
+
+	constructor(
+		@IStorageService private readonly storageService: IStorageService,
+		@IConfigurationService private readonly configurationService: IConfigurationService
+	) {
+		super();
+
+		this.updateConfiguration();
+		this.load();
+
+		this.registerListeners();
+	}
+
+	private registerListeners(): void {
+		this._register(this.configurationService.onDidChangeConfiguration(() => this.updateConfiguration()));
+	}
+
+	private updateConfiguration(): void {
+		this.configuredCommandsHistoryLength = CommandsHistory.getConfiguredCommandHistoryLength(this.configurationService);
+
+		if (CommandsHistory.cache && CommandsHistory.cache.limit !== this.configuredCommandsHistoryLength) {
+			CommandsHistory.cache.limit = this.configuredCommandsHistoryLength;
+
+			CommandsHistory.saveState(this.storageService);
+		}
+	}
+
+	private load(): void {
+		const raw = this.storageService.get(CommandsHistory.PREF_KEY_CACHE, StorageScope.GLOBAL);
+		let serializedCache: ISerializedCommandHistory | undefined;
+		if (raw) {
+			try {
+				serializedCache = JSON.parse(raw);
+			} catch (error) {
+				// invalid data
+			}
+		}
+
+		const cache = CommandsHistory.cache = new LRUCache<string, number>(this.configuredCommandsHistoryLength, 1);
+		if (serializedCache) {
+			let entries: { key: string; value: number }[];
+			if (serializedCache.usesLRU) {
+				entries = serializedCache.entries;
+			} else {
+				entries = serializedCache.entries.sort((a, b) => a.value - b.value);
+			}
+			entries.forEach(entry => cache.set(entry.key, entry.value));
+		}
+
+		CommandsHistory.counter = this.storageService.getNumber(CommandsHistory.PREF_KEY_COUNTER, StorageScope.GLOBAL, CommandsHistory.counter);
+	}
+
+	push(commandId: string): void {
+		if (!CommandsHistory.cache) {
+			return;
+		}
+
+		CommandsHistory.cache.set(commandId, CommandsHistory.counter++); // set counter to command
+
+		CommandsHistory.saveState(this.storageService);
+	}
+
+	peek(commandId: string): number | undefined {
+		return CommandsHistory.cache?.peek(commandId);
+	}
+
+	static saveState(storageService: IStorageService): void {
+		if (!CommandsHistory.cache) {
+			return;
+		}
+
+		const serializedCache: ISerializedCommandHistory = { usesLRU: true, entries: [] };
+		CommandsHistory.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
+
+		storageService.store(CommandsHistory.PREF_KEY_CACHE, JSON.stringify(serializedCache), StorageScope.GLOBAL);
+		storageService.store(CommandsHistory.PREF_KEY_COUNTER, CommandsHistory.counter, StorageScope.GLOBAL);
+	}
+
+	static getConfiguredCommandHistoryLength(configurationService: IConfigurationService): number {
+		const config = <ICommandsQuickAccessConfiguration>configurationService.getValue();
+
+		const configuredCommandHistoryLength = config.workbench?.commandPalette?.history;
+		if (typeof configuredCommandHistoryLength === 'number') {
+			return configuredCommandHistoryLength;
+		}
+
+		return CommandsHistory.DEFAULT_COMMANDS_HISTORY_LENGTH;
+	}
+
+	static clearHistory(configurationService: IConfigurationService, storageService: IStorageService): void {
+		const commandHistoryLength = CommandsHistory.getConfiguredCommandHistoryLength(configurationService);
+		CommandsHistory.cache = new LRUCache<string, number>(commandHistoryLength);
+		CommandsHistory.counter = 1;
+
+		CommandsHistory.saveState(storageService);
+	}
+}
+

src/vs/platform/quickinput/common/quickAccess.ts

@@ -205,7 +205,7 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 			picksCts = new CancellationTokenSource(token);
 
 			// Collect picks and support both long running and short
-			const res = this.getPicks(picker.value.substr(this.prefix.length).trim(), picksCts.token);
+			const res = this.getPicks(picker.value.substr(this.prefix.length).trim(), disposables.add(new DisposableStore()), picksCts.token);
 			if (Array.isArray(res)) {
 				picker.items = res;
 			} else {
@@ -272,8 +272,14 @@ export abstract class PickerQuickAccessProvider<T extends IPickerQuickAccessItem
 	 *
 	 * The implementor is responsible for filtering and sorting the picks given the
 	 * provided `filter`.
+	 *
+	 * @param filter a filter to apply to the picks.
+	 * @param disposables can be used to register disposables that should be cleaned
+	 * up when the picker closes.
+	 * @param token for long running tasks, implementors need to check on cancellation
+	 * through this token.
 	 */
-	protected abstract getPicks(filter: string, token: CancellationToken): Array<T | IQuickPickSeparator> | Promise<Array<T | IQuickPickSeparator>>;
+	protected abstract getPicks(filter: string, disposables: DisposableStore, token: CancellationToken): Array<T | IQuickPickSeparator> | Promise<Array<T | IQuickPickSeparator>>;
 }
 
 //#endregion

src/vs/platform/resource/common/resourceIdentityService.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { URI } from 'vs/base/common/uri';
+import { hash } from 'vs/base/common/hash';
+import { Disposable } from 'vs/base/common/lifecycle';
+
+export const IResourceIdentityService = createDecorator<IResourceIdentityService>('IResourceIdentityService');
+export interface IResourceIdentityService {
+	_serviceBrand: undefined;
+	resolveResourceIdentity(resource: URI): Promise<string>;
+}
+
+export class WebResourceIdentityService extends Disposable implements IResourceIdentityService {
+	_serviceBrand: undefined;
+	async resolveResourceIdentity(resource: URI): Promise<string> {
+		return hash(resource.toString()).toString(16);
+	}
+}

src/vs/platform/resource/node/resourceIdentityServiceImpl.ts

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createHash } from 'crypto';
+import { stat } from 'vs/base/node/pfs';
+import { Schemas } from 'vs/base/common/network';
+import { URI } from 'vs/base/common/uri';
+import { isLinux, isMacintosh, isWindows } from 'vs/base/common/platform';
+import { IResourceIdentityService } from 'vs/platform/resource/common/resourceIdentityService';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { ResourceMap } from 'vs/base/common/map';
+
+export class NativeResourceIdentityService extends Disposable implements IResourceIdentityService {
+
+	_serviceBrand: undefined;
+
+	private readonly cache: ResourceMap<Promise<string>> = new ResourceMap<Promise<string>>();
+
+	resolveResourceIdentity(resource: URI): Promise<string> {
+		let promise = this.cache.get(resource);
+		if (!promise) {
+			promise = this.createIdentity(resource);
+			this.cache.set(resource, promise);
+		}
+		return promise;
+	}
+
+	private async createIdentity(resource: URI): Promise<string> {
+		// Return early the folder is not local
+		if (resource.scheme !== Schemas.file) {
+			return createHash('md5').update(resource.toString()).digest('hex');
+		}
+
+		const fileStat = await stat(resource.fsPath);
+		let ctime: number | undefined;
+		if (isLinux) {
+			ctime = fileStat.ino; // Linux: birthtime is ctime, so we cannot use it! We use the ino instead!
+		} else if (isMacintosh) {
+			ctime = fileStat.birthtime.getTime(); // macOS: birthtime is fine to use as is
+		} else if (isWindows) {
+			if (typeof fileStat.birthtimeMs === 'number') {
+				ctime = Math.floor(fileStat.birthtimeMs); // Windows: fix precision issue in node.js 8.x to get 7.x results (see https://github.com/nodejs/node/issues/19897)
+			} else {
+				ctime = fileStat.birthtime.getTime();
+			}
+		}
+
+		// we use the ctime as extra salt to the ID so that we catch the case of a folder getting
+		// deleted and recreated. in that case we do not want to carry over previous state
+		return createHash('md5').update(resource.fsPath).update(ctime ? String(ctime) : '').digest('hex');
+	}
+}