fix: always preserve the child order in BadVDiff

It seems like `VariationDiffParser` never generates a variation diff
which triggers the bug in `BadVDiff` that doesn't preserve the child
order. Note that it should be possible to generate such variation diffs
with a tree matcher such as GumTree.

Author: ibbem

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

@@ -360,7 +360,6 @@ public List<DiffNode<L>> removeChildren(Time time) {
 
     /**
      * Removes all children from the given node and adds them as children to this node at the respective times.
-     * The order of children is not stable because first all before children are transferred and then all after children.
      * The given node will have no children afterwards.
      * @param other The node whose children should be stolen.
      */

src/main/java/org/variantsync/diffdetective/variation/diff/bad/BadVDiff.java

@@ -198,8 +198,18 @@ public static <L extends Label> BadVDiff<L> fromGood(VariationDiff<L> d) {
         record EdgeToConstruct<L extends Label>(
                 VariationTreeNode<L> child,
                 DiffNode<L> parent,
-                Time t
-        ) {}
+                Time t,
+                int index
+        ) {
+            public EdgeToConstruct(
+                VariationTreeNode<L> child,
+                DiffNode<L> parent,
+                Time t,
+                DiffNode<L> originalChild
+            ) {
+                this(child, parent, t, parent.indexOfChild(originalChild, t));
+            }
+        }
 
         final FromGoodNodeTranslation<L> nodeTranslation = new FromGoodNodeTranslation<>();
 
@@ -259,7 +269,7 @@ record EdgeToConstruct<L extends Label>(
 
                     nodeTranslation.put(diffNode, time, self);
 
-                    edgesToConstruct.add(new EdgeToConstruct<>(self, diffNode.getParent(time), time));
+                    edgesToConstruct.add(new EdgeToConstruct<>(self, diffNode.getParent(time), time, diffNode));
 
                     // further metadata to copy
                     lines.put(self, dRange);
@@ -283,16 +293,17 @@ record EdgeToConstruct<L extends Label>(
                  */
                 if (pbefore != null) {
                     edgesToConstruct.add(new EdgeToConstruct<>(
-                            self, pbefore, BEFORE
+                            self, pbefore, BEFORE, diffNode
                     ));
                 } else if (pafter != null) {
                     edgesToConstruct.add(new EdgeToConstruct<>(
-                            self, pafter, AFTER
+                            self, pafter, AFTER, diffNode
                     ));
                 }
             }
         });
 
+        edgesToConstruct.sort(Comparator.comparingInt(EdgeToConstruct::index));
         for (final EdgeToConstruct<L> e : edgesToConstruct) {
             nodeTranslation.get(e.parent, e.t).addChild(e.child);
         }
@@ -324,8 +335,18 @@ public VariationDiff<L> toGood() {
         record EdgeToConstruct<L extends Label>(
                 DiffNode<L> child,
                 VariationTreeNode<L> parent,
-                Time time
-        ) {}
+                Time time,
+                int index
+        ) {
+            public EdgeToConstruct(
+                DiffNode<L> child,
+                VariationTreeNode<L> parent,
+                Time time,
+                VariationTreeNode<L> originalChild
+            ) {
+                this(child, parent, time, parent.indexOfChild(originalChild));
+            }
+        }
 
         final List<EdgeToConstruct<L>>               edgesToConstruct = new ArrayList<>();
         final Map<VariationTreeNode<L>, DiffNode<L>> nodeTranslation  = new HashMap<>();
@@ -351,7 +372,7 @@ record EdgeToConstruct<L extends Label>(
 
                 nodeTranslation.put(vtnode, vGood);
                 coloring.get(vtnode).forAllTimesOfExistence(
-                        t -> edgesToConstruct.add(new EdgeToConstruct<>(vGood, parent, t))
+                        t -> edgesToConstruct.add(new EdgeToConstruct<>(vGood, parent, t, vtnode))
                 );
             } else {
                 // v was cloned.
@@ -369,14 +390,15 @@ record EdgeToConstruct<L extends Label>(
                 // invoke the callback for a single time:
                 // BEFORE for REM and AFTER for ADD.
                 vColor.forAllTimesOfExistence(
-                        t -> edgesToConstruct.add(new EdgeToConstruct<>(vGood, parent, t))
+                        t -> edgesToConstruct.add(new EdgeToConstruct<>(vGood, parent, t, vtnode))
                 );
                 badBuddyColor.forAllTimesOfExistence(
-                        t -> edgesToConstruct.add(new EdgeToConstruct<>(vGood, badBuddy.getParent(), t))
+                        t -> edgesToConstruct.add(new EdgeToConstruct<>(vGood, badBuddy.getParent(), t, badBuddy))
                 );
             }
         });
 
+        edgesToConstruct.sort(Comparator.comparingInt(EdgeToConstruct::index));
         for (final EdgeToConstruct<L> e : edgesToConstruct) {
             nodeTranslation.get(e.parent()).addChild(e.child(), e.time());
         }

src/test/java/BadVDiffTest.java

@@ -1,4 +1,5 @@
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.tinylog.Logger;
@@ -8,6 +9,12 @@
 import org.variantsync.diffdetective.variation.diff.VariationDiff;
 import org.variantsync.diffdetective.variation.diff.bad.BadVDiff;
 import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
+import org.variantsync.diffdetective.variation.diff.serialize.GraphFormat;
+import org.variantsync.diffdetective.variation.diff.serialize.LineGraphImport;
+import org.variantsync.diffdetective.variation.diff.serialize.LineGraphImportOptions;
+import org.variantsync.diffdetective.variation.diff.serialize.edgeformat.ChildOrderEdgeFormat;
+import org.variantsync.diffdetective.variation.diff.serialize.nodeformat.FullNodeFormat;
+import org.variantsync.diffdetective.variation.diff.serialize.treeformat.IndexedTreeFormat;
 
 import java.io.IOException;
 import java.nio.file.Path;
@@ -39,4 +46,21 @@ public void toGood_after_fromGood_idempotency(String filename) throws IOExceptio
 
         Assertions.assertTrue(initialVDiff.isSameAs(goodDiff));
     }
+
+    @Test
+    public void childOrderIsPreserved() throws IOException {
+        final Path fileGraphFile = resDir.resolve("childOrder.lg");
+        final var importOptions = new LineGraphImportOptions<DiffLinesLabel>(
+            GraphFormat.VARIATION_DIFF,
+            new IndexedTreeFormat(),
+            new FullNodeFormat(),
+            new ChildOrderEdgeFormat<>()
+        );
+
+        final VariationDiff<DiffLinesLabel> initialVDiff = LineGraphImport.fromFile(fileGraphFile, importOptions).get(0);
+        final var badDiff = BadVDiff.fromGood(initialVDiff);
+        final var goodDiff = badDiff.toGood();
+
+        Assertions.assertTrue(initialVDiff.isSameAs(goodDiff));
+    }
 }

src/test/resources/badvdiff/childOrder.lg

@@ -0,0 +1,13 @@
+t # 1
+v 16 NON;IF;(old: -1, diff: -1, new: -1);(old: -1, diff: -1, new: -1);True
+v 136 REM;IF;(old: 1, diff: 1, new: -1);(old: 5, diff: 7, new: -1);A;#if A
+v 264 REM;IF;(old: 2, diff: 3, new: -1);(old: 4, diff: 6, new: -1);X;#if X
+v 403 NON;ARTIFACT;(old: 3, diff: 5, new: 4);(old: 4, diff: 6, new: 5);;foo
+v 192 ADD;IF;(old: -1, diff: 2, new: 1);(old: -1, diff: 7, new: 5);B;#if B
+v 256 ADD;IF;(old: -1, diff: 3, new: 2);(old: -1, diff: 4, new: 3);X;#if X
+e 136 16 b;0,-1
+e 264 136 b;0,-1
+e 403 264 b;0,-1
+e 192 16 a;-1,0
+e 256 192 a;-1,0
+e 403 192 a;-1,1