chore: Appease clippy

Resolve 2 instances of `only_used_in_recursion`.

Author: relrelb

core/src/avm2/globals/flash/external/externalinterface.rs

@@ -43,7 +43,7 @@ pub fn call<'gc>(
     {
         let mut external_args = Vec::with_capacity(args.len() - 1);
         for arg in &args[1..] {
-            external_args.push(ExternalValue::from_avm2(activation, arg.to_owned())?);
+            external_args.push(ExternalValue::from_avm2(arg.to_owned())?);
         }
         Ok(method
             .call(&mut activation.context, &external_args)

core/src/avm2/object.rs

@@ -818,7 +818,7 @@ pub trait TObject<'gc>: 'gc + Collect + Debug + Into<Object<'gc>> + Clone + Copy
         if my_class.is_none() && Object::ptr_eq(test_class, activation.avm2().classes().object) {
             Ok(true)
         } else if let Some(my_class) = my_class {
-            my_class.has_class_in_chain(test_class, activation)
+            my_class.has_class_in_chain(test_class)
         } else {
             Ok(false)
         }

core/src/avm2/object/class_object.rs

@@ -426,11 +426,7 @@ impl<'gc> ClassObject<'gc> {
     /// interface we are checking against this class.
     ///
     /// To test if a class *instance* is of a given type, see is_of_type.
-    pub fn has_class_in_chain(
-        self,
-        test_class: ClassObject<'gc>,
-        activation: &mut Activation<'_, 'gc, '_>,
-    ) -> Result<bool, Error> {
+    pub fn has_class_in_chain(self, test_class: ClassObject<'gc>) -> Result<bool, Error> {
         let mut my_class = Some(self);
 
         while let Some(class) = my_class {
@@ -451,7 +447,7 @@ impl<'gc> ClassObject<'gc> {
 
                 are_all_params_coercible &= match (my_param, test_param) {
                     (Some(my_param), Some(test_param)) => {
-                        my_param.has_class_in_chain(test_param, activation)?
+                        my_param.has_class_in_chain(test_param)?
                     }
                     (None, Some(_)) => false,
                     _ => true,

core/src/external.rs

@@ -183,10 +183,7 @@ impl Value {
         }
     }
 
-    pub fn from_avm2<'gc>(
-        activation: &mut Avm2Activation<'_, 'gc, '_>,
-        value: Avm2Value<'gc>,
-    ) -> Result<Value, Avm2Error> {
+    pub fn from_avm2(value: Avm2Value) -> Result<Value, Avm2Error> {
         Ok(match value {
             Avm2Value::Undefined | Avm2Value::Null => Value::Null,
             Avm2Value::Bool(value) => value.into(),
@@ -201,7 +198,7 @@ impl Value {
                         .map(|i| {
                             // FIXME - is this right?
                             let element = array.get(i).unwrap_or(Avm2Value::Null);
-                            Value::from_avm2(activation, element)
+                            Value::from_avm2(element)
                         })
                         .collect();
                     Value::List(values?)
@@ -289,7 +286,7 @@ impl<'gc> Callback<'gc> {
                     .collect();
                 if let Ok(result) = method
                     .call(None, &args, &mut activation)
-                    .and_then(|value| Value::from_avm2(&mut activation, value))
+                    .and_then(Value::from_avm2)
                 {
                     result
                 } else {