Fix all any casts in lint rules

For microsoft#269213

Also bumps eslint versions to fix some typing issues

Author: mjbvz

.eslint-plugin-local/code-no-observable-get-in-reactive-context.ts

@@ -3,10 +3,10 @@
  *  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';
-import * as ESTree from 'estree';
+import * as eslint from 'eslint';
 import * as visitorKeys from 'eslint-visitor-keys';
+import * as ESTree from 'estree';
 
 export = new class NoObservableGetInReactiveContext implements eslint.Rule.RuleModule {
 	meta: eslint.Rule.RuleMetaData = {
@@ -61,13 +61,11 @@ function checkFunctionForObservableGetCalls(
 		if (node.type === 'CallExpression' && isObservableGetCall(node)) {
 			// Flag .get() calls since we're always in a reactive context here
 			context.report({
-				// eslint-disable-next-line local/code-no-any-casts
-				node: node as any as ESTree.Node,
+				node: node,
 				message: `Observable '.get()' should not be used in reactive context. Use '.read(${readerName})' instead to properly track dependencies or '.read(undefined)' to be explicit about an untracked read.`,
 				fix: (fixer) => {
 					const memberExpression = node.callee as TSESTree.MemberExpression;
-					// eslint-disable-next-line local/code-no-any-casts
-					return fixer.replaceText(node as any, `${context.getSourceCode().getText(memberExpression.object as any)}.read(undefined)`);
+					return fixer.replaceText(node, `${context.getSourceCode().getText(memberExpression.object as ESTree.Node)}.read(undefined)`);
 				}
 			});
 		}
@@ -133,8 +131,7 @@ function isReactiveFunctionWithReader(callee: TSESTree.Node): boolean {
 function walkChildren(node: TSESTree.Node, cb: (child: TSESTree.Node) => void) {
 	const keys = visitorKeys.KEYS[node.type] || [];
 	for (const key of keys) {
-		// eslint-disable-next-line local/code-no-any-casts
-		const child = (node as any)[key];
+		const child = (node as Record<string, any>)[key];
 		if (Array.isArray(child)) {
 			for (const item of child) {
 				if (item && typeof item === 'object' && item.type) {

.eslint-plugin-local/code-no-reader-after-await.ts

@@ -3,9 +3,8 @@
  *  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';
-import * as ESTree from 'estree';
+import * as eslint from 'eslint';
 
 export = new class NoReaderAfterAwait implements eslint.Rule.RuleModule {
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
@@ -59,8 +58,7 @@ function checkFunctionForAwaitBeforeReader(
 			if (awaitPositions.length > 0) {
 				const methodName = getMethodName(node);
 				context.report({
-					// eslint-disable-next-line local/code-no-any-casts
-					node: node as any as ESTree.Node,
+					node: node,
 					message: `Reader method '${methodName}' should not be called after 'await'. The reader becomes invalid after async operations.`
 				});
 			}

.eslint-plugin-local/code-no-static-self-ref.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
+import * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
 
 /**
@@ -28,16 +29,14 @@ export = new class implements eslint.Rule.RuleModule {
 
 			const classCtor = classDeclaration.body.body.find(node => node.type === 'MethodDefinition' && node.kind === 'constructor');
 
-			if (!classCtor) {
+			if (!classCtor || classCtor.type === 'StaticBlock') {
 				return;
 			}
 
 			const name = classDeclaration.id.name;
-			// eslint-disable-next-line local/code-no-any-casts
-			const valueText = context.sourceCode.getText(<any>propertyDefinition.value);
+			const valueText = context.sourceCode.getText(propertyDefinition.value as ESTree.Node);
 
 			if (valueText.includes(name + '.')) {
-
 				if (classCtor.value?.type === 'FunctionExpression' && !classCtor.value.params.find((param: any) => param.type === 'TSParameterProperty' && param.decorators?.length > 0)) {
 					return;
 				}

.eslint-plugin-local/code-no-test-async-suite.ts

@@ -20,8 +20,7 @@ export = new class NoAsyncSuite implements eslint.Rule.RuleModule {
 		function hasAsyncSuite(node: any) {
 			if (isCallExpression(node) && node.arguments.length >= 2 && isFunctionExpression(node.arguments[1]) && node.arguments[1].async) {
 				return context.report({
-					// eslint-disable-next-line local/code-no-any-casts
-					node: node as any,
+					node: node,
 					message: 'suite factory function should never be async'
 				});
 			}

.eslint-plugin-local/code-no-unexternalized-strings.ts

@@ -3,10 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
 import * as eslint from 'eslint';
-import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as ESTree from 'estree';
 
-function isStringLiteral(node: TSESTree.Node | null | undefined): node is TSESTree.StringLiteral {
+function isStringLiteral(node: TSESTree.Node | ESTree.Node | null | undefined): node is TSESTree.StringLiteral {
 	return !!node && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string';
 }
 
@@ -33,7 +34,7 @@ export = new class NoUnexternalizedStrings implements eslint.Rule.RuleModule {
 		const externalizedStringLiterals = new Map<string, { call: TSESTree.CallExpression; message: TSESTree.Node }[]>();
 		const doubleQuotedStringLiterals = new Set<TSESTree.Node>();
 
-		function collectDoubleQuotedStrings(node: TSESTree.Literal) {
+		function collectDoubleQuotedStrings(node: ESTree.Literal) {
 			if (isStringLiteral(node) && isDoubleQuoted(node)) {
 				doubleQuotedStringLiterals.add(node);
 			}
@@ -42,7 +43,7 @@ export = new class NoUnexternalizedStrings implements eslint.Rule.RuleModule {
 		function visitLocalizeCall(node: TSESTree.CallExpression) {
 
 			// localize(key, message)
-			const [keyNode, messageNode] = (<TSESTree.CallExpression>node).arguments;
+			const [keyNode, messageNode] = node.arguments;
 
 			// (1)
 			// extract key so that it can be checked later
@@ -81,8 +82,7 @@ export = new class NoUnexternalizedStrings implements eslint.Rule.RuleModule {
 				context.report({
 					loc: messageNode.loc,
 					messageId: 'badMessage',
-					// eslint-disable-next-line local/code-no-any-casts
-					data: { message: context.getSourceCode().getText(<any>node) }
+					data: { message: context.getSourceCode().getText(node as ESTree.Node) }
 				});
 			}
 		}
@@ -129,8 +129,7 @@ export = new class NoUnexternalizedStrings implements eslint.Rule.RuleModule {
 				// report all invalid duplicates (same key, different message)
 				if (values.length > 1) {
 					for (let i = 1; i < values.length; i++) {
-						// eslint-disable-next-line local/code-no-any-casts
-						if (context.getSourceCode().getText(<any>values[i - 1].message) !== context.getSourceCode().getText(<any>values[i].message)) {
+						if (context.getSourceCode().getText(values[i - 1].message as ESTree.Node) !== context.getSourceCode().getText(values[i].message as ESTree.Node)) {
 							context.report({ loc: values[i].call.loc, messageId: 'duplicateKey', data: { key } });
 						}
 					}
@@ -139,23 +138,23 @@ export = new class NoUnexternalizedStrings implements eslint.Rule.RuleModule {
 		}
 
 		return {
-			['Literal']: (node: any) => collectDoubleQuotedStrings(node),
-			['ExpressionStatement[directive] Literal:exit']: (node: any) => doubleQuotedStringLiterals.delete(node),
+			['Literal']: (node: ESTree.Literal) => collectDoubleQuotedStrings(node),
+			['ExpressionStatement[directive] Literal:exit']: (node: TSESTree.Literal) => doubleQuotedStringLiterals.delete(node),
 
 			// localize(...)
-			['CallExpression[callee.type="MemberExpression"][callee.object.name="nls"][callee.property.name="localize"]:exit']: (node: any) => visitLocalizeCall(node),
+			['CallExpression[callee.type="MemberExpression"][callee.object.name="nls"][callee.property.name="localize"]:exit']: (node: TSESTree.CallExpression) => visitLocalizeCall(node),
 
 			// localize2(...)
-			['CallExpression[callee.type="MemberExpression"][callee.object.name="nls"][callee.property.name="localize2"]:exit']: (node: any) => visitLocalizeCall(node),
+			['CallExpression[callee.type="MemberExpression"][callee.object.name="nls"][callee.property.name="localize2"]:exit']: (node: TSESTree.CallExpression) => visitLocalizeCall(node),
 
 			// vscode.l10n.t(...)
-			['CallExpression[callee.type="MemberExpression"][callee.object.property.name="l10n"][callee.property.name="t"]:exit']: (node: any) => visitL10NCall(node),
+			['CallExpression[callee.type="MemberExpression"][callee.object.property.name="l10n"][callee.property.name="t"]:exit']: (node: TSESTree.CallExpression) => visitL10NCall(node),
 
 			// l10n.t(...)
-			['CallExpression[callee.object.name="l10n"][callee.property.name="t"]:exit']: (node: any) => visitL10NCall(node),
+			['CallExpression[callee.object.name="l10n"][callee.property.name="t"]:exit']: (node: TSESTree.CallExpression) => visitL10NCall(node),
 
-			['CallExpression[callee.name="localize"][arguments.length>=2]:exit']: (node: any) => visitLocalizeCall(node),
-			['CallExpression[callee.name="localize2"][arguments.length>=2]:exit']: (node: any) => visitLocalizeCall(node),
+			['CallExpression[callee.name="localize"][arguments.length>=2]:exit']: (node: TSESTree.CallExpression) => visitLocalizeCall(node),
+			['CallExpression[callee.name="localize2"][arguments.length>=2]:exit']: (node: TSESTree.CallExpression) => visitLocalizeCall(node),
 			['Program:exit']: reportBadStringsAndBadKeys,
 		};
 	}

.eslint-plugin-local/vscode-dts-provider-naming.ts

@@ -24,16 +24,13 @@ export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
 
 		return {
 			['TSInterfaceDeclaration[id.name=/.+Provider/] TSMethodSignature']: (node: any) => {
-
-
 				const interfaceName = (<TSESTree.TSInterfaceDeclaration>(<TSESTree.Identifier>node).parent?.parent).id.name;
 				if (allowed.has(interfaceName)) {
 					// allowed
 					return;
 				}
 
-				// eslint-disable-next-line local/code-no-any-casts
-				const methodName = (<any>(<TSESTree.TSMethodSignatureNonComputedName>node).key).name;
+				const methodName = ((<TSESTree.TSMethodSignatureNonComputedName>node).key as TSESTree.Identifier).name;
 
 				if (!ApiProviderNaming._providerFunctionNames.test(methodName)) {
 					context.report({

.eslint-plugin-local/vscode-dts-vscode-in-comments.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import type * as estree from 'estree';
 
 export = new class ApiVsCodeInComments implements eslint.Rule.RuleModule {
 
@@ -40,10 +39,8 @@ export = new class ApiVsCodeInComments implements eslint.Rule.RuleModule {
 						}
 
 						// Types for eslint seem incorrect
-						// eslint-disable-next-line local/code-no-any-casts
-						const start = sourceCode.getLocFromIndex(startIndex + match.index) as any as estree.Position;
-						// eslint-disable-next-line local/code-no-any-casts
-						const end = sourceCode.getLocFromIndex(startIndex + match.index + match[0].length) as any as estree.Position;
+						const start = sourceCode.getLocFromIndex(startIndex + match.index);
+						const end = sourceCode.getLocFromIndex(startIndex + match.index + match[0].length);
 						context.report({
 							messageId: 'comment',
 							loc: { start, end }