Implement AsyncIteratorClose for for-await-of statement. (#3955)

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

tests/jerry/es.next/for-await-of-iterator-close.js

@@ -0,0 +1,623 @@
+// Copyright JS Foundation and other contributors, http://js.foundation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+var successCount = 0;
+
+// Test 1
+
+var asyncIter1 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: "Val", done: false })
+      }
+      /* No return() function */
+    }
+  }
+}
+
+async function f1() {
+  for await (var v of asyncIter1) {
+    assert(v === "Val")
+    break
+  }
+  successCount++
+
+exit:
+  for await (var v of asyncIter1) {
+    for await (var v of asyncIter1) {
+      assert(v === "Val")
+      break exit
+    }
+    assert(false)
+  }
+  successCount++
+
+  try {
+    for await (var v of asyncIter1) {
+      assert(v === "Val")
+      throw 3.75
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === 3.75)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter1) {
+      assert(v === "Val")
+      return {}
+    }
+    assert(false)
+  } finally {
+    successCount++
+  }
+  assert(false)
+}
+
+f1()
+
+// Test 2
+
+var o2 = {}
+var returnCount2 = 0
+var asyncIter2 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: o2, done: false })
+      },
+      return(...v) {
+        assert(v.length === 0)
+        returnCount2++
+        return Promise.resolve({})
+      }
+    }
+  }
+}
+
+async function f2() {
+  for await (var v of asyncIter2) {
+    assert(v === o2)
+    break
+  }
+  successCount++
+
+exit:
+  for await (var v of asyncIter2) {
+    for await (var v of asyncIter2) {
+      assert(v === o2)
+      break exit
+    }
+    assert(false)
+  }
+  successCount++
+
+  try {
+    for await (var v of asyncIter2) {
+      assert(v === o2)
+      throw o2
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === o2)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter2) {
+      assert(v === o2)
+      return "Ret"
+    }
+    assert(false)
+  } finally {
+    successCount++
+  }
+  assert(false)
+  print("OK")
+}
+
+f2()
+
+// Test 3
+
+var asyncIter3 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      return() {
+        throw "Error"
+      }
+    }
+  }
+}
+
+async function *f3() {
+  try {
+    for await (var v of asyncIter3) {
+      assert(v === -4.5)
+      break
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Error")
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter3) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Error")
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter3) {
+      assert(v === -4.5)
+      throw "Exit"
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Exit")
+    successCount++
+  }
+}
+
+f3().next()
+
+// Test 4
+
+var o4 = {}
+var asyncIter4 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      get return() {
+        throw o4
+      }
+    }
+  }
+}
+
+async function *f4() {
+  try {
+    for await (var v of asyncIter4) {
+      assert(v === -4.5)
+      break
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === o4)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter4) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === o4)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter4) {
+      assert(v === -4.5)
+      throw 9.25
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === 9.25)
+    successCount++
+  }
+}
+
+f4().next()
+
+// Test 5
+
+var asyncIter5 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      get return() {
+        return "Not callable"
+      }
+    }
+  }
+}
+
+async function f5() {
+  try {
+    for await (var v of asyncIter5) {
+      assert(v === -4.5)
+      break
+    }
+    assert(false)
+  } catch (e) {
+    assert(e instanceof TypeError)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter5) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } catch (e) {
+    assert(e instanceof TypeError)
+    successCount++
+  }
+
+  var o = {}
+  try {
+    for await (var v of asyncIter5) {
+      assert(v === -4.5)
+      throw o
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === o)
+    successCount++
+  }
+}
+
+f5()
+
+// Test 6
+
+var asyncIter6 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      return() {
+        return Promise.resolve(4.5)
+      }
+    }
+  }
+}
+
+async function f6() {
+  try {
+    for await (var v of asyncIter6) {
+      assert(v === -4.5)
+      break
+    }
+    assert(false)
+  } catch (e) {
+    assert(e instanceof TypeError)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter6) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } catch (e) {
+    assert(e instanceof TypeError)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter6) {
+      assert(v === -4.5)
+      throw true
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === true)
+    successCount++
+  }
+}
+
+f6()
+
+// Test 7
+
+var asyncIter7 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      return() {
+        return Promise.reject("Rejected")
+      }
+    }
+  }
+}
+
+async function f7() {
+  try {
+    for await (var v of asyncIter7) {
+      assert(v === -4.5)
+      break
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Rejected")
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter7) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Rejected")
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter7) {
+      assert(v === -4.5)
+      throw true
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === true)
+    successCount++
+  }
+}
+
+f7()
+
+// Test 8
+
+var asyncIter8 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      return() {
+        return {}
+      }
+    }
+  }
+}
+
+async function f8() {
+  for await (var v of asyncIter8) {
+    assert(v === -4.5)
+    break
+  }
+  successCount++
+
+  try {
+    for await (var v of asyncIter8) {
+      assert(v === -4.5)
+      throw null
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === null)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter8) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } finally {
+    successCount++
+  }
+}
+
+f8()
+
+// Test 9
+
+var asyncIter9 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        assert(++idx === 1)
+        return Promise.resolve({ value: -4.5, done: false })
+      },
+      return() {
+        throw "Except"
+      }
+    }
+  }
+}
+
+async function f9() {
+  try {
+    for await (var v of asyncIter9) {
+      assert(v === -4.5)
+      break
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Except")
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter9) {
+      assert(v === -4.5)
+      throw 7.5
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === 7.5)
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter9) {
+      assert(v === -4.5)
+      for await (var v of asyncIter9) {
+        assert(v === -4.5)
+        for await (var v of asyncIter9) {
+          assert(v === -4.5)
+          throw "Leave"
+        }
+        assert(false)
+      }
+      assert(false)
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Leave")
+    successCount++
+  }
+
+  try {
+    for await (var v of asyncIter9) {
+      assert(v === -4.5)
+      return
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Except")
+    successCount++
+  }
+}
+
+f9()
+
+// Test 10
+
+var asyncIter10 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        throw "NoNext"
+      },
+      return() {
+        assert(false)
+      },
+      throw() {
+        assert(false)
+      }
+    }
+  }
+}
+
+async function f10() {
+  try {
+    try {
+      for await (var v of asyncIter10) {
+        assert(false)
+      }
+      assert(false)
+    } finally {
+      successCount++
+    }
+  } catch (e) {
+    assert(e === "NoNext")
+    successCount++
+  }
+}
+
+f10()
+
+// Test 11
+
+var asyncIter11 = {
+  [Symbol.asyncIterator]() {
+    var idx = 0;
+
+    return {
+      next() {
+        if (++idx < 3)
+          return Promise.resolve({ value: -4.5, done: false })
+        throw "NoNext"
+      },
+      return() {
+        assert(false)
+      },
+      throw() {
+        assert(false)
+      }
+    }
+  }
+}
+
+async function f11() {
+  try {
+    try {
+      for await (var v of asyncIter11) {
+        assert(v === -4.5)
+      }
+      assert(false)
+    } finally {
+      successCount++
+    }
+  } catch (e) {
+    assert(e === "NoNext")
+    successCount++
+  }
+}
+
+f11()
+
+// END
+
+function __checkAsync() {
+  assert(returnCount2 === 5)
+  assert(successCount === 34)
+}