convert f-string parser to state machine

OddCoincidence · OddCoincidence · commit 5968c4d92237 · 2019-02-15T18:14:33.000-08:00
diff --git a/parser/src/parser.rs b/parser/src/parser.rs
@@ -1,7 +1,6 @@
 extern crate lalrpop_util;
 
 use std::iter;
-use std::mem;
 
 use super::ast;
 use super::error::ParseError;
@@ -86,74 +85,111 @@ impl From<FStringError>
     }
 }
 
+enum ParseState {
+    Text { content: String },
+    FormattedValue { expression: String, depth: usize },
+}
+
 pub fn parse_fstring(source: &str) -> Result<ast::StringGroup, FStringError> {
+    use self::ParseState::*;
+
     let mut values = vec![];
-    let mut start = 0;
-    let mut depth = 0;
-    let mut escaped = false;
-    let mut content = String::new();
-
-    let mut chars = source.char_indices().peekable();
-    while let Some((pos, ch)) = chars.next() {
-        match ch {
-            '{' | '}' if escaped => {
-                if depth == 0 {
+    let mut state = ParseState::Text {
+        content: String::new(),
+    };
+
+    let mut chars = source.chars().peekable();
+    while let Some(ch) = chars.next() {
+        state = match state {
+            Text { mut content } => match ch {
+                '{' => {
+                    if let Some('{') = chars.peek() {
+                        chars.next();
+                        content.push('{');
+                        Text { content }
+                    } else {
+                        if !content.is_empty() {
+                            values.push(ast::StringGroup::Constant { value: content });
+                        }
+
+                        FormattedValue {
+                            expression: String::new(),
+                            depth: 0,
+                        }
+                    }
+                }
+                '}' => {
+                    if let Some('}') = chars.peek() {
+                        chars.next();
+                        content.push('}');
+                        Text { content }
+                    } else {
+                        return Err(FStringError::UnopenedRbrace);
+                    }
+                }
+                _ => {
                     content.push(ch);
+                    Text { content }
                 }
-                escaped = false;
-            }
-            '{' => {
-                if let Some((_, '{')) = chars.peek() {
-                    escaped = true;
-                    continue;
+            },
+
+            FormattedValue {
+                mut expression,
+                depth,
+            } => match ch {
+                '{' => {
+                    if let Some('{') = chars.peek() {
+                        expression.push_str("{{");
+                        chars.next();
+                        FormattedValue { expression, depth }
+                    } else {
+                        expression.push('{');
+                        FormattedValue {
+                            expression,
+                            depth: depth + 1,
+                        }
+                    }
                 }
-
-                if depth == 0 {
-                    if !content.is_empty() {
-                        values.push(ast::StringGroup::Constant {
-                            value: mem::replace(&mut content, String::new()),
+                '}' => {
+                    if let Some('}') = chars.peek() {
+                        expression.push_str("}}");
+                        chars.next();
+                        FormattedValue { expression, depth }
+                    } else if depth > 0 {
+                        expression.push('}');
+                        FormattedValue {
+                            expression,
+                            depth: depth - 1,
+                        }
+                    } else {
+                        values.push(ast::StringGroup::FormattedValue {
+                            value: Box::new(match parse_expression(dbg!(expression.trim())) {
+                                Ok(expr) => expr,
+                                Err(_) => return Err(FStringError::InvalidExpression),
+                            }),
                         });
+                        Text {
+                            content: String::new(),
+                        }
                     }
-
-                    start = pos + 1;
-                }
-
-                depth += 1;
-            }
-            '}' => {
-                if let Some((_, '}')) = chars.peek() {
-                    escaped = true;
-                    continue;
                 }
-
-                if depth == 0 {
-                    return Err(FStringError::UnopenedRbrace);
+                _ => {
+                    expression.push(ch);
+                    FormattedValue { expression, depth }
                 }
+            },
+        };
+    }
 
-                depth -= 1;
-                if depth == 0 {
-                    values.push(ast::StringGroup::FormattedValue {
-                        value: Box::new(match parse_expression(source[start..pos].trim()) {
-                            Ok(expr) => expr,
-                            Err(_) => return Err(FStringError::InvalidExpression),
-                        }),
-                    });
-                }
-            }
-            ch => {
-                if depth == 0 {
-                    content.push(ch);
-                }
+    match state {
+        Text { content } => {
+            if !content.is_empty() {
+                values.push(ast::StringGroup::Constant { value: content })
             }
         }
-    }
-
-    if depth != 0 {
-        return Err(FStringError::UnclosedLbrace);
-    }
-
-    if !content.is_empty() {
-        values.push(ast::StringGroup::Constant { value: content })
+        FormattedValue { .. } => {
+            return Err(FStringError::UnclosedLbrace);
+        }
     }
 
     Ok(match values.len() {
diff --git a/tests/snippets/fstrings.py b/tests/snippets/fstrings.py
@@ -11,3 +11,6 @@
 assert f'{f"{{"}' == '{'
 assert f'{f"}}"}' == '}'
 assert f'{foo}' f"{foo}" 'foo' == 'barbarfoo'
+assert f'{"!:"}' == '!:'
+#assert f"{1 != 2}" == 'True'
+assert fr'x={4*10}\n' == 'x=40\\n'
