[foozzie] Refactoring - move source hashing to main script

tools/foozzie/v8_suppressions.py

 # Copyright 2016 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 Suppressions for V8 correctness fuzzer failures.
 
 We support three types of suppressions:
 1. Ignore test case by pattern.
 Map a regular expression to a bug entry. A new failure will be reported
 when the pattern matches a JS test case.
 Subsequent matches will be recoreded under the first failure.
 
 2. Ignore test run by output pattern:
 Map a regular expression to a bug entry. A new failure will be reported
 when the pattern matches the output of a particular run.
 Subsequent matches will be recoreded under the first failure.
 
 3. Relax line-to-line comparisons with expressions of lines to ignore and
 lines to be normalized (i.e. ignore only portions of lines).
 These are not tied to bugs, be careful to not silently switch off this tool!
 
 Alternatively, think about adding a behavior change to v8_suppressions.js
 to silence a particular class of problems.
 """
 
-import hashlib
 import itertools
 import re
 
 # Max line length for regular experessions checking for lines to ignore.
 MAX_LINE_LENGTH = 512
 
 # For ignoring lines before carets and to ignore caret positions.
 CARET_RE = re.compile(r'^\s*\^\s*$')
 
 # Ignore by original source files. Map from bug->relative file paths in V8,
@@ skipping 95 matching lines @@
 ]
 
 
 ###############################################################################
 # Implementation - you should not need to change anything below this point.
 
 # Compile regular expressions.
 ALLOWED_LINE_DIFFS = [re.compile(exp) for exp in ALLOWED_LINE_DIFFS]
 IGNORE_LINES = [re.compile(exp) for exp in IGNORE_LINES]
 
-# The number of hex digits used from the hash of the original source file path.
-# Keep the number small to avoid duplicate explosion.
-SOURCE_HASH_LENGTH = 3
-
 ORIGINAL_SOURCE_PREFIX = 'v8-foozzie source: '
-ORIGINAL_SOURCE_DEFAULT = 'none'
 
 def line_pairs(lines):
   return itertools.izip_longest(
       lines, itertools.islice(lines, 1, None), fillvalue=None)
 
 
 def caret_match(line1, line2):
   if (not line1 or
       not line2 or
       len(line1) > MAX_LINE_LENGTH or
@@ skipping 17 matching lines @@
     match2 = exp.match(line2)
     if match1 and match2:
       # If there are groups in the regexp, ensure the groups matched the same
       # things.
       if match1.groups() == match2.groups():  # tuple comparison
         return True
   return False
 
 
 def diff_output(output1, output2, allowed, ignore1, ignore2):
-  """Returns a tuple (difference, source, source_key).
+  """Returns a tuple (difference, source).
 
   The difference is None if there's no difference, otherwise a string
   with a readable diff.
 
-  The source is the last source output within the test case. It is the string
-  'none' if no such output existed.
-
-  The source_key is a short hash of source or 'none'.
+  The source is the last source output within the test case, or None if no
+  such output existed.
   """
   def useful_line(ignore):
     def fun(line):
       return all(not e.match(line) for e in ignore)
     return fun
 
   lines1 = filter(useful_line(ignore1), output1)
   lines2 = filter(useful_line(ignore2), output2)
 
   # This keeps track where we are in the original source file of the fuzz
   # test case.
-  source = ORIGINAL_SOURCE_DEFAULT
-  source_key = ORIGINAL_SOURCE_DEFAULT
+  source = None
 
   for ((line1, lookahead1), (line2, lookahead2)) in itertools.izip_longest(
       line_pairs(lines1), line_pairs(lines2), fillvalue=(None, None)):
 
     # Only one of the two iterators should run out.
     assert not (line1 is None and line2 is None)
 
     # One iterator ends earlier.
     if line1 is None:
-      return '+ %s' % short_line_output(line2), source, source_key
+      return '+ %s' % short_line_output(line2), source
     if line2 is None:
-      return '- %s' % short_line_output(line1), source, source_key
+      return '- %s' % short_line_output(line1), source
 
     # If lines are equal, no further checks are necessary.
     if line1 == line2:
       # Instrumented original-source-file output must be equal in both
       # versions. It only makes sense to update it here when both lines
       # are equal.
       if line1.startswith(ORIGINAL_SOURCE_PREFIX):
         source = line1[len(ORIGINAL_SOURCE_PREFIX):]
-        source_key = hashlib.sha1(source).hexdigest()[:SOURCE_HASH_LENGTH]
       continue
 
     # Look ahead. If next line is a caret, ignore this line.
     if caret_match(lookahead1, lookahead2):
       continue
 
     # Check if a regexp allows these lines to be different.
     if ignore_by_regexp(line1, line2, allowed):
       continue
 
     # Lines are different.
     return (
         '- %s\n+ %s' % (short_line_output(line1), short_line_output(line2)),
         source,
-        source_key,
     )
 
   # No difference found.
-  return None, source, source_key
+  return None, source
 
 
 def get_suppression(arch1, config1, arch2, config2):
   return V8Suppression(arch1, config1, arch2, config2)
 
 
 class Suppression(object):
   def diff(self, output1, output2):
     return None
 
@@ skipping 56 matching lines @@
     bug = check(IGNORE_OUTPUT.get(arch, {}))
     if bug:
       return bug
     bug = check(IGNORE_OUTPUT.get(config, {}))
     if bug:
       return bug
     bug = check(IGNORE_OUTPUT.get('%s,%s' % (arch, config), {}))
     if bug:
       return bug
     return None