@swf2es/runtime 0.1.14 → 0.1.16

package/dist/avm2/runtime.js

@@ -21,18 +21,18 @@ import { NAMED } from "./dictionary-keys.js";
 import { compileUnit, Domain, definitionNames, findScript } from "./domain.js";
 import { isViewRangeError, SharedMemoryView } from "./domain-memory.js";
 import { continues, dictionaryAt, elementsAt, enumerated, INT_ATOM_LIMIT, nextIndex, ownNames, pairIndex, pairOf, walkless, } from "./enumeration.js";
-import { AsError, describe, errorMessage, stackOf } from "./errors.js";
+import { AsError, describe, detailOf, errorMessage, stackOf, UnsupportedError } from "./errors.js";
 import { FloatValue, floatValue } from "./float.js";
 import { hookedBinding } from "./hooks.js";
 import { installMethod, nativeFactory, noBodyFactory, unverifiedFactory, verifyErrorFactory, } from "./method-factories.js";
 import { Modules } from "./modules.js";
-import { arrayIndex, CONSTANT_Multiname, CONSTANT_MultinameA, CONSTANT_MultinameL, CONSTANT_MultinameLA, CONSTANT_Qname, CONSTANT_RTQname, CONSTANT_RTQnameA, CONSTANT_RTQnameL, CONSTANT_RTQnameLA, Multiname, Namespace, NS_Private, NS_Public, namespace, prefixedNamespace, prefixOf, publicNs, publicQname, qname, TypeName, } from "./names.js";
+import { arrayIndex, CONSTANT_Multiname, CONSTANT_MultinameA, CONSTANT_MultinameL, CONSTANT_MultinameLA, CONSTANT_Qname, CONSTANT_RTQname, CONSTANT_RTQnameA, CONSTANT_RTQnameL, CONSTANT_RTQnameLA, MADE_Number, MADE_Value, Multiname, Namespace, NS_Private, NS_Public, namespace, prefixedNamespace, prefixOf, publicNs, publicQname, qname, TypeName, } from "./names.js";
 import { FloatVector, setFloatElement } from "./natives/float-vector.js";
 import { storeDouble, storeInt, storeObject, } from "./natives/vector-elements.js";
 import { escapeAttributeValue, escapeElementValue } from "./natives/xml/escape.js";
 import { numberToString, stringToNumber } from "./number-strings.js";
 import { defaultPrint, memoryFiles, } from "./options.js";
-import { cached, epoch, IC_Call, IC_Const, IC_Dynamic, IC_Get, IC_GetSet, IC_Method, IC_Set, IC_Slot, invalidate, NO_CACHE, REPLACEMENTS, UNFILLED, } from "./property-cache.js";
+import { cached, epoch, IC_Call, IC_Const, IC_Dynamic, IC_Get, IC_GetSet, IC_Method, IC_Set, IC_Slot, invalidate, NO_CACHE, ScopeFinds, UNFILLED, } from "./property-cache.js";
 import { BIND_Const, BIND_Get, BIND_GetSet, BIND_Method, BIND_Set, BIND_Var, boundKey, ClassRef, methodKey, slotKey, Traits, untypedSetKey, VectorRef, } from "./traits.js";
 export { NOT_FOUND } from "./descriptors.js";
 /**
@@ -54,6 +54,16 @@ class ScopePack {
         this.w = w;
     }
 }
+/** Whether a chain or a pack, `scopes` with bits `w`, has a with scope, in a pack in it too. */
+function hasWith(scopes, w) {
+    for (let i = 0; i < scopes.length; i++) {
+        const o = scopes[i];
+        if (o instanceof ScopePack ? hasWith(o.scopes, o.w) : (w >> i) & 1) {
+            return true;
+        }
+    }
+    return false;
+}
 /** The value of `o`'s dynamic property `name`, or NOT_FOUND. */
 function dynamicValue(o, name) {
     const d = o.$d;
@@ -67,6 +77,7 @@ export class Runtime {
     classHooks;
     print;
     debugger;
+    onUnsupported;
     compileAbc;
     files;
     /** See RuntimeOptions.workers and worker. */
@@ -147,7 +158,7 @@ export class Runtime {
     /** Special traits: an activation's or a catch scope's, by descriptor. */
     scopeTraits = new WeakMap();
     specialized = new Map();
-    empty = Object.assign([], { w: 0 });
+    empty = Object.assign([], { w: 0, found: undefined });
     /**
      * `natives` are the natives by name, or a provider that makes them for
      * this runtime, so that a natives module can close over its runtime (as a
@@ -158,6 +169,7 @@ export class Runtime {
         this.classHooks = classHooks;
         this.print = options.print ?? defaultPrint;
         this.debugger = options.debugger ?? false;
+        this.onUnsupported = options.onUnsupported;
         this.compileAbc = options.compileAbc ?? null;
         this.files = options.files ?? memoryFiles();
         this.workerHost = options.workers ?? null;
@@ -289,6 +301,7 @@ export class Runtime {
                 // Its string only once a lookup needs it: a Dictionary does not.
                 const keyed = Multiname.keyed(kind, namespaces, versions, part, mn.attribute, this.keyName);
                 keyed.domain = mn.domain;
+                keyed.made = MADE_Value;
                 return keyed;
             }
             else {
@@ -297,6 +310,37 @@ export class Runtime {
         }
         const named = new Multiname(kind, namespaces, versions, name, mn.attribute);
         named.domain = mn.domain;
+        // A number here is one no element access made: a Proxy tells it by its string.
+        if (mn.runtimeName && typeof last !== "number") {
+            named.made = MADE_Value;
+        }
+        return named;
+    }
+    /**
+     * The name runtimeName makes of `mn`, a MultinameL, and a string the
+     * code itself holds, `obj["name"]`: a module makes it once as it loads
+     * and keeps it as it keeps `mn`, so it has a cache as a module's own
+     * names have, however many such names the module has and however long
+     * the string is.
+     */
+    literalName(mn, name) {
+        const named = new Multiname(mn.kind, mn.namespaces, mn.versions, name, mn.attribute);
+        named.domain = mn.domain;
+        named.made = MADE_Value;
+        named.cache = UNFILLED;
+        return named;
+    }
+    /**
+     * The name number `i` makes of `mn` in an element's read or write, which
+     * avmplus' JIT hands an object as a number (getpropertylate_i and _d), a
+     * Proxy as its string: where the name has no public namespace, it is a
+     * name as any other.
+     */
+    indexName(mn, i) {
+        const named = this.runtimeName(mn, i);
+        if (mn.kind === CONSTANT_MultinameL && mn.elementName) {
+            named.made = MADE_Number;
+        }
         return named;
     }
     stringNames = new WeakMap();
@@ -318,6 +362,7 @@ export class Runtime {
         }
         const named = new Multiname(base.kind, base.namespaces, base.versions, name, base.attribute);
         named.domain = base.domain;
+        named.made = MADE_Value;
         if (!cache) {
             cache = { names: new Map(), misses: 0 };
             this.stringNames.set(base, cache);
@@ -417,6 +462,7 @@ export class Runtime {
             const traits = new Traits("global", this.objectTraits);
             traits.dynamic = true;
             traits.isGlobal = true;
+            traits.abc = script.abc;
             traits.describe(script.desc.traits);
             const g = traits.instance();
             // As the script's initializer, its methods run in an empty scope chain,
@@ -490,6 +536,7 @@ export class Runtime {
     scope(outer, locals, withs) {
         const chain = outer.concat(locals);
         chain.w = outer.w | (withs << outer.length);
+        chain.found = undefined;
         return chain;
     }
     /**
@@ -504,6 +551,7 @@ export class Runtime {
         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);
+        packed.found = undefined;
         return packed;
     }
     /**
@@ -532,6 +580,40 @@ export class Runtime {
                 return locals[i];
             }
         }
+        const found = this.outerScopeOf(outer, mn);
+        if (found !== null) {
+            return found;
+        }
+        return this.global(mn, outer.length ? outer[0] : locals[0], strict);
+    }
+    /**
+     * The innermost object of a captured chain that has `mn`, or null: kept
+     * on a chain without a with scope (ScopeFinds), as a function whose
+     * chain the compiler could not type, such as one made where chains of
+     * different lengths meet, looks its names up each time it runs.
+     */
+    outerScopeOf(outer, mn) {
+        let finds = outer.found;
+        if (finds === undefined) {
+            finds = hasWith(outer, outer.w) ? null : new ScopeFinds();
+            outer.found = finds;
+        }
+        // A name made at run time is a new one each time: keeping it would only grow the map.
+        if (finds === null || mn.cache === NO_CACHE) {
+            return this.searchOuter(outer, mn);
+        }
+        if (finds.epoch !== epoch()) {
+            finds.clear();
+            finds.epoch = epoch();
+        }
+        let o = finds.get(mn);
+        if (o === undefined) {
+            o = this.searchOuter(outer, mn);
+            finds.set(mn, o);
+        }
+        return o;
+    }
+    searchOuter(outer, mn) {
         for (let i = outer.length - 1; i >= 0; i--) {
             const o = outer[i];
             if (o instanceof ScopePack) {
@@ -544,7 +626,7 @@ export class Runtime {
                 return o;
             }
         }
-        return this.global(mn, outer.length ? outer[0] : locals[0], strict);
+        return null;
     }
     findPropertyStrict(mn, outer, locals, withs) {
         return this.findProperty(mn, outer, locals, withs, true);
@@ -669,15 +751,22 @@ export class Runtime {
     traitsOf(v) {
         switch (typeof v) {
             case "object":
-            case "function":
+            case "function": {
                 if (v === null) {
                     throw this.error("TypeError", 1009);
                 }
+                // An object's own first: instanceof walks the whole prototype
+                // chain of an object, and a class's is as deep as its bases.
+                const traits = v.$traits;
+                if (traits !== undefined) {
+                    return traits;
+                }
                 return v instanceof FloatValue
                     ? this.builtinTraits("float")
                     : v instanceof Namespace
                         ? this.builtinTraits("Namespace")
-                        : v.$traits;
+                        : traits;
+            }
             // As avmplus' toVTable: every number is a Number at run time, int or
             // not; int's and uint's traits only bind early, from static types.
             case "number":
@@ -698,12 +787,17 @@ export class Runtime {
     receiverTraits(v) {
         switch (typeof v) {
             case "object":
-            case "function":
-                return v instanceof FloatValue
-                    ? this.builtinTraits("float")
-                    : v === null
-                        ? undefined
-                        : v.$traits;
+            case "function": {
+                if (v === null) {
+                    return undefined;
+                }
+                // A float and a Namespace have none of their own (see traitsOf).
+                const traits = v.$traits;
+                if (traits !== undefined) {
+                    return traits;
+                }
+                return v instanceof FloatValue ? this.builtinTraits("float") : undefined;
+            }
             case "string":
                 return this.stringTraits;
             case "number":
@@ -877,7 +971,7 @@ export class Runtime {
                 }
             }
         }
-        return this.getProperty(o, this.runtimeName(mn, i));
+        return this.getProperty(o, this.indexName(mn, i));
     }
     /** obj[i] = v for a number i, as avmplus' setUintProperty. */
     setIndexed(o, mn, i, v) {
@@ -889,12 +983,93 @@ export class Runtime {
                 traits.setIndex(o, i, v, this);
                 return;
             }
-            if (o.$a !== undefined && o.$a !== SEALED_ELEMENTS && i !== 0xffffffff) {
-                o.$a[i] = v;
-                return;
+            const a = o.$a;
+            if (a !== undefined) {
+                if (a !== SEALED_ELEMENTS && i !== 0xffffffff) {
+                    a[i] = v;
+                    return;
+                }
+            }
+            else if (traits?.dynamic && traits.properties === null && !traits.refusesNames) {
+                // As ScriptObject::setUintProperty: an object with no elements of its own keeps the
+                // number among its dynamic properties, with no binding asked for.
+                const d = o.$d;
+                if (d) {
+                    d.set(`${i}`, v);
+                    return;
+                }
             }
         }
-        this.setProperty(o, this.runtimeName(mn, i), v);
+        this.setProperty(o, this.indexName(mn, i), v);
+    }
+    /**
+     * obj[k] for a key whose type the compiler does not know, by a name with
+     * no namespace from the stack, as avmplus' getprop_index and
+     * getpropertyHelper: a number is an index (getIndexed), an object a
+     * Dictionary has as a key is read by itself, and anything else, a QName
+     * and a Dictionary's absent key among them, is looked up by the name it
+     * makes.
+     */
+    getKeyed(o, mn, k) {
+        let r;
+        if (typeof k === "number") {
+            r = this.getIndexed(o, mn, k);
+            return r;
+        }
+        if (typeof k === "object" && k !== null) {
+            const keys = o?.$keys;
+            if (keys !== undefined) {
+                if (!mn.elementName) {
+                    r = this.getProperty(o, this.runtimeName(mn, this.unkeyed(k)));
+                    return r;
+                }
+                // What is there was put there by a name with the object as its key, which a QName's is not.
+                const v = keys.get(k);
+                if (v !== undefined) {
+                    return v;
+                }
+            }
+        }
+        r = this.getProperty(o, this.runtimeName(mn, k));
+        return r;
+    }
+    /**
+     * An object given as the key of a Dictionary by a name with no public
+     * namespace, as the name is made of it: avmplus' JIT asks a Dictionary
+     * for an object only through getprop_index and setprop_index, which such
+     * a name does not reach, so the object is its string, as on any other
+     * receiver (initMultinameLate); a QName names what it names. Its
+     * interpreter asks the Dictionary by any name, as a name made without
+     * this does: the compiler leaves script and class initializers to that.
+     */
+    unkeyed(k) {
+        return k.$traits !== undefined && k.$local === undefined ? this.toString(k) : k;
+    }
+    /** obj[k] = v for a key whose type the compiler does not know, as avmplus' setprop_index and setpropertyHelper. */
+    setKeyed(o, mn, k, v) {
+        if (typeof k === "number") {
+            this.setIndexed(o, mn, k, v);
+            return;
+        }
+        if (typeof k === "object" && k !== null) {
+            const keys = o?.$keys;
+            if (keys !== undefined) {
+                if (!mn.elementName) {
+                    this.setProperty(o, this.runtimeName(mn, this.unkeyed(k)), v);
+                    return;
+                }
+                if (keys.replace(k, v)) {
+                    return;
+                }
+                // A new key: an object of traits, which a float and a Namespace are not, and no QName,
+                // which names what it names. Those are added, or not, by the name they make.
+                if (k.$traits !== undefined && k.$local === undefined) {
+                    keys.add(k, v);
+                    return;
+                }
+            }
+        }
+        this.setProperty(o, this.runtimeName(mn, k), v);
     }
     /**
      * Element i of Vector o set to x, already converted, as
@@ -1093,9 +1268,7 @@ export class Runtime {
     /** fillCache (cache-fill.ts), for a name that caches on traits a cache knows `o` by. */
     fill(o, traits, b, mn) {
         const head = mn.cache;
-        if (head === NO_CACHE ||
-            (head.replaced === REPLACEMENTS && head.epoch === epoch()) ||
-            this.receiverTraits(o) !== traits) {
+        if (head === NO_CACHE || this.receiverTraits(o) !== traits) {
             return;
         }
         fillCache(head, o, traits, b, mn);
@@ -1124,6 +1297,8 @@ export class Runtime {
             f.$length = method.$length ?? method.length;
             f.$id = method.$id ?? 0;
             f.$closure = true;
+            // Whose method it is, for moduleOf.
+            f.$of = traits;
             if (typeof o === "object") {
                 byMethod.set(method, f);
             }
@@ -1388,8 +1563,7 @@ export class Runtime {
         // A namespace is the runtime's own object: its prototype is its class's.
         if (typeof o === "object" &&
             o !== null &&
-            !(o instanceof Namespace) &&
-            !(o instanceof FloatValue)) {
+            (o.$traits !== undefined || !(o instanceof Namespace || o instanceof FloatValue))) {
             return o.$p;
         }
         return this.traitsOf(o).proto.$p;
@@ -1809,6 +1983,19 @@ export class Runtime {
         this.functionObjects.set(method, f);
         return f;
     }
+    /**
+     * The module a function's code is from, as avmplus has a method's code
+     * context: a function's by the global object its scope begins with, a
+     * bound method's by its receiver's class; null for a native, a class's
+     * own method, or anything but a function.
+     */
+    moduleOf(f) {
+        const o = f;
+        if (o?.$of) {
+            return o.$of.abc;
+        }
+        return o?.$global ? this.traitsOf(o.$global).abc : null;
+    }
     /** A Function object calling `f`, with `global` as its receiver when it has none. */
     newFunctionObject(f, global) {
         const o = this.functionTraits.instance();
@@ -2543,12 +2730,21 @@ export class Runtime {
         catch {
             return new AsError(`${name}: ${message}`);
         }
-        return this.constructClass(cls, [message, id]);
+        const made = this.constructClass(cls, [message, id]);
+        // What the number stands for, kept beside the message for a host's report (detailOf).
+        if (!this.debugger) {
+            Object.defineProperty(made, "$detail", { value: errorMessage(true, id, args) });
+        }
+        return made;
     }
     /** See stackOf in errors.ts. */
     stackOf(error) {
         return stackOf(error);
     }
+    /** See detailOf in errors.ts. */
+    detailOf(error) {
+        return detailOf(error);
+    }
     /** See errorMessage in errors.ts. */
     errorMessage(id, args = []) {
         return errorMessage(this.debugger, id, args);
@@ -2573,11 +2769,35 @@ export class Runtime {
         if (isViewRangeError(e)) {
             return this.error("RangeError", 1506);
         }
+        if (e instanceof UnsupportedError) {
+            return this.unsupportedCaught(e);
+        }
         if (e instanceof Error && !(e instanceof AsError)) {
             throw e;
         }
         return e;
     }
+    /** What a catch was told of already (unsupportedCaught). */
+    unsupportedTold = new Set();
+    /**
+     * What is not supported as the AS3 error a catch gets: an
+     * IllegalOperationError with its message, or an Error where the player's
+     * classes are not loaded; said once to the host, as the code may say nothing.
+     */
+    unsupportedCaught(e) {
+        if (!this.unsupportedTold.has(e.message)) {
+            this.unsupportedTold.add(e.message);
+            this.onUnsupported?.(e.message);
+        }
+        let cls;
+        try {
+            cls = this.resolve(this.cls(namespace(NS_Public, "flash.errors"), "IllegalOperationError"));
+        }
+        catch {
+            cls = this.builtinClass("Error");
+        }
+        return this.constructClass(cls, [e.message, 0]);
+    }
     catches(e, type) {
         return this.isInstanceOf(e, this.traitsOfType(type));
     }
@@ -2585,7 +2805,7 @@ export class Runtime {
         return new Error("swf2es: a dispatcher reached no block");
     }
     unsupported(what) {
-        return new Error(`swf2es: ${what} is not supported yet`);
+        return new UnsupportedError(`swf2es: ${what} is not supported yet`);
     }
     // Class aliases and the classes AMF makes (amf-classes.ts).
     registerClassAlias(name, cls) {