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 261 matching lines @@
           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')]
 
     # 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:
+    if link_deps or sources_depends or actions_depends:
       output, output_binary = self.WriteTarget(
-          spec, config_name, config, final_deps, mac_bundle_depends,
+          spec, config_name, config, link_deps,
+          sources_depends or actions_depends, mac_bundle_depends,
           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)
+    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)

[Evan Martin, 2012/01/07 21:29:00]

Hm, now I'm confused.  Won't this write out this phony rule when output=None? 
Do we want that?

[Nico, 2012/01/07 21:32:33]

Yes, that's the point of this change :-) output will be none if "link_deps or
sources_depends or actions_depends" is false, which happens for empty bundles
(first target in the test case). In that case, we want to write a phony target,
so that building that empty bundle target doesn't error out with "no target
named empty_bundle".

As said in mail 1, ""The completely empty bundles aren't needed by the chromium
build, but I found that ninja was inconsistent with make/xcode while writing the
test, so I fixed that too.""". So if you don't like this change, I can revert it
and instead (later) make gyp's input.py error out on completely empty bundles.

I do want all generators to have the same behavior, but I don't care much how
that's done.

     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 263 matching lines @@
       var_name = {
         '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,
+  def WriteTarget(self, spec, config_name, config, link_deps, final_deps,
                   mac_bundle_depends, 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)
-    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.
       # - 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))
           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))
+        link_deps.extend(list(extra_deps))
+
+    if self.is_mac_bundle:
+      output = self.ComputeMacBundleOutput(spec)
+      output_binary = self.ComputeMacBundleBinaryOutput(spec)
+      if not link_deps:
+        output_binary = self.ComputeOutput(spec, type='none')
+      mac_bundle_depends.append(output_binary)
+    else:
+      output = output_binary = self.ComputeOutput(spec)
+
     command_map = {
       'executable':      'link',
       'static_library':  'alink',
       'loadable_module': 'solink_module',
       'shared_library':  'solink',
       'none':            'stamp',
     }
     command = command_map[spec['type']]
 
+    if link_deps:
+      final_deps = link_deps
+    else:
+      command = 'stamp'
+      order_only += final_deps
+      final_deps = []
+
     if output_uses_linker:
       if self.flavor == 'mac':
         ldflags = self.xcode_settings.GetLdflags(config_name,
             self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
             self.GypPathToNinja)
       else:
         ldflags = config.get('ldflags', [])
       self.WriteVariableList('ldflags',
                              gyp.common.uniquer(map(self.ExpandSpecial,
                                                     ldflags)))
@@ skipping 28 matching lines @@
     assert self.is_mac_bundle
     path = self.ExpandSpecial(generator_default_variables['PRODUCT_DIR'])
     return os.path.join(path, self.xcode_settings.GetWrapperName())
 
   def ComputeMacBundleBinaryOutput(self, spec):
     """Return the 'output' (full output path) to the binary in a bundle."""
     assert self.is_mac_bundle
     path = self.ExpandSpecial(generator_default_variables['PRODUCT_DIR'])
     return os.path.join(path, self.xcode_settings.GetExecutablePath())
 
-  def ComputeOutputFileName(self, spec):
+  def ComputeOutputFileName(self, spec, type=None):
     """Compute the filename of the final output for the current target."""
+    if not type:
+      type = spec['type']
 
     # Compute filename prefix: the product prefix, or a default for
     # the product type.
     DEFAULT_PREFIX = {
       'loadable_module': 'lib',
       'shared_library': 'lib',
       'static_library': 'lib',
       }
-    prefix = spec.get('product_prefix', DEFAULT_PREFIX.get(spec['type'], ''))
+    prefix = spec.get('product_prefix', DEFAULT_PREFIX.get(type, ''))
 
     # Compute filename extension: the product extension, or a default
     # for the product type.
     DEFAULT_EXTENSION = {
       'static_library': 'a',
       'loadable_module': 'so',
       'shared_library': 'so',
       }
     extension = spec.get('product_extension',
-                         DEFAULT_EXTENSION.get(spec['type'], ''))
+                         DEFAULT_EXTENSION.get(type, ''))
     if extension:
       extension = '.' + extension
 
     if 'product_name' in spec:
       # If we were given an explicit name, use that.
       target = spec['product_name']
     else:
       # Otherwise, derive a name from the target name.
       target = spec['target_name']
       if prefix == 'lib':
         # Snip out an extra 'lib' from libs if appropriate.
         target = StripPrefix(target, 'lib')
 
-    if spec['type'] in ('static_library', 'loadable_module', 'shared_library',
+    if type in ('static_library', 'loadable_module', 'shared_library',
                         'executable'):
       return '%s%s%s' % (prefix, target, extension)
-    elif spec['type'] == 'none':
+    elif type == 'none':
       return '%s.stamp' % target
     else:
-      raise 'Unhandled output type', spec['type']
+      raise 'Unhandled output type', type
 
-  def ComputeOutput(self, spec):
+  def ComputeOutput(self, spec, type=None):
     """Compute the path for the final output of the spec."""
+    assert not self.is_mac_bundle or type
 
-    assert not self.is_mac_bundle
+    if not type:
+      type = spec['type']
 
-    if self.flavor == 'mac' and spec['type'] in (
+    if self.flavor == 'mac' and type in (
         'static_library', 'executable', 'shared_library', 'loadable_module'):
       filename = self.xcode_settings.GetExecutablePath()
     else:
-      filename = self.ComputeOutputFileName(spec)
+      filename = self.ComputeOutputFileName(spec, type)
 
     if 'product_dir' in spec:
       path = os.path.join(spec['product_dir'], filename)
       return self.ExpandSpecial(path)
 
     # Some products go into the output root, libraries go into shared library
     # dir, and everything else goes into the normal place.
     type_in_output_root = ['executable', 'loadable_module']
     if self.flavor == 'mac' and self.toolset == 'target':
       type_in_output_root += ['shared_library', 'static_library']
 
-    if spec['type'] in type_in_output_root:
+    if type in type_in_output_root:
       return filename
-    elif spec['type'] == 'shared_library':
+    elif type == 'shared_library':
       libdir = 'lib'
       if self.toolset != 'target':
         libdir = 'lib/%s' % self.toolset
       return os.path.join(libdir, filename)
     else:
       return self.GypPathToUniqueOutput(filename, qualified=False)
 
   def WriteVariableList(self, var, values):
     if values is None:
       values = []
@@ skipping 246 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))