Allow escaping braces in fstrings (#725)

Author: mmarx

nemo/src/parser/ast/expression/complex/fstring.rs

@@ -17,6 +17,10 @@ pub enum FormatStringElement<'a> {
     String(Token<'a>),
     /// Expression
     Expression(Expression<'a>),
+    /// Escaped start marker
+    EscapedStart,
+    /// Escaped end marker
+    EscapedEnd,
 }
 
 /// A string which may include sub expressions
@@ -48,6 +52,12 @@ impl<'a> FormatString<'a> {
     fn parse_element(input: ParserInput<'a>) -> ParserResult<'a, FormatStringElement<'a>> {
         alt((
             map(Token::fstring, FormatStringElement::String),
+            map(Token::fstring_escape_start, |_| {
+                FormatStringElement::EscapedStart
+            }),
+            map(Token::fstring_escape_end, |_| {
+                FormatStringElement::EscapedEnd
+            }),
             map(Self::parse_expression, FormatStringElement::Expression),
         ))(input)
     }
@@ -58,6 +68,12 @@ impl<'a> FormatString<'a> {
     ) -> ParserResult<'a, FormatStringElement<'a>> {
         alt((
             map(Token::multiline_fstring, FormatStringElement::String),
+            map(Token::fstring_escape_start, |_| {
+                FormatStringElement::EscapedStart
+            }),
+            map(Token::fstring_escape_end, |_| {
+                FormatStringElement::EscapedEnd
+            }),
             map(Self::parse_expression, FormatStringElement::Expression),
         ))(input)
     }
@@ -73,6 +89,8 @@ impl<'a> ProgramAST<'a> for FormatString<'a> {
             match element {
                 FormatStringElement::String(_token) => {}
                 FormatStringElement::Expression(expression) => result.push(expression),
+                &FormatStringElement::EscapedStart => {}
+                &FormatStringElement::EscapedEnd => {}
             }
         }
 
@@ -125,6 +143,7 @@ impl<'a> ProgramAST<'a> for FormatString<'a> {
 #[cfg(test)]
 mod test {
     use nom::combinator::all_consuming;
+    use test_log::test;
 
     use crate::parser::{
         ParserState,
@@ -141,6 +160,10 @@ mod test {
             (r#"f"{?x + 1}""#, 1),
             (r#"f"result: {?x + 1}""#, 2),
             (r#"f"{?x} + {?y} = {?x + ?y}""#, 5),
+            (r#"f"{{""#, 1),
+            (r#"f"}}""#, 1),
+            (r#"f"{{}}""#, 2),
+            (r#"f"}}{{""#, 2),
         ];
 
         for (input, expected) in test {
@@ -150,6 +173,11 @@ mod test {
             assert!(result.is_ok());
 
             let result = result.unwrap().1;
+
+            log::debug!(
+                "{input:?}: expected {expected}; got {:?}",
+                result.elements().collect::<Vec<_>>()
+            );
             assert_eq!(expected, result.elements().count());
         }
     }

nemo/src/parser/ast/token.rs

@@ -180,6 +180,12 @@ pub enum TokenKind {
     /// Format string expression close
     #[assoc(name = format_string::EXPRESSION_END)]
     FormatStringExpressionEnd,
+    /// Format string escaped start marker
+    #[assoc(name = format_string::ESCAPE_START)]
+    FormatStringEscapeStart,
+    /// Format string escaped end marker
+    #[assoc(name = format_string::ESCAPE_END)]
+    FormatStringEscapeEnd,
     /// Blank node prefix
     #[assoc(name = "_:")]
     BlankNodePrefix,
@@ -816,6 +822,8 @@ impl<'a> Token<'a> {
     string_token!(triple_quote, TokenKind::TripleQuote);
     string_token!(fstring_open, TokenKind::FormatStringOpen);
     string_token!(fstring_close, TokenKind::FormatStringClose);
+    string_token!(fstring_escape_start, TokenKind::FormatStringEscapeStart);
+    string_token!(fstring_escape_end, TokenKind::FormatStringEscapeEnd);
     string_token!(fstring_multiline_open, TokenKind::FormatStringMultilineOpen);
     string_token!(
         fstring_multiline_close,

nemo/src/rule_model/translation/complex/fstring.rs

@@ -1,6 +1,6 @@
 use crate::{
     newtype_wrapper,
-    parser::ast::{self},
+    parser::ast::{self, expression::complex::fstring::FormatStringElement},
     rule_model::{
         components::term::{
             Term,
@@ -9,6 +9,7 @@ use crate::{
         origin::Origin,
         translation::TranslationComponent,
     },
+    syntax::expression::format_string::{EXPRESSION_END, EXPRESSION_START},
 };
 
 pub(crate) struct FormatStringLiteral(Operation);
@@ -25,15 +26,15 @@ impl TranslationComponent for FormatStringLiteral {
 
         for element in format_string.elements() {
             let term = match element {
-                ast::expression::complex::fstring::FormatStringElement::String(token) => {
-                    Term::from(token.to_string())
-                }
-                ast::expression::complex::fstring::FormatStringElement::Expression(expression) => {
+                FormatStringElement::String(token) => Term::from(token.to_string()),
+                FormatStringElement::Expression(expression) => {
                     let inner_term = Term::build_component(translation, expression)?;
                     let string_conversion =
                         Operation::new(OperationKind::LexicalValue, vec![inner_term]);
                     Term::from(string_conversion)
                 }
+                FormatStringElement::EscapedStart => Term::from(EXPRESSION_START),
+                FormatStringElement::EscapedEnd => Term::from(EXPRESSION_END),
             };
 
             subterms.push(term);

nemo/src/syntax.rs

@@ -147,6 +147,11 @@ pub mod expression {
         pub const EXPRESSION_START: &str = "{";
         /// Marker of the end of an expression
         pub const EXPRESSION_END: &str = "}";
+
+        /// Escaped version of the start marker
+        pub const ESCAPE_START: &str = "{{";
+        /// Escaped version of the end marker
+        pub const ESCAPE_END: &str = "}}";
     }
 }