core: Skip instantiation for timeline objects placed before clip instantiation

Often, `MovieClip`s have children that are placed before the `MovieClip`'s
AVM2 side is allocated and instantiated. These children will be instantiated
in the `super()` constructor (specifically, the `Sprite.constructChildren`
call), rather than in-line with normal frame construction. However, if the
`super()` constructor is /never/ called, these children will never be
instantiated. This commit adds a flag that is set on such early children.
Children with this flag set will never have `construct_frame` called on them
during normal frame construction.

Also add test coverage

Author: Lord-McSweeney

core/src/display_object.rs

@@ -794,6 +794,14 @@ impl<'gc> DisplayObjectBase<'gc> {
         self.set_flag(DisplayObjectFlags::PLACED_BY_AVM2_SCRIPT, value);
     }
 
+    fn manual_frame_construct(&self) -> bool {
+        self.contains_flag(DisplayObjectFlags::MANUAL_FRAME_CONSTRUCT)
+    }
+
+    fn set_manual_frame_construct(&self, value: bool) {
+        self.set_flag(DisplayObjectFlags::MANUAL_FRAME_CONSTRUCT, value);
+    }
+
     fn is_bitmap_cached_preference(&self) -> bool {
         self.contains_flag(DisplayObjectFlags::CACHE_AS_BITMAP)
     }
@@ -2192,6 +2200,18 @@ pub trait TDisplayObject<'gc>:
         self.base().set_placed_by_avm2_script(value)
     }
 
+    #[no_dynamic]
+    fn manual_frame_construct(&self) -> bool {
+        self.base().manual_frame_construct()
+    }
+
+    /// When this flag is set, the object will not be instantiated in-line with
+    /// normal frame construction by `MovieClip::construct_frame`.
+    #[no_dynamic]
+    fn set_manual_frame_construct(&self, value: bool) {
+        self.base().set_manual_frame_construct(value);
+    }
+
     /// Whether this display object has been instantiated by the timeline.
     /// When this flag is set, attempts to change the object's name from AVM2
     /// throw an exception.
@@ -2864,7 +2884,7 @@ impl<'gc> DisplayObject<'gc> {
 bitflags! {
     /// Bit flags used by `DisplayObject`.
     #[derive(Clone, Copy)]
-    struct DisplayObjectFlags: u16 {
+    struct DisplayObjectFlags: u32 {
         /// Whether this object has been removed from the display list.
         /// Necessary in AVM1 to throw away queued actions from removed movie clips.
         const AVM1_REMOVED             = 1 << 0;
@@ -2925,6 +2945,18 @@ bitflags! {
         /// i.e. attachMovie, createEmptyMovieClip, duplicateMovieClip.
         // TODO [KJ] Can this be merged with PLACED_BY_AVM2_SCRIPT?
         const PLACED_BY_AVM1_SCRIPT    = 1 << 15;
+
+        /// Whether this object was placed by the timeline on a `MovieClip`
+        /// before the `MovieClip` had its AVM2 object constructed. Such objects
+        /// are only instantiated by `Sprite.constructChildren`, which is
+        /// usually called when `super()` is called in a `Sprite` subclass.
+        /// However, if `super()` (and therefore `Sprite.constructChildren()`)
+        /// is never called, the object will never be instantiated. We mark all
+        /// objects placed by the timeline on a load frame with this flag to
+        /// ensure that `MovieClip::construct_frame` does not instantiate them
+        /// (they need to be instantiated "manually" by
+        /// `Sprite.constructChildren`).
+        const MANUAL_FRAME_CONSTRUCT  = 1 << 16;
     }
 }
 

core/src/display_object/movie_clip.rs

@@ -1409,6 +1409,12 @@ impl<'gc> MovieClip<'gc> {
                     child.set_parent(context, Some(self.into()));
                     child.set_place_frame(self.current_frame());
 
+                    // If this MC hasn't had an `object2` allocated yet, this
+                    // child will be constructed by `Sprite.constructChildren`,
+                    // not by the timeline
+                    let has_object2_allocated = self.object2().is_none();
+                    child.set_manual_frame_construct(has_object2_allocated);
+
                     // Apply PlaceObject parameters.
                     child.apply_place_object(context, place_object);
                     if let Some(name) = &place_object.name {
@@ -2485,12 +2491,28 @@ impl<'gc> TDisplayObject<'gc> for MovieClip<'gc> {
                 let running_construct_frame = self
                     .0
                     .contains_flag(MovieClipFlags::RUNNING_CONSTRUCT_FRAME);
-                // The supercall constructor for display objects is responsible
-                // for triggering construct_frame on frame 1.
                 for child in self.iter_render_list() {
-                    if running_construct_frame && child.object2().is_none() {
-                        continue;
+                    // Under some conditions, we won't run `construct_frame` on
+                    // a not-yet-constructed child
+                    if child.object2().is_none() {
+                        // Avoid running recursively- if `Sprite.constructChildren`
+                        // was constructing this clip's children, and somehow
+                        // a child's construction triggered another `construct_frame`
+                        // on this clip, Flash avoids running `construct_frame` on
+                        // the non-constructed children of this clip.
+                        if running_construct_frame {
+                            continue;
+                        }
+
+                        // The supercall constructor for display objects is responsible
+                        // for triggering construct_frame on frame 1 (see above comment).
+                        // However, if the child has already been constructed, we run
+                        // `construct_frame` like normal.
+                        if child.manual_frame_construct() {
+                            continue;
+                        }
                     }
+
                     child.construct_frame(context);
                 }
             }

tests/tests/swfs/avm2/movieclip_frameconstruct_skipped/output.txt

@@ -0,0 +1,9 @@
+Main allocated
+Frame constructed (theSprite=null, theShape=null)
+Frame exited
+Frame entered
+Frame constructed (theSprite=null, theShape=null)
+Frame exited
+Frame entered
+Frame constructed (theSprite=null, theShape=null)
+Frame exited

tests/tests/swfs/avm2/movieclip_frameconstruct_skipped/test.swf

@@ -0,0 +1 @@
+num_frames = 3