implicit-concat-as-joined-str

Author: harupy

compiler/parser/Cargo.toml

@@ -10,6 +10,7 @@ edition = "2021"
 
 [features]
 default = ["lalrpop"]  # removing this causes potential build failure
+implicit-concat-as-joined-str = []
 
 [build-dependencies]
 anyhow = "1.0.45"

compiler/parser/src/string.rs

@@ -29,17 +29,29 @@ pub fn parse_strings(
         });
     }
 
+    if values.len() > 1 && cfg!(feature = "implicit-concat-as-joined-str") {
+        let mut exprs: Vec<Expr> = vec![];
+        for (start, (source, kind, triple_quoted), end) in values {
+            let expr = parse_string(&source, kind, triple_quoted, start, end)?;
+            exprs.push(expr);
+        }
+        return Ok(Expr::new(
+            initial_start,
+            last_end,
+            ExprKind::JoinedStr { values: exprs },
+        ));
+    }
+
     if has_bytes {
         let mut content: Vec<u8> = vec![];
         for (start, (source, kind, triple_quoted), end) in values {
-            for value in parse_string(&source, kind, triple_quoted, start, end)? {
-                match value.node {
-                    ExprKind::Constant {
-                        value: Constant::Bytes(value),
-                        ..
-                    } => content.extend(value),
-                    _ => unreachable!("Unexpected non-bytes expression."),
-                }
+            let expr = parse_string(&source, kind, triple_quoted, start, end)?;
+            match expr.node {
+                ExprKind::Constant {
+                    value: Constant::Bytes(value),
+                    ..
+                } => content.extend(value),
+                _ => unreachable!("Unexpected non-bytes expression."),
             }
         }
         return Ok(Expr::new(
@@ -55,14 +67,13 @@ pub fn parse_strings(
     if !has_fstring {
         let mut content: Vec<String> = vec![];
         for (start, (source, kind, triple_quoted), end) in values {
-            for value in parse_string(&source, kind, triple_quoted, start, end)? {
-                match value.node {
-                    ExprKind::Constant {
-                        value: Constant::Str(value),
-                        ..
-                    } => content.push(value),
-                    _ => unreachable!("Unexpected non-string expression."),
-                }
+            let expr = parse_string(&source, kind, triple_quoted, start, end)?;
+            match expr.node {
+                ExprKind::Constant {
+                    value: Constant::Str(value),
+                    ..
+                } => content.push(value),
+                _ => unreachable!("Unexpected non-string expression."),
             }
         }
         return Ok(Expr::new(
@@ -91,20 +102,30 @@ pub fn parse_strings(
     };
 
     for (start, (source, kind, triple_quoted), end) in values {
-        for value in parse_string(&source, kind, triple_quoted, start, end)? {
-            match value.node {
-                ExprKind::FormattedValue { .. } => {
-                    if !current.is_empty() {
-                        deduped.push(take_current(&mut current));
+        let expr = parse_string(&source, kind, triple_quoted, start, end)?;
+        match expr.node {
+            ExprKind::Constant {
+                value: Constant::Str(value),
+                ..
+            } => current.push(value),
+            ExprKind::JoinedStr { values } => {
+                for value in values {
+                    match value.node {
+                        ExprKind::Constant {
+                            value: Constant::Str(value),
+                            ..
+                        } => current.push(value),
+                        ExprKind::FormattedValue { .. } => {
+                            if !current.is_empty() {
+                                deduped.push(take_current(&mut current));
+                            }
+                            deduped.push(value)
+                        }
+                        _ => unreachable!("Unexpected non-string expression."),
                     }
-                    deduped.push(value)
                 }
-                ExprKind::Constant {
-                    value: Constant::Str(value),
-                    ..
-                } => current.push(value),
-                _ => unreachable!("Unexpected non-string expression."),
             }
+            _ => unreachable!("Unexpected non-string expression."),
         }
     }
     if !current.is_empty() {

compiler/parser/src/string_parser.rs

@@ -506,13 +506,14 @@ impl<'a> StringParser<'a> {
         }))
     }
 
-    pub fn parse(&mut self) -> Result<Vec<Expr>, LexicalError> {
+    pub fn parse(&mut self) -> Result<Expr, LexicalError> {
         if self.kind.is_fstring() {
             self.parse_fstring(0)
+                .map(|values| self.expr(ExprKind::JoinedStr { values }))
         } else if self.kind.is_bytes() {
-            self.parse_bytes().map(|expr| vec![expr])
+            self.parse_bytes()
         } else {
-            self.parse_string().map(|expr| vec![expr])
+            self.parse_string()
         }
     }
 }
@@ -528,15 +529,15 @@ pub fn parse_string(
     triple_quoted: bool,
     start: Location,
     end: Location,
-) -> Result<Vec<Expr>, LexicalError> {
+) -> Result<Expr, LexicalError> {
     StringParser::new(source, kind, triple_quoted, start, end).parse()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    fn parse_fstring(source: &str) -> Result<Vec<Expr>, LexicalError> {
+    fn parse_fstring(source: &str) -> Result<Expr, LexicalError> {
         StringParser::new(
             source,
             StringKind::FString,