pool_string should return a Ref<str> just like value::abc_string.

Author: kmeisthax

core/src/avm2/activation.rs

@@ -13,6 +13,7 @@ use crate::avm2::{value, Avm2, Error};
 use crate::context::UpdateContext;
 use gc_arena::{Collect, Gc, GcCell, MutationContext};
 use smallvec::SmallVec;
+use std::cell::Ref;
 use std::io::Cursor;
 use swf::avm2::read::Reader;
 use swf::avm2::types::{
@@ -322,12 +323,27 @@ impl<'a, 'gc: 'a> Activation<'a, 'gc> {
     }
 
     /// Retrieve a string from the current constant pool.
-    fn pool_string(
+    fn pool_string<'b>(
         &self,
-        method: Gc<'gc, BytecodeMethod<'gc>>,
+        method: &'b BytecodeMethod<'gc>,
         index: Index<String>,
-    ) -> Result<String, Error> {
-        Ok(value::abc_string(&method.abc(), index)?.to_string())
+    ) -> Result<Ref<'b, str>, Error> {
+        let mut maybe_error = None;
+        let maybe_ref = Ref::map(method.abc_ref(), |abc| {
+            match value::abc_string(abc, index) {
+                Ok(s) => s,
+                Err(e) => {
+                    maybe_error = Some(e);
+                    ""
+                }
+            }
+        });
+
+        if let Some(err) = maybe_error {
+            Err(err)
+        } else {
+            Ok(maybe_ref)
+        }
     }
 
     /// Retrieve a namespace from the current constant pool.
@@ -585,7 +601,8 @@ impl<'a, 'gc: 'a> Activation<'a, 'gc> {
         method: Gc<'gc, BytecodeMethod<'gc>>,
         value: Index<String>,
     ) -> Result<FrameControl<'gc>, Error> {
-        self.avm2.push(self.pool_string(method, value)?);
+        self.avm2
+            .push(self.pool_string(&method, value)?.to_string());
         Ok(FrameControl::Continue)
     }
 

core/src/avm2/method.rs

@@ -7,6 +7,7 @@ use crate::avm2::value::Value;
 use crate::avm2::Error;
 use crate::context::UpdateContext;
 use gc_arena::{Collect, CollectionContext, Gc, MutationContext};
+use std::cell::Ref;
 use std::fmt;
 use std::rc::Rc;
 use swf::avm2::types::{AbcFile, Index, Method as AbcMethod, MethodBody as AbcMethodBody};
@@ -98,6 +99,11 @@ impl<'gc> BytecodeMethod<'gc> {
         self.txunit.abc()
     }
 
+    /// Retrieve a reference to the underlying ABC file.
+    pub fn abc_ref(&self) -> Ref<AbcFile> {
+        self.txunit.abc_ref()
+    }
+
     /// Get the underlying translation unit this method was defined in.
     pub fn translation_unit(&self) -> TranslationUnit<'gc> {
         self.txunit

core/src/avm2/script.rs

@@ -5,6 +5,7 @@ use crate::avm2::method::{BytecodeMethod, Method};
 use crate::avm2::r#trait::Trait;
 use crate::avm2::Error;
 use gc_arena::{Collect, Gc, GcCell, MutationContext};
+use std::cell::Ref;
 use std::collections::HashMap;
 use std::mem::drop;
 use std::rc::Rc;
@@ -64,6 +65,12 @@ impl<'gc> TranslationUnit<'gc> {
         self.0.read().abc.0.clone()
     }
 
+    /// Retrieve a reference to the underlying `AbcFile` for this translation
+    /// unit.
+    pub fn abc_ref(&self) -> Ref<AbcFile> {
+        Ref::map(self.0.read(), |tu| &*tu.abc.0)
+    }
+
     /// Load a method from the ABC file and return it's method definition.
     pub fn load_method(
         self,