Remove NodeType.ROOT in favor of an implicit root

The root node is now implicitly characterised by having no parents (no
after and no before parent). This makes it consistent with some
representations of `DiffTree`s where the root node is printed as an IF
node with the feature mapping `true`.

All representations which did explicitly mark the root node are now
printing an IF node and do not mark it specially. Most notably is the
line graph representation which did encode `NodeType.ROOT` in the node
ID (this is the reason why many IDs in the test cases changed).

For backwards compatibility the `isAnnotation` function of `DiffNode` is
still returning false on root nodes. This is subject to further
refactoring, mostly necessary to handle the difference between
`DiffGraph`s and actual trees.

Author: ibbem

src/main/java/org/variantsync/diffdetective/diff/difftree/DiffGraph.java

@@ -12,13 +12,6 @@ public final class DiffGraph {
 
     private DiffGraph() {}
 
-    /**
-     * Returns true iff the given node has no parents (i.e., is a root candidate).
-     */
-    public static boolean hasNoParents(final DiffNode node) {
-        return node.getBeforeParent() == null && node.getAfterParent() == null;
-    }
-
     /**
      * Invokes {@link DiffGraph#fromNodes(Collection, DiffTreeSource)} )} with an unknown DiffTreeSource.
      */
@@ -37,7 +30,7 @@ public static DiffTree fromNodes(final Collection<DiffNode> nodes, final DiffTre
         final DiffNode newRoot = DiffNode.createRoot();
         newRoot.setLabel(DIFFGRAPH_LABEL);
         nodes.stream()
-                .filter(DiffGraph::hasNoParents)
+                .filter(DiffNode::isRoot)
                 .forEach(n ->
                         n.diffType.matchBeforeAfter(
                                 () -> newRoot.addBeforeChild(n),

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

@@ -110,7 +110,7 @@ public DiffNode(DiffType diffType, NodeType nodeType,
     public static DiffNode createRoot() {
         return new DiffNode(
                 DiffType.NON,
-                NodeType.ROOT,
+                NodeType.IF,
                 new DiffLineNumber(1, 1, 1),
                 DiffLineNumber.Invalid(),
                 FixTrueFalse.True,
@@ -968,17 +968,17 @@ public boolean isElse() {
     }
 
     /**
-     * Returns true if this node is a root node (i.e., it has {@link NodeType#ROOT}.
+     * Returns true if this node is a root node (has no parents).
      */
     public boolean isRoot() {
-        return this.nodeType.equals(NodeType.ROOT);
+        return getBeforeParent() == null && getAfterParent() == null;
     }
 
     /**
      * Returns {@link NodeType#isAnnotation()} for this node's {@link DiffNode#nodeType}.
      */
     public boolean isAnnotation() {
-        return this.nodeType.isAnnotation();
+        return this.nodeType.isAnnotation() && !this.isRoot();
     }
 
     /**

src/main/java/org/variantsync/diffdetective/diff/difftree/NodeType.java

@@ -15,10 +15,7 @@ public enum NodeType {
     ELIF("elif"),
 
     // Artifact types
-    ARTIFACT("artifact"),
-
-    // Extra type for the root
-    ROOT("ROOT");
+    ARTIFACT("artifact");
 
     public final String name;
     NodeType(String name) {
@@ -36,7 +33,7 @@ public boolean isConditionalAnnotation() {
      * Returns true iff this node type represents a feature mapping.
      */
     public boolean isAnnotation() {
-        return this != ROOT && this != ARTIFACT;
+        return this != ARTIFACT;
     }
 
     final static Pattern annotationRegex = Pattern.compile("^[+-]?\\s*#\\s*(if|endif|else|elif)");

src/main/java/org/variantsync/diffdetective/diff/difftree/parse/DiffTreeParser.java

@@ -274,7 +274,7 @@ public static DiffNode popIf(final Stack<DiffNode> stack) {
         do {
             // Don't update line numbers of popped nodes here as this already happened.
             popped = stack.pop();
-        } while (!popped.isIf() && !popped.isRoot());
+        } while (!popped.isIf());
         return popped;
     }
 

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/LineGraphImport.java

@@ -129,22 +129,20 @@ private static DiffTree parseDiffTree(final String lineGraph, final Path inFile,
 
 		// Handle trees and graphs differently
 		if (options.graphFormat() == GraphFormat.DIFFGRAPH) {
-			// If you should interpret the input data as DiffTrees, always expect a root to be present. Parse all nodes (v) to a list of nodes. Search for the root. Assert that there is exactly one root.
-			Assert.assertTrue(diffNodeList.stream().noneMatch(DiffNode::isRoot)); // test if it’s not a tree
 			return DiffGraph.fromNodes(diffNodeList, diffTreeSource);
 		} else if (options.graphFormat() == GraphFormat.DIFFTREE) {
 			// If you should interpret the input data as DiffTrees, always expect a root to be present. Parse all nodes (v) to a list of nodes. Search for the root. Assert that there is exactly one root.
             DiffNode root = null;
             for (final DiffNode v : diffNodeList) {
-                if (DiffGraph.hasNoParents(v)) {
+                if (v.isRoot()) {
                     // v is root candidate
                     if (root != null) {
-                        throw new RuntimeException("Not a DiffTree but a DiffGraph: Got more than one root! Got \"" + root + "\" and \"" + v + "\"!");
+                        throw new RuntimeException("Not a DiffTree: Got more than one root! Got \"" + root + "\" and \"" + v + "\"!");
                     }
-                    if (v.nodeType == NodeType.IF || v.nodeType == NodeType.ROOT) {
+                    if (v.nodeType == NodeType.IF) {
                         root = v;
                     } else {
-                        throw new RuntimeException("Not a DiffTree but a DiffGraph: The node \"" + v + "\" is not labeled as ROOT or IF but has no parents!");
+                        throw new RuntimeException("Not a DiffTree but a DiffGraph: The node \"" + v + "\" is not labeled as IF but has no parents!");
                     }
                 }
             }

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/nodeformat/DiffNodeLabelPrettyfier.java

@@ -33,7 +33,7 @@ private static String prettyPrintTypeAndMapping(final DiffNode node) {
      */
     public static String prettyPrintIfAnnotationOr(final DiffNode node, final String elseValue) {
         String result = "";
-        if (node.nodeType.isAnnotation()) {
+        if (node.isAnnotation()) {
             result += prettyPrintTypeAndMapping(node);
         } else {
             result += elseValue;

src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseNestedNonEditedAnnotations.java

@@ -113,7 +113,7 @@ private static void collapseChain(Stack<DiffNode> chain) {
                         lastPopped = chain.pop();
                     }
                 }
-                case ROOT, ARTIFACT ->
+                case ARTIFACT ->
                     throw new RuntimeException("Unexpected node type " + lastPopped.nodeType + " within annotation chain!");
                 case ENDIF -> {}
             }

src/main/java/org/variantsync/diffdetective/mining/RWCompositePatternNodeFormat.java

@@ -11,7 +11,6 @@ public String toLabel(final DiffNode node) {
             return ProposedEditClasses.Instance.match(node).getName() + "<br>" + node.getLabel();
         } else {
             return node.diffType + "_" + switch (node.nodeType) {
-                case ROOT -> "r";
                 case IF -> "mapping<br> " + node.getLabel();
                 case ELSE -> "else";
                 case ELIF -> "elif<br>" + node.getLabel();

src/main/java/org/variantsync/diffdetective/mining/formats/DebugMiningDiffNodeFormat.java

@@ -19,8 +19,6 @@ public class DebugMiningDiffNodeFormat implements MiningNodeFormat {
 	public String toLabel(final DiffNode node) {
         if (node.isArtifact()) {
             return ProposedEditClasses.Instance.match(node).getName();
-        } else if (node.isRoot()) {
-            return node.diffType + "_" + NodeType.IF;
         } else {
             return node.diffType + "_" + node.nodeType;
         }
@@ -34,9 +32,6 @@ public Pair<DiffType, NodeType> fromEncodedTypes(String tag) {
             final DiffType dt = DiffType.fromName(tag);
             final int nodeTypeBegin = tag.indexOf("_") + 1;
             final NodeType nt = NodeType.fromName(tag.substring(nodeTypeBegin));
-            if (nt == NodeType.ROOT) {
-                throw new IllegalArgumentException("There should be no roots in mined edit classes!");
-            }
             return new Pair<>(dt, nt);
         } else {
             final EditClass editClass = ProposedEditClasses.Instance.fromName(tag).orElseThrow(

src/main/java/org/variantsync/diffdetective/mining/formats/ReleaseMiningDiffNodeFormat.java

@@ -41,8 +41,7 @@ public String toLabel(DiffNode node) {
         if (node.isArtifact()) {
             return ARTIFACT_PREFIX + toId(ProposedEditClasses.Instance.match(node));
         } else {
-            final NodeType nodeType = node.isRoot() ? NodeType.IF : node.nodeType;
-            return ANNOTATION_PREFIX + node.diffType.ordinal() + nodeType.ordinal();
+            return ANNOTATION_PREFIX + node.diffType.ordinal() + node.nodeType.ordinal();
         }
     }
 
@@ -61,9 +60,6 @@ public Pair<DiffType, NodeType> fromEncodedTypes(String tag) {
             final NodeType nodeType = NodeType.values()[Integer.parseInt(
                     tag.substring(nodeTypeBegin, nodeTypeBegin + 1)
             )];
-            if (nodeType == NodeType.ROOT) {
-                throw new IllegalArgumentException("There should be no roots in mined edit classes!");
-            }
             return new Pair<>(diffType, nodeType);
         }
     }