xbintsc 0.3.3 → 0.3.5

package/runtime/xt_symbol.c

@@ -0,0 +1,149 @@
+/*
+ * xbintsc runtime — Symbol primitives.
+ *
+ * Symbols are heap objects (`XT_OBJECT_KIND_SYMBOL`) tagged as `XT_TAG_OBJECT`
+ * so they can travel through the generic value plumbing, but they are
+ * distinguished by their header kind. Property keys are either strings or
+ * symbols; see `xt_to_property_key` in `xt_containers.c`.
+ */
+
+#include "rt_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  xt_header header;
+  /* `XT_UNDEFINED` for `Symbol()` without a description, otherwise a string. */
+  xt_value description;
+  uint64_t id;
+} xt_symbol_data;
+
+static uint64_t g_symbol_counter = 0;
+
+int xt_is_symbol(xt_value value) {
+  if (!XT_IS_OBJECT(value)) return 0;
+  return ((xt_header *)XT_GET_PTR(value))->kind == XT_OBJECT_KIND_SYMBOL;
+}
+
+static xt_symbol_data *xt_as_symbol(xt_value value) {
+  if (!xt_is_symbol(value)) return NULL;
+  return (xt_symbol_data *)XT_GET_PTR(value);
+}
+
+xt_value xt_symbol_new(xt_value description) {
+  xt_symbol_data *symbol =
+      (xt_symbol_data *)xt_alloc(sizeof(xt_symbol_data), XT_OBJECT_KIND_SYMBOL);
+  symbol->description = description;
+  symbol->id = ++g_symbol_counter;
+  return XT_FROM_PTR(XT_TAG_OBJECT, symbol);
+}
+
+/* -- well-known symbols --------------------------------------------------- */
+
+static const char *const XT_WELL_KNOWN_NAMES[] = {
+    "asyncIterator", "hasInstance",   "isConcatSpreadable", "iterator",
+    "match",         "matchAll",      "replace",            "search",
+    "species",       "split",         "toPrimitive",        "toStringTag",
+    "unscopables",
+};
+#define XT_WELL_KNOWN_COUNT \
+  ((int)(sizeof(XT_WELL_KNOWN_NAMES) / sizeof(XT_WELL_KNOWN_NAMES[0])))
+
+static xt_value g_well_known[XT_WELL_KNOWN_COUNT];
+static int g_well_known_ready = 0;
+
+static void xt_symbol_init_well_known(void) {
+  if (g_well_known_ready) return;
+  g_well_known_ready = 1;
+  for (int i = 0; i < XT_WELL_KNOWN_COUNT; i++) {
+    char buffer[64];
+    snprintf(buffer, sizeof(buffer), "Symbol.%s", XT_WELL_KNOWN_NAMES[i]);
+    g_well_known[i] = xt_symbol_new(xt_string_from_cstr(buffer));
+  }
+}
+
+xt_value xt_symbol_well_known(const char *name) {
+  xt_symbol_init_well_known();
+  for (int i = 0; i < XT_WELL_KNOWN_COUNT; i++) {
+    if (strcmp(name, XT_WELL_KNOWN_NAMES[i]) == 0) return g_well_known[i];
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_symbol_get(xt_value name) {
+  const char *text = xt_string_data(name);
+  if (!text) return XT_UNDEFINED;
+  return xt_symbol_well_known(text);
+}
+
+/* -- description / toString ---------------------------------------------- */
+
+xt_value xt_symbol_description(xt_value value) {
+  xt_symbol_data *symbol = xt_as_symbol(value);
+  return symbol ? symbol->description : XT_UNDEFINED;
+}
+
+xt_value xt_symbol_to_string(xt_value value) {
+  xt_symbol_data *symbol = xt_as_symbol(value);
+  if (!symbol) {
+    xt_throw(xt_string_from_cstr(
+        "TypeError: Symbol.prototype.toString requires that 'this' be a Symbol"));
+  }
+  xt_string *description =
+      XT_IS_STRING(symbol->description) ? xt_as_string(symbol->description) : NULL;
+  size_t length = description ? description->length : 0;
+  char *buffer = (char *)malloc(8 + length);
+  if (!buffer) abort();
+  memcpy(buffer, "Symbol(", 7);
+  if (description) memcpy(buffer + 7, description->data, length);
+  buffer[7 + length] = ')';
+  xt_value result = xt_string_new(buffer, 8 + length);
+  free(buffer);
+  return result;
+}
+
+/* -- constructor and statics ---------------------------------------------- */
+
+xt_value xt_symbol(int32_t argc, xt_value *argv) {
+  xt_value description = xt_arg_at(argc, argv, 0);
+  if (description != XT_UNDEFINED) description = xt_to_string(description);
+  return xt_symbol_new(description);
+}
+
+/* Global symbol registry backing `Symbol.for` / `Symbol.keyFor`. */
+static xt_value g_symbol_registry = XT_UNDEFINED;
+
+xt_value xt_symbol_for(xt_value key) {
+  xt_value keyString = xt_to_string(key);
+  if (g_symbol_registry == XT_UNDEFINED) g_symbol_registry = xt_object_new();
+  xt_value existing = xt_object_get(g_symbol_registry, keyString);
+  if (existing != XT_UNDEFINED) return existing;
+  xt_value symbol = xt_symbol_new(keyString);
+  xt_object_set(g_symbol_registry, keyString, symbol);
+  return symbol;
+}
+
+xt_value xt_symbol_key_for(xt_value value) {
+  if (!xt_is_symbol(value)) {
+    xt_throw(xt_string_from_cstr("TypeError: Symbol.keyFor requires a symbol"));
+  }
+  if (g_symbol_registry == XT_UNDEFINED) return XT_UNDEFINED;
+  xt_value keys = xt_object_keys(g_symbol_registry);
+  xt_array *array = xt_as_array(keys);
+  if (!array) return XT_UNDEFINED;
+  for (uint32_t i = 0; i < array->length; i++) {
+    xt_value key = array->items[i];
+    if (xt_object_get(g_symbol_registry, key) == value) return key;
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_symbol_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, "for") == 0) return xt_symbol_for(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "keyFor") == 0) return xt_symbol_key_for(xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}

package/runtime/xt_values.c

@@ -8,6 +8,7 @@
 #include "rt_internal.h"
 
 #include <math.h>
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -78,11 +79,57 @@ int xt_string_equals(xt_string *a, xt_string *b) {
 }
 
 /*
- * Format a double the way JavaScript's ToString does for the common cases:
- * integers print without a decimal point, everything else uses the shortest
- * representation that round-trips.
+ * ECMAScript number formatting.
+ *
+ * A double is rendered as the shortest decimal string that round-trips, then
+ * laid out with JavaScript's notation rules: fixed notation unless the decimal
+ * exponent is < -6 or >= 21, and a bare (unpadded, explicitly signed) exponent.
+ * The `toFixed`/`toExponential`/`toPrecision` variants reuse the same renderer.
  */
-static void xt_format_double(double d, char *buffer, size_t size) {
+static void xt_render_decimal(int negative, const char *digits, int nd, int exp10, int expo, char *buffer, size_t size) {
+  size_t o = 0;
+  if (negative && o + 1 < size) buffer[o++] = '-';
+  if (expo) {
+    if (o + 1 < size) buffer[o++] = digits[0];
+    if (nd > 1) {
+      if (o + 1 < size) buffer[o++] = '.';
+      for (int i = 1; i < nd && o + 1 < size; i++) buffer[o++] = digits[i];
+    }
+    int written = snprintf(buffer + o, size - o, "e%c%d", exp10 < 0 ? '-' : '+', exp10 < 0 ? -exp10 : exp10);
+    if (written > 0) o += (size_t)written;
+  } else if (exp10 >= 0) {
+    int intDigits = exp10 + 1;
+    if (nd <= intDigits) {
+      for (int i = 0; i < nd && o + 1 < size; i++) buffer[o++] = digits[i];
+      for (int i = nd; i < intDigits && o + 1 < size; i++) buffer[o++] = '0';
+    } else {
+      for (int i = 0; i < intDigits && o + 1 < size; i++) buffer[o++] = digits[i];
+      if (o + 1 < size) buffer[o++] = '.';
+      for (int i = intDigits; i < nd && o + 1 < size; i++) buffer[o++] = digits[i];
+    }
+  } else {
+    if (o + 1 < size) buffer[o++] = '0';
+    if (o + 1 < size) buffer[o++] = '.';
+    for (int i = 0; i < -exp10 - 1 && o + 1 < size; i++) buffer[o++] = '0';
+    for (int i = 0; i < nd && o + 1 < size; i++) buffer[o++] = digits[i];
+  }
+  buffer[o] = '\0';
+}
+
+/* Split a `%e`-formatted string into its significant digits and exponent. */
+static void xt_parse_scientific(const char *sci, char *digits, int *nd, int *exp10) {
+  int n = 0;
+  *exp10 = 0;
+  const char *q = sci;
+  while (*q && *q != 'e' && *q != 'E') {
+    if (*q >= '0' && *q <= '9') digits[n++] = *q;
+    q++;
+  }
+  if (*q == 'e' || *q == 'E') *exp10 = atoi(q + 1);
+  *nd = n;
+}
+
+void xt_number_to_js_string(double d, char *buffer, size_t size) {
   if (isnan(d)) {
     snprintf(buffer, size, "NaN");
     return;
@@ -95,14 +142,121 @@ static void xt_format_double(double d, char *buffer, size_t size) {
     snprintf(buffer, size, "0");
     return;
   }
-  if (d == floor(d) && fabs(d) < 1e21) {
-    snprintf(buffer, size, "%.0f", d);
+  int negative = d < 0;
+  double x = negative ? -d : d;
+  char sci[64];
+  for (int p = 1; p <= 17; p++) {
+    snprintf(sci, sizeof(sci), "%.*e", p - 1, x);
+    if (strtod(sci, NULL) == x) break;
+  }
+  char digits[32];
+  int nd = 0;
+  int exp10 = 0;
+  xt_parse_scientific(sci, digits, &nd, &exp10);
+  while (nd > 1 && digits[nd - 1] == '0') nd--;
+  xt_render_decimal(negative, digits, nd, exp10, exp10 < -6 || exp10 >= 21, buffer, size);
+}
+
+void xt_number_to_exponential(double d, int precision, char *buffer, size_t size) {
+  if (isnan(d)) {
+    snprintf(buffer, size, "NaN");
+    return;
+  }
+  if (isinf(d)) {
+    snprintf(buffer, size, d < 0 ? "-Infinity" : "Infinity");
+    return;
+  }
+  int negative = d < 0;
+  double x = negative ? -d : d;
+  char sci[64];
+  if (precision < 0) {
+    /* No fractionDigits argument: use the shortest round-tripping form. */
+    for (int p = 1; p <= 17; p++) {
+      snprintf(sci, sizeof(sci), "%.*e", p - 1, x);
+      if (strtod(sci, NULL) == x) break;
+    }
+  } else {
+    snprintf(sci, sizeof(sci), "%.*e", precision, x);
+  }
+  char digits[64];
+  int nd = 0;
+  int exp10 = 0;
+  xt_parse_scientific(sci, digits, &nd, &exp10);
+  if (precision < 0) while (nd > 1 && digits[nd - 1] == '0') nd--;
+  xt_render_decimal(negative, digits, nd, exp10, 1, buffer, size);
+}
+
+void xt_number_to_precision(double d, int precision, char *buffer, size_t size) {
+  if (isnan(d)) {
+    snprintf(buffer, size, "NaN");
+    return;
+  }
+  if (isinf(d)) {
+    snprintf(buffer, size, d < 0 ? "-Infinity" : "Infinity");
+    return;
+  }
+  int negative = d < 0;
+  double x = negative ? -d : d;
+  char sci[512];
+  snprintf(sci, sizeof(sci), "%.*e", precision - 1, x);
+  char digits[512];
+  int nd = 0;
+  int exp10 = 0;
+  xt_parse_scientific(sci, digits, &nd, &exp10);
+  xt_render_decimal(negative, digits, nd, exp10, exp10 < -6 || exp10 >= precision, buffer, size);
+}
+
+void xt_number_to_fixed(double d, int precision, char *buffer, size_t size) {
+  if (isnan(d)) {
+    snprintf(buffer, size, "NaN");
+    return;
+  }
+  if (isinf(d)) {
+    snprintf(buffer, size, d < 0 ? "-Infinity" : "Infinity");
+    return;
+  }
+  if (fabs(d) >= 1e21) {
+    xt_number_to_js_string(d, buffer, size);
     return;
   }
-  for (int precision = 1; precision <= 17; precision++) {
-    snprintf(buffer, size, "%.*g", precision, d);
-    if (strtod(buffer, NULL) == d) return;
+  int negative = d < 0;
+  double x = negative ? -d : d;
+  /* 20 guard digits let us round exactly half away from zero, which is what
+     ECMAScript specifies and what `printf`'s round-half-to-even does not. */
+  char raw[1024];
+  snprintf(raw, sizeof(raw), "%.*f", precision + 20, x);
+  const char *dot = strchr(raw, '.');
+  int intLen = dot ? (int)(dot - raw) : (int)strlen(raw);
+  int len = intLen;
+  if (precision > 0) len += 1 + precision;
+  if (len >= (int)sizeof(raw)) len = (int)sizeof(raw) - 1;
+  char work[1024];
+  memcpy(work, raw, (size_t)len);
+  work[len] = '\0';
+  /* The digit that decides rounding is the first one we dropped. With a
+     precision of zero that is the character after the decimal point. */
+  int firstDropped = precision > 0 ? len : (dot ? intLen + 1 : len);
+  if (dot && raw[firstDropped] >= '5') {
+    int i = len - 1;
+    while (i >= 0) {
+      if (work[i] == '.') {
+        i--;
+        continue;
+      }
+      if (work[i] < '9') {
+        work[i]++;
+        break;
+      }
+      work[i] = '0';
+      i--;
+    }
+    if (i < 0) {
+      memmove(work + 1, work, strlen(work) + 1);
+      work[0] = '1';
+    }
   }
+  if (negative) snprintf(buffer, size, "-%s", work);
+  else snprintf(buffer, size, "%s", work);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -131,18 +285,39 @@ double xt_to_number(xt_value v) {
   if (XT_IS_BIGINT(v)) return xt_bigint_to_double_value(v);
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    if (s->length == 0) return 0.0;
-    char *end = NULL;
-    double parsed = strtod(s->data, &end);
-    if (end != s->data + s->length) return NAN;
-    return parsed;
+    const char *begin = s->data;
+    const char *end = s->data + s->length;
+    while (begin < end && isspace((unsigned char)*begin)) begin++;
+    while (end > begin && isspace((unsigned char)end[-1])) end--;
+    size_t length = (size_t)(end - begin);
+    if (length == 0) return 0.0;
+    char stackbuf[128];
+    char *tmp = length < sizeof(stackbuf) ? stackbuf : (char *)malloc(length + 1);
+    memcpy(tmp, begin, length);
+    tmp[length] = '\0';
+    double result;
+    int base = 0;
+    if (length > 2 && tmp[0] == '0' && (tmp[1] == 'x' || tmp[1] == 'X')) base = 16;
+    else if (length > 2 && tmp[0] == '0' && (tmp[1] == 'o' || tmp[1] == 'O')) base = 8;
+    else if (length > 2 && tmp[0] == '0' && (tmp[1] == 'b' || tmp[1] == 'B')) base = 2;
+    if (base != 0) {
+      char *stop = NULL;
+      unsigned long long parsed = strtoull(tmp + 2, &stop, base);
+      result = (*stop == '\0' && stop != tmp + 2) ? (double)parsed : NAN;
+    } else {
+      char *stop = NULL;
+      result = strtod(tmp, &stop);
+      if (stop != tmp + length) result = NAN;
+    }
+    if (tmp != stackbuf) free(tmp);
+    return result;
   }
   return NAN;
 }
 
 static xt_value xt_number_to_string_value(double d) {
   char buffer[64];
-  xt_format_double(d, buffer, sizeof(buffer));
+  xt_number_to_js_string(d, buffer, sizeof(buffer));
   return xt_string_from_cstr(buffer);
 }
 
@@ -178,6 +353,13 @@ xt_value xt_to_string(xt_value v) {
     return result;
   }
   if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function () { [native code] }");
+  if (xt_is_symbol(v)) {
+    xt_throw(xt_string_from_cstr("TypeError: Cannot convert a Symbol value to a string"));
+  }
+  if (XT_IS_OBJECT(v) &&
+      ((xt_object *)XT_GET_PTR(v))->header.kind == XT_OBJECT_KIND_ERROR) {
+    return xt_error_to_string(v);
+  }
   return xt_string_from_cstr("[object Object]");
 }
 
@@ -189,6 +371,7 @@ xt_value xt_typeof(xt_value v) {
   if (v == XT_UNDEFINED) return xt_string_from_cstr("undefined");
   if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function");
   if (v == XT_NULL) return xt_string_from_cstr("object");
+  if (xt_is_symbol(v)) return xt_string_from_cstr("symbol");
   return xt_string_from_cstr("object");
 }
 
@@ -200,7 +383,15 @@ static void xt_throw_mixed_bigint(void) {
   xt_throw(xt_string_from_cstr("TypeError: Cannot mix BigInt and other types, use explicit conversions"));
 }
 
+/* ToPrimitive for the operators: arrays/objects/functions stringify (their
+   `valueOf` is the object itself, so `toString` decides). */
+static int xt_is_object_like(xt_value v) { return XT_IS_OBJECT(v) || XT_IS_ARRAY(v) || XT_IS_FUNCTION(v); }
+
+static xt_value xt_to_primitive(xt_value v) { return xt_is_object_like(v) ? xt_to_string(v) : v; }
+
 xt_value xt_add(xt_value a, xt_value b) {
+  a = xt_to_primitive(a);
+  b = xt_to_primitive(b);
   if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) {
     return xt_number(xt_to_double(a) + xt_to_double(b));
   }
@@ -364,6 +555,8 @@ static int xt_compare_numeric(xt_value a, xt_value b) {
 }
 
 xt_value xt_lt(xt_value a, xt_value b) {
+  a = xt_to_primitive(a);
+  b = xt_to_primitive(b);
   if (XT_IS_STRING(a) && XT_IS_STRING(b)) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
@@ -377,6 +570,8 @@ xt_value xt_lt(xt_value a, xt_value b) {
 }
 
 xt_value xt_le(xt_value a, xt_value b) {
+  a = xt_to_primitive(a);
+  b = xt_to_primitive(b);
   if (XT_IS_STRING(a) && XT_IS_STRING(b)) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
@@ -396,10 +591,21 @@ xt_value xt_gt(xt_value a, xt_value b) { return xt_lt(b, a); }
 xt_value xt_ge(xt_value a, xt_value b) { return xt_le(b, a); }
 
 static int xt_loose_equals(xt_value a, xt_value b) {
+  if (xt_is_symbol(a) || xt_is_symbol(b)) return a == b;
   if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) return xt_to_double(a) == xt_to_double(b);
   if (XT_IS_STRING(a) && XT_IS_STRING(b)) return xt_string_equals(xt_as_string(a), xt_as_string(b));
   if (a == b) return 1;
   if ((a == XT_NULL && b == XT_UNDEFINED) || (a == XT_UNDEFINED && b == XT_NULL)) return 1;
+  /* Abstract equality converts an object operand to a primitive (via
+     ToPrimitive) before comparing, so `[] == 0`, `[1] == 1` and
+     `{} == "[object Object]"` are all true. */
+  if (XT_IS_OBJECT(a) || XT_IS_ARRAY(a) || XT_IS_FUNCTION(a)) {
+    if (XT_IS_OBJECT(b) || XT_IS_ARRAY(b) || XT_IS_FUNCTION(b)) return 0;
+    return xt_loose_equals(xt_to_string(a), b);
+  }
+  if (XT_IS_OBJECT(b) || XT_IS_ARRAY(b) || XT_IS_FUNCTION(b)) {
+    return xt_loose_equals(a, xt_to_string(b));
+  }
   if (XT_IS_BIGINT(a) || XT_IS_BIGINT(b)) {
     xt_value big = XT_IS_BIGINT(a) ? a : b;
     xt_value other = XT_IS_BIGINT(a) ? b : a;

package/scripts/build-runtime.ts

@@ -73,7 +73,7 @@ function compile(sources: readonly string[], extension: string): string[] {
     const object = join(objDir, `${extension}_${index}_${basename(source, ".c")}.o`);
     const result = spawnSync(
       clang,
-      ["-O2", "-D_CRT_SECURE_NO_WARNINGS", "-c", source, "-o", object, `-I${runtimeDir}`],
+      ["-O2", "-Wall", "-Wextra", "-D_CRT_SECURE_NO_WARNINGS", "-c", source, "-o", object, `-I${runtimeDir}`],
       { stdio: "inherit", env: childEnv },
     );
     if (result.status !== 0) {

package/src/ast/expressions.ts

@@ -55,11 +55,15 @@ export interface NoSubstitutionTemplateLiteral extends Node {
   readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
   readonly text: string;
   readonly value: string;
+  /** Raw text between the backticks (escapes preserved), for tagged templates. */
+  readonly raw?: string;
 }
 
 export interface TemplateLiteral extends Node {
   readonly kind: SyntaxKind.TemplateLiteral;
   readonly head: string;
+  /** Raw text of the head chunk, for tagged templates. */
+  readonly raw?: string;
   readonly spans: TemplateSpan[];
 }
 
@@ -67,6 +71,8 @@ export interface TemplateSpan extends Node {
   readonly kind: SyntaxKind.TemplateSpan;
   readonly expression: Expression;
   readonly literal: string;
+  /** Raw text of the chunk that follows this substitution. */
+  readonly raw?: string;
   /** True when this span terminates the template (tail) rather than continues it. */
   readonly isTail: boolean;
 }
@@ -108,6 +114,8 @@ export interface PropertyAssignment extends Node {
   readonly kind: SyntaxKind.PropertyAssignment;
   readonly name: PropertyName;
   readonly initializer: Expression;
+  /** `get x() {}` / `set x(v) {}` in an object literal. */
+  readonly accessor?: "get" | "set";
 }
 
 export interface ShorthandPropertyAssignment extends Node {

package/src/binder/binder.ts

@@ -108,6 +108,7 @@ export class Binder {
       isModule,
       isArrow,
       isAsync: (((node as { flags?: number }).flags ?? 0) & NodeFlags.Async) !== 0,
+      isGenerator: (((node as { flags?: number }).flags ?? 0) & NodeFlags.Generator) !== 0,
       usesThis: false,
       capturesThis: false,
     };
@@ -120,7 +121,6 @@ export class Binder {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface Binder extends DeclarationMethods, ReferenceMethods {}
 
 Object.assign(Binder.prototype, declarationMethods, referenceMethods);

package/src/binder/references.ts

@@ -49,7 +49,7 @@ export interface ReferenceMethods {
   bindNode(this: Binder, node: Node | undefined, scope: Scope): void;
   bindVariableList(this: Binder, list: VariableDeclarationList, scope: Scope): void;
   bindBindingPattern(this: Binder, name: BindingName, scope: Scope): void;
-  bindFunction(this: Binder, node: FunctionDeclaration | FunctionExpression | ArrowFunction, parentScope: Scope, symbol: SymbolInfo | undefined): void;
+  bindFunction(this: Binder, node: FunctionDeclaration | FunctionExpression | ArrowFunction, parentScope: Scope, symbol: SymbolInfo | undefined, inferredName?: string): void;
   bindClass(this: Binder, node: ClassDeclaration | ClassExpression, scope: Scope): void;
   createClassFunction(this: Binder, member: Node, name: string, parameters: readonly Parameter[], body: Block | undefined, parentScope: Scope, info: ClassInfo, isStatic: boolean, isConstructor: boolean): FunctionInfo;
   reference(this: Binder, identifier: Identifier, scope: Scope): void;
@@ -80,7 +80,6 @@ export const referenceMethods: ReferenceMethods = {
       case SyntaxKind.FunctionDeclaration: {
         const fn = node as FunctionDeclaration;
         const symbol = this.symbolOfDeclaration.get(fn);
-        if (symbol) (symbol.declarations as Node[]).length; // keep declaration mapping warm
         this.bindFunction(fn, scope, symbol);
         return;
       }
@@ -108,7 +107,24 @@ export const referenceMethods: ReferenceMethods = {
         if (property.name.kind === SyntaxKind.ComputedPropertyName) {
           this.bindNode((property.name as unknown as { expression: Expression }).expression, scope);
         }
-        this.bindNode(property.initializer, scope);
+        const initializer = property.initializer;
+        if (
+          initializer.kind === SyntaxKind.FunctionExpression ||
+          initializer.kind === SyntaxKind.ArrowFunction
+        ) {
+          // Infer the function name from the property key (`{ sum() {} }`).
+          const accessor = (property as unknown as { accessor?: "get" | "set" }).accessor;
+          const key = classMemberName(property.name);
+          const inferred = accessor ? `${accessor} ${key}` : key;
+          this.bindFunction(
+            initializer as FunctionExpression | ArrowFunction,
+            scope,
+            undefined,
+            inferred,
+          );
+        } else {
+          this.bindNode(initializer, scope);
+        }
         return;
       }
       case SyntaxKind.ShorthandPropertyAssignment: {
@@ -202,7 +218,23 @@ export const referenceMethods: ReferenceMethods = {
       } else {
         this.bindBindingPattern(declaration.name, scope);
       }
-      this.bindNode(declaration.initializer, scope);
+      const initializer = declaration.initializer;
+      if (
+        declaration.name.kind === SyntaxKind.Identifier &&
+        initializer &&
+        (initializer.kind === SyntaxKind.FunctionExpression ||
+          initializer.kind === SyntaxKind.ArrowFunction)
+      ) {
+        // Infer the function name from the variable it is assigned to.
+        this.bindFunction(
+          initializer as FunctionExpression | ArrowFunction,
+          scope,
+          undefined,
+          (declaration.name as Identifier).text,
+        );
+      } else {
+        this.bindNode(initializer, scope);
+      }
     }
   },
 
@@ -221,6 +253,7 @@ export const referenceMethods: ReferenceMethods = {
     node: FunctionDeclaration | FunctionExpression | ArrowFunction,
     parentScope: Scope,
     symbol: SymbolInfo | undefined,
+    inferredName?: string,
   ): void {
     const name =
       node.kind === SyntaxKind.FunctionDeclaration
@@ -230,6 +263,9 @@ export const referenceMethods: ReferenceMethods = {
           : "(arrow)";
     const parentFn = this.current;
     const fn = this.createFunction(name, node, parentFn, false, node.kind === SyntaxKind.ArrowFunction);
+    if (inferredName && (name === "(anonymous)" || name === "(arrow)")) {
+      (fn as { name: string }).name = inferredName;
+    }
     this.current = fn;
 
     const scope = this.createScope(ScopeKind.Function, node, parentScope);
@@ -309,6 +345,13 @@ export const referenceMethods: ReferenceMethods = {
         const method = member as MethodDeclaration;
         const isStatic = method.modifiers.some((modifier) => modifier.modifierKind === ModifierKind.Static);
         const fn = this.createClassFunction(method, classMemberName(method.name), method.parameters, method.body, classScope, info, isStatic, false);
+        if (method.name.kind === SyntaxKind.ComputedPropertyName) {
+          // Computed member names are evaluated in the enclosing scope when
+          // the class is defined, so bind them there.
+          const keyExpression = (method.name as unknown as { expression: Expression }).expression;
+          this.bindNode(keyExpression, scope);
+          (fn as MutableFunction & { computedKey: Expression }).computedKey = keyExpression;
+        }
         if (isStatic) (info.statics as FunctionInfo[]).push(fn);
         else (info.methods as FunctionInfo[]).push(fn);
       }

package/src/binder/types.ts

@@ -61,12 +61,16 @@ export interface FunctionInfo {
   readonly isArrow: boolean;
   /** True when the function was declared `async`. */
   readonly isAsync: boolean;
+  /** True for `function*` / generator methods; calling one creates a generator. */
+  readonly isGenerator: boolean;
   /** True when this function's body mentions `this` directly. */
   usesThis: boolean;
   /** True when an arrow function must receive `this` from its enclosing scope. */
   capturesThis: boolean;
   /** Set for class methods/constructors; carries the owning class. */
   classInfo?: ClassInfo;
+  /** Computed member name (`[expr]() {}`), evaluated at class definition. */
+  computedKey?: Expression;
   /** True for `static` class members. */
   isStatic?: boolean;
   /** True for an explicit `constructor`. */

package/src/cli/main.ts

@@ -13,9 +13,8 @@
 
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { DiagnosticBag, formatDiagnostic, type Diagnostic } from "../diagnostics/diagnostic.js";
+import { formatDiagnostic, type Diagnostic } from "../diagnostics/diagnostic.js";
 import { SourceFile } from "../diagnostics/source.js";
 import { build, compileEntry, COMPILER_VERSION, type EmitKind } from "../driver/compiler.js";
 import { findRuntimeDir, platformSlug } from "../driver/paths.js";