avm1: Reference display objects indirectly by string path

core/src/avm1.rs

@@ -15,6 +15,7 @@ mod error;
 mod fscommand;
 pub(crate) mod globals;
 mod object;
+mod object_reference;
 mod property;
 mod property_map;
 mod runtime;

core/src/avm1/activation.rs

@@ -28,6 +28,8 @@ use swf::avm1::types::*;
 use swf::Twips;
 use url::form_urlencoded;
 
+use super::object_reference::MovieClipReference;
+
 macro_rules! avm_debug {
     ($avm: expr, $($arg:tt)*) => (
         if $avm.show_debug_output() {
@@ -537,6 +539,24 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         }
     }
 
+    fn stack_push(&mut self, mut value: Value<'gc>) {
+        if let Value::Object(Object::StageObject(s)) = value {
+            // Note that there currently exists a subtle issue with this logic:
+            // If the cached `Object` in a `MovieClipReference` becomes invalidated, causing it to switch back to path-based object resolution,
+            // it should *never* switch back to cache-based resolution
+            // However, currently if a `MovieClipReference` in this invalidated-cache state is converted back to an `Object`, such as when passed as an argument to a function,
+            // if it pushed back onto the stack then it will be converted into a new `MovieClipReference`, causing it to switch back to cache-based resolution
+            // Fixing this will require a thorough refactor of AVM1 to store `Either<MovieClipReference, Object>
+            // can refer to a MovieClip
+            // There is a ignored test for this issue of "reference laundering" at "avm1/string_paths_reference_launder"
+            if let Some(mcr) = MovieClipReference::try_from_stage_object(self, s) {
+                value = Value::MovieClip(mcr);
+            }
+        }
+
+        self.context.avm1.push(value);
+    }
+
     fn action_add(&mut self) -> Result<FrameControl<'gc>, Error<'gc>> {
         let a = self.context.avm1.pop();
         let b = self.context.avm1.pop();
@@ -549,6 +569,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         // ECMA-262 s. 11.6.1
         let a = self.context.avm1.pop().to_primitive(self)?;
         let b = self.context.avm1.pop().to_primitive(self)?;
+
         let result: Value<'_> = match (a, b) {
             (Value::String(a), Value::String(b)) => {
                 AvmString::concat(self.context.gc_context, b, a).into()
@@ -729,7 +750,12 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let num_args = num_args.min(self.context.avm1.stack_len());
         let mut args = Vec::with_capacity(num_args);
         for _ in 0..num_args {
-            args.push(self.context.avm1.pop());
+            let arg = self.context.avm1.pop();
+            if let Value::MovieClip(_) = arg {
+                args.push(Value::Object(arg.coerce_to_object(self)));
+            } else {
+                args.push(arg);
+            }
         }
 
         let variable = self.get_variable(fn_name)?;
@@ -740,7 +766,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             self,
             &args,
         )?;
-        self.context.avm1.push(result);
+        self.stack_push(result);
 
         // After any function call, execution of this frame stops if the base clip doesn't exist.
         // For example, a _root.gotoAndStop moves the timeline to a frame where the clip was removed.
@@ -754,12 +780,17 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let num_args = num_args.min(self.context.avm1.stack_len());
         let mut args = Vec::with_capacity(num_args);
         for _ in 0..num_args {
-            args.push(self.context.avm1.pop());
+            let arg = self.context.avm1.pop();
+            if let Value::MovieClip(_) = arg {
+                args.push(Value::Object(arg.coerce_to_object(self)));
+            } else {
+                args.push(arg);
+            }
         }
 
         // Can not call method on undefined/null.
         if matches!(object_val, Value::Undefined | Value::Null) {
-            self.context.avm1.push(Value::Undefined);
+            self.stack_push(Value::Undefined);
             return Ok(FrameControl::Continue);
         }
 
@@ -778,7 +809,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             // Call `this[method_name]`.
             object.call_method(method_name, &args, self, ExecutionReason::FunctionCall)?
         };
-        self.context.avm1.push(result);
+        self.stack_push(result);
 
         self.continue_if_base_clip_exists()
     }
@@ -790,6 +821,10 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let is_instance_of = if let Value::Object(obj) = obj {
             let prototype = constr.get("prototype", self)?.coerce_to_object(self);
             obj.is_instance_of(self, constr, prototype)?
+        } else if let Value::MovieClip(_) = obj {
+            let obj = obj.coerce_to_object(self);
+            let prototype = constr.get("prototype", self)?.coerce_to_object(self);
+            obj.is_instance_of(self, constr, prototype)?
         } else {
             false
         };
@@ -904,6 +939,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
 
         let success = if let Value::Object(object) = object {
             object.delete(self, name)
+        } else if let Value::MovieClip(_) = object {
+            let object = object.coerce_to_object(self);
+            object.delete(self, name)
         } else {
             avm_warn!(self, "Cannot delete property {} from {:?}", name, object);
             false
@@ -962,9 +1000,15 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.context.avm1.push(Value::Undefined); // Sentinel that indicates end of enumeration
 
         match object {
+            Value::MovieClip(_) => {
+                let ob = object.coerce_to_object(self);
+                for k in ob.get_keys(self).into_iter().rev() {
+                    self.stack_push(k.into());
+                }
+            }
             Value::Object(ob) => {
                 for k in ob.get_keys(self).into_iter().rev() {
-                    self.context.avm1.push(k.into());
+                    self.stack_push(k.into());
                 }
             }
             _ => avm_error!(self, "Cannot enumerate properties of {}", name),
@@ -978,9 +1022,14 @@ impl<'a, 'gc> Activation<'a, 'gc> {
 
         self.context.avm1.push(Value::Undefined); // Sentinel that indicates end of enumeration
 
-        if let Value::Object(object) = value {
+        if let Value::MovieClip(_) = value {
+            let object = value.coerce_to_object(self);
+            for k in object.get_keys(self).into_iter().rev() {
+                self.stack_push(k.into());
+            }
+        } else if let Value::Object(object) = value {
             for k in object.get_keys(self).into_iter().rev() {
-                self.context.avm1.push(k.into());
+                self.stack_push(k.into());
             }
         } else {
             avm_warn!(self, "Cannot enumerate {:?}", value);
@@ -1051,7 +1100,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let object = object_val.coerce_to_object(self);
 
         let result = object.get(name, self)?;
-        self.context.avm1.push(result);
+        self.stack_push(result);
 
         Ok(FrameControl::Continue)
     }
@@ -1082,7 +1131,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             avm_warn!(self, "GetProperty: Invalid base clip");
             Value::Undefined
         };
-        self.context.avm1.push(result);
+        self.stack_push(result);
         Ok(FrameControl::Continue)
     }
 
@@ -1106,7 +1155,8 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let path = var_path.coerce_to_string(self)?;
 
         let value: Value<'gc> = self.get_variable(path)?.into();
-        self.context.avm1.push(value);
+
+        self.stack_push(value);
 
         Ok(FrameControl::Continue)
     }
@@ -1194,6 +1244,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         } else if action.is_load_vars() || action.is_target_sprite() {
             if let Value::Object(target) = target_val {
                 target.as_display_object()
+            } else if let Value::MovieClip(_) = target_val {
+                let tgt = target_val.coerce_to_object(self);
+                tgt.as_display_object()
             } else {
                 let start = self.target_clip_or_root();
                 self.resolve_target_display_object(start, target_val, true)?
@@ -1213,6 +1266,11 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                         is_load_vars = DisplayObject::ptr_eq(clip, self.base_clip().avm1_root());
                     }
                 }
+                if matches!(target_val, Value::MovieClip(_)) {
+                    if let Some(clip) = clip_target {
+                        is_load_vars = DisplayObject::ptr_eq(clip, self.base_clip().avm1_root());
+                    }
+                }
             }
             if is_load_vars {
                 if let Some(clip_target) = clip_target {
@@ -1402,7 +1460,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             Value::Object(object.into())
         };
 
-        self.context.avm1.push(result);
+        self.stack_push(result);
         Ok(FrameControl::Continue)
     }
 
@@ -1441,6 +1499,10 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let result = if let Value::Object(obj) = obj {
             let prototype = constr.get("prototype", self)?.coerce_to_object(self);
             obj.is_instance_of(self, constr, prototype)?
+        } else if let Value::MovieClip(_) = obj {
+            let obj = obj.coerce_to_object(self);
+            let prototype = constr.get("prototype", self)?.coerce_to_object(self);
+            obj.is_instance_of(self, constr, prototype)?
         } else {
             false
         };
@@ -1601,7 +1663,12 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let num_args = num_args.min(self.context.avm1.stack_len());
         let mut args = Vec::with_capacity(num_args);
         for _ in 0..num_args {
-            args.push(self.context.avm1.pop());
+            let arg = self.context.avm1.pop();
+            if let Value::MovieClip(_) = arg {
+                args.push(Value::Object(arg.coerce_to_object(self)));
+            } else {
+                args.push(arg);
+            }
         }
 
         // Can not call method on undefined/null.
@@ -1636,7 +1703,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             }
         };
 
-        self.context.avm1.push(result);
+        self.stack_push(result);
 
         self.continue_if_base_clip_exists()
     }
@@ -1648,13 +1715,18 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let num_args = num_args.min(self.context.avm1.stack_len());
         let mut args = Vec::with_capacity(num_args);
         for _ in 0..num_args {
-            args.push(self.context.avm1.pop());
+            let arg = self.context.avm1.pop();
+            if let Value::MovieClip(_) = arg {
+                args.push(Value::Object(arg.coerce_to_object(self)));
+            } else {
+                args.push(arg);
+            }
         }
 
         let name_value: Value<'gc> = self.resolve(fn_name)?.into();
         let constructor = name_value.coerce_to_object(self);
         let result = constructor.construct(self, &args)?;
-        self.context.avm1.push(result);
+        self.stack_push(result);
 
         self.continue_if_base_clip_exists()
     }
@@ -1728,7 +1800,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                     }
                 }
             };
-            self.context.avm1.push(value);
+            self.stack_push(value); // Needs to handle MovieClipReferences, in case pushing a register
         }
         Ok(FrameControl::Continue)
     }
@@ -1854,6 +1926,17 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                     return self.set_target(&target);
                 }
             }
+            Value::MovieClip(_) => {
+                let o = target.coerce_to_object(self);
+                if let Some(clip) = o.as_display_object() {
+                    // MovieClips can be targeted directly.
+                    self.set_target_clip(Some(clip));
+                } else {
+                    // Other objects get coerced to string.
+                    let target = target.coerce_to_string(self)?;
+                    return self.set_target(&target);
+                }
+            }
             _ => {
                 let target = target.coerce_to_string(self)?;
                 return self.set_target(&target);
@@ -2480,6 +2563,8 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             // Resolve the value to an object while traversing the path.
             object = if let Value::Object(o) = val {
                 o
+            } else if let Value::MovieClip(_) = val {
+                val.coerce_to_object(self)
             } else {
                 return Ok(None);
             };

core/src/avm1/callable_value.rs

@@ -4,7 +4,7 @@ use crate::avm1::{Object, TObject, Value};
 use crate::string::AvmString;
 use gc_arena::Collect;
 
-#[derive(Clone, Collect)]
+#[derive(Clone, Collect, Debug)]
 #[collect(no_drop)]
 pub enum CallableValue<'gc> {
     UnCallable(Value<'gc>),

core/src/avm1/debug.rs

@@ -152,6 +152,10 @@ impl<'a> VariableDumper<'a> {
             Value::Object(object) => {
                 self.print_object(object, activation);
             }
+            Value::MovieClip(_) => {
+                let obj = value.coerce_to_object(activation);
+                self.print_object(&obj, activation);
+            }
         }
     }
 

core/src/avm1/globals/as_broadcaster.rs

@@ -145,6 +145,9 @@ pub fn broadcast_internal<'gc>(
                     activation,
                     ExecutionReason::Special,
                 )?;
+            } else if let Value::MovieClip(_) = listener {
+                let object = listener.coerce_to_object(activation);
+                object.call_method(method_name, call_args, activation, ExecutionReason::Special)?;
             }
         }
 

core/src/avm1/globals/movie_clip_loader.rs

@@ -56,6 +56,7 @@ fn load_clip<'gc>(
                     Some(activation.resolve_level(*level_id as i32))
                 }
                 Value::Object(object) => object.as_display_object(),
+                Value::MovieClip(_) => target.coerce_to_object(activation).as_display_object(),
                 _ => None,
             };
             if let Some(target) = target {
@@ -96,6 +97,7 @@ fn unload_clip<'gc>(
                 activation.context.stage.child_by_depth(*level_id as i32)
             }
             Value::Object(object) => object.as_display_object(),
+            Value::MovieClip(_) => target.coerce_to_object(activation).as_display_object(),
             _ => None,
         };
         if let Some(target) = target {
@@ -131,6 +133,7 @@ fn get_progress<'gc>(
             Value::Object(object) if object.as_display_object().is_some() => {
                 object.as_display_object()
             }
+            Value::MovieClip(_) => target.coerce_to_object(activation).as_display_object(),
             _ => return Ok(Value::Undefined),
         };
         let result = ScriptObject::new(activation.context.gc_context, None);

core/src/avm1/globals/selection.rs

@@ -137,6 +137,20 @@ pub fn set_focus<'gc>(
                 Ok(true.into())
             }
         }
+        Some(Value::MovieClip(_)) => {
+            let obj = args.get(0).unwrap().coerce_to_object(activation);
+
+            if let Some(display_object) = obj.as_display_object() {
+                if display_object.is_focusable() {
+                    tracker.set(Some(display_object), &mut activation.context);
+                }
+                // [NA] Note: The documentation says true is success and false is failure,
+                // but from testing this seems to be opposite.
+                Ok(false.into())
+            } else {
+                Ok(true.into())
+            }
+        }
         _ => Ok(false.into()),
     }
 }

core/src/avm1/globals/shared_object.rs

@@ -60,7 +60,7 @@ fn serialize_value<'gc>(
     elem: Value<'gc>,
 ) -> Option<AmfValue> {
     match elem {
-        Value::Undefined => Some(AmfValue::Undefined),
+        Value::Undefined | Value::MovieClip(_) => Some(AmfValue::Undefined),
         Value::Null => Some(AmfValue::Null),
         Value::Bool(b) => Some(AmfValue::Bool(b)),
         Value::Number(f) => Some(AmfValue::Number(f)),