Patchzilla

Bugzilla is good at handling bugs, but patches are somewhat orthogonal to bugs. Certainly there are obvious connections in that patches generally fix bugs. But there are many points of conflict too:
 * Patches have dependencies. So do bugs. But the dependency tree is likely to be very different. If you work on 2 bugs in the same file, the patches may well be dependent on one another, while the bugs are not. A patch for bug A that depends on bug B could be committed before the patch that depends on bug B.
 * Patches and bugs are not 1:1. Often bugs will have several patches which together constitute a fix and while a bugzilla bug can have several patches attached, the patch order is sometimes documented in comments, and often not documented.
 * Patches have states. They can be 'in progress', 'reviewed', etc. While this information is partially recorded by Bugzilla, it doesn't fully work because the state isn't persisted across patch updates.
 * Patches have more states than bugzilla understands, patches can be invasive or noninvasive, trivial or complex. While bugs can be voted upon, this feature is rarely used where the information is important but implicit.
 * Patches have conflicts, bugs shouldn't.

Patchzilla is a database of patches, states (ready for commit etc), dependencies, and scope of affected code. It could be done as an extension to Bugzilla, or it could be standalone.

If we had a system to manage patches then there are a ton of things that we could ask Patchzilla:
 * How many patches will need rebasing when this is committed?
 * How many patches are ready to be applied?
 * Given the importance, completeness, complexity and invasiveness of the outstanding patches, please suggest an application order.
 * (With try-integration) Given the suggested commit order of the next 100 patches, where in the commit list will we find something that breaks?

Patchzilla could act as a Mega-Deputy to the Sheriff.
 * Commit this patch, rebase all patches that can be trivially rebased, and email everyone affected to tell them about conflicts.

(You can also  think of this as a sort of shared Hg MQ with extra server smarts. It's  an application that manages not just patches/dependencies, but how  people collaborate on those patches.)

If Patchzilla is also available an extension to Hg, then it should be possible to push updates from MQ (or similar) to patchzilla, and have it sync not just patches, but also sync the patch dependencies. It could also allow you to simply stay in sync with patch updates from others, and could magically remove committed patches when they're pulled.