feat: Allow nested interpolated strings in lexer

prqlc/prql-compiler/tests/integration/parser.rs

@@ -1328,10 +1328,12 @@ fn test_func_call() {
         "###);
 
     // A non-friendly option for #154
-    let ast = parse_expr(r#"count s'*'"#).unwrap();
-    let func_call: FuncCall = ast.kind.into_func_call().unwrap();
     assert_yaml_snapshot!(
-            func_call, @r###"
+      parse_expr(r#"count s'*'"#)
+        .unwrap()
+        .kind
+        .into_func_call()
+        .unwrap(), @r###"
         ---
         name:
           Ident:

prqlc/prqlc-parser/src/expr.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use chumsky::prelude::*;
 
+use itertools::Itertools;
 use prqlc_ast::expr::*;
 use prqlc_ast::Span;
 
@@ -85,12 +86,15 @@ pub fn expr() -> impl Parser<Token, Expr, Error = PError> + Clone {
                     |_| Expr::new(ExprKind::Literal(Literal::Null)),
                 ));
 
+        // TODO: temporary implementation to keep it working on the new
+        // interpolation lexer with the old interpolation parser
         let interpolation = select! {
             Token::Interpolation('s', string) => (ExprKind::SString as fn(_) -> _, string),
             Token::Interpolation('f', string) => (ExprKind::FString as fn(_) -> _, string),
         }
         .validate(|(finish, string), span: ParserSpan, emit| {
-            match interpolation::parse(string, span + 2) {
+            match interpolation::parse(string.into_iter().map(|x| x.to_string()).join(""), span + 2)
+            {
                 Ok(items) => finish(items),
                 Err(errors) => {
                     for err in errors {

prqlc/prqlc-parser/src/interpolation.rs

@@ -8,9 +8,11 @@ use super::common::{into_expr, PError};
 use super::lexer::*;
 use super::span::ParserSpan;
 
+use prqlc_ast::expr::InterpolateItem;
+
 /// Parses interpolated strings
 pub fn parse(string: String, span_base: ParserSpan) -> Result<Vec<InterpolateItem>, Vec<PError>> {
-    let res = parser(span_base).parse(string);
+    let res = parser(span_base).parse(dbg!(string));
 
     match res {
         Ok(items) => Ok(items),