[eslint] Fix type checking in custom EsLint rules

Either fix or suppress the errors for now

Bug: 407085691
Change-Id: I45c5bd4c3644571ddaebcba45914c209ebfa46f5
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6415909
Auto-Submit: Nikolay Vitkov <[email protected]>
Commit-Queue: Nikolay Vitkov <[email protected]>
Reviewed-by: Danil Somsikov <[email protected]>
Commit-Queue: Danil Somsikov <[email protected]>

Author: Lightning00Blade

scripts/eslint_rules/lib/canvas-context-tracking.js

@@ -18,14 +18,15 @@ module.exports = {
     messages: {
       saveNotRestored:
         'Found a block that has more context.save() calls than context.restore() calls',
-      uselessRestore: 'Found a context.restore() call with no context.save() prior to it',
+      uselessRestore:
+        'Found a context.restore() call with no context.save() prior to it',
     },
     schema: [], // no options
   },
   create: function (context) {
     // To track canvas calls across scopes we keep a stack which we push nodes on with every new scope that we find.
     // When we then leave a scope, we can check all the calls in that scope and see if they align or not.
-    /** @type {Array<ASTNode>} */
+    /** @type {Array<import('estree').Node>} */
     let stack = [];
 
     // The key is a node's range as a string. The value is a stack of
@@ -48,8 +49,12 @@ module.exports = {
      */
     function exitScope() {
       const lastScope = stack.pop();
+      if (!lastScope) {
+        return;
+      }
+
       const stackForCurrentScope = scopeToCanvasCalls.get(
-        nodeToKeyForMap(lastScope)
+        nodeToKeyForMap(lastScope),
       );
 
       // We have no issues to report if:
@@ -60,10 +65,10 @@ module.exports = {
       }
 
       // If we got here it means the stack for the scope has items in, which means that it is unbalanced.
-        context.report({
-          node: lastScope,
-          messageId: 'saveNotRestored',
-        });
+      context.report({
+        node: lastScope,
+        messageId: 'saveNotRestored',
+      });
     }
 
     /**
@@ -72,32 +77,34 @@ module.exports = {
      **/
     function trackContextCall(methodName) {
       const currentScopeNode = stack.at(-1);
-      const stackForCurrentScope = scopeToCanvasCalls.get(
-        nodeToKeyForMap(currentScopeNode)
-      ) || [];
+      if (!currentScopeNode) {
+        return;
+      }
+      const stackForCurrentScope =
+        scopeToCanvasCalls.get(nodeToKeyForMap(currentScopeNode)) || [];
 
-      if(methodName === 'save') {
+      if (methodName === 'save') {
         stackForCurrentScope.push('save');
-      } else if(methodName === 'restore') {
+      } else if (methodName === 'restore') {
         // If we get a restore() call but the stack is empty, this means that
         // we have nothing to restore as we did not save anything in this
         // scope. Either the user has forgotten a save() call, or this
         // restore() has been accidentally left behind after a refactor and
         // shold be removed.
-        if(stackForCurrentScope.length === 0) {
+        if (stackForCurrentScope.length === 0) {
           context.report({
             messageId: 'uselessRestore',
             node: currentScopeNode,
           });
         } else {
           // Pop the stack, so that the last save() is accounted for.
-        stackForCurrentScope.pop();
+          stackForCurrentScope.pop();
         }
       }
 
       scopeToCanvasCalls.set(
         nodeToKeyForMap(currentScopeNode),
-        stackForCurrentScope
+        stackForCurrentScope,
       );
     }
 
@@ -108,9 +115,12 @@ module.exports = {
       MemberExpression(node) {
         const methodCallsToTrack = ['save', 'restore'];
         if (
+          node.object.type === 'Identifier' &&
           node.object?.name === 'context' &&
+          node.property.type === 'Identifier' &&
           methodCallsToTrack.includes(node.property?.name)
         ) {
+          // @ts-expect-error the methodCallsToTrack needs `as const`
           trackContextCall(node.property.name);
         }
       },

scripts/eslint_rules/lib/check-enumerated-histograms.js

@@ -14,22 +14,33 @@ module.exports = {
       category: 'Possible Errors',
     },
     fixable: 'code',
-    schema: []  // no options
+    schema: [], // no options
   },
-  create: function(context) {
+  create: function (context) {
     return {
       CallExpression(node) {
-        if (node?.callee?.object?.name === 'InspectorFrontendHostInstance' &&
-            node.callee.property.name === 'recordEnumeratedHistogram') {
-          if (node?.arguments[2]?.property?.name !== 'MAX_VALUE') {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          node.callee.object.type === 'Identifier' &&
+          node.callee.object.name === 'InspectorFrontendHostInstance' &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'recordEnumeratedHistogram'
+        ) {
+          const argumentNode = node.arguments[2];
+
+          if (
+            argumentNode.type !== 'MemberExpression' ||
+            argumentNode.property.type !== 'Identifier' ||
+            argumentNode.property.name !== 'MAX_VALUE'
+          ) {
             context.report({
               node,
               message:
-                  'When calling \'recordEnumeratedHistogram\' the third argument should be of the form \'SomeEnum.MAX_VALUE\'.'
+                'When calling \'recordEnumeratedHistogram\' the third argument should be of the form \'SomeEnum.MAX_VALUE\'.',
             });
           }
         }
-      }
+      },
     };
-  }
+  },
 };

scripts/eslint_rules/lib/check-license-header.js

@@ -175,11 +175,9 @@ module.exports = {
 
         const comments = sourceCode.getCommentsBefore(node.body[0]);
 
-        if (
-          !comments ||
-          comments.length === 0 ||
-          (comments.length === 1 && comments[0].type === 'Shebang')
-        ) {
+        if (!comments || comments.length === 0 ||
+            // @ts-expect-error Shebang is not on the types
+            (comments.length === 1 && comments[0].type === 'Shebang')) {
           context.report({
             node,
             message: 'Missing license header',
@@ -194,6 +192,7 @@ module.exports = {
         let commentsToCheck = comments;
         let firstCommentToCheck = comments[0];
 
+        // @ts-expect-error Shebang is not on the types
         if (comments[0].type === 'Shebang') {
           commentsToCheck = comments.slice(1);
           firstCommentToCheck = commentsToCheck[0];

scripts/eslint_rules/lib/l10n-no-locked-or-placeholder-only-phrase.js

@@ -17,36 +17,49 @@ module.exports = {
     type: 'problem',
     docs: {
       description:
-          'UIStrings object literals are not allowed to have phrases that are fully locked, or consist only of a single placeholder.',
+        'UIStrings object literals are not allowed to have phrases that are fully locked, or consist only of a single placeholder.',
       category: 'Possible Errors',
     },
-    schema: []  // no options
+    schema: [], // no options
   },
-  create: function(context) {
+  create: function (context) {
     return {
       VariableDeclarator(variableDeclarator) {
-        if (!l10nHelper.isUIStringsVariableDeclarator(context, variableDeclarator)) {
+        if (
+          !l10nHelper.isUIStringsVariableDeclarator(context, variableDeclarator)
+        ) {
           return;
         }
 
+        // @ts-ignore needs TypeScript types
+        if (variableDeclarator.init?.type !== 'TSAsExpression') {
+          return;
+        }
+
+        // @ts-ignore needs TypeScript types
         for (const property of variableDeclarator.init.expression.properties) {
-          if (property.type !== 'Property' || property.value.type !== 'Literal') {
+          if (
+            property.type !== 'Property' ||
+            property.value.type !== 'Literal'
+          ) {
             continue;
           }
 
           if (FULLY_LOCKED_PHRASE_REGEX.test(property.value.value)) {
             context.report({
               node: property.value,
-              message: 'Locking whole phrases is not allowed. Use i18n.i18n.lockedString instead.',
+              message:
+                'Locking whole phrases is not allowed. Use i18n.i18n.lockedString instead.',
             });
           } else if (SINGLE_PLACEHOLDER_REGEX.test(property.value.value)) {
             context.report({
               node: property.value,
-              message: 'Single placeholder-only phrases are not allowed. Use i18n.i18n.lockedString instead.',
+              message:
+                'Single placeholder-only phrases are not allowed. Use i18n.i18n.lockedString instead.',
             });
           }
         }
       },
     };
-  }
+  },
 };

scripts/eslint_rules/lib/l10n-no-unused-message.js

@@ -55,8 +55,9 @@ module.exports = {
       // Are there comments in front of the property?
       // Move the line we want to remove to the line of the first comment.
       const comments = source.getCommentsBefore(property);
-      if (comments.length > 0) {
-        lineToRemoveStart = source.getLocFromIndex(comments[0].range[0]).line;
+      const firstComment = comments[0];
+      if (firstComment && firstComment.range) {
+        lineToRemoveStart = source.getLocFromIndex(firstComment.range[0]).line;
       }
 
       const removeStart = source.getIndexFromLoc({
@@ -86,6 +87,7 @@ module.exports = {
           return;
         }
 
+        // @ts-expect-error the function above is not typed
         for (const property of variableDeclarator.init.expression.properties) {
           if (
             property.type !== 'Property' ||
@@ -100,6 +102,7 @@ module.exports = {
         if (!isStandardUIStringsMemberExpression(memberExpression)) {
           return;
         }
+        // @ts-expect-error the function above is not typed
         usedUIStringsKeys.add(memberExpression.property.name);
       },
       'Program:exit': function () {

scripts/eslint_rules/lib/no-imperative-dom-api/dom-fragment.js

@@ -205,6 +205,7 @@ function getEnclosingVariable(estreeNode, sourceCode) {
       if (variable) {
         return variable;
       }
+      // @ts-expect-error need the above to be typed to undefined
       scope = scope.upper;
     }
   }

scripts/eslint_rules/lib/set-data-type-reference.js

@@ -12,51 +12,72 @@ module.exports = {
     type: 'problem',
 
     docs: {
-      description: 'check data setters have an explicit type reference for their parameter',
+      description:
+        'check data setters have an explicit type reference for their parameter',
       category: 'Possible Errors',
     },
     fixable: 'code',
-    schema: []  // no options
+    schema: [], // no options
   },
-  create: function(context) {
+  create: function (context) {
     return {
       ClassDeclaration(node) {
         // Only enforce this rule for custom elements
-        if (!node.superClass || node.superClass.type !== 'Identifier' || node.superClass.name !== 'HTMLElement') {
+        if (
+          !node.superClass ||
+          node.superClass.type !== 'Identifier' ||
+          node.superClass.name !== 'HTMLElement'
+        ) {
           return;
         }
 
         const dataSetterDefinition = node.body.body.find(methodDefinition => {
           return (
-              'kind' in methodDefinition && methodDefinition.kind === 'set' && methodDefinition.key.name === 'data');
+            'kind' in methodDefinition &&
+            methodDefinition.kind === 'set' &&
+            'key' in methodDefinition &&
+            methodDefinition.key.type === 'Identifier' &&
+            methodDefinition.key.name === 'data'
+          );
         });
 
-        if (!dataSetterDefinition || dataSetterDefinition.type === 'StaticBlock') {
+        if (
+          !dataSetterDefinition ||
+          dataSetterDefinition.type === 'StaticBlock'
+        ) {
           return;
         }
-
+        // @ts-expect-error needs proper check of eslint.type
         const dataSetterParam = dataSetterDefinition.value?.params?.[0];
         if (!dataSetterParam) {
-          context.report(
-              {node: dataSetterDefinition, message: 'A data setter must take a parameter that is explicitly typed.'});
+          context.report({
+            node: dataSetterDefinition,
+            message:
+              'A data setter must take a parameter that is explicitly typed.',
+          });
           return;
         }
 
         if (!dataSetterParam.typeAnnotation) {
           context.report({
             node: dataSetterDefinition,
-            message: 'The type of a parameter in a data setter must be explicitly defined.'
+            message:
+              'The type of a parameter in a data setter must be explicitly defined.',
           });
           return;
         }
 
-        if (dataSetterParam.typeAnnotation.typeAnnotation.type !== 'TSTypeReference') {
+        if (
+          dataSetterParam.typeAnnotation.typeAnnotation.type !==
+          'TSTypeReference'
+        ) {
           context.report({
             node: dataSetterDefinition,
-            message: 'A data setter parameter\'s type must be a type reference, not a literal type defined inline.'
+            message:
+              'A data setter parameter\'s type must be a type reference, not a literal type defined inline.',
           });
         }
-      }
+      },
     };
-  }
+  },
 };