avm2: Replace most uses of instance_of with instance_class

This commit does not build by itself

Author: Lord-McSweeney

core/src/avm2.rs

@@ -72,6 +72,7 @@ mod vtable;
 pub use crate::avm2::activation::Activation;
 pub use crate::avm2::array::ArrayStorage;
 pub use crate::avm2::call_stack::{CallNode, CallStack};
+pub use crate::avm2::class::Class;
 #[allow(unused)] // For debug_ui
 pub use crate::avm2::domain::{Domain, DomainPtr};
 pub use crate::avm2::error::Error;

core/src/avm2/activation.rs

@@ -1632,6 +1632,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
 
     fn op_get_outer_scope(&mut self, index: u32) -> Result<FrameControl<'gc>, Error<'gc>> {
         // Verifier ensures that this points to a valid outer scope
+
         let scope = self.outer.get_unchecked(index as usize);
 
         self.push_stack(scope.values());
@@ -1730,10 +1731,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         } else {
             // Even if it's an object with the "descendants" property, we won't support it.
             let class_name = object
-                .instance_of()
+                .instance_class()
                 .map(|cls| {
-                    cls.inner_class_definition()
-                        .name()
+                    cls.name()
                         .to_qualified_name_err_message(self.context.gc_context)
                 })
                 .unwrap_or_else(|| AvmString::from("<UNKNOWN>"));

core/src/avm2/amf.rs

@@ -72,7 +72,7 @@ pub fn serialize_value<'gc>(
                 Some(AmfValue::ECMAArray(dense, sparse, len))
             } else if let Some(vec) = o.as_vector_storage() {
                 let val_type = vec.value_type();
-                if val_type == Some(activation.avm2().classes().int) {
+                if val_type == Some(activation.avm2().classes().int.inner_class_definition()) {
                     let int_vec: Vec<_> = vec
                         .iter()
                         .map(|v| {
@@ -81,7 +81,9 @@ pub fn serialize_value<'gc>(
                         })
                         .collect();
                     Some(AmfValue::VectorInt(int_vec, vec.is_fixed()))
-                } else if val_type == Some(activation.avm2().classes().uint) {
+                } else if val_type
+                    == Some(activation.avm2().classes().uint.inner_class_definition())
+                {
                     let uint_vec: Vec<_> = vec
                         .iter()
                         .map(|v| {
@@ -90,7 +92,9 @@ pub fn serialize_value<'gc>(
                         })
                         .collect();
                     Some(AmfValue::VectorUInt(uint_vec, vec.is_fixed()))
-                } else if val_type == Some(activation.avm2().classes().number) {
+                } else if val_type
+                    == Some(activation.avm2().classes().number.inner_class_definition())
+                {
                     let num_vec: Vec<_> = vec
                         .iter()
                         .map(|v| {
@@ -108,7 +112,8 @@ pub fn serialize_value<'gc>(
                         })
                         .collect();
 
-                    let val_type = val_type.unwrap_or(activation.avm2().classes().object);
+                    let val_type = val_type
+                        .unwrap_or(activation.avm2().classes().object.inner_class_definition());
 
                     let name = class_to_alias(activation, val_type);
                     Some(AmfValue::VectorObject(obj_vec, name, vec.is_fixed()))
@@ -125,11 +130,11 @@ pub fn serialize_value<'gc>(
             } else if let Some(bytearray) = o.as_bytearray() {
                 Some(AmfValue::ByteArray(bytearray.bytes().to_vec()))
             } else {
-                let class = o.instance_of().expect("Missing ClassObject");
+                let class = o.instance_class().expect("Missing Class");
                 let name = class_to_alias(activation, class);
 
                 let mut attributes = EnumSet::empty();
-                if !class.inner_class_definition().is_sealed() {
+                if !class.is_sealed() {
                     attributes.insert(Attribute::Dynamic);
                 }
 
@@ -359,23 +364,23 @@ pub fn deserialize_value<'gc>(
             let storage = VectorStorage::from_values(
                 vec.iter().map(|v| (*v).into()).collect(),
                 *is_fixed,
-                Some(activation.avm2().classes().number),
+                Some(activation.avm2().classes().number.inner_class_definition()),
             );
             VectorObject::from_vector(storage, activation)?.into()
         }
         AmfValue::VectorUInt(vec, is_fixed) => {
             let storage = VectorStorage::from_values(
                 vec.iter().map(|v| (*v).into()).collect(),
                 *is_fixed,
-                Some(activation.avm2().classes().uint),
+                Some(activation.avm2().classes().uint.inner_class_definition()),
             );
             VectorObject::from_vector(storage, activation)?.into()
         }
         AmfValue::VectorInt(vec, is_fixed) => {
             let storage = VectorStorage::from_values(
                 vec.iter().map(|v| (*v).into()).collect(),
                 *is_fixed,
-                Some(activation.avm2().classes().int),
+                Some(activation.avm2().classes().int.inner_class_definition()),
             );
             VectorObject::from_vector(storage, activation)?.into()
         }
@@ -397,7 +402,7 @@ pub fn deserialize_value<'gc>(
                     })
                     .collect::<Result<Vec<_>, _>>()?,
                 *is_fixed,
-                Some(class),
+                Some(class.inner_class_definition()),
             );
             VectorObject::from_vector(storage, activation)?.into()
         }

core/src/avm2/class.rs

@@ -104,6 +104,9 @@ pub struct ClassData<'gc> {
     /// superinterfaces, nor interfaces implemented by the superclass.
     direct_interfaces: Vec<Class<'gc>>,
 
+    /// The list of all interfaces implemented by this class.
+    all_interfaces: Vec<Class<'gc>>,
+
     /// The instance allocator for this class.
     ///
     /// If `None`, then instances of this object will be allocated the same way
@@ -163,7 +166,7 @@ pub struct ClassData<'gc> {
     /// Maps a type parameter to the application of this class with that parameter.
     ///
     /// Only applicable if this class is generic.
-    applications: FnvHashMap<Option<ClassKey<'gc>>, Class<'gc>>,
+    applications: FnvHashMap<Option<Class<'gc>>, Class<'gc>>,
 
     /// Whether or not this is a system-defined class.
     ///
@@ -184,29 +187,17 @@ impl PartialEq for Class<'_> {
     }
 }
 
-impl<'gc> core::fmt::Debug for Class<'gc> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        f.debug_struct("Class").field("name", &self.name()).finish()
-    }
-}
-
-/// Allows using a `Class<'gc>` as a HashMap key,
-/// using the pointer address for hashing/equality.
-#[derive(Collect, Copy, Clone)]
-#[collect(no_drop)]
-struct ClassKey<'gc>(Class<'gc>);
+impl Eq for Class<'_> {}
 
-impl PartialEq for ClassKey<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0
+impl Hash for Class<'_> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.as_ptr().hash(state);
     }
 }
 
-impl Eq for ClassKey<'_> {}
-
-impl Hash for ClassKey<'_> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0 .0.as_ptr().hash(state);
+impl<'gc> core::fmt::Debug for Class<'gc> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        f.debug_struct("Class").field("name", &self.name()).finish()
     }
 }
 
@@ -237,6 +228,7 @@ impl<'gc> Class<'gc> {
                 attributes: ClassAttributes::empty(),
                 protected_namespace: None,
                 direct_interfaces: Vec::new(),
+                all_interfaces: Vec::new(),
                 instance_allocator: None,
                 instance_init,
                 native_instance_init,
@@ -255,8 +247,7 @@ impl<'gc> Class<'gc> {
     }
 
     pub fn add_application(self, mc: &Mutation<'gc>, param: Option<Class<'gc>>, cls: Class<'gc>) {
-        let key = param.map(ClassKey);
-        self.0.write(mc).applications.insert(key, cls);
+        self.0.write(mc).applications.insert(param, cls);
     }
 
     /// Apply type parameters to an existing class.
@@ -271,9 +262,7 @@ impl<'gc> Class<'gc> {
         let mc = context.gc_context;
         let this_read = this.0.read();
 
-        let key = param.map(ClassKey);
-
-        if let Some(application) = this_read.applications.get(&key) {
+        if let Some(application) = this_read.applications.get(&param) {
             return *application;
         }
 
@@ -312,7 +301,7 @@ impl<'gc> Class<'gc> {
 
         drop(this_read);
 
-        this.0.write(mc).applications.insert(key, new_class);
+        this.0.write(mc).applications.insert(Some(param), new_class);
         new_class
     }
 
@@ -464,6 +453,7 @@ impl<'gc> Class<'gc> {
                 attributes,
                 protected_namespace,
                 direct_interfaces: interfaces,
+                all_interfaces: Vec::new(),
                 instance_allocator,
                 instance_init,
                 native_instance_init,
@@ -658,7 +648,7 @@ impl<'gc> Class<'gc> {
         // interfaces (i.e. those that were not already implemented by the superclass)
         // Otherwise, our behavior diverges from Flash Player in certain cases.
         // See the ignored test 'tests/tests/swfs/avm2/weird_superinterface_properties/'
-        for interface in interfaces {
+        for interface in &interfaces {
             for interface_trait in &*interface.instance_traits() {
                 if !interface_trait.name().namespace().is_public() {
                     let public_name = QName::new(
@@ -674,6 +664,8 @@ impl<'gc> Class<'gc> {
             }
         }
 
+        self.0.write(context.gc_context).all_interfaces = interfaces;
+
         Ok(())
     }
 
@@ -704,6 +696,7 @@ impl<'gc> Class<'gc> {
                 attributes: ClassAttributes::empty(),
                 protected_namespace: None,
                 direct_interfaces: Vec::new(),
+                all_interfaces: Vec::new(),
                 instance_allocator: None,
                 instance_init: Method::from_builtin(
                     |_, _, _| Ok(Value::Undefined),
@@ -737,6 +730,36 @@ impl<'gc> Class<'gc> {
         Ok(class)
     }
 
+    /// Determine if this class has a given type in its superclass chain.
+    ///
+    /// The given class `test_class` should be either a superclass or
+    /// interface we are checking against this class.
+    ///
+    /// To test if a class *instance* is of a given type, see `Object::is_of_type`.
+    pub fn has_class_in_chain(self, test_class: Class<'gc>) -> bool {
+        let mut my_class = Some(self);
+
+        while let Some(class) = my_class {
+            if class == test_class {
+                return true;
+            }
+
+            my_class = class.super_class()
+        }
+
+        // A `Class` stores all of the interfaces it implements, including
+        // those from superinterfaces and superclasses (recursively).
+        if test_class.is_interface() {
+            for interface in &*self.all_interfaces() {
+                if *interface == test_class {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+
     pub fn instance_vtable(self) -> VTable<'gc> {
         self.0.read().instance_vtable
     }
@@ -749,6 +772,26 @@ impl<'gc> Class<'gc> {
         self.0.try_read().map(|r| r.name)
     }
 
+    /// Attempts to obtain the name of this class.
+    /// If we are unable to read from the necessary `GcCell`,
+    /// the returned value will be some kind of error message.
+    ///
+    /// This should only be used in a debug context, where
+    /// we need infallible access to *something* to print
+    /// out.
+    pub fn debug_name(self) -> Box<dyn fmt::Debug + 'gc> {
+        let class_name = self.try_name();
+
+        match class_name {
+            Ok(class_name) => Box::new(class_name),
+            Err(err) => Box::new(err),
+        }
+    }
+
+    pub fn param(self) -> Option<Option<Class<'gc>>> {
+        self.0.read().param
+    }
+
     pub fn set_param(self, mc: &Mutation<'gc>, param: Option<Option<Class<'gc>>>) {
         self.0.write(mc).param = param;
     }
@@ -1079,6 +1122,10 @@ impl<'gc> Class<'gc> {
         Ref::map(self.0.read(), |c| &c.direct_interfaces)
     }
 
+    pub fn all_interfaces(&self) -> Ref<Vec<Class<'gc>>> {
+        Ref::map(self.0.read(), |c| &c.all_interfaces)
+    }
+
     /// Determine if this class is sealed (no dynamic properties)
     pub fn is_sealed(self) -> bool {
         self.0.read().attributes.contains(ClassAttributes::SEALED)

core/src/avm2/error.rs

@@ -1,10 +1,7 @@
 use ruffle_wstr::WString;
 
 use crate::avm2::object::TObject;
-use crate::avm2::Activation;
-use crate::avm2::AvmString;
-use crate::avm2::Multiname;
-use crate::avm2::Value;
+use crate::avm2::{Activation, AvmString, Class, Multiname, Value};
 use std::borrow::Cow;
 use std::fmt::Debug;
 use std::mem::size_of;
@@ -94,13 +91,12 @@ pub fn make_reference_error<'gc>(
     activation: &mut Activation<'_, 'gc>,
     code: ReferenceErrorCode,
     multiname: &Multiname<'gc>,
-    object_class: Option<ClassObject<'gc>>,
+    object_class: Option<Class<'gc>>,
 ) -> Error<'gc> {
     let qualified_name = multiname.as_uri(activation.context.gc_context);
     let class_name = object_class
         .map(|cls| {
-            cls.inner_class_definition()
-                .name()
+            cls.name()
                 .to_qualified_name_err_message(activation.context.gc_context)
         })
         .unwrap_or_else(|| AvmString::from("<UNKNOWN>"));

core/src/avm2/globals.rs

@@ -419,18 +419,17 @@ fn vector_class<'gc>(
     let mc = activation.context.gc_context;
     let (_, global, mut domain) = script.init();
 
-    let cls = param_class.map(|c| c.inner_class_definition());
+    let param_class = param_class.map(|c| c.inner_class_definition());
     let vector_cls = class(
-        vector::create_builtin_class(activation, cls),
+        vector::create_builtin_class(activation, param_class),
         script,
         activation,
     )?;
-    vector_cls.set_param(mc, Some(param_class));
 
     let generic_vector = activation.avm2().classes().generic_vector;
     generic_vector.add_application(mc, param_class, vector_cls);
     let generic_cls = generic_vector.inner_class_definition();
-    generic_cls.add_application(mc, cls, vector_cls.inner_class_definition());
+    generic_cls.add_application(mc, param_class, vector_cls.inner_class_definition());
 
     let legacy_name = QName::new(activation.avm2().vector_internal_namespace, legacy_name);
     global.install_const_late(

core/src/avm2/globals/flash/display/bitmap_data.rs

@@ -92,7 +92,7 @@ pub fn init<'gc>(
 ) -> Result<Value<'gc>, Error<'gc>> {
     // We set the underlying BitmapData instance - we start out with a dummy BitmapDataWrapper,
     // which makes custom classes see a disposed BitmapData before they call super()
-    let name = this.instance_of_class_definition().map(|c| c.name());
+    let name = this.instance_class().map(|c| c.name());
     let character = this
         .instance_of()
         .and_then(|t| {
@@ -374,7 +374,7 @@ pub fn get_vector<'gc>(
             height,
         );
 
-        let value_type = activation.avm2().classes().uint;
+        let value_type = activation.avm2().classes().uint.inner_class_definition();
         let new_storage = VectorStorage::from_values(pixels, false, Some(value_type));
 
         return Ok(VectorObject::from_vector(new_storage, activation)?.into());