visaljs 0.0.6 → 0.0.8

package/runtime/src/shape.c

@@ -1,4 +1,4 @@
-/* Shapes (ADR 0005): hidden classes, their transition tree and lookup tables. */
+/* Shapes: hidden classes, their transition tree and lookup tables. */
 #include <stdlib.h>
 #include <string.h>
 
@@ -63,7 +63,7 @@ void js_prop_table_add(JSPropTable *t, JSValue key, uint32_t slot, uint8_t attrs
         reindex(t);
     }
     uint32_t i = t->count++;
-    t->entries[i] = (JSPropEntry){ key, slot, attrs };
+    t->entries[i] = (JSPropEntry){ key, slot, attrs };  /* barrier: the caller's, on the shape */
     uint32_t h = key_hash(key) & (t->index_cap - 1);
     while (t->index[h] >= 0) h = (h + 1) & (t->index_cap - 1);
     t->index[h] = (int32_t)i;
@@ -84,17 +84,6 @@ JSPropTable *js_prop_table_clone(const JSPropTable *src) {
 
 /* ---- Shape cells ---------------------------------------------------------- */
 
-static void shape_visit(JSCell *c, JSTracer *trc) {
-    JSShape *s = (JSShape *)c;
-    js_trace_value(trc, s->proto);
-    js_trace_value(trc, s->key);
-    if (s->parent) js_trace_cell(trc, &s->parent->cell);
-    /* a dictionary's keys exist only in its table; a shared table's keys are on the chain */
-    if (s->table && (s->flags & JS_SHAPE_DICTIONARY))
-        for (uint32_t i = 0; i < s->table->count; i++) js_trace_value(trc, s->table->entries[i].key);
-    /* transitions are weak: children aren't traced (js_shapes_sweep) */
-}
-
 static void shape_finalize(JSRuntime *rt, JSCell *c) {
     (void)rt;
     JSShape *s = (JSShape *)c;
@@ -105,14 +94,15 @@ static void shape_finalize(JSRuntime *rt, JSCell *c) {
     }
 }
 
-const JSCellClass js_shape_cell_class = { "Shape", shape_visit, shape_finalize };
+const JSCellClass js_shape_cell_class = { "Shape", NULL, shape_finalize, NULL }  /* gc_visit.h visits it */;
 
 JSShape *js_alloc_shape(JSContext *ctx) {
     JSShape *s = (JSShape *)js_alloc_cell(ctx, JS_CELL_SHAPE, sizeof(JSShape));
     s->cell.flags |= JS_CELL_FINALIZABLE;  /* tables and transitions are malloc'd */
     js_block_of(s)->has_finalizable = 1;
-    s->proto = JS_NULL;
+    s->proto = JS_NULL;  /* barrier: fresh cell */
     s->key = JS_EMPTY;
+    s->enum_keys = JS_EMPTY;
     return s;
 }
 
@@ -154,7 +144,8 @@ JSShape *js_shape_root(JSContext *ctx, const JSClass *cls, JSValue proto, uint16
         }
     JSShape *s = js_alloc_shape(ctx);  /* may collect: nothing above is held across it */
     s->cls = cls;
-    s->proto = proto;
+    s->proto = proto;  /* barrier: fresh cell */
+    if (js_is_object(proto)) js_as_object(proto)->cell.flags |= JS_CELL_PROTOTYPE;  /* its shape changes now bump proto_epoch */
     s->flags = JS_SHAPE_EXTENSIBLE;
     s->inline_cap = inline_cap;
     s->slot_offset = cls->instance_size;
@@ -178,8 +169,8 @@ JSShape *js_shape_add(JSContext *ctx, JSShape *shape, JSValue key, uint8_t attrs
 
     JSShape *child = js_alloc_shape(ctx);  /* `shape` is kept alive by the caller */
     child->cls = shape->cls;
-    child->proto = shape->proto;
-    child->parent = shape;
+    child->proto = shape->proto;  /* barrier: fresh cell */
+    child->parent = shape;  /* barrier: fresh cell */
     child->key = key;
     child->attrs = attrs;
     child->flags = shape->flags;
@@ -210,7 +201,7 @@ JSShape *js_shape_add(JSContext *ctx, JSShape *shape, JSValue key, uint8_t attrs
 
 /* ---- Lookup ------------------------------------------------------------------- */
 
-#define WALK_LIMIT 8  /* above this many properties, build a table (ADR 0005) */
+#define WALK_LIMIT 8  /* above this many properties, build a table */
 
 static void build_table(JSShape *s) {
     uint32_t n = s->prop_count;

package/runtime/src/streams.c

@@ -1,4 +1,4 @@
-/* ReadableStream (WHATWG Streams §4), the streams component (ADR 0012, layer 2), as Node has it:
+/* ReadableStream (WHATWG Streams §4), the streams component, as Node has it:
  * default streams (an underlying source's start, pull and cancel, a queuing strategy's
  * highWaterMark and size), their default reader and controller, async iteration, and tee. Byte
  * streams' BYOB readers aren't provided yet; `type: 'bytes'` makes a default stream. WritableStream,
@@ -142,7 +142,7 @@ static JSValue rejected_with_exception(JSContext *ctx) { return rejected(ctx, js
 
 /* ---- The queue ------------------------------------------------------------------------------ */
 
-static void queue_push(ControllerObject *k, JSValue chunk, double size) {
+static void queue_push(JSContext *ctx, ControllerObject *k, JSValue chunk, double size) {
     if (k->head > 0 && k->n == k->cap) {  /* reclaim what reads consumed */
         memmove(k->queue, k->queue + k->head, (k->n - k->head) * sizeof *k->queue);
         k->n -= k->head;
@@ -155,8 +155,9 @@ static void queue_push(ControllerObject *k, JSValue chunk, double size) {
         k->queue = q;
         k->cap = cap;
     }
-    k->queue[k->n++] = chunk;
-    k->queue[k->n++] = js_number(size);
+    k->queue[k->n++] = chunk;  /* barrier: below */
+    js_write_barrier(ctx, &k->obj.cell, NULL, chunk);
+    k->queue[k->n++] = js_number(size);  /* barrier: not a cell */
     k->queue_size += size;
 }
 
@@ -310,7 +311,7 @@ static int enqueue(JSContext *ctx, ControllerObject *k, JSValue chunk) {
                 return fail(js_throw(ctx, e));
             }
         }
-        queue_push(k, chunk, size);
+        queue_push(ctx, k, chunk, size);
     }
     call_pull_if_needed(ctx, k);
     return 0;
@@ -463,15 +464,19 @@ JSValue js_new_readable_stream(JSContext *ctx, const JSStreamSource *source, JSV
     return js_rs_new(ctx, source, data, high_water_mark, JS_UNDEFINED, JS_UNDEFINED);
 }
 
-JSValue js_readable_stream_of_bytes(JSContext *ctx, JSValue chunk) {
+/* A closed stream of one chunk (none when undefined): a byte stream, or not */
+static JSValue stream_of(JSContext *ctx, JSValue chunk, bool bytes) {
     JSValue sv = new_stream(ctx, ctx->intrinsics[JS_INTRINSIC_READABLE_STREAM_PROTOTYPE], 0, JS_UNDEFINED);
-    as_stream(sv)->bytes = 1;
+    as_stream(sv)->bytes = bytes;
     ControllerObject *k = controller_of(as_stream(sv));
     k->started = 1;
     if (!js_is_undefined(chunk) && enqueue(ctx, k, chunk) < 0) return JS_EXCEPTION;
     return close_controller(ctx, k) < 0 ? JS_EXCEPTION : sv;
 }
 
+JSValue js_readable_stream_of_bytes(JSContext *ctx, JSValue chunk) { return stream_of(ctx, chunk, true); }
+JSValue js_readable_stream_of_chunk(JSContext *ctx, JSValue chunk) { return stream_of(ctx, chunk, false); }
+
 /* ---- ReadableStream.prototype --------------------------------------------------------------- */
 
 #define THIS_STREAM()                         \
@@ -551,6 +556,15 @@ BUILTIN(reader_ctor) {
     return new_reader(ctx, proto, ARG(0));
 }
 
+/* A chunk read at once from the queue: Node 24's fast path makes it { done: false, value }, where
+ * a read that waits for its chunk gets { value, done: false } */
+static JSValue queued_result(JSContext *ctx, JSValue chunk) {
+    JSValue o = js_new_object(ctx);
+    js_define_data(ctx, js_as_object(o), JS_ATOM(done), JS_FALSE, JS_PROP_DEFAULT);
+    js_define_data(ctx, js_as_object(o), JS_ATOM(value), chunk, JS_PROP_DEFAULT);
+    return o;
+}
+
 /* ReadableStreamDefaultReaderRead: a promise of { value, done } */
 static JSValue reader_read(JSContext *ctx, ReaderObject *r) {
     StreamObject *s = as_stream(r->stream);
@@ -567,7 +581,7 @@ static JSValue reader_read(JSContext *ctx, ReaderObject *r) {
         } else {
             call_pull_if_needed(ctx, k);
         }
-        return resolved(ctx, js_iter_result(ctx, chunk, false));
+        return resolved(ctx, queued_result(ctx, chunk));
     }
     JSValue p = js_new_promise(ctx);
     if (js_array_push(ctx, js_as_object(r->requests), p) < 0) return JS_EXCEPTION;

package/runtime/src/string.c

@@ -1,4 +1,4 @@
-/* Strings (ADR 0003). */
+/* Strings. */
 #include "jsstring.h"
 
 #include <stdlib.h>
@@ -9,37 +9,24 @@
 #include "jscontext.h"
 #include "jsnum.h"
 
-/* ---- GC classes -------------------------------------------------------- */
+/* ---- GC classes (gc_visit.h visits them) ------------------------------- */
 
-static void rope_visit(JSCell *c, JSTracer *trc) {
-    JSRope *r = (JSRope *)c;
-    js_trace_value(trc, r->left);
-    js_trace_value(trc, r->right);
-}
-
-static void slice_visit(JSCell *c, JSTracer *trc) {
-    js_trace_value(trc, ((JSSlice *)c)->parent);
-}
-
-const JSCellClass js_flat_string_class = { "String", NULL, NULL };
-const JSCellClass js_rope_class = { "Rope", rope_visit, NULL };
-const JSCellClass js_slice_class = { "Slice", slice_visit, NULL };
+const JSCellClass js_flat_string_class = { "String", NULL, NULL, NULL };
+const JSCellClass js_rope_class = { "Rope", NULL, NULL, NULL };
+const JSCellClass js_slice_class = { "Slice", NULL, NULL, NULL };
 
 /* ---- Static cells: "" and every unit 0…255 ----------------------------- */
 
-typedef JS_STATIC_LATIN1_TYPE(1) JSStaticChar;
-
 #define CHAR_HASH(u) JS_HASH_FIX(JS_HASH_STEP(JS_HASH_INIT, (u)))
 #define C1(u) JS_STATIC_ATOM_INIT(1, CHAR_HASH(u), { (uint8_t)(u), 0 })
 #define C4(u) C1(u), C1((u) + 1), C1((u) + 2), C1((u) + 3)
 #define C16(u) C4(u), C4((u) + 4), C4((u) + 8), C4((u) + 12)
 #define C64(u) C16(u), C16((u) + 16), C16((u) + 32), C16((u) + 48)
 
-static const JSStaticChar char_strings[256] = { C64(0), C64(64), C64(128), C64(192) };
+const JSStaticChar js_char_strings[256] = { C64(0), C64(64), C64(128), C64(192) };
 static const JS_STATIC_LATIN1_TYPE(0) empty_string = JS_STATIC_ATOM_INIT(0, JS_HASH_FIX(JS_HASH_INIT), { 0 });
 
 JSValue js_empty_string(void) { return js_cell((JSCell *)&empty_string); }
-JSValue js_char_string(uint8_t unit) { return js_cell((JSCell *)&char_strings[unit]); }
 
 /* ---- Flat strings ------------------------------------------------------ */
 
@@ -169,12 +156,8 @@ static unsigned depth_of(JSValue s) {
     return c->kind == JS_CELL_STR_ROPE && !rope_flattened((JSRope *)c) ? ((JSRope *)c)->depth : 0;
 }
 
-/* Copies the leaves into one flat string, iteratively (ropes can be deep),
- * and keeps it in the rope: left = result, right = EMPTY. */
-static JSString *flatten(JSContext *ctx, JSRope *rope) {
-    if (rope_flattened(rope)) return (JSString *)js_as_cell(rope->left);
-    JSString *out = alloc_flat(ctx, rope->length, cell_latin1(&rope->cell));  /* may GC; nothing moves */
-
+/* Copies the leaves of `rope` into `out` from unit 0, iteratively (ropes can be deep). */
+static void copy_rope(JSString *out, JSRope *rope) {
     size_t cap = (size_t)rope->depth + 2, sp = 0;
     JSValue small[64];
     JSValue *stack = cap <= 64 ? small : malloc(cap * sizeof *stack);
@@ -198,7 +181,13 @@ static JSString *flatten(JSContext *ctx, JSRope *rope) {
         at += v.length;
     }
     if (stack != small) free(stack);
+}
 
+/* Copies the leaves into one flat string and keeps it in the rope: left = result, right = EMPTY. */
+static JSString *flatten(JSContext *ctx, JSRope *rope) {
+    if (rope_flattened(rope)) return (JSString *)js_as_cell(rope->left);
+    JSString *out = alloc_flat(ctx, rope->length, cell_latin1(&rope->cell));  /* may GC; nothing moves */
+    copy_rope(out, rope);
     js_store(ctx, &rope->cell, &rope->left, js_cell(&out->cell));
     js_store(ctx, &rope->cell, &rope->right, JS_EMPTY);
     return out;
@@ -213,12 +202,61 @@ JSStrView js_string_view(JSContext *ctx, JSValue s) {
     }
 }
 
+/* ---- Append buffers ---------------------------------------------------- */
+
+/* The buffer `a` is the newest string of (a slice ending at its fill mark), or NULL. */
+static JSString *newest_in_buffer(JSValue a) {
+    JSCell *c = js_as_cell(a);
+    if (c->kind != JS_CELL_STR_SLICE) return NULL;
+    JSSlice *slice = (JSSlice *)c;
+    JSString *p = (JSString *)js_as_cell(slice->parent);
+    return (p->cell.flags & JS_STR_BUFFER) && slice->offset == 0 && slice->length == p->length ? p : NULL;
+}
+
+/* A zero-filled buffer with room for `capacity` units, `used` of them filled by the caller. */
+static JSString *alloc_buffer(JSContext *ctx, uint32_t used, uint32_t capacity, bool latin1) {
+    JSString *s = alloc_flat(ctx, capacity, latin1);
+    s->cell.flags |= JS_STR_BUFFER;
+    s->cell.aux = capacity;
+    s->length = used;
+    return s;
+}
+
+/* a + b continuing in a buffer: in `buf` (the one `a` is the newest string of, or NULL) when `b`
+ * fits, else in a new one with twice the room. Each unit is copied O(1) times on average. */
+static JSValue append(JSContext *ctx, JSString *buf, JSValue a, JSValue b, uint32_t length) {
+    JSStrView vb = js_string_view(ctx, b);  /* may flatten b: a, and so buf, stay live */
+    if (!buf || length > buf->cell.aux || (cell_latin1(&buf->cell) && !vb.latin1)) {
+        uint32_t la = js_string_length(a);
+        JSCell *ca = js_as_cell(a);
+        bool rope = ca->kind == JS_CELL_STR_ROPE && !rope_flattened((JSRope *)ca);
+        bool latin1 = (rope ? cell_latin1(ca) : js_string_view(ctx, a).latin1) && vb.latin1;
+        uint64_t capacity = (uint64_t)length * 2;
+        if (capacity > JS_STRING_MAX_LENGTH) capacity = JS_STRING_MAX_LENGTH;
+        buf = alloc_buffer(ctx, la, (uint32_t)capacity, latin1);  /* vb stays valid: nothing moves */
+        if (rope) copy_rope(buf, (JSRope *)ca);  /* straight into the buffer: no flat copy first */
+        else copy_view(buf, 0, js_string_view(ctx, a));
+    }
+    copy_view(buf, buf->length, vb);  /* past the fill mark: no string sees these units yet */
+    buf->length = length;
+    JSSlice *slice = (JSSlice *)js_alloc_cell(ctx, JS_CELL_STR_SLICE, sizeof(JSSlice));  /* buf is live */
+    slice->cell.flags = cell_latin1(&buf->cell) ? JS_STR_LATIN1 : 0;
+    slice->length = length;
+    slice->offset = 0;
+    js_init_slot(&slice->parent, js_cell(&buf->cell));
+    return js_cell(&slice->cell);
+}
+
+/* a + b: a short result is copied, appending to a buffer's newest string continues in it, a deep
+ * rope (an append loop) moves to a buffer, and anything else is a rope. */
 JSValue js_concat(JSContext *ctx, JSValue a, JSValue b) {
     uint32_t la = js_string_length(a), lb = js_string_length(b);
     if (la == 0) return b;
     if (lb == 0) return a;
     if ((uint64_t)la + lb > JS_STRING_MAX_LENGTH) return string_too_long(ctx);
     uint32_t length = la + lb;
+    JSString *buf = newest_in_buffer(a);
+    if (buf) return append(ctx, buf, a, b, length);
     bool latin1 = cell_latin1(js_as_cell(a)) && cell_latin1(js_as_cell(b));
 
     if (length < JS_ROPE_MIN) {  /* copying is cheaper than a rope */
@@ -229,6 +267,7 @@ JSValue js_concat(JSContext *ctx, JSValue a, JSValue b) {
         return js_cell(&s->cell);
     }
 
+    if (depth_of(a) >= JS_BUFFER_MIN_DEPTH) return append(ctx, NULL, a, b, length);
     unsigned depth = (depth_of(a) > depth_of(b) ? depth_of(a) : depth_of(b)) + 1;
     if (depth > JS_ROPE_MAX_DEPTH) {  /* bound the depth: flatten the deep side(s) */
         if (depth_of(a) >= JS_ROPE_MAX_DEPTH) (void)js_string_view(ctx, a);

package/runtime/src/string_builtins.c

@@ -1,7 +1,7 @@
-/* String and String.prototype (§22.1): core built-ins (ADR 0014). Case conversion and
- * normalization use QuickJS's libunicode (ADR 0015's vendored copy); the regex-based methods
+/* String and String.prototype (§22.1): core built-ins. Case conversion and
+ * normalization use QuickJS's libunicode (vendored with libregexp); the regex-based methods
  * dispatch to @@match/@@replace/@@search/@@split on their argument as the spec makes them, and
- * create a RegExp (the RegExp component, ADR 0015) only where the spec does. */
+ * create a RegExp (the RegExp component) only where the spec does. */
 #include "builtins_util.h"
 
 #include <math.h>
@@ -128,7 +128,7 @@ static JSValue get_method(JSContext *ctx, JSValue v, JSValue key) {
     return f;
 }
 
-/* RegExpCreate (§22.2.3.1), through the RegExp component (ADR 0015). */
+/* RegExpCreate (§22.2.3.1), through the RegExp component. */
 static JSValue regexp_create(JSContext *ctx, JSValue pattern, const char *flags, const char *method) {
     JSValue ctor = ctx->intrinsics[JS_INTRINSIC_REGEXP];
     if (!js_is_function(ctor)) return js_throw_type_error(ctx, "%s needs RegExp (not supported yet)", method);
@@ -368,8 +368,8 @@ CORE(string_proto_to_well_formed) {
     return finish(ctx, &b);
 }
 
-/* localeCompare without Intl (later, M7): by code units. Node compares by ICU collation,
- * which differs for mixed case and accents (plan/unsupported.md). */
+/* localeCompare without Intl: by code units. Node compares by ICU collation,
+ * which differs for mixed case and accents. */
 CORE(string_proto_locale_compare) {
     UNUSED_ARGS;
     JSValue s = this_string(ctx, this_val, "String.prototype.localeCompare");
@@ -728,7 +728,7 @@ CORE(string_proto_to_upper_case) {
     return case_convert(ctx, this_val, false, "String.prototype.toUpperCase");
 }
 
-/* The locale variants without Intl (later, M7): the root locale's mapping. */
+/* The locale variants without Intl: the root locale's mapping. */
 CORE(string_proto_to_locale_lower_case) {
     UNUSED_ARGS;
     return case_convert(ctx, this_val, true, "String.prototype.toLocaleLowerCase");

package/runtime/src/symbol.c

@@ -1,4 +1,4 @@
-/* Symbols (ECMAScript §6.1.5, §20.4; ADR 0001). */
+/* Symbols (ECMAScript §6.1.5, §20.4). */
 #include "js_symbol.h"
 
 #include "internal.h"
@@ -13,12 +13,7 @@
 JS_WELL_KNOWN_SYMBOLS(JS_SYMBOL_DEF)
 #undef JS_SYMBOL_DEF
 
-static void symbol_visit(JSCell *c, JSTracer *trc) {
-    const JSCell *d = ((JSSymbol *)c)->description;
-    if (d) js_trace_value(trc, js_cell((JSCell *)d));
-}
-
-const JSCellClass js_symbol_cell_class = { "Symbol", symbol_visit, NULL };
+const JSCellClass js_symbol_cell_class = { "Symbol", NULL, NULL, NULL };  /* gc_visit.h visits it */
 
 JSValue js_new_symbol(JSContext *ctx, JSValue description) {
     JSSymbol *s = (JSSymbol *)js_alloc_cell(ctx, JS_CELL_SYMBOL, sizeof(JSSymbol));

package/runtime/src/test_host.c

@@ -1,4 +1,4 @@
-/* The test262 host's $262 (ADR 0011). Only test262 units call js_test_host_init, so a
+/* The test262 host's $262. Only test262 units call js_test_host_init, so a
  * program's binary never links this file. */
 #include "internal.h"
 #include "js_builtins.h"
@@ -15,7 +15,7 @@ static JSValue host_create_realm(JSContext *ctx, JSValue callee, JSValue this_va
     return js_test_host_init(js_context_new(ctx->rt));
 }
 
-/* $262.gc(): a full collection (ADR 0002). */
+/* $262.gc(): a full collection. */
 static JSValue host_gc(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
                        const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)argc, (void)argv, (void)new_target;
@@ -44,7 +44,7 @@ static JSValue host_detach_array_buffer(JSContext *ctx, JSValue callee, JSValue
  * (threads), IsHTMLDDA (browser annex). Tests using them fail or are skipped. */
 JSValue js_test_host_init(JSContext *ctx) {
     js_set_rejection_mode(ctx->rt, JS_REJECTIONS_NONE);  /* tests leave rejected promises unhandled */
-    if (!ctx->rt->components) js_install_components(ctx, js_all_components, js_all_components_count);  /* all of them (ADR 0014) */
+    if (!ctx->rt->components) js_install_components(ctx, js_all_components, js_all_components_count);  /* all of them */
     JSValue global = ctx->intrinsics[JS_INTRINSIC_GLOBAL_OBJECT];
     JSValue host = js_new_object(ctx);
     JSObject *h = js_as_object(host);