avm1: Further simplify function object creation

This splits creating the raw `FunctionObject`, and
builf the actual AVM1 `Object` that contains it.

Author: moulins

core/src/avm1/activation.rs

@@ -886,11 +886,10 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             &self.context.strings,
             Some(self.context.avm1.prototypes().object),
         );
-        let func_obj = FunctionObject::function(
+        let func_obj = FunctionObject::bytecode(Gc::new(self.gc(), func)).build(
             &self.context.strings,
-            Gc::new(self.gc(), func),
             self.context.avm1.prototypes().function,
-            prototype,
+            Some(prototype),
         );
         if let Some(name) = name {
             self.define_local(name, func_obj.into())?;

core/src/avm1/function.rs

@@ -446,26 +446,19 @@ pub struct FunctionObject<'gc> {
 }
 
 impl<'gc> FunctionObject<'gc> {
-    /// Construct a function with any combination of regular and constructor parts.
+    /// Builds a new function object.
     ///
     /// `fn_proto` refers to the implicit proto of the function object, and the
-    /// `prototype` refers to the explicit prototype of the function.
-    /// The function and its prototype will be linked to each other.
-    fn allocate_function(
+    /// `prototype` refers to the explicit prototype of the function. If the
+    /// prototype is present, it will be linked with the newly-created object.
+    pub fn build(
+        self,
         context: &StringContext<'gc>,
-        function: Executable<'gc>,
-        constructor: Option<NativeFunction>,
         fn_proto: Object<'gc>,
         prototype: Option<Object<'gc>>,
     ) -> Object<'gc> {
         let obj = Object::new(context, Some(fn_proto));
-        let native = NativeObject::Function(Gc::new(
-            context.gc(),
-            Self {
-                function,
-                constructor,
-            },
-        ));
+        let native = NativeObject::Function(Gc::new(context.gc(), self));
         obj.set_native(context.gc(), native);
 
         if let Some(prototype) = prototype {
@@ -486,62 +479,45 @@ impl<'gc> FunctionObject<'gc> {
         obj
     }
 
-    /// Constructs a function that does nothing.
+    /// A function that does nothing.
     ///
     /// This can also serve as a no-op constructor.
-    pub fn empty(
-        context: &StringContext<'gc>,
-        fn_proto: Object<'gc>,
-        prototype: Object<'gc>,
-    ) -> Object<'gc> {
-        let empty = Executable::Native(|_, _, _| Ok(Value::Undefined));
-        Self::allocate_function(context, empty, None, fn_proto, Some(prototype))
+    pub fn empty() -> Self {
+        Self {
+            function: Executable::Native(|_, _, _| Ok(Value::Undefined)),
+            constructor: None,
+        }
     }
 
-    /// Construct a function from AVM1 bytecode and associated protos.
-    pub fn function(
-        context: &StringContext<'gc>,
-        function: Gc<'gc, Avm1Function<'gc>>,
-        fn_proto: Object<'gc>,
-        prototype: Object<'gc>,
-    ) -> Object<'gc> {
-        let function = Executable::Action(function);
-        Self::allocate_function(context, function, None, fn_proto, Some(prototype))
+    /// A function with AVM1 bytecode.
+    pub fn bytecode(function: Gc<'gc, Avm1Function<'gc>>) -> Self {
+        Self {
+            function: Executable::Action(function),
+            constructor: None,
+        }
     }
 
-    /// Construct a function from a native executable and associated protos.
-    pub fn native(
-        context: &StringContext<'gc>,
-        function: NativeFunction,
-        fn_proto: Object<'gc>,
-        prototype: Option<Object<'gc>>,
-    ) -> Object<'gc> {
-        let function = Executable::Native(function);
-        Self::allocate_function(context, function, None, fn_proto, prototype)
+    /// A function with a native executable.
+    pub fn native(function: NativeFunction) -> Self {
+        Self {
+            function: Executable::Native(function),
+            constructor: None,
+        }
     }
 
-    /// Construct a native constructor from native executables and associated protos.
+    /// A native constructor.
     ///
     /// This differs from [`Self::native`] in two important ways:
     /// - When called through `new`, the return value will always become the result of the
     ///   operation. Native constructors should therefore generally return either `this`,
     ///   if the object was successfully constructed, or `undefined` if not.
     /// - When called as a normal function, `function` will be called instead of `constructor`;
     ///   if it is `None`, the return value will be `undefined`.
-    pub fn constructor(
-        context: &StringContext<'gc>,
-        constructor: NativeFunction,
-        function: Option<NativeFunction>,
-        fn_proto: Object<'gc>,
-        prototype: Object<'gc>,
-    ) -> Object<'gc> {
-        Self::allocate_function(
-            context,
-            Executable::Native(function.unwrap_or(|_, _, _| Ok(Value::Undefined))),
-            Some(constructor),
-            fn_proto,
-            Some(prototype),
-        )
+    pub fn constructor(constructor: NativeFunction, function: Option<NativeFunction>) -> Self {
+        Self {
+            function: Executable::Native(function.unwrap_or(|_, _, _| Ok(Value::Undefined))),
+            constructor: Some(constructor),
+        }
     }
 
     /// Execute the given code.

core/src/avm1/property_decl.rs

@@ -33,15 +33,16 @@ impl<'gc> DeclContext<'_, 'gc> {
 
     pub fn empty_class(&self, super_proto: Object<'gc>) -> SystemClass<'gc> {
         let proto = Object::new(self.strings, Some(super_proto));
-        let constr = FunctionObject::empty(self.strings, self.fn_proto, proto);
+        let constr = FunctionObject::empty().build(self.strings, self.fn_proto, Some(proto));
         SystemClass { proto, constr }
     }
 
     /// Creates a class with a 'normal' constructor. This should be used for classes whose constructor
     /// is implemented in bytecode in Flash Player's `playerglobals.swf`.
     pub fn class(&self, function: NativeFunction, super_proto: Object<'gc>) -> SystemClass<'gc> {
         let proto = Object::new(self.strings, Some(super_proto));
-        let constr = FunctionObject::native(self.strings, function, self.fn_proto, Some(proto));
+        let constr =
+            FunctionObject::native(function).build(self.strings, self.fn_proto, Some(proto));
         SystemClass { proto, constr }
     }
 
@@ -63,8 +64,11 @@ impl<'gc> DeclContext<'_, 'gc> {
         function: Option<NativeFunction>,
         proto: Object<'gc>,
     ) -> SystemClass<'gc> {
-        let constr =
-            FunctionObject::constructor(self.strings, constructor, function, self.fn_proto, proto);
+        let constr = FunctionObject::constructor(constructor, function).build(
+            self.strings,
+            self.fn_proto,
+            Some(proto),
+        );
         SystemClass { proto, constr }
     }
 }
@@ -127,16 +131,16 @@ impl Declaration {
         let name = context.intern_static(WStr::from_units(self.name));
         let value = match self.kind {
             DeclKind::Property { getter, setter } => {
-                let getter = FunctionObject::native(context, getter, fn_proto, Some(fn_proto));
-                let setter = setter.map(|setter| {
-                    FunctionObject::native(context, setter, fn_proto, Some(fn_proto))
-                });
+                // Property objects are unobservable by user code, so a bare function is enough.
+                let getter = FunctionObject::native(getter).build(context, fn_proto, None);
+                let setter = setter
+                    .map(|setter| FunctionObject::native(setter).build(context, fn_proto, None));
                 this.add_property(mc, name.into(), getter, setter, self.attributes);
                 return Value::Undefined;
             }
-            DeclKind::Method(func) => FunctionObject::native(context, func, fn_proto, None).into(),
-            DeclKind::Function(func) => {
-                FunctionObject::native(context, func, fn_proto, Some(fn_proto)).into()
+            DeclKind::Method(f) | DeclKind::Function(f) => {
+                let p = matches!(self.kind, DeclKind::Function(_)).then_some(fn_proto);
+                FunctionObject::native(f).build(context, fn_proto, p).into()
             }
             DeclKind::String(s) => context.intern_static(WStr::from_units(s)).into(),
             DeclKind::Bool(b) => b.into(),

core/src/avm1/value.rs

@@ -891,7 +891,6 @@ fn string_to_f64(mut s: &WStr, swf_version: u8) -> f64 {
 #[cfg(test)]
 #[expect(clippy::unreadable_literal)] // Large numeric literals in tests
 mod test {
-    use crate::avm1::activation::Activation;
     use crate::avm1::error::Error;
     use crate::avm1::function::FunctionObject;
     use crate::avm1::globals::create_globals;
@@ -923,17 +922,8 @@ mod test {
 
             assert_eq!(vglobal.to_primitive_num(activation).unwrap(), undefined);
 
-            fn value_of_impl<'gc>(
-                _activation: &mut Activation<'_, 'gc>,
-                _: Object<'gc>,
-                _: &[Value<'gc>],
-            ) -> Result<Value<'gc>, Error<'gc>> {
-                Ok(5.into())
-            }
-
-            let valueof = FunctionObject::native(
+            let valueof = FunctionObject::native(|_, _, _| Ok(5.into())).build(
                 &activation.context.strings,
-                value_of_impl,
                 protos.function,
                 Some(protos.function),
             );