fix(matching): Early return on matching if nodes have different kinds (…

…#35)

This is a bug that was discovered thanks to running the tool in jdime
repository. Basically, the matching algorithm was running even if the
nodes have different kinds, which was introducing incorrect behavior in
the merge step: leading into trying merging two nodes that have
different kinds, which is logically inconsistent.

bin/tests/scenarios/jdime_matching_issue/base.java

@@ -0,0 +1,21 @@
+package de.fosd.jdime.artifact;
+
+import java.security.MessageDigest;
+
+public abstract class Artifact<T extends Artifact<T>> implements Comparable<T>, StatisticsInterface {
+    public boolean hasChanges(Revision revision) {
+        if (this.revision.equals(revision)) {
+            return false;
+        }
+
+        if (!hasMatching(revision)) {
+            return true;
+        }
+
+        T match = getMatching(revision).getMatchingArtifact(this);
+
+        return getTreeSize() != match.getTreeSize() || Artifacts.bfsStream(self()).anyMatch(a -> {
+            return !a.hasMatching(revision) || !a.getMatching(revision).getMatchingArtifact(a).hashId().equals(a.hashId());
+        });
+    }
+}

bin/tests/scenarios/jdime_matching_issue/left.java

@@ -0,0 +1,22 @@
+package de.fosd.jdime.artifact;
+
+import java.security.MessageDigest;
+
+public abstract class Artifact<T extends Artifact<T>> implements Comparable<T>, StatisticsInterface {
+    public boolean hasChanges(Revision revision) {
+
+        if (this.revision.equals(revision)) {
+            return false;
+        }
+
+        if (!hasMatching(revision)) {
+            return true;
+        }
+
+        T match = getMatching(revision).getMatchingArtifact(this);
+
+        return getTreeSize() != match.getTreeSize() || Artifacts.bfsStream(self()).anyMatch(a -> {
+            return !a.hasMatching(revision) || !a.getMatching(revision).getMatchingArtifact(a).hashId().equals(a.hashId());
+        });
+    }
+}

bin/tests/scenarios/jdime_matching_issue/merge.java

@@ -0,0 +1 @@
+  package    de . fosd . jdime . artifact ;  import   java . security . MessageDigest ;   public abstract class Artifact  <  T  extends  Artifact  < T > >  implements   Comparable  < T > , StatisticsInterface  {   public boolean hasChanges  (  Revision revision )  {  if  (   this . revision . equals  ( revision ) )  {  return false ; }  if  (  !  hasMatching  ( revision ) )  {  return true ; }  T  match =   getMatching  ( revision ) . getMatchingArtifact  ( this ) ;  return    getTreeSize  ( ) !=  match . getTreeSize  ( ) ||  !   getTreeHash  ( ) . equals  (  match . getTreeHash  ( ) ) ; } }

bin/tests/scenarios/jdime_matching_issue/right.java

@@ -0,0 +1,20 @@
+package de.fosd.jdime.artifact;
+
+import java.security.MessageDigest;
+
+public abstract class Artifact<T extends Artifact<T>> implements Comparable<T>, StatisticsInterface {
+    public boolean hasChanges(Revision revision) {
+
+        if (this.revision.equals(revision)) {
+            return false;
+        }
+
+        if (!hasMatching(revision)) {
+            return true;
+        }
+
+        T match = getMatching(revision).getMatchingArtifact(this);
+
+        return getTreeSize() != match.getTreeSize() || !getTreeHash().equals(match.getTreeHash());
+    }
+}

matching/src/ordered_tree_matching.rs

@@ -38,6 +38,14 @@ pub fn ordered_tree_matching<'a>(
         ) => {
             let root_matching: usize = (kind_left == kind_right).into();
 
+            // Node kinds do not match, so we return a matching with a score of 0
+            if root_matching == 0 {
+                return Matchings::from_single(
+                    UnorderedPair(left, right),
+                    MatchingEntry::new(0, false),
+                );
+            }
+
             let m = children_left.len();
             let n = children_right.len();