xbintsc 0.3.81 → 0.5.6

package/runtime/xt_builtins.c

@@ -18,23 +18,22 @@
 
 xt_value xt_object_values(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
-  if (!XT_IS_OBJECT(value)) return result;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) {
-    if (XT_IS_STRING(obj->properties[i].key)) xt_array_push(result, obj->properties[i].value);
-  }
+  xt_value keys = xt_object_keys(value);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) xt_array_push(result, xt_get(value, array->items[i]));
   return result;
 }
 
 xt_value xt_object_entries(xt_value value) {
   xt_value result = xt_array_new(0, NULL);
-  if (!XT_IS_OBJECT(value)) return result;
-  xt_object *obj = (xt_object *)XT_GET_PTR(value);
-  for (uint32_t i = 0; i < obj->count; i++) {
-    if (!XT_IS_STRING(obj->properties[i].key)) continue;
+  xt_value keys = xt_object_keys(value);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) {
     xt_value pair = xt_array_new(0, NULL);
-    xt_array_push(pair, obj->properties[i].key);
-    xt_array_push(pair, obj->properties[i].value);
+    xt_array_push(pair, array->items[i]);
+    xt_array_push(pair, xt_get(value, array->items[i]));
     xt_array_push(result, pair);
   }
   return result;
@@ -45,8 +44,11 @@ xt_value xt_object_assign(int32_t argc, xt_value *argv) {
   xt_value target = argv[0];
   if (!XT_IS_OBJECT(target)) return target;
   for (int32_t i = 1; i < argc; i++) {
-    if (!XT_IS_OBJECT(argv[i])) continue;
-    xt_object *source = (xt_object *)XT_GET_PTR(argv[i]);
+    if (!XT_IS_OBJECT(argv[i]) && !XT_IS_ARRAY(argv[i]) && !XT_IS_STRING(argv[i])) continue;
+    /* Arrays and strings contribute their index properties, exactly like
+     * `{ ..."ab" }` / `Object.assign({}, [1, 2])` in ECMAScript. */
+    xt_value properties = xt_object_rest(argv[i], 0, NULL);
+    xt_object *source = (xt_object *)XT_GET_PTR(properties);
     for (uint32_t j = 0; j < source->count; j++) {
       xt_object_set(target, source->properties[j].key, source->properties[j].value);
     }
@@ -62,9 +64,77 @@ xt_value xt_object_spread(xt_value target, xt_value source) {
   return xt_object_assign(2, args);
 }
 
+/* True when `key` is one of the explicitly destructured properties. */
+static int xt_object_rest_excludes(xt_value key, int32_t argc, xt_value *argv) {
+  for (int32_t i = 0; i < argc; i++) {
+    if (xt_property_key_equals(key, argv[i])) return 1;
+  }
+  return 0;
+}
+
+static void xt_object_rest_copy(xt_value target, xt_value key, xt_value value, int32_t argc, xt_value *argv) {
+  if (xt_object_rest_excludes(key, argc, argv)) return;
+  xt_object_set(target, key, value);
+}
+
+/*
+ * `const { a, ...rest } = source` (and the assignment / parameter forms).
+ *
+ * Copies the *own enumerable* properties that the pattern did not name, in
+ * insertion order. Arrays and strings contribute their index properties, like
+ * ECMAScript; accessor properties are read through their getter, with the
+ * source as the receiver.
+ */
+xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv) {
+  if (source == XT_UNDEFINED || source == XT_NULL) {
+    xt_throw(xt_string_from_cstr("TypeError: Cannot destructure null or undefined"));
+    return XT_UNDEFINED;
+  }
+  xt_value result = xt_object_new();
+
+  if (XT_IS_ARRAY(source)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(source);
+    for (uint32_t i = 0; i < array->length; i++) {
+      char buffer[16];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), array->items[i], argc, argv);
+    }
+    return result;
+  }
+
+  if (XT_IS_STRING(source)) {
+    xt_string *string = (xt_string *)XT_GET_PTR(source);
+    uint32_t units = xt_string_utf16_length(string);
+    for (uint32_t i = 0; i < units; i++) {
+      char buffer[16];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_unit_value(string, (int32_t)i), argc, argv);
+    }
+    return result;
+  }
+
+  if (!XT_IS_OBJECT(source) && !XT_IS_FUNCTION(source)) return result;
+  xt_object *object = xt_as_object(source);
+  if (!object) return result;
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT && object->header.kind != XT_OBJECT_KIND_ERROR) {
+    /* Map/Set/Date/RegExp/Promise have no own enumerable string properties. */
+    return result;
+  }
+  for (uint32_t i = 0; i < object->count; i++) {
+    xt_property *property = &object->properties[i];
+    if (xt_object_rest_excludes(property->key, argc, argv)) continue;
+    xt_value value = property->value;
+    if (property->getter != XT_UNDEFINED && XT_IS_FUNCTION(property->getter)) {
+      value = xt_call_with_this(property->getter, source, 0, NULL);
+    }
+    xt_object_set(result, property->key, value);
+  }
+  return result;
+}
+
 xt_value xt_parse_int(int32_t argc, xt_value *argv) {
   xt_string *s = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
-  const char *p = s->data;
+  const char *p = xt_string_bytes(s);
   /* JavaScript `parseInt` semantics: skip leading whitespace, accept an
      optional sign, pick the radix (auto-detecting a `0x` prefix), read the
      longest run of valid digits and accumulate into a double. Accumulating as
@@ -107,9 +177,10 @@ xt_value xt_parse_int(int32_t argc, xt_value *argv) {
 
 xt_value xt_parse_float(int32_t argc, xt_value *argv) {
   xt_string *s = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
+  const char *bytes = xt_string_bytes(s);
   char *end = NULL;
-  double value = strtod(s->data, &end);
-  if (end == s->data) return xt_number(NAN);
+  double value = strtod(bytes, &end);
+  if (end == bytes) return xt_number(NAN);
   return xt_number(value);
 }
 
@@ -140,6 +211,7 @@ static int xt_uri_is_kept(const char *allowed, unsigned char c) {
 
 static xt_value xt_uri_encode(xt_value input, const char *allowed) {
   xt_string *s = xt_as_string(xt_to_string(input));
+  const char *bytes = xt_string_bytes(s);
   static const char hex[] = "0123456789ABCDEF";
   char *out = (char *)malloc((size_t)s->length * 3 + 1);
   if (!out) {
@@ -148,7 +220,7 @@ static xt_value xt_uri_encode(xt_value input, const char *allowed) {
   }
   size_t written = 0;
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     if (xt_uri_is_kept(allowed, c)) {
       out[written++] = (char)c;
     } else {
@@ -173,6 +245,7 @@ static int xt_hex_value(int c) {
  * escapes for reserved characters are copied through unchanged. */
 static xt_value xt_uri_decode(xt_value input, int component) {
   xt_string *s = xt_as_string(xt_to_string(input));
+  const char *bytes = xt_string_bytes(s);
   char *out = (char *)malloc((size_t)s->length + 1);
   if (!out) {
     fprintf(stderr, "xbintsc: out of memory\n");
@@ -181,22 +254,22 @@ static xt_value xt_uri_decode(xt_value input, int component) {
   size_t written = 0;
   uint32_t i = 0;
   while (i < s->length) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     if (c != '%') {
       out[written++] = (char)c;
       i++;
       continue;
     }
     if (i + 2 >= s->length) xt_throw_uri_error("URI malformed");
-    int h1 = xt_hex_value((unsigned char)s->data[i + 1]);
-    int h2 = xt_hex_value((unsigned char)s->data[i + 2]);
+    int h1 = xt_hex_value((unsigned char)bytes[i + 1]);
+    int h2 = xt_hex_value((unsigned char)bytes[i + 2]);
     if (h1 < 0 || h2 < 0) xt_throw_uri_error("URI malformed");
     unsigned char b = (unsigned char)((h1 << 4) | h2);
     if (b < 0x80) {
       if (!component && xt_uri_is_kept(";/?:@&=+$,#", b)) {
-        out[written++] = s->data[i];
-        out[written++] = s->data[i + 1];
-        out[written++] = s->data[i + 2];
+        out[written++] = bytes[i];
+        out[written++] = bytes[i + 1];
+        out[written++] = bytes[i + 2];
       } else {
         out[written++] = (char)b;
       }
@@ -213,9 +286,9 @@ static xt_value xt_uri_decode(xt_value input, int component) {
     for (int k = 1; k <= extra; k++) {
       uint32_t pos = i + (uint32_t)k * 3;
       if (pos + 2 >= s->length) xt_throw_uri_error("URI malformed");
-      if (s->data[pos] != '%') xt_throw_uri_error("URI malformed");
-      int c1 = xt_hex_value((unsigned char)s->data[pos + 1]);
-      int c2 = xt_hex_value((unsigned char)s->data[pos + 2]);
+      if (bytes[pos] != '%') xt_throw_uri_error("URI malformed");
+      int c1 = xt_hex_value((unsigned char)bytes[pos + 1]);
+      int c2 = xt_hex_value((unsigned char)bytes[pos + 2]);
       if (c1 < 0 || c2 < 0) xt_throw_uri_error("URI malformed");
       unsigned char cb = (unsigned char)((c1 << 4) | c2);
       if ((cb & 0xC0) != 0x80) xt_throw_uri_error("URI malformed");
@@ -322,9 +395,9 @@ xt_value xt_in(xt_value key, xt_value value) {
     if (xt_is_symbol(key)) return XT_FALSE;
     xt_string *s = xt_as_string(value);
     xt_string *k = xt_as_string(xt_to_string(key));
-    if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return XT_TRUE;
+    if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
     int32_t index = xt_to_int32(key);
-    return xt_bool(index >= 0 && (uint32_t)index < s->length);
+    return xt_bool(index >= 0 && (uint32_t)index < xt_string_utf16_length(s));
   }
   return XT_FALSE;
 }
@@ -375,6 +448,9 @@ xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
   function->properties = NULL;
   function->environment = NULL;
   function->prototype = XT_UNDEFINED;
+  function->is_generator = 0;
+  function->is_async = 0;
+  function->builtin_name = NULL;
   if (env_count > 0) {
     function->environment = (xt_value *)malloc(sizeof(xt_value) * (size_t)env_count);
     for (int32_t i = 0; i < env_count; i++) function->environment[i] = env[i];
@@ -395,6 +471,9 @@ xt_value xt_call_with_this(xt_value value, xt_value thisValue, int32_t argc, xt_
   /* Calling a generator function returns a suspended generator instead of
    * running the body. */
   if (function->is_generator) return xt_generator_new(value, thisValue, argc, argv);
+  /* An `async` function runs its body on a coroutine and returns a promise,
+   * which may already be settled or may resolve after an event-loop turn. */
+  if (function->is_async) return xt_async_call(value, thisValue, argc, argv);
   /* The closure value itself is threaded through as `env` so the callee can
    * read its captures with xt_closure_env(env, i). */
   return function->code(thisValue, value, argc, argv);
@@ -407,11 +486,6 @@ xt_value xt_function_set_prototype(xt_value value, xt_value proto) {
   return value;
 }
 
-xt_value xt_function_set_generator(xt_value value) {
-  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_generator = 1;
-  return value;
-}
-
 xt_value xt_function_get_prototype(xt_value value) {
   if (XT_IS_FUNCTION(value)) return ((xt_function *)XT_GET_PTR(value))->prototype;
   return XT_UNDEFINED;
@@ -426,26 +500,78 @@ xt_value xt_new(xt_value ctor, int32_t argc, xt_value *argv) {
   xt_value proto = function->prototype;
   xt_value instance = xt_object_new_with_proto(XT_IS_OBJECT(proto) ? proto : XT_UNDEFINED);
   xt_value result = function->code(instance, ctor, argc, argv);
-  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result)) return result;
+  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result) || XT_IS_FUNCTION(result)) return result;
   return instance;
 }
 
 xt_value xt_instance_of(xt_value value, xt_value ctor) {
   if (!XT_IS_FUNCTION(ctor)) return XT_FALSE;
   xt_value proto = ((xt_function *)XT_GET_PTR(ctor))->prototype;
-  if (!XT_IS_OBJECT(proto)) return XT_FALSE;
-  if (!XT_IS_OBJECT(value)) return XT_FALSE;
-  xt_object *cur = (xt_object *)XT_GET_PTR(value);
-  xt_object *target = (xt_object *)XT_GET_PTR(proto);
-  cur = (xt_object *)XT_GET_PTR(XT_IS_OBJECT(cur->prototype) ? cur->prototype : XT_UNDEFINED);
-  while (cur) {
-    if (cur == target) return XT_TRUE;
-    if (!XT_IS_OBJECT(cur->prototype)) break;
-    cur = (xt_object *)XT_GET_PTR(cur->prototype);
+  if (XT_IS_OBJECT(proto) || XT_IS_ARRAY(proto) || XT_IS_FUNCTION(proto)) {
+    /* Walk the value's [[Prototype]] chain. `xt_object_get_prototype` knows the
+     * layout of every kind (arrays carry a prototype field; Map/Set/Date/... use
+     * their built-in prototype), so this is safe for containers too. */
+    xt_value cursor = xt_object_get_prototype(value);
+    while (cursor != XT_UNDEFINED && cursor != XT_NULL) {
+      if (cursor == proto) return XT_TRUE;
+      cursor = xt_object_get_prototype(cursor);
+    }
   }
   return XT_FALSE;
 }
 
+/*
+ * `value instanceof Array` (and the rest of the built-in constructors).
+ *
+ * The codegen recognises the direct spelling and asks this helper instead of
+ * materialising the constructor value; an alias (`const A = Array`) goes
+ * through the ordinary prototype chain in `xt_instance_of`. Ids match
+ * `BUILTIN_INSTANCEOF` in `src/codegen/generator/tables.ts`; 16..24 map onto
+ * the runtime's `XT_TA_*` order (Uint8Array first).
+ */
+enum {
+  XT_INSTANCE_ARRAY = 0,
+  XT_INSTANCE_OBJECT = 1,
+  XT_INSTANCE_FUNCTION = 2,
+  XT_INSTANCE_MAP = 3,
+  XT_INSTANCE_SET = 4,
+  XT_INSTANCE_DATE = 5,
+  XT_INSTANCE_REGEXP = 6,
+  XT_INSTANCE_PROMISE = 7,
+  XT_INSTANCE_TYPED_ARRAY_FIRST = 16,
+  XT_INSTANCE_TYPED_ARRAY_LAST = 24
+};
+
+static int xt_value_has_kind(xt_value value, uint8_t kind) {
+  return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == kind;
+}
+
+xt_value xt_instance_of_builtin(xt_value value, int32_t id) {
+  switch (id) {
+    case XT_INSTANCE_ARRAY:
+      return xt_bool(XT_IS_ARRAY(value));
+    case XT_INSTANCE_OBJECT:
+      return xt_bool(XT_IS_OBJECT(value) || XT_IS_ARRAY(value) || XT_IS_FUNCTION(value));
+    case XT_INSTANCE_FUNCTION:
+      return xt_bool(XT_IS_FUNCTION(value));
+    case XT_INSTANCE_MAP:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_MAP));
+    case XT_INSTANCE_SET:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_SET));
+    case XT_INSTANCE_DATE:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_DATE));
+    case XT_INSTANCE_REGEXP:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_REGEXP));
+    case XT_INSTANCE_PROMISE:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_PROMISE));
+    default:
+      if (id >= XT_INSTANCE_TYPED_ARRAY_FIRST && id <= XT_INSTANCE_TYPED_ARRAY_LAST) {
+        return xt_bool(xt_typed_array_kind_of(value) == id - XT_INSTANCE_TYPED_ARRAY_FIRST);
+      }
+      return XT_FALSE;
+  }
+}
+
 xt_value xt_closure_env(xt_value value, int32_t index) {
   if (!XT_IS_FUNCTION(value)) return XT_UNDEFINED;
   xt_function *function = (xt_function *)XT_GET_PTR(value);