xbintsc 0.2.5 → 0.2.7

package/runtime/ext_node/url/url.c

@@ -0,0 +1,85 @@
+/*
+ * Node.js `url` module for xbintsc.
+ *
+ * Implements the two helpers the compiler itself relies on:
+ *   - `pathToFileURL(path)`  -> URL object with an `href` property
+ *   - `fileURLToPath(url)`   -> filesystem path
+ *
+ * Both accept the `file://` scheme and percent-encoded URLs. On Windows a
+ * leading slash before a drive letter (`/C:/`) is removed, matching Node.
+ */
+
+#include "rt.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int url_hex(int c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+static xt_value url_percent_decode(const char *in) {
+  size_t length = strlen(in);
+  char *out = (char *)malloc(length + 1);
+  if (!out) return xt_string_from_cstr(in);
+  size_t j = 0;
+  for (size_t i = 0; i < length; i++) {
+    if (in[i] == '%' && i + 2 < length && url_hex(in[i + 1]) >= 0 && url_hex(in[i + 2]) >= 0) {
+      out[j++] = (char)((url_hex(in[i + 1]) << 4) | url_hex(in[i + 2]));
+      i += 2;
+    } else {
+      out[j++] = in[i];
+    }
+  }
+  out[j] = 0;
+  xt_value result = xt_string_from_cstr(out);
+  free(out);
+  return result;
+}
+
+xt_value xt_url_path_to_file_url(int32_t argc, xt_value *argv) {
+  const char *raw = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+  if (!raw) raw = "";
+  /* Resolve to an absolute path so the URL is comparable to `import.meta.url`
+     (which is built from realpath) even when given a relative path. */
+  char resolved[4096];
+  const char *path = raw;
+#if defined(_WIN32)
+  if (_fullpath(resolved, raw, sizeof(resolved))) path = resolved;
+#else
+  if (realpath(raw, resolved)) path = resolved;
+#endif
+  char href[4300];
+  size_t j = 0;
+  const char *prefix = "file://";
+  for (; *prefix && j < sizeof(href) - 1; prefix++) href[j++] = *prefix;
+#if defined(_WIN32)
+  if (j < sizeof(href) - 1) href[j++] = '/';
+#endif
+  for (const char *p = path; *p && j < sizeof(href) - 1; p++) href[j++] = (*p == '\\') ? '/' : *p;
+  href[j] = 0;
+
+  xt_value url = xt_object_new();
+  xt_set(url, xt_string_from_cstr("href"), xt_string_from_cstr(href));
+  xt_set(url, xt_string_from_cstr("protocol"), xt_string_from_cstr("file:"));
+  xt_set(url, xt_string_from_cstr("pathname"), xt_string_from_cstr(path));
+  return url;
+}
+
+xt_value xt_url_file_url_to_path(int32_t argc, xt_value *argv) {
+  const char *url = argc > 0 ? xt_string_data(xt_to_string(argv[0])) : "";
+  const char *path = url;
+  if (strncmp(url, "file://", 7) == 0) {
+    path = url + 7;
+    /* `file://localhost/...` is equivalent to `file:///...`. */
+    if (strncmp(path, "localhost", 9) == 0) path += 9;
+  }
+#if defined(_WIN32)
+  if (path[0] == '/' && isalpha((unsigned char)path[1]) && path[2] == ':') path++;
+#endif
+  return url_percent_decode(path);
+}

package/runtime/rt.h

@@ -147,6 +147,9 @@ xt_value xt_object_new_with_proto(xt_value proto);
 xt_value xt_object_get(xt_value obj, xt_value key);
 xt_value xt_object_get_prototype(xt_value obj);
 xt_value xt_object_set_prototype(xt_value obj, xt_value proto);
+/** Define `get name()` / `set name(v)` accessors on an object. */
+xt_value xt_object_define_getter(xt_value obj, xt_value key, xt_value getter);
+xt_value xt_object_define_setter(xt_value obj, xt_value key, xt_value setter);
 xt_value xt_object_freeze(xt_value obj);
 int xt_object_is_frozen(xt_value obj);
 xt_value xt_object_from_entries(xt_value entries);
@@ -182,6 +185,16 @@ xt_value xt_date_ctor(int32_t argc, xt_value *argv);
 xt_value xt_date_static(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_regexp_ctor(int32_t argc, xt_value *argv);
 
+/* -- node:url ------------------------------------------------------------- */
+xt_value xt_url_path_to_file_url(int32_t argc, xt_value *argv);
+xt_value xt_url_file_url_to_path(int32_t argc, xt_value *argv);
+
+/* -- node:crypto ---------------------------------------------------------- */
+xt_value xt_crypto_create_hash(int32_t argc, xt_value *argv);
+
+/* -- node:child_process --------------------------------------------------- */
+xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv);
+
 /* -- promises / async ----------------------------------------------------- */
 xt_value xt_promise_resolve(xt_value value);
 xt_value xt_promise_reject(xt_value value);
@@ -223,6 +236,7 @@ xt_value xt_rest_args(int32_t argc, xt_value *argv, int32_t start);
 /* -- program arguments ---------------------------------------------------- */
 /* Captured from `main` so host extensions can expose `process.argv`. */
 void xt_set_program_args(int32_t argc, char **argv);
+xt_value xt_import_meta(xt_value name);
 extern int32_t xt_program_argc;
 extern char **xt_program_argv;
 
@@ -233,6 +247,12 @@ xt_value xt_array_set(xt_value arr, xt_value index, xt_value value);
 xt_value xt_array_push(xt_value arr, xt_value value);
 xt_value xt_array_length(xt_value arr);
 xt_value xt_array_spread(xt_value target, xt_value source);
+int32_t xt_array_size(xt_value value);
+xt_value *xt_array_items(xt_value value);
+
+/* `for...of` iteration: dispatch over arrays, strings, Maps and Sets. */
+xt_value xt_iter_length(xt_value value);
+xt_value xt_iter_value(xt_value value, xt_value index);
 
 /* -- generic member access ------------------------------------------------ */
 xt_value xt_get(xt_value target, xt_value key);

package/runtime/rt_internal.h

@@ -66,6 +66,10 @@ typedef struct {
 typedef struct {
   xt_string *key;
   xt_value value;
+  /* Accessor properties (`get x()` / `set x(v)`) store the functions here;
+   * when set, `value` is ignored and property access invokes the getter. */
+  xt_value getter;
+  xt_value setter;
 } xt_property;
 
 typedef struct {
@@ -120,8 +124,15 @@ int xt_is_map(xt_value value);
 int xt_is_set(xt_value value);
 int xt_is_date(xt_value value);
 int xt_is_regexp(xt_value value);
+int xt_regexp_find(xt_value regexp, xt_value input, int32_t start, int32_t *matchStart, int32_t *matchEnd);
+xt_value xt_regexp_exec(xt_value regexp, xt_value input);
+xt_value xt_regexp_replace(xt_value value, xt_value regexp, xt_value replacement);
+xt_value xt_regexp_get_property(xt_value regexp, xt_value key);
 int32_t xt_map_size(xt_value value);
 int32_t xt_set_size(xt_value value);
+/* `for...of` iteration: dispatch over arrays, strings, Maps and Sets. */
+xt_value xt_iter_length(xt_value value);
+xt_value xt_iter_value(xt_value value, xt_value index);
 
 /* -- collection / date / regexp representations --------------------------- */
 typedef struct {

package/runtime/xt_builtins.c

@@ -100,6 +100,29 @@ xt_value xt_boolean_ctor(int32_t argc, xt_value *argv) {
   return xt_bool(xt_truthy(argv[0]));
 }
 
+/*
+ * Builtin function values. Global constructors like `Boolean` are usually
+ * called directly, but JavaScript also allows passing them around
+ * (`arr.filter(Boolean)`). These trampolines adapt the uniform `(argc, argv)`
+ * builtin ABI to the closure ABI so the codegen can wrap them with
+ * `xt_closure_new`.
+ */
+#define XT_BUILTIN_TRAMPOLINE(name, target)                            \
+  xt_value name(xt_value thisValue, xt_value env, int32_t argc,        \
+                xt_value *argv) {                                      \
+    (void)thisValue;                                                   \
+    (void)env;                                                         \
+    return target(argc, argv);                                         \
+  }
+
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_boolean, xt_boolean_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_number, xt_number_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_string, xt_string_ctor)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_parseInt, xt_parse_int)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_parseFloat, xt_parse_float)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_isNaN, xt_is_nan)
+XT_BUILTIN_TRAMPOLINE(xt_builtin_value_isFinite, xt_is_finite)
+
 xt_value xt_in(xt_value key, xt_value value) {
   if (XT_IS_OBJECT(value)) return xt_object_has(value, key);
   if (XT_IS_ARRAY(value)) {

package/runtime/xt_containers.c

@@ -63,16 +63,40 @@ xt_property *xt_object_find_property(xt_object *obj, xt_string *key) {
   return obj ? xt_object_find(obj, key) : NULL;
 }
 
+static int xt_key_is_prototype(xt_value key) {
+  xt_string *k = xt_as_string(xt_to_string(key));
+  return k && k->length == 9 && memcmp(k->data, "prototype", 9) == 0;
+}
+
 xt_value xt_object_get(xt_value value, xt_value key) {
+  /* A function's `.prototype` lives in a dedicated field (set by
+     `xt_function_set_prototype`), not in its property bag. Expose it as a
+     normal property so `Class.prototype` returns the object instances use. */
+  if (XT_IS_FUNCTION(value) && xt_key_is_prototype(key)) {
+    return ((xt_function *)XT_GET_PTR(value))->prototype;
+  }
   xt_object *obj = xt_as_object(value);
   if (!obj) return XT_UNDEFINED;
+  /* Only plain objects (and function property bags) use the `xt_object`
+     layout. Containers such as Map/Set/Date/RegExp/Promise/Array must not be
+     interpreted as property tables, or property lookup reads past the end of
+     their real representation. */
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT) return XT_UNDEFINED;
   xt_value keyString = xt_to_string(key);
   xt_string *k = xt_as_string(keyString);
   /* Walk the prototype chain like JavaScript property lookup. */
   xt_object *cur = obj;
   while (cur) {
     xt_property *prop = xt_object_find(cur, k);
-    if (prop) return prop->value;
+    if (prop) {
+      /* Invoke accessors with the original receiver as `this`, so getters
+         inherited from a prototype still see the instance. */
+      if (prop->getter != XT_UNDEFINED && XT_IS_FUNCTION(prop->getter)) {
+        return xt_call_with_this(prop->getter, value, 0, NULL);
+      }
+      if (prop->getter != XT_UNDEFINED) return XT_UNDEFINED;
+      return prop->value;
+    }
     if (!XT_IS_OBJECT(cur->prototype)) break;
     cur = (xt_object *)XT_GET_PTR(cur->prototype);
   }
@@ -80,22 +104,82 @@ xt_value xt_object_get(xt_value value, xt_value key) {
 }
 
 xt_value xt_object_set(xt_value value, xt_value key, xt_value newValue) {
+  if (XT_IS_FUNCTION(value) && xt_key_is_prototype(key)) {
+    return xt_function_set_prototype(value, newValue);
+  }
   xt_object *obj = xt_as_object(value);
   if (!obj) return newValue;
+  if (obj->header.kind != XT_OBJECT_KIND_OBJECT) return newValue;
   if (obj->frozen) return newValue;
   xt_value keyString = xt_to_string(key);
-  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
+  xt_string *k = xt_as_string(keyString);
+  xt_property *prop = xt_object_find(obj, k);
   if (prop) {
+    if (prop->setter != XT_UNDEFINED) {
+      if (XT_IS_FUNCTION(prop->setter)) {
+        xt_value argument = newValue;
+        xt_call_with_this(prop->setter, value, 1, &argument);
+      }
+      return newValue;
+    }
+    if (prop->getter != XT_UNDEFINED) return newValue; /* accessor without setter */
     prop->value = newValue;
     return newValue;
   }
+  /* No own property: an inherited accessor still intercepts the assignment
+     (JavaScript assigns through prototype setters instead of shadowing). */
+  xt_object *ancestor = XT_IS_OBJECT(obj->prototype) ? (xt_object *)XT_GET_PTR(obj->prototype) : NULL;
+  while (ancestor) {
+    xt_property *inherited = xt_object_find(ancestor, k);
+    if (inherited) {
+      if (inherited->setter != XT_UNDEFINED) {
+        if (XT_IS_FUNCTION(inherited->setter)) {
+          xt_value argument = newValue;
+          xt_call_with_this(inherited->setter, value, 1, &argument);
+        }
+        return newValue;
+      }
+      if (inherited->getter != XT_UNDEFINED) return newValue; /* getter-only accessor */
+      break; /* plain inherited data property: create an own shadowing property */
+    }
+    ancestor = XT_IS_OBJECT(ancestor->prototype) ? (xt_object *)XT_GET_PTR(ancestor->prototype) : NULL;
+  }
   xt_object_reserve(obj, obj->count + 1);
-  obj->properties[obj->count].key = xt_as_string(keyString);
+  obj->properties[obj->count].key = k;
   obj->properties[obj->count].value = newValue;
+  obj->properties[obj->count].getter = XT_UNDEFINED;
+  obj->properties[obj->count].setter = XT_UNDEFINED;
   obj->count++;
   return newValue;
 }
 
+static xt_property *xt_object_ensure_property(xt_object *obj, xt_value keyString) {
+  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
+  if (prop) return prop;
+  xt_object_reserve(obj, obj->count + 1);
+  prop = &obj->properties[obj->count];
+  prop->key = xt_as_string(keyString);
+  prop->value = XT_UNDEFINED;
+  prop->getter = XT_UNDEFINED;
+  prop->setter = XT_UNDEFINED;
+  obj->count++;
+  return prop;
+}
+
+xt_value xt_object_define_getter(xt_value value, xt_value key, xt_value getter) {
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return value;
+  xt_object_ensure_property(obj, xt_to_string(key))->getter = getter;
+  return value;
+}
+
+xt_value xt_object_define_setter(xt_value value, xt_value key, xt_value setter) {
+  xt_object *obj = xt_as_object(value);
+  if (!obj) return value;
+  xt_object_ensure_property(obj, xt_to_string(key))->setter = setter;
+  return value;
+}
+
 xt_value xt_object_get_prototype(xt_value value) {
   xt_object *obj = xt_as_object(value);
   if (obj) return obj->prototype;
@@ -248,21 +332,47 @@ xt_value xt_array_length(xt_value value) {
 }
 
 xt_value xt_array_spread(xt_value target, xt_value source) {
-  if (!XT_IS_ARRAY(target) || !XT_IS_ARRAY(source)) return target;
-  xt_array *dst = (xt_array *)XT_GET_PTR(target);
-  xt_array *src = (xt_array *)XT_GET_PTR(source);
-  xt_array_reserve(dst, dst->length + src->length);
-  for (uint32_t i = 0; i < src->length; i++) dst->items[dst->length++] = src->items[i];
+  if (!XT_IS_ARRAY(target)) return target;
+  if (XT_IS_ARRAY(source)) {
+    xt_array *dst = (xt_array *)XT_GET_PTR(target);
+    xt_array *src = (xt_array *)XT_GET_PTR(source);
+    xt_array_reserve(dst, dst->length + src->length);
+    for (uint32_t i = 0; i < src->length; i++) dst->items[dst->length++] = src->items[i];
+    return target;
+  }
+  /* Spreading a string/Map/Set iterates exactly like `for...of`. */
+  int32_t n = xt_to_int32(xt_iter_length(source));
+  for (int32_t i = 0; i < n; i++) {
+    xt_array_push(target, xt_iter_value(source, xt_number((double)i)));
+  }
   return target;
 }
 
+int32_t xt_array_size(xt_value value) {
+  if (!XT_IS_ARRAY(value)) return 0;
+  return (int32_t)((xt_array *)XT_GET_PTR(value))->length;
+}
+
+xt_value *xt_array_items(xt_value value) {
+  if (!XT_IS_ARRAY(value)) return NULL;
+  return ((xt_array *)XT_GET_PTR(value))->items;
+}
+
 
 /* ------------------------------------------------------------------------- */
 /* Generic member access                                                     */
 /* ------------------------------------------------------------------------- */
 
 xt_value xt_get(xt_value target, xt_value key) {
-  if (XT_IS_ARRAY(target)) return xt_array_get(target, key);
+  if (XT_IS_ARRAY(target)) {
+    /* `arr.length` must read the array's length, never an element. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0)
+        return xt_number((double)((xt_array *)XT_GET_PTR(target))->length);
+    }
+    return xt_array_get(target, key);
+  }
   if (XT_IS_FUNCTION(target)) return xt_object_get(target, key);
   if (XT_IS_OBJECT(target)) {
     /* Map/Set expose `.size`; promises, dates and regexps have their own
@@ -277,6 +387,7 @@ xt_value xt_get(xt_value target, xt_value key) {
         }
       }
     }
+    if (obj->header.kind == XT_OBJECT_KIND_REGEXP) return xt_regexp_get_property(target, key);
     return xt_object_get(target, key);
   }
   if (XT_IS_STRING(target)) {
@@ -294,7 +405,22 @@ xt_value xt_get(xt_value target, xt_value key) {
 }
 
 xt_value xt_set(xt_value target, xt_value key, xt_value value) {
-  if (XT_IS_ARRAY(target)) return xt_array_set(target, key, value);
+  if (XT_IS_ARRAY(target)) {
+    /* Assigning `arr.length` truncates or extends the array. */
+    if (XT_IS_STRING(key)) {
+      xt_string *k = xt_as_string(key);
+      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+        xt_array *array = (xt_array *)XT_GET_PTR(target);
+        int32_t n = xt_to_int32(value);
+        if (n < 0) n = 0;
+        xt_array_reserve(array, (uint32_t)n);
+        for (uint32_t j = array->length; j < (uint32_t)n; j++) array->items[j] = XT_UNDEFINED;
+        array->length = (uint32_t)n;
+        return value;
+      }
+    }
+    return xt_array_set(target, key, value);
+  }
   if (XT_IS_FUNCTION(target)) return xt_object_set(target, key, value);
   if (XT_IS_OBJECT(target)) return xt_object_set(target, key, value);
   return value;

package/runtime/xt_io.c

@@ -69,6 +69,59 @@ void xt_set_program_args(int32_t argc, char **argv) {
   xt_program_argv = argv;
 }
 
+/*
+ * `import.meta` support. The compiler resolves module URLs at build time, but
+ * a self-hosted binary only knows where *it* lives, so `import.meta.url` is the
+ * executable's own `file://` URL (and `dirname`/`filename` its path parts).
+ * This lets the compiler locate an adjacent `runtime/` directory at run time.
+ */
+static xt_value xt_file_url(const char *path) {
+  char url[4300];
+  size_t j = 0;
+  const char *prefix = "file://";
+  for (; *prefix; prefix++) url[j++] = *prefix;
+#if defined(_WIN32)
+  url[j++] = '/';
+#endif
+  for (const char *p = path; *p && j < sizeof(url) - 1; p++) url[j++] = (*p == '\\') ? '/' : *p;
+  url[j] = 0;
+  return xt_string_from_cstr(url);
+}
+
+xt_value xt_import_meta(xt_value name) {
+  const char *prop = xt_string_data(name);
+  const char *raw = (xt_program_argv && xt_program_argv[0]) ? xt_program_argv[0] : "";
+  char resolved[4096];
+  resolved[0] = 0;
+  if (raw[0]) {
+#if defined(_WIN32)
+    if (_fullpath(resolved, raw, sizeof(resolved)) == NULL) resolved[0] = 0;
+#else
+    if (realpath(raw, resolved) == NULL) resolved[0] = 0;
+#endif
+  }
+  const char *abs = resolved[0] ? resolved : raw;
+  if (prop && strcmp(prop, "dirname") == 0) {
+    char dir[4096];
+    size_t n = strlen(abs);
+    if (n >= sizeof(dir)) n = sizeof(dir) - 1;
+    memcpy(dir, abs, n);
+    dir[n] = 0;
+    char *slash = strrchr(dir, '/');
+#if defined(_WIN32)
+    char *back = strrchr(dir, '\\');
+    if (back && (!slash || back > slash)) slash = back;
+#endif
+    if (slash) {
+      if (slash == dir) slash[1] = 0;
+      else *slash = 0;
+    }
+    return xt_string_from_cstr(dir);
+  }
+  if (prop && strcmp(prop, "filename") == 0) return xt_string_from_cstr(abs);
+  return xt_file_url(abs);
+}
+
 void *xt_try_enter(void) {
   xt_try_frame *frame = (xt_try_frame *)calloc(1, sizeof(xt_try_frame));
   if (!frame) abort();

package/runtime/xt_regex.h

@@ -567,9 +567,13 @@ static int xt_re_match_alt(xt_re_alt *alt, const xt_re_input *in, size_t pos,
   return 0;
 }
 
-static int xt_re_accept(void *ctx, size_t pos) {
-  (void)ctx;
-  (void)pos;
+typedef struct {
+  size_t end;
+} xt_re_match_result;
+
+static int xt_re_record_match(void *ctx, size_t pos) {
+  xt_re_match_result *result = (xt_re_match_result *)ctx;
+  result->end = pos;
   return 1;
 }
 
@@ -597,15 +601,21 @@ static int regexec(const regex_t *preg, const char *string, size_t nmatch,
                    regmatch_t pmatch[], int eflags) {
   xt_re_input in;
   size_t start;
-  (void)nmatch;
-  (void)pmatch;
   (void)eflags;
   if (!preg || !preg->root || !string) return 1;
   in.text = string;
   in.len = strlen(string);
   in.icase = preg->icase;
   for (start = 0; start <= in.len; start++) {
-    if (xt_re_match_alt(preg->root, &in, start, xt_re_accept, NULL)) return 0;
+    xt_re_match_result result;
+    result.end = 0;
+    if (xt_re_match_alt(preg->root, &in, start, xt_re_record_match, &result)) {
+      if (nmatch > 0 && pmatch) {
+        pmatch[0].rm_so = (int)start;
+        pmatch[0].rm_eo = (int)result.end;
+      }
+      return 0;
+    }
   }
   return 1;
 }

package/runtime/xt_stdlib.c

@@ -327,6 +327,7 @@ static xt_value xt_string_trim(xt_value value) {
 }
 
 static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value replacementValue) {
+  if (xt_is_regexp(searchValue)) return xt_regexp_replace(value, searchValue, replacementValue);
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
@@ -456,13 +457,21 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
     xt_value result = xt_ext_object_method(target, method, argc, argv, &handled);
     if (handled) return result;
-    xt_throw(xt_string_from_cstr("TypeError: target does not have a callable property of that name"));
+    {
+      char message[256];
+      snprintf(message, sizeof(message), "TypeError: object has no callable method '%s'", method);
+      xt_throw(xt_string_from_cstr(message));
+    }
     return XT_UNDEFINED;
   }
   if (XT_IS_FUNCTION(target)) {
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
-    xt_throw(xt_string_from_cstr("TypeError: target does not have a callable property of that name"));
+    {
+      char message[256];
+      snprintf(message, sizeof(message), "TypeError: function has no callable method '%s'", method);
+      xt_throw(xt_string_from_cstr(message));
+    }
     return XT_UNDEFINED;
   }
   if (XT_IS_ARRAY(target)) {