Fix msvs-ninja OutputDirectory path.

pylib/gyp/generator/msvs.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 ntpath
 import os
 import posixpath
 import re
 import subprocess
 import sys
 
 import gyp.common
 import gyp.easy_xml as easy_xml
+import gyp.generator.ninja as ninja_generator
 import gyp.MSVSNew as MSVSNew
 import gyp.MSVSProject as MSVSProject
 import gyp.MSVSSettings as MSVSSettings
 import gyp.MSVSToolFile as MSVSToolFile
 import gyp.MSVSUserFile as MSVSUserFile
 import gyp.MSVSUtil as MSVSUtil
 import gyp.MSVSVersion as MSVSVersion
 from gyp.common import GypError
 from gyp.common import OrderedSet
 
@@ skipping 1755 matching lines @@
   # Set all the dependencies, but not if we are using an external builder like
   # ninja
   for project in projects.values():
     if not project.spec.get('msvs_external_builder'):
       deps = project.spec.get('dependencies', [])
       deps = [projects[d] for d in deps]
       project.set_dependencies(deps)
   return projects
 
 
-def _InitNinjaFlavor(options, target_list, target_dicts):
+def _InitNinjaFlavor(params, target_list, target_dicts):
   """Initialize targets for the ninja flavor.
 
   This sets up the necessary variables in the targets to generate msvs projects
   that use ninja as an external builder. The variables in the spec are only set
   if they have not been set. This allows individual specs to override the
   default values initialized here.
   Arguments:
-    options: Options provided to the generator.
+    params: Params provided to the generator.
     target_list: List of target pairs: 'base/base.gyp:base'.
     target_dicts: Dict of target properties keyed on target pair.
   """
   for qualified_target in target_list:
     spec = target_dicts[qualified_target]
     if spec.get('msvs_external_builder'):
       # The spec explicitly defined an external builder, so don't change it.
       continue
 
     path_to_ninja = spec.get('msvs_path_to_ninja', 'ninja.exe')
 
     spec['msvs_external_builder'] = 'ninja'
     if not spec.get('msvs_external_builder_out_dir'):
       spec['msvs_external_builder_out_dir'] = \
-        options.depth + '/out/$(Configuration)'
+          ninja_generator.ComputeOutputDir(params) + '\\$(Configuration)'

[Shezan Baig (Bloomberg), 2014/05/31 05:09:55]

I ran into another issue with this when I was trying it out.  I think we need to
join this with options.toplevel_dir.  Something like:

os.path.join(
    options.toplevel_dir,
    ninja_generator.ComputeOutputDir(params)) + '\\$(Configuration)'

This simulates the code in ninja_generator.GenerateOutputForConfig where it
computes 'toplevel_build'.

[bungeman-chromium, 2014/06/02 14:55:47]

I see now. msvs_external_builder_out_dir is always defined in the target spec
and is therefore relative to the gyp file which contains it. When running
msvs-ninja, msvs_exernal_builder_out_dir (if not already set) needs to be set to
the path from the gyp file in which the target is contained to the desired
output directory (in this case, where ninja put its output directory plus
$(Configuration)). ComputeOutputParams returns a path from the toplevel_dir to
the ninja build output directory. So this needs to be more like

spec['msvs_external_builder_out_dir'] = os.path.join(gyp_to_toplevel,
ninja_generator.ComputeOutputDir(params)) + '\\$(Configuration)'

In order to be consistent with how msvs_external_builder_out_dir would have been
defined in the target directly.

     if not spec.get('msvs_external_builder_build_cmd'):
       spec['msvs_external_builder_build_cmd'] = [
         path_to_ninja,
         '-C',
         '$(OutDir)',
         '$(ProjectName)',
       ]
     if not spec.get('msvs_external_builder_clean_cmd'):
       spec['msvs_external_builder_clean_cmd'] = [
         path_to_ninja,
@@ skipping 74 matching lines @@
   # Optionally shard targets marked with 'msvs_shard': SHARD_COUNT.
   (target_list, target_dicts) = MSVSUtil.ShardTargets(target_list, target_dicts)
 
   # Optionally use the large PDB workaround for targets marked with
   # 'msvs_large_pdb': 1.
   (target_list, target_dicts) = MSVSUtil.InsertLargePdbShims(
         target_list, target_dicts, generator_default_variables)
 
   # Optionally configure each spec to use ninja as the external builder.
   if params.get('flavor') == 'ninja':
-    _InitNinjaFlavor(options, target_list, target_dicts)
+    _InitNinjaFlavor(params, target_list, target_dicts)
 
   # Prepare the set of configurations.
   configs = set()
   for qualified_target in target_list:
     spec = target_dicts[qualified_target]
     for config_name, config in spec['configurations'].iteritems():
       configs.add(_ConfigFullName(config_name, config))
   configs = list(configs)
 
   # Figure out all the projects that will be generated and their guids
@@ skipping 634 matching lines @@
   return [
       ['PropertyGroup', {'Label': 'Globals'},
        ['ProjectGuid', guid],
        ['Keyword', 'Win32Proj'],
        ['RootNamespace', namespace],
        ['IgnoreWarnCompileDuplicatedFilename', 'true'],
       ]
   ]
 
 
-def _GetMSBuildConfigurationDetails(spec, build_file):
+def _GetMSBuildConfigurationDetails(spec, build_file, project_path):
   properties = {}
   for name, settings in spec['configurations'].iteritems():
-    msbuild_attributes = _GetMSBuildAttributes(spec, settings, build_file)
+    msbuild_attributes = _GetMSBuildAttributes(spec, settings,
+                                               build_file, project_path)
     condition = _GetConfigurationCondition(name, settings)
     character_set = msbuild_attributes.get('CharacterSet')
     _AddConditionalProperty(properties, condition, 'ConfigurationType',
                             msbuild_attributes['ConfigurationType'])
     if character_set:
       _AddConditionalProperty(properties, condition, 'CharacterSet',
                               character_set)
   return _GetMSBuildPropertyGroup(spec, 'Configuration', properties)
 
 
@@ skipping 86 matching lines @@
   if config_type.isdigit():
     config_type = {
         '1': 'Application',
         '2': 'DynamicLibrary',
         '4': 'StaticLibrary',
         '10': 'Utility'
     }[config_type]
   return config_type
 
 
-def _GetMSBuildAttributes(spec, config, build_file):
+def _GetMSBuildAttributes(spec, config, build_file, project_path):
   if 'msbuild_configuration_attributes' not in config:
     msbuild_attributes = _ConvertMSVSBuildAttributes(spec, config, build_file)
 
   else:
     config_type = _GetMSVSConfigurationType(spec, build_file)
     config_type = _ConvertMSVSConfigurationType(config_type)
     msbuild_attributes = config.get('msbuild_configuration_attributes', {})
     msbuild_attributes.setdefault('ConfigurationType', config_type)
     output_dir = msbuild_attributes.get('OutputDirectory',
                                       '$(SolutionDir)$(Configuration)')
     msbuild_attributes['OutputDirectory'] = _FixPath(output_dir) + '\\'
     if 'IntermediateDirectory' not in msbuild_attributes:
       intermediate = _FixPath('$(Configuration)') + '\\'
       msbuild_attributes['IntermediateDirectory'] = intermediate
     if 'CharacterSet' in msbuild_attributes:
       msbuild_attributes['CharacterSet'] = _ConvertMSVSCharacterSet(
           msbuild_attributes['CharacterSet'])
   if 'TargetName' not in msbuild_attributes:
     prefix = spec.get('product_prefix', '')
     product_name = spec.get('product_name', '$(ProjectName)')
     target_name = prefix + product_name
     msbuild_attributes['TargetName'] = target_name
 
   if spec.get('msvs_external_builder'):
     external_out_dir = spec.get('msvs_external_builder_out_dir', '.')
-    msbuild_attributes['OutputDirectory'] = _FixPath(external_out_dir) + '\\'
+    project_dir = os.path.dirname(project_path)
+    msbuild_attributes['OutputDirectory'] = \
+        gyp.common.RelativePath(external_out_dir, project_dir) + '\\'

[bungeman-chromium, 2014/06/02 14:55:47]

The external_out_dir is relative to the gyp file in which the target was
defined. The OutputDirectory needs to be the same path, but relative to the
msbuild project file. As a result, using _FixPath here was actually correct. The
issue was just that msvs-ninja wasn't setting the path so that this would work.

 
   # Make sure that 'TargetPath' matches 'Lib.OutputFile' or 'Link.OutputFile'
   # (depending on the tool used) to avoid MSB8012 warning.
   msbuild_tool_map = {
       'executable': 'Link',
       'shared_library': 'Link',
       'loadable_module': 'Link',
       'static_library': 'Lib',
   }
   msbuild_tool = msbuild_tool_map.get(spec['type'])
   if msbuild_tool:
     msbuild_settings = config['finalized_msbuild_settings']
     out_file = msbuild_settings[msbuild_tool].get('OutputFile')
     if out_file:
       msbuild_attributes['TargetPath'] = _FixPath(out_file)
     target_ext = msbuild_settings[msbuild_tool].get('TargetExt')
     if target_ext:
       msbuild_attributes['TargetExt'] = target_ext
 
   return msbuild_attributes
 
 
-def _GetMSBuildConfigurationGlobalProperties(spec, configurations, build_file):
+def _GetMSBuildConfigurationGlobalProperties(spec, configurations,
+                                             build_file, project_path):
   # TODO(jeanluc) We could optimize out the following and do it only if
   # there are actions.
   # TODO(jeanluc) Handle the equivalent of setting 'CYGWIN=nontsec'.
   new_paths = []
   cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])[0]
   if cygwin_dirs:
     cyg_path = '$(MSBuildProjectDirectory)\\%s\\bin\\' % _FixPath(cygwin_dirs)
     new_paths.append(cyg_path)
     # TODO(jeanluc) Change the convention to have both a cygwin_dir and a
     # python_dir.
     python_path = cyg_path.replace('cygwin\\bin', 'python_26')
     new_paths.append(python_path)
     if new_paths:
       new_paths = '$(ExecutablePath);' + ';'.join(new_paths)
 
   properties = {}
   for (name, configuration) in sorted(configurations.iteritems()):
     condition = _GetConfigurationCondition(name, configuration)
-    attributes = _GetMSBuildAttributes(spec, configuration, build_file)
+    attributes = _GetMSBuildAttributes(spec, configuration,
+                                       build_file, project_path)
     msbuild_settings = configuration['finalized_msbuild_settings']
     _AddConditionalProperty(properties, condition, 'IntDir',
                             attributes['IntermediateDirectory'])
     _AddConditionalProperty(properties, condition, 'OutDir',
                             attributes['OutputDirectory'])
     _AddConditionalProperty(properties, condition, 'TargetName',
                             attributes['TargetName'])
 
     if attributes.get('TargetPath'):
       _AddConditionalProperty(properties, condition, 'TargetPath',
@@ skipping 409 matching lines @@
   content = [
       'Project',
       {'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003',
        'ToolsVersion': version.ProjectVersion(),
        'DefaultTargets': 'Build'
       }]
 
   content += _GetMSBuildProjectConfigurations(configurations)
   content += _GetMSBuildGlobalProperties(spec, project.guid, project_file_name)
   content += import_default_section
-  content += _GetMSBuildConfigurationDetails(spec, project.build_file)
+  content += _GetMSBuildConfigurationDetails(spec,
+                                             project.build_file, project.path)
   content += _GetMSBuildLocalProperties(project.msbuild_toolset)
   content += import_cpp_props_section
   content += _GetMSBuildExtensions(props_files_of_rules)
   content += _GetMSBuildPropertySheets(configurations)
   content += macro_section
   content += _GetMSBuildConfigurationGlobalProperties(spec, configurations,
-                                                      project.build_file)
+                                                      project.build_file,
+                                                      project.path)
   content += _GetMSBuildToolSettingsSections(spec, configurations)
   content += _GetMSBuildSources(
       spec, sources, exclusions, extension_to_rule_name, actions_spec,
       sources_handled_by_action, list_excluded)
   content += _GetMSBuildProjectReferences(project)
   content += import_cpp_targets_section
   content += _GetMSBuildExtensionTargets(targets_files_of_rules)
 
   if spec.get('msvs_external_builder'):
     content += _GetMSBuildExternalBuilderTargets(spec)
@@ skipping 121 matching lines @@
   action_spec.extend(
       # TODO(jeanluc) 'Document' for all or just if as_sources?
       [['FileType', 'Document'],
        ['Command', command],
        ['Message', description],
        ['Outputs', outputs]
       ])
   if additional_inputs:
     action_spec.append(['AdditionalInputs', additional_inputs])
   actions_spec.append(action_spec)