Merge branch 'main' into tyriar/copilot_fix-258895__259417

Author: Tyriar

build/gulpfile.editor.js

@@ -116,12 +116,8 @@ function toExternalDTS(contents) {
 			lines[i] = line.replace('declare namespace monaco.', 'export namespace ');
 		}
 
-		if (line.indexOf('declare let MonacoEnvironment') === 0) {
-			lines[i] = `declare global {\n    let MonacoEnvironment: Environment | undefined;\n}`;
-		}
-
-		if (line.indexOf('\tMonacoEnvironment?') === 0) {
-			lines[i] = `    MonacoEnvironment?: Environment | undefined;`;
+		if (line.indexOf('declare var MonacoEnvironment') === 0) {
+			lines[i] = `declare global {\n    var MonacoEnvironment: Environment | undefined;\n}`;
 		}
 	}
 	return lines.join('\n').replace(/\n\n\n+/g, '\n\n');

build/monaco/monaco.d.ts.recipe

@@ -3,11 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-declare let MonacoEnvironment: monaco.Environment | undefined;
-
-interface Window {
-	MonacoEnvironment?: monaco.Environment | undefined;
-}
+// eslint-disable-next-line no-var
+declare var MonacoEnvironment: monaco.Environment | undefined;
 
 declare namespace monaco {
 

extensions/terminal-suggest/package.json

@@ -17,6 +17,15 @@
     "terminalCompletionProvider",
     "terminalShellEnv"
   ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "terminal.integrated.suggest.clearCachedGlobals",
+        "category": "Terminal",
+        "title": "%terminal.integrated.suggest.clearCachedGlobals%"
+      }
+    ]
+  },
   "scripts": {
     "compile": "npx gulp compile-extension:terminal-suggest",
     "watch": "npx gulp watch-extension:terminal-suggest",

extensions/terminal-suggest/package.nls.json

@@ -1,5 +1,6 @@
 {
 	"description": "Extension to add terminal completions for zsh, bash, and fish terminals.",
 	"displayName": "Terminal Suggest for VS Code",
-	"view.name": "Terminal Suggest"
+	"view.name": "Terminal Suggest",
+	"terminal.integrated.suggest.clearCachedGlobals": "Clear Suggest Cached Globals"
 }

extensions/terminal-suggest/src/env/pathExecutableCache.ts

@@ -16,20 +16,30 @@ import { TerminalShellType } from '../terminalSuggestMain';
 
 const isWindows = osIsWindows();
 
+export interface IExecutablesInPath {
+	completionResources: Set<ICompletionResource> | undefined;
+	labels: Set<string> | undefined;
+}
+
 export class PathExecutableCache implements vscode.Disposable {
 	private _disposables: vscode.Disposable[] = [];
 
-	private _cachedPathValue: string | undefined;
 	private _cachedWindowsExeExtensions: { [key: string]: boolean | undefined } | undefined;
-	private _cachedExes: { completionResources: Set<ICompletionResource> | undefined; labels: Set<string> | undefined } | undefined;
+	private _cachedExes: Map<string, Set<ICompletionResource> | undefined> = new Map();
+
+	private _inProgressRequest: {
+		env: ITerminalEnvironment;
+		shellType: TerminalShellType | undefined;
+		promise: Promise<IExecutablesInPath | undefined>;
+	} | undefined;
 
 	constructor() {
 		if (isWindows) {
 			this._cachedWindowsExeExtensions = vscode.workspace.getConfiguration(SettingsIds.SuggestPrefix).get(SettingsIds.CachedWindowsExecutableExtensionsSuffixOnly);
 			this._disposables.push(vscode.workspace.onDidChangeConfiguration(e => {
 				if (e.affectsConfiguration(SettingsIds.CachedWindowsExecutableExtensions)) {
 					this._cachedWindowsExeExtensions = vscode.workspace.getConfiguration(SettingsIds.SuggestPrefix).get(SettingsIds.CachedWindowsExecutableExtensionsSuffixOnly);
-					this._cachedExes = undefined;
+					this._cachedExes.clear();
 				}
 			}));
 		}
@@ -41,12 +51,37 @@ export class PathExecutableCache implements vscode.Disposable {
 		}
 	}
 
-	refresh(): void {
-		this._cachedExes = undefined;
-		this._cachedPathValue = undefined;
+	refresh(directory?: string): void {
+		if (directory) {
+			this._cachedExes.delete(directory);
+		} else {
+			this._cachedExes.clear();
+		}
+	}
+
+	async getExecutablesInPath(env: ITerminalEnvironment = process.env, shellType?: TerminalShellType): Promise<IExecutablesInPath | undefined> {
+		if (this._inProgressRequest &&
+			this._inProgressRequest.env === env &&
+			this._inProgressRequest.shellType === shellType
+		) {
+			return this._inProgressRequest.promise;
+		}
+
+		const promise = this._doGetExecutablesInPath(env, shellType);
+
+		this._inProgressRequest = {
+			env,
+			shellType,
+			promise,
+		};
+
+		await promise;
+		this._inProgressRequest = undefined;
+
+		return promise;
 	}
 
-	async getExecutablesInPath(env: ITerminalEnvironment = process.env, shellType?: TerminalShellType): Promise<{ completionResources: Set<ICompletionResource> | undefined; labels: Set<string> | undefined } | undefined> {
+	private async _doGetExecutablesInPath(env: ITerminalEnvironment, shellType?: TerminalShellType): Promise<IExecutablesInPath | undefined> {
 		// Create cache key
 		let pathValue: string | undefined;
 		if (shellType === TerminalShellType.GitBash) {
@@ -65,38 +100,59 @@ export class PathExecutableCache implements vscode.Disposable {
 			return;
 		}
 
-		// Check cache
-		if (this._cachedExes && this._cachedPathValue === pathValue) {
-			return this._cachedExes;
-		}
-
 		// Extract executables from PATH
 		const paths = pathValue.split(isWindows ? ';' : ':');
 		const pathSeparator = isWindows ? '\\' : '/';
+		const promisePaths: string[] = [];
 		const promises: Promise<Set<ICompletionResource> | undefined>[] = [];
 		const labels: Set<string> = new Set<string>();
-		for (const path of paths) {
-			promises.push(this._getExecutablesInPath(path, pathSeparator, labels));
+
+		for (const pathDir of paths) {
+			// Check if this directory is already cached
+			const cachedExecutables = this._cachedExes.get(pathDir);
+			if (cachedExecutables) {
+				for (const executable of cachedExecutables) {
+					const labelText = typeof executable.label === 'string' ? executable.label : executable.label.label;
+					labels.add(labelText);
+				}
+			} else {
+				// Not cached, need to scan this directory
+				promisePaths.push(pathDir);
+				promises.push(this._getExecutablesInSinglePath(pathDir, pathSeparator, labels));
+			}
 		}
 
-		// Merge all results
+		// Process uncached directories
+		if (promises.length > 0) {
+			const resultSets = await Promise.all(promises);
+			for (const [i, resultSet] of resultSets.entries()) {
+				const pathDir = promisePaths[i];
+				if (!this._cachedExes.has(pathDir)) {
+					this._cachedExes.set(pathDir, resultSet || new Set());
+				}
+			}
+		}
+
+		// Merge all results from all directories
 		const executables = new Set<ICompletionResource>();
-		const resultSets = await Promise.all(promises);
-		for (const resultSet of resultSets) {
-			if (resultSet) {
-				for (const executable of resultSet) {
+		const processedPaths: Set<string> = new Set();
+		for (const pathDir of paths) {
+			if (processedPaths.has(pathDir)) {
+				continue;
+			}
+			processedPaths.add(pathDir);
+			const dirExecutables = this._cachedExes.get(pathDir);
+			if (dirExecutables) {
+				for (const executable of dirExecutables) {
 					executables.add(executable);
 				}
 			}
 		}
 
-		// Return
-		this._cachedPathValue = pathValue;
-		this._cachedExes = { completionResources: executables, labels };
-		return this._cachedExes;
+		return { completionResources: executables, labels };
 	}
 
-	private async _getExecutablesInPath(path: string, pathSeparator: string, labels: Set<string>): Promise<Set<ICompletionResource> | undefined> {
+	private async _getExecutablesInSinglePath(path: string, pathSeparator: string, labels: Set<string>): Promise<Set<ICompletionResource> | undefined> {
 		try {
 			const dirExists = await fs.stat(path).then(stat => stat.isDirectory()).catch(() => false);
 			if (!dirExists) {
@@ -190,7 +246,7 @@ export async function watchPathDirectories(context: vscode.ExtensionContext, env
 			const watcher = filesystem.watch(dir, { persistent: false }, () => {
 				if (pathExecutableCache) {
 					// Refresh cache when directory contents change
-					pathExecutableCache.refresh();
+					pathExecutableCache.refresh(dir);
 				}
 			});
 

extensions/terminal-suggest/src/terminalSuggestMain.ts

@@ -76,7 +76,6 @@ const getShellSpecificGlobals: Map<TerminalShellType, (options: ExecOptionsWithS
 	[TerminalShellType.PowerShell, getPwshGlobals],
 ]);
 
-
 async function getShellGlobals(
 	shellType: TerminalShellType,
 	existingCommands?: Set<string>,
@@ -106,8 +105,11 @@ async function getShellGlobals(
 				shouldRefresh = true;
 			}
 			if (!shouldRefresh && cached.commands) {
-				// Trigger background refresh
-				void fetchAndCacheShellGlobals(shellType, existingCommands, machineId, remoteAuthority, true);
+				// NOTE: This used to trigger a background refresh in order to ensure all commands
+				// are up to date, but this ends up launching way too many processes. Especially on
+				// Windows where this caused significant performance issues as processes can block
+				// the extension host for several seconds
+				// (https://github.com/microsoft/vscode/issues/259343).
 				return cached.commands;
 			}
 		}
@@ -252,20 +254,15 @@ export async function activate(context: vscode.ExtensionContext) {
 				return;
 			}
 
-			const [commandsInPath, shellGlobals] = await Promise.all([
-				pathExecutableCache.getExecutablesInPath(terminal.shellIntegration?.env?.value, terminalShellType),
-				(async () => {
-					const executables = await pathExecutableCache.getExecutablesInPath(terminal.shellIntegration?.env?.value, terminalShellType);
-					return getShellGlobals(terminalShellType, executables?.labels, machineId, remoteAuthority);
-				})()
-			]);
-			const shellGlobalsArr = shellGlobals ?? [];
+			const commandsInPath = await pathExecutableCache.getExecutablesInPath(terminal.shellIntegration?.env?.value, terminalShellType);
+			const shellGlobals = await getShellGlobals(terminalShellType, commandsInPath?.labels, machineId, remoteAuthority) ?? [];
+
 			if (!commandsInPath?.completionResources) {
 				console.debug('#terminalCompletions No commands found in path');
 				return;
 			}
 			// Order is important here, add shell globals first so they are prioritized over path commands
-			const commands = [...shellGlobalsArr, ...commandsInPath.completionResources];
+			const commands = [...shellGlobals, ...commandsInPath.completionResources];
 			const currentCommandString = getCurrentCommandAndArgs(terminalContext.commandLine, terminalContext.cursorPosition, terminalShellType);
 			const pathSeparator = isWindows ? '\\' : '/';
 			const tokenType = getTokenType(terminalContext, terminalShellType);
@@ -309,6 +306,10 @@ export async function activate(context: vscode.ExtensionContext) {
 		}
 	}, '/', '\\'));
 	await watchPathDirectories(context, currentTerminalEnv, pathExecutableCache);
+
+	context.subscriptions.push(vscode.commands.registerCommand('terminal.integrated.suggest.clearCachedGlobals', () => {
+		cachedGlobals.clear();
+	}));
 }
 
 /**

extensions/terminal-suggest/src/test/env/pathExecutableCache.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import 'mocha';
-import { strictEqual } from 'node:assert';
+import { deepStrictEqual, strictEqual } from 'node:assert';
 import type { MarkdownString } from 'vscode';
 import { PathExecutableCache } from '../../env/pathExecutableCache';
 
@@ -16,12 +16,12 @@ suite('PathExecutableCache', () => {
 		strictEqual(Array.from(result!.labels!).length, 0);
 	});
 
-	test('caching is working on successive calls', async () => {
+	test('results are the same on successive calls', async () => {
 		const cache = new PathExecutableCache();
 		const env = { PATH: process.env.PATH };
 		const result = await cache.getExecutablesInPath(env);
 		const result2 = await cache.getExecutablesInPath(env);
-		strictEqual(result, result2);
+		deepStrictEqual(result!.labels, result2!.labels);
 	});
 
 	test('refresh clears the cache', async () => {

extensions/xml/package.json

@@ -54,6 +54,7 @@
           ".rng",
           ".rss",
           ".shproj",
+          ".slnx",
           ".storyboard",
           ".svg",
           ".targets",

src/vs/base/browser/ui/dialog/dialog.css

@@ -194,7 +194,7 @@
 }
 
 .monaco-dialog-box > .dialog-buttons-row > .dialog-buttons > .monaco-button {
-	padding: 5px 10px;
+	padding: 4px 10px;
 	overflow: hidden;
 	text-overflow: ellipsis;
 	margin: 4px 5px; /* allows button focus outline to be visible */

src/vs/base/common/async.ts

@@ -2168,24 +2168,12 @@ export class AsyncIterableObject<T> implements AsyncIterable<T> {
 	}
 }
 
-export class CancelableAsyncIterableObject<T> extends AsyncIterableObject<T> {
-	constructor(
-		private readonly _source: CancellationTokenSource,
-		executor: AsyncIterableExecutor<T>
-	) {
-		super(executor);
-	}
 
-	cancel(): void {
-		this._source.cancel();
-	}
-}
-
-export function createCancelableAsyncIterable<T>(callback: (token: CancellationToken) => AsyncIterable<T>): CancelableAsyncIterableObject<T> {
+export function createCancelableAsyncIterableProducer<T>(callback: (token: CancellationToken) => AsyncIterable<T>): CancelableAsyncIterableProducer<T> {
 	const source = new CancellationTokenSource();
 	const innerIterable = callback(source.token);
 
-	return new CancelableAsyncIterableObject<T>(source, async (emitter) => {
+	return new CancelableAsyncIterableProducer<T>(source, async (emitter) => {
 		const subscription = source.token.onCancellationRequested(() => {
 			subscription.dispose();
 			source.dispose();
@@ -2492,6 +2480,19 @@ export class AsyncIterableProducer<T> implements AsyncIterable<T> {
 	}
 }
 
+export class CancelableAsyncIterableProducer<T> extends AsyncIterableProducer<T> {
+	constructor(
+		private readonly _source: CancellationTokenSource,
+		executor: AsyncIterableExecutor<T>
+	) {
+		super(executor);
+	}
+
+	cancel(): void {
+		this._source.cancel();
+	}
+}
+
 //#endregion
 
 export const AsyncReaderEndOfStream = Symbol('AsyncReaderEndOfStream');