@swf2es/runtime 0.1.12 → 0.1.14

package/src/avm2/runtime.ts

@@ -141,6 +141,18 @@ export { NOT_FOUND } from "./descriptors.js";
  */
 export const SEALED_ELEMENTS: Value[] = Object.freeze([]) as unknown as Value[];
 
+/**
+ * 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 {
+  constructor(
+    readonly scopes: Value[],
+    readonly w: number,
+  ) {}
+}
+
 /** The value of `o`'s dynamic property `name`, or NOT_FOUND. */
 function dynamicValue(o: AsObject, name: string): Value {
   const d: Map<string, Value> | null | undefined = o.$d;
@@ -279,6 +291,8 @@ export class Runtime {
   /** Empty the inline caches, so that they keep no traits or code of what is being let go of. */
   forgetCaches(): void {
     invalidate();
+    this.stringNames = new WeakMap();
+    this.stringNamesEpoch = epoch();
   }
 
   // Names.
@@ -357,15 +371,30 @@ export class Runtime {
     return new TypeName(base, [param]);
   }
 
-  /** A multiname with its runtime namespace and name, from the stack. */
-  runtimeName(mn: Multiname, ...parts: Value[]): Multiname {
+  /**
+   * 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: Multiname, a?: Value, b?: Value): Multiname {
+    if (
+      !mn.runtimeNs &&
+      mn.runtimeName &&
+      mn.cache !== NO_CACHE &&
+      typeof a === "string" &&
+      a.length <= 128
+    ) {
+      return this.stringName(mn, a);
+    }
+
     let namespaces: readonly (Namespace | null)[] = 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 =
@@ -377,7 +406,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) {
@@ -411,6 +440,49 @@ export class Runtime {
     return named;
   }
 
+  private stringNames = new WeakMap<Multiname, { names: Map<string, Multiname>; misses: number }>();
+  private stringNamesEpoch = -1;
+
+  /** Repeated string keys share lookup work, without retaining arbitrary keys or retired domains. */
+  private stringName(base: Multiname, name: string): Multiname {
+    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. */
   private readonly keyName = (key: unknown): string => this.toString(key as Value);
 
@@ -602,6 +674,21 @@ export class Runtime {
     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: Scope, at: number): Scope {
+    const packed = chain.slice(0, at) as Scope;
+    packed.push(new ScopePack(chain.slice(at), chain.w >>> at) as never);
+    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
@@ -638,8 +725,14 @@ 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;
       }
     }
 
@@ -703,6 +796,23 @@ 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. */
+  private packHas(pack: ScopePack, mn: Multiname): AsObject | undefined {
+    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 as AsObject, mn, (pack.w >> i) & 1)) {
+        return o as AsObject;
+      }
+    }
+
+    return undefined;
+  }
+
   private scopeHas(o: AsObject, mn: Multiname, isWith: number): boolean {
     if (isWith) {
       return this.withHas(o, mn);
@@ -997,8 +1107,22 @@ export class Runtime {
       }
 
       const a: Value[] | undefined = 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: Map<string, Value> | null | undefined = o.$d;
+        if (d) {
+          const v = d.get(`${i}`);
+          if (v !== undefined) {
+            return v;
+          }
+        }
       }
     }