avm2: Store slot and disp ids as usize internally

Previously, they were being stored as u32s

Author: Lord-McSweeney

core/build_playerglobal/src/lib.rs

@@ -461,7 +461,7 @@ fn write_native_table(data: &[u8], out_dir: &Path) -> Result<Vec<u8>, Box<dyn st
                         panic!("ASC should calculate slot ids for all slots; cannot apply NativeAccessible without a compiler-calculated slot id")
                     } else {
                         // Slots are 1-indexed!
-                        let slot_id = slot_id - 1;
+                        let slot_id = slot_id as usize - 1;
 
                         let (trait_name, const_name) =
                             rust_path_and_trait_name(&abc, trait_, parent);
@@ -472,7 +472,7 @@ fn write_native_table(data: &[u8], out_dir: &Path) -> Result<Vec<u8>, Box<dyn st
                             .entry(trait_name)
                             .or_default()
                             .push(quote! {
-                                pub const #const_name: u32 = #slot_id;
+                                pub const #const_name: usize = #slot_id;
                             });
                     }
                 }
@@ -490,6 +490,7 @@ fn write_native_table(data: &[u8], out_dir: &Path) -> Result<Vec<u8>, Box<dyn st
                         // add 1 if it's a class method, or subtract 2 if it's
                         // an instance method.
                         let disp_id = if is_class { disp_id + 1 } else { disp_id - 2 };
+                        let disp_id = disp_id as usize;
 
                         let (trait_name, const_name) =
                             rust_path_and_trait_name(&abc, trait_, parent);
@@ -506,7 +507,7 @@ fn write_native_table(data: &[u8], out_dir: &Path) -> Result<Vec<u8>, Box<dyn st
                             .entry(trait_name)
                             .or_default()
                             .push(quote! {
-                                pub const #const_name: u32 = #disp_id;
+                                pub const #const_name: usize = #disp_id;
                             });
                     }
                 }

core/src/avm2/activation.rs

@@ -1033,7 +1033,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let args = self.stack.get_args(arg_count as usize);
         let receiver = self.pop_stack().null_check(self, None)?;
 
-        let value = receiver.call_method_with_args(index, args, self)?;
+        let value = receiver.call_method_with_args(index as usize, args, self)?;
 
         if push_return_value {
             self.push_stack(value);
@@ -1636,7 +1636,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             .null_check(self, None)?
             .as_object()
             .expect("Cannot get_slot on primitive");
-        let value = object.get_slot(index);
+        let value = object.get_slot(index as usize);
 
         // We use `stack_top` instead of `pop_stack` and `push_stack` here
         // because it allows us to skip the extra bounds checks and stack pointer
@@ -1655,7 +1655,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             .as_object()
             .expect("Cannot set_slot on primitive");
 
-        object.set_slot(index, value, self)?;
+        object.set_slot(index as usize, value, self)?;
 
         Ok(())
     }
@@ -1668,7 +1668,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             .as_object()
             .expect("Cannot set_slot on primitive");
 
-        object.set_slot_no_coerce(index, value, self.gc());
+        object.set_slot_no_coerce(index as usize, value, self.gc());
 
         Ok(())
     }
@@ -1679,7 +1679,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.global_scope()
             .as_object()
             .unwrap()
-            .set_slot(index, value, self)?;
+            .set_slot(index as usize, value, self)?;
 
         Ok(())
     }
@@ -1720,7 +1720,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             .as_object()
             .expect("Cannot get_slot on primitive");
 
-        let ctor = source.get_slot(index);
+        let ctor = source.get_slot(index as usize);
         let constructed_object = ctor.construct(self, args)?;
 
         self.push_stack(constructed_object);

core/src/avm2/error.rs

@@ -252,7 +252,7 @@ pub fn make_error_1025<'gc>(activation: &mut Activation<'_, 'gc>, index: u32) ->
 #[cold]
 pub fn make_error_1026<'gc>(
     activation: &mut Activation<'_, 'gc>,
-    slot_id: u32,
+    slot_id: usize,
     slot_count: usize,
 ) -> Error<'gc> {
     let err = verify_error(

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

@@ -934,7 +934,7 @@ pub fn object_to_rectangle<'gc>(
     activation: &mut Activation<'_, 'gc>,
     object: Object<'gc>,
 ) -> Result<Rectangle<Twips>, Error<'gc>> {
-    const SLOTS: &[u32] = &[
+    const SLOTS: &[usize] = &[
         rectangle_slots::X,
         rectangle_slots::Y,
         rectangle_slots::WIDTH,

core/src/avm2/globals/flash/events/mouse_event.rs

@@ -40,8 +40,8 @@ pub fn update_after_event<'gc>(
 pub(super) fn local_to_stage_x<'gc>(
     activation: &mut Activation<'_, 'gc>,
     this: Object<'gc>,
-    slot_x: u32,
-    slot_y: u32,
+    slot_x: usize,
+    slot_y: usize,
 ) -> Result<Value<'gc>, Error<'gc>> {
     if let Some(evt) = this.as_event() {
         let local_x = this.get_slot(slot_x).coerce_to_number(activation)?;
@@ -66,8 +66,8 @@ pub(super) fn local_to_stage_x<'gc>(
 pub(super) fn local_to_stage_y<'gc>(
     activation: &mut Activation<'_, 'gc>,
     this: Object<'gc>,
-    slot_x: u32,
-    slot_y: u32,
+    slot_x: usize,
+    slot_y: usize,
 ) -> Result<Value<'gc>, Error<'gc>> {
     if let Some(evt) = this.as_event() {
         let local_x = this.get_slot(slot_x).coerce_to_number(activation)?;

core/src/avm2/object.rs

@@ -399,7 +399,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Debug + Into<Object<'gc>> + Clone +
     /// Retrieve a slot by its index.
     #[no_dynamic]
     #[inline(always)]
-    fn get_slot(self, id: u32) -> Value<'gc> {
+    fn get_slot(self, id: usize) -> Value<'gc> {
         let base = self.base();
 
         base.get_slot(id)
@@ -409,7 +409,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Debug + Into<Object<'gc>> + Clone +
     #[no_dynamic]
     fn set_slot(
         self,
-        id: u32,
+        id: usize,
         value: Value<'gc>,
         activation: &mut Activation<'_, 'gc>,
     ) -> Result<(), Error<'gc>> {
@@ -422,7 +422,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Debug + Into<Object<'gc>> + Clone +
     }
 
     #[no_dynamic]
-    fn set_slot_no_coerce(self, id: u32, value: Value<'gc>, mc: &Mutation<'gc>) {
+    fn set_slot_no_coerce(self, id: usize, value: Value<'gc>, mc: &Mutation<'gc>) {
         let base = self.base();
 
         base.set_slot(id, value, mc);
@@ -580,7 +580,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Debug + Into<Object<'gc>> + Clone +
     fn install_bound_method(
         &self,
         mc: &Mutation<'gc>,
-        disp_id: u32,
+        disp_id: usize,
         function: FunctionObject<'gc>,
     ) {
         let base = self.base();
@@ -691,7 +691,7 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Debug + Into<Object<'gc>> + Clone +
     }
 
     #[no_dynamic]
-    fn get_bound_method(&self, id: u32) -> Option<FunctionObject<'gc>> {
+    fn get_bound_method(&self, id: usize) -> Option<FunctionObject<'gc>> {
         let base = self.base();
         base.get_bound_method(id)
     }

core/src/avm2/object/class_object.rs

@@ -608,7 +608,7 @@ impl<'gc> ClassObject<'gc> {
         self,
         activation: &mut Activation<'_, 'gc>,
         receiver: Object<'gc>,
-        disp_id: u32,
+        disp_id: usize,
         arguments: FunctionArgs<'_, 'gc>,
     ) -> Result<Value<'gc>, Error<'gc>> {
         let full_method = self.instance_vtable().get_full_method(disp_id).unwrap();

core/src/avm2/object/script_object.rs

@@ -290,22 +290,18 @@ impl<'gc> ScriptObjectWrapper<'gc> {
     }
 
     #[inline(always)]
-    pub fn get_slot(self, id: u32) -> Value<'gc> {
+    pub fn get_slot(self, id: usize) -> Value<'gc> {
         self.0
             .slots
-            .get(id as usize)
+            .get(id)
             .cloned()
             .map(|s| s.get())
             .expect("Slot index out of bounds")
     }
 
     /// Set a slot by its index.
-    pub fn set_slot(self, id: u32, value: Value<'gc>, mc: &Mutation<'gc>) {
-        let slot = self
-            .0
-            .slots
-            .get(id as usize)
-            .expect("Slot index out of bounds");
+    pub fn set_slot(self, id: usize, value: Value<'gc>, mc: &Mutation<'gc>) {
+        let slot = self.0.slots.get(id).expect("Slot index out of bounds");
 
         Gc::write(mc, self.0);
         // SAFETY: We just triggered a write barrier on the Gc.
@@ -314,8 +310,8 @@ impl<'gc> ScriptObjectWrapper<'gc> {
     }
 
     /// Retrieve a bound method from the method table.
-    pub fn get_bound_method(self, id: u32) -> Option<FunctionObject<'gc>> {
-        self.bound_methods().get(id as usize).and_then(|v| *v)
+    pub fn get_bound_method(self, id: usize) -> Option<FunctionObject<'gc>> {
+        self.bound_methods().get(id).and_then(|v| *v)
     }
 
     pub fn has_own_dynamic_property(self, name: &Multiname<'gc>) -> bool {
@@ -379,16 +375,16 @@ impl<'gc> ScriptObjectWrapper<'gc> {
     pub fn install_bound_method(
         self,
         mc: &Mutation<'gc>,
-        disp_id: u32,
+        disp_id: usize,
         function: FunctionObject<'gc>,
     ) {
         let mut bound_methods = self.bound_methods_mut(mc);
 
-        if bound_methods.len() <= disp_id as usize {
-            bound_methods.resize_with(disp_id as usize + 1, Default::default);
+        if bound_methods.len() <= disp_id {
+            bound_methods.resize_with(disp_id + 1, Default::default);
         }
 
-        *bound_methods.get_mut(disp_id as usize).unwrap() = Some(function);
+        *bound_methods.get_mut(disp_id).unwrap() = Some(function);
     }
 
     /// Get the `Class` for this object.

core/src/avm2/optimizer/type_aware.rs

@@ -1421,6 +1421,8 @@ fn abstract_interpret_ops<'gc>(
                 locals.set_any(object_register as usize);
             }
             Op::GetSlot { index: slot_id } => {
+                let slot_id = slot_id as usize;
+
                 let stack_value = stack.pop(activation)?;
 
                 // The value must have a vtable
@@ -1450,6 +1452,8 @@ fn abstract_interpret_ops<'gc>(
                 }
             }
             Op::SetSlot { index: slot_id } => {
+                let slot_id = slot_id as usize;
+
                 let set_value = stack.pop(activation)?;
                 let stack_value = stack.pop(activation)?;
 
@@ -1475,7 +1479,9 @@ fn abstract_interpret_ops<'gc>(
 
                 // Skip the coercion when possible
                 if set_value.matches_type(resolved_value_class) {
-                    optimize_op_to!(Op::SetSlotNoCoerce { index: slot_id });
+                    optimize_op_to!(Op::SetSlotNoCoerce {
+                        index: slot_id as u32
+                    });
                 }
             }
             Op::GetPropertyStatic { multiname } => {
@@ -1576,9 +1582,13 @@ fn abstract_interpret_ops<'gc>(
                                 vtable.set_slot_class(activation.gc(), slot_id, value_class);
 
                                 if set_value.matches_type(resolved_value_class) {
-                                    optimize_op_to!(Op::SetSlotNoCoerce { index: slot_id });
+                                    optimize_op_to!(Op::SetSlotNoCoerce {
+                                        index: slot_id as u32
+                                    });
                                 } else {
-                                    optimize_op_to!(Op::SetSlot { index: slot_id });
+                                    optimize_op_to!(Op::SetSlot {
+                                        index: slot_id as u32
+                                    });
                                 }
                             }
                             Some(Property::Virtual {
@@ -1589,7 +1599,7 @@ fn abstract_interpret_ops<'gc>(
 
                                 let mut result_op = Op::CallMethod {
                                     num_args: 1,
-                                    index: disp_id,
+                                    index: disp_id as u32,
                                     push_return_value: false,
                                 };
 
@@ -1631,9 +1641,13 @@ fn abstract_interpret_ops<'gc>(
                             vtable.set_slot_class(activation.gc(), slot_id, value_class);
 
                             if set_value.matches_type(resolved_value_class) {
-                                optimize_op_to!(Op::SetSlotNoCoerce { index: slot_id });
+                                optimize_op_to!(Op::SetSlotNoCoerce {
+                                    index: slot_id as u32
+                                });
                             } else {
-                                optimize_op_to!(Op::SetSlot { index: slot_id });
+                                optimize_op_to!(Op::SetSlot {
+                                    index: slot_id as u32
+                                });
                             }
                         }
                         Some(Property::Virtual {
@@ -1643,7 +1657,7 @@ fn abstract_interpret_ops<'gc>(
 
                             let mut result_op = Op::CallMethod {
                                 num_args: 1,
-                                index: disp_id,
+                                index: disp_id as u32,
                                 push_return_value: false,
                             };
 
@@ -1740,7 +1754,7 @@ fn abstract_interpret_ops<'gc>(
                             Some(Property::Slot { slot_id })
                             | Some(Property::ConstSlot { slot_id }) => {
                                 optimize_op_to!(Op::ConstructSlot {
-                                    index: slot_id,
+                                    index: slot_id as u32,
                                     num_args
                                 });
 
@@ -2235,7 +2249,12 @@ fn optimize_get_property<'gc>(
 
                 vtable.set_slot_class(activation.gc(), slot_id, value_class);
 
-                return Ok(Some((Op::GetSlot { index: slot_id }, resolved_value_class)));
+                return Ok(Some((
+                    Op::GetSlot {
+                        index: slot_id as u32,
+                    },
+                    resolved_value_class,
+                )));
             }
             Some(Property::Virtual {
                 get: Some(disp_id), ..
@@ -2244,7 +2263,7 @@ fn optimize_get_property<'gc>(
 
                 let mut result_op = Op::CallMethod {
                     num_args: 0,
-                    index: disp_id,
+                    index: disp_id as u32,
                     push_return_value: true,
                 };
 
@@ -2293,7 +2312,7 @@ fn optimize_call_property<'gc>(
 
                 let mut result_op = Op::CallMethod {
                     num_args,
-                    index: disp_id,
+                    index: disp_id as u32,
                     push_return_value,
                 };