[eslint] Migrate rules to TypeScript

Migrate l10n rules and their helpers

Bug: 397586315
Change-Id: If425e0aefb990498337a6cd056d560f7d3a975d1
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6448905
Commit-Queue: Danil Somsikov <dsv@chromium.org>
Commit-Queue: Nikolay Vitkov <nvitkov@chromium.org>
Reviewed-by: Danil Somsikov <dsv@chromium.org>
Auto-Submit: Nikolay Vitkov <nvitkov@chromium.org>

Author: Lightning00Blade

scripts/eslint_rules/lib/enforce-default-import-name.ts

@@ -2,10 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type {TSESTree} from '@typescript-eslint/utils';
 import path from 'path';
 
-import {createRule} from './tsUtils.ts';
+import {createRule, isStarAsImportSpecifier} from './tsUtils.ts';
 
 // Define the structure of the options expected by the rule.
 type RuleOptions = [{
@@ -15,13 +14,6 @@ type RuleOptions = [{
 
 // Define the message IDs used by the rule.
 type MessageIds = 'invalidName';
-type SpecifierNamespaceArray = [TSESTree.ImportNamespaceSpecifier];
-/**
- * Checks if the import specifiers represent a namespace import (`import * as Name`).
- */
-function isStarAsImportSpecifier(specifiers: TSESTree.ImportClause[]): specifiers is SpecifierNamespaceArray {
-  return specifiers.length === 1 && specifiers[0].type === 'ImportNamespaceSpecifier';
-}
 
 export default createRule<RuleOptions, MessageIds>({
   name: 'enforce-default-import-name',

scripts/eslint_rules/lib/l10n-filename-matches.js

@@ -0,0 +1,136 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type {TSESTree} from '@typescript-eslint/utils';
+import * as path from 'path';
+
+import {isModuleScope} from './l10n-helper.ts';
+import {createRule} from './tsUtils.ts';
+
+type CallExpression = TSESTree.CallExpression;
+// True iff the callExpression is `i18n.i18n.registerUIStrings`.
+function isRegisterUIStringsCall(callExpression: CallExpression): boolean {
+  if (callExpression.callee?.type !== 'MemberExpression') {
+    return false;
+  }
+  const callee = callExpression.callee;
+
+  if (callee.property?.type !== 'Identifier' || callee.property?.name !== 'registerUIStrings') {
+    return false;
+  }
+
+  if (callee.object?.type !== 'MemberExpression') {
+    return false;
+  }
+  const calleeObject = callee.object;
+
+  if (calleeObject.property?.type !== 'Identifier' || calleeObject.property?.name !== 'i18n') {
+    return false;
+  }
+
+  if (calleeObject.object?.type !== 'Identifier' || calleeObject.object?.name !== 'i18n') {
+    return false;
+  }
+  return true;
+}
+
+type Options = [
+  {
+    rootFrontendDirectory?: string,
+  },
+];
+
+type MessageIds = 'pathMismatch';
+
+export default createRule<Options, MessageIds>({
+  name: 'l10n-filename-matches',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'i18n.i18n.registerUIStrings must receive the current file\'s path as the first argument',
+      category: 'Possible Errors',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          rootFrontendDirectory: {
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      // Using a generic message ID as the message itself is dynamic
+      pathMismatch:
+          'First argument to \'registerUIStrings\' call must be \'{{expectedPath}}\' or the ModuleUIStrings.(js|ts)',
+    },
+  },
+  defaultOptions: [{}],
+  create: function(context) {
+    const filename = context.filename;
+
+    let frontEndDirectory = '';
+    if (context.options?.[0]?.rootFrontendDirectory) {
+      frontEndDirectory = context.options[0].rootFrontendDirectory;
+    }
+    if (!frontEndDirectory) {
+      throw new Error(
+          '\'rootFrontendDirectory\' option must be provided for the l10n-filename-matches rule.',
+      );
+    }
+    return {
+      CallExpression(node) {
+        if (!isModuleScope(context, node) || !isRegisterUIStringsCall(node)) {
+          return;
+        }
+
+        // Do nothing if there are no arguments or the first argument is not a string literal we
+        // can check.
+        const firstArgument = node.arguments[0];
+        if (node.arguments.length === 0 || !firstArgument || firstArgument.type !== 'Literal' ||
+            typeof firstArgument.value !== 'string') {
+          return;
+        }
+
+        const currentSourceFile = path.resolve(filename);
+        const currentFileRelativeToFrontEnd = path.relative(
+            frontEndDirectory,
+            currentSourceFile,
+        );
+
+        const currentModuleDirectory = path.dirname(currentSourceFile);
+        const allowedPathArguments = [
+          currentSourceFile,
+          path.join(currentModuleDirectory, 'ModuleUIStrings.js'),
+          path.join(currentModuleDirectory, 'ModuleUIStrings.ts'),
+        ];
+
+        const actualPath = path.join(
+            frontEndDirectory,
+            `${firstArgument.value}`,
+        );
+
+        if (!allowedPathArguments.includes(actualPath)) {
+          const newFileName = currentFileRelativeToFrontEnd.replace(/\\/g, '/');
+          context.report({
+            node,
+            messageId: 'pathMismatch',
+            data: {
+              expectedPath: newFileName,
+            },
+            fix(fixer) {
+              return fixer.replaceText(
+                  firstArgument,
+                  `'${newFileName}'`,
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+});

scripts/eslint_rules/lib/l10n-filename-matches.ts

@@ -0,0 +1,48 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import type {TSESLint, TSESTree} from '@typescript-eslint/utils';
+
+type RuleContext = TSESLint.RuleContext<string, unknown[]>;
+// Type alias for AST Node, using TSESTree for better compatibility with @typescript-eslint
+type Node = TSESTree.Node;
+type Identifier = TSESTree.Identifier;
+type VariableDeclarator = TSESTree.VariableDeclarator;
+
+/**
+ * Checks if a node is an Identifier whose name starts with "UIStrings".
+ */
+export function isUIStringsIdentifier(node: Node): node is Identifier&{
+  name: `UIStrings${string}`,
+}
+{
+  return node.type === 'Identifier' && node.name.startsWith('UIStrings');
+}
+/**
+ * Checks if a node is within the module scope.
+ */
+export function isModuleScope(context: RuleContext, node: Node): boolean {
+  // Prefer context.sourceCode, fallback to getSourceCode() for compatibility
+  const sourceCode = context.sourceCode;
+  // Prefer sourceCode.getScope if available
+  const scope = sourceCode.getScope(node);
+  return scope.type === 'module';
+}
+
+/**
+ * Checks if a VariableDeclarator is defining a UIStrings object
+ * (module scope, identifier starts with UIStrings, initializer is a TSAsExpression).
+ */
+export function isUIStringsVariableDeclarator(context: RuleContext, variableDeclarator: VariableDeclarator): boolean {
+  if (!isModuleScope(context, variableDeclarator)) {
+    return false;
+  }
+
+  if (!isUIStringsIdentifier(variableDeclarator.id)) {
+    return false;
+  }
+
+  // Check if the initializer exists and is a TSAsExpression
+  return variableDeclarator.init?.type === 'TSAsExpression';
+}