GYP: Make GYP build deterministic

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
@@ skipping 711 matching lines @@
           elif var == 'name':
             extra_bindings.append(('name', cygwin_munge(basename)))
           else:
             assert var == None, repr(var)
 
         outputs = [self.GypPathToNinja(o, env) for o in outputs]
         if self.flavor == 'win':
           # WriteNewNinjaRule uses unique_name for creating an rsp file on win.
           extra_bindings.append(('unique_name',
               hashlib.md5(outputs[0]).hexdigest()))
+
+        # Make sure we sort extra_bindings so that output is deterministic.
         self.ninja.build(outputs, rule_name, self.GypPathToNinja(source),
                          implicit=inputs,
                          order_only=prebuild,
-                         variables=extra_bindings)
+                         variables=sorted(extra_bindings))
 
         all_outputs.extend(outputs)
 
     return all_outputs
 
   def WriteCopies(self, copies, prebuild, mac_bundle_depends):
     outputs = []
     env = self.GetToolchainEnv()
     for copy in copies:
       for path in copy['files']:
@@ skipping 497 matching lines @@
         output = [output, output + '.TOC']
       else:
         command = command + '_notoc'
     elif self.flavor == 'win':
       extra_bindings.append(('binary', output))
       pdbname = self.msvs_settings.GetPDBName(
           config_name, self.ExpandSpecial, output + '.pdb')
       if pdbname:
         output = [output, pdbname]
 
+    # Sort the solibs here so that they're outputted deterministically.
+    if len(solibs):
+      extra_bindings.append(('solibs',
+                            gyp.common.EncodePOSIXShellList(sorted(solibs))))
 
-    if len(solibs):
-      extra_bindings.append(('solibs', gyp.common.EncodePOSIXShellList(solibs)))
-
+    # Sort outputs so that they're deterministically ordered.
     ninja_file.build(output, command + command_suffix, link_deps,
-                     implicit=list(implicit_deps),
-                     order_only=list(order_deps),
-                     variables=extra_bindings)
+                     implicit=sorted(implicit_deps),
+                     order_only=sorted(order_deps),
+                     variables=sorted(extra_bindings))
     return linked_binary
 
   def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
     extra_link_deps = any(self.target_outputs.get(dep).Linkable()
                           for dep in spec.get('dependencies', [])
                           if dep in self.target_outputs)
     if spec['type'] == 'none' or (not link_deps and not extra_link_deps):
       # TODO(evan): don't call this function for 'none' target types, as
       # it doesn't do anything, and we fake out a 'binary' with a stamp file.
       self.target.binary = compile_deps
@@ skipping 976 matching lines @@
       'stamp',
       description='STAMP $out',
       command='${postbuilds}touch $out')
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
       command='ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)')
   master_ninja.newline()
 
   all_targets = set()
-  for build_file in params['build_files']:
+  # Iterate over build files deterministically so they're consistently ordered.
+  for build_file in sorted(params['build_files']):
     for target in gyp.common.AllTargets(target_list,
                                         target_dicts,
                                         os.path.normpath(build_file)):
       all_targets.add(target)
   all_outputs = set()
 
   # target_outputs is a map from qualified target name to a Target object.
   target_outputs = {}
   # target_short_names is a map from target short name to a list of Target
   # objects.
@@ skipping 62 matching lines @@
       non_empty_target_names.add(name)
     else:
       empty_target_names.add(name)
 
   if target_short_names:
     # Write a short name to build this target.  This benefits both the
     # "build chrome" case as well as the gyp tests, which expect to be
     # able to run actions and build libraries by their short name.
     master_ninja.newline()
     master_ninja.comment('Short names for targets.')
-    for short_name in target_short_names:
+
+    # Iterate over the target short names in a deterministic order by sorting.
+    for short_name in sorted(target_short_names):
       master_ninja.build(short_name, 'phony', [x.FinalOutput() for x in
                                                target_short_names[short_name]])
 
   # Write phony targets for any empty targets that weren't written yet. As
   # short names are  not necessarily unique only do this for short names that
   # haven't already been output for another target.
   empty_target_names = empty_target_names - non_empty_target_names
   if empty_target_names:
     master_ninja.newline()
     master_ninja.comment('Empty targets (output for completeness).')
+
+    # Iterate over empty target names in a deterministic order by sorting.
     for name in sorted(empty_target_names):
       master_ninja.build(name, 'phony')
 
   if all_outputs:
     master_ninja.newline()
     master_ninja.build('all', 'phony', list(all_outputs))
     master_ninja.default(generator_flags.get('default_target', 'all'))
 
   master_ninja_file.close()
 
@@ skipping 40 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)