@swf2es/runtime 0.1.16 → 0.1.18

package/src/avm2/natives/bytearray.ts

@@ -760,13 +760,11 @@ export function byteArrayNatives(rt: Runtime): Natives {
       return rt.defaultObjectEncoding;
     }
 
+    // Unchecked, unlike an instance's: avmshell and Flash take any uint, a
+    // new ByteArray starts with it, and writeObject reads an encoding below
+    // 3 as AMF0 (#1508 in avmshell), any other as AMF3.
     static set defaultObjectEncoding(v: Value) {
-      const e = rt.toUint(v);
-      if (e !== kAMF0 && e !== kAMF3) {
-        throw rt.error("ArgumentError", 2008, "objectEncoding");
-      }
-
-      rt.defaultObjectEncoding = e;
+      rt.defaultObjectEncoding = rt.toUint(v);
     }
 
     get length() {
@@ -1215,13 +1213,11 @@ export function byteArrayNatives(rt: Runtime): Natives {
     },
   };
 
+  // AMF3 whatever their objectEncoding, as ObjectOutputObject::writeObject
+  // and ObjectInputObject::readObject: avmshell and Flash alike.
   class ObjectOutputNatives {
     writeObject(this: AsObject, v: Value): void {
       const stream: Writer = this.$amf;
-      if (stream.objectEncoding !== 3) {
-        throw rt.unsupported("AMF0");
-      }
-
       stream.value(v);
     }
   }
@@ -1229,10 +1225,6 @@ export function byteArrayNatives(rt: Runtime): Natives {
   class ObjectInputNatives {
     readObject(this: AsObject): Value {
       const stream: Reader = this.$amf;
-      if (stream.objectEncoding !== 3) {
-        throw rt.unsupported("AMF0");
-      }
-
       return stream.value();
     }
 

package/src/avm2/natives/describe.ts

@@ -121,7 +121,14 @@ function chooseTraits(rt: Runtime, v: Value): Traits | string {
     return "null";
   }
 
-  if (typeof v === "number" && (v | 0) === v && v >= -(1 << 28) && v < 1 << 28) {
+  // An int atom: -0 is a double.
+  if (
+    typeof v === "number" &&
+    (v | 0) === v &&
+    v >= -(1 << 28) &&
+    v < 1 << 28 &&
+    !Object.is(v, -0)
+  ) {
     return rt.traitsOfType("int");
   }
 

package/src/avm2/natives/object.ts

@@ -191,9 +191,12 @@ function shortName(qualified: string): string {
 
 export function qualifiedClassName(rt: Runtime, v: Value): string {
   switch (typeof v) {
-    // As TypeDescriber::chooseTraits: an int is one that fits avmplus' 29-bit int atom.
+    // As TypeDescriber::chooseTraits: an int is one that fits avmplus' 29-bit
+    // int atom, which -0, always a double, never is.
     case "number":
-      return (v | 0) === v && v >= -(1 << 28) && v < 1 << 28 ? "int" : "Number";
+      return (v | 0) === v && v >= -(1 << 28) && v < 1 << 28 && !Object.is(v, -0)
+        ? "int"
+        : "Number";
     case "string":
       return "String";
     case "boolean":

package/src/avm2/natives/vector.ts

@@ -330,7 +330,7 @@ for (const [kind, convert, fill, elementsOf, store] of VECTORS) {
 
       const source = args[0];
       if (!isObject(source)) {
-        throw rt.error("TypeError", 1034, rt.describe(source), cls.$it.name);
+        throw rt.error("TypeError", 1034, rt.describe(source), cls.$it.errorName);
       }
 
       if (source.$traits === cls.$it) {

package/src/avm2/runtime.ts

@@ -14,6 +14,7 @@
 import { API_VERSION, checkApiVersion } from "@swf2es/format";
 import { AmfClasses } from "./amf-classes.js";
 import { ArrayConversion } from "./array-conversion.js";
+import type { MethodName, PropertyName, Ref, WritableName } from "./as3-types.js";
 import { fillCache } from "./cache-fill.js";
 import { newClass, specializeVector, withId } from "./classes.js";
 import { classNamed, classNamedByCode, definingAbc, definitionNamed } from "./definitions.js";
@@ -168,6 +169,21 @@ function hasWith(scopes: Value[], w: number): boolean {
 }
 
 /** The value of `o`'s dynamic property `name`, or NOT_FOUND. */
+/** Whether k is an int atom avmplus can take as a uint: an integer of 0 to 2^32-1, -0 not, as it is a double's. */
+function uintAtom(k: Value): k is number {
+  return typeof k === "number" && k >>> 0 === k && (k !== 0 || 1 / k > 0);
+}
+
+/** Whether v is an object's atom to avmplus: not null, nor a Namespace or float, whose atoms are their own. */
+function isScriptObject(v: Value): boolean {
+  return (
+    typeof v === "object" && v !== null && !(v instanceof Namespace) && !(v instanceof FloatValue)
+  );
+}
+
+/** The name avmplus' getUintProperty looks a number up by: public, at every version. */
+const ELEMENT_NAME = new Multiname(CONSTANT_MultinameL, [publicNs], [255], null, false);
+
 function dynamicValue(o: AsObject, name: string): Value {
   const d: Map<string, Value> | null | undefined = o.$d;
   if (!d) {
@@ -244,6 +260,13 @@ export class Runtime {
   /** The builtin classes' traits, made before their classes so the bootstrap can refer to them. */
   readonly objectTraits: Traits;
   readonly classTraits: Traits;
+  /**
+   * What the super operations of a script's methods and of a class's
+   * static ones look in, as avmplus' script traits extend Object and a
+   * class object's traits Class: their `super` is that class's instance.
+   */
+  readonly scriptSuper: AsObject;
+  readonly staticSuper: AsObject;
   readonly functionTraits: Traits;
   /**
    * Method closures, by receiver and method, so that o.f === o.f; by the
@@ -299,6 +322,8 @@ export class Runtime {
     this.objectTraits.dynamic = true;
     this.objectTraits.testsValues = true;
     this.classTraits = new Traits("Class", this.objectTraits);
+    this.scriptSuper = { $it: this.objectTraits };
+    this.staticSuper = { $it: this.classTraits };
     this.functionTraits = new Traits("Function", this.objectTraits);
     this.functionTraits.dynamic = true;
     this.natives = typeof natives === "function" ? natives(this) : natives;
@@ -640,14 +665,9 @@ export class Runtime {
       // indexes the scopes their closures capture: the global object is
       // only what they push.
       for (const [d, factory, id, , params] of script.desc.traits.methods) {
-        installMethod(
-          this,
-          traits.methodHome(3),
-          d,
-          withId(factory(this.empty, null), id),
-          factory,
-          params,
-        );
+        const method = withId(factory(this.empty, this.scriptSuper), id);
+        this.keepStatic(factory, method);
+        installMethod(this, traits.methodHome(3), d, method, factory, params);
       }
 
       // Caches keep the methods.
@@ -677,7 +697,7 @@ export class Runtime {
     if (script.state === 0 || (retry && script.state === 3)) {
       script.state = 1;
       try {
-        script.desc.init(this.empty, null).call(g);
+        script.desc.init(this.empty, this.scriptSuper).call(g);
       } catch (e) {
         script.state = 3;
         throw e;
@@ -1095,7 +1115,21 @@ export class Runtime {
     this.arrayConversion.noteArrayClass(cls);
   }
 
+  /**
+   * A class's prototype, whose methods compiled code calls on a primitive:
+   * at every such call, so a String's, a Number's and a Boolean's are read
+   * from their traits, kept once known, without the lookup by name.
+   */
   prototypeOf(ref: TypeRef): AsObject {
+    switch (ref) {
+      case "String":
+        return (this.stringTraits ?? this.builtinTraits("String")).proto;
+      case "Number":
+        return (this.numberTraits ?? this.builtinTraits("Number")).proto;
+      case "Boolean":
+        return (this.booleanTraits ?? this.builtinTraits("Boolean")).proto;
+    }
+
     return this.classOf(ref).$it.proto;
   }
 
@@ -1197,7 +1231,7 @@ export class Runtime {
       "ReferenceError",
       name === null && nsset ? 1081 : 1069,
       mn.name ?? "*",
-      traits.name,
+      traits.errorName,
     );
   }
 
@@ -1273,6 +1307,31 @@ export class Runtime {
     this.setProperty(o, this.indexName(mn, i), v);
   }
 
+  /**
+   * obj[k] by a runtime name with no public namespace, or an attribute's,
+   * in a script's or a class's initializer, which avmplus interprets: its
+   * getproperty reads an int key of at least 0 off an object by
+   * getUintProperty, whatever namespaces the name has, where its JIT asks
+   * for a public one (getIndexed). Any other key makes a name.
+   */
+  getInterpreted(o: Value, mn: Multiname, k: Value): Value {
+    if (uintAtom(k) && isScriptObject(o)) {
+      return this.getIndexed(o, ELEMENT_NAME, k);
+    }
+
+    return this.getProperty(o, this.runtimeName(mn, k));
+  }
+
+  /** obj[k] = v as getInterpreted reads it, as avmplus' interpreter's setproperty. */
+  setInterpreted(o: Value, mn: Multiname, k: Value, v: Value): void {
+    if (uintAtom(k) && isScriptObject(o)) {
+      this.setIndexed(o, ELEMENT_NAME, k, v);
+      return;
+    }
+
+    this.setProperty(o, this.runtimeName(mn, k), 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
@@ -1578,10 +1637,10 @@ export class Runtime {
           return o[slot];
         }
 
-        throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.errorName);
       }
       default:
-        throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.errorName);
     }
   }
 
@@ -1683,7 +1742,7 @@ export class Runtime {
       switch (b & 7) {
         case BIND_Const:
           if (!init) {
-            throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.name);
+            throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.errorName);
           }
           o[slotKey(id)] = this.coerce(v, traits.slotType(id));
           return;
@@ -1695,9 +1754,9 @@ export class Runtime {
           (traits.proto[untypedSetKey(id + 1)] ?? traits.proto[methodKey(id + 1)]).call(o, v);
           return;
         case BIND_Method:
-          throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.name);
+          throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.errorName);
         default:
-          throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.name);
+          throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.errorName);
       }
     }
 
@@ -1722,7 +1781,7 @@ export class Runtime {
       }
     }
 
-    throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.name);
+    throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.errorName);
   }
 
   initProperty(o: Value, mn: Multiname, v: Value): void {
@@ -1741,7 +1800,7 @@ export class Runtime {
 
     // A primitive's property cannot be deleted, as MethodEnv's delproperty has it.
     if (typeof o !== "object" || o instanceof Namespace) {
-      throw this.error("ReferenceError", 1120, mn.name ?? "*", this.traitsOf(o).name);
+      throw this.error("ReferenceError", 1120, mn.name ?? "*", this.traitsOf(o).errorName);
     }
 
     // E4X 11.3.1: delete x[list] is a TypeError, as in delete x.a.(b == 1).
@@ -1958,6 +2017,36 @@ export class Runtime {
     return qname(publicNs, this.nameString(name));
   }
 
+  // Natives' typed reach into AS3 objects (as3-types.ts): getProperty,
+  // setProperty and callProperty of the public name, the lookup natives
+  // made before, with the name checked against the class's declarations
+  // when compiled.
+
+  /** `o`'s public property `name`: a variable, constant or accessor its class declares. */
+  prop<T, K extends PropertyName<T>>(o: Ref<T>, name: K): T[K] {
+    // biome-ignore lint/style/useConst: a const is folded into a tail call (see getProperty)
+    let r: Value;
+    r = this.getProperty(o, this.publicName(name));
+    return r;
+  }
+
+  /** Sets `o`'s public property `name`, which its class declares writable. */
+  setProp<T, K extends WritableName<T>>(o: Ref<T>, name: K, v: T[K]): void {
+    this.setProperty(o, this.publicName(name), v);
+  }
+
+  /** Calls `o`'s public method `name` with `args`. */
+  callProp<T, K extends MethodName<T>>(
+    o: Ref<T>,
+    name: K,
+    ...args: T[K] extends (...a: infer A) => unknown ? A : never
+  ): T[K] extends (...a: never[]) => infer R ? R : never {
+    // biome-ignore lint/style/useConst: a const is folded into a tail call (see getProperty)
+    let r: Value;
+    r = this.callProperty(o, this.publicName(name), ...args);
+    return r;
+  }
+
   /** A property name as a string, as ToString makes one. */
   private nameString(name: Value): string {
     return typeof name === "string" ? name : this.toString(name);
@@ -2208,8 +2297,33 @@ export class Runtime {
     return key;
   }
 
-  callStatic(_abc: Abc, m: number, ..._args: Value[]): Value {
-    throw this.unsupported(`callstatic ${m}`);
+  /**
+   * The first method each factory made for a class's or a script's
+   * traits, as avmplus' AbcEnv keeps the first MethodEnv of each method
+   * a vtable makes (VTable::makeMethodEnv): what callstatic calls.
+   */
+  private readonly staticMethods = new WeakMap<Factory, Method>();
+
+  /** Keep `method`, made by `factory`, for callstatic, unless it made one before. */
+  keepStatic(factory: Factory, method: Method): void {
+    if (!this.staticMethods.has(factory)) {
+      this.staticMethods.set(factory, method);
+    }
+  }
+
+  /**
+   * callstatic: method `factory` made, called on `o` with its arguments,
+   * which the compiler coerced. avmplus verifies a method when it first
+   * runs and refuses one that calls a method no vtable has made yet
+   * (1107); that is found here only once the call is reached.
+   */
+  callStatic(factory: Factory, o: Value, ...args: Value[]): Value {
+    const method = this.staticMethods.get(factory);
+    if (method === undefined) {
+      throw this.error("VerifyError", 1107);
+    }
+
+    return method.apply(o, args);
   }
 
   // The super operations, as MethodEnv's: by the base class's traits
@@ -2225,7 +2339,7 @@ export class Runtime {
     }
 
     if (b === 0) {
-      throw this.error("ReferenceError", 1070, mn.name ?? "*", traits.name);
+      throw this.error("ReferenceError", 1070, mn.name ?? "*", traits.errorName);
     }
 
     r = this.callValue(this.getBound(o, traits, b, mn), o, args, mn);
@@ -2236,7 +2350,7 @@ export class Runtime {
     const traits: Traits = sup.$it;
     const b = traits.find(mn);
     if (b === 0) {
-      throw this.error("ReferenceError", 1069, mn.name ?? "*", traits.name);
+      throw this.error("ReferenceError", 1069, mn.name ?? "*", traits.errorName);
     }
 
     return this.getBound(o, traits, b, mn);
@@ -2255,11 +2369,11 @@ export class Runtime {
         o[slotKey(id)] = this.coerce(v, traits.slotType(id));
         return;
       case BIND_Method:
-        throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.errorName);
       case 0:
-        throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.errorName);
       default:
-        throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.errorName);
     }
   }
 
@@ -2734,7 +2848,7 @@ export class Runtime {
           return v;
         }
 
-        throw this.error("TypeError", 1034, this.describe(v), traits.name);
+        throw this.error("TypeError", 1034, this.describe(v), traits.errorName);
       }
     }
   }
@@ -2759,7 +2873,7 @@ export class Runtime {
       return v;
     }
 
-    throw this.error("TypeError", 1034, this.describe(v), traits.name);
+    throw this.error("TypeError", 1034, this.describe(v), traits.errorName);
   }
 
   coerceString(v: Value): string | null {
@@ -3000,7 +3114,7 @@ export class Runtime {
       }
     }
 
-    throw this.error("TypeError", 1050, o.$traits.name);
+    throw this.error("TypeError", 1050, o.$traits.errorName);
   }
 
   add(a: Value, b: Value): Value {

package/src/avm2/traits.ts

@@ -187,6 +187,26 @@ export class Traits {
     }
   }
 
+  /**
+   * Its name as Flash's debugger player writes it in an error message
+   * (AvmCore::toErrorString): the package and the name joined by a dot,
+   * "flash.text.TextField"; a class object's as "class " and its class's.
+   */
+  get errorName(): string {
+    let name = this.name;
+    const statics = this.base?.name === "Class" && name.endsWith("$");
+    if (statics) {
+      name = name.slice(0, -1);
+    }
+
+    const colons = name.lastIndexOf("::");
+    if (colons >= 0) {
+      name = `${name.slice(0, colons)}.${name.slice(colons + 2)}`;
+    }
+
+    return statics ? `class ${name}` : name;
+  }
+
   /**
    * The object a method and its entries, `count` properties, go into:
    * the prototype, till it holds HOME_PROPERTIES, then an object chained