Briefly: it would be very useful to be able to unapply and re-apply the changes associated with a changelist to the working copy. This would give SVN functionality similar to that of "quilt" and also somewhat ease working with SVN while disconnected from the main repository. Background: It is currently awkward to work with multiple changelists at once. Suppose I am working on a big change when I notice a small cleanup that I would like to make and commit. I create a new changelist called "cleanup", modify a file or two, and add them to the changelist. But it is impossible to test the "cleanup" change because my working copy includes modifications for the big change. I may not even be able to compile and run the code, or it may be that the tests pass only because of the unrelated changes. It would be nice to be able to create a second changelist called "bigchange", and then *unapply* "bigchange" from my working copy (storing it to a temporary location in some kind of patch format). Then I could test "cleanup", commit it, reapply "bigchange", then continue work on "bigchange". Quilt is a tool that helps such a workflow by maintaining a "stack" of patches. Quilt stores patches as diffs in a special directory, and keeps a list of the known patch filenames in a text file. A patch can be applied to a source tree by typing "quilt push" and removed by typing "quilt pop". It is also possible to edit the files in the source tree, then incorporate the edits into the topmost applied patch by typing "quilt refresh". Other quilt commands allow the user to create and delete patches, inspect patches, etc. Quilt keeps track of the order of the patches that it controls, and only allows them to be pushed and popped in the correct order. If a patch that is deeper in the stack has been modified, it is possible that there will be a conflict when pushing a later patch. Patches are applied using the "patch" program, so simple conflicts are resolved automatically; others have to be resolved by the user. Quilt allows many patches to be managed at once; I routinely have a dozen patches under quilt's control. Apparently some users manage more than a thousand patches at once with quilt. However, quilt is already very useful when working with only two or three patches at once. For more information about quilt, see: http://savannah.nongnu.org/projects/quilt/ http://www.suse.de/~agruen/quilt.pdf It would be very nice to add some quilt-like functionality to SVN's new changelist feature by allowing changelists to be pushed and popped off of the working copy. SVN could improve on quilt because (1) it knows what the files looked like in their pristine forms; (2) it knows when a changelist has been committed (and can therefore be forgotten). One tricky issue when dealing with patches is that they do not commute; in general it might be possible to apply patchA followed by patchB, but not patchB followed by patchA. Equivalently, if patchA then patchB are applied to the working copy, then it is not necessarily possible to unapply patchA while patchB is still applied. Quilt avoids this problem by keeping track of the order of patches, and only pushing/popping them in the correct order. But such a restriction might not fit in with SVN's implementation of changelists. Another possibility would be to enforce the following restriction: two changelists may not be applied at the same time if they have files in common. This doesn't prevent the possibility of conflicts, but at least when a file is modified it is unambiguous to which changelist the modification belongs. This idea was mentioned on the dev mailing list http://subversion.tigris.org/servlets/ReadMsg?list=dev&msgNo=130364 and discussed briefly in IRC; dlr asked me to create an enhancement request for it.
Original issue reported by mhagger