[eslint] Migrate rules to TypeScript

Bug: 397586315
Change-Id: I8939d3ba36d147fa1c8e8c671045504cb1ffe554
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6448310
Reviewed-by: Benedikt Meurer <[email protected]>
Commit-Queue: Nikolay Vitkov <[email protected]>

Author: Lightning00Blade

scripts/eslint_rules/lib/lit-template-result-or-nothing.js renamed to scripts/eslint_rules/lib/lit-template-result-or-nothing.ts

@@ -1,51 +1,47 @@
 // Copyright 2020 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.
-'use strict';
 
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-module.exports = {
+import type {TSESTree} from '@typescript-eslint/utils';
+
+import {createRule} from './tsUtils.ts';
+
+export default createRule({
+  name: 'lit-template-result-or-nothing',
   meta: {
     type: 'problem',
-
     docs: {
-      description:
-        'Enforce use of Lit.LitTemplate type rather than union with Lit.nothing',
+      description: 'Enforce use of Lit.LitTemplate type rather than union with Lit.nothing or {}',
       category: 'Possible Errors',
     },
     fixable: 'code',
     messages: {
-      useLitTemplateOverEmptyObject:
-        'Prefer Lit.LitTemplate type over a union with {}',
-      useLitTemplateOverTypeOfNothing:
-        'Prefer Lit.LitTemplate type over a union with Lit.nothing',
+      useLitTemplateOverEmptyObject: 'Prefer Lit.LitTemplate type over a union with {}',
+      useLitTemplateOverTypeOfNothing: 'Prefer Lit.LitTemplate type over a union with typeof Lit.nothing',
     },
-    schema: [], // no options
+    schema: [],  // no options
   },
-  create: function (context) {
-    const sourceCode = context.sourceCode ?? context.getSourceCode();
+  defaultOptions: [],
+  create: function(context) {
+    const sourceCode = context.sourceCode;
     const UNION_TYPE_FOR_LIT_TEMPLATE = 'Lit.LitTemplate';
 
-    function checkUnionReturnTypeForLit(node) {
+    function checkUnionReturnTypeForLit(node: TSESTree.TSUnionType): void {
       // We want to go through the types in the union and match if:
       // 1. We find `Lit.TemplateResult` and `{}`
-      // 2. We find `Lit.TemplateResult` and `Lit.nothing`.
+      // 2. We find `Lit.TemplateResult` and `typeof Lit.nothing`.
       // Otherwise, this node is OK.
 
-      let templateResultNode = null;
-      let literalEmptyObjectNode = null;
-      let litNothingNode = null;
+      let templateResultNode: TSESTree.TSTypeReference|null = null;
+      let literalEmptyObjectNode: TSESTree.TSTypeLiteral|null = null;
+      let litNothingNode: TSESTree.TSTypeQuery|null = null;
 
-      const nonLitRelatedNodesInUnion = new Set();
+      const nonLitRelatedNodesInUnion = new Set<TSESTree.TypeNode>();
 
       for (const typeNode of node.types) {
         // This matches a type reference of X.y. Now we see if X === 'Lit' and y === 'TemplateResult'
-        if (
-          typeNode.type === 'TSTypeReference' &&
-          typeNode.typeName.type === 'TSQualifiedName'
-        ) {
+        if (typeNode.type === 'TSTypeReference' && typeNode.typeName.type === 'TSQualifiedName' &&
+            typeNode.typeName.left.type === 'Identifier') {
           const leftText = typeNode.typeName.left.name;
           const rightText = typeNode.typeName.right.name;
           if (leftText === 'Lit' && rightText === 'TemplateResult') {
@@ -57,9 +53,8 @@ module.exports = {
           literalEmptyObjectNode = typeNode;
           continue;
         } else if (
-          typeNode.type === 'TSTypeQuery' &&
-          typeNode.exprName.type === 'TSQualifiedName'
-        ) {
+            typeNode.type === 'TSTypeQuery' && typeNode.exprName.type === 'TSQualifiedName' &&
+            typeNode.exprName.left.type === 'Identifier') {
           // matches `typeof X.y`
           const leftText = typeNode.exprName.left.name;
           const rightText = typeNode.exprName.right.name;
@@ -90,10 +85,10 @@ module.exports = {
       // So we capture all the non-lit related types in the union, and get
       // their text content, so we can keep them around when we run the fixer.
       const nonLitRelatedTypesToKeep = Array.from(
-        nonLitRelatedNodesInUnion,
-        node => {
-          return sourceCode.getText(node);
-        },
+          nonLitRelatedNodesInUnion,
+          node => {
+            return sourceCode.getText(node);
+          },
       );
       const newText = [
         UNION_TYPE_FOR_LIT_TEMPLATE,
@@ -102,48 +97,43 @@ module.exports = {
 
       context.report({
         node,
-        messageId: litNothingNode
-          ? 'useLitTemplateOverTypeOfNothing'
-          : 'useLitTemplateOverEmptyObject',
+        messageId: litNothingNode ? 'useLitTemplateOverTypeOfNothing' : 'useLitTemplateOverEmptyObject',
         fix(fixer) {
           return fixer.replaceText(node, newText);
         },
       });
     }
 
-    function checkTSTypeAnnotationForPotentialIssue(node) {
+    function checkTSTypeAnnotationForPotentialIssue(node: TSESTree.TSTypeAnnotation): void {
       const annotation = node.typeAnnotation;
-      if (!annotation) {
-        return;
-      }
+
       if (annotation.type === 'TSUnionType') {
         // matches foo(): X|Y
         checkUnionReturnTypeForLit(annotation);
       } else if (annotation.type === 'TSTypeReference') {
         // matches many things, including foo(): Promise<X|Y>, which we do want
         // to check.
 
-        if (annotation.typeName.name !== 'Promise') {
+        if (annotation.typeName.type !== 'Identifier' || annotation.typeName.name !== 'Promise') {
           // If it's not a promise, bail out.
           return;
         }
+
         // Represents the generic type passed to the promise: if our code is
         // Promise<X>, this node represents the X.
-        const promiseGenericNode = annotation.typeArguments.params[0];
+        const promiseGenericNode = annotation.typeArguments?.params[0];
         if (promiseGenericNode && promiseGenericNode.type === 'TSUnionType') {
           checkUnionReturnTypeForLit(promiseGenericNode);
         }
       }
     }
 
-    function checkFunctionDeclarationOrExpressionForUnionType(node) {
+    function checkFunctionDeclarationOrExpressionForUnionType(
+        node: TSESTree.FunctionDeclaration|TSESTree.FunctionExpression|TSESTree.ArrowFunctionExpression): void {
       if (!node.returnType) {
         return;
       }
 
-      if (node.returnType.type !== 'TSTypeAnnotation') {
-        return;
-      }
       checkTSTypeAnnotationForPotentialIssue(node.returnType);
     }
 
@@ -165,4 +155,4 @@ module.exports = {
       },
     };
   },
-};
+});