Implement yield* operator (#3923)

Missing features:
- caching next() method (this also true for normal generators)
- automatic sync to async generator conversion

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

tests/jerry/es.next/function-async-gen2.js

@@ -0,0 +1,304 @@
+// 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
+
+function check_fulfilled(p, value, done)
+{
+  assert(p instanceof Promise)
+
+  p.then(function(v) {
+    assert(v.value === value)
+    assert(v.done === done)
+    successCount++
+  }, function() {
+    assert(false)
+  })
+}
+
+function check_rejected(p, value)
+{
+  assert(p instanceof Promise)
+
+  p.then(function(v) {
+    assert(false)
+  }, function(v) {
+    assert(v === value)
+    successCount++
+  })
+}
+
+// Test 1
+
+var o1 = {}
+var arr1 = []
+var async1 = {
+  [Symbol.asyncIterator]() {
+    arr1 = []
+    var i = 0
+    return {
+      next(v) {
+        var res
+
+        if (i == 0) {
+          assert(v === undefined)
+          res = { value:"Res", done:false }
+        } else if (i == 1) {
+          assert(v === "B")
+          res = { value:{}, done:false }
+        } else if (i == 2) {
+          assert(v === o1)
+          res = Promise.resolve("Nested")
+          res = { value:res, done:false }
+        } else {
+          assert(v === -1.5)
+          res = { value:3.5, done:true }
+        }
+        i++
+
+        arr1.push(res)
+        return Promise.resolve(res)
+      }
+    }
+  }
+}
+
+async function *f1() {
+  successCount++
+  assert((yield *async1) === 3.5)
+  successCount++
+  return "End"
+}
+
+async function f1_run() {
+  var gen = f1()
+
+  var res = await gen.next("A")
+  assert(res != arr1[0])
+  assert(res.value === "Res")
+  assert(arr1[0].value === "Res")
+  assert(res.done === false)
+  assert(arr1[0].done === false)
+  successCount++
+
+  var res = await gen.next("B")
+  assert(res != arr1[1])
+  assert(res.value === arr1[1].value)
+  assert(res.done === false)
+  assert(arr1[1].done === false)
+  successCount++
+
+  var res = await gen.next(o1)
+  assert(res != arr1[2])
+  assert(res.value === "Nested")
+  assert(arr1[2].value instanceof Promise)
+  assert(res.done === false)
+  assert(arr1[2].done === false)
+  successCount++
+
+  var res = await gen.next(-1.5)
+  assert(res.value === "End")
+  assert(res.done === true)
+  successCount++
+}
+
+f1_run()
+
+// Test 2
+
+var o2 = {}
+var async2 = {
+  [Symbol.asyncIterator]() {
+    return {
+      next() {
+        throw "Except"
+      }
+    }
+  }
+}
+
+async function *f2() {
+  successCount++
+  try {
+    try {
+      yield *async2
+      assert(false)
+    } finally {
+      successCount++
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Except")
+    successCount++
+    throw o2
+  }
+  assert(false)
+}
+
+var gen = f2()
+check_rejected(gen.next(), o2)
+
+// Test 3
+
+var o3 = {}
+var async3 = {
+  [Symbol.asyncIterator]() {
+    var i = 0
+    return {
+      next() {
+        if (i == 0) {
+          i++
+          return { value:6.25, done:false }
+        }
+        throw o3
+      }
+    }
+  }
+}
+
+async function *f3() {
+  successCount++
+  try {
+    try {
+      yield *async3
+      assert(false)
+    } finally {
+      successCount++
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === o3)
+    successCount++
+    return o3
+  }
+  assert(false)
+}
+
+var gen = f3()
+check_fulfilled(gen.next(), 6.25, false)
+check_fulfilled(gen.next(), o3, true)
+
+// Test 4
+
+var async4 = {
+  [Symbol.asyncIterator]() {
+    return {
+      next() {
+        /* Returns with a promise which fails. */
+        return { value:Promise.reject("Failed!"), done:false }
+      }
+    }
+  }
+}
+
+async function *f4() {
+  successCount++
+  try {
+    try {
+      yield *async4
+      assert(false)
+    } finally {
+      successCount++
+    }
+    assert(false)
+  } catch (e) {
+    assert(e === "Failed!")
+    successCount++
+    return
+  }
+  assert(false)
+}
+
+var gen = f4()
+check_fulfilled(gen.next(), undefined, true)
+
+// Test 5
+
+var async5 = {
+  [Symbol.asyncIterator]() {
+    return {
+      next() {
+        /* Returns with a promise which fails. */
+        return { value:Promise.reject("FailedAndDone!"), done:true }
+      }
+    }
+  }
+}
+
+async function *f5() {
+  successCount++
+  try {
+    var p = yield *async5
+    assert(p instanceof Promise)
+    check_rejected(p, "FailedAndDone!")
+    successCount++
+  } catch (e) {
+    assert(false)
+  }
+}
+
+var gen = f5()
+check_fulfilled(gen.next(), undefined, true)
+
+// Test 6
+
+var state = 0
+
+var o6 = {}
+var async6 = {
+  [Symbol.asyncIterator]() {
+    var i = 0
+    assert(++state === 2)
+
+    return {
+      next() {
+        i++
+        if (i == 1) {
+          assert(++state === 3)
+          return { value:5.75, done:false }
+        } else if (i == 2) {
+          assert(++state === 7)
+          return { value:o6, done:false }
+        } else if (i == 3) {
+          assert(++state === 8)
+          return { value:"Val", done:true }
+        }
+      }
+    }
+  }
+}
+
+async function *f6() {
+  assert(++state === 1)
+
+  assert((yield *async6) === "Val")
+
+  assert(++state === 9)
+  return "End"
+}
+
+var gen = f6()
+check_fulfilled(gen.next(), 5.75, false)
+assert(++state === 4)
+check_fulfilled(gen.next(), o6, false)
+assert(++state === 5)
+check_fulfilled(gen.next(), "End", true)
+assert(++state === 6)
+
+// END
+
+function __checkAsync() {
+  assert(successCount === 26)
+  assert(state === 9)
+}