avm2: Rename make_mismatch_error to make_error_1063

Also make it consistent with the rest of the error creation functions

Author: Lord-McSweeney

core/src/avm2/activation.rs

@@ -5,8 +5,8 @@ use crate::avm2::class::Class;
 use crate::avm2::domain::Domain;
 use crate::avm2::e4x::{escape_attribute_value, escape_element_value};
 use crate::avm2::error::{
-    make_error_1040, make_error_1041, make_error_1065, make_error_1127, make_error_1506,
-    make_null_or_undefined_error, type_error, verify_error,
+    make_error_1040, make_error_1041, make_error_1063, make_error_1065, make_error_1127,
+    make_error_1506, make_null_or_undefined_error, type_error, verify_error,
 };
 use crate::avm2::function::FunctionArgs;
 use crate::avm2::method::{Method, NativeMethodImpl, ResolvedParamConfig};
@@ -32,8 +32,6 @@ use std::cmp::{min, Ordering};
 use std::sync::Arc;
 use swf::avm2::types::MethodFlags as AbcMethodFlags;
 
-use super::error::make_mismatch_error;
-
 /// Represents a single activation of a given AVM2 function or keyframe.
 pub struct Activation<'a, 'gc: 'a> {
     /// The number of locals this method uses.
@@ -214,11 +212,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                     let arg = if let Some(default_value) = &param_config.default_value {
                         *default_value
                     } else {
-                        return Err(Error::avm_error(make_mismatch_error(
-                            self,
-                            method,
-                            user_arguments.len(),
-                        )?));
+                        return Err(make_error_1063(self, method, user_arguments.len()));
                     };
 
                     let coerced_arg = if let Some(param_class) = param_config.param_type {
@@ -344,11 +338,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let signature = method.resolved_param_config();
 
         if user_arguments.len() > signature.len() && !has_rest_or_args && !method.is_unchecked() {
-            return Err(Error::avm_error(make_mismatch_error(
-                self,
-                method,
-                user_arguments.len(),
-            )?));
+            return Err(make_error_1063(self, method, user_arguments.len()));
         }
 
         // Create locals
@@ -377,11 +367,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 } else if method.is_unchecked() {
                     Value::Undefined
                 } else {
-                    return Err(Error::avm_error(make_mismatch_error(
-                        self,
-                        method,
-                        user_arguments.len(),
-                    )?));
+                    return Err(make_error_1063(self, method, user_arguments.len()));
                 };
 
                 let coerced_arg = if let Some(param_class) = param_config.param_type {

core/src/avm2/error.rs

@@ -554,6 +554,36 @@ pub fn make_error_1058<'gc>(activation: &mut Activation<'_, 'gc>) -> Error<'gc>
     }
 }
 
+#[inline(never)]
+#[cold]
+pub fn make_error_1063<'gc>(
+    activation: &mut Activation<'_, 'gc>,
+    method: Method<'gc>,
+    passed_arg_count: usize,
+) -> Error<'gc> {
+    let expected_num_params = method
+        .signature()
+        .iter()
+        .filter(|param| param.default_value.is_none())
+        .count();
+
+    let mut function_name = WString::new();
+
+    display_function(&mut function_name, method);
+
+    let err = argument_error(
+        activation,
+        &format!(
+            "Error #1063: Argument count mismatch on {function_name}. Expected {expected_num_params}, got {passed_arg_count}.",
+        ),
+        1063,
+    );
+    match err {
+        Ok(err) => Error::avm_error(err),
+        Err(err) => err,
+    }
+}
+
 #[inline(never)]
 #[cold]
 pub fn make_error_1065<'gc>(
@@ -1260,32 +1290,6 @@ pub fn error<'gc>(
     error_constructor(activation, class, message, code)
 }
 
-#[inline(never)]
-#[cold]
-pub fn make_mismatch_error<'gc>(
-    activation: &mut Activation<'_, 'gc>,
-    method: Method<'gc>,
-    passed_arg_count: usize,
-) -> Result<Value<'gc>, Error<'gc>> {
-    let expected_num_params = method
-        .signature()
-        .iter()
-        .filter(|param| param.default_value.is_none())
-        .count();
-
-    let mut function_name = WString::new();
-
-    display_function(&mut function_name, method);
-
-    return Err(Error::avm_error(argument_error(
-        activation,
-        &format!(
-            "Error #1063: Argument count mismatch on {function_name}. Expected {expected_num_params}, got {passed_arg_count}.",
-        ),
-        1063,
-    )?));
-}
-
 fn error_constructor<'gc>(
     activation: &mut Activation<'_, 'gc>,
     class: ClassObject<'gc>,

core/src/avm2/function.rs

@@ -1,5 +1,5 @@
 use crate::avm2::activation::Activation;
-use crate::avm2::error::{make_mismatch_error, Error};
+use crate::avm2::error::{make_error_1063, Error};
 use crate::avm2::method::{Method, MethodKind, ParamConfig};
 use crate::avm2::object::{ClassObject, FunctionObject};
 use crate::avm2::scope::ScopeChain;
@@ -217,11 +217,7 @@ pub fn exec<'gc>(
             // Check for too many arguments
             if arguments.len() > signature.len() && !method.is_variadic() && !method.is_unchecked()
             {
-                return Err(Error::avm_error(make_mismatch_error(
-                    &mut activation,
-                    method,
-                    arguments.len(),
-                )?));
+                return Err(make_error_1063(&mut activation, method, arguments.len()));
             }
 
             let arguments = activation.resolve_parameters(method, arguments, signature)?;