test: use blocks instead of async IIFE

Using an IIFE with async functions + await is equivalent
to using a block scope (aside from scoping effects
we don’t rely on), as far as I can tell.
PR-URL: #24989
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Anto Aravinth <anto.aravinth.cse@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>

Author: addaleax

test/parallel/test-stream-readable-async-iterators.js

@@ -14,7 +14,7 @@ async function tests() {
 AsyncIteratorPrototype);
 }
 
-await(asyncfunction(){
+{
 constreadable=newReadable({objectMode: true,read(){}});
 readable.push(0);
 readable.push(1);
@@ -25,9 +25,9 @@ async function tests() {
 forawait(constdofiter){
 assert.strictEqual(d,1);
 }
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('read without for..await');
 constmax=5;
 constreadable=newReadable({
@@ -55,9 +55,9 @@ async function tests() {
 
 constlast=awaititer.next();
 assert.strictEqual(last.done,true);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('read without for..await deferred');
 constreadable=newReadable({
 objectMode: true,
@@ -95,9 +95,9 @@ async function tests() {
 
 constlast=awaititer.next();
 assert.strictEqual(last.done,true);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('read without for..await with errors');
 constmax=3;
 constreadable=newReadable({
@@ -133,9 +133,9 @@ async function tests() {
 });
 
 readable.destroy(newError('kaboom'));
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('call next() after error');
 constreadable=newReadable({
 read(){}
@@ -145,9 +145,9 @@ async function tests() {
 consterr=newError('kaboom');
 readable.destroy(newError('kaboom'));
 awaitassert.rejects(iterator.next.bind(iterator),err);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('read object mode');
 constmax=42;
 letreaded=0;
@@ -168,9 +168,9 @@ async function tests() {
 }
 
 assert.strictEqual(readed,received);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('destroy sync');
 constreadable=newReadable({
 objectMode: true,
@@ -187,9 +187,9 @@ async function tests() {
 err=e;
 }
 assert.strictEqual(err.message,'kaboom from read');
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('destroy async');
 constreadable=newReadable({
 objectMode: true,
@@ -219,9 +219,9 @@ async function tests() {
 
 assert.strictEqual(err.message,'kaboom');
 assert.strictEqual(received,1);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('destroyed by throw');
 constreadable=newReadable({
 objectMode: true,
@@ -242,9 +242,9 @@ async function tests() {
 
 assert.strictEqual(err.message,'kaboom');
 assert.strictEqual(readable.destroyed,true);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('destroyed sync after push');
 constreadable=newReadable({
 objectMode: true,
@@ -268,9 +268,9 @@ async function tests() {
 
 assert.strictEqual(err.message,'kaboom');
 assert.strictEqual(received,1);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('push async');
 constmax=42;
 letreaded=0;
@@ -293,9 +293,9 @@ async function tests() {
 }
 
 assert.strictEqual(readed,received);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('push binary async');
 constmax=42;
 letreaded=0;
@@ -323,9 +323,9 @@ async function tests() {
 }
 
 assert.strictEqual(data,expected);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('.next() on destroyed stream');
 constreadable=newReadable({
 read(){
@@ -337,9 +337,9 @@ async function tests() {
 
 const{ done }=awaitreadable[Symbol.asyncIterator]().next();
 assert.strictEqual(done,true);
-})();
+}
 
-await(asyncfunction(){
+{
 console.log('.next() on pipelined stream');
 constreadable=newReadable({
 read(){
@@ -358,9 +358,9 @@ async function tests() {
 }catch(e){
 assert.strictEqual(e,err);
 }
-})();
+}
 
-await(async()=>{
+{
 console.log('iterating on an ended stream completes');
 constr=newReadable({
 objectMode: true,
@@ -376,9 +376,9 @@ async function tests() {
 // eslint-disable-next-line no-unused-vars
 forawait(constbofr){
 }
-})();
+}
 
-await(async()=>{
+{
 console.log('destroy mid-stream does not error');
 constr=newReadable({
 objectMode: true,
@@ -392,9 +392,9 @@ async function tests() {
 forawait(constaofr){
 r.destroy(null);
 }
-})();
+}
 
-await(async()=>{
+{
 console.log('all next promises must be resolved on end');
 constr=newReadable({
 objectMode: true,
@@ -408,9 +408,9 @@ async function tests() {
 r.push(null);
 assert.deepStrictEqual(awaitc,{done: true,value: undefined});
 assert.deepStrictEqual(awaitd,{done: true,value: undefined});
-})();
+}
 
-await(async()=>{
+{
 console.log('all next promises must be resolved on destroy');
 constr=newReadable({
 objectMode: true,
@@ -424,9 +424,9 @@ async function tests() {
 r.destroy();
 assert.deepStrictEqual(awaitc,{done: true,value: undefined});
 assert.deepStrictEqual(awaitd,{done: true,value: undefined});
-})();
+}
 
-await(async()=>{
+{
 console.log('all next promises must be resolved on destroy with error');
 constr=newReadable({
 objectMode: true,
@@ -457,7 +457,7 @@ async function tests() {
 }
 assert.strictEqual(e,err);
 })()]);
-})();
+}
 }
 
 // to avoid missing some tests if a promise does not resolve