Index: src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java	(revision 18225)
+++ src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java	(working copy)
@@ -8,6 +8,7 @@
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -15,6 +16,9 @@
 import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmDataManager;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.OsmUtils;
 import org.openstreetmap.josm.data.osm.Relation;
@@ -80,6 +84,10 @@
     private final Map<Point2D, List<WaySegment>> cellSegments = new HashMap<>(1000);
     /** The already detected ways in error */
     private final Map<List<Way>, List<WaySegment>> seenWays = new HashMap<>(50);
+    /** collection of ways which refer to modified nodes */
+    private final Set<Way> possiblyModifiedWays = new LinkedHashSet<>();
+    private final Set<Way> visitedWays = new HashSet<>();
+    protected boolean isSurroundingTest;
 
     protected final int code;
 
@@ -98,16 +106,18 @@
         }
 
         @Override
-        public boolean isPrimitiveUsable(OsmPrimitive w) {
-            return super.isPrimitiveUsable(w)
-                    && !isProposedOrAbandoned(w)
-                    && (isHighway(w)
-                    || w.hasKey(WATERWAY)
-                    || isRailway(w)
-                    || isCoastline(w)
-                    || isBuilding(w)
-                    || w.hasKey(BARRIER)
-                    || isResidentialArea(w));
+        public boolean isPrimitiveUsable(OsmPrimitive p) {
+            if (partialSelection && p instanceof Node)
+                return p.isModified();
+            return super.isPrimitiveUsable(p)
+                    && !isProposedOrAbandoned(p)
+                    && (isHighway(p)
+                    || p.hasKey(WATERWAY)
+                    || isRailway(p)
+                    || isCoastline(p)
+                    || isBuilding(p)
+                    || p.hasKey(BARRIER)
+                    || isResidentialArea(p));
         }
 
         @Override
@@ -226,6 +236,8 @@
 
         @Override
         public boolean isPrimitiveUsable(OsmPrimitive p) {
+            if (partialSelection && p instanceof Node)
+                return p.isModified();
             return super.isPrimitiveUsable(p) && p.hasKey("boundary") && !p.hasTag("boundary", "protected_area")
                     && (!(p instanceof Relation) || p.isMultipolygon());
         }
@@ -278,6 +290,13 @@
         }
 
         @Override
+        public boolean isPrimitiveUsable(OsmPrimitive p) {
+            if (partialSelection && p instanceof Node)
+                return p.isModified();
+            return super.isPrimitiveUsable(p);
+        }
+
+        @Override
         boolean ignoreWaySegmentCombination(Way w1, Way w2) {
             return false; // we should not get here
         }
@@ -298,15 +317,32 @@
     @Override
     public void startTest(ProgressMonitor monitor) {
         super.startTest(monitor);
+        isSurroundingTest = false;
         cellSegments.clear();
         seenWays.clear();
+        possiblyModifiedWays.clear();
+        visitedWays.clear();
     }
 
     @Override
     public void endTest() {
+        if (partialSelection) {
+            possiblyModifiedWays.stream().filter(w -> !visitedWays.contains(w)).forEach(this::visit);
+            // see #20680: if only a selection was tested, test it also against the other suitable ways
+            if (!cellSegments.isEmpty() && !(this instanceof SelfCrossing)) {
+                isSurroundingTest = true; // don't add more ways to the spatial index
+                DataSet ds = OsmDataManager.getInstance().getActiveDataSet();
+                for (Way w : ds.getWays()) {
+                    if (isPrimitiveUsable(w) && !visitedWays.contains(w))
+                        visit(w);
+                }
+            }
+        }
         super.endTest();
         cellSegments.clear();
         seenWays.clear();
+        possiblyModifiedWays.clear();
+        visitedWays.clear();
     }
 
     static boolean isCoastline(OsmPrimitive w) {
@@ -342,7 +378,15 @@
     }
 
     @Override
+    public void visit(Node n) {
+        if (partialSelection && n.isModified()) {
+            possiblyModifiedWays.addAll(n.getParentWays());
+        }
+    }
+
+    @Override
     public void visit(Way w) {
+        visitedWays.add(w);
         boolean findSelfCrossingOnly = this instanceof SelfCrossing;
         if (findSelfCrossingOnly) {
             // free memory, we are not interested in previous ways
@@ -390,7 +434,8 @@
                         highlight.add(es2);
                     }
                 }
-                segments.add(es1);
+                if (!isSurroundingTest)
+                    segments.add(es1);
             }
         }
     }