@scriptc/cli-darwin-x64 0.2.0 → 0.2.1

package/dist/lib/runtime-sources/src/scr_dyn_invoke.c

@@ -555,7 +555,15 @@ static bool dyn_name_is(const char *m, const char *n) { return strcmp(m, n) == 0
  * accessor reports). */
 static ScrDyn *scr_dynh_dispatch(ScrDyn *recv, const char *method, ScrDyn *const *args, size_t argc, const char *what) {
   const ScrDynHandleOps *ops = scr_dyn_handle_ops_of(recv);
-  return ops->invoke(recv->v.handle.ptr, recv, method, args, argc, what);
+  if (ops->invoke) return ops->invoke(recv->v.handle.ptr, recv, method, args, argc, what);
+  ScrDyn *callable = ops->get ? ops->get(recv->v.handle.ptr, method, strlen(method)) : NULL;
+  if (scr_exc_pending()) { scr_dyn_release(callable); return NULL; }
+  if (!callable) callable = scr_dyn_retain(scr_dyn_undefined());
+  scr_dyn_this_push_dyn(recv);
+  ScrDyn *result = scr_dyn_call(callable, args, argc, what);
+  scr_dyn_this_pop();
+  scr_dyn_release(callable);
+  return result;
 }
 
 /* JS Array.prototype.sort over a dyn array: the spec's snapshot-sort —
@@ -648,6 +656,14 @@ static bool dyn_arr_flatten(ScrDyn *out, const ScrDyn *source, double depth, siz
       return false;
     }
     const ScrDyn *item = source->v.arr.items[i];
+    if (depth > 0 && item->kind == SCR_DYN_TYPED_REF && scr_dyn_isl_is_array(item)) {
+      ScrDyn *view = scr_dyn_typed_ref_materialize(item);
+      if (!view || scr_exc_pending()) { scr_dyn_release(view); return false; }
+      bool ok = dyn_arr_flatten(out, view, depth - 1, visits);
+      scr_dyn_release(view);
+      if (!ok) return false;
+      continue;
+    }
     if (depth > 0 && item->kind == SCR_DYN_ARR) {
       if (!dyn_arr_flatten(out, item, depth - 1, visits)) return false;
     } else {
@@ -690,6 +706,29 @@ static ScrDyn *scr_dyn_invoke_impl(
     ScrDyn *recv, const char *method, ScrDyn *const *args, size_t argc,
     const char *what, ScrDyn *callback_recv);
 
+ScrDyn *scr_dyn_prepare_method(ScrDyn *recv, const char *method) {
+  if (recv->kind == SCR_DYN_UNDEF || recv->kind == SCR_DYN_NULL)
+    return scr_dyn_invoke(recv, method, NULL, 0, method);
+  if (recv->kind == SCR_DYN_OBJ)
+    return scr_dyn_obj_read(recv, method, strlen(method));
+  if (recv->kind == SCR_DYN_PROXY) {
+    ScrStr *key = scr_str_new(method, strlen(method));
+    ScrDyn *result = scr_dyn_proxy_get(recv, key);
+    scr_str_release(key);
+    return result;
+  }
+  return NULL;
+}
+
+ScrDyn *scr_dyn_invoke_prepared(ScrDyn *recv, ScrDyn *callee, const char *method,
+                               ScrDyn *const *args, size_t argc, const char *what) {
+  if (!callee) return scr_dyn_invoke(recv, method, args, argc, what);
+  scr_dyn_this_push_dyn(recv);
+  ScrDyn *result = scr_dyn_call(callee, args, argc, what);
+  scr_dyn_this_pop();
+  return result;
+}
+
 ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method,
                        ScrDyn *const *args, size_t argc,
                        const char *what) {
@@ -788,32 +827,8 @@ static ScrDyn *scr_dyn_invoke_impl(
 
   if (recv->kind == SCR_DYN_FUNC) {
     if (dyn_name_is(method, "apply")) {
-      /* fn.apply(thisArg, argsArray) — thisArg binds the ambient receiver
-       * for the call window (the mustCall wrapper's `fn.apply(this,
-       * arguments)` forwards whatever receiver the wrapper ran under). */
-      const ScrDyn *thisv = argc >= 1 ? args[0] : scr_dyn_undefined();
-      ScrDyn *list = argc >= 2 ? args[1] : NULL;
-      if (list == NULL || list->kind == SCR_DYN_UNDEF || list->kind == SCR_DYN_NULL) {
-        scr_dyn_this_push_dyn(thisv);
-        ScrDyn *r = scr_dyn_call(recv, NULL, 0, what);
-        scr_dyn_this_pop();
-        return r;
-      }
-      ScrDyn *view = list->kind == SCR_DYN_TYPED_REF && scr_dyn_isl_is_array(list)
-          ? scr_dyn_typed_ref_materialize(list) : NULL;
-      if (scr_exc_pending()) { scr_dyn_release(view); return NULL; }
-      if (view) list = view;
-      if (list->kind != SCR_DYN_ARR) {
-        scr_throw_error_msg(SCR_ERR_TYPE, "CreateListFromArrayLike called on non-object",
-                            strlen("CreateListFromArrayLike called on non-object"));
-        scr_dyn_release(view);
-        return NULL;
-      }
-      scr_dyn_this_push_dyn(thisv);
-      ScrDyn *r = scr_dyn_call(recv, list->v.arr.items, list->v.arr.len, what);
-      scr_dyn_this_pop();
-      scr_dyn_release(view);
-      return r;
+      return scr_dyn_apply_array_like(recv, argc ? args[0] : scr_dyn_undefined(),
+        argc > 1 ? args[1] : scr_dyn_undefined(), what);
     }
     if (dyn_name_is(method, "call")) {
       scr_dyn_this_push_dyn(argc >= 1 ? args[0] : scr_dyn_undefined());
@@ -823,6 +838,15 @@ static ScrDyn *scr_dyn_invoke_impl(
     }
     if (dyn_name_is(method, "bind")) return scr_dyn_bind(recv, args, argc);
     if (dyn_name_is(method, "toString")) {
+      ScrDyn *member = scr_dyn_fn_get(recv, method, strlen(method));
+      if (member && member->kind != SCR_DYN_UNDEF) {
+        scr_dyn_this_push_dyn(recv);
+        ScrDyn *result = scr_dyn_call(member, args, argc, what);
+        scr_dyn_this_pop();
+        scr_dyn_release(member);
+        return result;
+      }
+      scr_dyn_release(member);
       dyn_throw_unsupported("Function", method);
       return NULL;
     }
@@ -868,9 +892,11 @@ static ScrDyn *scr_dyn_invoke_impl(
       if ((dyn_name_is(method, "indexOf") || dyn_name_is(method, "lastIndexOf") ||
            dyn_name_is(method, "includes")) &&
           argc >= 1 && args[0]->kind == SCR_DYN_STR) {
-        if (dyn_name_is(method, "includes")) return scr_dyn_new_bool(scr_str_includes(s, args[0]->v.str));
-        if (dyn_name_is(method, "indexOf")) return scr_dyn_new_num(scr_str_index_of(s, args[0]->v.str, 0));
-        return scr_dyn_new_num(scr_str_last_index_of(s, args[0]->v.str));
+        double position = dyn_index_arg(args, argc, 1, dyn_name_is(method, "lastIndexOf") ? INFINITY : 0, what);
+        if (scr_exc_pending()) return NULL;
+        if (dyn_name_is(method, "includes")) return scr_dyn_new_bool(scr_str_index_of(s, args[0]->v.str, position) >= 0);
+        if (dyn_name_is(method, "indexOf")) return scr_dyn_new_num(scr_str_index_of(s, args[0]->v.str, position));
+        return scr_dyn_new_num(scr_str_last_index_of_from(s, args[0]->v.str, position));
       }
       dyn_throw_unsupported("String", method);
       return NULL;
@@ -1030,7 +1056,7 @@ static ScrDyn *scr_dyn_invoke_impl(
       ScrDyn *needle = argc > 0 ? args[0] : scr_dyn_undefined();
       double from = dyn_name_is(method, "lastIndexOf") ? (double)len - 1 : 0;
       if (argc > 1) {
-        from = dyn_index_arg(args, argc, 1, from, what);
+        from = dyn_index_arg(args, argc, 1, 0, what);
         if (scr_exc_pending()) return NULL;
       }
       if (!dyn_arr_length_unchanged(recv, len)) return NULL;
@@ -1309,6 +1335,12 @@ static ScrDyn *scr_dyn_invoke_impl(
             cb, item, i, callback_recv ? callback_recv : recv);
         scr_dyn_release(item);
         if (!r) { scr_dyn_release(out); return NULL; }
+        if (r->kind == SCR_DYN_TYPED_REF && scr_dyn_isl_is_array(r)) {
+          ScrDyn *view = scr_dyn_typed_ref_materialize(r);
+          scr_dyn_release(r);
+          r = view;
+          if (!r) { scr_dyn_release(out); return NULL; }
+        }
         if (r->kind == SCR_DYN_ARR) {
           for (size_t j = 0; j < r->v.arr.len; j++) {
             scr_dyn_arr_push(out, scr_dyn_retain(r->v.arr.items[j]));
@@ -1487,6 +1519,107 @@ static ScrDyn *dyn_array_method_value_call(ScrClosure *closure, ScrDyn *const *a
   return result;
 }
 
+static SCR_TL ScrDyn *dyn_builtin_methods;
+
+static void dyn_builtin_methods_cleanup(void) {
+  scr_dyn_release(dyn_builtin_methods);
+  dyn_builtin_methods = NULL;
+}
+
+static ScrDyn *dyn_builtin_method_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
+  ScrStr *prototype = scr_box_get_ref(closure->caps[0]);
+  ScrStr *method = scr_box_get_ref(closure->caps[1]);
+  ScrDyn *receiver = scr_dyn_this_get();
+  ScrDyn *result = NULL;
+  if (!strcmp(prototype->data, "Object")) {
+    ScrDyn *key = argc ? args[0] : scr_dyn_undefined();
+    if (!strcmp(method->data, "toString")) {
+      ScrStr *tag = scr_dyn_object_tag(receiver);
+      if (tag) { result = scr_dyn_new_str(tag); scr_str_release(tag); }
+    } else if (!strcmp(method->data, "hasOwnProperty")) {
+      bool own = scr_dyn_has_own_computed(receiver, key);
+      if (!scr_exc_pending()) result = scr_dyn_new_bool(own);
+    } else if (!strcmp(method->data, "propertyIsEnumerable")) {
+      bool enumerable = scr_dyn_property_is_enumerable_computed(receiver, key);
+      if (!scr_exc_pending()) result = scr_dyn_new_bool(enumerable);
+    } else if (receiver->kind == SCR_DYN_NULL || receiver->kind == SCR_DYN_UNDEF) {
+      static const char message[] = "Cannot convert undefined or null to object";
+      scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    } else if (receiver->kind == SCR_DYN_OBJ || receiver->kind == SCR_DYN_ARR ||
+        receiver->kind == SCR_DYN_FUNC || receiver->kind == SCR_DYN_HANDLE ||
+        receiver->kind == SCR_DYN_TYPED_REF || receiver->kind == SCR_DYN_PROXY) result = scr_dyn_retain(receiver);
+    else dyn_throw_unsupported("Object", method->data);
+  } else {
+    bool compatible = false;
+    if (!strcmp(prototype->data, "String")) compatible = receiver->kind != SCR_DYN_UNDEF && receiver->kind != SCR_DYN_NULL;
+    else if (!strcmp(prototype->data, "Number")) compatible = receiver->kind == SCR_DYN_NUM;
+    else if (receiver->kind == SCR_DYN_HANDLE) {
+      const ScrDynHandleOps *ops = scr_dyn_handle_ops_of(receiver);
+      compatible = !strcmp(ops->cls, prototype->data);
+    }
+    if (!compatible) {
+      static const char message[] = "Builtin prototype method called on incompatible receiver";
+      scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    } else if (!strcmp(method->data, "toString") && receiver->kind == SCR_DYN_NUM) {
+      ScrStr *value = scr_dyn_to_string_argument(receiver, argc ? args[0] : scr_dyn_undefined(), method);
+      if (value) { result = scr_dyn_new_str(value); scr_str_release(value); }
+    } else if (!strcmp(prototype->data, "String")) {
+      bool strict = !strcmp(method->data, "toString") || !strcmp(method->data, "valueOf");
+      if (strict && receiver->kind != SCR_DYN_STR) {
+        static const char message[] = "String.prototype method requires a string receiver";
+        scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+      } else if (strict) result = scr_dyn_retain(receiver);
+      else {
+        ScrStr *text = scr_dyn_string_coerce_js(receiver);
+        if (text) {
+          ScrDyn *string = scr_dyn_new_str(text);
+          scr_str_release(text);
+          if (!strcmp(method->data, "slice")) result = scr_dyn_invoke(string, method->data, args, argc, method->data);
+          else dyn_throw_unsupported("String", method->data);
+          scr_dyn_release(string);
+        }
+      }
+    } else result = scr_dyn_invoke(receiver, method->data, args, argc, method->data);
+  }
+  scr_dyn_release(receiver);
+  scr_str_release(prototype);
+  scr_str_release(method);
+  return result;
+}
+
+ScrDyn *scr_dyn_builtin_method(const ScrStr *prototype, const ScrStr *method) {
+  if (!dyn_builtin_methods) {
+    dyn_builtin_methods = scr_dyn_new_obj_null_proto();
+    scr_atexit(dyn_builtin_methods_cleanup);
+  }
+  ScrJsonBuf buffer;
+  scr_jb_init(&buffer);
+  scr_jb_puts(&buffer, prototype->data);
+  scr_jb_putc(&buffer, '.');
+  scr_jb_puts(&buffer, method->data);
+  ScrStr *key = scr_jb_finish(&buffer);
+  ScrDyn *value = scr_dyn_obj_get(dyn_builtin_methods, key->data, key->len);
+  if (!value) {
+    ScrClosure *closure = scr_closure_new(NULL, 2);
+    closure->caps[0] = scr_box_new(SCR_BOX_STR);
+    closure->caps[1] = scr_box_new(SCR_BOX_STR);
+    scr_box_set_ref(closure->caps[0], scr_str_retain((ScrStr *)prototype));
+    scr_box_set_ref(closure->caps[1], scr_str_retain((ScrStr *)method));
+    size_t arity = (!strcmp(method->data, "set") || !strcmp(method->data, "substring") ||
+      !strcmp(method->data, "slice") ||
+      !strcmp(method->data, "replace") || !strcmp(method->data, "split")) ? 2 :
+      (!strcmp(method->data, "get") || !strcmp(method->data, "add") || !strcmp(method->data, "has") ||
+       !strcmp(method->data, "delete") || !strcmp(method->data, "forEach") || !strcmp(method->data, "startsWith") ||
+       !strcmp(method->data, "endsWith") || !strcmp(method->data, "padStart") || !strcmp(method->data, "toJSON") ||
+       !strcmp(method->data, "charCodeAt") || !strcmp(method->data, "hasOwnProperty") ||
+       !strcmp(method->data, "propertyIsEnumerable") || (!strcmp(prototype->data, "Number") && !strcmp(method->data, "toString"))) ? 1 : 0;
+    value = scr_dyn_new_func(closure, dyn_builtin_method_call, arity, "native:prototype", method->data);
+    scr_dyn_obj_set(dyn_builtin_methods, key->data, key->len, value);
+  }
+  scr_str_release(key);
+  return scr_dyn_retain(value);
+}
+
 ScrDyn *scr_dyn_array_prototype(void) {
   static SCR_TL bool initialized;
   ScrDyn *prototype = scr_dyn_array_prototype_base();

package/dist/lib/runtime-sources/src/scr_error.c

@@ -135,6 +135,7 @@ void scr_error_init(void *obj, int kind, ScrStr *message) {
   const char *n = scr_error_names[kind];
   e->name = scr_str_new(n, strlen(n));
   e->message = message ? scr_str_retain(message) : scr_str_new("", 0);
+  e->message_present = message != NULL;
   e->stack_frames = scr_stack_capture();
 }
 
@@ -172,9 +173,28 @@ ScrError *scr_error_new(int kind, ScrStr *message) {
   return e;
 }
 
-ScrStr *scr_error_to_string(ScrError *e) {
-  /* ECMA-262 Error.prototype.toString over the two fields (no prototype
-   * chain exists: constructors always initialize both) — except Node's
+static SCR_TL ScrStr *(*scr_error_message_reader)(ScrError *);
+static SCR_TL ScrStr *(*scr_error_name_reader)(ScrError *);
+
+void scr_error_install_message_reader(ScrStr *(*reader)(ScrError *)) {
+  scr_error_message_reader = reader;
+}
+
+void scr_error_install_name_reader(ScrStr *(*reader)(ScrError *)) {
+  scr_error_name_reader = reader;
+}
+
+ScrStr *scr_error_default_name(const ScrError *e) {
+  for (int i = 1; i < SCR_ERR_COUNT; i++) {
+    if (i == SCR_ERR_DOMEX) continue;
+    if (scr_error_vts[i].pre <= e->vt->pre && e->vt->pre <= scr_error_vts[i].post)
+      return scr_str_new(scr_error_names[i], strlen(scr_error_names[i]));
+  }
+  return scr_str_new("Error", 5);
+}
+
+static ScrStr *scr_error_format(ScrError *e, ScrStr *name, ScrStr *message) {
+  /* ECMA-262 Error.prototype.toString over the resolved properties — except Node's
    * OWN error classes: AssertionError's toString and the NodeError
    * family's construction-time name both render "name [code]: message".
    * Every ERR_*-coded error this runtime mints IS one of those classes
@@ -182,8 +202,6 @@ ScrStr *scr_error_to_string(ScrError *e) {
    * the code-prefix test is exact for runtime-thrown errors; a user
    * assigning an ERR_* code onto a plain Error would bracket here where
    * Node would not (documented — user code owns that spelling). */
-  ScrStr *name = e->name;
-  ScrStr *message = e->message;
   bool assertion = name && e->code && e->code->len >= 4 &&
                    memcmp(e->code->data, "ERR_", 4) == 0;
   if (!name || name->len == 0) {
@@ -214,9 +232,36 @@ ScrStr *scr_error_to_string(ScrError *e) {
   return out;
 }
 
+ScrStr *scr_error_to_string(ScrError *e) {
+  // Diagnostic formatting can run with the original error still pending.
+  // Accessors execute with a clear cell, and cannot replace that error.
+  ScrCaught *pending = scr_exc_pending() ? scr_exc_take() : NULL;
+  ScrStr *name = !e->name_present && scr_error_name_reader
+    ? scr_error_name_reader(scr_error_retain(e)) : scr_str_retain(e->name);
+  ScrStr *message = scr_exc_pending() ? NULL : !e->message_present && scr_error_message_reader
+    ? scr_error_message_reader(scr_error_retain(e)) : scr_str_retain(e->message);
+  if (pending) {
+    if (scr_exc_pending()) {
+      scr_exc_clear();
+      scr_str_release(message);
+      message = scr_str_retain(e->message);
+      scr_str_release(name);
+      name = scr_str_retain(e->name);
+    }
+    scr_rethrow(pending);
+    scr_caught_release(pending);
+  }
+  if (!name || !message) { scr_str_release(name); scr_str_release(message); return NULL; }
+  ScrStr *result = scr_error_format(e, name, message);
+  scr_str_release(name);
+  scr_str_release(message);
+  return result;
+}
+
 ScrStr *scr_error_stack(ScrError *e) {
   if (!e->stack) {
     ScrStr *heading = scr_error_to_string(e);
+    if (!heading) return NULL;
     e->stack = e->stack_frames ? scr_str_concat(heading, e->stack_frames) : scr_str_retain(heading);
     scr_str_release(heading);
   }
@@ -367,6 +412,8 @@ void scr_throw_error_named(ScrStr *name, ScrStr *message) {
   ScrError *e = scr_error_alloc(kind);
   e->name = name;       /* ownership moves in (engine names may be custom) */
   e->message = message; /* ownership moves in */
+  e->name_present = kind == SCR_ERR_ERROR && !(name->len == 5 && memcmp(name->data, "Error", 5) == 0);
+  e->message_present = true;
   scr_throw_obj(e, &scr_error_retain_v, &scr_error_release_v,
                  scr_error_traced ? &scr_error_trace : NULL);
 }

package/dist/lib/runtime-sources/src/scr_exception.c

@@ -139,11 +139,24 @@ void scr_exc_clear(void) { scr_exc_reset(); }
 
 /* ── catch bindings (ScrCaught — contract in scr_runtime.h) ──────────── */
 
-ScrCaught *scr_exc_take(void) {
-  ScrCaught *c = calloc(1, sizeof *c);
-  if (!c) {
-    scr_trap("scriptc: out of memory\n");
+void scr_caught_trace_v(void *object, ScrTraceVisit visit, void *ctx) {
+  ScrCaught *c = object;
+  if (c->payload && c->trace_fn) visit(c->payload, ctx);
+}
+
+static void scr_caught_gcfree(void *object) {
+  ScrCaught *c = object;
+  if (c->kind == SCR_EXC_STR) {
+    scr_str_release((ScrStr *)c->payload);
+  } else if (c->payload && c->release_fn && !c->trace_fn) {
+    c->release_fn(c->payload);
   }
+  scr_obj_free_note();
+  scr_cyc_free(c);
+}
+
+ScrCaught *scr_exc_take(void) {
+  ScrCaught *c = scr_cyc_alloc(sizeof *c, scr_caught_trace_v, scr_caught_gcfree);
   c->rc = 1;
   c->kind = scr_exc_kind;
   c->f64 = scr_exc_f64;
@@ -169,6 +182,7 @@ ScrCaught *scr_caught_retain(ScrCaught *c) {
 void scr_caught_release(ScrCaught *c) {
   if (!c) return;
   if (--c->rc == 0) {
+    scr_cyc_on_dead(c);
     if (c->kind == SCR_EXC_STR) {
       scr_str_release((ScrStr *)c->payload);
     } else if (c->kind == SCR_EXC_REF || c->kind == SCR_EXC_OBJ ||
@@ -176,7 +190,9 @@ void scr_caught_release(ScrCaught *c) {
       c->release_fn(c->payload);
     }
     scr_obj_free_note();
-    free(c);
+    scr_cyc_free(c);
+  } else {
+    scr_cyc_on_release(c);
   }
 }