Fix hacks for RepeatFallback

Author: archaephyrryx

src/lib.rs

@@ -782,7 +782,7 @@ enum Decoder {
     Record(Vec<(Cow<'static, str>, Decoder)>),
     While(MatchTree, Box<Decoder>),
     Until(MatchTree, Box<Decoder>),
-    RepeatFallback(Box<Decoder>, Box<Decoder>),
+    RepeatFallback(MatchTree, Box<Decoder>, Box<Decoder>),
     RepeatCount(Expr, Box<Decoder>),
     RepeatUntilLast(Expr, Box<Decoder>),
     RepeatUntilSeq(Expr, Box<Decoder>),
@@ -2381,7 +2381,18 @@ impl Decoder {
                     Rc::new(Next::Repeat(wide, next.clone())),
                 )?);
 
-                Ok(Decoder::RepeatFallback(dnarrow, dwide))
+                // Under the precondition that narrow is a subset of wide, the union of the two matchtrees is just the
+                // matchtree for wide
+
+                let wide_star = Format::Repeat(wide.clone());
+                let f_wide = Format::Tuple(vec![(**wide).clone(), wide_star]);
+                let f_empty = Format::EMPTY;
+
+                if let Some(tree) = MatchTree::build(compiler.module, &[f_wide, f_empty], next) {
+                    Ok(Decoder::RepeatFallback(tree, dnarrow, dwide))
+                } else {
+                    Err(format!("Cannot build match tree for {format:?}"))
+                }
             }
             Format::Repeat1(a) => {
                 if a.is_nullable(compiler.module) {
@@ -2604,43 +2615,33 @@ impl Decoder {
                 }
                 Ok((Value::Seq(v), input))
             }
-            Decoder::RepeatFallback(subset, superset) => {
-                let mut accum = Vec::new();
-                let mut incr_input = input;
+            Decoder::RepeatFallback(tree, subset, superset) => {
+                let mut input = input;
+                let mut v = Vec::new();
+                let mut decoder = subset;
+                let mut fellback = false;
 
-                loop {
-                    match subset.parse(program, scope, incr_input) {
-                        Ok((b, next_input)) => {
-                            accum.push(b);
-                            incr_input = next_input;
+                while tree.matches(input).ok_or(ParseError::NoValidBranch {
+                    offset: input.offset,
+                })? == 0
+                {
+                    match decoder.parse(program, scope, input) {
+                        Ok((va, next_input)) => {
+                            input = next_input;
+                            v.push(va);
                         }
-                        Err(_err) => break,
-                    }
-                }
-
-                // track the last offset we reached to see if we get any further
-                let checkpoint = incr_input.offset;
-
-                loop {
-                    match superset.parse(program, scope, incr_input) {
-                        Ok((b, next_input)) => {
-                            accum.push(b);
-                            incr_input = next_input;
+                        err @ Err(_) => {
+                            if fellback {
+                                return err;
+                            } else {
+                                decoder = superset;
+                                fellback = true;
+                            }
                         }
-                        Err(_err) => break,
                     }
                 }
 
-                if let Err(e) = (Decoder::EndOfInput).parse(program, scope, incr_input) {
-                    return Err(e);
-                }
-
-                let fellthrough = incr_input.offset > checkpoint;
-
-                Ok((
-                    Value::Fallback(fellthrough, Box::new(Value::Seq(accum))),
-                    incr_input,
-                )) // index 1
+                Ok((Value::Fallback(fellback, Box::new(Value::Seq(v))), input))
             }
             Decoder::RepeatCount(expr, a) => {
                 let mut input = input;