@scriptc/compiler 0.4.0 → 0.4.1

package/dist/ir/validate.js

@@ -1458,10 +1458,11 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     "while",
                 ]);
                 if (e.generatorDelegate) {
-                    if (!fn.generator || fn.async)
-                        err("delegation sequence outside a synchronous generator", e.loc);
+                    if (!fn.generator)
+                        err("delegation sequence outside a generator", e.loc);
                     allowed.add("return");
                     allowed.add("throw");
+                    allowed.add("rethrow");
                     allowed.add("runtimeFence");
                     allowed.add("tryCatch");
                 }
@@ -2175,23 +2176,35 @@ function validateFunction(fn, functions, ffiByName, classes, records, recordVali
                     if (e.method === "sortDense" && e.args[1]?.kind !== "boolLit")
                         err("arrIntrinsic sortDense owned flag must be a boolean literal", e.loc);
                     // A recognized comparator's key order: [order] for numbers,
-                    // [order, key reader] for record and class elements.
+                    // [order, key reader] for record and class elements. An order
+                    // from 2 carries several keys (sortKeysOrder): the key count
+                    // (2..8) in the low byte, a descending bit per key from bit 8, and
+                    // a reader that also takes the key's index.
                     const order = e.args[2];
                     if (order) {
-                        if (order.kind !== "numLit" || (order.value !== 1 && order.value !== -1))
-                            err(`arrIntrinsic ${e.method} key order must be the literal 1 or -1`, e.loc);
+                        const count = order.kind === "numLit" && order.value >= 2 ? order.value & 0xff : 1;
+                        if (order.kind !== "numLit" ||
+                            (order.value !== 1 &&
+                                order.value !== -1 &&
+                                !(Number.isInteger(order.value) &&
+                                    count >= 2 &&
+                                    count <= 8 &&
+                                    (order.value >> 8) >> count === 0)))
+                            err(`arrIntrinsic ${e.method} key order must be 1, -1 or a key-chain order`, e.loc);
                         const key = e.args[3]?.type;
                         if (elem.kind === "f64"
-                            ? key !== undefined
+                            ? key !== undefined || count > 1
                             : elem.kind !== "record" && elem.kind !== "object")
                             err(`arrIntrinsic ${e.method} key order on ${elem.kind} elements`, e.loc);
+                        const params = count > 1 ? 2 : 1;
                         if (elem.kind !== "f64" &&
                             (!key ||
                                 key.kind !== "func" ||
-                                key.params.length !== 1 ||
+                                key.params.length !== params ||
                                 !typeEquals(key.params[0], elem) ||
+                                (params === 2 && key.params[1].kind !== "f64") ||
                                 key.ret.kind !== "f64"))
-                            err(`arrIntrinsic ${e.method} key reader must be (elem) => number`, e.loc);
+                            err(`arrIntrinsic ${e.method} key reader must be (elem${params === 2 ? ", number" : ""}) => number`, e.loc);
                     }
                 }
                 if (e.method === "getNumber" && elem.kind !== "f64") {