ninja/mac: Don't choke on bundles that have no 'sources'.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2012 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 gyp.xcode_emulation
 import os.path
 import re
@@ skipping 248 matching lines @@
 
     # 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 = []
+    has_binary = True
     sources = spec.get('sources', []) + extra_sources
     if sources:
       link_deps = self.WriteSources(
           config_name, config, sources, compile_depends,
           gyp.xcode_emulation.MacPrefixHeader(
               self.xcode_settings, self.GypPathToNinja,
               lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang)))
       # Some actions/rules output 'sources' that are already object files.
       link_deps += [self.GypPathToNinja(f) for f in sources if f.endswith('.o')]
+    else:
+      has_binary = False
 
     # The final output of our target depends on the last output of the
     # above steps.
     output = output_binary = None
     final_deps = link_deps or sources_depends or actions_depends
     if final_deps:
       output, output_binary = self.WriteTarget(
           spec, config_name, config, final_deps, mac_bundle_depends,
-          order_only=actions_depends)
+          has_binary, 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)
+    else:
+      self.ninja.build(self.name, 'phony', output)

[Evan Martin, 2012/01/07 21:10:12]

Would reusing the above similar line for this case work?  (I.e. untab the block
just above here.)

     return output, output_binary, compile_depends
 
   def WriteActionsRulesCopies(self, spec, extra_sources, prebuild,
                               mac_bundle_depends):
     """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 = []
     extra_mac_bundle_resources = []
 
     if 'actions' in spec:
@@ skipping 264 matching lines @@
         'c': 'cflags_pch_c',
         'cc': 'cflags_pch_cc',
         'm': 'cflags_pch_objc',
         'mm': 'cflags_pch_objcc',
       }[lang]
 
       cmd = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }.get(lang)
       self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])
 
   def WriteTarget(self, spec, config_name, config, final_deps,
-                  mac_bundle_depends, order_only):
+                  mac_bundle_depends, has_binary, 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], final_deps[0]
       # Otherwise, fall through to writing out a stamp file.
 
     if self.is_mac_bundle:
       output = self.ComputeMacBundleOutput(spec)
       output_binary = self.ComputeMacBundleBinaryOutput(spec)
-      mac_bundle_depends.append(output_binary)
+      if has_binary:
+        mac_bundle_depends.append(output_binary)
     else:
       output = output_binary = 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.
@@ skipping 395 matching lines @@
       # For bundles, the binary in the bundle is the right answer.
       target_outputs[qualified_target] = (
           output_binary, compile_depends, linkable)
 
       # But for all_outputs, the bundle is the interesting bit.
       if qualified_target in all_targets:
         all_outputs.add(output)
 
   if all_outputs:
     master_ninja.build('all', 'phony', list(all_outputs))