avm2: Do not reference trivially copyable objects

Author: kjarosh

core/src/avm2/domain.rs

@@ -121,7 +121,7 @@ impl<'gc> Domain<'gc> {
     }
 
     #[cfg(feature = "egui")]
-    pub fn children(&self, mc: &Mutation<'gc>) -> Vec<Domain<'gc>> {
+    pub fn children(self, mc: &Mutation<'gc>) -> Vec<Domain<'gc>> {
         // Take this opportunity to clean up dead children.
         let mut output = Vec::new();
         self.cell_mut(mc).children.retain(|child| {
@@ -327,7 +327,7 @@ impl<'gc> Domain<'gc> {
         res
     }
 
-    pub fn get_defined_names(&self) -> Vec<QName<'gc>> {
+    pub fn get_defined_names(self) -> Vec<QName<'gc>> {
         self.cell()
             .defs
             .iter()
@@ -349,7 +349,7 @@ impl<'gc> Domain<'gc> {
     /// Export a class into the current application domain.
     ///
     /// This does nothing if the definition already exists in this domain or a parent.
-    pub fn export_class(&self, export_name: QName<'gc>, class: Class<'gc>, mc: &Mutation<'gc>) {
+    pub fn export_class(self, export_name: QName<'gc>, class: Class<'gc>, mc: &Mutation<'gc>) {
         if self.has_class(export_name) {
             return;
         }
@@ -371,7 +371,7 @@ impl<'gc> Domain<'gc> {
         std::ptr::eq(domain_memory_ptr, default_domain_memory_ptr)
     }
 
-    pub fn domain_memory(&self) -> ByteArrayObject<'gc> {
+    pub fn domain_memory(self) -> ByteArrayObject<'gc> {
         self.0
             .domain_memory
             .get()

core/src/avm2/globals/avmplus.rs

@@ -295,7 +295,7 @@ fn describe_internal_body<'gc>(
                     activation.gc(),
                 );
 
-                let params = write_params(&method.method, activation);
+                let params = write_params(method.method, activation);
                 method_obj.set_dynamic_property(
                     istr!("parameters"),
                     params.into(),
@@ -416,7 +416,7 @@ fn describe_internal_body<'gc>(
     if let Some(constructor) = constructor.filter(|c| {
         !c.signature().is_empty() && flags.contains(DescribeTypeFlags::INCLUDE_CONSTRUCTOR)
     }) {
-        let params = write_params(&constructor, activation);
+        let params = write_params(constructor, activation);
         traits.set_dynamic_property(istr!("constructor"), params.into(), activation.gc());
     } else {
         // This is needed to override the normal 'constructor' property
@@ -452,7 +452,7 @@ fn display_name<'gc>(
 }
 
 fn write_params<'gc>(
-    method: &Method<'gc>,
+    method: Method<'gc>,
     activation: &mut Activation<'_, 'gc>,
 ) -> ArrayObject<'gc> {
     let params = ArrayObject::empty(activation);

core/src/avm2/globals/string.rs

@@ -305,7 +305,7 @@ pub fn replace<'gc>(
     {
         // Replacement is either a function or treatable as string.
         if let Some(f) = replacement.as_object().and_then(|o| o.as_function_object()) {
-            return Ok(RegExp::replace_fn(regexp, activation, this, &f)?.into());
+            return Ok(RegExp::replace_fn(regexp, activation, this, f)?.into());
         } else {
             let replacement = replacement.coerce_to_string(activation)?;
             return Ok(RegExp::replace_string(regexp, activation, this, replacement)?.into());

core/src/avm2/method.rs

@@ -233,16 +233,16 @@ impl<'gc> Method<'gc> {
     }
 
     /// Get the underlying ABC file.
-    pub fn abc(&self) -> Rc<AbcFile> {
+    pub fn abc(self) -> Rc<AbcFile> {
         self.0.txunit.abc()
     }
 
     /// Get the underlying translation unit this method was defined in.
-    pub fn translation_unit(&self) -> TranslationUnit<'gc> {
+    pub fn translation_unit(self) -> TranslationUnit<'gc> {
         self.0.txunit
     }
 
-    pub fn abc_method_index(&self) -> u32 {
+    pub fn abc_method_index(self) -> u32 {
         self.0.abc_method
     }
 
@@ -252,7 +252,7 @@ impl<'gc> Method<'gc> {
     }
 
     /// Get a reference to the SwfMovie this method came from.
-    pub fn owner_movie(&self) -> Arc<SwfMovie> {
+    pub fn owner_movie(self) -> Arc<SwfMovie> {
         self.0.txunit.movie()
     }
 
@@ -296,7 +296,7 @@ impl<'gc> Method<'gc> {
         &self.0.resolved_info.get().unwrap().param_config
     }
 
-    pub fn resolved_return_type(&self) -> Option<Class<'gc>> {
+    pub fn resolved_return_type(self) -> Option<Class<'gc>> {
         self.0.resolved_info.get().unwrap().return_type
     }
 
@@ -351,22 +351,22 @@ impl<'gc> Method<'gc> {
     /// Determine if a given method is variadic.
     ///
     /// Variadic methods shove excess parameters into a final register.
-    pub fn is_variadic(&self) -> bool {
+    pub fn is_variadic(self) -> bool {
         self.method()
             .flags
             .intersects(AbcMethodFlags::NEED_ARGUMENTS | AbcMethodFlags::NEED_REST)
     }
 
     /// Check if this method needs `arguments`.
-    pub fn needs_arguments_object(&self) -> bool {
+    pub fn needs_arguments_object(self) -> bool {
         self.method().flags.contains(AbcMethodFlags::NEED_ARGUMENTS)
     }
 
     pub fn method_kind(&self) -> &MethodKind<'gc> {
         &self.0.method_kind
     }
 
-    pub fn return_type(&self) -> Option<Gc<'gc, Multiname<'gc>>> {
+    pub fn return_type(self) -> Option<Gc<'gc, Multiname<'gc>>> {
         self.0.return_type
     }
 
@@ -392,7 +392,7 @@ impl<'gc> Method<'gc> {
     ///
     ///  * The method was declared as a free-standing function
     ///  * The function's parameters have no declared types or default values
-    pub fn is_unchecked(&self) -> bool {
+    pub fn is_unchecked(self) -> bool {
         self.0.is_unchecked
     }
 }

core/src/avm2/namespace.rs

@@ -245,27 +245,27 @@ impl<'gc> Namespace<'gc> {
         )))
     }
 
-    pub fn is_public(&self) -> bool {
+    pub fn is_public(self) -> bool {
         matches!(self.0.as_deref(), Some(NamespaceData::Namespace(name, _)) if name.as_wstr().is_empty())
     }
 
-    pub fn is_public_ignoring_ns(&self) -> bool {
+    pub fn is_public_ignoring_ns(self) -> bool {
         matches!(self.0.as_deref(), Some(NamespaceData::Namespace(_, _)))
     }
 
-    pub fn is_any(&self) -> bool {
+    pub fn is_any(self) -> bool {
         self.0.is_none()
     }
 
-    pub fn is_private(&self) -> bool {
+    pub fn is_private(self) -> bool {
         matches!(self.0.as_deref(), Some(NamespaceData::Private(_)))
     }
 
-    pub fn is_namespace(&self) -> bool {
+    pub fn is_namespace(self) -> bool {
         matches!(self.0.as_deref(), Some(NamespaceData::Namespace(_, _)))
     }
 
-    pub fn as_uri_opt(&self) -> Option<AvmString<'gc>> {
+    pub fn as_uri_opt(self) -> Option<AvmString<'gc>> {
         self.0.map(|data| match *data {
             NamespaceData::Namespace(a, _) => a.into(),
             NamespaceData::PackageInternal(a) => a.into(),
@@ -279,7 +279,7 @@ impl<'gc> Namespace<'gc> {
     /// Get the string value of this namespace, ignoring its type.
     ///
     /// TODO: Is this *actually* the namespace URI?
-    pub fn as_uri(&self, context: &mut StringContext<'gc>) -> AvmString<'gc> {
+    pub fn as_uri(self, context: &mut StringContext<'gc>) -> AvmString<'gc> {
         self.as_uri_opt().unwrap_or_else(|| context.empty())
     }
 
@@ -289,7 +289,7 @@ impl<'gc> Namespace<'gc> {
     ///
     /// Namespace does not implement `PartialEq`, so that each caller is required
     /// to explicitly choose either `exact_version_match` or `matches_ns`.
-    pub fn exact_version_match(&self, other: Self) -> bool {
+    pub fn exact_version_match(self, other: Self) -> bool {
         if self.0.map(Gc::as_ptr) == other.0.map(Gc::as_ptr) {
             true
         } else if self.is_private() || other.is_private() {
@@ -304,7 +304,7 @@ impl<'gc> Namespace<'gc> {
     /// seen by the other). This is used to implement `PropertyMap`, where we want to
     /// a definition with `ApiVersion::SWF_16` to be visible when queried from
     /// a SWF with `ApiVersion::SWF_16` or any higher version.
-    pub fn matches_ns(&self, other: Self) -> bool {
+    pub fn matches_ns(self, other: Self) -> bool {
         if self.exact_version_match(other) {
             return true;
         }
@@ -321,7 +321,7 @@ impl<'gc> Namespace<'gc> {
             _ => false,
         }
     }
-    pub fn matches_api_version(&self, match_version: ApiVersion) -> bool {
+    pub fn matches_api_version(self, match_version: ApiVersion) -> bool {
         match self.0.as_deref() {
             Some(NamespaceData::Namespace(_, version)) => version <= &match_version,
             _ => true,

core/src/avm2/regexp.rs

@@ -228,7 +228,7 @@ impl<'gc> RegExp<'gc> {
         regexp: RegExpObject<'gc>,
         activation: &mut Activation<'_, 'gc>,
         text: AvmString<'gc>,
-        f: &FunctionObject<'gc>,
+        f: FunctionObject<'gc>,
     ) -> Result<AvmString<'gc>, Error<'gc>> {
         Self::replace_with_fn(regexp, activation, &text, |activation, txt, m| {
             let args = std::iter::once(Some(&m.range))

core/src/avm2/script.rs

@@ -233,7 +233,7 @@ impl<'gc> TranslationUnit<'gc> {
     }
 
     /// Gets a script in the ABC file by index.
-    pub fn get_script(&self, index: usize) -> Option<Script<'gc>> {
+    pub fn get_script(self, index: usize) -> Option<Script<'gc>> {
         self.0.scripts.get(index).and_then(|s| s.get()).copied()
     }
 

core/src/avm2/specification.rs

@@ -154,7 +154,7 @@ struct FunctionInfo {
 }
 
 impl FunctionInfo {
-    pub fn from_method(method: &Method, stubbed: bool) -> Self {
+    pub fn from_method(method: Method, stubbed: bool) -> Self {
         Self {
             returns: method
                 .return_type()
@@ -388,7 +388,7 @@ impl Definition {
                     output
                         .get_or_insert_default()
                         .function
-                        .insert(trait_name, FunctionInfo::from_method(method, stubbed));
+                        .insert(trait_name, FunctionInfo::from_method(*method, stubbed));
                 }
                 TraitKind::Getter { method, .. } => {
                     let stubbed = stubs.has_getter(&trait_name);

core/src/avm2/stack.rs

@@ -72,7 +72,7 @@ impl<'gc> Stack<'gc> {
         StackFrame::for_data(subslice)
     }
 
-    pub fn dispose_stack_frame(&self, stack_frame: StackFrame<'_, 'gc>) {
+    pub fn dispose_stack_frame(self, stack_frame: StackFrame<'_, 'gc>) {
         self.0
             .stack_pointer
             .set(self.0.stack_pointer.get() - stack_frame.data.len());