Fix make and ninja backends to sensibly handle duplicate target names in different directories

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 copy
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.MSVSVersion
 import gyp.system_test
@@ skipping 167 matching lines @@
 # All paths as written into the .ninja files are relative to the build
 # directory.  Call these paths "ninja paths".
 #
 # We translate between these two notions of paths with two helper
 # functions:
 #
 # - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
 #   into the equivalent ninja path.
 #
 # - GypPathToUniqueOutput translates a gyp path into a ninja path to write
-#   an output file; the result can be namespaced such that is unique
+#   an output file; the result can be namespaced such that it is unique
 #   to the input file name as well as the output target name.
 
 class NinjaWriter:
-  def __init__(self, target_outputs, base_dir, build_dir, output_file, flavor,
-               abs_build_dir=None):
+  def __init__(self, qualified_target, target_outputs, base_dir, build_dir,
+               output_file, flavor, abs_build_dir=None):
     """
     base_dir: path from source root to directory containing this gyp file,
               by gyp semantics, all input paths are relative to this
     build_dir: path from source root to build output
     abs_build_dir: absolute path to the build directory
     """
 
+    self.qualified_target = qualified_target
     self.target_outputs = target_outputs
     self.base_dir = base_dir
     self.build_dir = build_dir
     self.ninja = ninja_syntax.Writer(output_file)
     self.flavor = flavor
     self.abs_build_dir = abs_build_dir
     self.obj_ext = '.obj' if flavor == 'win' else '.o'
 
     # Relative path from build output dir to base dir.
     self.build_to_base = os.path.join(InvertRelativePath(build_dir), base_dir)
@@ skipping 186 matching lines @@
       if self.is_mac_bundle:
         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)
 
     if not output:
       return None
 
-    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)
-
     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."""
     outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
         source, self.config_name)
     outdir = self.GypPathToNinja(outdir)
     def fix_path(path, rel=None):
@@ skipping 69 matching lines @@
 
   def WriteActions(self, actions, extra_sources, prebuild,
                    extra_mac_bundle_resources):
     # Actions cd into the base directory.
     env = self.GetXcodeEnv()
     if self.flavor == 'win':
       env = self.msvs_settings.GetVSMacroEnv('$!PRODUCT_DIR')
     all_outputs = []
     for action in actions:
       # First write out a rule for the action.
-      name = re.sub(r'[ {}$]', '_', action['action_name'])
+      name = re.sub(r'[^a-zA-Z0-9_]', '_', '%s_%s' % (self.qualified_target,

[Nico, 2012/06/04 23:10:20]

nit: indent looks weird

[Steve Block, 2012/06/07 10:17:40]

Done.

+                                               action['action_name']))
       description = self.GenerateDescription('ACTION',
                                              action.get('message', None),
                                              name)
       is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)
                    if self.flavor == 'win' else False)
       args = action['action']
       args = [self.msvs_settings.ConvertVSMacros(arg, self.base_to_build)
               for arg in args] if self.flavor == 'win' else args
       rule_name = self.WriteNewNinjaRule(name, args, description,
                                          is_cygwin, env=env)
@@ skipping 12 matching lines @@
 
       self.ninja.newline()
 
     return all_outputs
 
   def WriteRules(self, rules, extra_sources, prebuild,
                  extra_mac_bundle_resources):
     all_outputs = []
     for rule in rules:
       # First write out a rule for the rule action.
-      name = rule['rule_name']
+      name = '%s_%s' % (self.qualified_target, rule['rule_name'])
       args = rule['action']
       description = self.GenerateDescription(
           'RULE',
           rule.get('message', None),
           ('%s ' + generator_default_variables['RULE_INPUT_PATH']) % name)
       is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(rule)
                    if self.flavor == 'win' else False)
       args = [self.msvs_settings.ConvertVSMacros(arg, self.base_to_build)
               for arg in args] if self.flavor == 'win' else args
       rule_name = self.WriteNewNinjaRule(name, args, description, is_cygwin)
@@ skipping 897 matching lines @@
   all_targets = set()
   for build_file in params['build_files']:
     for target in gyp.common.AllTargets(target_list,
                                         target_dicts,
                                         os.path.normpath(build_file)):
       all_targets.add(target)
   all_outputs = set()
 
   # target_outputs is a map from qualified target name to a Target object.
   target_outputs = {}
+  # target_short_names is a map from target short name to a list of Target
+  # objects.
+  target_short_names = {}
   for qualified_target in target_list:
     # qualified_target is like: third_party/icu/icu.gyp:icui18n#target
     build_file, name, toolset = \
         gyp.common.ParseQualifiedTarget(qualified_target)
 
     this_make_global_settings = data[build_file].get('make_global_settings', [])
     assert make_global_settings == this_make_global_settings, (
         "make_global_settings needs to be the same for all targets.")
 
     spec = target_dicts[qualified_target]
     if flavor == 'mac':
       gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
 
     build_file = gyp.common.RelativePath(build_file, options.toplevel_dir)
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
     abs_build_dir = os.path.abspath(toplevel_build)
-    writer = NinjaWriter(target_outputs, base_path, build_dir,
+    writer = NinjaWriter(qualified_target, target_outputs, base_path, build_dir,
                          OpenOutput(os.path.join(toplevel_build, output_file)),
                          flavor, abs_build_dir=abs_build_dir)
     master_ninja.subninja(output_file)
 
     target = writer.WriteSpec(spec, config_name, generator_flags)
     if target:
+      if name != target.FinalOutput() and spec['toolset'] == 'target':
+        target_short_names.setdefault(name, []).append(target)
       target_outputs[qualified_target] = target
       if qualified_target in all_targets:
         all_outputs.add(target.FinalOutput())
 
+  if target_short_names:
+    # 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.
+    master_ninja.newline()
+    master_ninja.comment('Short names for targets.')
+    for short_name in target_short_names:
+      master_ninja.build(short_name, 'phony', [x.FinalOutput() for x in
+                                               target_short_names[short_name]])
+
   if all_outputs:
     master_ninja.newline()
     master_ninja.build('all', 'phony', list(all_outputs))
     master_ninja.default('all')
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   if params['options'].generator_output:
     raise NotImplementedError, "--generator_output not implemented for ninja"
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)