fix lint issues

Author: rochdev

lib/diagnostics_channel.js

@@ -281,7 +281,7 @@ function tracingChannelFrom(nameOrChannels, name) {
 }
 
 class TracingChannel {
-  #nextChannel
+  #nextChannel;
 
   constructor(nameOrChannels) {
     for (let i = 0; i < traceEvents.length; ++i) {
@@ -438,17 +438,13 @@ class TracingChannel {
 
     const { start, end, asyncStart, asyncEnd, error } = this;
 
-    if (!this.#nextChannel) {
-      this.#nextChannel = tracingChannel({
-        start: channel(start.name.slice(0, -6) + ':next:start'),
-        end: channel(end.name.slice(0, -4) + ':next:end'),
-        asyncStart: channel(asyncStart.name.slice(0, -11) + ':next:asyncStart'),
-        asyncEnd: channel(asyncEnd.name.slice(0, -9) + ':next:asyncEnd'),
-        error: channel(error.name.slice(0, -6) + ':next:error'),
-      });
-    }
-
-    const nextChannel = this.#nextChannel;
+    const nextChannel = this.#nextChannel ||= tracingChannel({
+      start: channel(start.name.slice(0, -6) + ':next:start'),
+      end: channel(end.name.slice(0, -4) + ':next:end'),
+      asyncStart: channel(asyncStart.name.slice(0, -11) + ':next:asyncStart'),
+      asyncEnd: channel(asyncEnd.name.slice(0, -9) + ':next:asyncEnd'),
+      error: channel(error.name.slice(0, -6) + ':next:error'),
+    });
 
     const wrapIter = (iter) => {
       const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
@@ -465,9 +461,9 @@ class TracingChannel {
 
     const result = this.#traceMaybePromise(fn, context, thisArg, ...args);
 
-    return result instanceof Promise
-      ? PromisePrototypeThen(result, wrapIter)
-      : wrapIter(result);
+    return result instanceof Promise ?
+      PromisePrototypeThen(result, wrapIter) :
+      wrapIter(result);
   }
 
   #traceMaybePromise(fn, context = {}, thisArg, ...args) {
@@ -499,8 +495,8 @@ class TracingChannel {
         const result = ReflectApply(fn, thisArg, args);
         // TODO: Should tracePromise just always do this?
         if (!(result instanceof Promise)) {
-          context.result = result
-          return result
+          context.result = result;
+          return result;
         }
         return PromisePrototypeThen(result, resolve, reject);
       } catch (err) {

test/parallel/test-diagnostics-channel-tracing-channel-iterator-async-next.js

@@ -21,7 +21,7 @@ function checkNextAsync(found) {
   assert.deepStrictEqual(found.result, { value: expectedResult, done: false });
 }
 
-// async function* returns an AsyncGenerator synchronously, so no asyncStart/asyncEnd
+// Async function* returns an AsyncGenerator synchronously, so no asyncStart/asyncEnd
 // for the fn call itself
 const handlers = {
   start: common.mustCall(check),

test/parallel/test-diagnostics-channel-tracing-channel-iterator-error.js

@@ -29,10 +29,11 @@ const handlers = {
   error: common.mustNotCall(),
 };
 
-// next() and throw() each produce one error
+// iter1: next() success + next() throws = start×2, end×2, error×1
+// iter2: throw() throws = start×1, end×1, error×1
 const nextHandlers = {
-  start: common.mustCall(check, 2),
-  end: common.mustCall(check, 2),
+  start: common.mustCall(check, 3),
+  end: common.mustCall(check, 3),
   asyncStart: common.mustNotCall(),
   asyncEnd: common.mustNotCall(),
   error: common.mustCall(checkError, 2),
@@ -41,12 +42,14 @@ const nextHandlers = {
 channel.subscribe(handlers);
 nextChannel.subscribe(nextHandlers);
 
-// Test next(): generator throws on first next() call
+// Test next(): generator throws after the first yield
 const iter1 = channel.traceIterator(common.mustCall(function*() {
   assert.deepStrictEqual(this, thisArg);
+  yield 1;
   throw expectedError;
 }), input, thisArg);
 
+assert.deepStrictEqual(iter1.next(), { value: 1, done: false });
 assert.throws(() => iter1.next(), expectedError);
 
 // Test throw(): propagates error through the iterator

test/parallel/test-diagnostics-channel-tracing-channel-iterator-promise-async-next.js

@@ -33,7 +33,7 @@ function checkNextAsync(found) {
   assert.deepStrictEqual(found.result, { value: expectedResult, done: false });
 }
 
-// async fn returns a Promise, so main channel fires asyncStart/asyncEnd
+// Async fn returns a Promise, so main channel fires asyncStart/asyncEnd
 const handlers = {
   start: common.mustCall(check),
   end: common.mustCall(check),
@@ -54,7 +54,7 @@ const nextHandlers = {
 channel.subscribe(handlers);
 nextChannel.subscribe(nextHandlers);
 
-// fn is async: returns a Promise resolving to an AsyncGenerator
+// Fn is async: returns a Promise resolving to an AsyncGenerator
 // traceIterator returns a Promise resolving to the wrapped AsyncGenerator
 channel.traceIterator(common.mustCall(async function() {
   assert.deepStrictEqual(this, thisArg);

test/parallel/test-diagnostics-channel-tracing-channel-iterator-promise.js

@@ -24,7 +24,7 @@ function checkAsync(found) {
   assert.strictEqual(found.result, syncIter);
 }
 
-// async fn returns a Promise, so main channel fires asyncStart/asyncEnd
+// Async fn returns a Promise, so main channel fires asyncStart/asyncEnd
 const handlers = {
   start: common.mustCall(check),
   end: common.mustCall(check),
@@ -45,7 +45,7 @@ const nextHandlers = {
 channel.subscribe(handlers);
 nextChannel.subscribe(nextHandlers);
 
-// fn is async: returns a Promise resolving to a sync iterator
+// Fn is async: returns a Promise resolving to a sync iterator
 // traceIterator returns a Promise resolving to the wrapped iterator
 channel.traceIterator(common.mustCall(async function() {
   assert.deepStrictEqual(this, thisArg);