Work around buggy break in List.sort and optimize constant folding of negative values.

dart/frog/leg/lib/dual_pivot_quicksort.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(ahe): Remove this file and use the shared one.
 
 /**
  * Dual-Pivot Quicksort algorithm.
  *
  * This class implements the dual-pivot quicksort algorithm as presented in
@@ skipping 136 matching lines @@
         } else {
           // comp > 0.
           //
           // Find the first element <= pivot in the range [k - 1, great] and
           // put [:ak:] there. We know that such an element must exist:
           // When k == less, then el3 (which is equal to pivot) lies in the
           // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.
           // Note that in the latter case invariant 2 will be violated for a
           // short amount of time. The invariant will be restored when the
           // pivots are put into their final positions.
-          while (true) {
+          bool done = false;
+          while (!done) {
             comp = compare(a[great], pivot);
             if (comp > 0) {
               great--;
               // This is the only location in the while-loop where a new
               // iteration is started.
               // continue;
             } else if (comp < 0) {
               // Triple exchange.
               a[k] = a[less];
               a[less++] = a[great];
               a[great--] = ak;
-              break;
+              done = true;
             } else {
               // comp == 0;
               a[k] = a[great];
               a[great--] = ak;
               // Note: if great < k then we will exit the outer loop and fix
               // invariant 2 (which we just violated).
-              break;
+              done = true;
             }
           }
         }
       }
     } else {
       // We partition the list into three parts:
       //  1. < pivot1
       //  2. >= pivot1 && <= pivot2
       //  3. > pivot2
       //
@@ skipping 14 matching lines @@
         int comp_pivot1 = compare(ak, pivot1);
         if (comp_pivot1 < 0) {
           if (k != less) {
             a[k] = a[less];
             a[less] = ak;
           }
           less++;
         } else {
           int comp_pivot2 = compare(ak, pivot2);
           if (comp_pivot2 > 0) {
-            while (true) {
+            bool done = false;
+            while (!done) {
               int comp = compare(a[great], pivot2);
               if (comp > 0) {
                 great--;
-                if (great < k) break;
+                if (great < k) done = true;
                 // This is the only location inside the loop where a new
                 // iteration is started.
                 // continue;
               } else {
                 // a[great] <= pivot2.
                 comp = compare(a[great], pivot1);
                 if (comp < 0) {
                   // Triple exchange.
                   a[k] = a[less];
                   a[less++] = a[great];
                   a[great--] = ak;
                 } else {
                   // a[great] >= pivot1.
                   a[k] = a[great];
                   a[great--] = ak;
                 }
-                break;
+                done = true;
               }
             }
           }
         }
       }
     }
 
     // Move pivots into their final positions.
     // We shrunk the list from both sides (a[left] and a[right] have
     // meaningless values in them) and now we move elements from the first
@@ skipping 48 matching lines @@
         int comp_pivot1 = compare(ak, pivot1);
         if (comp_pivot1 == 0) {
           if (k != less) {
             a[k] = a[less];
             a[less] = ak;
           }
           less++;
         } else {
           int comp_pivot2 = compare(ak, pivot2);
           if (comp_pivot2 == 0) {
-            while (true) {
+            bool done = false;
+            while (!done) {
               int comp = compare(a[great], pivot2);
               if (comp == 0) {
                 great--;
-                if (great < k) break;
+                if (great < k) done = true;
                 // This is the only location inside the loop where a new
                 // iteration is started.
                 // continue;
               } else {
                 // a[great] < pivot2.
                 comp = compare(a[great], pivot1);
                 if (comp < 0) {
                   // Triple exchange.
                   a[k] = a[less];
                   a[less++] = a[great];
                   a[great--] = ak;
                 } else {
                   // a[great] == pivot1.
                   a[k] = a[great];
                   a[great--] = ak;
                 }
-                break;
+                done = true;
               }
             }
           }
         }
       }
       // The second partition has now been cleared of pivot elements and looks
       // as follows:
       // [  *  |  > pivot1 && < pivot2  | * ]
       //        ^                      ^
       //       less                  great
       // Sort the second partition using recursive descent.
       _doSort(a, less, great, compare);
     } else {
       // The second partition looks as follows:
       // [  *  |  >= pivot1 && <= pivot2  | * ]
       //        ^                        ^
       //       less                    great
       // Simply sort it by recursive descent.
       _doSort(a, less, great, compare);
     }
   }
 }