ninja: Correctly handle copies steps in sourceless shared_library targets.

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 1040 matching lines @@
         'c': 'cflags_pch_c',
         'cc': 'cflags_pch_cc',
         'm': 'cflags_pch_objc',
         'mm': 'cflags_pch_objcc',
       }[lang]
 
       map = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }
       cmd = map.get(lang)
       ninja_file.build(gch, cmd, input, variables=[(var_name, lang_flag)])
 
-  def WriteLink(self, spec, config_name, config, link_deps):
+  def WriteLink(self, spec, config_name, config, link_deps, compile_deps):
     """Write out a link step. Fills out target.binary. """
     if self.flavor != 'mac' or len(self.archs) == 1:
       return self.WriteLinkForArch(
-          self.ninja, spec, config_name, config, link_deps)
+          self.ninja, spec, config_name, config, link_deps, compile_deps)
     else:
       output = self.ComputeOutput(spec)
       inputs = [self.WriteLinkForArch(self.arch_subninjas[arch], spec,
                                       config_name, config, link_deps[arch],
-                                      arch=arch)
+                                      compile_deps, arch=arch)
                 for arch in self.archs]
       extra_bindings = []
       build_output = output
       if not self.is_mac_bundle:
         self.AppendPostbuildVariable(extra_bindings, spec, output, output)
 
       # TODO(yyanagisawa): more work needed to fix:
       # https://code.google.com/p/gyp/issues/detail?id=411
       if (spec['type'] in ('shared_library', 'loadable_module') and
           not self.is_mac_bundle):
         extra_bindings.append(('lib', output))
         self.ninja.build([output, output + '.TOC'], 'solipo', inputs,
             variables=extra_bindings)
       else:
         self.ninja.build(build_output, 'lipo', inputs, variables=extra_bindings)
       return output
 
   def WriteLinkForArch(self, ninja_file, spec, config_name, config,
-                       link_deps, arch=None):
+                       link_deps, compile_deps, arch=None):
     """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 compile_deps:
+      # Normally, the compiles of the target already depend on compile_deps,
+      # but a shared_library target might have no sources and only link together
+      # a few static_library deps, so the link step also needs to depend
+      # on compile_deps to make sure actions in the shared_library target
+      # get run before the link.
+      order_deps.add(compile_deps)
+
     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
@@ skipping 189 matching lines @@
             inputs.append(output)
           # TODO: It's not clear if libtool_flags should be passed to the alink
           # call that combines single-arch .a files into a fat .a file.
           self.AppendPostbuildVariable(variables, spec,
                                        self.target.binary, self.target.binary)
           self.ninja.build(self.target.binary, 'alink', inputs,
                            # FIXME: test proving order_only=compile_deps isn't
                            # needed.
                            variables=variables)
     else:
-      self.target.binary = self.WriteLink(spec, config_name, config, link_deps)
+      self.target.binary = self.WriteLink(spec, config_name, config, link_deps,
+                                          compile_deps)
     return self.target.binary
 
   def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
     assert self.is_mac_bundle
     package_framework = spec['type'] in ('shared_library', 'loadable_module')
     output = self.ComputeMacBundleOutput()
     if is_empty:
       output += '.stamp'
     variables = []
     self.AppendPostbuildVariable(variables, spec, output, self.target.binary,
@@ skipping 1079 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)