refactor: directly pass the time to popIfChain in the diff parser

Author: ibbem

src/main/java/org/variantsync/diffdetective/variation/diff/DiffType.java

@@ -1,11 +1,10 @@
 package org.variantsync.diffdetective.variation.diff;
 
 import org.apache.commons.lang3.function.FailableConsumer;
-import org.tinylog.Logger;
+import org.apache.commons.lang3.function.FailableRunnable;
 
 import java.util.Optional;
 import java.util.Set;
-import java.util.function.Consumer;
 
 /**
  * Type of change made to an artifact (e.g., a line of text in a text-based diff).
@@ -70,8 +69,9 @@ public static Optional<DiffType> thatExistsOnlyAtAll(final Set<Time> t) {
      *       exists before and after the edit (DiffType = NON).
      * @param ifExistsBefore Procedure to run if the edited artifact existed before the edit (DiffType != ADD).
      * @param ifExistsAfter Procedure to run if the edited artifact exists after the edit (DiffType != REM).
+     * @throws T iff {@code ifExistsBefore} or {@code ifExistsAfter} throws {@code E}
      */
-    public void forAllTimesOfExistence(final Runnable ifExistsBefore, final Runnable ifExistsAfter) {
+    public <T extends Throwable> void forAllTimesOfExistence(final FailableRunnable<T> ifExistsBefore, final FailableRunnable<T> ifExistsAfter) throws T {
         if (this != DiffType.ADD) {
             ifExistsBefore.run();
         }
@@ -84,8 +84,9 @@ public void forAllTimesOfExistence(final Runnable ifExistsBefore, final Runnable
      * Runs the given procedure for any time at which elements with this diff type exist.
      * The consumer will be invoked at least once and at most twice.
      * @param t Procedure to run for each time elements with this diff type exist.
+     * @throws T iff {@code t} throws {@code E}
      */
-    public void forAllTimesOfExistence(final Consumer<Time> t) {
+    public <T extends Throwable> void forAllTimesOfExistence(final FailableConsumer<Time, T> t) throws T {
         forAllTimesOfExistence(
                 () -> t.accept(Time.BEFORE),
                 () -> t.accept(Time.AFTER)

src/main/java/org/variantsync/diffdetective/variation/diff/parse/VariationDiffParser.java

@@ -328,8 +328,8 @@ private void parseLine(
 
             // Do not create a node for ENDIF, but update the line numbers of the closed if-chain
             // and remove that if-chain from the relevant stacks.
-            diffType.forAllTimesOfExistence(beforeStack, afterStack, stack ->
-                    popIfChain(stack, fromLine, line)
+            diffType.forAllTimesOfExistence(time ->
+                    popIfChain(time, fromLine, line)
             );
         } else if (options.collapseMultipleCodeLines()
                 && annotation.type() == AnnotationType.None
@@ -357,20 +357,22 @@ private void parseLine(
     }
 
     /**
-     * Pop {@code stack} until an IF node is popped.
+     * Pop the stack until an IF node is popped.
      * If there were ELSEs or ELIFs between an IF and an ENDIF, they were placed on the stack and
      * have to be popped now. The {@link DiffNode#getToLine() end line numbers} are adjusted
      *
-     * @param stack          the stack which should be popped
+     * @param time           which stack to pop the if chain (i.e., {@link beforeStack} or {@link afterStack})
      * @param elseLineNumber the first line of the else which causes this IF to be popped
      * @param line           the line containing the endif
      * @throws DiffParseException if {@code stack} doesn't contain an IF node
      */
     private void popIfChain(
-            Stack<DiffNode<DiffLinesLabel>> stack,
+            Time time,
             DiffLineNumber elseLineNumber,
             LogicalLine line
     ) throws DiffParseException {
+        Stack<DiffNode<DiffLinesLabel>> stack = time.match(beforeStack, afterStack);
+
         DiffLineNumber previousLineNumber = elseLineNumber;
         do {
             DiffNode<DiffLinesLabel> annotation = stack.peek();
@@ -381,19 +383,19 @@ private void popIfChain(
                 for (int i = 0; i < line.getLines().size(); i++) {
                     list.add(line.getLines().get(i).content());
                 }
-                annotation.setEndIf(list, stack == beforeStack ? Time.BEFORE : Time.AFTER);
+                annotation.setEndIf(list, time);
             }
 
             // Set the line number of now closed annotations to the beginning of the
             // following annotation.
             annotation.setToLine(new DiffLineNumber(
                     Math.max(previousLineNumber.inDiff(), annotation.getToLine().inDiff()),
-                    stack == beforeStack
-                            ? previousLineNumber.beforeEdit()
-                            : annotation.getToLine().beforeEdit(),
-                    stack == afterStack
-                            ? previousLineNumber.afterEdit()
-                            : annotation.getToLine().afterEdit()
+                    time.match(
+                        previousLineNumber.beforeEdit(),
+                        annotation.getToLine().beforeEdit()),
+                    time.match(
+                        annotation.getToLine().afterEdit(),
+                        previousLineNumber.afterEdit())
             ));
 
             previousLineNumber = annotation.getFromLine();