ninja windows: Fix special variables not getting emitted when expanded from VS macros

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 hashlib
 import os.path
 import re
 import subprocess
 import sys
@@ skipping 531 matching lines @@
     for action in actions:
       # First write out a rule for the action.
       name = '%s_%s' % (action['action_name'],
                         hashlib.md5(self.qualified_target).hexdigest())
       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']
-      rule_name = self.WriteNewNinjaRule(name, args, description,
-                                         is_cygwin, env=env)
+      rule_name, _ = self.WriteNewNinjaRule(name, args, description,
+                                            is_cygwin, env=env)
 
       inputs = [self.GypPathToNinja(i, env) for i in action['inputs']]
       if int(action.get('process_outputs_as_sources', False)):
         extra_sources += action['outputs']
       if int(action.get('process_outputs_as_mac_bundle_resources', False)):
         extra_mac_bundle_resources += action['outputs']
       outputs = [self.GypPathToNinja(o, env) for o in action['outputs']]
 
       # Then write out an edge using the rule.
       self.ninja.build(outputs, rule_name, inputs,
@@ skipping 14 matching lines @@
       # Skip a rule with no action and no inputs.
       if 'action' not in rule and not rule.get('rule_sources', []):
         continue
       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)
-      rule_name = self.WriteNewNinjaRule(name, args, description, is_cygwin)
+      rule_name, args = self.WriteNewNinjaRule(
+          name, args, description, is_cygwin)
 
       # TODO: if the command references the outputs directly, we should
       # simplify it to just use $out.
 
       # Rules can potentially make use of some special variables which
       # must vary per source file.
       # Compute the list of variables we'll need to provide.
       special_locals = ('source', 'root', 'dirname', 'ext', 'name')
       needed_variables = set(['source'])
       for argument in args:
@@ skipping 539 matching lines @@
 
   def WriteVariableList(self, var, values):
     assert not isinstance(values, str)
     if values is None:
       values = []
     self.ninja.variable(var, ' '.join(values))
 
   def WriteNewNinjaRule(self, name, args, description, is_cygwin, env=[]):
     """Write out a new ninja "rule" statement for a given command.
 
-    Returns the name of the new rule."""
+    Returns the name of the new rule, and a copy of |args| with variables
+    expanded."""
 
     if self.flavor == 'win':
       args = [self.msvs_settings.ConvertVSMacros(
                   arg, self.base_to_build, config=self.config_name)
               for arg in args]
       description = self.msvs_settings.ConvertVSMacros(
           description, config=self.config_name)
     elif self.flavor == 'mac':
       args = [gyp.xcode_emulation.ExpandEnvVars(arg, env) for arg in args]
       description = gyp.xcode_emulation.ExpandEnvVars(description, env)
 
     # TODO: we shouldn't need to qualify names; we do it because
     # currently the ninja rule namespace is global, but it really
     # should be scoped to the subninja.
     rule_name = self.name
     if self.toolset == 'target':
       rule_name += '.' + self.toolset
     rule_name += '.' + name
     rule_name = re.sub('[^a-zA-Z0-9_]', '_', rule_name)
 
     description = re.sub('[^ a-zA-Z0-9_]', '_', description)
 
-    args = args[:]
-
     # gyp dictates that commands are run from the base directory.
     # cd into the directory before running, and adjust paths in
     # the arguments to point to the proper locations.
     rspfile = None
     rspfile_content = None
     args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
     if self.flavor == 'win':
       rspfile = rule_name + '.$unique_name.rsp'
       # The cygwin case handles this inside the bash sub-shell.
       run_in = '' if is_cygwin else ' ' + self.build_to_base
@@ skipping 13 matching lines @@
         command = ninja_syntax.escape(command)
       command = 'cd %s; ' % self.build_to_base + env + command
 
     # GYP rules/actions express being no-ops by not touching their outputs.
     # Avoid executing downstream dependencies in this case by specifying
     # restat=1 to ninja.
     self.ninja.rule(rule_name, command, description, restat=True,
                     rspfile=rspfile, rspfile_content=rspfile_content)
     self.ninja.newline()
 
-    return rule_name
+    return rule_name, args
 
 
 def CalculateVariables(default_variables, params):
   """Calculate additional variables for use in the build (called by gyp)."""
   global generator_additional_non_configuration_keys
   global generator_additional_path_sections
   flavor = gyp.common.GetFlavor(params)
   if flavor == 'mac':
     default_variables.setdefault('OS', 'mac')
     default_variables.setdefault('SHARED_LIB_SUFFIX', '.dylib')
@@ skipping 495 matching lines @@
 
   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)