ninja/mac: Don't write an empty binary into sourceless bundles.

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 copy
 import hashlib
 import multiprocessing
 import os.path
 import re
 import signal
@@ skipping 456 matching lines @@
         else:
           print "Warning: Actions/rules writing object files don't work with " \
                 "multiarch targets, dropping. (target %s)" % spec['target_name']
 
 
     if self.flavor == 'win' and self.target.type == 'static_library':
       self.target.component_objs = link_deps
 
     # Write out a link step, if needed.
     output = None
+    is_empty_bundle = True
     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)
       if self.is_mac_bundle:
+        is_empty_bundle = not link_deps and not mac_bundle_depends

[justincohen, 2013/09/06 14:06:05]

This breaks some bundles we depend on that are only mac_bundle_resources.  In
this case, mac_bundle_depends is not nil, but since line 478 evaluates to False,
this will never run.  Is there a reason this is nested inside #478?  Why not
just check for not link_deps and not mac_bundle_depends on line 477?

This CL breaks ninja for iOS builds.  Perhaps one of the bundles we depend on is
doing something wrong?

[Nico, 2013/09/06 14:10:16]

Sounds reasonable.
Not sure, this CL explicitly is about supporting sourceless bundles (i.e. just
mac_bundle_resources) better, see the tests. I'm guessing your sourceless
bundles look slightly different? I suggest adding a demo of your problem to
test/mac/sourceless-bundle/test.gyp / test/mac/gyptest-sourceless-bundle.py and
then sending a CL with that test and your proposed fix.

         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)
+      output = self.WriteMacBundle(spec, mac_bundle_depends, is_empty_bundle)
 
     if not output:
       return None
 
     assert self.target.FinalOutput(), output
     return self.target
 
   def _WinIdlRule(self, source, prebuild, outputs):
     """Handle the implicit VS .idl rule for one source file. Fills |outputs|
     with files that are generated."""
@@ skipping 568 matching lines @@
 
     if len(solibs):
       extra_bindings.append(('solibs', gyp.common.EncodePOSIXShellList(solibs)))
 
     ninja_file.build(output, command + command_suffix, link_deps,
                      implicit=list(implicit_deps),
                      variables=extra_bindings)
     return linked_binary
 
   def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
-    if spec['type'] == 'none':
+    if spec['type'] == 'none' or not 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.
       self.target.binary = compile_deps
     elif spec['type'] == 'static_library':
       self.target.binary = self.ComputeOutput(spec)
       if (self.flavor not in ('mac', 'openbsd', 'win') and not
           self.is_standalone_static_library):
         self.ninja.build(self.target.binary, 'alink_thin', link_deps,
                          order_only=compile_deps)
       else:
@@ skipping 25 matching lines @@
           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)
     return self.target.binary
 
-  def WriteMacBundle(self, spec, mac_bundle_depends):
+  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,
                                  is_command_start=not package_framework)
-    if package_framework:
+    if package_framework and not is_empty:
       variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
       self.ninja.build(output, 'package_framework', mac_bundle_depends,
                        variables=variables)
     else:
       self.ninja.build(output, 'stamp', mac_bundle_depends,
                        variables=variables)
     self.target.bundle = output
     return output
 
   def GetSortedXcodeEnv(self, additional_settings=None):
@@ skipping 939 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)