avm2: implement string.replace(...) with fn, for now regex only. (ruffle-rs#7429)

* avm2: implement string.replace(...) with fn, for now regex only.

  * string - added path for replacing regex with fn (replacing string
  with fn is still unimplemented)

  * regex - factored out common replace logic for when replacement is
  a string and when it is a function

  * added tests

* Addressed review comments

* removed tinkering cruft; formatting

* addressed review comments

Author: dowgird

core/src/avm2/globals/string.rs

@@ -291,22 +291,25 @@ fn replace<'gc>(
         let pattern = args.get(0).unwrap_or(&Value::Undefined);
         let replacement = args.get(1).unwrap_or(&Value::Undefined);
 
-        if replacement
-            .as_object()
-            .and_then(|o| o.as_function_object())
-            .is_some()
-        {
-            log::warn!("string.replace(_, function) - not implemented");
-            return Err("NotImplemented".into());
+        if let Some(f) = replacement.as_object().and_then(|o| o.as_function_object()) {
+            if let Some(mut regexp) = pattern
+                .as_object()
+                .as_ref()
+                .and_then(|o| o.as_regexp_mut(activation.context.gc_context))
+            {
+                return Ok(regexp.replace_fn(activation, this, &f)?.into());
+            } else {
+                log::warn!("string.replace(string, function) - not implemented");
+                return Err("NotImplemented".into());
+            }
         }
         let replacement = replacement.coerce_to_string(activation)?;
-
         if let Some(mut regexp) = pattern
             .as_object()
             .as_ref()
             .and_then(|o| o.as_regexp_mut(activation.context.gc_context))
         {
-            return Ok(regexp.replace(activation, this, replacement).into());
+            return Ok(regexp.replace_string(activation, this, replacement)?.into());
         } else {
             let pattern = pattern.coerce_to_string(activation)?;
             if let Some(position) = this.find(&pattern) {

core/src/avm2/regexp.rs

@@ -3,6 +3,8 @@
 use std::borrow::Cow;
 
 use crate::avm2::activation::Activation;
+use crate::avm2::object::FunctionObject;
+use crate::avm2::object::TObject;
 use crate::avm2::Error;
 use crate::avm2::{ArrayObject, ArrayStorage, Object};
 use crate::string::WString;
@@ -148,6 +150,8 @@ impl<'gc> RegExp<'gc> {
         }
     }
 
+    /// Helper for replace_string. Evaluates the special $-sequences
+    /// in `replacement`.
     fn effective_replacement(
         replacement: &AvmString<'gc>,
         text: &AvmString<'gc>,
@@ -200,17 +204,65 @@ impl<'gc> RegExp<'gc> {
         ret
     }
 
-    pub fn replace(
+    /// Implements string.replace(regex, replacement) where the replacement is
+    /// a function.
+    pub fn replace_fn(
+        &mut self,
+        activation: &mut Activation<'_, 'gc, '_>,
+        text: AvmString<'gc>,
+        f: &FunctionObject<'gc>,
+    ) -> Result<AvmString<'gc>, Error> {
+        self.replace_with_fn(activation, &text, |activation, txt, m| {
+            let args = std::iter::once(Some(&m.range))
+                .chain((m.captures.iter()).map(|x| x.as_ref()))
+                .map(|o| match o {
+                    Some(r) => {
+                        AvmString::new(activation.context.gc_context, &txt[r.start..r.end]).into()
+                    }
+                    None => "".into(),
+                })
+                .chain(std::iter::once(m.range.start.into()))
+                .chain(std::iter::once((*txt).into()))
+                .collect::<Vec<_>>();
+            let r = f.call(activation.global_scope(), &args, activation)?;
+            return Ok(WString::from(r.coerce_to_string(activation)?.as_wstr()));
+        })
+    }
+
+    /// Implements string.replace(regex, replacement) where the replacement is
+    /// a string with $-sequences.
+    pub fn replace_string(
         &mut self,
         activation: &mut Activation<'_, 'gc, '_>,
         text: AvmString<'gc>,
         replacement: AvmString<'gc>,
-    ) -> AvmString<'gc> {
+    ) -> Result<AvmString<'gc>, Error> {
+        self.replace_with_fn(activation, &text, |_activation, txt, m| {
+            Ok(Self::effective_replacement(&replacement, txt, m))
+        })
+    }
+
+    // Helper for replace_string and replace_function.
+    //
+    // Replaces occurrences of regex with results of f(activation, &text, &match)
+    fn replace_with_fn<F>(
+        &mut self,
+        activation: &mut Activation<'_, 'gc, '_>,
+        text: &AvmString<'gc>,
+        mut f: F,
+    ) -> Result<AvmString<'gc>, Error>
+    where
+        F: FnMut(
+            &mut Activation<'_, 'gc, '_>,
+            &AvmString<'gc>,
+            &regress::Match,
+        ) -> Result<WString, Error>,
+    {
         let mut ret = WString::new();
         let mut start = 0;
-        while let Some(m) = self.find_utf16_match(text, start) {
+        while let Some(m) = self.find_utf16_match(*text, start) {
             ret.push_str(&text[start..m.range.start]);
-            ret.push_str(&Self::effective_replacement(&replacement, &text, &m));
+            ret.push_str(&f(activation, &text, &m)?);
 
             start = m.range.end;
 
@@ -228,7 +280,7 @@ impl<'gc> RegExp<'gc> {
         }
 
         ret.push_str(&text[start..]);
-        AvmString::new(activation.context.gc_context, ret)
+        Ok(AvmString::new(activation.context.gc_context, ret))
     }
 
     pub fn split(

tests/tests/swfs/avm2/string_replace/Test.as

@@ -60,5 +60,33 @@ trace("// Two-digit capture group number")
 var r=RegExp("(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)")
 trace("abbbbbbbbb#bbc".replace(r, "<$10>"))
 
+trace("// replace function")
 
+function replFN():String {
+      return "foo";
+}
+
+
+trace("abbbb".replace(/a/,replFN))
+
+trace("// replace with functions returning non-string values")
+
+function replFn2() {
+     return 2;
+}
+
+function replFn3() {
+}
+
+trace("abbbb".replace(/a/,replFn2))
+trace("abbbb".replace(/a/,replFn3))
+
+trace("// replace a regex with function, check arguments")
+
+// relies on implicit coercion to string
+function rFN() {
+  return arguments;
+}
 
+// The (b) and (c) groups have no matches.
+trace("<<a>>".replace(/(a)(b)?|(c)/, rFN))

tests/tests/swfs/avm2/string_replace/output.txt

@@ -31,3 +31,10 @@ a<$2>c
 a<b0>c
 // Two-digit capture group number
 <b>#bbc
+// replace function
+foobbbb
+// replace with functions returning non-string values
+2bbbb
+undefinedbbbb
+// replace a regex with function, check arguments
+<<a,a,,,2,<<a>>>>