avm1: Add TDisplayObject::object1_or_bare convenience method

Author: moulins

core/src/avm1/activation.rs

@@ -343,11 +343,10 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         active_clip: DisplayObject<'gc>,
         code: SwfSlice,
     ) -> Result<ReturnType<'gc>, Error<'gc>> {
-        let mut parent_activation =
+        // TODO(moulins): remove this activation, it's useless.
+        let parent_activation =
             Activation::from_nothing(self.context, self.id.child("[Actions Parent]"), active_clip);
-        let clip_obj = active_clip
-            .object1_or_undef()
-            .coerce_to_object(&mut parent_activation);
+        let clip_obj = active_clip.object1_or_bare(parent_activation.gc());
         let child_scope = Gc::new(
             parent_activation.gc(),
             Scope::new(
@@ -866,7 +865,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let swf_version = self.swf_version();
         let func_data = parent_data.to_unbounded_subslice(action.actions);
         let constant_pool = self.constant_pool();
-        let bc = self.base_clip.object1_or_undef().coerce_to_object(self);
+        let bc = self.base_clip.object1_or_bare(self.gc());
         let func = Avm1Function::from_swf_function(
             self.gc(),
             swf_version,
@@ -1253,7 +1252,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             }
             if is_load_vars {
                 if let Some(clip_target) = clip_target {
-                    let target_obj = clip_target.object1_or_undef().coerce_to_object(self);
+                    let target_obj = clip_target.object1_or_bare(self.gc());
                     let request = self.locals_into_request(
                         url,
                         NavigationMethod::from_send_vars_method(action.send_vars_method()),
@@ -1792,10 +1791,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 // Revert the target to the base clip, or `None` if the base was also removed
                 self.set_target_clip(Some(self.base_clip()));
 
-                let clip_obj = self
-                    .target_clip_or_root()
-                    .object1_or_undef()
-                    .coerce_to_object(self);
+                let clip_obj = self.target_clip_or_root().object1_or_bare(self.gc());
 
                 self.set_scope(Scope::new_target_scope(self.scope(), clip_obj, self.gc()));
             }
@@ -1940,10 +1936,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             }
         };
 
-        let clip_obj = self
-            .target_clip_or_base_clip()
-            .object1_or_undef()
-            .coerce_to_object(self);
+        let clip_obj = self.target_clip_or_base_clip().object1_or_bare(self.gc());
 
         self.set_scope(Scope::new_target_scope(self.scope(), clip_obj, self.gc()));
         Ok(FrameControl::Continue)
@@ -2503,7 +2496,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         }
 
         let root = start.avm1_root();
-        let start = start.object1_or_undef().coerce_to_object(self);
+        let start = start.object1_or_bare(self.gc());
         Ok(self
             .resolve_target_path(root, start, &path, false, true)?
             .and_then(|o| o.as_display_object()))
@@ -2535,7 +2528,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         // (`/bar` means `_root.bar`)
         let (mut object, mut is_slash_path) = if path.starts_with(b'/') {
             path = &path[1..];
-            (root.object1_or_undef().coerce_to_object(self), true)
+            (root.object1_or_bare(self.gc()), true)
         } else {
             (start, false)
         };
@@ -2589,7 +2582,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 if first_element && name == b"this" {
                     self.this_cell()
                 } else if first_element && name == b"_root" {
-                    self.root_object()
+                    self.base_clip().avm1_root().object1_or_undef()
                 } else {
                     // Get the value from the object.
                     // Resolves display object instances first, then local variables.
@@ -2869,11 +2862,6 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.target_clip().unwrap_or_else(|| self.base_clip())
     }
 
-    /// Obtain the value of `_root`.
-    pub fn root_object(&self) -> Value<'gc> {
-        self.base_clip().avm1_root().object1_or_undef()
-    }
-
     /// Returns whether property keys should be case sensitive based on the current SWF version.
     pub fn is_case_sensitive(&self) -> bool {
         crate::avm1::runtime::Avm1::is_case_sensitive(self.swf_version())
@@ -2926,7 +2914,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             Scope::new(
                 self.scope,
                 ScopeClass::Target,
-                object.object1_or_undef().coerce_to_object(self),
+                object.object1_or_bare(self.gc()),
             ),
         );
     }
@@ -3022,7 +3010,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let base_clip = self.base_clip();
         let new_target_clip;
         let root = base_clip.avm1_root();
-        let start = base_clip.object1_or_undef().coerce_to_object(self);
+        let start = base_clip.object1_or_bare(self.gc());
         if target.is_empty() {
             new_target_clip = Some(base_clip);
         } else if let Some(clip) = self
@@ -3058,10 +3046,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
 
         self.set_target_clip(new_target_clip);
 
-        let clip_obj = self
-            .target_clip_or_root()
-            .object1_or_undef()
-            .coerce_to_object(self);
+        let clip_obj = self.target_clip_or_root().object1_or_bare(self.gc());
 
         self.set_scope(Scope::new_target_scope(self.scope(), clip_obj, self.gc()));
         Ok(FrameControl::Continue)

core/src/avm1/debug.rs

@@ -147,9 +147,12 @@ 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);
+            Value::MovieClip(mcr) => {
+                if let Some(obj) = mcr.coerce_to_object(activation) {
+                    self.print_object(obj, activation)
+                } else {
+                    self.output.push_str("undefined")
+                }
             }
         }
     }

core/src/avm1/globals/movie_clip.rs

@@ -1595,7 +1595,7 @@ fn load_movie<'gc>(
     let url = url_val.coerce_to_string(activation)?;
     let method = args.get(1).cloned().unwrap_or(Value::Undefined);
     let method = NavigationMethod::from_method_str(&method.coerce_to_string(activation)?);
-    let target_obj = target.object1_or_undef().coerce_to_object(activation);
+    let target_obj = target.object1_or_bare(activation.gc());
     let request = activation.object_into_request(target_obj, url, method);
     let future = activation.context.load_manager.load_movie_into_clip(
         activation.context.player_handle(),
@@ -1618,7 +1618,7 @@ fn load_variables<'gc>(
     let url = url_val.coerce_to_string(activation)?;
     let method = args.get(1).cloned().unwrap_or(Value::Undefined);
     let method = NavigationMethod::from_method_str(&method.coerce_to_string(activation)?);
-    let target = target.object1_or_undef().coerce_to_object(activation);
+    let target = target.object1_or_bare(activation.gc());
     let request = activation.object_into_request(target, url, method);
     let future = crate::loader::load_form_into_object(activation.context, target, request);
     activation.context.navigator.spawn_future(future);

core/src/avm1/object/stage_object.rs

@@ -156,7 +156,7 @@ fn resolve_path_property<'gc>(
     } else if name.eq_with_case(b"_parent", case_sensitive) {
         return Some(
             dobj.avm1_parent()
-                .map(|dn| dn.object1_or_undef().coerce_to_object(activation))
+                .map(|dn| dn.object1_or_bare(activation.gc()))
                 .map(Value::Object)
                 .unwrap_or(Value::Undefined),
         );

core/src/avm1/object_reference.rs

@@ -167,9 +167,7 @@ impl<'gc> MovieClipReference<'gc> {
 
             Some((
                 false,
-                display_object
-                    .object1_or_undef()
-                    .coerce_to_object(activation),
+                display_object.object1_or_bare(activation.gc()),
                 display_object,
             ))
         } else {

core/src/avm1/runtime.rs

@@ -146,15 +146,14 @@ impl<'gc> Avm1<'gc> {
             return;
         }
 
-        let mut parent_activation = Activation::from_nothing(
+        // TODO(moulins): remove this activation, it's useless.
+        let parent_activation = Activation::from_nothing(
             context,
             ActivationIdentifier::root("[Actions Parent]"),
             active_clip,
         );
 
-        let clip_obj = active_clip
-            .object1_or_undef()
-            .coerce_to_object(&mut parent_activation);
+        let clip_obj = active_clip.object1_or_bare(parent_activation.gc());
         let child_scope = Gc::new(
             parent_activation.gc(),
             Scope::new(
@@ -231,15 +230,14 @@ impl<'gc> Avm1<'gc> {
             return;
         }
 
-        let mut parent_activation = Activation::from_nothing(
+        // TODO(moulins): remove this activation, it's useless
+        let parent_activation = Activation::from_nothing(
             context,
             ActivationIdentifier::root("[Init Parent]"),
             active_clip,
         );
 
-        let clip_obj = active_clip
-            .object1_or_undef()
-            .coerce_to_object(&mut parent_activation);
+        let clip_obj = active_clip.object1_or_bare(parent_activation.gc());
         let child_scope = Gc::new(
             parent_activation.gc(),
             Scope::new(

core/src/avm1/scope.rs

@@ -158,8 +158,9 @@ impl<'gc> Scope<'gc> {
                 && self.locals().has_own_property(activation, name)
             {
                 return activation
-                    .root_object()
-                    .coerce_to_object(activation)
+                    .base_clip()
+                    .avm1_root()
+                    .object1_or_bare(activation.gc())
                     .get_non_slash_path(name, activation)
                     .map(|v| CallableValue::Callable(self.locals_cell(), v));
             }

core/src/display_object.rs

@@ -2530,6 +2530,15 @@ pub trait TDisplayObject<'gc>:
             .unwrap_or(Avm1Value::Undefined)
     }
 
+    // [MOULINS]: I suspect that most (if not all) usages of this method are incorrect,
+    // but a dedicated method is still superior to the equivalent `self.object1_or_undef().coerce_to_object()`
+    // as it avoids the need for an activation.
+    #[no_dynamic]
+    fn object1_or_bare(self, mc: &Mutation<'gc>) -> Avm1Object<'gc> {
+        self.object1()
+            .unwrap_or_else(|| Avm1Object::new_without_proto(mc))
+    }
+
     fn object2(self) -> Option<Avm2StageObject<'gc>>;
 
     fn set_object2(self, _context: &mut UpdateContext<'gc>, _to: Avm2StageObject<'gc>) {}