A more useful gyp_flag_compare script

tools/gyp_flag_compare.py

 #!/usr/bin/env python
 
 # Copyright (c) 2016 The WebRTC 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 in the root of the source
 # tree. An additional intellectual property rights grant can be found
 # in the file PATENTS.  All contributing project authors may
 # be found in the AUTHORS file in the root of the source tree.
 
@@ skipping 105 matching lines @@
 class Comparison(object):
   """A comparison of the currently-configured build for a target."""
 
   def __init__(self, gyp_target="", gn_target=None, gyp_dir=_DEFAULT_GYP_DIR,
                gn_dir=_DEFAULT_GN_DIR):
     """Creates a comparison of a GN and GYP target. If the target names differ
     between the two build systems, then two names may be passed.
     """
     if gn_target is None:
       gn_target = gyp_target
+
     self._gyp_target = gyp_target
     self._gn_target = gn_target
 
     self._gyp_dir = gyp_dir
     self._gn_dir = gn_dir
 
     self._skipped = []
 
     self._total_diffs = 0
 
@@ skipping 73 matching lines @@
     self._gn_flags = dict((FilterChromium(filename), value)
                           for filename, value in self._gn_flags.iteritems())
     self._gyp_flags = dict((FilterChromium(filename), value)
                            for filename, value in self._gyp_flags.iteritems())
 
     all_files = sorted(self.gn_files & self.gyp_files)
     for filename in all_files:
       gyp_flags = self._gyp_flags[filename]
       gn_flags = self._gn_flags[filename]
       self._CompareLists(filename, gyp_flags, gn_flags, 'dash_f')
-      self._CompareLists(filename, gyp_flags, gn_flags, 'defines')
+      self._CompareLists(filename, gyp_flags, gn_flags, 'defines',
+          # These defines are not used by WebRTC
+          dont_care_gyp=[
+            '-DENABLE_WEBVR',
+            '-DUSE_EXTERNAL_POPUP_MENU',
+            '-DUSE_LIBJPEG_TURBO=1',
+            '-DUSE_MINIKIN_HYPHENATION=1',
+            '-DV8_USE_EXTERNAL_STARTUP_DATA',
+            '-DCR_CLANG_REVISION=280106-1',
+            '-DUSE_LIBPCI=1'
+          ],
+          dont_care_gn=[
+            '-DUSE_EXTERNAL_POPUP_MENU=1'
+          ])
       self._CompareLists(filename, gyp_flags, gn_flags, 'include_dirs')
       self._CompareLists(filename, gyp_flags, gn_flags, 'warnings',
           # More conservative warnings in GN we consider to be OK.
           dont_care_gyp=[
             '/wd4091',  # 'keyword' : ignored on left of 'type' when no variable
                         # is declared.
             '/wd4456',  # Declaration hides previous local declaration.
             '/wd4457',  # Declaration hides function parameter.
             '/wd4458',  # Declaration hides class member.
             '/wd4459',  # Declaration hides global declaration.
             '/wd4702',  # Unreachable code.
             '/wd4800',  # Forcing value to bool 'true' or 'false'.
             '/wd4838',  # Conversion from 'type' to 'type' requires a narrowing
                         # conversion.
           ] if sys.platform == 'win32' else None,
           dont_care_gn=[
             '-Wendif-labels',
             '-Wextra',
             '-Wsign-compare',
           ] if not sys.platform == 'win32' else None)
-      self._CompareLists(filename, gyp_flags, gn_flags, 'other')
+      self._CompareLists(filename, gyp_flags, gn_flags, 'other',
+                         dont_care_gyp=['-g'], dont_care_gn=['-g2'])
 
   def _CompareLists(self, filename, gyp, gn, name,
                     dont_care_gyp=None, dont_care_gn=None):
     """Return a report of any differences between gyp and gn lists, ignoring
     anything in |dont_care_{gyp|gn}| respectively."""
     if gyp[name] == gn[name]:
       return
     if not dont_care_gyp:
       dont_care_gyp = []
     if not dont_care_gn:
@@ skipping 17 matching lines @@
                             .setdefault(m, []).append(filename)
       self._total_diffs += 1
     self._missing_gn_files.setdefault(filename, {}) \
                           .setdefault(name, set()).update(missing_in_gn)
 
   def _GetFlags(self, lines, build_dir):
     """Turn a list of command lines into a semi-structured dict."""
     is_win = sys.platform == 'win32'
     flags_by_output = {}
     for line in lines:
+      line = FilterChromium(line)
+      line = line.replace(os.getcwd(), '../../')
+      line = line.replace('//', '/')
       command_line = shlex.split(line.strip(), posix=not is_win)[1:]
 
       output_name = _FindAndRemoveArgWithValue(command_line, '-o')
       dep_name = _FindAndRemoveArgWithValue(command_line, '-MF')
 
       command_line = _MergeSpacedArgs(command_line, '-Xclang')
 
       cc_file = [x for x in command_line if x.endswith('.cc') or
                                             x.endswith('.c') or
                                             x.endswith('.cpp') or
@@ skipping 118 matching lines @@
   if len(sys.argv) > 3:
     gyp_target = sys.argv[3]
   if len(sys.argv) > 4:
     gn_target = sys.argv[4]
 
   print 'GYP output directory is %s' % gyp_dir
   print 'GN output directory is %s' % gn_dir
 
   comparison = Comparison(gyp_target, gn_target, gyp_dir, gn_dir)
 
-  gyp_files = comparison.gyp_files
-  gn_files = comparison.gn_files
-  different_source_list = comparison.gyp_files != comparison.gn_files
-  if different_source_list:
-    print 'Different set of sources files:'
-    print '  In gyp, not in GN:\n    %s' % '\n    '.join(
-        sorted(gyp_files - gn_files))
-    print '  In GN, not in gyp:\n    %s' % '\n    '.join(
-        sorted(gn_files - gyp_files))
-    print '\nNote that flags will only be compared for files in both sets.\n'
-
   differing_files = set(comparison.missing_in_gn_by_file.keys()) & \
                     set(comparison.missing_in_gyp_by_file.keys())
   files_with_given_differences = {}
   for filename in differing_files:
     output = ''
     missing_in_gyp = comparison.missing_in_gyp_by_file.get(filename, {})
     missing_in_gn = comparison.missing_in_gn_by_file.get(filename, {})
     difference_types = sorted(set(missing_in_gyp.keys() + missing_in_gn.keys()))
     for difference_type in difference_types:
+      if (len(missing_in_gyp[difference_type]) == 0 and
+          len(missing_in_gn[difference_type]) == 0):
+        continue
       output += '  %s differ:\n' % difference_type
-      if difference_type in missing_in_gyp:
+      if (difference_type in missing_in_gyp and
+          len(missing_in_gyp[difference_type])):
         output += '    In gyp, but not in GN:\n      %s' % '\n      '.join(
             sorted(missing_in_gyp[difference_type])) + '\n'
-      if difference_type in missing_in_gn:
+      if (difference_type in missing_in_gn and
+          len(missing_in_gn[difference_type])):
         output += '    In GN, but not in gyp:\n      %s' % '\n      '.join(
             sorted(missing_in_gn[difference_type])) + '\n'
     if output:
       files_with_given_differences.setdefault(output, []).append(filename)
 
   for diff, files in files_with_given_differences.iteritems():
     print '\n'.join(sorted(files))
     print diff
 
   print 'Total differences:', comparison.total_differences
   # TODO(scottmg): Return failure on difference once we're closer to identical.
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())