feat: Flatten Choice chains across Let boundaries where possible

Author: ms6123

parsley/shared/src/main/scala/parsley/internal/collection/mutable/SinglyLinkedList.scala

@@ -70,6 +70,8 @@ private [internal] class SinglyLinkedList[A] private
         var current = start
         override val end = SinglyLinkedList.this.end
     }
+
+    def copy: SinglyLinkedList[A] = { val r = new SinglyLinkedList[A]; r.addAll(this); r }
 }
 
 private [internal] object SinglyLinkedList {

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/AlternativeEmbedding.scala

@@ -12,6 +12,7 @@ import parsley.XAssert.*
 
 import parsley.internal.collection.mutable.SinglyLinkedList, SinglyLinkedList.LinkedListIterator
 import parsley.internal.deepembedding.ContOps, ContOps.{result, suspend, ContAdapter}
+import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.deepembedding.singletons.*
 import parsley.internal.errors.{ExpectDesc, ExpectItem}
 import parsley.internal.machine.instructions
@@ -21,24 +22,23 @@ import Choice.*
 import StrictParsley.InstrBuffer
 // scalastyle:on underscore.import
 
-// TODO: can we tabilify across a Let?
 // FIXME: It's annoying this doesn't work if the first thing is not tablable: let's make it more fine-grained to create groupings?
 private [deepembedding] final class Choice[A] private (private [backend] val alt1: StrictParsley[A],
                                                        private [backend] var alt2: StrictParsley[A],
                                                        private [backend] var alts: SinglyLinkedList[StrictParsley[A]]) extends StrictParsley[A] {
     def this(lalt: StrictParsley[A], ralt: StrictParsley[A]) = this(lalt, ralt, SinglyLinkedList.empty)
     def inlinable: Boolean = false
 
-    override def optimise: StrictParsley[A] = {
+    override def optimise(implicit lets: LetMap): StrictParsley[A] = {
         // We make the assumption that nodes here are not reoptimised: as such, we can safely
         // assume that it is always in <|> form, with no alts on a choice (as this is the only public constructor)
         if (alts.nonEmpty) throw new IllegalStateException("<|> assumed, but full Choice given") // scalastyle:ignore throw
         if (alt2 eq Empty.Zero) alt1
         else alt1 match {
             case (u: Pure[?]) => u
             case Empty.Zero => alt2
-            case ret@Choice(_, _, lalts: SinglyLinkedList[StrictParsley[A]] @unchecked) => alt2 match {
-                case Choice(ralt1, ralt2, ralts: SinglyLinkedList[StrictParsley[A]] @unchecked) =>
+            case FindChoice(ret@Choice(_, _, lalts: SinglyLinkedList[StrictParsley[A]] @unchecked)) => alt2 match {
+                case FindChoice(Choice(ralt1, ralt2, ralts: SinglyLinkedList[StrictParsley[A]] @unchecked)) =>
                     assume(!lalts.exists(_.isInstanceOf[Choice[?]]), "ralts can never contain a choice")
                     assume(!ralts.exists(_.isInstanceOf[Choice[?]]), "lalts can never contain a choice")
                     lalts.addOne(ralt1)
@@ -51,7 +51,7 @@ private [deepembedding] final class Choice[A] private (private [backend] val alt
                     ret
             }
             case _ => alt2 match {
-                case Choice(ralt1, ralt2, ralts: SinglyLinkedList[StrictParsley[A]] @unchecked) =>
+                case FindChoice(Choice(ralt1, ralt2, ralts: SinglyLinkedList[StrictParsley[A]] @unchecked)) =>
                     assume(!ralts.exists(_.isInstanceOf[Choice[?]]), "ralts can never contain a choice")
                     this.alt2 = ralt1
                     this.alts = ralts
@@ -346,6 +346,28 @@ private [backend] object Choice {
             case _ => false
         }
     }
+
+    private object FindChoice {
+        def unapply[A](p: StrictParsley[A])(implicit lets: LetMap): Option[Choice[A]] = {
+            @tailrec
+            def go(p: StrictParsley[A], requiresCopy: Boolean = false): Option[Choice[A]] =
+                p match {
+                    case Choice(alt1, alt2, alts: SinglyLinkedList[StrictParsley[A]] @unchecked) =>
+                        Some(new Choice(alt1, alt2, if (requiresCopy) alts.copy else alts))
+                    case sub: Let[?] =>
+                        val body = lets.findBody(sub)
+                        if (body.isDefined) {
+                            go(body.get.asInstanceOf[StrictParsley[A]], requiresCopy = true)
+                        } else {
+                            // Recursion point
+                            None
+                        }
+                    case _ => None
+                }
+
+            go(p)
+        }
+    }
 }
 
 

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/ErrorEmbedding.scala

@@ -7,6 +7,7 @@ package parsley.internal.deepembedding.backend
 
 import parsley.token.errors.Label
 
+import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.deepembedding.singletons.*
 import parsley.internal.machine.instructions
 
@@ -17,7 +18,7 @@ private [deepembedding] final class ErrorLabel[A](val p: StrictParsley[A], priva
     override def instrNeedsLabel: Boolean = false
     override def handlerLabel(state: CodeGenState): Int = state.getLabelForRelabelError(label +: labels)
     // don't need to be limited to not hidden when the thing can never internally generate hints
-    final override def optimise: StrictParsley[A] = p match {
+    final override def optimise(implicit lets: LetMap): StrictParsley[A] = p match {
         case CharTok(c, x) => new CharTok(c, x, Label(label, labels*)).asInstanceOf[StrictParsley[A]]
         case SupplementaryCharTok(c, x) => new SupplementaryCharTok(c, x, Label(label, labels*)).asInstanceOf[StrictParsley[A]]
         case StringTok(s, x) => new StringTok(s, x, Label(label, labels*)).asInstanceOf[StrictParsley[A]]

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/IterativeEmbedding.scala

@@ -10,13 +10,14 @@ import scala.collection.{mutable, Factory}
 import parsley.exceptions.NonProductiveIterationException
 
 import parsley.internal.deepembedding.ContOps, ContOps.{ContAdapter, suspend}
+import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.deepembedding.singletons.*
 import parsley.internal.machine.instructions
 
 import StrictParsley.InstrBuffer
 
 private [deepembedding] final class Many[A, C](val init: StrictParsley[mutable.Builder[A, C]], val p: StrictParsley[A]) extends Unary[A, C] {
-    final override def optimise: StrictParsley[C] = p match {
+    final override def optimise(implicit lets: LetMap): StrictParsley[C] = p match {
         case _: Pure[?] => throw new NonProductiveIterationException("many") // scalastyle:ignore throw
         case _          => this
     }
@@ -44,7 +45,7 @@ private [backend] object Many {
 
 private [backend] sealed abstract class ChainLike[A](p: StrictParsley[A], op: StrictParsley[A => A]) extends StrictParsley[A] {
     def inlinable: Boolean = false
-    override def optimise: StrictParsley[A] = op match {
+    override def optimise(implicit lets: LetMap): StrictParsley[A] = op match {
         case _: Pure[?] => throw new NonProductiveIterationException("chain") // scalastyle:ignore throw
         case _: MZero   => p
         case _          => this

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/PrecedenceEmbedding.scala

@@ -7,6 +7,7 @@ package parsley.internal.deepembedding.backend
 
 import parsley.internal.deepembedding.ContOps
 import parsley.internal.deepembedding.ContOps.{suspend, ContAdapter}
+import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.deepembedding.singletons.Pure
 import parsley.internal.collection.mutable.SinglyLinkedList
 import parsley.internal.machine.instructions
@@ -47,7 +48,7 @@ private [deepembedding] final class Precedence[A] private (prefixAtomChoice: Str
 
 private [deepembedding] final class StrictOp(val fixity: Fixity, val op: StrictParsley[Any], val prec: Int)
 private [deepembedding] object Precedence {
-    def apply[A](vatoms: List[StrictParsley[Any]], vops: List[StrictOp], wraps: Array[Any => Any]): Precedence[A] = {
+    def apply[A](vatoms: List[StrictParsley[Any]], vops: List[StrictOp], wraps: Array[Any => Any])(implicit lets: LetMap): Precedence[A] = {
         val maxLevel = wraps.length
         val atoms = unwrapChoices(vatoms).map(a => <*>(new Pure(r => new Atom(r, maxLevel)), a).optimise)
         val (prefixes, postfixInfixes) = vops.partition(_.fixity == Prefix)
@@ -56,7 +57,7 @@ private [deepembedding] object Precedence {
         new Precedence(prefixAtomChoice, postfixInfixChoice, buildPrecomputedWraps(wraps))
     }
 
-    private def buildChoiceNode[A](options: List[StrictParsley[A]]): StrictParsley[A] = options.map(_.optimise) match {
+    private def buildChoiceNode[A](options: List[StrictParsley[A]])(implicit lets: LetMap): StrictParsley[A] = options.map(_.optimise) match {
         case Nil => new Fail(new FlexibleCaret(0))
         case p :: Nil => p
         case p1 :: p2 :: Nil => <|>(p1, p2)
@@ -68,7 +69,7 @@ private [deepembedding] object Precedence {
         case p => p :: Nil
     }
 
-    private def buildOpChoice(op: StrictOp): StrictParsley[Operator] = {
+    private def buildOpChoice(op: StrictOp)(implicit lets: LetMap): StrictParsley[Operator] = {
         val opFn = op.fixity match {
             case InfixL => (x: Any) => new instructions.InfixLOp(x.asInstanceOf[(Any, Any) => Any], op.prec)
             case InfixR => (x: Any) => new instructions.InfixROp(x.asInstanceOf[(Any, Any) => Any], op.prec)

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/PrimitiveEmbedding.scala

@@ -10,6 +10,7 @@ import parsley.errors.ErrorBuilder
 import parsley.state.Ref
 
 import parsley.internal.deepembedding.ContOps, ContOps.{ContAdapter, result, suspend}
+import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.deepembedding.singletons.*
 import parsley.internal.machine.instructions
 
@@ -20,7 +21,7 @@ private [deepembedding] final class Atomic[A](val p: StrictParsley[A]) extends S
     override val instr: instructions.Instr = instructions.PopHandlerAndState
     override def instrNeedsLabel: Boolean = false
     override def handlerLabel(state: CodeGenState): Int  = state.getLabel(instructions.RestoreAndFail)
-    override def optimise: StrictParsley[A] = p match {
+    override def optimise(implicit lets: LetMap): StrictParsley[A] = p match {
         case p: CharTok[?] => p
         case p: Atomic[?] => p
         //case StringTok(s, _) if s.size == 1 => p

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/SelectiveEmbedding.scala

@@ -6,6 +6,7 @@
 package parsley.internal.deepembedding.backend
 
 import parsley.internal.deepembedding.ContOps, ContOps.{suspend, ContAdapter}
+import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.deepembedding.singletons.*
 import parsley.internal.machine.instructions
 
@@ -47,7 +48,7 @@ private [backend] sealed abstract class BranchLike[A, B, C, D](finaliser: Option
 private [deepembedding] final class Branch[A, B, C](val b: StrictParsley[Either[A, B]], val p: StrictParsley[A => C], val q: StrictParsley[B => C])
     extends BranchLike[Either[A, B], A => C, B => C, C](Some(FlipApp)) {
     override def instr(label: Int): instructions.Instr = new instructions.Case(label)
-    override def optimise: StrictParsley[C] = b match {
+    override def optimise(implicit lets: LetMap): StrictParsley[C] = b match {
         case Pure(Left(x)) => <*>(p, new Pure(x)).optimise
         case Pure(Right(y)) => <*>(q, new Pure(y)).optimise
         case _ => (p, q) match {
@@ -63,7 +64,7 @@ private [deepembedding] final class Branch[A, B, C](val b: StrictParsley[Either[
 private [deepembedding] final class If[A](val b: StrictParsley[Boolean], val p: StrictParsley[A], val q: StrictParsley[A])
     extends BranchLike[Boolean, A, A, A](None) {
     override def instr(label: Int): instructions.Instr = new instructions.If(label)
-    override def optimise: StrictParsley[A] = b match {
+    override def optimise(implicit lets: LetMap): StrictParsley[A] = b match {
         case Pure(true) => p
         case Pure(false) => q
         case _ => this

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/SequenceEmbedding.scala

@@ -9,7 +9,7 @@ import parsley.XAssert.*
 
 import parsley.internal.collection.mutable.DoublyLinkedList
 import parsley.internal.deepembedding.ContOps, ContOps.{result, suspend, ContAdapter}
-import parsley.internal.deepembedding.frontend
+import parsley.internal.deepembedding.frontend, frontend.LetMap
 import parsley.internal.deepembedding.singletons.*
 import parsley.internal.machine.instructions
 
@@ -19,7 +19,7 @@ import StrictParsley.InstrBuffer
 private [deepembedding] final class <*>[A, B](var left: StrictParsley[A => B], var right: StrictParsley[A]) extends StrictParsley[B] {
     def inlinable: Boolean = false
     // TODO: Refactor
-    override def optimise: StrictParsley[B] = (left, right) match {
+    override def optimise(implicit lets: LetMap): StrictParsley[B] = (left, right) match {
         // Fusion laws
         case (uf, Pure(x)) if (uf.isInstanceOf[Pure[?]] || uf.isInstanceOf[_ <*> _]) => uf match {
             // first position fusion
@@ -87,7 +87,7 @@ private [deepembedding] final class <*>[A, B](var left: StrictParsley[A => B], v
 }
 
 private [deepembedding] final class >>=[A, B](val p: StrictParsley[A], private [>>=] val f: A => frontend.LazyParsley[B]) extends Unary[A, B] {
-    override def optimise: StrictParsley[B] = p match {
+    override def optimise(implicit lets: LetMap): StrictParsley[B] = p match {
         case z: MZero => z
         case _ => this
     }
@@ -138,7 +138,7 @@ private [deepembedding] final class Seq[A](private [backend] var before: DoublyL
 
     // TODO: Get behaves much like pure except for shifting positions
     // TODO: can this be optimised to reduce repeated matching?
-    override def optimise: StrictParsley[A] = this match {
+    override def optimise(implicit lets: LetMap): StrictParsley[A] = this match {
         // Assume that this is eliminated first, so not other before or afters
         case (_: Pure[?] | _: Get[?] | Line | Col | Offset) **> u => u
         case (p: MZero) **> _ => p

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/StrictParsley.scala

@@ -18,6 +18,7 @@ import parsley.internal.deepembedding.frontend.LetMap
 import parsley.internal.machine.instructions, instructions.{Instr, Label}
 
 import StrictParsley.*
+import org.typelevel.scalaccompat.annotation.unused
 
 /** This is the root type of the parsley "backend": it represents a combinator tree
   * where the join-points in the tree (recursive or otherwise) have been factored into
@@ -76,7 +77,7 @@ private [deepembedding] trait StrictParsley[+A] {
       *
       * By default, this method just returns this parser unchanged.
       */
-    protected [deepembedding] def optimise: StrictParsley[A] = this
+    protected [deepembedding] def optimise(implicit @unused lets: LetMap): StrictParsley[A] = this
 
     /** Should this parser be inlined if it is shared?
       *
@@ -273,7 +274,7 @@ private [deepembedding] class CodeGenState(val numRefs: Int)(implicit letMap: Le
         label
     })
 
-    def getBody[A](sub: Let[A]): StrictParsley[A] = letMap.bodies(sub).asInstanceOf[StrictParsley[A]]
+    def getBody[A](sub: Let[A]): StrictParsley[A] = letMap.findBody(sub).get.asInstanceOf[StrictParsley[A]]
 
     /** Returns the next shared-parser that has been refered during code generation */
     def nextLet(): (Let[?], Boolean, Int) = queue.remove(0)

parsley/shared/src/main/scala/parsley/internal/deepembedding/frontend/LazyParsley.scala

@@ -281,6 +281,8 @@ private [deepembedding] final class LetMap private (letGen: Map[LazyParsley[?],
             }
     }
 
+    def findBody(let: backend.Let[?]): Option[StrictParsley[?]] = bodyMap.get(let)
+
     def bodies: Map[backend.Let[?], StrictParsley[?]] = bodyMap.toMap
 
     // $COVERAGE-OFF$