Evaluate assert/discriminator expressions after groupContent

daffodil-core/src/main/scala/org/apache/daffodil/core/dsom/DFDLStatementMixin.scala

@@ -216,8 +216,8 @@ trait ProvidesDFDLStatementMixin extends ThrowsSDE with HasTermCheck {
 
   final lazy val patternStatements: Seq[DFDLStatement] = patternAsserts ++ patternDiscrims
 
-  final lazy val lowPriorityStatements: Seq[DFDLStatement] =
-    setVariableStatements ++ nonPatternAsserts ++ nonPatternDiscrims
+  final lazy val expressionStatements: Seq[DFDLStatement] =
+    nonPatternAsserts ++ nonPatternDiscrims
 
   final protected lazy val localStatements = this.annotationObjs.collect {
     case st: DFDLStatement => st

daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/Grammar.scala

@@ -92,7 +92,11 @@ class SeqComp private (context: SchemaComponent, children: Seq[Gram])
   final override lazy val parser = {
     if (parserChildren.isEmpty) new NadaParser(context.runtimeData)
     else if (parserChildren.length == 1) parserChildren.head
-    else new SeqCompParser(context.runtimeData, parserChildren.toVector)
+    else
+      new SeqCompParser(
+        context.runtimeData,
+        parserChildren.toVector,
+      )
   }
 
   lazy val unparserChildren = {

daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/HasStatementsGrammarMixin.scala

@@ -23,11 +23,11 @@ trait HasStatementsGrammarMixin extends GrammarMixin { self: Term =>
 
   // Includes setVariable as well as assert/discriminator statements that
   // are not testKind="pattern"
-  private lazy val lowPriorityStatementGrams = lowPriorityStatements.map { _.gram(self) }
+  private lazy val expressionStatementGrams = expressionStatements.map { _.gram(self) }
 
-  final lazy val dfdlLowPriorityStatementEvaluations =
-    prod("dfdlStatementEvaluations", lowPriorityStatementGrams.length > 0) {
-      lowPriorityStatementGrams.fold(mt) { _ ~ _ }
+  final lazy val dfdlExpressionStatementEvaluations =
+    prod("dfdlExpressionStatementEvaluations", expressionStatementGrams.length > 0) {
+      expressionStatementGrams.fold(mt) { _ ~ _ }
     }
 
   // assert/discriminator statements with testKind="pattern"

daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/ModelGroupGrammarMixin.scala

@@ -50,8 +50,10 @@ trait ModelGroupGrammarMixin
     // See 9.5 Evaluation Order for Statement Annotations
     dfdlPatternStatementEvaluations ~ // Assert and Discriminator statements with testKind="pattern"
       dfdlScopeBegin ~ // newVariableInstance
-      dfdlLowPriorityStatementEvaluations ~ // setVariable and the rest of the Assert and Discriminator statements
-      groupLeftFraming ~ groupContentWithInitiatorTerminator ~ groupRightFraming ~ dfdlScopeEnd
+      dfdlSetVariableStatements ~
+      groupLeftFraming ~ groupContentWithInitiatorTerminator ~ groupRightFraming ~
+      dfdlExpressionStatementEvaluations ~ // The rest of the Assert and Discriminator statements
+      dfdlScopeEnd
   }
 
   private lazy val groupContentWithInitiatorTerminator =

daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/TermGrammarMixin.scala

@@ -48,6 +48,15 @@ trait TermGrammarMixin extends AlignedMixin with BitOrderMixin with TermRuntime1
     newVarEnds.fold(mt) { _ ~ _ }
   }
 
+  private lazy val setVars = this.setVariableStatements
+
+  private lazy val setVarGrams = setVars.map { _.gram(self) }
+
+  protected lazy val dfdlSetVariableStatements =
+    prod("dfdlSetVariableStatments", setVarGrams.length > 0) {
+      setVarGrams.fold(mt) { _ ~ _ }
+    }
+
   /**
    * Mandatory text alignment or mta
    *

daffodil-core/src/main/scala/org/apache/daffodil/core/grammar/primitives/SequenceCombinator.scala

@@ -71,7 +71,9 @@ class OrderedSequence(sq: SequenceTermBase, sequenceChildrenArg: Seq[SequenceChi
   // the mta parser differently to avoid this
   private lazy val sepUnparser = sepGram.unparser
 
-  lazy val sequenceChildren = sequenceChildrenArg.toVector
+  lazy val sequenceChildren = {
+    sequenceChildrenArg.toVector
+  }
 
   override lazy val parser: Parser = sq.hasSeparator match {
     case true =>

daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/PState.scala

@@ -588,6 +588,24 @@ final class PState private (
     }
   }
 
+  /**
+   * This function is used for cases where a parse must be performed after there
+   * has already been a failed parse of an enclosing element/sequence. Most
+   * common example of this would be a choice branch containing a sequence with
+   * an annotated assert expression. According to 9.5.2 of the DFDL spec this
+   * assert expression needs to be parsed regardless of whether or not the
+   * enclosing sequence content parses or not as the assert expression may be
+   * used as a discriminator for the choice branch.
+   */
+  def withTempSuccess(func: (PState) => Unit): ProcessorResult = {
+    val priorProcessorStatus = processorStatus
+    setSuccess()
+    func(this)
+    val funcStatus = processorStatus
+    _processorStatus = priorProcessorStatus
+    funcStatus
+  }
+
   def suspensions = Seq.empty
 }
 

daffodil-runtime1/src/main/scala/org/apache/daffodil/runtime1/processors/parsers/Parser.scala

@@ -227,26 +227,31 @@ abstract class CombinatorParser(override val context: RuntimeData)
   extends Parser
   with CombinatorProcessor
 
-final class SeqCompParser(context: RuntimeData, val childParsers: Vector[Parser])
-  extends CombinatorParser(context) {
+final class SeqCompParser(
+  context: RuntimeData,
+  val childParsers: Vector[Parser],
+) extends CombinatorParser(context) {
   override lazy val runtimeDependencies = Vector()
   override def childProcessors = childParsers
 
   override def nom = "seq"
 
-  val numChildParsers = childParsers.size
+  val discrimExpressions = childParsers.collect{ case ae: AssertExpressionEvaluationParser if (ae.discrim) => ae }
+  val nonDiscrimChildren = childParsers.diff(discrimExpressions)
 
   def parse(pstate: PState): Unit = {
-    var i: Int = 0
-    while (i < numChildParsers) {
-      val parser = childParsers(i)
-      parser.parse1(pstate)
-      if (pstate.processorStatus ne Success)
-        return
-      i += 1
+    for (p <- nonDiscrimChildren) {
+      if (pstate.processorStatus eq Success)
+        p.parse1(pstate)
     }
-  }
 
+    discrimExpressions.foreach { d =>
+      if (pstate.processorStatus eq Success)
+        d.parse1(pstate)
+      else
+        pstate.withTempSuccess(d.parse1)
+    }
+  }
 }
 
 class ChoiceParser(ctxt: RuntimeData, val childParsers: Vector[Parser])