[Dexter] Collate penalties of the same type into a single line for each

[StephenTozer]

Summary

Currently in Dexter, every step at which a DexExpectWatchValue/Type does
not have the correct value is printed on a separate line. This patch
reduces the size of the text output by instead printing each incorrect
result (i.e. each incorrect value seen, 'Variable optimized out', and so
on) on its own line, alongside a list of the steps at which that result
was seen. This makes for much less spam in the output when watches are
missing or wrong for many steps.

[Orlando]

This should improve the readability of the output nicely. LGTM.

cross-project-tests/debuginfo-tests/dexter/dex/heuristic/Heuristic.py

parser.add_argument(
         '--penalty-incorrect-program-state',
         type=int,
         default=4,  # XXX XXX XXX selected by random
         help='set the penalty for the program never entering an expected state'
         ' or entering an unexpected state.',
         metavar='<int>')
 
 
+class PenaltyLineRanges:
+    def __init__(self, first_step, penalty):
+        self.ranges = [(first_step, first_step)]
+        self.penalty = penalty
+
+    def add_step(self, next_step, penalty):
+        last_range = self.ranges[-1]
+        last_step = last_range[1]
+        if (next_step == last_step + 1):
+            self.ranges[-1] = (last_range[0], next_step)
+        else:
+            self.ranges.append((next_step, next_step))
+        self.penalty += penalty
+
+    def __str__(self):
+        range_to_str = lambda r: str(r[0]) if r[0] == r[1] else f'{r[0]}-{r[1]}'
+        if self.ranges[0][0] == self.ranges[-1][1]:
+            text = f'step {self.ranges[0][0]}'
+        else:
+            step_list = ', '.join([range_to_str(r) for r in self.ranges])
+            text = f'steps [{step_list}]'
+        if self.penalty:
+            text += ' <r>[-{}]</>'.format(self.penalty)
+        return text
+
+
 class Heuristic(object):
     def __init__(self, context, steps):
         self.context = context
         self.penalties = {}
         self.address_resolutions = {}
 
         worst_penalty = max([
             self.penalty_variable_optimized, self.penalty_irretrievable,
def verbose_output(self):  # noqa
         for command in sorted(self.penalties):
             pen_cmd = self.penalties[command]
             maximum_possible_penalty = pen_cmd.max_penalty
             total_penalty = 0
             lines = []
             for category in sorted(pen_cmd.pen_dict):
                 lines.append('    <r>{}</>:\n'.format(category))
 
+                step_value_results = {}
+                for result, penalty in pen_cmd.pen_dict[category]:
+                    if not isinstance(result, StepValueInfo):
+                        continue
+                    if result.expected_value not in step_value_results:
+                        step_value_results[result.expected_value] = PenaltyLineRanges(result.step_index, penalty)
+                    else:
+                        step_value_results[result.expected_value].add_step(result.step_index, penalty)
+
+                for value, penalty_line_range in step_value_results.items():
+                    text = f'({value}): {penalty_line_range}'
+                    total_penalty += penalty_line_range.penalty
+                    lines.append('      {}\n'.format(text))
+
                 for result, penalty in pen_cmd.pen_dict[category]:
                     if isinstance(result, StepValueInfo):
-                        text = 'step {}'.format(result.step_index)
-                        if result.expected_value:
-                            text += ' ({})'.format(result.expected_value)
+                        continue
                     else:
                         text = str(result)
                     if penalty:
                         assert penalty > 0, penalty
                         total_penalty += penalty
                         text += ' <r>[-{}]</>'.format(penalty)
                     lines.append('      {}\n'.format(text))
 

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/address_printing.cpp

 // CHECK: missing values:
 // CHECK-NEXT: address 'x_1'
 
 // CHECK-LABEL: [z] ExpectValue
 // CHECK: expected encountered watches:
 // CHECK-NEXT: address 'x_2' (0x[[X2_VAL]])
 // CHECK-NEXT: address 'y' (0x[[Y_VAL]])
 // CHECK: misordered result:
-// CHECK-NEXT: step 4 (0x[[Y_VAL]])
-// CHECK-NEXT: step 5 (0x[[X2_VAL]])
+// CHECK-NEXT: (0x[[Y_VAL]]): step 4
+// CHECK-NEXT: (0x[[X2_VAL]]): step 5
 
 int main() {
     int *x = new int(5);
     int *y = new int(4);
     if (false) {
         (void)0; // DexLabel('unreachable')
     }
     int *z = y;