[analyzer] [tests] [NFC] Remove dead code from CmpRuns

[george.karpenkov]

Summary

Indeed, "CHANGE" is not a thing yet, and we should probably not carry around dead code which does not do anything apart from confusing the reader.

[NoQ]

Burn it.

utils/analyzer/CmpRuns.py

def cmpAnalysisDiagnostic(d):
     return d.getIssueIdentifier()
 
 
 def compareResults(A, B, opts):
     """
     compareResults - Generate a relation from diagnostics in run A to
     diagnostics in run B.
 
-    The result is the relation as a list of triples (a, b, confidence) where
-    each element {a,b} is None or an element from the respective run, and
-    confidence is a measure of the match quality (where 0 indicates equality,
-    and None is used if either element is None).
+    The result is the relation as a list of triples (a, b) where
+    each element {a,b} is None or a matching element from the respective run
     """
 
     res = []
 
     # Map size_before -> size_after
     path_difference_data = []
 
     # Quickly eliminate equal elements.
while eltsA and eltsB:
                         float(a.getPathLength()) / b.getPathLength())
                 elif opts.relative_log_path_histogram:
                     path_difference_data.append(
                         log(float(a.getPathLength()) / b.getPathLength()))
                 elif opts.absolute_path_histogram:
                     path_difference_data.append(
                         a.getPathLength() - b.getPathLength())
 
-            res.append((a, b, 0))
+            res.append((a, b))
         elif a.getIssueIdentifier() > b.getIssueIdentifier():
             eltsB.append(b)
             neqA.append(a)
         else:
             eltsA.append(a)
             neqB.append(b)
     neqA.extend(eltsA)
     neqB.extend(eltsB)
 
     # FIXME: Add fuzzy matching. One simple and possible effective idea would
     # be to bin the diagnostics, print them in a normalized form (based solely
     # on the structure of the diagnostic), compute the diff, then use that as
     # the basis for matching. This has the nice property that we don't depend
     # in any way on the diagnostic format.
 
     for a in neqA:
-        res.append((a, None, None))
+        res.append((a, None))
     for b in neqB:
-        res.append((None, b, None))
+        res.append((None, b))
 
     if opts.relative_log_path_histogram or opts.relative_path_histogram or \
             opts.absolute_path_histogram:
         from matplotlib import pyplot
         pyplot.hist(path_difference_data, bins=100)
         pyplot.show()
 
     return res
if opts.verboseLog:
         auxLog = open(opts.verboseLog, "wb")
     else:
         auxLog = None
 
     diff = compareResults(resultsA, resultsB, opts)
     foundDiffs = 0
     totalAdded = 0
     totalRemoved = 0
-    totalChanged = 0
     for res in diff:
-        a, b, confidence = res
+        a, b = res
         if a is None:
             print "ADDED: %r" % b.getReadableName()
             foundDiffs += 1
             totalAdded += 1
             if auxLog:
                 print >>auxLog, ("('ADDED', %r, %r)" % (b.getReadableName(),
                                                         b.getReport()))
         elif b is None:
             print "REMOVED: %r" % a.getReadableName()
             foundDiffs += 1
             totalRemoved += 1
             if auxLog:
                 print >>auxLog, ("('REMOVED', %r, %r)" % (a.getReadableName(),
                                                           a.getReport()))
-        elif confidence:
-            print "CHANGED: %r to %r" % (a.getReadableName(),
-                                         b.getReadableName())
-            foundDiffs += 1
-            totalChanged += 1
-            if auxLog:
-                print >>auxLog, ("('CHANGED', %r, %r, %r, %r)"
-                                 % (a.getReadableName(),
-                                    b.getReadableName(),
-                                    a.getReport(),
-                                    b.getReport()))
         else:
             pass
 
     TotalReports = len(resultsB.diagnostics)
     print "TOTAL REPORTS: %r" % TotalReports
     print "TOTAL DIFFERENCES: %r" % foundDiffs
     print "TOTAL ADDED: %r" % totalAdded
     print "TOTAL REMOVED: %r" % totalRemoved
-    print "TOTAL CHANGED: %r" % totalChanged
     if auxLog:
         print >>auxLog, "('TOTAL NEW REPORTS', %r)" % TotalReports
         print >>auxLog, "('TOTAL DIFFERENCES', %r)" % foundDiffs
 
     return foundDiffs, len(resultsA.diagnostics), len(resultsB.diagnostics)
 
 
 def main():