avm2: Use direct slot access in more native code

core/src/avm2/activation.rs

@@ -1559,7 +1559,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             ScriptObject::catch_scope(self, &vname)
         } else {
             // for `finally` scopes, FP just creates a normal object.
-            self.avm2().classes().object.construct(self, &[])?
+            ScriptObject::new_object(self)
         };
 
         self.push_stack(so);
@@ -1813,13 +1813,13 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     }
 
     fn op_new_object(&mut self, num_args: u32) -> Result<FrameControl<'gc>, Error<'gc>> {
-        let object = self.context.avm2.classes().object.construct(self, &[])?;
+        let object = ScriptObject::new_object(self);
 
         for _ in 0..num_args {
             let value = self.pop_stack();
             let name = self.pop_stack();
 
-            object.set_public_property(name.coerce_to_string(self)?, value, self)?;
+            object.set_string_property_local(name.coerce_to_string(self)?, value, self)?;
         }
 
         self.push_stack(object);
@@ -1835,7 +1835,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let method_entry = self.table_method(method, index, true)?;
         let scope = self.create_scopechain();
 
-        let new_fn = FunctionObject::from_function(self, method_entry, scope)?;
+        let new_fn = FunctionObject::from_method(self, method_entry, scope, None, None, None);
 
         self.push_stack(new_fn);
 
@@ -2527,13 +2527,15 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let object = self.pop_stack();
         if matches!(object, Value::Undefined | Value::Null) {
             self.push_raw(0.0);
+        } else if let Some(next_index) = object
+            .as_object()
+            .map(|o| o.get_next_enumerant(cur_index, self))
+            .transpose()?
+            .flatten()
+        {
+            self.push_raw(next_index);
         } else {
-            let object = object.coerce_to_object(self)?;
-            if let Some(next_index) = object.get_next_enumerant(cur_index, self)? {
-                self.push_raw(next_index);
-            } else {
-                self.push_raw(0.0);
-            }
+            self.push_raw(0.0);
         }
 
         Ok(FrameControl::Continue)
@@ -2689,16 +2691,14 @@ impl<'a, 'gc> Activation<'a, 'gc> {
 
         let value = self.pop_stack();
 
-        if let Ok(value) = value.coerce_to_object(self) {
-            let is_instance_of = value.is_instance_of(self, type_object)?;
+        match value {
+            Value::Undefined => return Err(make_null_or_undefined_error(self, value, None)),
+            Value::Null => self.push_raw(false),
+            value => {
+                let is_instance_of = value.is_instance_of(self, type_object);
 
-            self.push_raw(is_instance_of);
-        } else if matches!(value, Value::Undefined) {
-            // undefined
-            return Err(make_null_or_undefined_error(self, value, None));
-        } else {
-            // null
-            self.push_raw(false);
+                self.push_raw(is_instance_of);
+            }
         }
 
         Ok(FrameControl::Continue)

core/src/avm2/amf.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 use super::property::Property;
 use crate::avm2::bytearray::ByteArrayStorage;
 use crate::avm2::class::Class;
-use crate::avm2::object::{ByteArrayObject, ClassObject, TObject, VectorObject};
+use crate::avm2::object::{ByteArrayObject, ClassObject, ScriptObject, TObject, VectorObject};
 use crate::avm2::vector::VectorStorage;
 use crate::avm2::ArrayObject;
 use crate::avm2::ArrayStorage;
@@ -315,7 +315,7 @@ pub fn deserialize_value_impl<'gc>(
 
             // Now let's add each element as a property
             for element in elements {
-                array.set_public_property(
+                array.set_string_property_local(
                     AvmString::new_utf8(activation.context.gc_context, element.name()),
                     deserialize_value_impl(activation, element.value(), object_map)?,
                     activation,
@@ -473,7 +473,7 @@ pub fn deserialize_value_impl<'gc>(
                     dict_obj.set_property_by_object(key, value, activation.context.gc_context);
                 } else {
                     let key_string = key.coerce_to_string(activation)?;
-                    dict_obj.set_public_property(key_string, value, activation)?;
+                    dict_obj.set_string_property_local(key_string, value, activation)?;
                 }
             }
             dict_obj.into()
@@ -507,14 +507,10 @@ pub fn deserialize_lso<'gc>(
     activation: &mut Activation<'_, 'gc>,
     lso: &Lso,
 ) -> Result<Object<'gc>, Error<'gc>> {
-    let obj = activation
-        .avm2()
-        .classes()
-        .object
-        .construct(activation, &[])?;
+    let obj = ScriptObject::new_object(activation);
 
     for child in &lso.body {
-        obj.set_public_property(
+        obj.set_string_property_local(
             AvmString::new_utf8(activation.context.gc_context, &child.name),
             deserialize_value(activation, child.value())?,
             activation,

core/src/avm2/e4x.rs

@@ -1,25 +1,21 @@
-use std::{
-    cell::{Ref, RefMut},
-    fmt::{self, Debug},
-};
+use crate::avm2::error::{make_error_1010, make_error_1085, make_error_1118, type_error};
+use crate::avm2::globals::slots::xml as xml_class_slots;
+use crate::avm2::object::{E4XOrXml, FunctionObject, NamespaceObject};
+use crate::avm2::{Activation, Error, Multiname, TObject, Value};
+use crate::string::{AvmString, WStr, WString};
+use crate::xml::custom_unescape;
 
 use gc_arena::{Collect, GcCell, Mutation};
+
 use quick_xml::{
     errors::{IllFormedError, SyntaxError as XmlSyntaxError},
     events::{attributes::AttrError as XmlAttrError, BytesStart, Event},
     name::ResolveResult,
     Error as XmlError, NsReader,
 };
 
-use crate::{avm2::TObject, xml::custom_unescape};
-
-use super::{
-    error::{make_error_1010, make_error_1085, make_error_1118, type_error},
-    object::{E4XOrXml, FunctionObject, NamespaceObject},
-    string::AvmString,
-    Activation, Error, Multiname, Value,
-};
-use crate::string::{WStr, WString};
+use std::cell::{Ref, RefMut};
+use std::fmt::{self, Debug};
 
 mod is_xml_name;
 mod iterators;
@@ -1664,16 +1660,15 @@ pub fn to_xml_string<'gc>(
         .avm2()
         .classes()
         .xml
-        .get_public_property("prettyPrinting", activation)
-        .expect("prettyPrinting should be set")
+        .get_slot(xml_class_slots::PRETTY_PRINTING)
         .coerce_to_boolean();
+
     let pretty = if pretty_printing {
         let pretty_indent = activation
             .avm2()
             .classes()
             .xml
-            .get_public_property("prettyIndent", activation)
-            .expect("prettyIndent should be set")
+            .get_slot(xml_class_slots::PRETTY_INDENT)
             .coerce_to_i32(activation)
             .expect("shouldn't error");
 

core/src/avm2/filters.rs

@@ -10,6 +10,7 @@ use swf::{
 };
 
 use crate::avm2::error::{make_error_2008, type_error};
+use crate::avm2::globals::slots::flash_geom_point as point_slots;
 use crate::avm2::{Activation, ArrayObject, ClassObject, Error, Object, TObject, Value};
 
 use super::globals::flash::display::shader_job::get_shader_args;
@@ -458,12 +459,8 @@ fn avm2_to_displacement_map_filter<'gc>(
     let map_point =
         if let Value::Object(point) = object.get_public_property("mapPoint", activation)? {
             (
-                point
-                    .get_public_property("x", activation)?
-                    .coerce_to_i32(activation)?,
-                point
-                    .get_public_property("y", activation)?
-                    .coerce_to_i32(activation)?,
+                point.get_slot(point_slots::X).coerce_to_i32(activation)?,
+                point.get_slot(point_slots::Y).coerce_to_i32(activation)?,
             )
         } else {
             (0, 0)

core/src/avm2/flv.rs

@@ -21,7 +21,7 @@ fn avm2_object_from_flv_variables<'gc>(
         let property_name = value.name;
 
         info_object
-            .set_public_property(
+            .set_string_property_local(
                 AvmString::new_utf8_bytes(activation.context.gc_context, property_name),
                 value.data.to_avm2_value(activation),
                 activation,

core/src/avm2/globals.rs

@@ -210,6 +210,7 @@ pub struct SystemClassDefs<'gc> {
     pub rectangletexture: Class<'gc>,
     pub display_object: Class<'gc>,
     pub sprite: Class<'gc>,
+    pub contextmenuitem: Class<'gc>,
 }
 
 impl<'gc> SystemClasses<'gc> {
@@ -380,6 +381,7 @@ impl<'gc> SystemClassDefs<'gc> {
             rectangletexture: object,
             display_object: object,
             sprite: object,
+            contextmenuitem: object,
         }
     }
 }
@@ -1004,6 +1006,7 @@ pub fn init_native_system_classes(activation: &mut Activation<'_, '_>) {
                 "RectangleTexture",
                 rectangletexture
             ),
+            ("flash.ui", "ContextMenuItem", contextmenuitem),
         ]
     );
 }

core/src/avm2/globals/XML.as

@@ -106,7 +106,11 @@ package {
         public static var ignoreComments:Boolean = true;
         public static var ignoreProcessingInstructions:Boolean = true;
         public static var ignoreWhitespace:Boolean = true;
+
+        [Ruffle(InternalSlot)]
         public static var prettyPrinting:Boolean = true;
+
+        [Ruffle(InternalSlot)]
         public static var prettyIndent:int = 2;
 
         prototype.hasComplexContent = function():Boolean {