tools: update ESLint to 8.0.0

.eslintrc.js

@@ -17,9 +17,6 @@ const hacks = [
   'eslint-plugin-node-core',
   'eslint-plugin-markdown',
   '@babel/eslint-parser',
-  '@babel/plugin-syntax-class-properties',
-  '@babel/plugin-syntax-import-assertions',
-  '@babel/plugin-syntax-top-level-await',
 ];
 Module._findPath = (request, paths, isMain) => {
   const r = ModuleFindPath(request, paths, isMain);
@@ -39,13 +36,6 @@ module.exports = {
   plugins: ['markdown', 'node-core'],
   parser: '@babel/eslint-parser',
   parserOptions: {
-    babelOptions: {
-      plugins: [
-        Module._findPath('@babel/plugin-syntax-class-properties'),
-        Module._findPath('@babel/plugin-syntax-import-assertions'),
-        Module._findPath('@babel/plugin-syntax-top-level-await'),
-      ],
-    },
     requireConfigFile: false,
     sourceType: 'script',
   },

tools/eslint-rules/crypto-check.js

@@ -20,107 +20,108 @@ const cryptoModules = ['crypto', 'http2'];
 const requireModules = cryptoModules.concat(['tls', 'https']);
 const bindingModules = cryptoModules.concat(['tls_wrap']);
 
-module.exports = function(context) {
-  const missingCheckNodes = [];
-  const requireNodes = [];
-  let commonModuleNode = null;
-  let hasSkipCall = false;
+module.exports = {
+  meta: {
+    fixable: 'code',
+  },
+  create(context) {
+    const missingCheckNodes = [];
+    const requireNodes = [];
+    let commonModuleNode = null;
+    let hasSkipCall = false;
+
+    function testCryptoUsage(node) {
+      if (utils.isRequired(node, requireModules) ||
+          utils.isBinding(node, bindingModules)) {
+        requireNodes.push(node);
+      }
 
-  function testCryptoUsage(node) {
-    if (utils.isRequired(node, requireModules) ||
-        utils.isBinding(node, bindingModules)) {
-      requireNodes.push(node);
+      if (utils.isCommonModule(node)) {
+        commonModuleNode = node;
+      }
     }
 
-    if (utils.isCommonModule(node)) {
-      commonModuleNode = node;
+    function testIfStatement(node) {
+      if (node.test.argument === undefined) {
+        return;
+      }
+      if (isCryptoCheck(node.test.argument)) {
+        checkCryptoCall(node);
+      }
     }
-  }
 
-  function testIfStatement(node) {
-    if (node.test.argument === undefined) {
-      return;
-    }
-    if (isCryptoCheck(node.test.argument)) {
-      checkCryptoCall(node);
+    function isCryptoCheck(node) {
+      return utils.usesCommonProperty(node, ['hasCrypto', 'hasFipsCrypto']);
     }
-  }
-
-  function isCryptoCheck(node) {
-    return utils.usesCommonProperty(node, ['hasCrypto', 'hasFipsCrypto']);
-  }
 
-  function checkCryptoCall(node) {
-    if (utils.inSkipBlock(node)) {
-      hasSkipCall = true;
-    } else {
-      missingCheckNodes.push(node);
+    function checkCryptoCall(node) {
+      if (utils.inSkipBlock(node)) {
+        hasSkipCall = true;
+      } else {
+        missingCheckNodes.push(node);
+      }
     }
-  }
 
-  function testMemberExpression(node) {
-    if (isCryptoCheck(node)) {
-      checkCryptoCall(node);
+    function testMemberExpression(node) {
+      if (isCryptoCheck(node)) {
+        checkCryptoCall(node);
+      }
     }
-  }
-
-  function reportIfMissingCheck() {
-    if (hasSkipCall) {
-      // There is a skip, which is good, but verify that the require() calls
-      // in question come after at least one check.
-      if (missingCheckNodes.length > 0) {
-        requireNodes.forEach((requireNode) => {
-          const beforeAllChecks = missingCheckNodes.every((checkNode) => {
-            return requireNode.range[0] < checkNode.range[0];
-          });
 
-          if (beforeAllChecks) {
-            context.report({
-              node: requireNode,
-              message: msg
+    function reportIfMissingCheck() {
+      if (hasSkipCall) {
+        // There is a skip, which is good, but verify that the require() calls
+        // in question come after at least one check.
+        if (missingCheckNodes.length > 0) {
+          requireNodes.forEach((requireNode) => {
+            const beforeAllChecks = missingCheckNodes.every((checkNode) => {
+              return requireNode.range[0] < checkNode.range[0];
             });
-          }
-        });
+
+            if (beforeAllChecks) {
+              context.report({
+                node: requireNode,
+                message: msg
+              });
+            }
+          });
+        }
+        return;
       }
-      return;
-    }
 
-    if (requireNodes.length > 0) {
-      if (missingCheckNodes.length > 0) {
-        report(missingCheckNodes);
-      } else {
-        report(requireNodes);
+      if (requireNodes.length > 0) {
+        if (missingCheckNodes.length > 0) {
+          report(missingCheckNodes);
+        } else {
+          report(requireNodes);
+        }
       }
     }
-  }
 
-  function report(nodes) {
-    nodes.forEach((node) => {
-      context.report({
-        node,
-        message: msg,
-        fix: (fixer) => {
-          if (commonModuleNode) {
-            return fixer.insertTextAfter(
-              commonModuleNode,
-              '\nif (!common.hasCrypto) {' +
-              ' common.skip("missing crypto");' +
-              '}'
-            );
+    function report(nodes) {
+      nodes.forEach((node) => {
+        context.report({
+          node,
+          message: msg,
+          fix: (fixer) => {
+            if (commonModuleNode) {
+              return fixer.insertTextAfter(
+                commonModuleNode,
+                '\nif (!common.hasCrypto) {' +
+                ' common.skip("missing crypto");' +
+                '}'
+              );
+            }
           }
-        }
+        });
       });
-    });
-  }
-
-  return {
-    'CallExpression': (node) => testCryptoUsage(node),
-    'IfStatement:exit': (node) => testIfStatement(node),
-    'MemberExpression:exit': (node) => testMemberExpression(node),
-    'Program:exit': () => reportIfMissingCheck()
-  };
-};
+    }
 
-module.exports.meta = {
-  fixable: 'code'
+    return {
+      'CallExpression': (node) => testCryptoUsage(node),
+      'IfStatement:exit': (node) => testIfStatement(node),
+      'MemberExpression:exit': (node) => testMemberExpression(node),
+      'Program:exit': () => reportIfMissingCheck()
+    };
+  }
 };

tools/eslint-rules/inspector-check.js

@@ -13,53 +13,54 @@ const utils = require('./rules-utils.js');
 const msg = 'Please add a skipIfInspectorDisabled() call to allow this ' +
             'test to be skipped when Node is built \'--without-inspector\'.';
 
-module.exports = function(context) {
-  const missingCheckNodes = [];
-  let commonModuleNode = null;
-  let hasInspectorCheck = false;
+module.exports = {
+  meta: {
+    fixable: 'code',
+  },
+  create(context) {
+    const missingCheckNodes = [];
+    let commonModuleNode = null;
+    let hasInspectorCheck = false;
 
-  function testInspectorUsage(context, node) {
-    if (utils.isRequired(node, ['inspector'])) {
-      missingCheckNodes.push(node);
-    }
+    function testInspectorUsage(context, node) {
+      if (utils.isRequired(node, ['inspector'])) {
+        missingCheckNodes.push(node);
+      }
 
-    if (utils.isCommonModule(node)) {
-      commonModuleNode = node;
+      if (utils.isCommonModule(node)) {
+        commonModuleNode = node;
+      }
     }
-  }
 
-  function checkMemberExpression(context, node) {
-    if (utils.usesCommonProperty(node, ['skipIfInspectorDisabled'])) {
-      hasInspectorCheck = true;
+    function checkMemberExpression(context, node) {
+      if (utils.usesCommonProperty(node, ['skipIfInspectorDisabled'])) {
+        hasInspectorCheck = true;
+      }
     }
-  }
 
-  function reportIfMissing(context) {
-    if (!hasInspectorCheck) {
-      missingCheckNodes.forEach((node) => {
-        context.report({
-          node,
-          message: msg,
-          fix: (fixer) => {
-            if (commonModuleNode) {
-              return fixer.insertTextAfter(
-                commonModuleNode,
-                '\ncommon.skipIfInspectorDisabled();'
-              );
+    function reportIfMissing(context) {
+      if (!hasInspectorCheck) {
+        missingCheckNodes.forEach((node) => {
+          context.report({
+            node,
+            message: msg,
+            fix: (fixer) => {
+              if (commonModuleNode) {
+                return fixer.insertTextAfter(
+                  commonModuleNode,
+                  '\ncommon.skipIfInspectorDisabled();'
+                );
+              }
             }
-          }
+          });
         });
-      });
+      }
     }
-  }
 
-  return {
-    'CallExpression': (node) => testInspectorUsage(context, node),
-    'MemberExpression': (node) => checkMemberExpression(context, node),
-    'Program:exit': () => reportIfMissing(context)
-  };
-};
-
-module.exports.meta = {
-  fixable: 'code'
+    return {
+      'CallExpression': (node) => testInspectorUsage(context, node),
+      'MemberExpression': (node) => checkMemberExpression(context, node),
+      'Program:exit': () => reportIfMissing(context)
+    };
+  }
 };