tools: add linting rule for async IIFEs

The result of an async IIFE should always be handled in our tests,
typically by adding `.then(common.mustCall())` to verify that the
async function actually finishes executing at some point.
PR-URL: #34363
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>

Author: addaleax

test/.eslintrc.yaml

@@ -53,6 +53,7 @@ rules:
 node-core/prefer-common-mustsucceed: error
 node-core/crypto-check: error
 node-core/eslint-check: error
+node-core/async-iife-no-unused-result: error
 node-core/inspector-check: error
 ## common module is mandatory in tests
 node-core/required-modules:

test/parallel/test-eslint-async-iife-no-unused-result.js

@@ -0,0 +1,49 @@
+'use strict';
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+common.skipIfEslintMissing();
+
+constRuleTester=require('../../tools/node_modules/eslint').RuleTester;
+construle=require('../../tools/eslint-rules/async-iife-no-unused-result');
+
+constmessage='The result of an immediately-invoked async function needs '+
+'to be used (e.g. with `.then(common.mustCall())`)';
+
+consttester=newRuleTester({parserOptions: {ecmaVersion: 8}});
+tester.run('async-iife-no-unused-result',rule,{
+valid: [
+'(() => {})()',
+'(async () => {})',
+'(async () => {})().then()',
+'(async () => {})().catch()',
+'(function () {})()',
+'(async function () {})',
+'(async function () {})().then()',
+'(async function () {})().catch()',
+],
+invalid: [
+{
+code: '(async () => {})()',
+errors: [{ message }],
+output: '(async () => {})()',
+},
+{
+code: '(async function() {})()',
+errors: [{ message }],
+output: '(async function() {})()',
+},
+{
+code: "const common = require('../common');(async () => {})()",
+errors: [{ message }],
+output: "const common = require('../common');(async () => {})()"+
+'.then(common.mustCall())',
+},
+{
+code: "const common = require('../common');(async function() {})()",
+errors: [{ message }],
+output: "const common = require('../common');(async function() {})()"+
+'.then(common.mustCall())',
+},
+]
+});

tools/eslint-rules/async-iife-no-unused-result.js

@@ -0,0 +1,40 @@
+'use strict';
+const{ isCommonModule }=require('./rules-utils.js');
+
+functionisAsyncIIFE(node){
+const{callee: { type, async }}=node;
+consttypes=['FunctionExpression','ArrowFunctionExpression'];
+returntypes.includes(type)&&async;
+}
+
+constmessage=
+'The result of an immediately-invoked async function needs to be used '+
+'(e.g. with `.then(common.mustCall())`)';
+
+module.exports={
+meta: {
+fixable: 'code'
+},
+create: function(context){
+lethasCommonModule=false;
+return{
+CallExpression: function(node){
+if(isCommonModule(node)&&node.parent.type==='VariableDeclarator'){
+hasCommonModule=true;
+}
+
+if(!isAsyncIIFE(node))return;
+if(node.parent&&node.parent.type==='ExpressionStatement'){
+context.report({
+ node,
+ message,
+fix: (fixer)=>{
+if(hasCommonModule)
+returnfixer.insertTextAfter(node,'.then(common.mustCall())');
+}
+});
+}
+}
+};
+}
+};