!2455 [ArkTS CTS] Update tests in 17.16.1 Create and Launch a Coroutine

Merge pull request !2455 from fotograf/cts-17685

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func.params.yaml

@@ -18,7 +18,7 @@ cases:
       use: |-
           // Promise of void
           let r: Promise<void> = launch foo()
-          assert (await r) == undefined
+          assert((await r) == undefined)
 
     - decl: |-
           function foo(p: int): int {
@@ -26,8 +26,9 @@ cases:
           }
       use: |-
           // Promise of primitive
-          let r: Promise<int> = launch foo(42)
-          assert (await r) == 84
+          let bar: (p: int) => int = foo
+          let r = launch bar(42)
+          assert((await r) == 84)
 
     - decl: |-
           function foo(p: Double): Double {
@@ -36,7 +37,7 @@ cases:
       use: |-
           // Promise of boxed
           let r: Promise<Double> = launch foo(new Double(42.0))
-          assert (await r) == 84.0
+          assert((await r) == 84.0)
 
     - decl: |-
           function foo(p: int): string {
@@ -44,8 +45,8 @@ cases:
           }
       use: |-
           // Promise of string
-          let r: Promise<string> = launch foo(42)
-          assert (await r) == '42'
+          let r = launch foo(42)
+          assert((await r) == '42')
 
     - decl: |-
           function foo(p: int): String {
@@ -54,7 +55,7 @@ cases:
       use: |-
           // Promise of String
           let r: Promise<String> = launch foo(42)
-          assert (await r) instanceof String
+          assert((await r) instanceof String)
 
     - decl: |-
           class A {}
@@ -65,7 +66,7 @@ cases:
       use: |-
           // Promise of Object
           let r: Promise<Object> = launch foo(new A())
-          assert (await r) instanceof A
+          assert((await r) instanceof A)
 
     - decl: |-
           function foo(p: Number|undefined): Number|undefined {
@@ -74,7 +75,7 @@ cases:
       use: |-
           // Promise of nullish
           let r: Promise<Number|undefined> = launch foo(42)
-          assert (await r) == 43
+          assert((await r) == 43)
 
     - decl: |-
           function foo(p: Number|null): Number|null {
@@ -83,7 +84,7 @@ cases:
       use: |-
           // Promise of nullish
           let r: Promise<Number|null> = launch foo(42)
-          assert (await r) == 43
+          assert((await r) == 43)
 
     - decl: |-
           function foo(p: Int|null|undefined): Int|null|undefined {
@@ -92,7 +93,7 @@ cases:
       use: |-
           // Promise of nullish
           let r: Promise<Int|undefined|null> = launch foo(42)
-          assert (await r) == 43
+          assert((await r) == 43)
 
     - decl: |-
           function foo(p: string): string {
@@ -100,13 +101,13 @@ cases:
           }
 
           function bar(p: string): Promise<string> {
-              return launch foo('A')
+              return launch foo(p)
           }
 
       use: |-
           // Promise of promise
           let r: Promise<Promise<String>> = launch bar('A')
-          assert (await (await r)) == 'AA'
+          assert((await r) == 'AA')
 
     - decl: |-
           function foo(): int[] {
@@ -116,7 +117,7 @@ cases:
           // Promise of array
           let r: Promise<int[]> = launch foo()
           let q: int[] = await r
-          assert q[0] == 1 && q[1] == 2 && q[2] == 3
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
 
     - decl: |-
           function foo(): (p: string) => string {
@@ -125,7 +126,7 @@ cases:
       use: |-
           // Promise of function
           let r: Promise<(p: string) => string> = launch foo()
-          assert (await r)('A') == 'AA'
+          assert((await r)('A') == 'AA')
 
     - decl: |-
           type UT = number | string | boolean
@@ -136,7 +137,7 @@ cases:
           // Promise of union
           let r: Promise<number|boolean|string> = launch foo(-1)
           let q: boolean|number|string = await r
-          assert q as string == '-1'
+          assert(q as string == '-1')
 
     - decl: |-
           function foo(p: int): [boolean, Error] {
@@ -144,9 +145,9 @@ cases:
           }
       use: |-
           // Promise of tuple
-          let r: Promise<[boolean, Error]> = launch foo(42)
+          let r = launch foo(42)
           let q: [boolean, Error] = await r
-          assert q[0] && (q[1] instanceof Error)
+          assert(q[0] && (q[1] instanceof Error))
 
     - decl: |-
           function foo(p: string): BigInt {
@@ -156,7 +157,7 @@ cases:
           // Promise of BigInt
           let r: Promise<BigInt> = launch foo('123456789012345678901234567890')
           let q: BigInt = await r
-          assert q == 123456789012345678901234567890n
+          assert(q == 123456789012345678901234567890n)
 
     - decl: |-
           function foo(p: bigint): bigint {
@@ -164,9 +165,9 @@ cases:
           }
       use: |-
           // Promise of bigint
-          let r: Promise<bigint> = launch foo(123456789012345678901234567890n)
+          let r = launch foo(123456789012345678901234567890n)
           let q: bigint = await r
-          assert q == 123456789012345678901234567890n
+          assert(q == 123456789012345678901234567890n)
 
     - use: |-
           // array of promises
@@ -184,7 +185,7 @@ cases:
           ]
           let cnt = 0
           for (let v of arr) cnt += (await v)
-          assert cnt == 90
+          assert(cnt == 90)
 
     - decl: |-
           let fs: ((p: int) => int)[]
@@ -216,7 +217,7 @@ cases:
           for (let i = 9; i >= 0; i--) {
               cnt += (await ps[i] as Promise<(p: int) => int>)(i)
           }
-          assert cnt == 90
+          assert(cnt == 90)
 
     - decl: |-
           let fs: ((p: int) => int)[]
@@ -246,7 +247,7 @@ cases:
           for (let i = 9; i >= 0; i--) {
               cnt += (await ps[i] as Promise<int>)
           }
-          assert cnt == 90
+          assert(cnt == 90)
 
     - decl: |-
           enum Color { Red, Green, Blue }
@@ -256,8 +257,8 @@ cases:
           }
       use: |-
           // Promise of enum
-          let r: Promise<Color> = launch foo(42)
-          assert (await r) == Color.Green
+          let r = launch foo(42)
+          assert((await r) == Color.Green)
 
     - decl: |-
           enum Color { R="red", G="green", B="blue" }
@@ -268,7 +269,7 @@ cases:
       use: |-
           // Promise of string-based enum
           let r: Promise<Color> = launch foo(-42)
-          assert (await r) == Color.B
+          assert((await r) == Color.B)
 
     - decl: |-
           function foo<T>(p: T): T {
@@ -287,4 +288,36 @@ cases:
       use: |-
           // Promise of T
           let a: A<string> = new A<string>("abc")
-          assert a.meth() == "abc"
+          assert(a.meth() == "abc")
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+          }
+          function foo(p: number): string {
+              return '' + p
+          }
+      use: |-
+          // Launch in object literal
+          let a: A = { fld: launch foo(42.0) }
+          assert((await a.fld!) == '42')
+
+    - decl: |-
+          let s = 'ABC'
+          function foo(p: () => Promise<string>): string {
+              return await p()
+          }
+      use: |-
+          // Launch in argument lambda
+          let r = foo((): Promise<string> => launch ((): string => s)())
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          function foo(p: () => Promise<string>): string {
+              return await p()
+          }
+      use: |-
+          // Launch in trailing lambda
+          let r = foo() { launch ((): string => s)() }
+          assert(r == 'ABC')

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb.params.yaml

@@ -0,0 +1,171 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# 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.
+
+---
+cases:
+    - use: |-
+          // Promise of void
+          let r: Promise<void> = launch (() => {})()
+          assert((await r) == undefined)
+
+    - use: |-
+          // Promise of primitive
+          let bar = (p: int): int => p + p
+          let r = launch bar(42)
+          assert((await r) == 84)
+
+    - use: |-
+          // Promise of boxed
+          let r: Promise<Double> = launch ((p: Double): Double => p + p)(new Double(42.0))
+          assert((await r) == 84.0)
+
+    - use: |-
+          // Promise of string
+          let r: Promise<string> = launch ((p: int): string => `${p}`)(42)
+          assert((await r) == '42')
+
+    - use: |-
+          // Promise of String
+          let r = launch ((p: int): String => new String(`${p}`))(42)
+          assert((await r) instanceof String)
+
+    - decl: |-
+          class A {}
+      use: |-
+          // Promise of Object
+          let r: Promise<Object> = launch ((p: Object): Object => p)(new A())
+          assert((await r) instanceof A)
+
+    - use: |-
+          // Promise of nullish
+          let r: Promise<Number|undefined> = launch ((p: Number|undefined): Number|undefined => p instanceof Number ? p + 1 : p)(42)
+          assert((await r) == 43)
+
+    - use: |-
+          // Promise of nullish
+          let r: Promise<Number|null> = launch ((p: Number|null): Number|null => p instanceof Number ? p + 1 : p)(42)
+          assert((await r) == 43)
+
+    - use: |-
+          // Promise of nullish
+          let r = launch ((p: Int|null|undefined): Int|null|undefined => p == null || p == undefined ? p : p + 1)(42)
+          assert((await r) == 43)
+
+    - use: |-
+          // Promise of promise
+          let r: Promise<Promise<String>> = launch ((p: string): Promise<string> => launch ((q: string): string => q + q)(p))('A')
+          assert((await r) == 'AA')
+
+    - use: |-
+          // Promise of array
+          let r: Promise<int[]> = launch ((): int[] => [1, 2, 3])()
+          let q: int[] = await r
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
+
+    - decl: |-
+          type FUNC = (p: string) => string
+      use: |-
+          // Promise of function
+          let r: Promise<FUNC> = launch ((): FUNC => {
+                  return (p: string): string => p + p
+              })()
+          assert((await r)('A') == 'AA')
+
+    - decl: |-
+          type UT = number | string | boolean
+      use: |-
+          // Promise of union
+          let r: Promise<number|boolean|string> = launch ((p: int): UT => p == 0 ? true : p > 0 ? new Number(p) : `${p}`)(-1)
+          let q: boolean|number|string = await r
+          assert(q as string == '-1')
+
+    - use: |-
+          // Promise of tuple
+          let r: Promise<[boolean, Error]> = launch ((p: int): [boolean, Error] => [p > 0, new Error()])(42)
+          let q: [boolean, Error] = await r
+          assert(q[0] && (q[1] instanceof Error))
+
+    - use: |-
+          // Promise of BigInt
+          let r = launch ((p: string): BigInt => new BigInt(p))('123456789012345678901234567890')
+          let q: BigInt = await r
+          assert(q == 123456789012345678901234567890n)
+
+    - use: |-
+          // Promise of bigint
+          let r: Promise<bigint> = launch ((p: bigint): bigint => { return p })(123456789012345678901234567890n)
+          let q: bigint = await r
+          assert(q == 123456789012345678901234567890n)
+
+    - use: |-
+          // array of promises
+          let arr: Object[] = [
+              (p: int): int => p + 1,
+              (p: int): int => p + 2,
+              (p: int): int => p + 3,
+              (p: int): int => p + 4,
+              (p: int): int => p + 5,
+              (p: int): int => p + 6,
+              (p: int): int => p + 7,
+              (p: int): int => p + 8,
+              (p: int): int => p + 9,
+              (p: int): int => p + 0,
+          ]
+          for (let i = 0; i < arr.length; i++) {
+              arr[i] = launch (arr[i] as (p: int) => int)(i)
+          }
+          let cnt = 0
+          for (let i = 0; i < arr.length; i++) {
+              cnt += await arr[i] as Promise<int>
+          }
+          assert(cnt == 90)
+
+    - decl: |-
+          enum Color { Red, Green, Blue }
+      use: |-
+          // Promise of enum
+          let r = launch ((p: int): Color => p > 0 ? Color.Green : Color.Blue)(42)
+          assert((await r) == Color.Green)
+
+    - decl: |-
+          enum Color { R="red", G="green", B="blue" }
+      use: |-
+          // Promise of string-based enum
+          let r: Promise<Color> = launch ((p: int): Color => p > 0 ? Color.G : Color.B)(-42)
+          assert((await r) == Color.B)
+
+    - decl: |-
+          class A<T> {
+              f: (p: T) => T
+              p: Promise<T>
+              constructor(arg1: (p: T) => T, arg2: T) {
+                  this.f = arg1
+                  this.p = launch this.f(arg2)
+              }
+              meth(): T {
+                  return await this.p
+              }
+          }
+      use: |-
+          // Promise of T
+          let a: A<string> = new A<string>((p: string): string => p + p, "X")
+          assert(a.meth() == "XX")
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+          }
+      use: |-
+          // Launch in object literal
+          let a: A = { fld: launch ((p: number): string => '' + p)(42.0) }
+          assert((await a.fld!) == '42')

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb.sts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+{% for c in cases %}
+/*---
+desc: The class Promise<T> represents the values returned by launch expressions.
+---*/
+
+{{c.decl}}
+
+function main() {
+    {{c.use|indent}}
+}
+{% endfor %}

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth.params.yaml

@@ -0,0 +1,336 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# 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.
+
+---
+cases:
+    - decl: |-
+          class A {
+              fld: int
+              foo() { this.fld = 1 }
+          }
+      use: |-
+          // Promise of void
+          let r: Promise<void> = launch new A().foo()
+          assert((await r) == undefined)
+
+    - decl: |-
+          interface I {
+              foo(p: int): int;
+          }
+          class A implements I {
+              foo(p: int): int {
+                  return p + p
+              }
+          }
+      use: |-
+          // Promise of primitive
+          let i: I = new A()
+          let r = launch i.foo(42)
+          assert((await r) == 84)
+
+    - decl: |-
+          interface I {
+              foo(p: Double): Double {
+                  return p + p
+              }
+          }
+          class A implements I {}
+      use: |-
+          // Promise of boxed
+          let r: Promise<Double> = launch new A().foo(new Double(42.0))
+          assert((await r) == 84.0)
+
+    - decl: |-
+          class A {
+              foo(p: int): string {
+                  return `${p}`
+              }
+          }
+      use: |-
+          // Promise of string
+          let r: Promise<string> = launch new A().foo(42)
+          assert((await r) == '42')
+
+    - decl: |-
+          class A {
+              foo(p: int): String {
+                  return new String(`${p}`)
+              }
+          }
+      use: |-
+          // Promise of String
+          let r: Promise<String> = launch new A().foo(42)
+          assert((await r) instanceof String)
+
+    - decl: |-
+          class A {}
+          class B {
+              foo(p: Object): Object {
+                  return p
+              }
+          }
+      use: |-
+          // Promise of Object
+          let r: Promise<Object> = launch new B().foo(new A())
+          assert((await r) instanceof A)
+
+    - decl: |-
+          class A {
+              foo(p: Number|undefined): Number|undefined {
+                  return p instanceof Number ? p + 1 : p
+              }
+          }
+      use: |-
+          // Promise of nullish
+          let r: Promise<Number|undefined> = launch new A().foo(42)
+          assert((await r) == 43)
+
+    - decl: |-
+          class A {
+              foo(p: Number|null): Number|null {
+                  return p instanceof Number ? p + 1 : p
+              }
+          }
+      use: |-
+          // Promise of nullish
+          let r = launch new A().foo(42)
+          assert((await r) == 43)
+
+    - decl: |-
+          class A {
+              foo(p: Int|null|undefined): Int|null|undefined {
+                  return p == null || p == undefined ? p : p + 1
+              }
+          }
+      use: |-
+          // Promise of nullish
+          let r: Promise<Int|undefined|null> = launch new A().foo(42)
+          assert((await r) == 43)
+
+    - decl: |-
+          class A {
+              foo(p: string): string {
+                  return p + p
+              }
+              bar(p: string): Promise<string> {
+                  return launch this.foo(p)
+              }
+          }
+      use: |-
+          // Promise of promise
+          let r: Promise<Promise<String>> = launch new A().bar('A');
+          assert((await r) == 'AA')
+
+    - decl: |-
+          class A {
+              foo(): int[] {
+                  return [1, 2, 3]
+              }
+          }
+      use: |-
+          // Promise of array
+          let r: Promise<int[]> = launch new A().foo()
+          let q: int[] = await r
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
+
+    - decl: |-
+          class A {
+              foo(): (p: string) => string {
+                  return (p: string): string => { return p + p }
+              }
+          }
+      use: |-
+          // Promise of function
+          let r: Promise<(p: string) => string> = launch new A().foo()
+          assert((await r)('A') == 'AA')
+
+    - decl: |-
+          type UT = number | string | boolean
+          class A {
+              foo(p: int): UT {
+                  return p == 0 ? true : p > 0 ? new Number(p) : `${p}`
+              }
+          }
+      use: |-
+          // Promise of union
+          let r = launch new A().foo(-1);
+          let q: boolean|number|string = await r
+          assert(q as string == '-1')
+
+    - decl: |-
+          class A {
+              foo(p: int): [boolean, Error] {
+                  return [p > 0, new Error()]
+              }
+          }
+      use: |-
+          // Promise of tuple
+          let r: Promise<[boolean, Error]> = launch new A().foo(42);
+          let q: [boolean, Error] = await r
+          assert(q[0] && (q[1] instanceof Error))
+
+    - decl: |-
+          class A {
+              foo(p: string): BigInt {
+                  return new BigInt(p)
+              }
+          }
+      use: |-
+          // Promise of BigInt
+          let r: Promise<BigInt> = launch new A().foo('123456789012345678901234567890')
+          let q: BigInt = await r
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          class A {
+              foo(p: bigint): bigint {
+                  return p
+              }
+          }
+      use: |-
+          // Promise of bigint
+          let r = launch new A().foo(123456789012345678901234567890n)
+          let q: bigint = await r
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          class A {
+              fld: int
+              constructor(p: int) {
+                  this.fld = p
+              }
+              foo(p: int): int {
+                  return this.fld + p
+              }
+          }
+      use: |-
+          // array of promises
+          let arr: Promise<int>[] = [
+              launch new A(1).foo(1),
+              launch new A(2).foo(2),
+              launch new A(3).foo(3),
+              launch new A(4).foo(4),
+              launch new A(5).foo(5),
+              launch new A(6).foo(6),
+              launch new A(7).foo(7),
+              launch new A(8).foo(8),
+              launch new A(9).foo(9),
+              launch new A(0).foo(0),
+          ]
+          let cnt = 0
+          for (let v of arr) cnt += (await v)
+          assert(cnt == 90)
+
+    - decl: |-
+          class A {
+              fld: int
+              constructor(p: int) {
+                  this.fld = p
+              }
+              foo(p: int): int {
+                  return this.fld + p
+              }
+          }
+      use: |-
+          let arr: Object[] = new Object[10]
+          for (let i = 0; i < 10; i++) {
+              arr[i] = new A(i)
+          }
+          for (let i = 0; i < 10; i++) {
+              arr[i] = launch (arr[i] as A).foo(i)
+          }
+          let cnt = 0
+          for (let i = 9; i >= 0; i--) {
+              cnt += (await arr[i] as Promise<int>)
+          }
+          assert(cnt == 90)
+
+    - decl: |-
+          enum Color { Red, Green, Blue }
+          class A {
+              foo(p: int): Color {
+                  return p > 0 ? Color.Green : Color.Blue
+              }
+          }
+      use: |-
+          // Promise of enum
+          let r = launch new A().foo(42)
+          assert((await r) == Color.Green)
+
+    - decl: |-
+          enum Color { R = "red", G = "green", B = "blue" }
+          class A {
+              foo(p: int): Color {
+                  return p > 0 ? Color.G : Color.B
+              }
+          }
+      use: |-
+          // Promise of string-based enum
+          let r: Promise<Color> = launch new A().foo(-42)
+          assert((await r) == Color.B)
+
+    - decl: |-
+          class B<U> {
+              foo<U>(p: U): U {
+                  return p
+              }
+          }
+          class A<T> {
+              fld: Promise<T>
+              constructor(p: T) {
+                  this.fld = launch new B<T>().foo<T>(p)
+              }
+              meth(): T {
+                  return await this.fld
+              }
+          }
+      use: |-
+          // Promise of T
+          let a: A<string> = new A<string>("abc")
+          assert(a.meth() == "abc")
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+              static foo(p: number): string {
+                  return '' + p
+              }
+          }
+      use: |-
+          // Launch in object literal
+          let a: A = { fld: launch A.foo(42.0) }
+          assert((await a.fld!) == '42')
+
+    - decl: |-
+          let s = 'ABC'
+          class A {
+              foo(p: () => Promise<string>): string {
+                  return await p()
+              }
+          }
+      use: |-
+          // Launch in argument lambda
+          let r = new A().foo((): Promise<string> => launch ((): string => s)())
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          class A {
+              foo(p: () => Promise<string>): string {
+                  return await p()
+              }
+          }
+      use: |-
+          // Launch in trailing lambda
+          let r = new A().foo() { launch ((): string => s)() }
+          assert(r == 'ABC')

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth.sts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+{% for c in cases %}
+/*---
+desc: The class Promise<T> represents the values returned by launch expressions.
+---*/
+
+{{c.decl}}
+
+function main() {
+    {{c.use|indent}}
+}
+{% endfor %}

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_n.params.yaml

@@ -42,37 +42,3 @@ cases:
           }
       use: |-
           let r = launch new A('abc')  // call a constructor
-
-    - decl: |-
-          class A {
-              fld: string
-              constructor(p: string) {
-                  this.fld = p
-              }
-              meth(): string {
-                  return this.fld
-              }
-          }
-      use: |-
-          let a: A = new A('abc')
-          let r = launch a.meth()  // call a method
-
-    - decl: |-
-          class A {
-              static meth(p: string): string {
-                  return p + p
-              }
-          }
-      use: |-
-          let r = launch A.meth('abc')  // call static method
-
-    - decl: |-
-          interface I {
-              meth(p: string): string {
-                  return p + p
-              }
-          }
-          class A implements I {}
-      use: |-
-          let a: A = new A()
-          let r = launch a.meth('abc')  // call default interface method

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/02.awaiting_coroutine/a.params.yaml

@@ -22,7 +22,7 @@ cases:
               return p + 1
           }
       use: |-
-          assert foo(launch bar(1)) == 2
+          assert(foo(launch bar(1)) == 2)
 
     - decl: |-
           // Error in launch function propagates outside
@@ -38,11 +38,11 @@ cases:
       use: |-
           try {
               foo(launch bar(1))
-              assert false
+              assert(false)
           } catch (e: Error) {
-              assert e.message == 'ABC'  // expected
+              assert(e.message == 'ABC')  // expected
           } catch (e) {
-              assert false
+              assert(false)
           }
 
     - decl: |-
@@ -59,11 +59,11 @@ cases:
       use: |-
           try {
               foo(launch bar(1), 1)
-              assert false
+              assert(false)
           } catch (e: Error) {
-              assert e.message == 'ABC'  // expected
+              assert(e.message == 'ABC')  // expected
           } catch (e) {
-              assert false
+              assert(false)
           }
 
     - decl: |-
@@ -80,11 +80,11 @@ cases:
       use: |-
           try {
               foo(launch bar(1))
-              assert false
+              assert(false)
           } catch (e: Exception) {
-              assert e.message == 'ABC'  // expected
+              assert(e.message == 'ABC')  // expected
           } catch (e) {
-              assert false
+              assert(false)
           }
 
     - decl: |-
@@ -101,11 +101,11 @@ cases:
       use: |-
           try {
               foo(1, launch bar(1))
-              assert false
+              assert(false)
           } catch (e: Exception) {
-              assert e.message == 'ABC'  // expected
+              assert(e.message == 'ABC')  // expected
           } catch (e) {
-              assert false
+              assert(false)
           }
 
     - decl: |-
@@ -125,11 +125,11 @@ cases:
       use: |-
           try {
               baz(launch bar(1), foo)
-              assert false
+              assert(false)
           } catch (e: Exception) {
-              assert e.message == 'ABC'  // expected
+              assert(e.message == 'ABC')  // expected
           } catch (e) {
-              assert false
+              assert(false)
           }
 
     - decl: |-
@@ -154,7 +154,7 @@ cases:
           let res = ''
           arr = [launch foo(1), launch foo(2), launch foo(3)]
           for (let v of arr) res += bar(v)
-          assert res == '1X3'
+          assert(res == '1X3')
 
     - decl: |-
           // Exception in one promise should not affect other running promises
@@ -181,9 +181,9 @@ cases:
               let res = ''
               arr = [launch foo(1), launch foo(2), launch foo(3)]
               for (let v of arr) res += bar(v)
-              assert res == '1X3'
+              assert(res == '1X3')
           } catch (e) {
-              assert false
+              assert(false)
           }
 
     - decl: |-
@@ -208,42 +208,42 @@ cases:
       use: |-
           // array element
           let arr: Promise<string>[] = [launch foo('A')]
-          assert (await arr[0]) == 'AA'
+          assert((await arr[0]) == 'AA')
 
           // tuple element
           let tup: [boolean, Promise<string>] = [false, launch foo('A')]
-          assert (await tup[1]) == 'AA'
+          assert((await tup[1]) == 'AA')
 
           // union type
           let ut: boolean|number|Promise<string> = launch foo('A')
-          assert (await (ut as Promise<string>)) == 'AA'
+          assert((await (ut as Promise<string>)) == 'AA')
 
           // nullish type
           let nt: Promise<string>|null|undefined = p1()
-          assert (await nt!) == 'AA'
+          assert((await nt!) == 'AA')
 
           nt = p2()
           try {
               await nt!
-              assert false
+              assert(false)
           } catch (e) {
               // OK
           }
 
           // function call
           let f: (p: Promise<string>) => Promise<string> = (p: Promise<string>): Promise<string> => p
-          assert (await f(launch foo('A'))) == 'AA'
+          assert((await f(launch foo('A'))) == 'AA')
 
           // instance field
           let a: A = { fld: launch foo('A') }
-          assert (await a.fld) == 'AA'
+          assert((await a.fld) == 'AA')
 
           // method call
           let b: A = new A(launch foo('A'))
-          assert (await b.meth()) == 'AA'
+          assert((await b.meth()) == 'AA')
 
           // conditional expression
           let expr1 = launch foo('A')
           let expr2 = launch foo('B')
-          assert (await a instanceof A ? expr1 : expr2) == 'AA'
-          assert (await ! (a instanceof A) ? expr1 : expr2) == 'BB'
+          assert((await a instanceof A ? expr1 : expr2) == 'AA')
+          assert((await ! (a instanceof A) ? expr1 : expr2) == 'BB')

static_core/plugins/ets/tests/ets-templates/17.experimental_features/16.coroutines/03.promise_class/p.params.yaml

@@ -27,7 +27,7 @@ cases:
                   }
               }
           )
-          assert (await r) == 'XYZ'
+          assert((await r) == 'XYZ')
 
     - decl: |-
           type ON = Object|null
@@ -47,10 +47,10 @@ cases:
           try {
               await r
           } catch (e: Error) {
-              assert e.message == 'ABC'
+              assert(e.message == 'ABC')
               return
           }
-          assert false
+          assert(false)
 
     - decl: |-
           type ON = Object|null
@@ -70,17 +70,17 @@ cases:
           try {
               await r
           } catch (e: Error) {
-              assert e.message == 'XYZ'
+              assert(e.message == 'XYZ')
               return
           }
-          assert false
+          assert(false)
 
     - decl: |-
           type ON = Object|null
           let initVal: number = 1.0
       use: |-
           // test then chain, resolved
-          let r: Promise<number> = new Promise<number>(
+          let r = new Promise<number>(
               (resolve: (p: number) => void, reject: (p: ON) => void): void => {
                   if (initVal > 0) {
                       resolve(initVal)
@@ -97,14 +97,14 @@ cases:
                   return p + 100.0
               }
           )
-          assert (await r) == 111.0
+          assert((await r) == 111.0)
 
     - decl: |-
           type ON = Object|null
           let initVal: number = 1.0
       use: |-
           // test catch chain
-          let r: Promise<string> = new Promise<number>(
+          let r: Promise<string|number> = new Promise<number>(
               (resolve: (p: number) => void, reject: (p: ON) => void): void => {
                   if (initVal < 0) {
                       resolve(initVal)
@@ -133,10 +133,10 @@ cases:
           try {
               await r
           } catch (e: Error) {
-              assert e.message == 'ABC'
+              assert(e.message == 'ABC')
               return
           }
-          assert false
+          assert(false)
 
     - decl: |-
           type ON = Object|null
@@ -196,7 +196,7 @@ cases:
           try {
               await r
           } catch (e: Error) {
-              assert e.message == 'AEFJ'
+              assert(e.message == 'AEFJ')
               return
           }
-          assert false
+          assert(false)

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc.params.yaml

@@ -0,0 +1,550 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# 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.
+
+---
+cases:
+    - decl: |-
+          async function foo(): Promise<void> {}
+      use: |-
+          // Promise of void
+          let r = foo()
+          assert((await r) == undefined)
+
+    - decl: |-
+          async function foo(p: int): Promise<Int> {
+              return p + p
+          }
+      use: |-
+          // Promise of primitive
+          assert((await foo(42)) == 84)
+
+    - decl: |-
+          async function foo(p: int): Promise<Int> {
+              return launch ((x:int): int => x + x)(p)
+          }
+      use: |-
+          // Promise of primitive
+          assert((await foo(42)) == 84)
+
+    - decl: |-
+          async function foo(p: Double): Promise<Double> {
+              return p + p
+          }
+      use: |-
+          // Promise of boxed
+          assert((await foo(new Double(42.0))) == 84.0)
+
+    - decl: |-
+          async function foo(p: Double): Promise<Double> {
+              return launch ((x: Double): Double => x + x)(p)
+          }
+      use: |-
+          // Promise of boxed
+          assert((await foo(new Double(42.0))) == 84.0)
+
+    - decl: |-
+          async function foo(p: int): Promise<string> {
+              return `${p}`
+          }
+      use: |-
+          // Promise of string
+          let r = foo(42)
+          assert((await r) == '42')
+
+    - decl: |-
+          async function foo(p: int): Promise<string> {
+              return launch ((x: string): string => x + x)(`${p}`)
+          }
+      use: |-
+          // Promise of string
+          let r = foo(42)
+          assert((await r) == '4242')
+
+    - decl: |-
+          async function foo(p: int): Promise<String> {
+              return new String(`${p}`)
+          }
+      use: |-
+          // Promise of String
+          assert((await foo(42)) instanceof String)
+
+    - decl: |-
+          async function foo(p: int): Promise<String> {
+              return launch ((x: int): String => new String(`${x}`))(p)
+          }
+      use: |-
+          // Promise of String
+          assert((await foo(42)) instanceof String)
+
+    - decl: |-
+          class A {}
+
+          async function foo(p: Object): Promise<Object> {
+              return p
+          }
+      use: |-
+          // Promise of Object
+          assert((await foo(new A())) instanceof A)
+
+    - decl: |-
+          class A {}
+
+          async function foo(p: Object): Promise<Object> {
+              return launch ((x: Object): Object => x)(p)
+          }
+      use: |-
+          // Promise of Object
+          assert((await foo(new A())) instanceof A)
+
+    - decl: |-
+          async function foo(p: Number|undefined): Promise<Number|undefined> {
+              return p instanceof Number ? p + 1 : p
+          }
+      use: |-
+          // Promise of nullish
+          assert((await foo(42)) == 43)
+
+    - decl: |-
+          async function foo(p: Number|undefined): Promise<Number|undefined> {
+              return launch ((x: Number|undefined): Number|undefined => x instanceof Number ? x + 1 : x)(p)
+          }
+      use: |-
+          // Promise of nullish
+          assert((await foo(42)) == 43)
+
+    - decl: |-
+          async function foo(p: Number|null): Promise<Number|null> {
+              return p instanceof Number ? p + 1 : p
+          }
+      use: |-
+          // Promise of nullish
+          assert((await foo(42)) == 43)
+
+    - decl: |-
+          async function foo(p: Number|null): Promise<Number|null> {
+              return launch ((x: Number|null): Number|null => x instanceof Number ? x + 1 : x)(p)
+          }
+      use: |-
+          // Promise of nullish
+          assert((await foo(42)) == 43)
+
+    - decl: |-
+          async function foo(p: Int|null|undefined): Promise<Int|null|undefined> {
+              return p == null || p == undefined ? p : p + 1
+          }
+      use: |-
+          // Promise of nullish
+          assert((await foo(42)) == 43)
+
+    - decl: |-
+          async function foo(p: Int|null|undefined): Promise<Int|null|undefined> {
+              let q = (p: Int|null|undefined): Int|null|undefined => {
+                  return p == null || p == undefined ? p : p + 1
+              }
+              return launch q(p)
+          }
+      use: |-
+          // Promise of nullish
+          assert((await foo(42)) == 43)
+
+    - decl: |-
+          async function foo(p: string): Promise<string> {
+              return p + p
+          }
+
+          async function bar(p: string): Promise<Promise<string>> {
+              return foo(p)
+          }
+      use: |-
+          // Promise of promise
+          assert((await bar('A')) == 'AA')
+
+    - decl: |-
+          async function foo(p: string): Promise<string> {
+              return launch ((x: string): string => x + x)(p)
+          }
+
+          async function bar(p: string): Promise<Promise<string>> {
+              return launch ((x: string): Promise<string> => foo(x))(p)
+          }
+      use: |-
+          // Promise of promise
+          assert((await bar('A')) == 'AA')
+
+    - decl: |-
+          async function foo(): Promise<int[]> {
+              return [1, 2, 3] as int[]
+          }
+      use: |-
+          // Promise of array
+          let q: int[] = await foo()
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
+
+    - decl: |-
+          async function foo(): Promise<int[]> {
+              return launch ((): int[] => [1, 2, 3])()
+          }
+      use: |-
+          // Promise of array
+          let q: int[] = await foo()
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
+
+    - decl: |-
+          async function foo(): Promise<(p: string) => string> {
+              return (p: string): string => { return p + p }
+          }
+      use: |-
+          // Promise of function
+          assert((await foo())('A') == 'AA')
+
+    - decl: |-
+          type FT = (p: string) => string
+          async function foo(): Promise<FT> {
+              let f = (p: string): string => p + p
+              return launch ((): FT => f)()
+          }
+      use: |-
+          // Promise of function
+          assert((await foo())('A') == 'AA')
+
+    - decl: |-
+          type UT = number | string | boolean
+          async function foo(p: int): Promise<UT> {
+              return p == 0 ? true : p > 0 ? new Number(p) : `${p}`
+          }
+      use: |-
+          // Promise of union
+          let q: boolean|number|string = await foo(-1)
+          assert(q as string == '-1')
+
+    - decl: |-
+          type UT = number | string | boolean
+          async function foo(p: int): Promise<UT> {
+              let f = (x: int): UT => x == 0 ? true : x > 0 ? new Number(x) : `${x}`
+              return launch f(p)
+          }
+      use: |-
+          // Promise of union
+          let q: boolean|number|string = await foo(-1)
+          assert(q as string == '-1')
+
+    - decl: |-
+          async function foo(p: int): Promise<[boolean, Error]> {
+              return [p > 0, new Error()] as [boolean, Error]
+          }
+      use: |-
+          // Promise of tuple
+          let q: [boolean, Error] = await foo(42)
+          assert(q[0] && (q[1] instanceof Error))
+
+    - decl: |-
+          async function foo(p: int): Promise<[boolean, Error]> {
+              return launch ((x: int): [boolean, Error] => [x > 0, new Error()])(p)
+          }
+      use: |-
+          // Promise of tuple
+          let q: [boolean, Error] = await foo(42)
+          assert(q[0] && (q[1] instanceof Error))
+
+    - decl: |-
+          async function foo(p: string): Promise<BigInt> {
+              return new BigInt(p)
+          }
+      use: |-
+          // Promise of BigInt
+          let q: BigInt = await foo('123456789012345678901234567890')
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          async function foo(p: string): Promise<BigInt> {
+              return launch ((x: BigInt): BigInt => x)(new BigInt(p))
+          }
+      use: |-
+          // Promise of BigInt
+          let q: BigInt = await foo('123456789012345678901234567890')
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          async function foo(p: bigint): Promise<bigint> {
+              return p
+          }
+      use: |-
+          // Promise of bigint
+          let q: bigint = await foo(123456789012345678901234567890n)
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          async function foo(p: bigint): Promise<bigint> {
+              return launch ((x: bigint): bigint => x)(p)
+          }
+      use: |-
+          // Promise of bigint
+          let q: bigint = await foo(123456789012345678901234567890n)
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          async function foo(p: number, q: number): Promise<Number> {
+              return p + q
+          }
+      use: |-
+          // Array of promises
+          let arr: Promise<Number>[] = [
+              foo(1, 1),
+              foo(2, 2),
+              foo(3, 3),
+              foo(4, 4),
+              foo(5, 5),
+              foo(6, 6),
+              foo(7, 7),
+              foo(8, 8),
+              foo(9, 9),
+              foo(0, 0),
+          ]
+          let cnt = 0.0
+          for (let v of arr) cnt += (await v)
+          assert(cnt == 90.0)
+
+    - decl: |-
+          async function foo(p: number, q: number): Promise<Number> {
+              return launch ((x: number): number => x + q)(p)
+          }
+      use: |-
+          // Array of promises
+          let arr: Promise<Number>[] = [
+              foo(1, 1),
+              foo(2, 2),
+              foo(3, 3),
+              foo(4, 4),
+              foo(5, 5),
+              foo(6, 6),
+              foo(7, 7),
+              foo(8, 8),
+              foo(9, 9),
+              foo(0, 0),
+          ]
+          let cnt = 0.0
+          for (let v of arr) cnt += (await v)
+          assert(cnt == 90.0)
+
+    - decl: |-
+          enum Color { Red, Green, Blue }
+
+          async function foo(p: int): Promise<Color> {
+              return p > 0 ? Color.Green : Color.Blue
+          }
+      use: |-
+          // Promise of enum
+          assert((await foo(42)) == Color.Green)
+
+    - decl: |-
+          enum Color { Red, Green, Blue }
+
+          async function foo(p: int): Promise<Color> {
+              return launch ((x: int): Color => p > 0 ? Color.Green : Color.Blue)(p)
+          }
+      use: |-
+          // Promise of enum
+          assert((await foo(42)) == Color.Green)
+
+    - decl: |-
+          enum Color { R="red", G="green", B="blue" }
+
+          async function foo(p: int): Promise<Color> {
+              return p > 0 ? Color.G : Color.B
+          }
+      use: |-
+          // Promise of string-based enum
+          assert((await foo(-42)) == Color.B)
+
+    - decl: |-
+          enum Color { R="red", G="green", B="blue" }
+
+          async function foo(p: int): Promise<Color> {
+              return launch ((x: int): Color => x > 0 ? Color.G : Color.B)(p)
+          }
+      use: |-
+          // Promise of string-based enum
+          assert((await foo(-42)) == Color.B)
+
+    - decl: |-
+          async function foo<T>(p: T): Promise<T> {
+              return p
+          }
+
+          class A<T> {
+              fld: Promise<T>
+              constructor(p: T) {
+                  this.fld = foo<T>(p)
+              }
+              meth(): T {
+                  return await this.fld
+              }
+          }
+      use: |-
+          // Promise of T
+          let a: A<string> = new A<string>("abc")
+          assert(a.meth() == "abc")
+
+    - decl: |-
+          function bar<T>(p: T): T {
+              return p
+          }
+          async function foo<T>(p: T): Promise<T> {
+              return launch bar(p)
+          }
+
+          class A<T> {
+              fld: Promise<T>
+              constructor(p: T) {
+                  this.fld = foo<T>(p)
+              }
+              meth(): T {
+                  return await this.fld
+              }
+          }
+      use: |-
+          // Promise of T
+          let a: A<string> = new A<string>("abc")
+          assert(a.meth() == "abc")
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+          }
+          async function foo(p: number): Promise<string> {
+              return '' + p
+          }
+      use: |-
+          // Promise in object literal
+          let a: A = { fld: foo(42.0) }
+          assert((await a.fld!) == '42')
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+          }
+          async function foo(p: number): Promise<string> {
+              return launch ((x: number): string => '' + x)(p)
+          }
+      use: |-
+          // Promise in object literal
+          let a: A = { fld: foo(42.0) }
+          assert((await a.fld!) == '42')
+
+    - decl: |-
+          let s = 'ABC'
+          async function foo(p: () => Promise<string>): Promise<string> {
+              return await p()
+          }
+      use: |-
+          // Launch in argument lambda
+          let r = await foo((): Promise<string> => launch ((): string => s)())
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          async function foo(p: () => Promise<string>): Promise<string> {
+              return p()
+          }
+      use: |-
+          // Launch in argument lambda
+          let r = await foo((): Promise<string> => launch ((): string => s)())
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          async function foo(p: () => Promise<string>): Promise<string> {
+              return await p()
+          }
+      use: |-
+          // Launch in trailing lambda
+          let r = await foo() { launch ((): string => s)() }
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          async function foo(p: () => Promise<string>): Promise<string> {
+              return p()
+          }
+      use: |-
+          // Launch in trailing lambda
+          let r = await foo() { launch ((): string => s)() }
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'A'
+          async function foo(p: string): Promise<string> {
+              return p + p
+          }
+      use: |-
+          // Resolve async function promise in chained then
+          let r = foo(s)
+              .then((p: string): string => p + p)
+              .then((p: string): string => p + p)
+
+          assert((await r) == 'AAAAAAAA')
+
+    - decl: |-
+          type EN = Error|null
+          let s = 'A'
+          async function foo(p: string): Promise<string> {
+              if (p == 'A') {
+                  throw new Error('E')
+              }
+              return 'X'
+          }
+      use: |-
+          // Catch error in chained catch
+          let r = foo(s)
+              .then((p: string): string => p + p)  // skipped
+              .catch((p: EN): string => p!.message)
+              .then((p: string): string => p + p)
+
+          assert((await r) == 'EE')
+
+    - decl: |-
+          type EN = Error|null
+          let s = 'A'
+          async function foo(p: string): Promise<string> {
+              return p + p
+          }
+      use: |-
+          // Throw error in chained then and catch in the following chained catch
+          let r: Promise<string> = foo(s)
+              .then((p: string): string => { throw new Error(p) })
+              .catch((p: EN): string => p!.message + p!.message)
+
+          assert((await r) == 'AAAA')
+
+    - decl: |-
+          type EN = Error|null
+          let s = 'A'
+          async function foo(p: string): Promise<string> {
+              if (p == 'A') {
+                  throw new Error('E')
+              }
+              return 'X'
+          }
+      use: |-
+          // Throw error in chained catch
+          let r: Promise<string> = foo(s)
+              .then((p: string): string => p + p)
+              .catch((p: EN): string => { throw p! })
+
+          try {
+              await r
+          } catch (e: Error) {
+              assert(e.message == 'E')
+              return
+          }
+          assert(false)

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc.sts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+{% for c in cases %}
+/*---
+desc: Async functions are implicit coroutines that can be called as regular functions.
+---*/
+
+{{c.decl}}
+
+function main() {
+    {{c.use|indent}}
+}
+{% endfor %}

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_n.params.yaml

@@ -0,0 +1,67 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# 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.
+
+---
+cases:
+    - decl: |-
+          // Async functions can be neither abstract nor native.
+          async native function foo(): Promise<Number>;
+
+    - decl: |-
+          // The return type of an async function must be Promise<T>
+          async function foo(p: int): undefined {
+              return undefined
+          }
+
+    - decl: |-
+          // The return type of an async function must be Promise<T>
+          async function foo(p: int): int {
+              return p + p
+          }
+
+    - decl: |-
+          // The return type of an async function must be Promise<T>
+          async function foo(p: boolean): Promise<Int> {
+              return p
+          }
+
+    - decl: |-
+          // The return type of an async function must be Promise<T>
+          async function foo<U>(p: U): Promise<T> {
+              return p
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async functions is allowed.
+          async function foo<T>(p: T): Promise<T> {
+              return new Object()
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async functions is allowed.
+          async function foo(p: string): Promise<String> {
+              return launch ((): Object => new Object())()
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async functions is allowed.
+          async function foo(p: string): Promise<String> {
+              return undefined
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async functions is allowed.
+          async function foo(p: int): Promise<Number> {
+              if (p == 1) return 1.0
+              return true
+          }

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_n.sts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+{% for c in cases %}
+/*---
+desc: The return type of an async function must be Promise<T>.
+tags: [compile-only, negative]
+---*/
+
+{{c.decl}}
+
+function main() {}
+{% endfor %}

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth.params.yaml

@@ -0,0 +1,642 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# 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.
+
+---
+cases:
+    - decl: |-
+          class A {
+              async foo(): Promise<void> {}
+          }
+      use: |-
+          // Promise of void
+          let r = new A().foo()
+          assert((await r) == undefined)
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<Int> {
+                  return p + p
+              }
+          }
+      use: |-
+          // Promise of primitive
+          assert((await new A().foo(42)) == 84)
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<Int> {
+                  return launch ((x:int): int => x + x)(p)
+              }
+          }
+      use: |-
+          // Promise of primitive
+          assert((await new A().foo(42)) == 84)
+
+    - decl: |-
+          class A {
+              async foo(p: Double): Promise<Double> {
+                  return p + p
+              }
+          }
+      use: |-
+          // Promise of boxed
+          assert((await new A().foo(new Double(42.0))) == 84.0)
+
+    - decl: |-
+          class A {
+              async foo(p: Double): Promise<Double> {
+                  return launch ((x: Double): Double => x + x)(p)
+              }
+          }
+      use: |-
+          // Promise of boxed
+          assert((await new A().foo(new Double(42.0))) == 84.0)
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<string> {
+                  return `${p}`
+              }
+          }
+      use: |-
+          // Promise of string
+          let r = new A().foo(42)
+          assert((await r) == '42')
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<string> {
+                  return launch ((x: string): string => x + x)(`${p}`)
+              }
+          }
+      use: |-
+          // Promise of string
+          let r = new A().foo(42)
+          assert((await r) == '4242')
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<String> {
+                  return new String(`${p}`)
+              }
+          }
+      use: |-
+          // Promise of String
+          assert((await new A().foo(42)) instanceof String)
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<String> {
+                  return launch ((x: int): String => new String(`${x}`))(p)
+              }
+          }
+      use: |-
+          // Promise of String
+          assert((await new A().foo(42)) instanceof String)
+
+    - decl: |-
+          class A {
+              async foo(p: Object): Promise<Object> {
+                  return p
+              }
+          }
+      use: |-
+          // Promise of Object
+          assert((await new A().foo(new A())) instanceof A)
+
+    - decl: |-
+          class A {
+              async foo(p: Object): Promise<Object> {
+                  return launch ((x: Object): Object => x)(p)
+              }
+          }
+      use: |-
+          // Promise of Object
+          assert((await new A().foo(new A())) instanceof A)
+
+    - decl: |-
+          class A {
+              async foo(p: Number|undefined): Promise<Number|undefined> {
+                  return p instanceof Number ? p + 1 : p
+              }
+          }
+      use: |-
+          // Promise of nullish
+          assert((await new A().foo(42)) == 43)
+
+    - decl: |-
+          class A {
+              async foo(p: Number|undefined): Promise<Number|undefined> {
+                  return launch ((x: Number|undefined): Number|undefined => x instanceof Number ? x + 1 : x)(p)
+              }
+          }
+      use: |-
+          // Promise of nullish
+          assert((await new A().foo(42)) == 43)
+
+    - decl: |-
+          class A {
+              async foo(p: Number|null): Promise<Number|null> {
+                  return p instanceof Number ? p + 1 : p
+              }
+          }
+      use: |-
+          // Promise of nullish
+          assert((await new A().foo(42)) == 43)
+
+    - decl: |-
+          class A {
+              async foo(p: Number|null): Promise<Number|null> {
+                  return launch ((x: Number|null): Number|null => x instanceof Number ? x + 1 : x)(p)
+              }
+          }
+      use: |-
+          // Promise of nullish
+          assert((await new A().foo(42)) == 43)
+
+    - decl: |-
+          class A {
+              async foo(p: Int|null|undefined): Promise<Int|null|undefined> {
+                  return p == null || p == undefined ? p : p + 1
+              }
+          }
+      use: |-
+          // Promise of nullish
+          assert((await new A().foo(42)) == 43)
+
+    - decl: |-
+          class A {
+              async foo(p: Int|null|undefined): Promise<Int|null|undefined> {
+                  let q = (p: Int|null|undefined): Int|null|undefined => {
+                      return p == null || p == undefined ? p : p + 1
+                  }
+                  return launch q(p)
+              }
+          }
+      use: |-
+          // Promise of nullish
+          assert((await new A().foo(42)) == 43)
+
+    - decl: |-
+          class A {
+              async foo(p: string): Promise<string> {
+                  return p + p
+              }
+
+              async bar(p: string): Promise<Promise<string>> {
+                  return this.foo(p)
+              }
+          }
+      use: |-
+          // Promise of promise
+          assert((await new A().bar('A')) == 'AA')
+
+    - decl: |-
+          class A {
+              async static foo(p: string): Promise<string> {
+                  return launch ((x: string): string => x + x)(p)
+              }
+
+              async bar(p: string): Promise<Promise<string>> {
+                  return launch ((x: string): Promise<string> => A.foo(x))(p)
+              }
+          }
+      use: |-
+          // Promise of promise
+          assert((await new A().bar('A')) == 'AA')
+
+    - decl: |-
+          class A {
+              async foo(): Promise<int[]> {
+                  return [1, 2, 3] as int[]
+              }
+          }
+      use: |-
+          // Promise of array
+          let q: int[] = await new A().foo()
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
+
+    - decl: |-
+          class A {
+              async foo(): Promise<int[]> {
+                  return launch ((): int[] => [1, 2, 3])()
+              }
+          }
+      use: |-
+          // Promise of array
+          let q: int[] = await new A().foo()
+          assert(q[0] == 1 && q[1] == 2 && q[2] == 3)
+
+    - decl: |-
+          class A {
+              async foo(): Promise<(p: string) => string> {
+                  return (p: string): string => { return p + p }
+              }
+          }
+      use: |-
+          // Promise of function
+          assert((await new A().foo())('A') == 'AA')
+
+    - decl: |-
+          type FT = (p: string) => string
+          class A {
+              async foo(): Promise<FT> {
+                  let f = (p: string): string => p + p
+                  return launch ((): FT => f)()
+              }
+          }
+      use: |-
+          // Promise of function
+          assert((await new A().foo())('A') == 'AA')
+
+    - decl: |-
+          type UT = number | string | boolean
+          class A {
+              async foo(p: int): Promise<UT> {
+                  return p == 0 ? true : p > 0 ? new Number(p) : `${p}`
+              }
+          }
+      use: |-
+          // Promise of union
+          let q: boolean|number|string = await new A().foo(-1)
+          assert(q as string == '-1')
+
+    - decl: |-
+          type UT = number | string | boolean
+          class A {
+              async foo(p: int): Promise<UT> {
+                  let f = (x: int): UT => x == 0 ? true : x > 0 ? new Number(x) : `${x}`
+                  return launch f(p)
+              }
+          }
+      use: |-
+          // Promise of union
+          let q: boolean|number|string = await new A().foo(-1)
+          assert(q as string == '-1')
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<[boolean, Error]> {
+                  return [p > 0, new Error()] as [boolean, Error]
+              }
+          }
+      use: |-
+          // Promise of tuple
+          let q: [boolean, Error] = await new A().foo(42)
+          assert(q[0] && (q[1] instanceof Error))
+
+    - decl: |-
+          class A {
+              async foo(p: int): Promise<[boolean, Error]> {
+                  return launch ((x: int): [boolean, Error] => [x > 0, new Error()])(p)
+              }
+          }
+      use: |-
+          // Promise of tuple
+          let q: [boolean, Error] = await new A().foo(42)
+          assert(q[0] && (q[1] instanceof Error))
+
+    - decl: |-
+          class A {
+              async foo(p: string): Promise<BigInt> {
+                  return new BigInt(p)
+              }
+          }
+      use: |-
+          // Promise of BigInt
+          let q: BigInt = await new A().foo('123456789012345678901234567890')
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          class A {
+              async foo(p: string): Promise<BigInt> {
+                  return launch ((x: BigInt): BigInt => x)(new BigInt(p))
+              }
+          }
+      use: |-
+          // Promise of BigInt
+          let q: BigInt = await new A().foo('123456789012345678901234567890')
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          class A {
+              async foo(p: bigint): Promise<bigint> {
+                  return p
+              }
+          }
+      use: |-
+          // Promise of bigint
+          let q: bigint = await new A().foo(123456789012345678901234567890n)
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          class A {
+              async foo(p: bigint): Promise<bigint> {
+                  return launch ((x: bigint): bigint => x)(p)
+              }
+          }
+      use: |-
+          // Promise of bigint
+          let q: bigint = await new A().foo(123456789012345678901234567890n)
+          assert(q == 123456789012345678901234567890n)
+
+    - decl: |-
+          class B {
+              async foo(p: number, q: number): Promise<Number> {
+                  return p + q
+              }
+          }
+          class A extends B {}
+      use: |-
+          let a = new A()
+          // Array of promises
+          let arr: Promise<Number>[] = [
+              a.foo(1, 1),
+              a.foo(2, 2),
+              a.foo(3, 3),
+              a.foo(4, 4),
+              a.foo(5, 5),
+              a.foo(6, 6),
+              a.foo(7, 7),
+              a.foo(8, 8),
+              a.foo(9, 9),
+              a.foo(0, 0),
+          ]
+          let cnt = 0.0
+          for (let v of arr) cnt += (await v)
+          assert(cnt == 90.0)
+
+    - decl: |-
+          class A {
+              async static foo(p: number, q: number): Promise<Number> {
+                  return launch ((x: number): number => x + q)(p)
+              }
+          }
+      use: |-
+          // Array of promises
+          let arr: Promise<Number>[] = [
+              A.foo(1, 1),
+              A.foo(2, 2),
+              A.foo(3, 3),
+              A.foo(4, 4),
+              A.foo(5, 5),
+              A.foo(6, 6),
+              A.foo(7, 7),
+              A.foo(8, 8),
+              A.foo(9, 9),
+              A.foo(0, 0),
+          ]
+          let cnt = 0.0
+          for (let v of arr) cnt += (await v)
+          assert(cnt == 90.0)
+
+    - decl: |-
+          enum Color { Red, Green, Blue }
+          class A {
+              async foo(p: int): Promise<Color> {
+                  return p > 0 ? Color.Green : Color.Blue
+              }
+          }
+      use: |-
+          // Promise of enum
+          assert((await new A().foo(42)) == Color.Green)
+
+    - decl: |-
+          enum Color { Red, Green, Blue }
+          class A {
+              async foo(p: int): Promise<Color> {
+                  return launch ((x: int): Color => p > 0 ? Color.Green : Color.Blue)(p)
+              }
+          }
+      use: |-
+          // Promise of enum
+          assert((await new A().foo(42)) == Color.Green)
+
+    - decl: |-
+          enum Color { R="red", G="green", B="blue" }
+          class A {
+              async foo(p: int): Promise<Color> {
+                  return p > 0 ? Color.G : Color.B
+              }
+          }
+      use: |-
+          // Promise of string-based enum
+          assert((await new A().foo(-42)) == Color.B)
+
+    - decl: |-
+          enum Color { R="red", G="green", B="blue" }
+          class A {
+              async foo(p: int): Promise<Color> {
+                  return launch ((x: int): Color => x > 0 ? Color.G : Color.B)(p)
+              }
+          }
+      use: |-
+          // Promise of string-based enum
+          assert((await new A().foo(-42)) == Color.B)
+
+    - decl: |-
+          class B<T> {
+              async foo(p: T): Promise<T> {
+                  return p
+              }
+          }
+
+          class A<T> {
+              fld: Promise<T>
+              constructor(p: T) {
+                  this.fld = new B<T>().foo(p)
+              }
+              meth(): T {
+                  return await this.fld
+              }
+          }
+      use: |-
+          // Promise of T
+          let a: A<string> = new A<string>("abc")
+          assert(a.meth() == "abc")
+
+    - decl: |-
+          class B<T> {
+              bar(p: T): T {
+                  return p
+              }
+              async foo(p: T): Promise<T> {
+                  return launch this.bar(p)
+              }
+          }
+
+          class A<T> {
+              fld: Promise<T>
+              constructor(p: T) {
+                  this.fld = new B<T>().foo(p)
+              }
+              meth(): T {
+                  return await this.fld
+              }
+          }
+      use: |-
+          // Promise of T
+          let a: A<string> = new A<string>("abc")
+          assert(a.meth() == "abc")
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+          }
+          class B {
+              async foo(p: number): Promise<string> {
+                  return '' + p
+              }
+          }
+      use: |-
+          // Promise in object literal
+          let a: A = { fld: new B().foo(42.0) }
+          assert((await a.fld!) == '42')
+
+    - decl: |-
+          class A {
+              fld: Promise<string>|null|undefined
+          }
+          class B {
+              async static foo(p: number): Promise<string> {
+                  return launch ((x: number): string => '' + x)(p)
+              }
+          }
+      use: |-
+          // Promise in object literal
+          let a: A = { fld: B.foo(42.0) }
+          assert((await a.fld!) == '42')
+
+    - decl: |-
+          let s = 'ABC'
+          class A {
+              async foo(p: () => Promise<string>): Promise<string> {
+                  return await p()
+              }
+          }
+      use: |-
+          // Launch in argument lambda
+          let r = await new A().foo((): Promise<string> => launch ((): string => s)())
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          class A {
+              async foo(p: () => Promise<string>): Promise<string> {
+                  return p()
+              }
+          }
+      use: |-
+          // Launch in argument lambda
+          let r = await new A().foo((): Promise<string> => launch ((): string => s)())
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          class A {
+              async foo(p: () => Promise<string>): Promise<string> {
+                  return await p()
+              }
+          }
+      use: |-
+          // Launch in trailing lambda
+          let r = await new A().foo() { launch ((): string => s)() }
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'ABC'
+          class A {
+              async static foo(p: () => Promise<string>): Promise<string> {
+                  return p()
+              }
+          }
+      use: |-
+          // Launch in trailing lambda
+          let r = await A.foo() { launch ((): string => s)() }
+          assert(r == 'ABC')
+
+    - decl: |-
+          let s = 'A'
+          class A {
+              async foo(p: string): Promise<string> {
+                  return p + p
+              }
+          }
+      use: |-
+          // Resolve async method promise in chained then
+          let r = new A().foo(s)
+              .then((p: string): string => p + p)
+              .then((p: string): string => p + p)
+
+          assert((await r) == 'AAAAAAAA')
+
+    - decl: |-
+          type EN = Error|null
+          let s = 'A'
+          class A {
+              async foo(p: string): Promise<string> {
+                  if (p == 'A') {
+                      throw new Error('E')
+                  }
+                  return 'X'
+              }
+          }
+      use: |-
+          // Catch error in chained catch
+          let r = new A().foo(s)
+              .then((p: string): string => p + p)  // skipped
+              .catch((p: EN): string => p!.message)
+              .then((p: string): string => p + p)
+
+          assert((await r) == 'EE')
+
+    - decl: |-
+          type EN = Error|null
+          let s = 'A'
+          class A {
+              async static foo(p: string): Promise<string> {
+                  return p + p
+              }
+          }
+      use: |-
+          // Throw error in chained then and catch in the following chained catch
+          let r: Promise<string> = A.foo(s)
+              .then((p: string): string => { throw new Error(p) })
+              .catch((p: EN): string => p!.message + p!.message)
+
+          assert((await r) == 'AAAA')
+
+    - decl: |-
+          type EN = Error|null
+          let s = 'A'
+          class A {
+              async foo(p: string): Promise<string> {
+                  if (p == 'A') {
+                      throw new Error('E')
+                  }
+                  return 'X'
+              }
+          }
+      use: |-
+          // Throw error in chained catch
+          let r = new A().foo(s)
+              .then((p: string): string => p + p)
+              .catch((p: EN): string => { throw p! })
+
+          try {
+              await r
+          } catch (e: Error) {
+              assert(e.message == 'E')
+              return
+          }
+          assert(false)

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth.sts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+{% for c in cases %}
+/*---
+desc: The method async is an implicit coroutine that can be called as a regular method.
+---*/
+
+{{c.decl}}
+
+function main() {
+    {{c.use|indent}}
+}
+{% endfor %}

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_n.params.yaml

@@ -0,0 +1,103 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# 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.
+
+---
+cases:
+    - decl: |-
+          // Async methods can be neither abstract nor native.
+          class A {
+              async abstract foo(p: Number): Promise<Number>;
+          }
+
+    - decl: |-
+          // Async methods can be neither abstract nor native.
+          class A {
+              async abstract foo(p: Number): Promise<void> {}
+          }
+
+    - decl: |-
+          // Async methods can be neither abstract nor native.
+          class A {
+              async native foo(p: Number): Promise<Number>;
+          }
+
+    - decl: |-
+          // Async methods can be neither abstract nor native.
+          class A {
+              async native foo(p: Number): Promise<void> {}
+          }
+
+    - decl: |-
+          // The return type of an async method must be Promise<T>
+          class A {
+              async foo(p: int): undefined {
+                  return undefined
+              }
+          }
+
+    - decl: |-
+          // The return type of an async method must be Promise<T>
+          class A {
+              async foo(p: string): string {
+                  return p + p
+              }
+          }
+
+    - decl: |-
+          // The return type of an async method must be Promise<T>
+          class A {
+              async foo(p: boolean): Promise<Int> {
+                  return p
+              }
+          }
+
+    - decl: |-
+          // The return type of an async method must be Promise<T>
+          class A {
+              async foo<U>(p: U): Promise<T> {
+                  return p
+              }
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async methods is allowed.
+          class A {
+              async foo<T>(p: T): Promise<T> {
+                  return new Object()
+              }
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async methods is allowed.
+          class A {
+              async foo(p: string): Promise<String> {
+                  return launch ((): Object => new Object())()
+              }
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async methods is allowed.
+          class A {
+              async foo(p: string): Promise<String> {
+                  return undefined
+              }
+          }
+
+    - decl: |-
+          // Returning values of types Promise<T> and T from async methods is allowed.
+          class A {
+              async foo(p: int): Promise<Number> {
+                  if (p == 1) return 1.0
+                  return true
+              }
+          }

static_core/plugins/ets/tests/ets-templates/17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_n.sts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+{% for c in cases %}
+/*---
+desc: The return type of an async method must be Promise<T>.
+tags: [compile-only, negative]
+---*/
+
+{{c.decl}}
+
+function main() {}
+{% endfor %}

static_core/tests/tests-u-runner/test-lists/ets-cts/ets-cts-excluded-JIT-REPEATS.txt

@@ -51,12 +51,84 @@ escompat/escompat_BigInt_instance_BigInt_toString_001.sts
 08.statements/08.for_statements/for_loop_parameters_12.sts
 # end of 16707
 
-# 17965 E/gc: Global reference storage is full
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_18.sts
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_17.sts
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_16.sts
-17.experimental_features/16.coroutines/02.awaiting_coroutine/a_8.sts
+# 17053 Cannot create array of nullish tuples
+07.expressions/04.array_literal/array_literal_13.sts
 
 # 17964 Segmentation fault with too many repeated calls
 17.experimental_features/16.coroutines/02.awaiting_coroutine/a_2.sts
 17.experimental_features/16.coroutines/02.awaiting_coroutine/a_4.sts
+17.experimental_features/16.coroutines/02.awaiting_coroutine/a_8.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_10.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_12.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_14.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_2.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_18.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_20.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_22.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_26.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_28.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_30.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_32.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_4.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_40.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_41.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_42.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_6.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_8.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_10.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_12.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_14.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_2.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_18.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_20.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_22.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_26.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_28.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_30.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_32.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_4.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_40.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_41.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_42.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_6.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_8.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_1.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_17.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_18.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_23.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_1.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_10.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_11.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_12.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_13.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_14.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_15.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_2.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_20.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_3.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_4.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_5.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_6.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_7.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_8.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_9.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_1.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_10.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_11.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_12.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_13.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_14.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_15.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_17.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_2.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_22.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_3.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_4.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_5.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_6.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_7.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_8.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_9.sts

static_core/tests/tests-u-runner/test-lists/ets-cts/ets-cts-ignored-AMD64-AOT.txt

@@ -162,4 +162,81 @@
 # end of 16707
 
 # 17965 ERRNO: 12 (Cannot allocate memory)
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_23.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_10.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_11.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_12.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_13.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_14.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_15.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_2.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_20.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_3.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_4.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_5.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_6.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_7.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_8.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_9.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_22.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_10.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_12.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_14.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_2.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_18.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_20.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_22.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_26.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_28.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_30.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_32.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_4.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_40.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_41.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_42.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_6.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_8.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_45.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_46.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_47.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_48.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_10.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_12.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_14.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_2.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_18.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_20.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_22.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_26.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_28.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_30.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_32.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_4.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_40.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_41.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_42.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_6.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_8.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_45.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_46.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_47.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_48.sts
+
+# 17488: Separate module initializer not implemented yet for AOT
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_abstract_class.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_const_var.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_enum.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_function_gen.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_generic_class.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_interface.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_tuple.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_type.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_union.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/multiple_default_export.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/multiple_export.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_abstract_class.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_class_same_name.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_var_boxed.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_var_default.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_var_primitive.sts

static_core/tests/tests-u-runner/test-lists/ets-cts/ets-cts-ignored-ARM64-AOT.txt

@@ -162,4 +162,81 @@
 # end of 16707
 
 # 17965 ERRNO: 12 (Cannot allocate memory)
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_16.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_23.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_10.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_11.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_12.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_13.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_14.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_15.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_2.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_20.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_3.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_4.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_5.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_6.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_7.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_8.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_9.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_22.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_10.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_12.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_14.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_2.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_18.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_20.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_22.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_26.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_28.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_30.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_32.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_4.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_40.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_41.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_42.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_6.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_8.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_45.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_46.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_47.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_48.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_10.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_12.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_14.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_2.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_18.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_20.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_22.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_26.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_28.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_30.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_32.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_4.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_40.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_41.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_42.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_6.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_8.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_45.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_46.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_47.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_48.sts
+
+# 17488: Separate module initializer not implemented yet for AOT
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_abstract_class.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_const_var.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_enum.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_function_gen.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_generic_class.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_interface.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_tuple.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_type.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/default_import_union.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/multiple_default_export.sts
+13.compilation_units_packages_and_modules/04.import_directives/04.default_import_binding/multiple_export.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_abstract_class.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_class_same_name.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_var_boxed.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_var_default.sts
+13.compilation_units_packages_and_modules/04.import_directives/05.type_import_binding/type_binding_var_primitive.sts

static_core/tests/tests-u-runner/test-lists/ets-cts/ets-cts-ignored.txt

@@ -13,16 +13,6 @@
 # end of es2panda fails
 
 # 16343 Improve typeof result inference, move it to ETSAnalyzer
-07.expressions/17.typeof_expression/tof_const_1.sts
-07.expressions/17.typeof_expression/tof_vars_1.sts
-07.expressions/17.typeof_expression/tof_func_1.sts
-07.expressions/17.typeof_expression/tof_meth_1.sts
-07.expressions/17.typeof_expression/tof_obj_1.sts
-07.expressions/17.typeof_expression/tof_const_4.sts
-07.expressions/17.typeof_expression/tof_vars_4.sts
-07.expressions/17.typeof_expression/tof_func_4.sts
-07.expressions/17.typeof_expression/tof_meth_4.sts
-07.expressions/17.typeof_expression/tof_obj_4.sts
 07.expressions/17.typeof_expression/tof_const_6.sts
 07.expressions/17.typeof_expression/tof_vars_6.sts
 07.expressions/17.typeof_expression/tof_func_6.sts
@@ -73,14 +63,6 @@
 05.generics/01.type_parameters/generic_classes/generic_class_self_dependency_12.sts
 05.generics/01.type_parameters/generic_classes/generic_class_self_dependency_13.sts
 05.generics/01.type_parameters/generic_classes/generic_class_self_dependency_14.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_functions/function_type_parameter_default_0.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_functions/function_type_parameter_default_1.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_functions/function_type_parameter_default_4.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_methods/method_type_parameter_default_0.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_methods/method_type_parameter_default_1.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_methods/method_type_parameter_default_2.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_methods/method_type_parameter_default_3.sts
-05.generics/01.type_parameters/02.type_parameter_default/generic_methods/method_type_parameter_default_4.sts
 05.generics/02.generic_instantiations/02.type_arguments/type_arguments_of_parameterized_declarations/class_args_9.sts
 05.generics/02.generic_instantiations/02.type_arguments/type_arguments_of_parameterized_declarations/class_variance_0.sts
 05.generics/02.generic_instantiations/02.type_arguments/type_arguments_of_parameterized_declarations/class_variance_1.sts
@@ -153,8 +135,6 @@
 07.expressions/01.evaluation_of_expressions/eval_decl.sts
 07.expressions/03.qualified_name/qualified_name_0.sts
 07.expressions/03.qualified_name/qualified_name_1.sts
-07.expressions/03.qualified_name/qualified_name_4.sts
-07.expressions/03.qualified_name/qualified_name_5.sts
 07.expressions/08.this_expression/this_in_interface_method.sts
 07.expressions/08.this_expression/this_in_lambda.sts
 07.expressions/08.this_expression/this_in_lambda_negative.sts
@@ -474,7 +454,6 @@
 03.types/08.reference_types/07.function_types/function_type_6.sts
 03.types/08.reference_types/07.function_types/function_type_7.sts
 17.experimental_features/07.function_and_method_overloading/01.function_overloading/fn_overloading_30.sts
-04.names_declarations_and_scopes/08.function_declarations/02.parameter_list/param_list_7.sts
 04.names_declarations_and_scopes/08.function_declarations/04.optional_parameters/opt_param_11.sts
 04.names_declarations_and_scopes/08.function_declarations/04.optional_parameters/opt_param_12.sts
 04.names_declarations_and_scopes/08.function_declarations/04.optional_parameters/opt_param_2.sts
@@ -588,30 +567,45 @@
 06.contexts_and_conversions/03.numeric_operator_contexts/conv_7.sts
 # end of es2panda fails
 
-# es2panda fails: panda#14767 undefined is not supported
-06.contexts_and_conversions/02.string_operator_contexts/conversion_9.sts
-# end of es2panda fails
+# 19583 es2panda segfault on launching a coroutine in trailing lambda
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_24.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_23.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_43.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_44.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_43.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_44.sts
 
 # 17053 Cannot create array of nullish tuples
 07.expressions/04.array_literal/array_literal_13.sts
 
 # 17051 Promise<void> should resolve as undefined
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_0.sts
-
-# 17050 SegFault on executing launch in a launched function
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_9.sts
-
-# 17022 No CTE on launching a method
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_n_6.sts
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_n_7.sts
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_n_8.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_0.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_0.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_0.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_0.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_0.sts
 
 # 17057 Cannot launch function returning enum
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_19.sts
-17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_20.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_19.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_func_20.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_18.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_meth_19.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_17.sts
+17.experimental_features/16.coroutines/01.create_and_launch_coroutine/c_lamb_18.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_33.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_34.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_35.sts
+17.experimental_features/17.async_functions_and_methods/01.async_functions/afunc_36.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_33.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_34.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_35.sts
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_36.sts
 
-# 17142 Compilation fails on multiple then/catch in Promise chain
-17.experimental_features/16.coroutines/03.promise_class/p_4.sts
+# 19596 es2panda aborts on this reference from async method
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_38.sts
+
+# 19985 es2panda aborts on using async methods
+17.experimental_features/17.async_functions_and_methods/02.async_methods/ameth_17.sts
 
 # es2panda fails: panda#11752
 13.compilation_units_packages_and_modules/10.top-level_statements/block_declaration_10.sts
@@ -643,13 +637,9 @@
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_11.sts
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_12.sts
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_13.sts
-07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_16.sts
-#19909
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_14.sts
-07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_17.sts
-07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_3.sts
+07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_16.sts
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_4.sts
-07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_5.sts
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_6.sts
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_7.sts
 07.expressions/04.array_literal/02.type_inference_from-types_of_elements/arr_inf2_9.sts
@@ -662,18 +652,11 @@
 # es2panda fails: panda#12528
 04.names_declarations_and_scopes/07.variable_and_constant_declarations/04.type_inference_from_initializer/infer_4.sts
 04.names_declarations_and_scopes/07.variable_and_constant_declarations/04.type_inference_from_initializer/infer_5.sts
-04.names_declarations_and_scopes/08.function_declarations/function_decl_9.sts
-# 19909
 04.names_declarations_and_scopes/07.variable_and_constant_declarations/04.type_inference_from_initializer/infer_6.sts
 # es2panda fails: panda#12554
 04.names_declarations_and_scopes/01.names/qualified_name_0.sts
 04.names_declarations_and_scopes/01.names/qualified_name_1.sts
 04.names_declarations_and_scopes/01.names/qualified_name_2.sts
-04.names_declarations_and_scopes/01.names/qualified_name_3.sts
-04.names_declarations_and_scopes/01.names/qualified_name_6.sts
-04.names_declarations_and_scopes/01.names/qualified_name_7.sts
-04.names_declarations_and_scopes/01.names/qualified_name_10.sts
-04.names_declarations_and_scopes/01.names/qualified_name_11.sts
 # end of es2panda fails
 
 # es2panda fails: panda#12853 es2panda fails on private interface method
@@ -699,14 +682,10 @@
 17.experimental_features/06.statements/01.for-of_type_annotation/for_of_10.sts
 
 # 15477 Type conversions are not supported in for-of statement
-17.experimental_features/06.statements/01.for-of_type_annotation/for_of_13.sts
-17.experimental_features/06.statements/01.for-of_type_annotation/for_of_14.sts
-17.experimental_features/06.statements/01.for-of_type_annotation/for_of_24.sts
 17.experimental_features/06.statements/01.for-of_type_annotation/for_of_15.sts
 17.experimental_features/06.statements/01.for-of_type_annotation/for_of_25.sts
 
-# #19932 es2panda fails: 7.6.2 Object Literal of Interface Type is not implemented
-07.expressions/05.object_literal/02.object_literal_of_interface_type/in_0.sts
+# es2panda fails: 7.6.2 Object Literal of Interface Type is not implemented
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_1.sts
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_10.sts
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_2.sts
@@ -715,7 +694,6 @@
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_5.sts
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_6.sts
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_7.sts
-07.expressions/05.object_literal/02.object_literal_of_interface_type/in_8.sts
 07.expressions/05.object_literal/02.object_literal_of_interface_type/in_9.sts
 07.expressions/05.object_literal/02.object_literal_of_interface_type/spec_ex1.sts
 # end of es2panda fails
@@ -875,7 +853,6 @@
 
 # es2panda fails: equality not yet implemented
 07.expressions/25.equality_expressions/eq_12.sts
-07.expressions/25.equality_expressions/eq_13.sts
 07.expressions/25.equality_expressions/eq_16.sts
 07.expressions/25.equality_expressions/eq_17.sts
 07.expressions/25.equality_expressions/eq_19.sts
@@ -913,6 +890,10 @@
 07.expressions/11.function_call_expression/step_1_selection_of_function/step1_16.sts
 07.expressions/11.function_call_expression/step_1_selection_of_function/step1_17.sts
 07.expressions/11.function_call_expression/step_1_selection_of_function/step1_18.sts
+07.expressions/11.function_call_expression/step_1_selection_of_function/step1_20.sts
+07.expressions/11.function_call_expression/step_1_selection_of_function/step1_21.sts
+07.expressions/11.function_call_expression/step_2_semantic_correctness_check/step2_5.sts
+07.expressions/11.function_call_expression/step_2_semantic_correctness_check/step2_6.sts
 07.expressions/11.function_call_expression/step_1_selection_of_function/step1_27.sts
 07.expressions/11.function_call_expression/step_1_selection_of_function/step1_5.sts
 07.expressions/11.function_call_expression/step_1_selection_of_function/step1_6.sts
@@ -921,7 +902,6 @@
 
 
 # es2panda fails: panda, 4.8.3 optional parameters not fully implemented
-07.expressions/10.method_call_expression/02.step_2_selection_of_method/step2_16.sts
 07.expressions/10.method_call_expression/02.step_2_selection_of_method/step2_17.sts
 07.expressions/10.method_call_expression/02.step_2_selection_of_method/step2_18.sts
 07.expressions/10.method_call_expression/02.step_2_selection_of_method/step2_19.sts
@@ -971,9 +951,6 @@
 06.contexts_and_conversions/04.casting_contexts_and_conversions/02.narrowing_reference_casting_conversions/neg_gen1.sts
 06.contexts_and_conversions/04.casting_contexts_and_conversions/02.narrowing_reference_casting_conversions/neg_gen2.sts
 
-# 18096 Cannot assign a function to Object variable
-06.contexts_and_conversions/04.casting_contexts_and_conversions/02.narrowing_reference_casting_conversions/userdef_ref_3.sts
-
 # 15242 Ensure-Not-Nullish expression for nullish tuple not recognized
 03.types/08.reference_types/10.tuple_types/tt_17.sts
 
@@ -1006,11 +983,6 @@
 13.compilation_units_packages_and_modules/04.import_directives/07.import_path/dir/import_path_dir_2.sts
 13.compilation_units_packages_and_modules/04.import_directives/07.import_path/dir/import_path_dir_3.sts
 
-13.compilation_units_packages_and_modules/09.export_directives/01.selective_export_directive/selective_exports_1.sts
-13.compilation_units_packages_and_modules/09.export_directives/01.selective_export_directive/selective_exports_3.sts
-13.compilation_units_packages_and_modules/09.export_directives/01.selective_export_directive/selective_exports_4.sts
-13.compilation_units_packages_and_modules/09.export_directives/01.selective_export_directive/selective_exports_5.sts
-13.compilation_units_packages_and_modules/09.export_directives/01.selective_export_directive/selective_exports_6.sts
 13.compilation_units_packages_and_modules/09.export_directives/04.re-export_directive/re-export_all_by_old_names.sts
 
 # 18493
@@ -1023,14 +995,12 @@
 # end 15095
 
 # es2panda: panda#13442 Reworking the equality expression so it aligns with the specification changes
-03.types/08.reference_types/10.tuple_types/tt2_15.sts
 # end of es2panda fails
 
 # Throwing function types
-17.experimental_features/08.native_functions_and_methods/01.native_functions/nat8.sts
 17.experimental_features/15.exceptions/01.throwing_functions/lambda.sts
 
-# Leftovers from bit operations on floats
+# Leftovers from bit operations on floats, verifier failure with opt-level=0
 06.contexts_and_conversions/03.numeric_operator_contexts/binary_numeric_promotion/result_type_bitwise_61.sts
 06.contexts_and_conversions/03.numeric_operator_contexts/binary_numeric_promotion/result_type_bitwise_68.sts
 
@@ -1039,12 +1009,6 @@
 03.types/08.reference_types/08.null_type/null12.sts
 03.types/08.reference_types/08.null_type/null13.sts
 
-# 17736 Incorrect relational operation result with negative bigint
-07.expressions/24.relational_expressions/03.bigint_relational_operators/ge_0.sts
-07.expressions/24.relational_expressions/03.bigint_relational_operators/gt_0.sts
-07.expressions/24.relational_expressions/03.bigint_relational_operators/le_0.sts
-07.expressions/24.relational_expressions/03.bigint_relational_operators/lt_0.sts
-
 # inferred type is null
 04.names_declarations_and_scopes/07.variable_and_constant_declarations/04.type_inference_from_initializer/null_initializer.sts
 # nullable in arithmetics
@@ -1223,9 +1187,7 @@
 17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_14.sts
 17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_15.sts
 17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_17.sts
-17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_19.sts
 17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_20.sts
-17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_21.sts
 17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_22.sts
 17.experimental_features/19.packages/03.import_and_overloading_of_function_names/pkgs_ab_23.sts
 
@@ -1412,7 +1374,6 @@
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/comp_obj/comp-intf_4.sts
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/comp_obj/comp-intf_5.sts
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/comp_obj/comp-intf_6.sts
-06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/comp_obj/comp-intf_7.sts
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/comp_obj/comp-intf_8.sts
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/decl_const/decl-const_0.sts
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/decl_const/decl-const_1.sts
@@ -1444,117 +1405,10 @@
 06.contexts_and_conversions/05.implicit_conversions/03.constant_narrowing_integer_conversion/decl_var/decl-var_8.sts
 
 # 13947 Object Literal of Interface Type is not implemented
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-nan.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_0.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_1.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_10.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_11.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_12.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_13.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_14.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_15.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_16.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_17.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_18.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_19.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_2.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_20.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_21.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_22.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_23.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_24.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_25.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_26.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_27.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_28.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_3.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_4.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_5.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_6.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_7.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_8.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf_9.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_0.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_1.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_2.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_3.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_4.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_5.sts
-06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/comp_obj/comp-intf-ident_6.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf-nan_0.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf-nan_1.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf-nan_2.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_0.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_1.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_10.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_11.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_12.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_13.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_14.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_15.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_16.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_17.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_18.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_19.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_2.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_20.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_21.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_22.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_23.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_24.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_25.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_26.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_27.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_28.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_3.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_4.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_5.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_6.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_7.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_8.sts
-06.contexts_and_conversions/05.implicit_conversions/04.boxing_conversion/comp_obj/comp-intf_9.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf-nan_0.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf-nan_1.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf-nan_2.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_0.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_1.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_10.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_11.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_12.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_13.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_14.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_15.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_16.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_17.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_18.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_19.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_2.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_20.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_21.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_22.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_23.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_24.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_25.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_26.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_3.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_4.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_5.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_6.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_7.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_8.sts
-06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/comp_obj/comp-intf_9.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_0.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_1.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_10.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_11.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_12.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_13.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_14.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_15.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_16.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_17.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_18.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_19.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_2.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_20.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_21.sts
@@ -1565,7 +1419,6 @@
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_6.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_7.sts
 06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_8.sts
-06.contexts_and_conversions/05.implicit_conversions/07.widening_reference_conversion/comp_obj/comp-intf_9.sts
 
 # 16325 unboxing in lambda parameter
 06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/call_lmbd/call-lmbd-nan_1.sts
@@ -1589,9 +1442,6 @@
 06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/call_lmbd/call-lmbd_8.sts
 06.contexts_and_conversions/05.implicit_conversions/05.unboxing_conversion/call_lmbd/call-lmbd_9.sts
 
-# 6.5.9 Constant String to Character Conversions not yet supported
-06.contexts_and_conversions/05.implicit_conversions/09.constant_string_to_char_conversion/str2char_7.sts
-
 # 18550 [ArkTS frontend] es2panda aborts on implicit number conversion
 06.contexts_and_conversions/05.implicit_conversions/02.widening_primitive_conversions/decl_const/decl-const_6.sts
 
@@ -1757,40 +1607,6 @@
 06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_obj/comp-obj_8.sts
 06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_obj/comp-obj_9.sts
 
-# 16523 tuple conversion should allow identical types only
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_3.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_4.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_5.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_6.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_7.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_8.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/assn_var/assn-var_n_9.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_3.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_4.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_5.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_6.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_7.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_8.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_arr/comp-arr_n_9.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_obj/comp-obj_n_3.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_obj/comp-obj_n_4.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_obj/comp-obj_n_5.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/comp_obj/comp-obj_n_6.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_3.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_4.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_5.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_6.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_7.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_8.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_field/decl-field_n_9.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_3.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_4.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_5.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_6.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_7.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_8.sts
-06.contexts_and_conversions/05.implicit_conversions/11.tuple_types_conversion/decl_var/decl-var_n_9.sts
-
 # 18763 es2panda aborts on for-of over a union type array
 08.statements/09.for_of_statements/for_of_28.sts
 17.experimental_features/04.iterable_types/it_11.sts
@@ -1853,6 +1669,10 @@
 07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/object_type_equality_operators/eq1_8.sts
 07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/object_type_equality_operators/ne1_10.sts
 07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/object_type_equality_operators/ne1_9.sts
+07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/type_parameter_equality_operators/eq1_7.sts
+07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/type_parameter_equality_operators/eq1_8.sts
+07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/type_parameter_equality_operators/ne1_10.sts
+07.expressions/25.equality_expressions/06.reference_equality_based_on_actual_type/type_parameter_equality_operators/ne1_9.sts
 
 # 16840
 10.interfaces/04.interface_members/methods_overriding.sts
@@ -1908,9 +1728,6 @@
 # es2panda: #16410 Cannot declare function with optional parameters (ambient declarations)
 14.ambient_declarations/ambient_declarations_7.sts
 
-# es2panda: #16411 Cannot declare final class
-14.ambient_declarations/ambient_declarations_57.sts
-
 # es2panda: #16415 Cannot declare static field in generic ambient class
 14.ambient_declarations/ambient_declarations_24.sts
 
@@ -1963,8 +1780,6 @@
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_39.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_40.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_41.sts
-15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_48.sts
-15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_50.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_7.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_1.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_variance_29.sts
@@ -1973,8 +1788,6 @@
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_13.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_15.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_17.sts
-15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_46.sts
-15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_48.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_10.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_35.sts
 15.semantic_rules/07.overloading_and_overriding/02.override-compatible_signatures/override_with_object_36.sts
@@ -2105,22 +1918,7 @@
 15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_and_decl_1.sts
 15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_and_decl_2.sts
 15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_and_decl_4.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_0.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_1.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_10.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_11.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_12.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_13.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_14.sts
 15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_18.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_2.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_3.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_4.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_5.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_6.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_7.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_8.sts
-15.semantic_rules/07.overloading_and_overriding/03.overloading_for_functions/function_import_neg_9.sts
 
 # 18550 es2panda aborts on implicit number conversion
 17.experimental_features/03.indexable_types/ind_interface_4.sts