Ticket #19885: 19885-splitway.patch

src/org/openstreetmap/josm/actions/SplitWayAction.java

@@ -222 +222 @@
             } else {
                 setHighlightedWaySegments(Collections.emptyList());
                 DISPLAY_COUNT.decrementAndGet();
+                if (getValue() != 1) {
+                    newWays.forEach(w -> w.setNodes(null)); // see 19885
+                }
             }
         }
 
@@ -303 +306 @@
                 way.getDataSet().setSelected(newSel);
             }
         });
+        if (!splitWayCommand.isPresent()) {
+            newWays.forEach(w -> w.setNodes(null)); // see 19885
+        }
     }
 
     @Override

src/org/openstreetmap/josm/command/SplitWayCommand.java

@@ -16 +16 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -89 +90 @@
      * @param commandList The sequence of commands that should be executed.
      * @param newSelection The new list of selected primitives ids (which is saved for later retrieval with {@link #getNewSelection})
      * @param originalWay The original way being split (which is saved for later retrieval with {@link #getOriginalWay})
-     * @param newWays The resulting new ways (which is saved for later retrieval with {@link #getOriginalWay})
+     * @param newWays The resulting new ways (which is saved for later retrieval with {@link #getNewWays})
      */
     public SplitWayCommand(String name, Collection<Command> commandList,
             List<? extends PrimitiveId> newSelection, Way originalWay, List<Way> newWays) {
@@ -395 +396 @@
             }
         }
 
-        switch (missingMemberStrategy) {
+        try {
+            switch (missingMemberStrategy) {
             case GO_AHEAD_WITH_DOWNLOADS:
                 try {
                     downloadMissingMembers(incompleteMembers);
@@ -405 +407 @@
                 }
                 // If missing relation members were downloaded, perform the analysis again to find the relation
                 // member order for all relations.
+                analysis.cleanup();
                 analysis = analyseSplit(way, wayToKeep, newWays);
-                return Optional.of(splitBasedOnAnalyses(way, newWays, newSelection, analysis, indexOfWayToKeep));
+                break;
             case GO_AHEAD_WITHOUT_DOWNLOADS:
                 // Proceed with the split with the information we have.
                 // This can mean that there are no missing members we want, or that the user chooses to continue
                 // the split without downloading them.
-                return Optional.of(splitBasedOnAnalyses(way, newWays, newSelection, analysis, indexOfWayToKeep));
+                break;
             case USER_ABORTED:
             default:
                 return Optional.empty();
+            }
+            return Optional.of(splitBasedOnAnalyses(way, newWays, newSelection, analysis, indexOfWayToKeep));
+        } finally {
+            // see #19885
+            wayToKeep.setNodes(null);
+            analysis.cleanup();
         }
     }
 
@@ -441 +450 @@
             if (!r.isUsable()) {
                 continue;
             }
-
             numberOfRelations++;
+            boolean isSimpleCase = true;
 
             Relation c = null;
             String type = Optional.ofNullable(r.get("type")).orElse("");
@@ -548 +557 @@
                             missingWays = Collections.emptySet();
                         }
                         relationAnalyses.add(new RelationAnalysis(c, rm, direction, missingWays));
+                        isSimpleCase = false;
                     }
                 }
             }
-
-            if (c != null) {
-                commandList.add(new ChangeCommand(r.getDataSet(), r, c));
+            if (c != null && isSimpleCase && !r.getMembers().equals(c.getMembers())) {
+                commandList.add(new ChangeMembersCommand(r, new ArrayList<>(c.getMembers())));
+                c.setMembers(null); // see #19885
             }
         }
         changedWay.setNodes(null); // see #19885
@@ -576 +586 @@
             this.numberOfRelations = numberOfRelations;
         }
 
+        /**
+         * Unlink temporary copies of relations. See #19885
+         */
+        void cleanup() {
+            for (RelationAnalysis ra : relationAnalyses) {
+                if (ra.relation.getDataSet() == null)
+                    ra.relation.setMembers(null);
+            }
+        }
+
         List<RelationAnalysis> getRelationAnalyses() {
             return relationAnalyses;
         }
@@ -687 +707 @@
             newSelection.addAll(newWays);
         }
 
+        Set<Relation> modifiedRelations = new LinkedHashSet<>();
         // Perform the split.
         for (RelationAnalysis relationAnalysis : analysis.getRelationAnalyses()) {
             RelationMember rm = relationAnalysis.getRelationMember();
@@ -728 +749 @@
                     relation.addMember(j, em);
                 }
             }
+            modifiedRelations.add(relation);
         }
+        for (Relation r : modifiedRelations) {
+            DataSet ds = way.getDataSet();
+            Relation orig = (Relation) ds.getPrimitiveById(r);
+            analysis.getCommands().add(new ChangeMembersCommand(orig, new ArrayList<>(r.getMembers())));
+            r.setMembers(null); // see #19885
+        }
 
         EnumSet<WarningType> warnings = analysis.getWarningTypes();