fix: let GumTreeDiff update the line numbers in the labels

Author: ibbem

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

@@ -2,12 +2,14 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 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.Time;
 import org.variantsync.diffdetective.variation.diff.VariationDiff; // For Javadoc
 
 /**
@@ -82,6 +84,67 @@ public List<String> getTrailingLines() {
         return getDiffTrailingLines().stream().map(Line::content).toList();
     }
 
+    /**
+     * Returns a deep copy where the line numbers at {@code time} are set to
+     * {@link DiffLineNumber#InvalidLineNumber}.
+     */
+    @Override
+    public DiffLinesLabel withoutTimeDependentState(Time time) {
+        return new DiffLinesLabel(
+            mapWithoutTimeDependentState(getDiffLines(), time),
+            mapWithoutTimeDependentState(getDiffTrailingLines(), time)
+        );
+    }
+
+    private List<Line> mapWithoutTimeDependentState(List<Line> lines, Time time) {
+        return lines
+            .stream()
+            .map(line -> new Line(
+                line.content(),
+                line.lineNumber().withLineNumberAtTime(DiffLineNumber.InvalidLineNumber, time)
+            ))
+            .toList();
+    }
+
+    /**
+     * Returns a deep copy where the line numbers at {@code time} are copied from
+     * {@code otherLabel}. The number of lines and their content must be identical in {@code this}
+     * and {@code otherLabel}.
+     *
+     * @see withoutTimeDependentState
+     */
+    @Override
+    public DiffLinesLabel withTimeDependentStateFrom(Label otherLabel, Time time) {
+        DiffLinesLabel other = (DiffLinesLabel) otherLabel;
+
+        return new DiffLinesLabel(
+            zipWithTimeDependentStateFrom(this.getDiffLines(), other.getDiffLines(), time),
+            zipWithTimeDependentStateFrom(this.getDiffTrailingLines(), other.getDiffTrailingLines(), time)
+        );
+    }
+
+    private static List<Line> zipWithTimeDependentStateFrom(List<Line> linesA, List<Line> linesB, Time time) {
+        List<Line> result = new ArrayList<>(linesA.size());
+
+        Iterator<Line> itA = linesA.iterator();
+        Iterator<Line> itB = linesA.iterator();
+        while (itA.hasNext() && itB.hasNext()) {
+            Line lineA = itA.next();
+            Line lineB = itB.next();
+
+            Assert.assertEquals(lineA.content(), lineB.content());
+            result.add(new Line(
+                lineA.content(),
+                lineB.lineNumber().withLineNumberAtTime(lineB.lineNumber().atTime(time), time)
+            ));
+        }
+
+        Assert.assertFalse(itA.hasNext());
+        Assert.assertFalse(itB.hasNext());
+
+        return result;
+    }
+
     @Override
     public String toString() {
         return lines

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

@@ -2,6 +2,8 @@
 
 import java.util.List;
 
+import org.variantsync.diffdetective.util.Assert;
+import org.variantsync.diffdetective.variation.diff.Time;
 import org.variantsync.diffdetective.variation.diff.VariationDiff; // For Javadoc
 import org.variantsync.diffdetective.variation.tree.VariationTree; // For Javadoc
 
@@ -19,6 +21,29 @@ public interface Label {
      * For example, {@code #endif}s are stored as trailing lines.
      */
     List<String> getTrailingLines();
+
+    /**
+     * Returns a deep copy where the state that is only valid at {@code time} is set to its default
+     * value. Note that not all implementations need to have time dependent state.
+     *
+     * @see withTimeDependentStateFrom
+     */
+    default Label withoutTimeDependentState(Time time) {
+        return this.clone();
+    }
+
+    /**
+     * Returns a deep copy where the state that is only valid at {@code time} is copied from
+     * {@code other}. All time independent state must be equal in {@code this} and {@code other}.
+     * Note that not all implementations need to have time dependent state.
+     *
+     * @see withoutTimeDependentState
+     */
+    default Label withTimeDependentStateFrom(Label other, Time time) {
+        Assert.assertEquals(this, other);
+        return this.clone();
+    }
+
     /**
      * Creates a deep copy of this label.
      */

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

@@ -14,7 +14,6 @@
 import org.variantsync.functjonal.Cast;
 
 import java.util.*;
-import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
@@ -393,12 +392,13 @@ public DiffNode<L> split(Time time) {
             getFromLine().as(otherDiffType),
             getToLine().as(otherDiffType),
             getFormula(),
-            Cast.unchecked(label.clone())
+            Cast.unchecked(label.withoutTimeDependentState(time.other()))
         );
 
         this.diffType = otherDiffType.inverse();
         this.from = this.from.as(this.diffType);
         this.to = this.to.as(this.diffType);
+        this.setLabel(Cast.unchecked(this.getLabel().withoutTimeDependentState(time)));
 
         other.addChildren(this.removeChildren(time), time);
         getParent(time).replaceChild(this, other, time);
@@ -417,14 +417,13 @@ public DiffNode<L> split(Time time) {
      * Merges {@code other} into this node.
      * {@code other} is removed from the graph and this node inherits all of its edges. This
      * node and {@code other} need to be compatible (exist at different times and have the
-     * same {@link getNodeType node type}).
+     * same {@link getNodeType node type} and compatible {@link getLabel labels}).
      * <p>
      * Both {@code this} and {@code other} must not be {@link isRoot the root}.
      *
      * @param other the node which is removed from the graph
-     * @param joinLabels returns a label that should represent the two passed labels
      */
-    public void join(DiffNode<L> other, BiFunction<L, L, L> joinLabels) {
+    public void join(DiffNode<L> other) {
         Time time = switch (diffType) {
             case ADD -> BEFORE;
             case REM -> AFTER;
@@ -436,7 +435,7 @@ public void join(DiffNode<L> other, BiFunction<L, L, L> joinLabels) {
         Assert.assertFalse(other.isRoot());
 
         diffType = DiffType.NON;
-        label.setInnerLabel(joinLabels.apply(getLabel(), other.getLabel()));
+        setLabel(Cast.unchecked(getLabel().withTimeDependentStateFrom(other.getLabel(), time)));
 
         setFromLine(getFromLine().withLineNumberAtTime(other.getFromLine().atTime(AFTER), AFTER));
         setToLine(getToLine().withLineNumberAtTime(other.getToLine().atTime(AFTER), AFTER));

src/main/java/org/variantsync/diffdetective/variation/diff/construction/GumTreeDiff.java

@@ -11,6 +11,7 @@
 import org.variantsync.diffdetective.util.Assert;
 import org.variantsync.diffdetective.variation.Label;
 import org.variantsync.diffdetective.variation.diff.DiffNode;
+import org.variantsync.diffdetective.variation.diff.Time;
 import org.variantsync.diffdetective.variation.diff.VariationDiff;
 import org.variantsync.diffdetective.variation.diff.source.VariationTreeDiffSource;
 import org.variantsync.diffdetective.variation.diff.traverse.VariationDiffTraversal;
@@ -22,7 +23,6 @@
 import java.util.Map;
 
 import static org.variantsync.diffdetective.variation.diff.DiffType.ADD;
-import static org.variantsync.diffdetective.variation.diff.DiffType.REM;
 import static org.variantsync.diffdetective.variation.diff.Time.AFTER;
 import static org.variantsync.diffdetective.variation.diff.Time.BEFORE;
 
@@ -124,8 +124,7 @@ private static <L extends Label> void removeUnmapped(MappingStore mappings, Vari
             Tree dst = mappings.getDstForSrc(node);
             if (dst == null || !dst.getLabel().equals(node.getLabel())) {
                 var diffNode = Cast.<Tree, VariationDiffAdapter<L>>unchecked(node).getDiffNode();
-                diffNode.diffType = REM;
-                diffNode.drop(AFTER);
+                diffNode.split(AFTER).drop();
             }
         }
     }
@@ -157,7 +156,7 @@ private static <L extends Label> void addUnmapped(MappingStore mappings, DiffNod
                 new DiffLineNumber(DiffLineNumber.InvalidLineNumber, from, from),
                 new DiffLineNumber(DiffLineNumber.InvalidLineNumber, to, to),
                 variationNode.getFormula(),
-                Cast.unchecked(variationNode.getLabel().clone())
+                Cast.unchecked(variationNode.getLabel().withoutTimeDependentState(BEFORE))
             );
         } else {
             diffNode = Cast.<Tree, VariationDiffAdapter<L>>unchecked(src).getDiffNode();
@@ -168,6 +167,7 @@ private static <L extends Label> void addUnmapped(MappingStore mappings, DiffNod
 
             diffNode.setFromLine(diffNode.getFromLine().withLineNumberAtTime(afterNode.getVariationNode().getLineRange().fromInclusive(), AFTER));
             diffNode.setToLine(diffNode.getToLine().withLineNumberAtTime(afterNode.getVariationNode().getLineRange().toExclusive(), AFTER));
+            diffNode.setLabel(Cast.unchecked(diffNode.getLabel().withTimeDependentStateFrom(afterNode.getVariationNode().getLabel(), Time.AFTER)));
         }
         parent.addChild(diffNode, AFTER);
 
@@ -220,11 +220,7 @@ public static <L extends Label> DiffNode<L> improveMatching(DiffNode<L> tree, Ma
                         afterNode.split(BEFORE);
                     }
 
-                    beforeNode.join(afterNode, (beforeLabel, afterLabel) -> {
-                        Assert.assertEquals(beforeLabel.getLines(), afterLabel.getLines());
-                        Assert.assertEquals(beforeLabel.getTrailingLines(), afterLabel.getTrailingLines());
-                        return beforeLabel;
-                    });
+                    beforeNode.join(afterNode);
                 }
 
                 Assert.assertTrue(beforeNode.isNon());