xbintsc 0.3.87 → 0.5.6

package/src/codegen/generator/tables.ts

@@ -253,6 +253,23 @@ export const NAMESPACE_STATICS: Record<string, string> = {
   ...TYPED_ARRAY_STATICS,
 };
 
+/** The well-known symbols exposed as properties of the `Symbol` namespace. */
+export const SYMBOL_WELL_KNOWN = new Set<string>([
+  "asyncIterator",
+  "hasInstance",
+  "isConcatSpreadable",
+  "iterator",
+  "match",
+  "matchAll",
+  "replace",
+  "search",
+  "species",
+  "split",
+  "toPrimitive",
+  "toStringTag",
+  "unscopables",
+]);
+
 /** Namespace identifiers whose property access maps to a runtime getter. */
 export const NAMESPACE_PROPERTIES: Record<string, string> = {
   process: "xt_process_get",
@@ -262,7 +279,7 @@ export const NAMESPACE_PROPERTIES: Record<string, string> = {
 
 /** Global constructors called as `new X(...)` (all have signature `(i32, i64*)`). */
 export const CTOR_FUNCTIONS: Record<string, string> = {
-  Array: "xt_array_new",
+  Array: "xt_array_ctor",
   Map: "xt_map_ctor",
   Set: "xt_set_ctor",
   Date: "xt_date_ctor",
@@ -281,6 +298,30 @@ export const CTOR_FUNCTIONS: Record<string, string> = {
   ...TYPED_ARRAY_CTORS,
 };
 
+/**
+ * Built-in constructors that are also ordinary first-class values. The codegen
+ * lowers a bare reference (`const A = Array`) to `xt_builtin_constructor`, which
+ * returns a cached function with `name`/`length`, a `prototype` and the
+ * constructor's statics (`A.isArray`, `A.from`, ...).
+ */
+export const FIRST_CLASS_CONSTRUCTORS = new Set<string>([
+  "Array",
+  "Object",
+  "Function",
+  "Map",
+  "Set",
+  "Date",
+  "RegExp",
+  "Promise",
+  ...Object.keys(TYPED_ARRAYS),
+  ...Object.keys(ERROR_CONSTRUCTORS),
+  "Number",
+  "String",
+  "Boolean",
+  "BigInt",
+  "Symbol",
+]);
+
 export const BUILTIN_METHODS = new Set<string>([
   "push", "pop", "shift", "unshift", "join", "slice", "indexOf", "includes", "map", "forEach", "filter",
   "reduce", "concat", "reverse", "charAt", "charCodeAt", "substring", "substr", "split", "toUpperCase",
@@ -394,7 +435,7 @@ export function utf8Bytes(text: string): number[] {
   if (!hasMultiByteUnit(text)) {
     const bytes: number[] = [];
     for (let index = 0; index < text.length; index++) bytes.push(text.charCodeAt(index) & 0xff);
-    return bytes;
+    return combineSurrogateBytes(bytes);
   }
   const bytes: number[] = [];
   const length = text.length;
@@ -420,6 +461,47 @@ function hasMultiByteUnit(text: string): boolean {
   return false;
 }
 
+/**
+ * Join adjacent WTF-8 surrogate halves into one four-byte sequence.
+ *
+ * A literal such as `"\uD83D\uDE00"` scans to two separate three-byte
+ * escapes. JavaScript's string value is one code point, so the emitted bytes
+ * must be the four-byte UTF-8 form (and a lone escape must stay three bytes,
+ * which is why this runs after scanning rather than per escape).
+ */
+function combineSurrogateBytes(bytes: number[]): number[] {
+  const out: number[] = [];
+  for (let index = 0; index < bytes.length; index++) {
+    if (
+      index + 5 < bytes.length &&
+      bytes[index] === 0xed &&
+      bytes[index + 1]! >= 0xa0 &&
+      bytes[index + 1]! <= 0xaf &&
+      bytes[index + 2]! >= 0x80 &&
+      bytes[index + 2]! <= 0xbf &&
+      bytes[index + 3] === 0xed &&
+      bytes[index + 4]! >= 0xb0 &&
+      bytes[index + 4]! <= 0xbf &&
+      bytes[index + 5]! >= 0x80 &&
+      bytes[index + 5]! <= 0xbf
+    ) {
+      const high = ((bytes[index]! & 0x0f) << 12) | ((bytes[index + 1]! & 0x3f) << 6) | (bytes[index + 2]! & 0x3f);
+      const low = ((bytes[index + 3]! & 0x0f) << 12) | ((bytes[index + 4]! & 0x3f) << 6) | (bytes[index + 5]! & 0x3f);
+      const code = 0x10000 + ((high - 0xd800) << 10) + (low - 0xdc00);
+      out.push(
+        0xf0 | (code >> 18),
+        0x80 | ((code >> 12) & 0x3f),
+        0x80 | ((code >> 6) & 0x3f),
+        0x80 | (code & 0x3f),
+      );
+      index += 5;
+      continue;
+    }
+    out.push(bytes[index]!);
+  }
+  return out;
+}
+
 export function escapeBytes(bytes: readonly number[]): string {
   return bytes
     .map((byte) => {

package/src/driver/compiler.ts

@@ -42,7 +42,7 @@ import {
  * `package.json`); a stale version would let an upgraded compiler reuse binaries
  * produced by the previous one.
  */
-export const COMPILER_VERSION = "0.3.87";
+export const COMPILER_VERSION = "0.5.6";
 
 export type EmitKind = "exe" | "obj" | "ir";
 
@@ -444,11 +444,14 @@ export const RUNTIME_SOURCES = [
   "xt_stdlib.c",
   "xt_stdlib2.c",
   "xt_promise.c",
+  "xt_async.c",
   "xt_loop.c",
   "xt_generator.c",
+  "xt_coroutine.c",
   "xt_fetch.c",
   "xt_symbol.c",
   "xt_builtins.c",
+  "xt_constructors.c",
   "xt_io.c",
 ] as const;