@scriptc/runtime 0.0.22 → 0.0.24

package/src/scr_json.c

@@ -94,6 +94,10 @@ static void scr_jb_write(ScrJsonBuf *b, const char *s, size_t n) {
   b->len += n;
 }
 
+void scr_jb_put_str(ScrJsonBuf *b, const ScrStr *s) {
+  scr_jb_write(b, s->data, s->len);
+}
+
 void scr_jb_puts(ScrJsonBuf *b, const char *s) { scr_jb_write(b, s, strlen(s)); }
 
 void scr_jb_put_f64(ScrJsonBuf *b, double v) {
@@ -986,10 +990,18 @@ void scr_throw_arg_type(const ScrStr *argname, const ScrStr *expected, const Scr
 void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrDyn *got) {
   char detail[64];
   const char *d = scr_dyn_specific_type(got, detail, sizeof detail);
-  char msg[224];
-  int len = snprintf(msg, sizeof msg,
-                     "The \"%s\" argument must be %s. Received %s", argname, expected, d);
-  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_TYPE");
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  scr_jb_puts(&b, "The \"");
+  scr_jb_puts(&b, argname);
+  scr_jb_puts(&b, "\" argument must be ");
+  scr_jb_puts(&b, expected);
+  scr_jb_puts(&b, ". Received ");
+  scr_jb_puts(&b, d);
+  ScrStr *msg = scr_jb_finish(&b);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg->data, msg->len,
+                           "ERR_INVALID_ARG_TYPE");
+  scr_str_release(msg);
 }
 
 /* The property flavor of the same ladder — Node renders option-bag
@@ -999,10 +1011,18 @@ void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrD
 void scr_dyn_prop_type_fail(const char *name, const char *expected, const ScrDyn *got) {
   char detail[64];
   const char *d = scr_dyn_specific_type(got, detail, sizeof detail);
-  char msg[224];
-  int len = snprintf(msg, sizeof msg,
-                     "The \"%s\" property must be %s. Received %s", name, expected, d);
-  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_TYPE");
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  scr_jb_puts(&b, "The \"");
+  scr_jb_puts(&b, name);
+  scr_jb_puts(&b, "\" property must be ");
+  scr_jb_puts(&b, expected);
+  scr_jb_puts(&b, ". Received ");
+  scr_jb_puts(&b, d);
+  ScrStr *msg = scr_jb_finish(&b);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg->data, msg->len,
+                           "ERR_INVALID_ARG_TYPE");
+  scr_str_release(msg);
 }
 
 /* The compiler-resolved property-typed throw (error.propTypeThrow —
@@ -1051,11 +1071,19 @@ const char *scr_dyn_inspect_lite(const ScrDyn *v, char *buf, size_t cap) {
 void scr_dyn_arg_value_fail(const char *name, const char *reason, const ScrDyn *got) {
   char insp[64];
   const char *d = scr_dyn_inspect_lite(got, insp, sizeof insp);
-  char msg[256];
-  int len = snprintf(msg, sizeof msg, "The %s '%s' %s. Received %s",
-                     strchr(name, '.') != NULL ? "property" : "argument", name,
-                     reason != NULL ? reason : "is invalid", d);
-  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_VALUE");
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  scr_jb_puts(&b, "The ");
+  scr_jb_puts(&b, strchr(name, '.') != NULL ? "property '" : "argument '");
+  scr_jb_puts(&b, name);
+  scr_jb_puts(&b, "' ");
+  scr_jb_puts(&b, reason != NULL ? reason : "is invalid");
+  scr_jb_puts(&b, ". Received ");
+  scr_jb_puts(&b, d);
+  ScrStr *msg = scr_jb_finish(&b);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg->data, msg->len,
+                           "ERR_INVALID_ARG_VALUE");
+  scr_str_release(msg);
 }
 
 /* The deferred JS lowering fence, thrown from a ladder's post-validation
@@ -1362,7 +1390,8 @@ ScrStr *scr_dyn_typeof(const ScrDyn *d) {
 /* ── JSON.stringify over a dyn value (util.format's %j) ───────────────
  * The RUNTIME walk the type-directed serializers deliberately avoid for
  * static values — a dyn value has no static type, so the checked-dynamic tree's own kinds
- * drive it, JS-exactly: insertion-ordered objects with undefined/function
+ * drive it, JS-exactly: objects in OrdinaryOwnPropertyKeys order (array
+ * indices ascending, then other strings in insertion order) with undefined/function
  * members OMITTED, arrays rendering those as null, Buffer's toJSON shape
  * ({"type":"Buffer","data":[...]}), shortest-roundtrip numbers, escaped
  * strings. HANDLE values fence loudly (Node walks own enumerable props
@@ -1390,23 +1419,26 @@ static bool scr_dyn_json_write(ScrJsonBuf *b, const ScrDyn *d) {
   case SCR_DYN_OBJ: {
     scr_jb_putc(b, '{');
     bool first = true;
-    for (size_t i = 0; i < d->v.obj.len; i++) {
+    ScrDyn *entries = scr_dyn_obj_entries(d);
+    for (size_t i = 0; i < entries->v.arr.len; i++) {
+      const ScrDyn *pair = entries->v.arr.items[i];
+      const ScrDyn *key = pair->v.arr.items[0];
+      const ScrDyn *value = pair->v.arr.items[1];
       ScrJsonBuf probe;
       scr_jb_init(&probe);
-      if (!scr_dyn_json_write(&probe, d->v.obj.entries[i].value)) {
+      if (!scr_dyn_json_write(&probe, value)) {
         scr_jb_dispose(&probe);
         continue; /* undefined/function members drop, like Node */
       }
       if (!first) scr_jb_putc(b, ',');
       first = false;
-      ScrStr *k = scr_str_new(d->v.obj.entries[i].key, d->v.obj.entries[i].key_len);
-      scr_jb_put_json_str(b, k);
-      scr_str_release(k);
+      scr_jb_put_json_str(b, key->v.str);
       scr_jb_putc(b, ':');
       ScrStr *body = scr_jb_finish(&probe);
       scr_jb_write(b, body->data, body->len);
       scr_str_release(body);
     }
+    scr_dyn_release(entries);
     scr_jb_putc(b, '}');
     return true;
   }
@@ -1637,8 +1669,17 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) {
   case SCR_DYN_OBJ:
     return scr_str_new("[object Object]", 15);
   case SCR_DYN_HANDLE:
-    /* IncomingMessage/ServerResponse/Socket inherit
-     * Object.prototype.toString — Node's String() answer exactly. */
+    if (d->v.handle.tag >= SCR_DYNH_ABORT_SIGNAL &&
+        d->v.handle.tag <= SCR_DYNH_ABORT_CONTROLLER) {
+      ScrJsonBuf b;
+      scr_jb_init(&b);
+      scr_jb_puts(&b, "[object ");
+      scr_jb_puts(&b, scr_dyn_handle_cls(d));
+      scr_jb_putc(&b, ']');
+      return scr_jb_finish(&b);
+    }
+    /* IncomingMessage/ServerResponse/Socket and the other Node handles
+     * inherit Object.prototype.toString without a @@toStringTag. */
     return scr_str_new("[object Object]", 15);
   case SCR_DYN_PROMISE:
     /* Object.prototype.toString with the Promise @@toStringTag. */
@@ -1789,6 +1830,81 @@ ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d) {
   return scr_dyn_string_coerce(d);
 }
 
+/* JS ToNumber over a checked-dynamic value, including OrdinaryToPrimitive's
+ * NUMBER hint for object snapshots. This is the numeric twin of
+ * scr_dyn_string_coerce_js above: valueOf precedes toString, inherited
+ * Object.prototype.valueOf returns the receiver (so conversion continues),
+ * and the inherited toString fallback supplies "[object Object]". Borrows d;
+ * false means an object hook threw or no primitive value could be produced. */
+bool scr_dyn_number_coerce_js(const ScrDyn *d, double *out) {
+  if (d->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *materialized = scr_dyn_typed_ref_materialize(d);
+    bool ok = scr_dyn_number_coerce_js(materialized, out);
+    scr_dyn_release(materialized);
+    return ok;
+  }
+  switch (d->kind) {
+  case SCR_DYN_NULL:
+    *out = 0.0;
+    return true;
+  case SCR_DYN_BOOL:
+    *out = d->v.b ? 1.0 : 0.0;
+    return true;
+  case SCR_DYN_NUM:
+    *out = d->v.num;
+    return true;
+  case SCR_DYN_STR:
+    *out = scr_string_to_number(d->v.str);
+    return true;
+  case SCR_DYN_UNDEF:
+    *out = NAN;
+    return true;
+  case SCR_DYN_OBJ: {
+    static const char *const hint[2] = { "valueOf", "toString" };
+    for (int i = 0; i < 2; i++) {
+      ScrDyn *m = scr_dyn_obj_get(d, hint[i], strlen(hint[i])); /* borrowed */
+      if (!m) {
+        if (!d->null_proto && i == 0) {
+          /* Inherited Object.prototype.valueOf returns the object, so the
+           * number-hint protocol advances to toString. */
+          continue;
+        }
+        if (!d->null_proto && i == 1) {
+          *out = NAN; /* Number("[object Object]") */
+          return true;
+        }
+        continue;
+      }
+      if (m->kind != SCR_DYN_FUNC) continue;
+      scr_dyn_this_push_dyn(d);
+      ScrDyn *r = scr_dyn_call(m, NULL, 0, hint[i]);
+      scr_dyn_this_pop();
+      if (!r) return false;
+      if (scr_dyn_to_primitive_result_is_object(r)) {
+        scr_dyn_release(r);
+        continue;
+      }
+      bool ok = scr_dyn_number_coerce_js(r, out);
+      scr_dyn_release(r);
+      return ok;
+    }
+    static const char msg[] = "Cannot convert object to primitive value";
+    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+    return false;
+  }
+  default: {
+    /* Arrays, byte views, functions, promises, and native handles inherit a
+     * valueOf that returns the receiver, then use their existing JS-exact
+     * string rendering for the numeric conversion. */
+    ScrStr *text = scr_dyn_string_coerce(d);
+    if (!text) return false;
+    *out = scr_string_to_number(text);
+    scr_str_release(text);
+    return true;
+  }
+  }
+}
+
 /* The checked-dynamic keyed WRITE (`h.k = v` on a dyn receiver): OBJ sets
  * the member (later writes win, insertion order — JS); undefined/null
  * throws Node's "Cannot set properties of ..."; every other kind throws