[mirror] microsoft/vscode#304990 fix: use setupDelayedHover for settings indicator hovers to support Ctrl+K I

.eslint-ignore

@@ -18,8 +18,6 @@
 **/extensions/terminal-suggest/src/shell/fishBuiltinsCache.ts
 **/extensions/terminal-suggest/third_party/**
 **/extensions/typescript-language-features/test-workspace/**
-**/extensions/typescript-language-features/extension.webpack.config.js
-**/extensions/typescript-language-features/extension-browser.webpack.config.js
 **/extensions/typescript-language-features/package-manager/node-maintainer/**
 **/extensions/vscode-api-tests/testWorkspace/**
 **/extensions/vscode-api-tests/testWorkspace2/**

.eslint-plugin-local/code-no-icons-in-localized-strings.ts

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/utils';
+
+/**
+ * Prevents theme icon syntax `$(iconName)` from appearing inside localized
+ * string arguments. Localizers may translate or corrupt the icon syntax,
+ * breaking rendering. Icon references should be kept outside the localized
+ * string - either prepended via concatenation or passed as a placeholder
+ * argument.
+ *
+ * Examples:
+ * ❌ localize('key', "$(gear) Settings")
+ * ✅ '$(gear) ' + localize('key', "Settings")
+ * ✅ localize('key', "Like {0}", '$(gear)')
+ *
+ * ❌ nls.localize('key', "$(loading~spin) Loading...")
+ * ✅ '$(loading~spin) ' + nls.localize('key', "Loading...")
+ */
+export default new class NoIconsInLocalizedStrings implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			noIconInLocalizedString: 'Theme icon syntax $(…) should not appear inside localized strings. Move it outside the localize call or pass it as a placeholder argument.'
+		},
+		docs: {
+			description: 'Prevents $(icon) theme icon syntax inside localize() string arguments',
+		},
+		type: 'problem',
+		schema: false,
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		// Matches $(iconName) or $(iconName~modifier) but not escaped \$(...)
+		const iconPattern = /(?<!\\)\$\([a-zA-Z][\w~-]*\)/;
+
+		function isLocalizeCall(callee: TSESTree.CallExpression['callee']): { isLocalize: boolean; messageArgIndex: number } {
+			// Direct localize('key', "message", ...) or localize2('key', "message", ...)
+			if (callee.type === 'Identifier' && (callee.name === 'localize' || callee.name === 'localize2')) {
+				return { isLocalize: true, messageArgIndex: 1 };
+			}
+
+			// nls.localize('key', "message", ...) or *.localize(...)
+			if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && callee.property.name === 'localize') {
+				return { isLocalize: true, messageArgIndex: 1 };
+			}
+
+			return { isLocalize: false, messageArgIndex: -1 };
+		}
+
+		function getStringValue(node: TSESTree.Node): string | undefined {
+			if (node.type === 'Literal' && typeof node.value === 'string') {
+				return node.value;
+			}
+			if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
+				return node.quasis[0].value.cooked ?? undefined;
+			}
+			return undefined;
+		}
+
+		function checkCallExpression(node: TSESTree.CallExpression) {
+			const { isLocalize, messageArgIndex } = isLocalizeCall(node.callee);
+			if (!isLocalize) {
+				return;
+			}
+
+			// The first argument may be a string key or an object { key, comment }.
+			// Adjust the message argument index if the first arg is an object.
+			let actualMessageArgIndex = messageArgIndex;
+			const firstArg = node.arguments[0];
+			if (firstArg && firstArg.type === 'ObjectExpression') {
+				// localize({ key: '...', comment: [...] }, "message", ...)
+				actualMessageArgIndex = 1;
+			}
+
+			const messageArg = node.arguments[actualMessageArgIndex];
+			if (!messageArg) {
+				return;
+			}
+
+			const messageValue = getStringValue(messageArg);
+			if (messageValue !== undefined && iconPattern.test(messageValue)) {
+				context.report({
+					node: messageArg,
+					messageId: 'noIconInLocalizedString'
+				});
+			}
+		}
+
+		return {
+			CallExpression: (node: any) => checkCallExpression(node as TSESTree.CallExpression)
+		};
+	}
+};

.eslint-plugin-local/code-no-static-node-module-import.ts

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { TSESTree } from '@typescript-eslint/typescript-estree';
+import * as eslint from 'eslint';
+import { builtinModules } from 'module';
+import { join, normalize, relative } from 'path';
+import minimatch from 'minimatch';
+import { createImportRuleListener } from './utils.ts';
+
+const nodeBuiltins = new Set([
+	...builtinModules,
+	...builtinModules.map(m => `node:${m}`)
+]);
+
+const REPO_ROOT = normalize(join(import.meta.dirname, '../'));
+
+export default new class implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			staticImport: 'Static imports of \'{{module}}\' are not allowed here because they are loaded synchronously on startup. Use a dynamic `await import(...)` or `import type` instead.'
+		},
+		docs: {
+			description: 'Disallow static imports of node_modules packages to prevent synchronous loading on startup. Allows Node.js built-ins, electron, relative imports, and whitelisted file paths.'
+		},
+		schema: {
+			type: 'array',
+			items: {
+				type: 'string'
+			}
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+		const allowedPaths = context.options as string[];
+		const filePath = normalize(relative(REPO_ROOT, normalize(context.getFilename()))).replace(/\\/g, '/');
+
+		// Skip whitelisted files
+		if (allowedPaths.some(pattern => filePath === pattern || minimatch(filePath, pattern))) {
+			return {};
+		}
+
+		return createImportRuleListener((node, value) => {
+			// Allow `import type` and `export type` declarations
+			if (node.parent?.type === TSESTree.AST_NODE_TYPES.ImportDeclaration && node.parent.importKind === 'type') {
+				return;
+			}
+			if (node.parent && 'exportKind' in node.parent && node.parent.exportKind === 'type') {
+				return;
+			}
+
+			// Allow relative imports
+			if (value.startsWith('.')) {
+				return;
+			}
+
+			// Allow Node.js built-in modules
+			if (nodeBuiltins.has(value)) {
+				return;
+			}
+
+			// Allow electron
+			if (value === 'electron') {
+				return;
+			}
+
+			context.report({
+				loc: node.parent!.loc,
+				messageId: 'staticImport',
+				data: {
+					module: value
+				}
+			});
+		});
+	}
+};

.eslint-plugin-local/code-no-telemetry-common-property.ts

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
+
+const telemetryMethods = new Set(['publicLog', 'publicLog2', 'publicLogError', 'publicLogError2']);
+
+/**
+ * Common telemetry property names that are automatically added to every event.
+ * Telemetry events must not set these because they would collide with / be
+ * overwritten by the common properties that the telemetry pipeline injects.
+ *
+ * Collected from:
+ *   - src/vs/platform/telemetry/common/commonProperties.ts  (resolveCommonProperties)
+ *   - src/vs/workbench/services/telemetry/common/workbenchCommonProperties.ts
+ *   - src/vs/workbench/services/telemetry/browser/workbenchCommonProperties.ts
+ */
+const commonTelemetryProperties = new Set([
+	'common.machineid',
+	'common.sqmid',
+	'common.devdeviceid',
+	'sessionid',
+	'commithash',
+	'version',
+	'common.releasedate',
+	'common.platformversion',
+	'common.platform',
+	'common.nodeplatform',
+	'common.nodearch',
+	'common.product',
+	'common.msftinternal',
+	'timestamp',
+	'common.timesincesessionstart',
+	'common.sequence',
+	'common.snap',
+	'common.platformdetail',
+	'common.version.shell',
+	'common.version.renderer',
+	'common.firstsessiondate',
+	'common.lastsessiondate',
+	'common.isnewsession',
+	'common.remoteauthority',
+	'common.cli',
+	'common.useragent',
+	'common.istouchdevice',
+]);
+
+export default new class NoTelemetryCommonProperty implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			noCommonProperty: 'Telemetry events must not contain the common property "{{name}}". Common properties are automatically added by the telemetry pipeline and will be dropped.',
+		},
+		schema: false,
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		/**
+		 * Check whether any property key in an object expression is a reserved common telemetry property.
+		 */
+		function checkObjectForCommonProperties(node: ESTree.ObjectExpression) {
+			for (const prop of node.properties) {
+				if (prop.type === 'Property') {
+					let name: string | undefined;
+					if (prop.key.type === 'Identifier') {
+						name = prop.key.name;
+					} else if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') {
+						name = prop.key.value;
+					}
+					if (name && commonTelemetryProperties.has(name.toLowerCase())) {
+						context.report({
+							node: prop.key,
+							messageId: 'noCommonProperty',
+							data: { name },
+						});
+					}
+				}
+			}
+		}
+
+		return {
+			['CallExpression[callee.property.type="Identifier"]'](node: ESTree.CallExpression) {
+				const callee = node.callee;
+				if (callee.type !== 'MemberExpression') {
+					return;
+				}
+				const prop = callee.property;
+				if (prop.type !== 'Identifier' || !telemetryMethods.has(prop.name)) {
+					return;
+				}
+				// The data argument is the second argument for publicLog/publicLog2/publicLogError/publicLogError2
+				const dataArg = node.arguments[1];
+				if (dataArg && dataArg.type === 'ObjectExpression') {
+					checkObjectForCommonProperties(dataArg);
+				}
+			},
+		};
+	}
+};

.eslint-plugin-local/code-translation-remind.ts

@@ -26,18 +26,19 @@ export default new class TranslationRemind implements eslint.Rule.RuleModule {
 
 	private _checkImport(context: eslint.Rule.RuleContext, node: TSESTree.Node, path: string) {
 
-		if (path !== TranslationRemind.NLS_MODULE) {
+		if (path !== TranslationRemind.NLS_MODULE && !path.endsWith('/nls.js')) {
 			return;
 		}
 
 		const currentFile = context.getFilename();
 		const matchService = currentFile.match(/vs\/workbench\/services\/\w+/);
 		const matchPart = currentFile.match(/vs\/workbench\/contrib\/\w+/);
-		if (!matchService && !matchPart) {
+		const matchSessionsPart = currentFile.match(/vs\/sessions\/contrib\/\w+/);
+		if (!matchService && !matchPart && !matchSessionsPart) {
 			return;
 		}
 
-		const resource = matchService ? matchService[0] : matchPart![0];
+		const resource = matchService ? matchService[0] : matchPart ? matchPart[0] : matchSessionsPart![0];
 		let resourceDefined = false;
 
 		let json;
@@ -47,9 +48,10 @@ export default new class TranslationRemind implements eslint.Rule.RuleModule {
 			console.error('[translation-remind rule]: File with resources to pull from Transifex was not found. Aborting translation resource check for newly defined workbench part/service.');
 			return;
 		}
-		const workbenchResources = JSON.parse(json).workbench;
+		const parsed = JSON.parse(json);
+		const resources = [...parsed.workbench, ...parsed.sessions];
 
-		workbenchResources.forEach((existingResource: any) => {
+		resources.forEach((existingResource: any) => {
 			if (existingResource.name === resource) {
 				resourceDefined = true;
 				return;

.github/CODENOTIFY

@@ -26,6 +26,7 @@ src/vs/base/browser/ui/tree/** @joaomoreno @benibenj
 # Platform
 src/vs/platform/auxiliaryWindow/** @bpasero
 src/vs/platform/backup/** @bpasero
+src/vs/platform/browserView/** @kycutler @jruales
 src/vs/platform/dialogs/** @bpasero
 src/vs/platform/editor/** @bpasero
 src/vs/platform/environment/** @bpasero
@@ -40,8 +41,8 @@ src/vs/platform/secrets/** @TylerLeonhardt
 src/vs/platform/sharedProcess/** @bpasero
 src/vs/platform/state/** @bpasero
 src/vs/platform/storage/** @bpasero
-src/vs/platform/terminal/electron-main/** @Tyriar
-src/vs/platform/terminal/node/** @Tyriar
+src/vs/platform/terminal/electron-main/** @anthonykim1
+src/vs/platform/terminal/node/** @anthonykim1
 src/vs/platform/utilityProcess/** @bpasero
 src/vs/platform/window/** @bpasero
 src/vs/platform/windows/** @bpasero
@@ -65,6 +66,7 @@ src/vs/code/** @bpasero @deepak1556
 src/vs/workbench/services/activity/** @bpasero
 src/vs/workbench/services/authentication/** @TylerLeonhardt
 src/vs/workbench/services/auxiliaryWindow/** @bpasero
+src/vs/workbench/services/browserView/** @kycutler @jruales
 src/vs/workbench/services/contextmenu/** @bpasero
 src/vs/workbench/services/dialogs/** @alexr00 @bpasero
 src/vs/workbench/services/editor/** @bpasero
@@ -97,6 +99,7 @@ src/vs/workbench/electron-browser/** @bpasero
 
 # Workbench Contributions
 src/vs/workbench/contrib/authentication/** @TylerLeonhardt
+src/vs/workbench/contrib/browserView/** @kycutler @jruales
 src/vs/workbench/contrib/files/** @bpasero
 src/vs/workbench/contrib/chat/browser/chatListRenderer.ts @roblourens
 src/vs/workbench/contrib/localization/** @TylerLeonhardt

.github/agents/data.md

@@ -42,3 +42,7 @@ Your response should include:
 - Interpretation and analysis of the results
 - References to specific documentation files when applicable
 - Additional context or insights from the telemetry data
+
+# Troubleshooting
+
+If the connection to the Kusto cluster is timing out consistently, stop and ask the user to check whether they are connected to Azure VPN.

.github/agents/sessions.md

@@ -0,0 +1,15 @@
+---
+name: Sessions Window Developer
+description: Specialist in developing the Agent Sessions Window
+---
+
+# Role and Objective
+
+You are a developer working on the 'sessions window'. Your goal is to make changes to the sessions window (`src/vs/sessions`), minimally editing outside of that directory.
+
+# Instructions
+
+1.  **Always read the `sessions` skill first.** This is your primary source of truth for the sessions architecture.
+    -   Invoke `skill: "sessions"`.
+2.  Focus your work on `src/vs/sessions/`.
+3.  Avoid making changes to core VS Code files (`src/vs/workbench/`, `src/vs/platform/`, etc.) unless absolutely necessary for the sessions window functionality.