Ninja: separate dependencies for compile steps vs actions/rules/copies

pylib/gyp/generator/ninja.py

 #!/usr/bin/python
 
 # Copyright (c) 2011 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 gyp
 import gyp.common
 import gyp.system_test
 import os.path
@@ skipping 202 matching lines @@
 
     if len(targets) > 1:
       stamp = self.GypPathToUniqueOutput(name + '.stamp')
       targets = self.ninja.build(stamp, 'stamp', targets)
       self.ninja.newline()
     return targets
 
   def WriteSpec(self, spec, config):
     """The main entry point for NinjaWriter: write the build rules for a spec.
 
-    Returns the path to the build output, or None."""
+    Returns the path to the build output, or None, and a list of targets for
+    dependencies of its compile steps."""
 
     self.name = spec['target_name']
     self.toolset = spec['toolset']
 
     if spec['type'] == 'settings':
       # TODO: 'settings' is not actually part of gyp; it was
       # accidentally introduced somehow into just the Linux build files.
       # Remove this (or make it an error) once all the users are fixed.
       print ("WARNING: %s uses invalid type 'settings'.  " % self.name +
              "Please fix the source gyp file to use type 'none'.")
       print "See http://code.google.com/p/chromium/issues/detail?id=96629 ."
       spec['type'] = 'none'
 
     # Compute predepends for all rules.
-    # prebuild is the dependencies this target depends on before
-    # running any of its internal steps.
-    prebuild = []
+    # actions_depends is the dependencies this target depends on before running
+    # any of its action/rule/copy steps.
+    # compile_depends is the dependencies this target depends on before running
+    # any of its compile steps.
+    actions_depends = []
+    compile_depends = []
     if 'dependencies' in spec:
       for dep in spec['dependencies']:
         if dep in self.target_outputs:
-          prebuild.append(self.target_outputs[dep][0])
-      prebuild = self.WriteCollapsedDependencies('predepends', prebuild)
+          input, precompile_input, linkable = self.target_outputs[dep]
+          actions_depends.append(input)
+          compile_depends.extend(precompile_input)
+      actions_depends = self.WriteCollapsedDependencies('actions_depends',
+                                                        actions_depends)
 
     # Write out actions, rules, and copies.  These must happen before we
     # compile any sources, so compute a list of predependencies for sources
     # while we do it.
     extra_sources = []
-    sources_predepends = self.WriteActionsRulesCopies(spec, extra_sources,
-                                                      prebuild)
+    sources_depends = self.WriteActionsRulesCopies(spec, extra_sources,
+                                                   actions_depends)
+
+    # If we have actions/rules/copies, we depend directly on those, but
+    # otherwise we depend on dependent target's actions/rules/copies etc.
+    # We never need to explicitly depend on previous target's link steps,
+    # because no compile ever depends on them.
+    compile_depends = self.WriteCollapsedDependencies('compile_depends',
+        sources_depends or compile_depends)
 
     # Write out the compilation steps, if any.
     link_deps = []
     sources = spec.get('sources', []) + extra_sources
     if sources:
-      link_deps = self.WriteSources(config, sources,
-                                    sources_predepends or prebuild)
+      link_deps = self.WriteSources(config, sources, compile_depends)
       # Some actions/rules output 'sources' that are already object files.
       link_deps += [self.GypPathToNinja(f) for f in sources if f.endswith('.o')]
 
     # The final output of our target depends on the last output of the
     # above steps.
     output = None
-    final_deps = link_deps or sources_predepends or prebuild
+    final_deps = link_deps or sources_depends or actions_depends
     if final_deps:
-      output = self.WriteTarget(spec, config, final_deps)
+      output = self.WriteTarget(spec, config, final_deps,
+                                order_only=actions_depends)
       if self.name != output and self.toolset == 'target':
         # 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.
         self.ninja.build(self.name, 'phony', output)
-    return output
+    return output, compile_depends
 
   def WriteActionsRulesCopies(self, spec, extra_sources, prebuild):
     """Write out the Actions, Rules, and Copies steps.  Return any outputs
     of these steps (or a stamp file if there are lots of outputs)."""
     outputs = []
 
     if 'actions' in spec:
       outputs += self.WriteActions(spec['actions'], extra_sources, prebuild)
     if 'rules' in spec:
       outputs += self.WriteRules(spec['rules'], extra_sources, prebuild)
@@ skipping 156 matching lines @@
         # TODO: should we assert here on unexpected extensions?
         continue
       input = self.GypPathToNinja(source)
       output = self.GypPathToUniqueOutput(filename + '.o')
       self.ninja.build(output, command, input,
                        order_only=predepends)
       outputs.append(output)
     self.ninja.newline()
     return outputs
 
-  def WriteTarget(self, spec, config, final_deps):
+  def WriteTarget(self, spec, config, final_deps, order_only):
     if spec['type'] == 'none':
       # This target doesn't have any explicit final output, but is instead
       # used for its effects before the final output (e.g. copies steps).
       # Reuse the existing output if it's easy.
       if len(final_deps) == 1:
         return final_deps[0]
       # Otherwise, fall through to writing out a stamp file.
 
     output = self.ComputeOutput(spec)
 
     output_uses_linker = spec['type'] in ('executable', 'loadable_module',
                                           'shared_library')
 
     implicit_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
       if output_uses_linker:
         extra_deps = set()
         for dep in spec['dependencies']:
-          input, linkable = self.target_outputs.get(dep, (None, False))
+          input, _, linkable = self.target_outputs.get(dep, (None, [], False))
           if not input:
             continue
           if linkable:
             extra_deps.add(input)
           else:
             # TODO: Chrome-specific HACK.  Chrome runs this lastchange rule on
             # every build, but we don't want to rebuild when it runs.
             if 'lastchange' not in input:
               implicit_deps.add(input)
         final_deps.extend(list(extra_deps))
@@ skipping 13 matching lines @@
       self.WriteVariableList('libs',
                              gyp.common.uniquer(map(self.ExpandSpecial,
                                                     spec.get('libraries', []))))
 
     extra_bindings = []
     if command in ('solink', 'solink_module'):
       extra_bindings.append(('soname', os.path.split(output)[1]))
 
     self.ninja.build(output, command, final_deps,
                      implicit=list(implicit_deps),
+                     order_only=order_only,
                      variables=extra_bindings)
 
     return output
 
   def ComputeOutputFileName(self, spec):
     """Compute the filename of the final output for the current target."""
 
     # Compute filename prefix: the product prefix, or a default for
     # the product type.
     DEFAULT_PREFIX = {
@@ skipping 197 matching lines @@
     output_file = os.path.join(obj, base_path, name + '.ninja')
     spec = target_dicts[qualified_target]
     config = spec['configurations'][config_name]
 
     writer = NinjaWriter(target_outputs, base_path, builddir,
                          OpenOutput(os.path.join(options.toplevel_dir,
                                                  builddir,
                                                  output_file)))
     master_ninja.subninja(output_file)
 
-    output = writer.WriteSpec(spec, config)
+    output, compile_depends = writer.WriteSpec(spec, config)
     if output:
       linkable = spec['type'] in ('static_library', 'shared_library')
-      target_outputs[qualified_target] = (output, linkable)
+      target_outputs[qualified_target] = (output, compile_depends, linkable)
 
       if qualified_target in all_targets:
         all_outputs.add(output)
 
   if all_outputs:
     master_ninja.build('all', 'phony', list(all_outputs))