Fix error highlight for self-intersecting ways

src/org/openstreetmap/josm/data/osm/WaySegment.java

@@ -2,7 +2,7 @@
 package org.openstreetmap.josm.data.osm;
 
 /**
- * A segment consisting of 2 consecutive nodes out of a way.
+ * A segment consisting of two consecutive nodes out of a way.
  */
 public final class WaySegment extends IWaySegment<Node, Way> {
 
@@ -36,7 +36,7 @@ public static WaySegment forNodePair(Way way, Node first, Node second) {
             }
             endIndex--;
         }
-        throw new IllegalArgumentException("Node pair is not part of way!");
+        throw new IllegalArgumentException("The node pair is not consecutive part of the way!");
     }
 
     /**

src/org/openstreetmap/josm/data/validation/tests/CycleDetector.java

@@ -155,7 +155,7 @@ private static Collection<WaySegment> createSegments(Map<Node, List<Node>> graph
                 intersect.retainAll(mWays);
 
                 for (Way w : intersect) {
-                    if (w.getNeighbours(n).contains(m) && getNodeIndex(w, n) + 1 == getNodeIndex(w, m)) {
+                    if (isConsecutive(w, n, m)) {
                         segments.add(WaySegment.forNodePair(w, n, m));
                     }
                 }
@@ -166,20 +166,21 @@ private static Collection<WaySegment> createSegments(Map<Node, List<Node>> graph
     }
 
     /**
-     * Returns the way index of a node. Only the first occurrence is considered in case it's a closed way.
+     * Returns the way index of a node. Only the first occurrence is considered in case it's a closed or self-intersecting way.
      *
      * @param w parent way
-     * @param n the node to look up
-     * @return {@code >=0} if the node is found or<br>{@code -1} if node not part of the way
+     * @param n the first node to look up
+     * @param m the second, possibly consecutive node
+     * @return {@code true} if the nodes are consecutive order in the way direction
      */
-    private static int getNodeIndex(Way w, Node n) {
-        for (int i = 0; i < w.getNodesCount(); i++) {
-            if (w.getNode(i).equals(n)) {
-                return i;
+    private static boolean isConsecutive(Way w, Node n, Node m) {
+        for (int i = 0; i < w.getNodesCount() - 1; i++) {
+            if (w.getNode(i).equals(n) && w.getNode(i + 1).equals(m)) {
+                return true;
             }
         }
 
-        return -1;
+        return false;
     }
 
     /**
@@ -237,6 +238,12 @@ private Collection<Way> buildGraph(Way way) {
                 }
             }
         }
+
+        // case for single, non-connected waterways
+        if (graph.isEmpty()) {
+            graph.add(way);
+        }
+
         return graph;
     }
 }