Add a test for Iterator.concat not closing the underlying iterator

The only IteratorClose in the closure of Iterator.concat is the one
performed for an abrupt completion of the Yield. An abrupt completion
from IteratorStepValue is propagated as is, so a throwing next method, a
throwing done or value getter, and a next method returning a non-object
all leave the iterator alone.

Note that V8 fails this test: it closes the iterator in all four cases,
unlike its own iterator helpers, which do not. JavaScriptCore does not
close it.

Author: saghul

test/built-ins/Iterator/concat/underlying-iterator-not-closed-when-step-throws.js

@@ -0,0 +1,112 @@
+// Copyright (C) 2026 Saúl Ibarra Corretgé. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-iterator.concat
+description: >
+  Underlying iterator is not closed when stepping it throws
+info: |
+  Iterator.concat ( ...items )
+
+  ...
+  3. Let closure be a new Abstract Closure with no parameters that captures iterables and performs the following steps when called:
+    a. For each Record iterable of iterables, do
+      ...
+      v. Repeat, while innerAlive is true,
+        1. Let innerValue be ? IteratorStepValue(iteratorRecord).
+        ...
+
+  The only IteratorClose in the closure is the one performed for an abrupt
+  completion of the Yield; an abrupt completion from IteratorStepValue is
+  propagated as is, which only marks the iterator record done:
+
+  IteratorStepValue ( iteratorRecord )
+
+  1. Let result be Completion(IteratorNext(iteratorRecord)).
+  2. If result is a throw completion, then
+    a. Set iteratorRecord.[[Done]] to true.
+    b. Return ? result.
+  ...
+  4. Let done be Completion(IteratorComplete(result)).
+  5. If done is a throw completion, then
+    a. Set iteratorRecord.[[Done]] to true.
+    b. Return ? done.
+  ...
+  8. Let value be Completion(Get(result, "value")).
+  9. If value is a throw completion, then
+    a. Set iteratorRecord.[[Done]] to true.
+  10. Return ? value.
+features: [iterator-sequencing]
+---*/
+
+let returnCalls = 0;
+
+function concatWithStep(next) {
+  let iterable = {
+    [Symbol.iterator]() {
+      return {
+        next,
+        return() {
+          ++returnCalls;
+          return {};
+        },
+      };
+    }
+  };
+
+  return Iterator.concat(iterable);
+}
+
+// Underlying iterator has a throwing next method.
+let iterator = concatWithStep(function() {
+  throw new Test262Error();
+});
+
+assert.throws(Test262Error, function() {
+  iterator.next();
+});
+
+assert.sameValue(returnCalls, 0, 'return is not called on the underlying iterator');
+
+// Underlying iterator next returns an object with a throwing done getter.
+iterator = concatWithStep(function() {
+  return {
+    get done() {
+      throw new Test262Error();
+    },
+    value: 1,
+  };
+});
+
+assert.throws(Test262Error, function() {
+  iterator.next();
+});
+
+assert.sameValue(returnCalls, 0, 'return is not called on the underlying iterator');
+
+// Underlying iterator next returns an object with a throwing value getter.
+iterator = concatWithStep(function() {
+  return {
+    done: false,
+    get value() {
+      throw new Test262Error();
+    },
+  };
+});
+
+assert.throws(Test262Error, function() {
+  iterator.next();
+});
+
+assert.sameValue(returnCalls, 0, 'return is not called on the underlying iterator');
+
+// Underlying iterator next returns a non-object.
+iterator = concatWithStep(function() {
+  return null;
+});
+
+assert.throws(TypeError, function() {
+  iterator.next();
+});
+
+assert.sameValue(returnCalls, 0, 'return is not called on the underlying iterator');