Nit: It would be nice if the function returns a Cow to avoid the extra allocation if the string doesn't contain any ${ (which is the case for the majority of strings).

Nice that you thought of that edge case!

There is one more edge case. It is still necessary to add the \ if the input is "\\${" where the first backslash escapes the second.

This should be converted to \\\${ where the third \ escapes the ${

@MichaReiser Thanks for telling me more edge cases! I have investigated again based on your advice and it looks like I need to escape backticks as well as dollar signs. (ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)

In implementing these escaping operations, I would like to use regex crate. Is it OK?

Good point. An alternative would be to not error on strings that contain backticks because it having a template literal with many escapes may as well be less readable than using + (which we probably can also say is true if the string contains any ${

It should be possible to implement this functionality without using the regex crate as it is only necessary to test for the presence of specific characters. We do something similar in normalize_newlines where we match on a set of characters and then push the result to a new string. The code doesn't allocate for the cases where the input string contains no new lines because an empty string doesn't allocate in Rust.

I did a quick test here on a possible generic implementation. I have not spent to much time testing.

We can move this to a util folder and create an extension method for strings.

It is important to implement the already-escaped looking forward. Looking backward doing i-1 it is not UTF8 safe.

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=3e3e9e1d460a57170e04b45e3c5d292d

fn escape<'a>(unescaped_string: &'a str, needs_escaping: &[&str], escaping_char: char) -> std::borrow::Cow<'a, str> {
    let mut escaped = String::new();
    let escaping_char_len = escaping_char.len_utf8();
    let mut iter = unescaped_string.char_indices();
    'unescaped: while let Some((idx, chr)) = iter.next() {
       'candidates: for candidate in needs_escaping {
            if chr == escaping_char && unescaped_string[idx + escaping_char_len..].starts_with(candidate) {
                for _ in candidate.chars().skip(1) {
                    let _ = iter.next();
                }
               continue 'candidates;
            }
           
            if unescaped_string[idx..].starts_with(candidate) {
                if escaped.is_empty() {
                    escaped = String::with_capacity(unescaped_string.len() * 2);
                    escaped.push_str(&unescaped_string[0..idx]);
                }
                escaped.push(escaping_char);
                escaped.push_str(candidate);
                for _ in candidate.chars().skip(1) {
                    let _ = iter.next();
                }
                continue 'unescaped;
            }
        }
        
        if !escaped.is_empty() {
            escaped.push(chr);
        }
   }
   
   if escaped.is_empty() {
       std::borrow::Cow::Borrowed(unescaped_string)
   } else {
       std::borrow::Cow::Owned(escaped)
   }
}