refactor: store endifs in the label

This is necessary because when `endif`s are fully integrated (included
in deep copies, assertConsistency and comparisons) some assumptions are
broken (which fields are compare by `DiffNode`s) which is especially
annoying in `BadVDiff`. By storing the `endif`s in the label instead of
the nodes directly, no user needs to be updated except if the label is
actually modified (there seems to be no instance of that in this code
base).

This also generalized the concept to trailing lines instead of limiting
the concept to endifs. This is also kind of necessary because not all
labels know the node type.

Depending on the user of `VariationDiffParser`, this might be a breaking
change because we now consider the `#endif` line as part of the label.
Hence, if the `#endif` line changed (e.g., a comment is added) the node
can no longer be `DiffType.NON` but we instead split the node into two
`DiffType.REM` and `DiffType.ADD` nodes. Artifacts which are below such
a split node are thus classified as refactored instead of unchanged.

Author: ibbem

src/main/java/org/variantsync/diffdetective/variation/DiffLinesLabel.java

@@ -6,6 +6,7 @@
 import java.util.stream.Collectors;
 
 import org.variantsync.diffdetective.diff.text.DiffLineNumber;
+import org.variantsync.diffdetective.util.Assert;
 import org.variantsync.diffdetective.util.StringUtils;
 import org.variantsync.diffdetective.variation.diff.VariationDiff; // For Javadoc
 
@@ -18,6 +19,7 @@
  */
 public class DiffLinesLabel implements Label {
     private final List<Line> lines;
+    private List<Line> trailingLines;
 
     public record Line(String content, DiffLineNumber lineNumber) {
         public static Line withInvalidLineNumber(String content) {
@@ -30,7 +32,15 @@ public DiffLinesLabel() {
     }
 
     public DiffLinesLabel(List<Line> lines) {
+        this(lines, new ArrayList<>());
+    }
+
+    public DiffLinesLabel(List<Line> lines, List<Line> trailingLines) {
+        Assert.assertNotNull(lines);
+        Assert.assertNotNull(trailingLines);
+
         this.lines = lines;
+        this.trailingLines = trailingLines;
     }
 
     public static DiffLinesLabel withInvalidLineNumbers(List<String> lines) {
@@ -53,11 +63,25 @@ public List<Line> getDiffLines() {
         return lines;
     }
 
+    public void setDiffTrailingLines(List<Line> newLines) {
+        Assert.assertNotNull(newLines);
+        trailingLines = newLines;
+    }
+
+    public List<Line> getDiffTrailingLines() {
+        return trailingLines;
+    }
+
     @Override
     public List<String> getLines() {
         return getDiffLines().stream().map(Line::content).toList();
     }
 
+    @Override
+    public List<String> getTrailingLines() {
+        return getDiffTrailingLines().stream().map(Line::content).toList();
+    }
+
     @Override
     public String toString() {
         return lines
@@ -68,6 +92,15 @@ public String toString() {
 
     @Override
     public DiffLinesLabel clone() {
-        return new DiffLinesLabel(new ArrayList<>(lines));
+        return new DiffLinesLabel(new ArrayList<>(lines), new ArrayList<>(trailingLines));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DiffLinesLabel that = (DiffLinesLabel) o;
+        return lines.equals(that.lines) &&
+            trailingLines.equals(that.trailingLines);
     }
 }

src/main/java/org/variantsync/diffdetective/variation/Label.java

@@ -9,6 +9,18 @@
  * Base interface for labels of {@link VariationTree}s and {@link VariationDiff}s.
  */
 public interface Label {
+    /**
+     * Returns the lines which need to be printed before the children of a node.
+     * Most lines associated with a node should be included in this list, for example, {@code #if}s are stored here.
+     */
     List<String> getLines();
+    /**
+     * Returns the lines which need to be printed after the children of a node.
+     * For example, {@code #endif}s are stored as trailing lines.
+     */
+    List<String> getTrailingLines();
+    /**
+     * Creates a deep copy of this label.
+     */
     Label clone();
 }

src/main/java/org/variantsync/diffdetective/variation/LinesLabel.java

@@ -5,30 +5,46 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import org.variantsync.diffdetective.util.Assert;
 import org.variantsync.diffdetective.util.StringUtils;
 
 /**
  * A label containing a list of lines represented as {@code String}s.
  */
 public class LinesLabel implements Label {
     private final List<String> lines;
+    private final List<String> trailingLines;
 
     public LinesLabel() {
-        this(new ArrayList<>());
+        this(new ArrayList<>(), new ArrayList<>());
     }
 
     public LinesLabel(List<String> lines) {
+        this(lines, new ArrayList<>());
+    }
+
+    public LinesLabel(List<String> lines, List<String> trailingLines) {
+        Assert.assertNotNull(lines);
+        Assert.assertNotNull(trailingLines);
+
         this.lines = lines;
+        this.trailingLines = trailingLines;
     }
 
     public static LinesLabel ofCodeBlock(String codeBlock) {
         return new LinesLabel(Arrays.asList(StringUtils.LINEBREAK_REGEX.split(codeBlock, -1)));
     }
 
+    @Override
     public List<String> getLines() {
         return lines;
     }
 
+    @Override
+    public List<String> getTrailingLines() {
+        return trailingLines;
+    }
+
     @Override
     public String toString() {
         return lines
@@ -38,6 +54,15 @@ public String toString() {
 
     @Override
     public LinesLabel clone() {
-        return new LinesLabel(new ArrayList<>(lines));
+        return new LinesLabel(new ArrayList<>(lines), new ArrayList<>(trailingLines));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LinesLabel that = (LinesLabel) o;
+        return lines.equals(that.lines) &&
+            trailingLines.equals(that.trailingLines);
     }
 }

src/main/java/org/variantsync/diffdetective/variation/VariationLabel.java

@@ -2,6 +2,7 @@
 
 import java.util.List;
 
+import org.variantsync.diffdetective.util.Assert;
 import org.variantsync.diffdetective.variation.tree.HasNodeType;
 import org.variantsync.diffdetective.variation.tree.VariationTree; // For Javadoc
 import org.variantsync.functjonal.Cast;
@@ -23,6 +24,9 @@ public class VariationLabel<L extends Label> implements Label, HasNodeType {
     private L innerLabel;
 
     public VariationLabel(NodeType type, L innerLabel) {
+        Assert.assertNotNull(type);
+        Assert.assertNotNull(innerLabel);
+
         this.type = type;
         this.innerLabel = innerLabel;
     }
@@ -40,6 +44,11 @@ public List<String> getLines() {
         return innerLabel.getLines();
     }
 
+    @Override
+    public List<String> getTrailingLines() {
+        return innerLabel.getTrailingLines();
+    }
+
     @Override
     public NodeType getNodeType() {
         return type;
@@ -49,9 +58,18 @@ public NodeType getNodeType() {
     public VariationLabel<L> clone() {
         return new VariationLabel<L>(type, Cast.unchecked(innerLabel.clone()));
     }
-    
+
     @Override
     public String toString() {
-    	return innerLabel.toString();
+        return innerLabel.toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        VariationLabel<?> that = (VariationLabel<?>) o;
+        return type.equals(that.type) &&
+            innerLabel.equals(that.innerLabel);
     }
 }

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

@@ -51,8 +51,6 @@ public class DiffNode<L extends Label> implements HasNodeType {
 
     private Node featureMapping;
 
-    private List<String>[] endIf = new List[2];
-
     /**
      * The parents {@link DiffNode} before and after the edit.
      * This array has to be indexed by {@code Time.ordinal()}
@@ -135,8 +133,6 @@ public static <L extends Label> DiffNode<L> createArtifact(DiffType diffType, Di
 
     /**
      * Returns the lines in the diff that are represented by this DiffNode as a single text.
-     *
-     * @see getEndIf
      */
     public L getLabel() {
         return label.getInnerLabel();
@@ -150,24 +146,6 @@ public void setLabel(L newLabel) {
         label.setInnerLabel(newLabel);
     }
 
-    /**
-     * Returns the line with the endif of the corresponding if, if the node is an if node, otherwise null
-     * @param time when the returned endif exists
-     * @return String, the Line with endif
-     */
-    public List<String> getEndIf(Time time) {
-        return endIf[time.ordinal()];
-    }
-
-    /**
-     * Sets the line with the endif of the corresponding if, if the node is an if node
-     * @param endIf String, the Line with endif
-     * @param time when {@code endIf} exists
-     */
-    public void setEndIf(List<String> endIf, Time time) {
-        this.endIf[time.ordinal()] = endIf;
-    }
-
     /**
      * Gets the first {@code if} node in the path from the root to this node at the time
      * {@code time}.
@@ -367,6 +345,64 @@ public void stealChildrenOf(final DiffNode<L> other) {
         Time.forAll(time -> addChildren(other.removeChildren(time), time));
     }
 
+    /**
+     * Splits an {@link isNon unmodified} node into a removed and an added node.
+     * Only one new node is created. Depending on {@code time}, {@code this} is changed into
+     * {@link DiffType#ADD} for {@link Time#BEFORE} or {@link DiffType#REM} for {@link Time#AFTER}.
+     *
+     * @param time decides which node is created
+     * @return the new node that exists at time {@code time}.
+     */
+    public DiffNode<L> split(Time time) {
+        Assert.assertTrue(isNon());
+
+        DiffType otherDiffType = DiffType.thatExistsOnlyAt(time);
+        var other = new DiffNode<L>(
+            otherDiffType,
+            getNodeType(),
+            getFromLine().as(otherDiffType),
+            getToLine().as(otherDiffType),
+            getFormula(),
+            Cast.unchecked(label.getInnerLabel().clone())
+        );
+
+        this.diffType = otherDiffType.inverse();
+        this.from = this.from.as(this.diffType);
+        this.to = this.to.as(this.diffType);
+
+        other.addChildren(this.removeChildren(time), time);
+        getParent(time).replaceChild(this, other, time);
+
+        // FIXME? If we allowed access to the backing node,
+        // we could preserve the identity of this projection by moving it to `other`.
+        this.projections[time.ordinal()] = null;
+
+        return other;
+    }
+
+    /**
+     * Replaces a child of this node with another node.
+     * <p>
+     * If {@code oldChild} is not a child of this node, nothing happens.
+     *
+     * @param oldChild the child that is removed
+     * @param newChild the child that is inserted
+     * @param time at which the child relation is changed
+     */
+    public void replaceChild(DiffNode<L> oldChild, DiffNode<L> newChild, Time time) {
+        Assert.assertNull(newChild.getParent(time));
+        Assert.assertTrue(newChild.getDiffType().existsAtTime(time));
+
+        for (ListIterator<DiffNode<L>> it = children[time.ordinal()].listIterator(); it.hasNext(); ) {
+            if (it.next() == oldChild) {
+                it.set(newChild);
+                newChild.parents[time.ordinal()] = oldChild.parents[time.ordinal()];
+                oldChild.parents[time.ordinal()] = null;
+                break;
+            }
+        }
+    }
+
     /**
      * Returns the parent of this node before or after the edit.
      */
@@ -775,7 +811,7 @@ public DiffNode<L> shallowCopy() {
             getFromLine(),
             getToLine(),
             getFormula(),
-            Cast.unchecked(label.clone())
+            Cast.unchecked(label.getInnerLabel().clone())
         );
     }
 
@@ -808,7 +844,7 @@ private static <L extends Label> boolean isSameAs(DiffNode<L> a, DiffNode<L> b,
                 a.getNodeType().equals(b.getNodeType()) &&
                 a.getFromLine().equals(b.getFromLine()) &&
                 a.getToLine().equals(b.getToLine()) &&
-                (a.getFormula() == null ? b.getFormula() == null : a.getFormula().equals(b.getFormula())) &&
+                Objects.equals(a.getFormula(), b.getFormula()) &&
                 a.getLabel().equals(b.getLabel())
         )) {
             return false;

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

@@ -121,9 +121,4 @@ public Node getFormula() {
     public int getID() {
         return getBackingNode().getID();
     }
-
-    @Override
-    public List<String> getEndIf() {
-        return getBackingNode().getEndIf(getTime());
-    }
 };

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

@@ -1,7 +1,5 @@
 package org.variantsync.diffdetective.variation.diff.parse;
 
-import java.util.ArrayList;
-import java.util.List;
 import org.apache.commons.lang3.function.FailableSupplier;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.lib.ObjectId;
@@ -379,11 +377,15 @@ private void popIfChain(
 
             // Save endif
             if (annotation.isIf()) {
-                List<String> list = new ArrayList<>();
-                for (int i = 0; i < line.getLines().size(); i++) {
-                    list.add(line.getLines().get(i).content());
+                var endIf = line.getLines();
+                var otherEndIf = annotation.getLabel().getDiffTrailingLines();
+
+                // Split the node if two different endif lines are associated to one if node.
+                if (!otherEndIf.isEmpty() && !endIf.equals(otherEndIf)) {
+                    annotation = annotation.split(time);
                 }
-                annotation.setEndIf(list, time);
+
+                annotation.getLabel().setDiffTrailingLines(endIf);
             }
 
             // Set the line number of now closed annotations to the beginning of the