Sync/vscode 1.110.0

.claude/CLAUDE.md

@@ -0,0 +1 @@
+../.github/copilot-instructions.md

.eslint-ignore

@@ -33,7 +33,6 @@
 **/src/typings/**/*.d.ts
 **/src/vs/*/**/*.d.ts
 **/src/vs/base/test/common/filters.perf.data.js
-**/src/vs/loader.js
 **/test/unit/assert.js
 **/test/automation/out/**
 **/typings/**

.eslint-plugin-local/code-amd-node-module.ts

@@ -4,10 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 
 
-export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
+export default new class ApiProviderNaming implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -21,7 +23,8 @@ export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
 		const modules = new Set<string>();
 
 		try {
-			const { dependencies, optionalDependencies } = require(join(__dirname, '../package.json'));
+			const packageJson = JSON.parse(readFileSync(join(import.meta.dirname, '../package.json'), 'utf-8'));
+			const { dependencies, optionalDependencies } = packageJson;
 			const all = Object.keys(dependencies).concat(Object.keys(optionalDependencies));
 			for (const key of all) {
 				modules.add(key);
@@ -33,13 +36,13 @@ export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
 		}
 
 
-		const checkImport = (node: any) => {
+		const checkImport = (node: ESTree.Literal & { parent?: ESTree.Node & { importKind?: string } }) => {
 
-			if (node.type !== 'Literal' || typeof node.value !== 'string') {
+			if (typeof node.value !== 'string') {
 				return;
 			}
 
-			if (node.parent.importKind === 'type') {
+			if (node.parent?.type === 'ImportDeclaration' && node.parent.importKind === 'type') {
 				return;
 			}
 

.eslint-plugin-local/code-declare-service-brand.ts

@@ -4,8 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 
-export = new class DeclareServiceBrand implements eslint.Rule.RuleModule {
+export default new class DeclareServiceBrand implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		fixable: 'code',
@@ -14,7 +15,7 @@ export = new class DeclareServiceBrand implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {
-			['PropertyDefinition[key.name="_serviceBrand"][value]']: (node: any) => {
+			['PropertyDefinition[key.name="_serviceBrand"][value]']: (node: ESTree.PropertyDefinition) => {
 				return context.report({
 					node,
 					message: `The '_serviceBrand'-property should not have a value`,

.eslint-plugin-local/code-ensure-no-disposables-leak-in-test.ts

@@ -4,9 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import { Node } from 'estree';
+import type * as estree from 'estree';
 
-export = new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rule.RuleModule {
+export default new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		type: 'problem',
@@ -18,15 +18,15 @@ export = new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rul
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		const config = <{ exclude: string[] }>context.options[0];
+		const config = context.options[0] as { exclude: string[] };
 
 		const needle = context.getFilename().replace(/\\/g, '/');
 		if (config.exclude.some((e) => needle.endsWith(e))) {
 			return {};
 		}
 
 		return {
-			[`Program > ExpressionStatement > CallExpression[callee.name='suite']`]: (node: Node) => {
+			[`Program > ExpressionStatement > CallExpression[callee.name='suite']`]: (node: estree.Node) => {
 				const src = context.getSourceCode().getText(node);
 				if (!src.includes('ensureNoDisposablesAreLeakedInTestSuite(')) {
 					context.report({

.eslint-plugin-local/code-import-patterns.ts

@@ -7,9 +7,9 @@ import * as eslint from 'eslint';
 import { TSESTree } from '@typescript-eslint/utils';
 import * as path from 'path';
 import minimatch from 'minimatch';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
-const REPO_ROOT = path.normalize(path.join(__dirname, '../'));
+const REPO_ROOT = path.normalize(path.join(import.meta.dirname, '../'));
 
 interface ConditionalPattern {
 	when?: 'hasBrowser' | 'hasNode' | 'hasElectron' | 'test';
@@ -31,15 +31,15 @@ interface LayerAllowRule {
 type RawOption = RawImportPatternsConfig | LayerAllowRule;
 
 function isLayerAllowRule(option: RawOption): option is LayerAllowRule {
-	return !!((<LayerAllowRule>option).when && (<LayerAllowRule>option).allow);
+	return !!((option as LayerAllowRule).when && (option as LayerAllowRule).allow);
 }
 
 interface ImportPatternsConfig {
 	target: string;
 	restrictions: string[];
 }
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -55,7 +55,7 @@ export = new class implements eslint.Rule.RuleModule {
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		const options = <RawOption[]>context.options;
+		const options = context.options as RawOption[];
 		const configs = this._processOptions(options);
 		const relativeFilename = getRelativeFilename(context);
 
@@ -217,7 +217,7 @@ export = new class implements eslint.Rule.RuleModule {
 					configs.push(testConfig);
 				}
 			} else {
-				configs.push({ target, restrictions: <string[]>restrictions.filter(r => typeof r === 'string') });
+				configs.push({ target, restrictions: restrictions.filter(r => typeof r === 'string') as string[] });
 			}
 		}
 		this._optionsCache.set(options, configs);

.eslint-plugin-local/code-layering.ts

@@ -5,14 +5,14 @@
 
 import * as eslint from 'eslint';
 import { join, dirname } from 'path';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
 type Config = {
 	allowed: Set<string>;
 	disallowed: Set<string>;
 };
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -38,8 +38,7 @@ export = new class implements eslint.Rule.RuleModule {
 
 		const fileDirname = dirname(context.getFilename());
 		const parts = fileDirname.split(/\\|\//);
-		const ruleArgs = <Record<string, string[]>>context.options[0];
-
+		const ruleArgs = context.options[0] as Record<string, string[]>;
 		let config: Config | undefined;
 		for (let i = parts.length - 1; i >= 0; i--) {
 			if (ruleArgs[parts[i]]) {
@@ -91,4 +90,3 @@ export = new class implements eslint.Rule.RuleModule {
 		});
 	}
 };
-

.eslint-plugin-local/code-limited-top-functions.ts

@@ -6,8 +6,9 @@
 import * as eslint from 'eslint';
 import { dirname, relative } from 'path';
 import minimatch from 'minimatch';
+import type * as ESTree from 'estree';
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -28,11 +29,11 @@ export = new class implements eslint.Rule.RuleModule {
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		let fileRelativePath = relative(dirname(__dirname), context.getFilename());
+		let fileRelativePath = relative(dirname(import.meta.dirname), context.getFilename());
 		if (!fileRelativePath.endsWith('/')) {
 			fileRelativePath += '/';
 		}
-		const ruleArgs = <Record<string, string[]>>context.options[0];
+		const ruleArgs = context.options[0] as Record<string, string[]>;
 
 		const matchingKey = Object.keys(ruleArgs).find(key => fileRelativePath.startsWith(key) || minimatch(fileRelativePath, key));
 		if (!matchingKey) {
@@ -43,8 +44,8 @@ export = new class implements eslint.Rule.RuleModule {
 		const restrictedFunctions = ruleArgs[matchingKey];
 
 		return {
-			FunctionDeclaration: (node: any) => {
-				const isTopLevel = node.parent.type === 'Program';
+			FunctionDeclaration: (node: ESTree.FunctionDeclaration & { parent?: ESTree.Node }) => {
+				const isTopLevel = node.parent?.type === 'Program';
 				const functionName = node.id.name;
 				if (isTopLevel && !restrictedFunctions.includes(node.id.name)) {
 					context.report({
@@ -53,10 +54,10 @@ export = new class implements eslint.Rule.RuleModule {
 					});
 				}
 			},
-			ExportNamedDeclaration(node: any) {
+			ExportNamedDeclaration(node: ESTree.ExportNamedDeclaration & { parent?: ESTree.Node }) {
 				if (node.declaration && node.declaration.type === 'FunctionDeclaration') {
 					const functionName = node.declaration.id.name;
-					const isTopLevel = node.parent.type === 'Program';
+					const isTopLevel = node.parent?.type === 'Program';
 					if (isTopLevel && !restrictedFunctions.includes(node.declaration.id.name)) {
 						context.report({
 							node,

.eslint-plugin-local/code-must-use-result.ts

@@ -4,29 +4,30 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
 
 const VALID_USES = new Set<TSESTree.AST_NODE_TYPES | undefined>([
 	TSESTree.AST_NODE_TYPES.AwaitExpression,
 	TSESTree.AST_NODE_TYPES.VariableDeclarator,
 ]);
 
-export = new class MustUseResults implements eslint.Rule.RuleModule {
+export default new class MustUseResults implements eslint.Rule.RuleModule {
 	readonly meta: eslint.Rule.RuleMetaData = {
 		schema: false
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 
-		const config = <{ message: string; functions: string[] }[]>context.options[0];
+		const config = context.options[0] as { message: string; functions: string[] }[];
 		const listener: eslint.Rule.RuleListener = {};
 
 		for (const { message, functions } of config) {
 			for (const fn of functions) {
 				const query = `CallExpression[callee.property.name='${fn}'], CallExpression[callee.name='${fn}']`;
-				listener[query] = (node: any) => {
-					const cast: TSESTree.CallExpression = node;
-					if (!VALID_USES.has(cast.parent?.type)) {
+				listener[query] = (node: ESTree.Node) => {
+					const callExpression = node as TSESTree.CallExpression;
+					if (!VALID_USES.has(callExpression.parent?.type)) {
 						context.report({ node, message });
 					}
 				};

.eslint-plugin-local/code-must-use-super-dispose.ts

@@ -3,18 +3,20 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { TSESTree } from '@typescript-eslint/utils';
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 
-export = new class NoAsyncSuite implements eslint.Rule.RuleModule {
+export default new class NoAsyncSuite implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		function doesCallSuperDispose(node: any) {
+		function doesCallSuperDispose(node: TSESTree.MethodDefinition) {
 
 			if (!node.override) {
 				return;
 			}
 
-			const body = context.getSourceCode().getText(node);
+			const body = context.getSourceCode().getText(node as ESTree.Node);
 
 			if (body.includes('super.dispose')) {
 				return;

.eslint-plugin-local/code-no-any-casts.ts

@@ -6,7 +6,7 @@
 import * as eslint from 'eslint';
 import { TSESTree } from '@typescript-eslint/utils';
 
-export = new class NoAnyCasts implements eslint.Rule.RuleModule {
+export default new class NoAnyCasts implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {

.eslint-plugin-local/code-no-dangerous-type-assertions.ts

@@ -4,15 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
 
-export = new class NoDangerousTypeAssertions implements eslint.Rule.RuleModule {
+export default new class NoDangerousTypeAssertions implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {
 			// Disallow type assertions on object literals: <T>{ ... } or {} as T
-			['TSTypeAssertion > ObjectExpression, TSAsExpression > ObjectExpression']: (node: any) => {
-				const objectNode = node as TSESTree.Node;
+			['TSTypeAssertion > ObjectExpression, TSAsExpression > ObjectExpression']: (node: ESTree.ObjectExpression) => {
+				const objectNode = node as TSESTree.ObjectExpression;
 
 				const parent = objectNode.parent as TSESTree.TSTypeAssertion | TSESTree.TSAsExpression;
 				if (

.eslint-plugin-local/code-no-deep-import-of-internal.ts

@@ -5,9 +5,9 @@
 
 import * as eslint from 'eslint';
 import { join, dirname } from 'path';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -28,8 +28,8 @@ export = new class implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		const patterns = context.options[0] as Record<string, boolean>;
-		const internalModulePattern = Object.entries(patterns).map(([key, v]) => v ? key : undefined).filter(v => !!v);
-		const allowedPatterns = Object.entries(patterns).map(([key, v]) => !v ? key : undefined).filter(v => !!v);
+		const internalModulePattern = Object.entries(patterns).map(([key, v]) => v ? key : undefined).filter((v): v is string => !!v);
+		const allowedPatterns = Object.entries(patterns).map(([key, v]) => !v ? key : undefined).filter((v): v is string => !!v);
 
 		return createImportRuleListener((node, path) => {
 			const importerModuleDir = dirname(context.filename);

.eslint-plugin-local/code-no-global-document-listener.ts

@@ -5,7 +5,7 @@
 
 import * as eslint from 'eslint';
 
-export = new class NoGlobalDocumentListener implements eslint.Rule.RuleModule {
+export default new class NoGlobalDocumentListener implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {

.eslint-plugin-local/code-no-in-operator.ts

@@ -4,6 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
+import { TSESTree } from '@typescript-eslint/utils';
 
 /**
  * Disallows the use of the `in` operator in TypeScript code, except within
@@ -15,7 +17,7 @@ import * as eslint from 'eslint';
  * Exception: Type predicate functions are allowed to use the `in` operator
  * since they are the standard way to perform runtime type checking.
  */
-export = new class NoInOperator implements eslint.Rule.RuleModule {
+export default new class NoInOperator implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -26,9 +28,10 @@ export = new class NoInOperator implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 
-		function checkInOperator(inNode: any) {
+		function checkInOperator(inNode: ESTree.BinaryExpression) {
+			const node = inNode as TSESTree.BinaryExpression;
 			// Check if we're inside a type predicate function
-			const ancestors = context.sourceCode.getAncestors(inNode);
+			const ancestors = context.sourceCode.getAncestors(node as ESTree.Node);
 
 			for (const ancestor of ancestors) {
 				if (ancestor.type === 'FunctionDeclaration' ||
@@ -45,7 +48,7 @@ export = new class NoInOperator implements eslint.Rule.RuleModule {
 			}
 
 			context.report({
-				node: inNode,
+				node,
 				messageId: 'noInOperator'
 			});
 		}