avm2: Implement namespace versioning

This allows us to hide things like `MovieClip.isPlaying` from older
SWFs, which may define an `isPlaying` method without marking it
as an override.

This has the largest impact on public namespaces. There is no longer
just one public namespace - we now have a public namespace per API
version. Most callsites should use `Avm2.find_public_namespace()`,
which determines the public namespace based on the root SWF API version.
This ensures that explicit property access in Ruffle (e.g. calling
"toString") are able to see things defined in the user SWF.

This requires several changes other:

* A new `ApiVersion` enum is introduced, storing all of the api versions
  defined in avmplus
* NamespaceData::Namespace now holds an `ApiVersion`. When we read a
  namespace from a user-defined ABC file, we use the `ApiVersion` from
  the root movie clip. This matches Flash Player's behavior - when a
  child SWF is loaded through `Loader`, its API version gets overwritten
  with the parent's API version, which affects definition visibility and
  'override' requirements in the child SWF. Note that 'behavior changes'
  in methods like `gotoAndPlay` are unaffected.
* The `PartialEq` impl for `Namespace` has been removed - each call site must now choose
  to compare namespaces either by an exact version match, or by
  'compatible' versions (a `<=` check) with `Namespace::matches_ns`
* `PropertyMap` now uses `Namespace::matches_ns` to check for a
  compatible version when looking up a definition.
* When compiling our playerglobal, we pass in the `-apiversioning` flag,
  which causes asc.jar to convert `[API]` metadata into a special
  Unicode 'version mark' suffix in namespace URLs. We parse this
  when loading namespaces to determine the API version to use for
  playerglobal definitions (unmarked definitions use the lowest possible
  version).

Unfortunately, this makes ffdec unable to decompile our
playerglobal.swc
I've going to file an upstream issue

Author: Aaron1011

core/build_playerglobal/src/lib.rs

@@ -52,6 +52,10 @@ pub fn build_playerglobal(
             &asc_path.to_string_lossy(),
             "macromedia.asc.embedding.ScriptCompiler",
             "-optimize",
+            "-builtin",
+            "-apiversioning",
+            "-version",
+            "9",
             "-outdir",
             &out_dir.to_string_lossy(),
             "-out",
@@ -114,18 +118,54 @@ fn resolve_multiname_name<'a>(abc: &'a AbcFile, multiname: &Multiname) -> &'a st
     }
 }
 
+// Strips off the version mark inserted by 'asc.jar',
+// giving us a valid Rust module name. The actual versioning logic
+// is handling in Ruffle when we load playerglobals
+fn strip_version_mark(val: &str) -> &str {
+    const MIN_API_MARK: usize = 0xE000;
+    const MAX_API_MARK: usize = 0xF8FF;
+
+    if let Some(chr) = val.chars().last() {
+        if chr as usize >= MIN_API_MARK && chr as usize <= MAX_API_MARK {
+            // The version mark is 3 bytes in utf-8
+            return &val[..val.len() - 3];
+        }
+    }
+    val
+}
+
 // Like `resolve_multiname_name`, but for namespaces instead.
 fn resolve_multiname_ns<'a>(abc: &'a AbcFile, multiname: &Multiname) -> &'a str {
-    if let Multiname::QName { namespace, .. } = multiname {
-        let ns = &abc.constant_pool.namespaces[namespace.0 as usize - 1];
-        if let Namespace::Package(p) | Namespace::PackageInternal(p) = ns {
-            &abc.constant_pool.strings[p.0 as usize - 1]
-        } else {
-            panic!("Unexpected Namespace {ns:?}");
+    let ns = match multiname {
+        Multiname::QName { namespace, .. } => {
+            &abc.constant_pool.namespaces[namespace.0 as usize - 1]
         }
+        Multiname::Multiname { namespace_set, .. } => {
+            if namespace_set.0 == 0 {
+                panic!("Multiname namespace set must not be null");
+            }
+
+            let actual_index = namespace_set.0 as usize - 1;
+            let ns_set = abc
+                .constant_pool
+                .namespace_sets
+                .get(actual_index)
+                .unwrap_or_else(|| panic!("Unknown namespace set constant {}", actual_index));
+
+            if ns_set.len() == 1 {
+                &abc.constant_pool.namespaces[ns_set[0].0 as usize - 1]
+            } else {
+                panic!("Found multiple namespaces in namespace set {ns_set:?}")
+            }
+        }
+        _ => panic!("Unexpected Multiname {multiname:?}"),
+    };
+    let namespace = if let Namespace::Package(p) | Namespace::PackageInternal(p) = ns {
+        &abc.constant_pool.strings[p.0 as usize - 1]
     } else {
-        panic!("Unexpected Multiname {multiname:?}");
-    }
+        panic!("Unexpected Namespace {ns:?}");
+    };
+    strip_version_mark(namespace)
 }
 
 fn flash_to_rust_path(path: &str) -> String {

core/src/avm2.rs

@@ -29,6 +29,7 @@ macro_rules! avm_debug {
 
 pub mod activation;
 mod amf;
+pub mod api_version;
 mod array;
 pub mod bytearray;
 mod call_stack;
@@ -77,8 +78,10 @@ pub use crate::avm2::object::{
 pub use crate::avm2::qname::QName;
 pub use crate::avm2::value::Value;
 
+use self::api_version::ApiVersion;
 use self::object::WeakObject;
 use self::scope::Scope;
+use num_traits::FromPrimitive;
 
 const BROADCAST_WHITELIST: [&str; 4] = ["enterFrame", "exitFrame", "frameConstructed", "render"];
 
@@ -113,7 +116,13 @@ pub struct Avm2<'gc> {
     /// However, it's not strictly defined which items end up there.
     toplevel_global_object: Option<Object<'gc>>,
 
-    pub public_namespace: Namespace<'gc>,
+    /// The public namespace, versioned with `ApiVersion::ALL_VERSIONS`.
+    /// When calling into user code, you should almost always use `find_public_namespace`
+    /// instead, as it will return the correct version for the current call stack.
+    public_namespace_base_version: Namespace<'gc>,
+    // FIXME - make this an enum map once gc-arena supports it
+    public_namespaces: Vec<Namespace<'gc>>,
+    public_namespace_vm_internal: Namespace<'gc>,
     pub internal_namespace: Namespace<'gc>,
     pub as3_namespace: Namespace<'gc>,
     pub vector_public_namespace: Namespace<'gc>,
@@ -156,6 +165,14 @@ pub struct Avm2<'gc> {
     /// strong references around (this matches Flash's behavior).
     orphan_objects: Rc<Vec<DisplayObjectWeak<'gc>>>,
 
+    /// The api version of our root movie clip. Note - this is used as the
+    /// api version for swfs loaded via `Loader`, overriding the api version
+    /// specified in the loaded SWF. This is only used for API versioning (hiding
+    /// definitions from playerglobals) - version-specific behavior in things like
+    /// `gotoAndPlay` uses the current movie clip's SWF version.
+    #[collect(require_static)]
+    pub root_api_version: ApiVersion,
+
     #[cfg(feature = "avm_debug")]
     pub debug_output: bool,
 }
@@ -167,6 +184,10 @@ impl<'gc> Avm2<'gc> {
         let stage_domain =
             Domain::uninitialized_domain(context.gc_context, Some(playerglobals_domain));
 
+        let public_namespaces = (0..=(ApiVersion::VM_INTERNAL as usize))
+            .map(|val| Namespace::package("", ApiVersion::from_usize(val).unwrap(), context))
+            .collect();
+
         Self {
             player_version,
             stack: Vec::new(),
@@ -177,13 +198,24 @@ impl<'gc> Avm2<'gc> {
             system_classes: None,
             toplevel_global_object: None,
 
-            public_namespace: Namespace::package("", context),
+            public_namespace_base_version: Namespace::package("", ApiVersion::AllVersions, context),
+            public_namespaces,
+            public_namespace_vm_internal: Namespace::package("", ApiVersion::VM_INTERNAL, context),
             internal_namespace: Namespace::internal("", context),
-            as3_namespace: Namespace::package("http://adobe.com/AS3/2006/builtin", context),
-            vector_public_namespace: Namespace::package("__AS3__.vec", context),
+            as3_namespace: Namespace::package(
+                "http://adobe.com/AS3/2006/builtin",
+                ApiVersion::AllVersions,
+                context,
+            ),
+            vector_public_namespace: Namespace::package(
+                "__AS3__.vec",
+                ApiVersion::AllVersions,
+                context,
+            ),
             vector_internal_namespace: Namespace::internal("__AS3__.vec", context),
             proxy_namespace: Namespace::package(
                 "http://www.adobe.com/2006/actionscript/flash/proxy",
+                ApiVersion::AllVersions,
                 context,
             ),
             // these are required to facilitate shared access between Rust and AS
@@ -201,6 +233,9 @@ impl<'gc> Avm2<'gc> {
 
             orphan_objects: Default::default(),
 
+            // Set the lowest version for now - this be overriden when we set our movie
+            root_api_version: ApiVersion::AllVersions,
+
             #[cfg(feature = "avm_debug")]
             debug_output: false,
         }
@@ -639,6 +674,13 @@ impl<'gc> Avm2<'gc> {
 
     #[cfg(not(feature = "avm_debug"))]
     pub const fn set_show_debug_output(&self, _visible: bool) {}
+
+    /// Gets the public namespace, versioned based on the current root SWF.
+    /// See `AvmCore::findPublicNamespace()`
+    /// https://github.com/adobe/avmplus/blob/858d034a3bd3a54d9b70909386435cf4aec81d21/core/AvmCore.cpp#L5809C25-L5809C25
+    pub fn find_public_namespace(&self) -> Namespace<'gc> {
+        self.public_namespaces[self.root_api_version as usize]
+    }
 }
 
 /// If the provided `DisplayObjectWeak` should have frames run, returns

core/src/avm2/activation.rs

@@ -761,7 +761,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     ) -> Result<Namespace<'gc>, Error<'gc>> {
         method
             .translation_unit()
-            .pool_namespace(index, &mut self.borrow_gc())
+            .pool_namespace(index, &mut self.context)
     }
 
     /// Retrieve a multiname from the current constant pool.
@@ -772,7 +772,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     ) -> Result<Gc<'gc, Multiname<'gc>>, Error<'gc>> {
         method
             .translation_unit()
-            .pool_maybe_uninitialized_multiname(index, &mut self.borrow_gc())
+            .pool_maybe_uninitialized_multiname(index, &mut self.context)
     }
 
     /// Retrieve a multiname from the current constant pool.
@@ -784,7 +784,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     ) -> Result<Gc<'gc, Multiname<'gc>>, Error<'gc>> {
         let name = method
             .translation_unit()
-            .pool_maybe_uninitialized_multiname(index, &mut self.borrow_gc())?;
+            .pool_maybe_uninitialized_multiname(index, &mut self.context)?;
         if name.has_lazy_component() {
             let name = name.fill_with_runtime_params(self)?;
             Ok(Gc::new(self.context.gc_context, name))
@@ -804,7 +804,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     ) -> Result<Gc<'gc, Multiname<'gc>>, Error<'gc>> {
         method
             .translation_unit()
-            .pool_multiname_static(index, &mut self.borrow_gc())
+            .pool_multiname_static(index, &mut self.context)
     }
 
     /// Retrieve a static, or non-runtime, multiname from the current constant
@@ -818,7 +818,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     ) -> Result<Gc<'gc, Multiname<'gc>>, Error<'gc>> {
         method
             .translation_unit()
-            .pool_multiname_static_any(index, &mut self.borrow_gc())
+            .pool_multiname_static_any(index, &mut self.context)
     }
 
     /// Retrieve a method entry from the current ABC file's method table.
@@ -1652,7 +1652,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         }
 
         let name = name_value.coerce_to_string(self)?;
-        let multiname = Multiname::new(self.avm2().public_namespace, name);
+        let multiname = Multiname::new(self.avm2().find_public_namespace(), name);
         let has_prop = obj.has_property_via_in(self, &multiname)?;
 
         self.push_stack(has_prop);
@@ -1672,11 +1672,8 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 // for `finally` scopes, FP just creates a bare object.
                 self.avm2().classes().object.construct(self, &[])?
             } else {
-                let qname = QName::from_abc_multiname(
-                    method.translation_unit(),
-                    vname,
-                    &mut self.borrow_gc(),
-                )?;
+                let qname =
+                    QName::from_abc_multiname(method.translation_unit(), vname, &mut self.context)?;
                 ScriptObject::catch_scope(self.context.gc_context, &qname)
             };
             self.push_stack(so);

core/src/avm2/api_version.rs

@@ -0,0 +1,96 @@
+// Based on https://github.com/adobe/avmplus/blob/master/core/api-versions.h
+// FIXME - if we ever add in AIR emulation, then implement the 'version series' logic.
+// For now, it's fine to just compare Flash player version against air versions directly.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, FromPrimitive)]
+#[allow(non_camel_case_types)]
+pub enum ApiVersion {
+    AllVersions = 0,
+    AIR_1_0 = 1,
+    FP_10_0 = 2,
+    AIR_1_5 = 3,
+    AIR_1_5_1 = 4,
+    FP_10_0_32 = 5,
+    AIR_1_5_2 = 6,
+    FP_10_1 = 7,
+    AIR_2_0 = 8,
+    AIR_2_5 = 9,
+    FP_10_2 = 10,
+    AIR_2_6 = 11,
+    SWF_12 = 12,
+    AIR_2_7 = 13,
+    SWF_13 = 14,
+    AIR_3_0 = 15,
+    SWF_14 = 16,
+    AIR_3_1 = 17,
+    SWF_15 = 18,
+    AIR_3_2 = 19,
+    SWF_16 = 20,
+    AIR_3_3 = 21,
+    SWF_17 = 22,
+    AIR_3_4 = 23,
+    SWF_18 = 24,
+    AIR_3_5 = 25,
+    SWF_19 = 26,
+    AIR_3_6 = 27,
+    SWF_20 = 28,
+    AIR_3_7 = 29,
+    SWF_21 = 30,
+    AIR_3_8 = 31,
+    SWF_22 = 32,
+    AIR_3_9 = 33,
+    SWF_23 = 34,
+    AIR_4_0 = 35,
+    SWF_24 = 36,
+    AIR_13_0 = 37,
+    SWF_25 = 38,
+    AIR_14_0 = 39,
+    SWF_26 = 40,
+    AIR_15_0 = 41,
+    SWF_27 = 42,
+    AIR_16_0 = 43,
+    SWF_28 = 44,
+    AIR_17_0 = 45,
+    SWF_29 = 46,
+    AIR_18_0 = 47,
+    SWF_30 = 48,
+    AIR_19_0 = 49,
+    SWF_31 = 50,
+    AIR_20_0 = 51,
+    VM_INTERNAL = 52,
+}
+
+impl ApiVersion {
+    pub fn from_swf_version(val: u8) -> Option<ApiVersion> {
+        match val {
+            // There's no specific entry for SWF 9 in avmplus,
+            // so map it to the lowest entry.
+            9 => Some(ApiVersion::AllVersions),
+            10 => Some(ApiVersion::FP_10_1),
+            11 => Some(ApiVersion::FP_10_2),
+            12 => Some(ApiVersion::SWF_12),
+            13 => Some(ApiVersion::SWF_13),
+            14 => Some(ApiVersion::SWF_14),
+            15 => Some(ApiVersion::SWF_15),
+            16 => Some(ApiVersion::SWF_16),
+            17 => Some(ApiVersion::SWF_17),
+            18 => Some(ApiVersion::SWF_18),
+            19 => Some(ApiVersion::SWF_19),
+            20 => Some(ApiVersion::SWF_20),
+            21 => Some(ApiVersion::SWF_21),
+            22 => Some(ApiVersion::SWF_22),
+            23 => Some(ApiVersion::SWF_23),
+            24 => Some(ApiVersion::SWF_24),
+            25 => Some(ApiVersion::SWF_25),
+            26 => Some(ApiVersion::SWF_26),
+            27 => Some(ApiVersion::SWF_27),
+            28 => Some(ApiVersion::SWF_28),
+            29 => Some(ApiVersion::SWF_29),
+            30 => Some(ApiVersion::SWF_30),
+            31 => Some(ApiVersion::SWF_31),
+            // We haven't yet created entries from higher versions - just map them
+            // to the highest non-VM_INTERNAL version.
+            _ if val > 31 => Some(ApiVersion::SWF_31),
+            _ => None,
+        }
+    }
+}