refactor: move joinNode into DiffNode

This makes it more discoverable and consistent with `DiffNode.split`.

Author: ibbem

src/main/java/org/variantsync/diffdetective/util/Assert.java

@@ -86,7 +86,7 @@ public static void assertFalse(boolean condition, String errorMessage) {
     }
 
     /** Throws {@link AssertionError} with {@code errorMessage} as error message. */
-    public static void fail(String errorMessage) {
+    public static <T> T fail(String errorMessage) {
         throw new AssertionError(errorMessage);
     }
 

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

@@ -14,6 +14,7 @@
 import org.variantsync.functjonal.Cast;
 
 import java.util.*;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
@@ -412,6 +413,35 @@ public DiffNode<L> split(Time time) {
         return other;
     }
 
+    /**
+     * 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}).
+     * <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) {
+        Time time = switch (diffType) {
+            case ADD -> BEFORE;
+            case REM -> AFTER;
+            case NON -> Assert.fail("Attempt to join a node that already exists at both times.");
+        };
+        Assert.assertEquals(other.diffType, DiffType.thatExistsOnlyAt(time));
+        Assert.assertEquals(getNodeType(), other.getNodeType());
+        Assert.assertFalse(isRoot());
+        Assert.assertFalse(other.isRoot());
+
+        diffType = DiffType.NON;
+        label.setInnerLabel(joinLabels.apply(getLabel(), other.getLabel()));
+
+        this.stealChildrenOf(other);
+        other.getParent(time).replaceChild(other, this, time);
+    }
+
     /**
      * Replaces a child of this node with another node.
      * <p>

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

@@ -22,7 +22,6 @@
 import java.util.Map;
 
 import static org.variantsync.diffdetective.variation.diff.DiffType.ADD;
-import static org.variantsync.diffdetective.variation.diff.DiffType.NON;
 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;
@@ -218,7 +217,7 @@ public static <L extends Label> DiffNode<L> improveMatching(DiffNode<L> tree, Ma
                         afterNode.split(BEFORE);
                     }
 
-                    joinNode(beforeNode, afterNode);
+                    beforeNode.join(afterNode, (beforeLabel, afterLabel) -> beforeLabel);
                 }
 
                 Assert.assertTrue(beforeNode.isNon());
@@ -229,27 +228,6 @@ public static <L extends Label> DiffNode<L> improveMatching(DiffNode<L> tree, Ma
         return tree;
     }
 
-    /**
-     * Merges {@code afterNode} into {@code beforeNode} such that {@code beforeNode.isNon() ==
-     * true}. Essentially, an implicit matching is inserted between {@code beforeNode} and {@code
-     * afterNode}.
-     *
-     * This method doesn't change the {@code BEFORE} and {@code AFTER} projection of {@code
-     * beforeNode}.
-     *
-     * @param beforeNode the node which is will exist {@code BEFORE} and {@code AFTER} the edit
-     * @param afterNode the node which is discarded
-     */
-    private static <L extends Label> void joinNode(DiffNode<L> beforeNode, DiffNode<L> afterNode) {
-        Assert.assertTrue(beforeNode.isRem());
-        Assert.assertTrue(afterNode.isAdd());
-
-        beforeNode.diffType = NON;
-
-        beforeNode.stealChildrenOf(afterNode);
-        afterNode.getParent(AFTER).replaceChild(afterNode, beforeNode, AFTER);
-    }
-
     /**
      * Makes the implicit matching of a {@code VariationDiff} explicit.
      *