Method parse_interpolated_string_middle

crates/ruff_python_parser/src/string.rs:280–374

(
        mut self,
    )

    }

    fn parse_interpolated_string_middle(
        mut self,
    ) -> Result<ast::InterpolatedStringLiteralElement, LexicalError> {
        // Fast-path: if the f-string or t-string doesn't contain any escape sequences, return the literal.
        let Some(mut index) = memchr::memchr3(b'{', b'}', b'\\', self.source.as_bytes()) else {
            return Ok(ast::InterpolatedStringLiteralElement {
                value: self.source.into(),
                range: self.range,
                node_index: AtomicNodeIndex::NONE,
            });
        };

        let mut value = String::with_capacity(self.source.len());
        loop {
            // Add the characters before the escape sequence (or curly brace) to the string.
            let before_with_slash_or_brace = self.skip_bytes(index + 1);
            let before = &before_with_slash_or_brace[..before_with_slash_or_brace.len() - 1];
            value.push_str(before);

            // Add the escaped character to the string.
            match self.source.as_bytes()[self.cursor - 1] {
                // If there are any curly braces inside a `F/TStringMiddle` token,
                // then they were escaped (i.e. `{{` or `}}`). This means that
                // the raw source contains a doubled brace, but the literal value only
                // contains one brace.
                brace @ (b'{' | b'}') => {
                    if self.peek_byte() == Some(brace) {
                        self.next_byte();
                    }
                    value.push(char::from(brace));
                }
                // We can encounter a `\` as the last character in a `F/TStringMiddle`
                // token which is valid in this context. For example,
                //
                // ```python
                // f"\{foo} \{bar:\}"
                // # ^     ^^     ^
                // ```
                //
                // Here, the `F/TStringMiddle` token content will be "\" and " \"
                // which is invalid if we look at the content in isolation:
                //
                // ```python
                // "\"
                // ```
                //
                // However, the content is syntactically valid in the context of
                // the f/t-string because it's a substring of the entire f/t-string.
                // This is still an invalid escape sequence, but we don't want to
                // raise a syntax error as is done by the CPython parser. It might
                // be supported in the future, refer to point 3: https://peps.python.org/pep-0701/#rejected-ideas
                b'\\' => {
                    if !self.flags.is_raw_string() && self.peek_byte().is_some() {
                        if let Some(brace @ (b'{' | b'}')) = self.peek_byte()
                            && self.source.as_bytes().get(self.cursor + 1).copied() == Some(brace)
                        {
                            // Leave the doubled brace for the next iteration to collapse.
                            value.push('\\');