win: Fix missing loadable_module dependency in ULDI mode

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 121 matching lines @@
     self.precompile_stamp = None
     # File representing the completion of actions/rules/copies, if any.
     self.actions_stamp = None
     # Path to the output of the link step, if any.
     self.binary = None
     # Path to the file representing the completion of building the bundle,
     # if any.
     self.bundle = None
     # On Windows, incremental linking requires linking against all the .objs
     # that compose a .lib (rather than the .lib itself). That list is stored
-    # here.
+    # here. In this case, we also need to save the compile_deps for the target,
+    # so that the the target that directly depends on the .objs can also depend
+    # on those.
     self.component_objs = None
+    self.compile_deps = None
     # Windows only. The import .lib is the output of a build step, but
     # because dependents only link against the lib (not both the lib and the
     # dll) we keep track of the import library here.
     self.import_lib = None
 
   def Linkable(self):
     """Return true if this is a target that can be linked against."""
     return self.type in ('static_library', 'shared_library')
 
   def UsesToc(self, flavor):
@@ skipping 313 matching lines @@
       obj_outputs = [f for f in sources if f.endswith(self.obj_ext)]
       if obj_outputs:
         if self.flavor != 'mac' or len(self.archs) == 1:
           link_deps += [self.GypPathToNinja(o) for o in obj_outputs]
         else:
           print "Warning: Actions/rules writing object files don't work with " \
                 "multiarch targets, dropping. (target %s)" % spec['target_name']
     elif self.flavor == 'mac' and len(self.archs) > 1:
       link_deps = collections.defaultdict(list)
 
-
+    compile_deps = self.target.actions_stamp or actions_depends
     if self.flavor == 'win' and self.target.type == 'static_library':
       self.target.component_objs = link_deps
+      self.target.compile_deps = compile_deps
 
     # Write out a link step, if needed.
     output = None
     is_empty_bundle = not link_deps and not mac_bundle_depends
     if link_deps or self.target.actions_stamp or actions_depends:
       output = self.WriteTarget(spec, config_name, config, link_deps,
-                                self.target.actions_stamp or actions_depends)
+                                compile_deps)
       if self.is_mac_bundle:
         mac_bundle_depends.append(output)
 
     # Bundle all of the above together, if needed.
     if self.is_mac_bundle:
       output = self.WriteMacBundle(spec, mac_bundle_depends, is_empty_bundle)
 
     if not output:
       return None
 
@@ skipping 589 matching lines @@
     """Write out a link step. Fills out target.binary. """
     command = {
       'executable':      'link',
       'loadable_module': 'solink_module',
       'shared_library':  'solink',
     }[spec['type']]
     command_suffix = ''
 
     implicit_deps = set()
     solibs = set()
+    order_deps = set()
 
     if 'dependencies' in spec:
       # Two kinds of dependencies:
       # - Linkable dependencies (like a .a or a .so): add them to the link line.
       # - Non-linkable dependencies (like a rule that generates a file
       #   and writes a stamp file): add them to implicit_deps
       extra_link_deps = set()
       for dep in spec['dependencies']:
         target = self.target_outputs.get(dep)
         if not target:
           continue
         linkable = target.Linkable()
         if linkable:
           new_deps = []
           if (self.flavor == 'win' and
               target.component_objs and
               self.msvs_settings.IsUseLibraryDependencyInputs(config_name)):
             new_deps = target.component_objs
+            if target.compile_deps:
+              order_deps.add(target.compile_deps)
           elif self.flavor == 'win' and target.import_lib:
             new_deps = [target.import_lib]
           elif target.UsesToc(self.flavor):
             solibs.add(target.binary)
             implicit_deps.add(target.binary + '.TOC')
           else:
             new_deps = [target.binary]
           for new_dep in new_deps:
             if new_dep not in extra_link_deps:
               extra_link_deps.add(new_dep)
@@ skipping 118 matching lines @@
           config_name, self.ExpandSpecial, output + '.pdb')
       if pdbname:
         output = [output, pdbname]
 
 
     if len(solibs):
       extra_bindings.append(('solibs', gyp.common.EncodePOSIXShellList(solibs)))
 
     ninja_file.build(output, command + command_suffix, link_deps,
                      implicit=list(implicit_deps),
+                     order_only=list(order_deps),
                      variables=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.
@@ skipping 1131 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)