@swf2es/runtime 0.1.12 → 0.1.14

package/dist/avm2/runtime.js

@@ -41,6 +41,19 @@ export { NOT_FOUND } from "./descriptors.js";
  * checks for it, and fails as a sealed object does.
  */
 export const SEALED_ELEMENTS = Object.freeze([]);
+/**
+ * The scopes a contested function's chain has past those all its creators'
+ * chains share, in one entry of the chain (Runtime.packScope): `w` has a bit
+ * for each that is a with scope, as a Scope's has.
+ */
+class ScopePack {
+    scopes;
+    w;
+    constructor(scopes, w) {
+        this.scopes = scopes;
+        this.w = w;
+    }
+}
 /** The value of `o`'s dynamic property `name`, or NOT_FOUND. */
 function dynamicValue(o, name) {
     const d = o.$d;
@@ -171,6 +184,8 @@ export class Runtime {
     /** Empty the inline caches, so that they keep no traits or code of what is being let go of. */
     forgetCaches() {
         invalidate();
+        this.stringNames = new WeakMap();
+        this.stringNamesEpoch = epoch();
     }
     // Names.
     ns(kind, uri) {
@@ -227,15 +242,27 @@ export class Runtime {
     typeName(_N, _V, _S, base, param) {
         return new TypeName(base, [param]);
     }
-    /** A multiname with its runtime namespace and name, from the stack. */
-    runtimeName(mn, ...parts) {
+    /**
+     * A multiname with its runtime namespace and name, from the stack: `a`
+     * the namespace where it has one at run time, and then `b` the name,
+     * else `a` the name. Two parameters, not a rest: a lookup by a name made
+     * at run time calls this each time, and a rest is an array each call.
+     */
+    runtimeName(mn, a, b) {
+        if (!mn.runtimeNs &&
+            mn.runtimeName &&
+            mn.cache !== NO_CACHE &&
+            typeof a === "string" &&
+            a.length <= 128) {
+            return this.stringName(mn, a);
+        }
         let namespaces = mn.namespaces;
         let versions = mn.versions;
-        let k = 0;
+        let last = a;
         if (mn.runtimeNs) {
-            const ns = parts[k++];
-            namespaces = [this.namespaceOf(ns)];
+            namespaces = [this.namespaceOf(a)];
             versions = [255];
+            last = b;
         }
         const kind = mn.kind === CONSTANT_RTQname ||
             mn.kind === CONSTANT_RTQnameA ||
@@ -245,7 +272,7 @@ export class Runtime {
             : mn.kind;
         let name = mn.name;
         if (mn.runtimeName) {
-            const part = parts[k];
+            const part = last;
             if (part?.$local !== undefined && !(part instanceof Namespace)) {
                 // A Proxy's QName of a multiname names its namespaces still.
                 if (part.$mn) {
@@ -272,6 +299,44 @@ export class Runtime {
         named.domain = mn.domain;
         return named;
     }
+    stringNames = new WeakMap();
+    stringNamesEpoch = -1;
+    /** Repeated string keys share lookup work, without retaining arbitrary keys or retired domains. */
+    stringName(base, name) {
+        const current = epoch();
+        if (this.stringNamesEpoch !== current) {
+            this.stringNames = new WeakMap();
+            this.stringNamesEpoch = current;
+        }
+        let cache = this.stringNames.get(base);
+        if (cache && cache.misses >= 0) {
+            const known = cache.names.get(name);
+            if (known) {
+                cache.misses = 0;
+                return known;
+            }
+        }
+        const named = new Multiname(base.kind, base.namespaces, base.versions, name, base.attribute);
+        named.domain = base.domain;
+        if (!cache) {
+            cache = { names: new Map(), misses: 0 };
+            this.stringNames.set(base, cache);
+        }
+        // Replacing filled inline caches would retain their heads until the next invalidation.
+        if (cache.misses < 0) {
+            return named;
+        }
+        if (cache.names.size < 64) {
+            named.cache = UNFILLED;
+            cache.names.set(name, named);
+        }
+        else if (++cache.misses >= 64) {
+            // A stream of unrelated keys should stop paying for a map lookup on every access.
+            cache.names.clear();
+            cache.misses = -1;
+        }
+        return named;
+    }
     /** An object's string, as the name of an object that is not a Dictionary. */
     keyName = (key) => this.toString(key);
     /** The runtime namespace a Namespace value stands for. */
@@ -427,6 +492,20 @@ export class Runtime {
         chain.w = outer.w | (withs << outer.length);
         return chain;
     }
+    /**
+     * `chain` for a contested function whose creators' chains differ in
+     * length (the codegen's Scope.merged): its first `at` entries, which all
+     * of them have, then one entry holding the rest, a ScopePack, searched in
+     * its place. The function's chain is then as long whichever creator made
+     * it, and what it creates finds its own scopes where it was compiled to.
+     * Called by compiled code.
+     */
+    packScope(chain, at) {
+        const packed = chain.slice(0, at);
+        packed.push(new ScopePack(chain.slice(at), chain.w >>> at));
+        packed.w = (chain.w & ((1 << at) - 1)) | (1 << at);
+        return packed;
+    }
     /**
      * The global object of the script that defines `mn`, run first if it has
      * not run. A module reads `mn.global` before calling this: once set it
@@ -454,8 +533,15 @@ export class Runtime {
             }
         }
         for (let i = outer.length - 1; i >= 0; i--) {
-            if (this.scopeHas(outer[i], mn, (outer.w >> i) & 1)) {
-                return outer[i];
+            const o = outer[i];
+            if (o instanceof ScopePack) {
+                const found = this.packHas(o, mn);
+                if (found !== undefined) {
+                    return found;
+                }
+            }
+            else if (this.scopeHas(o, mn, (outer.w >> i) & 1)) {
+                return o;
             }
         }
         return this.global(mn, outer.length ? outer[0] : locals[0], strict);
@@ -506,6 +592,22 @@ export class Runtime {
         }
         return global;
     }
+    /** The innermost scope of a pack that has `mn`, a pack in it searched in turn; undefined if none has. */
+    packHas(pack, mn) {
+        for (let i = pack.scopes.length - 1; i >= 0; i--) {
+            const o = pack.scopes[i];
+            if (o instanceof ScopePack) {
+                const found = this.packHas(o, mn);
+                if (found !== undefined) {
+                    return found;
+                }
+            }
+            else if (this.scopeHas(o, mn, (pack.w >> i) & 1)) {
+                return o;
+            }
+        }
+        return undefined;
+    }
     scopeHas(o, mn, isWith) {
         if (isWith) {
             return this.withHas(o, mn);
@@ -756,8 +858,23 @@ export class Runtime {
                 return traits.getIndex(o, i, this);
             }
             const a = o.$a;
-            if (a !== undefined && i in a) {
-                return a[i];
+            if (a !== undefined) {
+                if (i in a) {
+                    return a[i];
+                }
+            }
+            else if (traits?.dynamic && traits.properties === null && !traits.refusesNames) {
+                // As ScriptObject::getUintProperty: an object with no elements of its own looks the
+                // number up among its dynamic properties first, with no binding asked for; a table
+                // keyed by numbers, as a Dictionary of handles, is read so on every access. One not
+                // there, or there as undefined, is looked up in full.
+                const d = o.$d;
+                if (d) {
+                    const v = d.get(`${i}`);
+                    if (v !== undefined) {
+                        return v;
+                    }
+                }
             }
         }
         return this.getProperty(o, this.runtimeName(mn, i));