avm1: Refactor Executable::exec

- reduce rightwards drift by exiting early
- outline some code into separate methods on Avm1Function

core/src/avm1/function.rs

@@ -143,6 +143,81 @@ impl<'gc> Avm1Function<'gc> {
     pub fn register_count(&self) -> u8 {
         self.register_count
     }
+
+    fn debug_string_for_call(&self, name: ExecutionName<'gc>, args: &[Value<'gc>]) -> String {
+        let mut result = match self.name.map(ExecutionName::Dynamic).unwrap_or(name) {
+            ExecutionName::Static(n) => n.to_owned(),
+            ExecutionName::Dynamic(n) => n.to_utf8_lossy().into_owned(),
+        };
+        result.push('(');
+        for i in 0..args.len() {
+            result.push_str(args.get(i).unwrap().type_of());
+            if i < args.len() - 1 {
+                result.push_str(", ");
+            }
+        }
+        result.push(')');
+        result
+    }
+
+    fn load_this(&self, frame: &mut Activation<'_, 'gc, '_>, this: Value<'gc>, preload_r: &mut u8) {
+        if self.flags.contains(FunctionFlags::PRELOAD_THIS) {
+            //TODO: What happens if you specify both suppress and
+            //preload for this?
+            frame.set_local_register(*preload_r, this);
+            *preload_r += 1;
+        }
+    }
+
+    fn load_arguments(&self, frame: &mut Activation<'_, 'gc, '_>, arguments: Value<'gc>, preload_r: &mut u8) {
+        if self.flags.contains(FunctionFlags::PRELOAD_ARGUMENTS) {
+            //TODO: What happens if you specify both suppress and
+            //preload for arguments?
+            frame.set_local_register(*preload_r, arguments);
+            *preload_r += 1;
+        }
+    }
+
+    fn load_super(&self, frame: &mut Activation<'_, 'gc, '_>, super_object: Option<Object<'gc>>, preload_r: &mut u8) {
+        if let Some(super_object) = super_object {
+            if self.flags.contains(FunctionFlags::PRELOAD_SUPER) {
+                frame.set_local_register(*preload_r, super_object.into());
+                //TODO: What happens if you specify both suppress and
+                //preload for super?
+                *preload_r += 1;
+            } else {
+                frame.force_define_local("super".into(), super_object.into());
+            }
+        }
+    }
+
+    fn load_root(&self, frame: &mut Activation<'_, 'gc, '_>, preload_r: &mut u8) {
+        if self.flags.contains(FunctionFlags::PRELOAD_ROOT) {
+            let root = self.base_clip.avm1_root().object();
+            frame.set_local_register(*preload_r, root);
+            *preload_r += 1;
+        }
+    }
+
+    fn load_parent(&self, frame: &mut Activation<'_, 'gc, '_>, preload_r: &mut u8) {
+        if self.flags.contains(FunctionFlags::PRELOAD_PARENT) {
+            // If _parent is undefined (because this is a root timeline), it actually does not get pushed,
+            // and _global ends up incorrectly taking _parent's register.
+            // See test for more info.
+            if let Some(parent) = self.base_clip.avm1_parent() {
+                frame.set_local_register(*preload_r, parent.object());
+                *preload_r += 1;
+            }
+        }
+    }
+
+    fn load_global(&self, frame: &mut Activation<'_, 'gc, '_>, preload_r: &mut u8) {
+        if self.flags.contains(FunctionFlags::PRELOAD_GLOBAL) {
+            let global = frame.context.avm1.global_object();
+            frame.set_local_register(*preload_r, global);
+            *preload_r += 1;
+        }
+    }
 }
 
 #[derive(Debug, Clone, Collect)]
@@ -218,13 +293,15 @@ impl<'gc> Executable<'gc> {
         reason: ExecutionReason,
         callee: Object<'gc>,
     ) -> Result<Value<'gc>, Error<'gc>> {
-        match self {
+        let af = match self {
             Executable::Native(nf) => {
                 // TODO: Change NativeFunction to accept `this: Value`.
                 let this = this.coerce_to_object(activation);
-                nf(activation, this, args)
+                return nf(activation, this, args);
             }
-            Executable::Action(af) => {
+            Executable::Action(af) => af,
+        };
+
         let this_obj = match this {
             Value::Object(obj) => Some(obj),
             _ => None,
@@ -312,21 +389,7 @@ impl<'gc> Executable<'gc> {
         });
 
         let name = if cfg!(feature = "avm_debug") {
-                    let mut result = match af.name.map(ExecutionName::Dynamic).unwrap_or(name) {
+            Cow::Owned(af.debug_string_for_call(name, args))
-                        ExecutionName::Static(n) => n.to_owned(),
-                        ExecutionName::Dynamic(n) => n.to_utf8_lossy().into_owned(),
-                    };
-
-                    result.push('(');
-                    for i in 0..args.len() {
-                        result.push_str(args.get(i).unwrap().type_of());
-                        if i < args.len() - 1 {
-                            result.push_str(", ");
-                        }
-                    }
-                    result.push(')');
-
-                    Cow::Owned(result)
         } else {
             Cow::Borrowed("[Anonymous]")
         };
@@ -347,51 +410,12 @@ impl<'gc> Executable<'gc> {
         frame.allocate_local_registers(af.register_count(), frame.context.gc_context);
 
         let mut preload_r = 1;
-
+        af.load_this(&mut frame, this, &mut preload_r);
-                if af.flags.contains(FunctionFlags::PRELOAD_THIS) {
+        af.load_arguments(&mut frame, arguments.into(), &mut preload_r);
-                    //TODO: What happens if you specify both suppress and
+        af.load_super(&mut frame, super_object, &mut preload_r);
-                    //preload for this?
+        af.load_root(&mut frame, &mut preload_r);
-                    frame.set_local_register(preload_r, this);
+        af.load_parent(&mut frame, &mut preload_r);
-                    preload_r += 1;
+        af.load_global(&mut frame, &mut preload_r);
-                }
-
-                if af.flags.contains(FunctionFlags::PRELOAD_ARGUMENTS) {
-                    //TODO: What happens if you specify both suppress and
-                    //preload for arguments?
-                    frame.set_local_register(preload_r, arguments.into());
-                    preload_r += 1;
-                }
-
-                if let Some(super_object) = super_object {
-                    if af.flags.contains(FunctionFlags::PRELOAD_SUPER) {
-                        frame.set_local_register(preload_r, super_object.into());
-                        //TODO: What happens if you specify both suppress and
-                        //preload for super?
-                        preload_r += 1;
-                    } else {
-                        frame.force_define_local("super".into(), super_object.into());
-                    }
-                }
-
-                if af.flags.contains(FunctionFlags::PRELOAD_ROOT) {
-                    frame.set_local_register(preload_r, af.base_clip.avm1_root().object());
-                    preload_r += 1;
-                }
-
-                if af.flags.contains(FunctionFlags::PRELOAD_PARENT) {
-                    // If _parent is undefined (because this is a root timeline), it actually does not get pushed,
-                    // and _global ends up incorrectly taking _parent's register.
-                    // See test for more info.
-                    if let Some(parent) = af.base_clip.avm1_parent() {
-                        frame.set_local_register(preload_r, parent.object());
-                        preload_r += 1;
-                    }
-                }
-
-                if af.flags.contains(FunctionFlags::PRELOAD_GLOBAL) {
-                    let global = frame.context.avm1.global_object();
-                    frame.set_local_register(preload_r, global);
-                }
 
         // Any unassigned args are set to undefined to prevent assignments from leaking to the parent scope (#2166)
         let args_iter = args
@@ -411,8 +435,6 @@ impl<'gc> Executable<'gc> {
 
         Ok(frame.run_actions(af.data.clone())?.value())
     }
-        }
-    }
 }
 
 impl<'gc> From<NativeFunction> for Executable<'gc> {