visaljs 0.0.8 → 0.0.10

package/runtime/src/function.c

@@ -222,10 +222,38 @@ JSValue js_get_prototype_from_constructor(JSContext *ctx, JSValue new_target, JS
     return realm ? realm->intrinsics[fallback] : JS_EXCEPTION;
 }
 
+/* The root shape of the objects `new f` makes, with at least `slots` inline slots: kept on f, and
+ * grown by learn_instance_slots to what its instances end up holding. */
+static JSShape *instance_root(JSContext *ctx, JSFunction *f, JSValue proto, uint16_t slots) {
+    JSShape *s = f->instance_shape;
+    if (JS_UNLIKELY(!s || !js_same_bits(s->proto, proto) || s->inline_cap < slots)) {
+        s = js_shape_root(ctx, &js_class_object, proto, slots);
+        js_store_ptr(ctx, &f->obj.cell, &f->instance_shape, s);
+    }
+    return s;
+}
+
+/* Slack tracking: when the constructors (a class's and its bases') left `v` with more properties
+ * than its root shape has inline slots, the next instances get room for them all. A derived
+ * class's `this` is made by its base, which can't count its subclasses' properties; the rest
+ * would sit out of line, where an inline cache's hit isn't inlined. */
+static void learn_instance_slots(JSContext *ctx, JSFunction *f, JSValue v) {
+    JSShape *root = f->instance_shape;
+    if (!root || !js_is_object(v)) return;
+    JSShape *s = js_as_object(v)->shape;
+    if (JS_LIKELY(s->prop_count <= root->inline_cap || root->inline_cap >= JS_MAX_INLINE_SLOTS)) return;
+    JSShape *r = s;
+    while (r->parent) r = r->parent;
+    if (r != root) return;  /* not made from it: an object the constructor returned, or a dictionary */
+    JSShape *grown = js_shape_root(ctx, &js_class_object, root->proto, (uint16_t)(s->prop_count < JS_MAX_INLINE_SLOTS ? s->prop_count : JS_MAX_INLINE_SLOTS));
+    js_store_ptr(ctx, &f->obj.cell, &f->instance_shape, grown);
+}
+
 JSValue js_create_from_constructor(JSContext *ctx, JSValue new_target, JSIntrinsic fallback) {
     JSValue proto = js_get_prototype_from_constructor(ctx, new_target, fallback);
     if (js_is_exception(proto)) return JS_EXCEPTION;
-    return js_new_object_proto(ctx, proto, JS_DEFAULT_INLINE_SLOTS);
+    if (!js_is_function(new_target)) return js_new_object_proto(ctx, proto, JS_DEFAULT_INLINE_SLOTS);
+    return js_object_value(js_alloc_object(ctx, JS_CELL_OBJECT, instance_root(ctx, js_as_function(new_target), proto, JS_DEFAULT_INLINE_SLOTS)));
 }
 
 JSValue js_new_instance(JSContext *ctx, JSValue fv, uint16_t slots, JSPropCache *ic) {
@@ -234,26 +262,25 @@ JSValue js_new_instance(JSContext *ctx, JSValue fv, uint16_t slots, JSPropCache
                                                                     : js_get_prop(ctx, fv, JS_ATOM(prototype), ic);
     if (js_is_exception(proto)) return JS_EXCEPTION;
     if (!js_is_object(proto)) proto = ctx->intrinsics[JS_INTRINSIC_OBJECT_PROTOTYPE];  /* OrdinaryCreateFromConstructor's fallback */
-    JSFunction *f = js_as_function(fv);
-    JSShape *s = f->instance_shape;
-    if (JS_UNLIKELY(!s || !js_same_bits(s->proto, proto) || s->inline_cap != slots)) {
-        s = js_shape_root(ctx, &js_class_object, proto, slots);
-        js_store_ptr(ctx, &f->obj.cell, &f->instance_shape, s);
-    }
-    return js_object_value(js_alloc_object(ctx, JS_CELL_OBJECT, s));
+    return js_object_value(js_alloc_object(ctx, JS_CELL_OBJECT, instance_root(ctx, js_as_function(fv), proto, slots)));
 }
 
 JSValue js_construct(JSContext *ctx, JSValue f, uint32_t argc, const JSValue *argv, JSValue new_target, const char *callee_text) {
     if (JS_UNLIKELY(!js_is_constructor(f))) return not_callable(ctx, f, callee_text, "constructor");
     JSFunction *fn = js_as_function(f);
+    bool outermost = js_is_undefined(new_target) || js_same_bits(new_target, f);  /* not a super() */
     if (js_is_undefined(new_target)) new_target = f;
-    if (!(fn->flags & JS_FN_ORDINARY))  /* builtins create their own object; a derived constructor gets it from super() */
-        return fn->entry(fn->flags & JS_FN_PROXY ? ctx : fn->realm, f, JS_UNDEFINED, argc, argv, new_target);
+    if (!(fn->flags & JS_FN_ORDINARY)) {  /* builtins create their own object; a derived constructor gets it from super() */
+        JSValue r = fn->entry(fn->flags & JS_FN_PROXY ? ctx : fn->realm, f, JS_UNDEFINED, argc, argv, new_target);
+        if (outermost && (fn->flags & JS_FN_DERIVED) && !js_is_exception(r)) learn_instance_slots(ctx, fn, r);
+        return r;
+    }
     /* [[Construct]] of an ordinary function (§10.2.2): this = a new object; an object result wins */
     JSValue this_val = js_create_from_constructor(fn->realm, new_target, JS_INTRINSIC_OBJECT_PROTOTYPE);
     if (js_is_exception(this_val)) return JS_EXCEPTION;
     JSValue r = fn->entry(fn->realm, f, this_val, argc, argv, new_target);
     if (js_is_exception(r)) return JS_EXCEPTION;
+    if (outermost) learn_instance_slots(ctx, fn, this_val);
     return js_is_object(r) ? r : this_val;
 }
 

package/runtime/src/gc.c

@@ -1646,8 +1646,10 @@ static void mark_roots(JSRuntime *rt, JSTracer *trc) {
     js_trace_value(trc, rt->async_context);
     js_jobs_trace(rt, trc);  /* queued jobs, unhandled rejections */
     js_weak_trace_roots(rt, trc);  /* the WeakRef kept-alive set */
-    for (JSContext *realm = rt->realms; realm; realm = realm->next_realm)
+    for (JSContext *realm = rt->realms; realm; realm = realm->next_realm) {
         for (unsigned i = 0; i < JS_INTRINSIC_COUNT; i++) js_trace_value(trc, realm->intrinsics[i]);
+        if (realm->array_shape) js_trace_cell(trc, &realm->array_shape->cell);
+    }
     for (size_t t = 0; t < h->root_table_count; t++)
         for (size_t i = 0; i < h->root_tables[t].n; i++) js_trace_value(trc, h->root_tables[t].slots[i]);
     for (size_t i = 0; i < h->root_count; i++) js_trace_value(trc, *h->roots[i]);
@@ -1910,14 +1912,14 @@ static JS_NOINLINE void collect(JSContext *ctx, const void *stack_low, bool full
     mark_roots(rt, trc);
     mark_stack(trc);
     drain(trc);
-    while (js_weak_ephemerons(rt, trc)) drain(trc);  /* a WeakMap value lives if its key does */
+    while (js_weak_ephemerons(rt, trc, full)) drain(trc);  /* a WeakMap value lives if its key does */
     h->mark_stack = trc->stack;  /* kept for the next collection */
     h->mark_stack_cap = trc->cap;
     double marked = js_os_now_ms_precise();
 
-    js_weak_sweep(rt);
-    js_atoms_sweep(rt);  /* weak references, before anything is freed */
-    js_shapes_sweep(rt);
+    js_weak_sweep(rt, full);
+    js_atoms_sweep(rt, full);  /* weak references, before anything is freed */
+    js_shapes_sweep(rt, full);
     js_prop_caches_sweep(rt);
     double weak = js_os_now_ms_precise();
 

package/runtime/src/internal.h

@@ -12,7 +12,7 @@
 bool js_gc_is_marked(const JSCell *c);
 
 /* Shapes (shape.c): weak processing after marking, and teardown. */
-void js_shapes_sweep(JSRuntime *rt);
+void js_shapes_sweep(JSRuntime *rt, bool full);
 void js_shapes_free(JSRuntime *rt);
 /* Inline caches (object.c): weak processing after marking, and teardown. */
 void js_prop_caches_sweep(JSRuntime *rt);
@@ -55,8 +55,8 @@ void js_promise_then_internal(JSContext *ctx, JSValue promise, JSValue on_fulfil
  * marked anything), weak processing after marking, the kept-alive roots, teardown;
  * ClearKeptObjects; the FinalizationRegistry cleanup tasks (0, or -1 after an uncaught
  * error); the realm's WeakMap, WeakSet, WeakRef, FinalizationRegistry. */
-bool js_weak_ephemerons(JSRuntime *rt, JSTracer *trc);
-void js_weak_sweep(JSRuntime *rt);
+bool js_weak_ephemerons(JSRuntime *rt, JSTracer *trc, bool full);
+void js_weak_sweep(JSRuntime *rt, bool full);
 void js_weak_trace_roots(JSRuntime *rt, JSTracer *trc);
 void js_weak_free(JSRuntime *rt);
 void js_clear_kept_objects(JSRuntime *rt);
@@ -64,7 +64,7 @@ int js_run_finalization_cleanups(JSContext *ctx);
 
 /* Atom table lifecycle (atoms.c). */
 void js_atoms_init(JSRuntime *rt);
-void js_atoms_sweep(JSRuntime *rt);  /* weak processing: drop unmarked atoms */
+void js_atoms_sweep(JSRuntime *rt, bool full);  /* weak processing: drop unmarked atoms */
 void js_atoms_free(JSRuntime *rt);
 
 /* Cell classes defined outside gc.c: each kind's name and finalizer. The marker visits these kinds

package/runtime/src/iterator.c

@@ -236,7 +236,11 @@ JSValue js_iter_next(JSContext *ctx, JSValue rec) {
     if (r->done) return JS_EMPTY;
     JSValue value;
     if (r->mode == MODE_ARRAY) {
-        value = array_step(ctx, r->iterator, r->index, KIND_VALUES);
+        /* a dense array's present element: what array_step's [[Get]] would read */
+        const JSElements *d = js_as_object(r->iterator)->elements;
+        uint32_t i = (uint32_t)r->index;
+        if (JS_LIKELY(d->kind == JS_ELEMENTS_DENSE && r->index < d->length && !js_is_empty(d->data[i]))) value = d->data[i];
+        else value = array_step(ctx, r->iterator, r->index, KIND_VALUES);
         r->index++;
     } else if (r->mode == MODE_STRING) {
         uint32_t i = (uint32_t)r->index;

package/runtime/src/object.c

@@ -697,8 +697,7 @@ const JSClass js_class_array = {
     "Array", sizeof(JSObject), array_get_own, array_define, array_delete, array_extra_keys, NULL, NULL, NULL,
 };
 
-static JSValue array_with_proto(JSContext *ctx, JSValue proto, uint32_t capacity) {
-    JSShape *shape = js_shape_root(ctx, &js_class_array, proto, 0);  /* named properties on arrays are rare */
+static JSValue array_of_shape(JSContext *ctx, JSShape *shape, uint32_t capacity) {
     JSObject *a = js_alloc_object(ctx, JS_CELL_ARRAY, shape);
     if (capacity) {
         JSElements *e = (JSElements *)js_alloc_cell(ctx, JS_CELL_ELEMENTS, sizeof(JSElements) + (size_t)capacity * sizeof(JSValue));
@@ -709,8 +708,13 @@ static JSValue array_with_proto(JSContext *ctx, JSValue proto, uint32_t capacity
     return js_object_value(a);
 }
 
+static JSValue array_with_proto(JSContext *ctx, JSValue proto, uint32_t capacity) {
+    return array_of_shape(ctx, js_shape_root(ctx, &js_class_array, proto, 0), capacity);  /* named properties on arrays are rare */
+}
+
 JSValue js_new_array(JSContext *ctx, uint32_t capacity) {
-    return array_with_proto(ctx, ctx->intrinsics[JS_INTRINSIC_ARRAY_PROTOTYPE], capacity);
+    if (JS_UNLIKELY(!ctx->array_shape)) ctx->array_shape = js_shape_root(ctx, &js_class_array, ctx->intrinsics[JS_INTRINSIC_ARRAY_PROTOTYPE], 0);
+    return array_of_shape(ctx, ctx->array_shape, capacity);
 }
 
 JSValue js_new_array_from(JSContext *ctx, const JSValue *values, uint32_t n) {
@@ -821,7 +825,7 @@ JSValue js_get_value(JSContext *ctx, JSValue obj, JSValue key) {
 }
 
 int js_set_value(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict) {
-    if (js_is_object(obj)) return js_set(ctx, js_as_object(obj), key, v, obj, strict);
+    if (js_is_object(obj)) return js_key_is_index(key) ? js_set(ctx, js_as_object(obj), key, v, obj, strict) : js_set_prop_slow(ctx, obj, key, v, strict, NULL);
     if (js_is_nullish(obj)) {
         js_discard(nullish_error(ctx, obj, key, "set"));
         return -1;
@@ -1045,6 +1049,11 @@ int js_set_prop_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool s
     JS_ASSERT_NOT_EXC(obj);
     JS_ASSERT_NOT_EXC(v);
     if (!js_is_object(obj) || js_key_is_index(key)) return js_set_value(ctx, obj, key, v, strict);
+    JSPropCache none;  /* no site (a computed key): only the shared cache */
+    if (!ic) {
+        none.kind = JS_IC_EMPTY;
+        ic = &none;
+    }
     JSObject *o = js_as_object(obj);
     if (ic->kind == JS_IC_ADD && o->shape == ic->shape && chain_holds(ctx, ic)) {
         JSShape *next = ic->next;  /* on the stack: kept alive if ensure_slot collects */
@@ -1083,8 +1092,10 @@ int js_set_prop_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool s
         return 1;
     }
     int r = js_set(ctx, o, key, v, obj, strict);
-    /* a plain add (no setter or read-only property on the chain): remember the transition */
-    if (r == 1 && cacheable && !l.holder && !before->cls->define_own_property && !is_dictionary(o) &&
+    /* a plain add (no setter or read-only property on the chain, or a prototype's writable data
+     * property it shadows, as EventEmitter.prototype._events): remember the transition */
+    bool shadows = l.holder && l.holder != o && (l.attrs & (JS_PROP_WRITABLE | JS_PROP_ACCESSOR)) == JS_PROP_WRITABLE;
+    if (r == 1 && cacheable && (!l.holder || shadows) && !before->cls->define_own_property && !is_dictionary(o) &&
         o->shape->parent == before && js_same_bits(o->shape->key, key)) {
         JSPropCache c = { .kind = JS_IC_ADD, .depth = l.depth, .shape = before, .next = o->shape, .epoch = epoch };
         memcpy(c.chain, l.chain, sizeof c.chain);
@@ -1098,9 +1109,32 @@ int js_set_prop_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool s
 
 /* ---- Generated code: computed keys, delete, literals --------------------------------- */
 
+/* Whether `key` can be a keyed site's: a property key as it is (a symbol, an interned string
+ * that isn't an index), so that the same bits mean the same key. Makes the site its. */
+static bool take_site_key(JSContext *ctx, JSValue key, JSValue *site, JSPropCache *ic) {
+    if (!js_is_symbol(key) && !(js_is_string(key) && js_is_atom(key))) return false;
+    JSValue k = js_to_property_key(ctx, key);  /* a primitive: no user code */
+    if (!js_same_bits(k, key) || js_key_is_index(k)) return false;
+    memset(ic, 0, sizeof *ic);  /* its entries were for the old key */
+    *site = key;
+    return true;
+}
+
+JSValue js_get_keyed_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue *site, JSPropCache *ic) {
+    if (take_site_key(ctx, key, site, ic)) return js_get_prop(ctx, obj, key, ic);
+    return js_get_elem(ctx, obj, key);
+}
+
+int js_set_keyed_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict, JSValue *site, JSPropCache *ic) {
+    if (take_site_key(ctx, key, site, ic)) return js_set_prop(ctx, obj, key, v, strict, ic);
+    return js_set_elem(ctx, obj, key, v, strict);
+}
+
 JSValue js_get_elem(JSContext *ctx, JSValue obj, JSValue key) {
     JS_ASSERT_NOT_EXC(obj);
     JS_ASSERT_NOT_EXC(key);
+    JSValue elem;  /* a typed array's element: the component reads it inline */
+    if (js_is_int32(key) && ctx->rt->typed_array_get && ctx->rt->typed_array_get(obj, js_as_int32(key), &elem)) return elem;
     if (js_is_nullish(obj)) {
         JSValue k = js_is_object(key) ? key : js_to_property_key(ctx, key);  /* primitives only: no user code */
         if (js_is_exception(k)) return JS_EXCEPTION;
@@ -1113,6 +1147,8 @@ JSValue js_get_elem(JSContext *ctx, JSValue obj, JSValue key) {
 
 int js_set_elem(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict) {
     JS_ASSERT_NOT_EXC(v);
+    /* a Number into a typed array's element: no ToNumber code to run, the component stores it inline */
+    if (js_is_int32(key) && js_is_number(v) && ctx->rt->typed_array_set && ctx->rt->typed_array_set(obj, js_as_int32(key), js_as_number(v))) return 1;
     if (js_is_nullish(obj)) {
         JSValue k = js_is_object(key) ? js_empty_string() : js_to_property_key(ctx, key);
         if (js_is_exception(k)) return -1;