ninja/mac: Put dylibs directly into the product directory.

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 651 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):
     """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 = {
       'loadable_module': 'lib',
       'shared_library': 'lib',
       'static_library': 'lib',
       }
@@ skipping 37 matching lines @@
     if self.flavor == 'mac' and spec['type'] in (
         'static_library', 'executable', 'shared_library', 'loadable_module'):
       filename = self.xcode_settings.GetExecutablePath()
     else:
       filename = self.ComputeOutputFileName(spec)
 
     if 'product_dir' in spec:
       path = os.path.join(spec['product_dir'], filename)
       return self.ExpandSpecial(path)
 
-    # Executables and loadable modules go into the output root,
-    # libraries go into shared library dir, and everything else
-    # goes into the normal place.
-    if spec['type'] in ('executable', 'loadable_module'):
+    # 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:
       return filename
     elif spec['type'] == 'shared_library':
       libdir = 'lib'
       if self.toolset != 'target':
         libdir = 'lib/%s' % self.toolset
       return os.path.join(libdir, filename)
-    elif spec['type'] == 'static_library' and self.flavor == 'mac':
-      # Static libraries go into the output root on mac, too.
-      return filename
     else:
       return self.GypPathToUniqueOutput(filename, qualified=False)
 
   def WriteVariableList(self, var, values):
     if values is None:
       values = []
     self.ninja.variable(var, ' '.join(values))
 
   def WriteNewNinjaRule(self, name, args, description):
     """Write out a new ninja "rule" statement for a given command.
@@ skipping 242 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))