xbintsc 0.5.6 → 0.5.20

package/runtime/xt_stdlib2/json.inc

@@ -133,50 +133,152 @@ static xt_value xt_json_parse_value(xt_json_cursor *c) {
   return xt_json_parse_number(c);
 }
 
+/* Reviver walk: rebuild each container bottom-up, then pass the value to the
+ * user callback with its holder as `this`. Returning undefined deletes an
+ * object property / array element, exactly like the specification. */
+static xt_value xt_json_revive(xt_value holder, xt_value key, xt_value reviver) {
+  xt_value value = xt_get(holder, key);
+  if (XT_IS_ARRAY(value)) {
+    xt_array *array = xt_as_array(value);
+    for (uint32_t i = 0; i < array->length; i++) {
+      /* Reviver keys are strings even for array indices. */
+      char keyBuffer[16];
+      snprintf(keyBuffer, sizeof(keyBuffer), "%u", i);
+      xt_value index = xt_string_from_cstr(keyBuffer);
+      xt_value updated = xt_json_revive(value, index, reviver);
+      if (updated == XT_UNDEFINED) xt_delete(value, index);
+      else xt_set(value, index, updated);
+    }
+  } else if (XT_IS_OBJECT(value)) {
+    xt_value keys = xt_object_keys(value);
+    xt_array *list = xt_as_array(keys);
+    if (list) {
+      for (uint32_t i = 0; i < list->length; i++) {
+        xt_value childKey = list->items[i];
+        xt_value updated = xt_json_revive(value, childKey, reviver);
+        if (updated == XT_UNDEFINED) xt_delete(value, childKey);
+        else xt_object_set(value, childKey, updated);
+      }
+    }
+  }
+  xt_value args[2] = {key, value};
+  return xt_call_with_this(reviver, holder, 2, args);
+}
+
 xt_value xt_json_parse(int32_t argc, xt_value *argv) {
   xt_value input = xt_to_string(xt_arg_at(argc, argv, 0));
   xt_string *s = xt_as_string(input);
   if (!s) return XT_UNDEFINED;
   xt_json_cursor cursor = {xt_string_bytes(s), s->length, 0};
-  return xt_json_parse_value(&cursor);
+  xt_value parsed = xt_json_parse_value(&cursor);
+  xt_value reviver = xt_arg_at(argc, argv, 1);
+  if (!XT_IS_FUNCTION(reviver)) return parsed;
+  xt_value holder = xt_object_new();
+  xt_object_set(holder, xt_string_from_cstr(""), parsed);
+  return xt_json_revive(holder, xt_string_from_cstr(""), reviver);
 }
 
-static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_value *out);
+static void xt_json_stringify_value(xt_value value, xt_value indent, int depth, xt_value *out);
 
-static void xt_json_indent(xt_value *out, int indent, int depth) {
-  if (indent <= 0) return;
+/* The indentation unit for the `space` argument: up to 10 spaces for a
+ * number, or the first 10 UTF-16 code units of a string (any characters,
+ * not just spaces), matching JSON.stringify. An empty string means compact. */
+static xt_value xt_json_space_unit(xt_value space) {
+  if (XT_IS_NUMBER(space)) {
+    int count = xt_to_int32(space);
+    if (count < 0) count = 0;
+    if (count > 10) count = 10;
+    char spaces[10];
+    memset(spaces, ' ', (size_t)count);
+    return xt_string_new(spaces, (size_t)count);
+  }
+  if (XT_IS_STRING(space)) {
+    xt_string *s = xt_as_string(space);
+    const char *bytes = xt_string_bytes(s);
+    size_t offset = 0;
+    size_t end = 0;
+    uint32_t units = 0;
+    while (offset < s->length && units < 10) {
+      size_t width = 0;
+      uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+      units += code >= 0x10000 ? 2 : 1;
+      offset += width;
+      if (units <= 10) end = offset;
+    }
+    return xt_string_new(bytes, end);
+  }
+  return xt_string_from_cstr("");
+}
+
+static int xt_json_indented(xt_value unit) {
+  return XT_IS_STRING(unit) && xt_as_string(unit)->length > 0;
+}
+
+static void xt_json_indent(xt_value *out, xt_value unit, int depth) {
+  if (!xt_json_indented(unit)) return;
   *out = xt_add(*out, xt_string_from_cstr("\n"));
-  for (int i = 0; i < indent * depth; i++) *out = xt_add(*out, xt_string_from_cstr(" "));
+  for (int i = 0; i < depth; i++) *out = xt_add(*out, unit);
+}
+
+/* Containers on the current serialization path. A repeated pointer is a cycle;
+ * serializing it would recurse until the native stack overflowed (a hard crash,
+ * not the TypeError the platform throws). */
+static xt_value *xt_json_path = NULL;
+static uint32_t xt_json_path_count = 0;
+static uint32_t xt_json_path_capacity = 0;
+
+static void xt_json_enter(xt_value value) {
+  for (uint32_t i = 0; i < xt_json_path_count; i++) {
+    if (xt_json_path[i] == value) {
+      xt_value message = xt_string_from_cstr("Converting circular structure to JSON");
+      xt_throw(xt_type_error_ctor(1, &message));
+    }
+  }
+  if (xt_json_path_count >= xt_json_path_capacity) {
+    uint32_t capacity = xt_json_path_capacity == 0 ? 16 : xt_json_path_capacity * 2;
+    xt_value *path = (xt_value *)realloc(xt_json_path, sizeof(xt_value) * capacity);
+    if (!path) abort();
+    xt_json_path = path;
+    xt_json_path_capacity = capacity;
+  }
+  xt_json_path[xt_json_path_count++] = value;
+}
+
+static void xt_json_leave(void) {
+  if (xt_json_path_count > 0) xt_json_path_count--;
 }
 
-static void xt_json_stringify_array(xt_value value, int indent, int depth, xt_value *out) {
+static void xt_json_stringify_array(xt_value value, xt_value indent, int depth, xt_value *out) {
   xt_array *array = xt_as_array(value);
   if (!array || array->length == 0) { *out = xt_add(*out, xt_string_from_cstr("[]")); return; }
   *out = xt_add(*out, xt_string_from_cstr("["));
+  xt_json_enter(value);
   for (uint32_t i = 0; i < array->length; i++) {
     if (i > 0) *out = xt_add(*out, xt_string_from_cstr(","));
     xt_json_indent(out, indent, depth + 1);
     xt_json_stringify_value(array->items[i], indent, depth + 1, out);
   }
   xt_json_indent(out, indent, depth);
+  xt_json_leave();
   *out = xt_add(*out, xt_string_from_cstr("]"));
 }
 
-static void xt_json_stringify_object(xt_value value, int indent, int depth, xt_value *out) {
+static void xt_json_stringify_object(xt_value value, xt_value indent, int depth, xt_value *out) {
   xt_value keys = xt_object_keys(value);
   xt_array *array = xt_as_array(keys);
   if (!array) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
   int any = 0;
   for (uint32_t i = 0; i < array->length; i++) {
-    xt_value item = xt_object_get(value, array->items[i]);
+    xt_value item = xt_get(value, array->items[i]);
     if (item != XT_UNDEFINED && !XT_IS_FUNCTION(item) && !xt_is_symbol(item)) { any = 1; break; }
   }
   if (!any) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
   *out = xt_add(*out, xt_string_from_cstr("{"));
+  xt_json_enter(value);
   int written = 0;
   for (uint32_t i = 0; i < array->length; i++) {
     xt_value key = array->items[i];
-    xt_value item = xt_object_get(value, key);
+    xt_value item = xt_get(value, key);
     /* `undefined`, functions and symbols are omitted from objects. */
     if (item == XT_UNDEFINED || XT_IS_FUNCTION(item) || xt_is_symbol(item)) continue;
     if (written > 0) *out = xt_add(*out, xt_string_from_cstr(","));
@@ -185,20 +287,21 @@ static void xt_json_stringify_object(xt_value value, int indent, int depth, xt_v
     *out = xt_add(*out, xt_string_from_cstr("\""));
     *out = xt_add(*out, key);
     *out = xt_add(*out, xt_string_from_cstr("\":"));
-    if (indent > 0) *out = xt_add(*out, xt_string_from_cstr(" "));
+    if (xt_json_indented(indent)) *out = xt_add(*out, xt_string_from_cstr(" "));
     xt_json_stringify_value(item, indent, depth + 1, out);
   }
   xt_json_indent(out, indent, depth);
+  xt_json_leave();
   *out = xt_add(*out, xt_string_from_cstr("}"));
 }
 
-static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_value *out) {
+static void xt_json_stringify_value(xt_value value, xt_value indent, int depth, xt_value *out) {
   if (value == XT_UNDEFINED || value == XT_NULL || XT_IS_FUNCTION(value) || xt_is_symbol(value)) {
     *out = xt_add(*out, xt_string_from_cstr("null"));
     return;
   }
   if (XT_IS_BIGINT(value)) {
-    xt_throw(xt_string_from_cstr("TypeError: Do not know how to serialize a BigInt"));
+    xt_throw(xt_error_from_message("TypeError: Do not know how to serialize a BigInt"));
     return;
   }
   if (XT_IS_BOOL(value)) { *out = xt_add(*out, value == XT_TRUE ? xt_string_from_cstr("true") : xt_string_from_cstr("false")); return; }
@@ -237,19 +340,207 @@ static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_va
     return;
   }
   if (XT_IS_ARRAY(value)) { xt_json_stringify_array(value, indent, depth, out); return; }
-  if (XT_IS_OBJECT(value)) { xt_json_stringify_object(value, indent, depth, out); return; }
+  if (XT_IS_OBJECT(value)) {
+    /* Map/Set/Date/RegExp/Promise/generators are not property-bag objects;
+     * handing them to xt_json_stringify_object reads their fields as a property
+     * table and crashed with an access violation. JSON sees no enumerable own
+     * properties on the first group and calls Date.prototype.toJSON. */
+    xt_object *object = (xt_object *)XT_GET_PTR(value);
+    switch (object->header.kind) {
+      case XT_OBJECT_KIND_MAP:
+      case XT_OBJECT_KIND_SET:
+      case XT_OBJECT_KIND_REGEXP:
+      case XT_OBJECT_KIND_PROMISE:
+      case XT_OBJECT_KIND_GENERATOR:
+      case XT_OBJECT_KIND_ITERATOR:
+      case XT_OBJECT_KIND_ASYNC:
+        *out = xt_add(*out, xt_string_from_cstr("{}"));
+        return;
+      case XT_OBJECT_KIND_DATE: {
+        xt_value time = xt_call_method(value, xt_string_from_cstr("getTime"), 0, NULL);
+        if (isnan(xt_to_number(time))) {
+          *out = xt_add(*out, xt_string_from_cstr("null"));
+          return;
+        }
+        xt_value text = xt_call_method(value, xt_string_from_cstr("toJSON"), 0, NULL);
+        xt_json_stringify_value(text, indent, depth, out);
+        return;
+      }
+      default:
+        break;
+    }
+    xt_json_stringify_object(value, indent, depth, out);
+    return;
+  }
   *out = xt_add(*out, xt_string_from_cstr("null"));
 }
 
+/* -- replacer-aware stringify -------------------------------------------- */
+/*
+ * The replacer overload needs the holder and key of every value, so it gets a
+ * separate walk instead of complicating the fast path. It also calls `toJSON`
+ * and filters object keys through an array replacer.
+ */
+typedef struct {
+  xt_value replacer;
+  xt_value indent;
+  xt_value *path;
+  uint32_t path_count;
+  uint32_t path_capacity;
+} xt_json_replacer_context;
+
+static void xt_json_replacer_enter(xt_json_replacer_context *ctx, xt_value value) {
+  for (uint32_t i = 0; i < ctx->path_count; i++) {
+    if (ctx->path[i] == value) {
+      xt_value message = xt_string_from_cstr("Converting circular structure to JSON");
+      xt_throw(xt_type_error_ctor(1, &message));
+    }
+  }
+  if (ctx->path_count >= ctx->path_capacity) {
+    uint32_t capacity = ctx->path_capacity == 0 ? 16 : ctx->path_capacity * 2;
+    xt_value *path = (xt_value *)realloc(ctx->path, sizeof(xt_value) * capacity);
+    if (!path) abort();
+    ctx->path = path;
+    ctx->path_capacity = capacity;
+  }
+  ctx->path[ctx->path_count++] = value;
+}
+
+static void xt_json_replacer_leave(xt_json_replacer_context *ctx) {
+  if (ctx->path_count > 0) ctx->path_count--;
+}
+
+static void xt_json_replacer_indent(xt_json_replacer_context *ctx, int depth, xt_value *out) {
+  xt_json_indent(out, ctx->indent, depth);
+}
+
+static int xt_json_replacer_allows(xt_value replacer, xt_value key) {
+  if (!XT_IS_ARRAY(replacer)) return 1;
+  xt_array *allowed = xt_as_array(replacer);
+  for (uint32_t i = 0; i < allowed->length; i++) {
+    xt_value item = allowed->items[i];
+    if (!XT_IS_STRING(item) && !XT_IS_NUMBER(item)) continue;
+    xt_value text = xt_to_string(item);
+    xt_string *a = xt_as_string(text);
+    xt_string *b = xt_as_string(key);
+    if (a && b && xt_string_equals(a, b)) return 1;
+  }
+  return 0;
+}
+
+static int xt_json_replacer_write(xt_json_replacer_context *ctx, xt_value holder, xt_value key,
+                                  int depth, xt_value *out);
+
+static int xt_json_replacer_container(xt_json_replacer_context *ctx, xt_value value, int depth,
+                                      xt_value *out) {
+  xt_json_replacer_enter(ctx, value);
+  if (XT_IS_ARRAY(value)) {
+    xt_array *array = xt_as_array(value);
+    *out = xt_add(*out, xt_string_from_cstr("["));
+    for (uint32_t i = 0; i < array->length; i++) {
+      if (i > 0) *out = xt_add(*out, xt_string_from_cstr(","));
+      xt_json_replacer_indent(ctx, depth + 1, out);
+      char keyBuffer[16];
+      snprintf(keyBuffer, sizeof(keyBuffer), "%u", i);
+      xt_value temporary = xt_string_from_cstr("");
+      int wrote = xt_json_replacer_write(ctx, value, xt_string_from_cstr(keyBuffer), depth + 1,
+                                         &temporary);
+      *out = xt_add(*out, wrote ? temporary : xt_string_from_cstr("null"));
+    }
+    xt_json_replacer_indent(ctx, depth, out);
+    xt_json_replacer_leave(ctx);
+    *out = xt_add(*out, xt_string_from_cstr("]"));
+    return 1;
+  }
+
+  xt_value keys = xt_object_keys(value);
+  xt_array *list = xt_as_array(keys);
+  *out = xt_add(*out, xt_string_from_cstr("{"));
+  int written = 0;
+  if (list) {
+    for (uint32_t i = 0; i < list->length; i++) {
+      xt_value childKey = list->items[i];
+      if (!xt_json_replacer_allows(ctx->replacer, childKey)) continue;
+      xt_value temporary = xt_string_from_cstr("");
+      int wrote = xt_json_replacer_write(ctx, value, childKey, depth + 1, &temporary);
+      if (!wrote) continue;
+      if (written > 0) *out = xt_add(*out, xt_string_from_cstr(","));
+      written++;
+      xt_json_replacer_indent(ctx, depth + 1, out);
+      *out = xt_add(*out, xt_string_from_cstr("\""));
+      *out = xt_add(*out, childKey);
+      *out = xt_add(*out, xt_string_from_cstr("\":"));
+      if (xt_json_indented(ctx->indent)) *out = xt_add(*out, xt_string_from_cstr(" "));
+      *out = xt_add(*out, temporary);
+    }
+  }
+  xt_json_replacer_indent(ctx, depth, out);
+  xt_json_replacer_leave(ctx);
+  *out = xt_add(*out, xt_string_from_cstr("}"));
+  return 1;
+}
+
+static int xt_json_replacer_write(xt_json_replacer_context *ctx, xt_value holder, xt_value key,
+                                  int depth, xt_value *out) {
+  xt_value value = xt_get(holder, key);
+  if (XT_IS_FUNCTION(ctx->replacer)) {
+    xt_value args[2] = {key, value};
+    value = xt_call_with_this(ctx->replacer, holder, 2, args);
+  }
+  if (xt_is_date(value)) {
+    value = xt_call_method(value, xt_string_from_cstr("toJSON"), 1, &key);
+  } else if (XT_IS_ARRAY(value) ||
+             (XT_IS_OBJECT(value) &&
+              (((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_OBJECT ||
+               ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_ERROR))) {
+    xt_value toJSON = XT_IS_ARRAY(value) ? xt_get(value, xt_string_from_cstr("toJSON"))
+                                         : xt_object_get(value, xt_string_from_cstr("toJSON"));
+    if (XT_IS_FUNCTION(toJSON)) {
+      xt_value args[1] = {key};
+      value = xt_call_with_this(toJSON, value, 1, args);
+    }
+  }
+  if (value == XT_UNDEFINED || XT_IS_FUNCTION(value) || xt_is_symbol(value)) return 0;
+  if (XT_IS_BIGINT(value)) {
+    xt_value message = xt_string_from_cstr("Do not know how to serialize a BigInt");
+    xt_throw(xt_type_error_ctor(1, &message));
+  }
+  if (XT_IS_ARRAY(value)) return xt_json_replacer_container(ctx, value, depth, out);
+  if (XT_IS_OBJECT(value)) {
+    int kind = ((xt_object *)XT_GET_PTR(value))->header.kind;
+    if (kind == XT_OBJECT_KIND_MAP || kind == XT_OBJECT_KIND_SET ||
+        kind == XT_OBJECT_KIND_REGEXP || kind == XT_OBJECT_KIND_PROMISE ||
+        kind == XT_OBJECT_KIND_GENERATOR || kind == XT_OBJECT_KIND_ITERATOR ||
+        kind == XT_OBJECT_KIND_ASYNC) {
+      *out = xt_add(*out, xt_string_from_cstr("{}"));
+      return 1;
+    }
+    return xt_json_replacer_container(ctx, value, depth, out);
+  }
+  xt_json_stringify_value(value, ctx->indent, depth, out);
+  return 1;
+}
+
 xt_value xt_json_stringify(int32_t argc, xt_value *argv) {
-  int indent = 0;
-  xt_value space = xt_arg_at(argc, argv, 1);
-  if (XT_IS_NUMBER(space)) indent = xt_to_int32(space);
-  else if (XT_IS_STRING(space)) indent = (int)xt_string_utf16_length((xt_string *)XT_GET_PTR(space));
-  if (indent < 0) indent = 0;
-  if (indent > 10) indent = 10;
   xt_value value = xt_arg_at(argc, argv, 0);
   if (value == XT_UNDEFINED || XT_IS_FUNCTION(value) || xt_is_symbol(value)) return XT_UNDEFINED;
+  /* Signature: stringify(value, replacer, space). The replacer is argv[1] and
+   * the indentation is argv[2]; reading argv[1] as `space` silently ignored
+   * `JSON.stringify(value, null, 2)`. */
+  xt_value indent = xt_json_space_unit(xt_arg_at(argc, argv, 2));
+  xt_value replacer = xt_arg_at(argc, argv, 1);
+  if (XT_IS_FUNCTION(replacer) || XT_IS_ARRAY(replacer)) {
+    xt_json_replacer_context context = {replacer, indent, NULL, 0, 0};
+    xt_value wrapper = xt_object_new();
+    xt_object_set(wrapper, xt_string_from_cstr(""), value);
+    xt_value out = xt_string_from_cstr("");
+    int wrote = xt_json_replacer_write(&context, wrapper, xt_string_from_cstr(""), 0, &out);
+    free(context.path);
+    return wrote ? out : XT_UNDEFINED;
+  }
+  /* A caught circular-structure error longjmps past xt_json_leave; start every
+   * top-level serialization with a clean path. */
+  xt_json_path_count = 0;
   xt_value out = xt_string_from_cstr("");
   xt_json_stringify_value(value, indent, 0, &out);
   return out;

package/runtime/xt_stdlib2/number-string-statics.inc

@@ -60,7 +60,7 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
       int32_t code = xt_to_int32(argv[i]);
       if (code < 0 || code > 0x10FFFF) {
         free(out);
-        xt_throw(xt_string_from_cstr("RangeError: Invalid code point"));
+        xt_throw(xt_error_from_message("RangeError: Invalid code point"));
         return XT_UNDEFINED;
       }
       length += xt_utf8_encode((uint32_t)code, out + length);

package/runtime/xt_stdlib2/objects.inc

@@ -35,9 +35,131 @@ static xt_value xt_object_group_by(xt_value value, xt_value fn) {
   return result;
 }
 
+/* -- property descriptors ------------------------------------------------- */
+
+/* `attr` defaults for `defineProperty` are all false; literal properties are
+ * all true. Store the bits per key under a symbol so the flag table stays out
+ * of Object.keys / JSON. Writable/enumerable are reported truthfully, but the
+ * runtime does not enforce them on later writes or enumeration yet. */
+static xt_value xt_object_descriptor_flags_key_value = XT_UNDEFINED;
+
+static xt_value xt_object_descriptor_flags_key(void) {
+  if (!xt_is_symbol(xt_object_descriptor_flags_key_value)) {
+    xt_object_descriptor_flags_key_value =
+        xt_symbol_new(xt_string_from_cstr("__propertyDescriptorFlags"));
+    xt_gc_add_root(&xt_object_descriptor_flags_key_value);
+  }
+  return xt_object_descriptor_flags_key_value;
+}
+
+static xt_value xt_object_descriptor_flags(xt_value target) {
+  if (!XT_IS_OBJECT(target)) return XT_UNDEFINED;
+  xt_value flags = xt_object_get(target, xt_object_descriptor_flags_key());
+  if (!XT_IS_OBJECT(flags)) {
+    flags = xt_object_new();
+    xt_object_set(target, xt_object_descriptor_flags_key(), flags);
+  }
+  return flags;
+}
+
+static int xt_object_descriptor_mask(xt_value target, xt_value key) {
+  if (!XT_IS_OBJECT(target)) return 7;
+  xt_value flags = xt_object_get(target, xt_object_descriptor_flags_key());
+  if (!XT_IS_OBJECT(flags)) return 7;
+  xt_value mask = xt_object_get(flags, key);
+  return mask == XT_UNDEFINED ? 7 : xt_to_int32(mask);
+}
+
+static xt_value xt_object_data_descriptor(xt_value value, int enumerable, int configurable,
+                                         int writable) {
+  xt_value descriptor = xt_object_new();
+  xt_object_set(descriptor, xt_string_from_cstr("value"), value);
+  xt_object_set(descriptor, xt_string_from_cstr("writable"), xt_bool(writable));
+  xt_object_set(descriptor, xt_string_from_cstr("enumerable"), xt_bool(enumerable));
+  xt_object_set(descriptor, xt_string_from_cstr("configurable"), xt_bool(configurable));
+  return descriptor;
+}
+
+static xt_value xt_object_get_own_property_descriptor(xt_value target, xt_value key) {
+  if (XT_IS_ARRAY(target)) {
+    if (XT_IS_STRING(key) && xt_as_string(key)->length == 6 &&
+        memcmp(xt_string_bytes(xt_as_string(key)), "length", 6) == 0) {
+      return xt_object_data_descriptor(xt_array_length(target), 0, 0, 1);
+    }
+    xt_value item = xt_get(target, key);
+    if (item != XT_UNDEFINED) return xt_object_data_descriptor(item, 1, 1, 1);
+    return XT_UNDEFINED;
+  }
+  if (!XT_IS_OBJECT(target)) return XT_UNDEFINED;
+  xt_object *object = (xt_object *)XT_GET_PTR(target);
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT && object->header.kind != XT_OBJECT_KIND_ERROR) {
+    return XT_UNDEFINED;
+  }
+  xt_property *property = xt_object_find_property(object, xt_to_property_key(key));
+  if (!property) return XT_UNDEFINED;
+  int mask = xt_object_descriptor_mask(target, key);
+  if (property->getter != XT_UNDEFINED || property->setter != XT_UNDEFINED) {
+    xt_value descriptor = xt_object_new();
+    if (property->getter != XT_UNDEFINED) {
+      xt_object_set(descriptor, xt_string_from_cstr("get"), property->getter);
+    }
+    if (property->setter != XT_UNDEFINED) {
+      xt_object_set(descriptor, xt_string_from_cstr("set"), property->setter);
+    }
+    xt_object_set(descriptor, xt_string_from_cstr("enumerable"), xt_bool((mask & 2) != 0));
+    xt_object_set(descriptor, xt_string_from_cstr("configurable"), xt_bool((mask & 4) != 0));
+    return descriptor;
+  }
+  return xt_object_data_descriptor(property->value, (mask & 2) != 0, (mask & 4) != 0,
+                                   (mask & 1) != 0);
+}
+
+static xt_value xt_object_define_property(xt_value target, xt_value key, xt_value descriptor) {
+  if (!XT_IS_OBJECT(descriptor)) return target;
+  int writable = xt_truthy(xt_object_get(descriptor, xt_string_from_cstr("writable")));
+  int enumerable = xt_truthy(xt_object_get(descriptor, xt_string_from_cstr("enumerable")));
+  int configurable = xt_truthy(xt_object_get(descriptor, xt_string_from_cstr("configurable")));
+  int mask = (writable ? 1 : 0) | (enumerable ? 2 : 0) | (configurable ? 4 : 0);
+  xt_value flags = xt_object_descriptor_flags(target);
+  if (XT_IS_OBJECT(flags)) xt_object_set(flags, key, xt_number((double)mask));
+  xt_value getter = xt_object_get(descriptor, xt_string_from_cstr("get"));
+  xt_value setter = xt_object_get(descriptor, xt_string_from_cstr("set"));
+  if (getter != XT_UNDEFINED || setter != XT_UNDEFINED) {
+    if (getter != XT_UNDEFINED) xt_object_define_getter(target, key, getter);
+    if (setter != XT_UNDEFINED) xt_object_define_setter(target, key, setter);
+    return target;
+  }
+  if (xt_object_has_own(descriptor, xt_string_from_cstr("value"))) {
+    xt_set(target, key, xt_object_get(descriptor, xt_string_from_cstr("value")));
+  }
+  return target;
+}
+
+static xt_value xt_object_get_own_property_descriptors(xt_value target) {
+  xt_value result = xt_object_new();
+  xt_value names = xt_object_own_property_names(target);
+  xt_array *keys = xt_as_array(names);
+  if (!keys) return result;
+  for (uint32_t i = 0; i < keys->length; i++) {
+    xt_value descriptor = xt_object_get_own_property_descriptor(target, keys->items[i]);
+    if (descriptor != XT_UNDEFINED) xt_object_set(result, keys->items[i], descriptor);
+  }
+  return result;
+}
+
 xt_value xt_object_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
+  if (strcmp(fn, "getOwnPropertyDescriptor") == 0) {
+    return xt_object_get_own_property_descriptor(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  }
+  if (strcmp(fn, "getOwnPropertyDescriptors") == 0) {
+    return xt_object_get_own_property_descriptors(xt_arg_at(argc, argv, 0));
+  }
+  if (strcmp(fn, "defineProperty") == 0) {
+    return xt_object_define_property(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1),
+                                      xt_arg_at(argc, argv, 2));
+  }
   if (strcmp(fn, "keys") == 0) return xt_object_keys(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "getOwnPropertyNames") == 0) return xt_object_own_property_names(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "getOwnPropertySymbols") == 0) return xt_object_own_property_symbols(xt_arg_at(argc, argv, 0));

package/runtime/xt_stdlib2/set.inc

@@ -55,7 +55,7 @@ xt_value xt_iter_open(xt_value value) {
       return XT_FROM_PTR(XT_TAG_OBJECT, state);
     }
   }
-  xt_throw(xt_string_from_cstr("TypeError: value is not iterable"));
+  xt_throw(xt_error_from_message("TypeError: value is not iterable"));
   return XT_UNDEFINED;
 }