test,tools: use .then(common.mustCall()) for all async IIFEs + linter rule

test/.eslintrc.yaml

@@ -53,6 +53,7 @@ rules:
   node-core/prefer-common-mustnotcall: 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/es-module/test-esm-error-cache.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const file = '../fixtures/syntax/bad_syntax.mjs';
@@ -23,4 +23,4 @@ let error;
       return true;
     }
   );
-})();
+})().then(common.mustCall());

test/es-module/test-esm-import-meta-resolve.mjs

@@ -1,5 +1,5 @@
 // Flags: --experimental-import-meta-resolve
-import '../common/index.mjs';
+import { mustCall } from '../common/index.mjs';
 import assert from 'assert';
 
 const dirname = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1);
@@ -21,4 +21,4 @@ const fixtures = dirname.slice(0, dirname.lastIndexOf('/', dirname.length - 2) +
   assert.strictEqual(await import.meta.resolve('../fixtures/'), fixtures);
   assert.strictEqual(await import.meta.resolve('baz/', fixtures),
                      fixtures + 'node_modules/baz/');
-})();
+})().then(mustCall());

test/internet/test-dns-promises-resolve.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const dnsPromises = require('dns').promises;
@@ -38,5 +38,5 @@ const dnsPromises = require('dns').promises;
     const result = await dnsPromises.resolve('example.org', rrtype);
     assert.ok(result !== undefined);
     assert.ok(result.length > 0);
-  })();
+  })().then(common.mustCall());
 }

test/internet/test-dns-txt-sigsegv.js

@@ -1,13 +1,13 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const dns = require('dns');
 const dnsPromises = dns.promises;
 
 (async function() {
   const result = await dnsPromises.resolveTxt('www.microsoft.com');
   assert.strictEqual(result.length, 0);
-})();
+})().then(common.mustCall());
 
 dns.resolveTxt('www.microsoft.com', function(err, records) {
   assert.strictEqual(err, null);

test/internet/test-dns.js

@@ -708,4 +708,4 @@ dns.lookupService('0.0.0.0', 0, common.mustCall());
 (async function() {
   await dnsPromises.lookup(addresses.INET6_HOST, 6);
   await dnsPromises.lookup(addresses.INET_HOST, {});
-})();
+})().then(common.mustCall());

test/parallel/test-c-ares.js

@@ -40,7 +40,7 @@ const dnsPromises = dns.promises;
   res = await dnsPromises.lookup('::1');
   assert.strictEqual(res.address, '::1');
   assert.strictEqual(res.family, 6);
-})();
+})().then(common.mustCall());
 
 // Try resolution without callback
 
@@ -94,5 +94,5 @@ if (!common.isWindows && !common.isIBMi) {
 
   (async function() {
     assert.ok(Array.isArray(await dnsPromises.reverse('127.0.0.1')));
-  })();
+  })().then(common.mustCall());
 }

test/parallel/test-child-process-spawn-args.js

@@ -52,4 +52,4 @@ const expectedResult = tmpdir.path.trim().toLowerCase();
   );
 
   assert.deepStrictEqual([...new Set(results)], [expectedResult]);
-})();
+})().then(common.mustCall());

test/parallel/test-dns-lookup-promises.js

@@ -135,5 +135,5 @@ async function lookupallNegative() {
     lookupNegative(),
     lookupallPositive(),
     lookupallNegative()
-  ]).then(common.mustCall());
-})();
+  ]);
+})().then(common.mustCall());

test/parallel/test-dns-lookup.js

@@ -109,7 +109,7 @@ assert.throws(() => {
     all: false
   });
   assert.deepStrictEqual(res, { address: '127.0.0.1', family: 4 });
-})();
+})().then(common.mustCall());
 
 dns.lookup(false, {
   hints: 0,

test/parallel/test-dns-setservers-type-check.js

@@ -95,7 +95,7 @@ const promiseResolver = new dns.promises.Resolver();
   // This should not throw any error.
   (async () => {
     setServers([ '127.0.0.1' ]);
-  })();
+  })().then(common.mustCall());
 
   [
     [null],

test/parallel/test-dns.js

@@ -276,7 +276,7 @@ dns.lookup('', {
   await dnsPromises.lookup('', {
     hints: dns.ADDRCONFIG | dns.V4MAPPED | dns.ALL
   });
-})();
+})().then(common.mustCall());
 
 {
   const err = {
@@ -450,7 +450,7 @@ assert.throws(() => {
         cases.shift();
         nextCase();
       }));
-    })();
+    })().then(common.mustCall());
 
   }));
 }

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

@@ -0,0 +1,49 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+common.skipIfEslintMissing();
+
+const RuleTester = require('../../tools/node_modules/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/async-iife-no-unused-result');
+
+const message = 'The result of an immediately-invoked async function needs ' +
+  'to be used (e.g. with `.then(common.mustCall())`)';
+
+const tester = new RuleTester({ 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())',
+    },
+  ]
+});

test/parallel/test-fs-copyfile-respect-permissions.js

@@ -49,7 +49,7 @@ function beforeEach() {
   const { source, dest, check } = beforeEach();
   (async () => {
     await assert.rejects(fs.promises.copyFile(source, dest), check);
-  })();
+  })().then(common.mustCall());
 }
 
 // Test callback API.

test/parallel/test-fs-read-empty-buffer.js

@@ -38,4 +38,4 @@ assert.throws(
                'Received Uint8Array(0) []'
     }
   );
-})();
+})().then(common.mustCall());

test/parallel/test-fs-readdir-types.js

@@ -77,7 +77,7 @@ fs.readdir(readdirDir, {
     withFileTypes: true
   });
   assertDirents(dirents);
-})();
+})().then(common.mustCall());
 
 // Check for correct types when the binding returns unknowns
 const UNKNOWN = constants.UV_DIRENT_UNKNOWN;

test/parallel/test-fs-readv-promises.js

@@ -1,6 +1,5 @@
 'use strict';
-
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 const fs = require('fs').promises;
@@ -64,4 +63,4 @@ const allocateEmptyBuffers = (combinedLength) => {
     assert(Buffer.concat(bufferArr).equals(await fs.readFile(filename)));
     handle.close();
   }
-})();
+})().then(common.mustCall());

test/parallel/test-fs-rmdir-recursive.js

@@ -149,7 +149,7 @@ function removeAsync(dir) {
 
   // Attempted removal should fail now because the directory is gone.
   assert.rejects(fs.promises.rmdir(dir), { syscall: 'rmdir' });
-})();
+})().then(common.mustCall());
 
 // Test input validation.
 {

test/parallel/test-fs-stat-bigint.js

@@ -185,4 +185,4 @@ if (!common.isWindows) {
   const allowableDelta = Math.ceil(Number(endTime - startTime) / 1e6);
   verifyStats(bigintStats, numStats, allowableDelta);
   await handle.close();
-})();
+})().then(common.mustCall());

test/parallel/test-fs-writev-promises.js

@@ -1,6 +1,5 @@
 'use strict';
-
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 const fs = require('fs').promises;
@@ -48,4 +47,4 @@ tmpdir.refresh();
     assert(Buffer.concat(bufferArr).equals(await fs.readFile(filename)));
     handle.close();
   }
-})();
+})().then(common.mustCall());

test/parallel/test-inspect-publish-uid.js

@@ -10,7 +10,7 @@ const { spawnSync } = require('child_process');
   await testArg('stderr');
   await testArg('http');
   await testArg('http,stderr');
-})();
+})().then(common.mustCall());
 
 async function testArg(argValue) {
   console.log('Checks ' + argValue + '..');

test/parallel/test-internal-module-wrap.js

@@ -1,8 +1,6 @@
-'use strict';
-
 // Flags: --expose-internals
-
-require('../common');
+'use strict';
+const common = require('../common');
 const assert = require('assert');
 
 const { internalBinding } = require('internal/test/binding');
@@ -26,4 +24,4 @@ const bar = new ModuleWrap('bar', undefined, 'export const five = 5', 0, 0);
 
   assert.strictEqual(await foo.evaluate(-1, false), undefined);
   assert.strictEqual(foo.getNamespace().five, 5);
-})();
+})().then(common.mustCall());

test/parallel/test-repl.js

@@ -827,7 +827,7 @@ const tcpTests = [
     socket.end();
   }
   common.allowGlobals(...Object.values(global));
-})();
+})().then(common.mustCall());
 
 function startTCPRepl() {
   let resolveSocket, resolveReplServer;

test/parallel/test-util-inspect-namespace.js

@@ -1,8 +1,6 @@
-'use strict';
-
 // Flags: --experimental-vm-modules
-
-require('../common');
+'use strict';
+const common = require('../common');
 const assert = require('assert');
 
 const { SourceTextModule } = require('vm');
@@ -16,4 +14,4 @@ const { inspect } = require('util');
     '[Module] { a: <uninitialized>, b: undefined }');
   await m.evaluate();
   assert.strictEqual(inspect(m.namespace), '[Module] { a: 1, b: 2 }');
-})();
+})().then(common.mustCall());

test/parallel/test-util-promisify.js

@@ -131,7 +131,7 @@ const stat = promisify(fs.stat);
   (async () => {
     const value = await promisify(fn)(null, 42);
     assert.strictEqual(value, 42);
-  })();
+  })().then(common.mustCall());
 }
 
 {
@@ -159,7 +159,7 @@ const stat = promisify(fs.stat);
     await fn();
     await Promise.resolve();
     return assert.strictEqual(stack, err.stack);
-  })();
+  })().then(common.mustCall());
 }
 
 {

test/parallel/test-util-types.js

@@ -1,6 +1,6 @@
 // Flags: --experimental-vm-modules --expose-internals
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const { types, inspect } = require('util');
 const vm = require('vm');
@@ -280,4 +280,4 @@ for (const [ value, _method ] of [
   await m.link(() => 0);
   await m.evaluate();
   assert.ok(types.isModuleNamespaceObject(m.namespace));
-})();
+})().then(common.mustCall());

test/parallel/test-vm-module-basic.js

@@ -32,7 +32,7 @@ const util = require('util');
     baz: 'bar',
     typeofProcess: 'undefined'
   });
-}());
+}().then(common.mustCall()));
 
 (async () => {
   const m = new SourceTextModule(`
@@ -45,14 +45,14 @@ const util = require('util');
   assert.strictEqual(global.vmResultTypeofProcess, '[object process]');
   delete global.vmResultFoo;
   delete global.vmResultTypeofProcess;
-})();
+})().then(common.mustCall());
 
 (async () => {
   const m = new SourceTextModule('while (true) {}');
   await m.link(common.mustNotCall());
   await m.evaluate({ timeout: 500 })
     .then(() => assert(false), () => {});
-})();
+})().then(common.mustCall());
 
 // Check the generated identifier for each module
 (async () => {
@@ -65,7 +65,7 @@ const util = require('util');
   assert.strictEqual(m2.identifier, 'vm:module(1)');
   const m3 = new SourceTextModule('3', { context: context2 });
   assert.strictEqual(m3.identifier, 'vm:module(0)');
-})();
+})().then(common.mustCall());
 
 // Check inspection of the instance
 {

test/parallel/test-vm-module-errors.js

@@ -233,4 +233,4 @@ const finished = common.mustCall();
   await checkInvalidOptionForEvaluate();
   checkInvalidCachedData();
   finished();
-})();
+})().then(common.mustCall());

test/parallel/test-vm-module-import-meta.js

@@ -41,4 +41,4 @@ async function testInvalid() {
 (async () => {
   await testBasic();
   await testInvalid();
-})();
+})().then(common.mustCall());

test/parallel/test-vm-module-link.js

@@ -133,4 +133,4 @@ const finished = common.mustCall();
   await circular();
   await circular2();
   finished();
-})();
+})().then(common.mustCall());

test/parallel/test-vm-module-reevaluate.js

@@ -48,4 +48,4 @@ const finished = common.mustCall();
   }
 
   finished();
-})();
+})().then(common.mustCall());