Parse Optionals

Author: loewenheim

relay-pattern/src/lib.rs

@@ -672,11 +672,12 @@ struct Tokens(Vec<Token>);
 impl Tokens {
     fn push(&mut self, mut token: Token) {
         // Normalize / clean the token.
-        if let Token::Alternates(alternates) = &mut token {
+        if let Token::Alternates(mut alternates) = token {
+            let mut contains_empty = false;
             let mut contains_wildcard = false;
             alternates.retain_mut(|alternate| {
-                // Empty groups can just be ignored and skipped.
                 if alternate.0.is_empty() {
+                    contains_empty = true;
                     return false;
                 }
 
@@ -687,10 +688,38 @@ impl Tokens {
                 true
             });
 
-            // If any of the alternations contains a wildcard, we can fold the entire
-            // alternation into a single wildcard.
+            // At this point `alternates` contains only the nonempty branches
+            // and we additionally know
+            // * if one of the branches was just a wildcard
+            // * if there were any empty branches.
+            //
+            // We can push different tokens based on this.
             if contains_wildcard {
+                // Case: {foo,*,} -> reduces to *
                 token = Token::Wildcard;
+            } else if alternates.len() == 1 {
+                if contains_empty {
+                    // Case: {foo*bar,} -> Optional(foo*bar)
+                    token = Token::Optional(alternates.remove(0).0);
+                } else {
+                    // Case: {foo*bar} -> remove the alternation and
+                    // push foo*bar directly
+                    for t in alternates.remove(0).0 {
+                        self.push(t);
+                    }
+                    return;
+                }
+            } else if alternates.len() > 1 {
+                if contains_empty {
+                    // Case: {foo,bar,} -> Optional({foo,bar})
+                    token = Token::Optional(vec![Token::Alternates(alternates)]);
+                } else {
+                    // Case: {foo, bar} -> can stay as it is
+                    token = Token::Alternates(alternates);
+                }
+            } else {
+                // Case: {,,,} -> reduces to {}
+                token = Token::Alternates(vec![]);
             }
         }