msvs: Fix rule dependencies for VS2013

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
@@ skipping 799 matching lines @@
   rules_external = [r for r in rules if int(r.get('msvs_external_rule', 0))]
 
   # Handle rules that use a native rules file.
   if rules_native:
     _GenerateNativeRulesForMSVS(p, rules_native, output_dir, spec, options)
 
   # Handle external rules (non-native rules).
   if rules_external:
     _GenerateExternalRules(rules_external, output_dir, spec,
                            sources, options, actions_to_add)
-  _AdjustSourcesForRules(spec, rules, sources, excluded_sources)
+  _AdjustSourcesForRules(rules, sources, excluded_sources, False)
 
 
-def _AdjustSourcesForRules(spec, rules, sources, excluded_sources):
+def _AdjustSourcesForRules(rules, sources, excluded_sources, is_msbuild):
   # Add outputs generated by each rule (if applicable).
   for rule in rules:
     # Add in the outputs from this rule.
     trigger_files = _FindRuleTriggerFiles(rule, sources)
     for trigger_file in trigger_files:
       # Remove trigger_file from excluded_sources to let the rule be triggered
       # (e.g. rule trigger ax_enums.idl is added to excluded_sources
       # because it's also in an action's inputs in the same project)
       excluded_sources.discard(_FixPath(trigger_file))
       # Done if not processing outputs as sources.
       if int(rule.get('process_outputs_as_sources', False)):
         inputs, outputs = _RuleInputsAndOutputs(rule, trigger_file)
         inputs = OrderedSet(_FixPaths(inputs))
         outputs = OrderedSet(_FixPaths(outputs))
         inputs.remove(_FixPath(trigger_file))
         sources.update(inputs)
-        if not spec.get('msvs_external_builder'):
+        if not is_msbuild:
           excluded_sources.update(inputs)
         sources.update(outputs)
 
 
 def _FilterActionsFromExcluded(excluded_sources, actions_to_add):
   """Take inputs with actions attached out of the list of exclusions.
 
   Arguments:
     excluded_sources: list of source files not to be built.
     actions_to_add: dict of actions keyed on source file they're attached to.
@@ skipping 1155 matching lines @@
   if missing_sources:
     error_message = "Missing input files:\n" + \
                     '\n'.join(set(missing_sources))
     if generator_flags.get('msvs_error_on_missing_sources', False):
       raise GypError(error_message)
     else:
       print >> sys.stdout, "Warning: " + error_message
 
 
 def _GenerateMSBuildFiltersFile(filters_path, source_files,
-                                extension_to_rule_name):
+                                rule_dependencies, extension_to_rule_name):
   """Generate the filters file.
 
   This file is used by Visual Studio to organize the presentation of source
   files into folders.
 
   Arguments:
       filters_path: The path of the file to be created.
       source_files: The hierarchical structure of all the sources.
       extension_to_rule_name: A dictionary mapping file extensions to rules.
   """
   filter_group = []
   source_group = []
-  _AppendFiltersForMSBuild('', source_files, extension_to_rule_name,
-                           filter_group, source_group)
+  _AppendFiltersForMSBuild('', source_files, rule_dependencies,
+                           extension_to_rule_name, filter_group, source_group)
   if filter_group:
     content = ['Project',
                {'ToolsVersion': '4.0',
                 'xmlns': 'http://schemas.microsoft.com/developer/msbuild/2003'
                },
                ['ItemGroup'] + filter_group,
                ['ItemGroup'] + source_group
               ]
     easy_xml.WriteXmlIfChanged(content, filters_path, pretty=True, win32=True)
   elif os.path.exists(filters_path):
     # We don't need this filter anymore.  Delete the old filter file.
     os.unlink(filters_path)
 
 
-def _AppendFiltersForMSBuild(parent_filter_name, sources,
+def _AppendFiltersForMSBuild(parent_filter_name, sources, rule_dependencies,
                              extension_to_rule_name,
                              filter_group, source_group):
   """Creates the list of filters and sources to be added in the filter file.
 
   Args:
       parent_filter_name: The name of the filter under which the sources are
           found.
       sources: The hierarchy of filters and sources to process.
       extension_to_rule_name: A dictionary mapping file extensions to rules.
       filter_group: The list to which filter entries will be appended.
       source_group: The list to which source entries will be appeneded.
   """
   for source in sources:
     if isinstance(source, MSVSProject.Filter):
       # We have a sub-filter.  Create the name of that sub-filter.
       if not parent_filter_name:
         filter_name = source.name
       else:
         filter_name = '%s\\%s' % (parent_filter_name, source.name)
       # Add the filter to the group.
       filter_group.append(
           ['Filter', {'Include': filter_name},
            ['UniqueIdentifier', MSVSNew.MakeGuid(source.name)]])
       # Recurse and add its dependents.
       _AppendFiltersForMSBuild(filter_name, source.contents,
-                               extension_to_rule_name,
+                               rule_dependencies, extension_to_rule_name,
                                filter_group, source_group)
     else:
       # It's a source.  Create a source entry.
-      _, element = _MapFileToMsBuildSourceType(source, extension_to_rule_name)
+      _, element = _MapFileToMsBuildSourceType(source, rule_dependencies,
+                                               extension_to_rule_name)
       source_entry = [element, {'Include': source}]
       # Specify the filter it is part of, if any.
       if parent_filter_name:
         source_entry.append(['Filter', parent_filter_name])
       source_group.append(source_entry)
 
 
-def _MapFileToMsBuildSourceType(source, extension_to_rule_name):
+def _MapFileToMsBuildSourceType(source, rule_dependencies,
+                                extension_to_rule_name):
   """Returns the group and element type of the source file.
 
   Arguments:
       source: The source file name.
       extension_to_rule_name: A dictionary mapping file extensions to rules.
 
   Returns:
       A pair of (group this file should be part of, the label of element)
   """
   _, ext = os.path.splitext(source)
   if ext in extension_to_rule_name:
     group = 'rule'
     element = extension_to_rule_name[ext]
   elif ext in ['.cc', '.cpp', '.c', '.cxx']:
     group = 'compile'
     element = 'ClCompile'
   elif ext in ['.h', '.hxx']:
     group = 'include'
     element = 'ClInclude'
   elif ext == '.rc':
     group = 'resource'
     element = 'ResourceCompile'
   elif ext == '.idl':
     group = 'midl'
     element = 'Midl'
+  elif source in rule_dependencies:
+    group = 'rule_dependency'
+    element = 'CustomBuild'
   else:
     group = 'none'
     element = 'None'
   return (group, element)
 
 
 def _GenerateRulesForMSBuild(output_dir, options, spec,
                              sources, excluded_sources,
                              props_files_of_rules, targets_files_of_rules,
-                             actions_to_add, extension_to_rule_name):
+                             actions_to_add, rule_dependencies,
+                             extension_to_rule_name):
   # MSBuild rules are implemented using three files: an XML file, a .targets
   # file and a .props file.
   # See http://blogs.msdn.com/b/vcblog/archive/2010/04/21/quick-help-on-vs2010-custom-build-rule.aspx
   # for more details.
   rules = spec.get('rules', [])
   rules_native = [r for r in rules if not int(r.get('msvs_external_rule', 0))]
   rules_external = [r for r in rules if int(r.get('msvs_external_rule', 0))]
 
   msbuild_rules = []
   for rule in rules_native:
     # Skip a rule with no action and no inputs.
     if 'action' not in rule and not rule.get('rule_sources', []):
       continue
     msbuild_rule = MSBuildRule(rule, spec)
     msbuild_rules.append(msbuild_rule)
+    rule_dependencies.update(msbuild_rule.additional_dependencies.split(';'))
     extension_to_rule_name[msbuild_rule.extension] = msbuild_rule.rule_name
   if msbuild_rules:
     base = spec['target_name'] + options.suffix
     props_name = base + '.props'
     targets_name = base + '.targets'
     xml_name = base + '.xml'
 
     props_files_of_rules.add(props_name)
     targets_files_of_rules.add(targets_name)
 
     props_path = os.path.join(output_dir, props_name)
     targets_path = os.path.join(output_dir, targets_name)
     xml_path = os.path.join(output_dir, xml_name)
 
     _GenerateMSBuildRulePropsFile(props_path, msbuild_rules)
     _GenerateMSBuildRuleTargetsFile(targets_path, msbuild_rules)
     _GenerateMSBuildRuleXmlFile(xml_path, msbuild_rules)
 
   if rules_external:
     _GenerateExternalRules(rules_external, output_dir, spec,
                            sources, options, actions_to_add)
-  _AdjustSourcesForRules(spec, rules, sources, excluded_sources)
+  _AdjustSourcesForRules(rules, sources, excluded_sources, True)
 
 
 class MSBuildRule(object):
   """Used to store information used to generate an MSBuild rule.
 
   Attributes:
     rule_name: The rule name, sanitized to use in XML.
     target_name: The name of the target.
     after_targets: The name of the AfterTargets element.
     before_targets: The name of the BeforeTargets element.
@@ skipping 900 matching lines @@
     if isinstance(source, MSVSProject.Filter):
       missing_sources.extend(_VerifySourcesExist(source.contents, root_dir))
     else:
       if '$' not in source:
         full_path = os.path.join(root_dir, source)
         if not os.path.exists(full_path):
           missing_sources.append(full_path)
   return missing_sources
 
 
-def _GetMSBuildSources(spec, sources, exclusions, extension_to_rule_name,
-                       actions_spec, sources_handled_by_action, list_excluded):
-  groups = ['none', 'midl', 'include', 'compile', 'resource', 'rule']
+def _GetMSBuildSources(spec, sources, exclusions, rule_dependencies,
+                       extension_to_rule_name, actions_spec,
+                       sources_handled_by_action, list_excluded):
+  groups = ['none', 'midl', 'include', 'compile', 'resource', 'rule',
+            'rule_dependency']
   grouped_sources = {}
   for g in groups:
     grouped_sources[g] = []
 
   _AddSources2(spec, sources, exclusions, grouped_sources,
-               extension_to_rule_name, sources_handled_by_action, list_excluded)
+               rule_dependencies, extension_to_rule_name,
+               sources_handled_by_action, list_excluded)
   sources = []
   for g in groups:
     if grouped_sources[g]:
       sources.append(['ItemGroup'] + grouped_sources[g])
   if actions_spec:
     sources.append(['ItemGroup'] + actions_spec)
   return sources
 
 
 def _AddSources2(spec, sources, exclusions, grouped_sources,
-                 extension_to_rule_name, sources_handled_by_action,
+                 rule_dependencies, extension_to_rule_name,
+                 sources_handled_by_action,
                  list_excluded):
   extensions_excluded_from_precompile = []
   for source in sources:
     if isinstance(source, MSVSProject.Filter):
       _AddSources2(spec, source.contents, exclusions, grouped_sources,
-                   extension_to_rule_name, sources_handled_by_action,
+                   rule_dependencies, extension_to_rule_name,
+                   sources_handled_by_action,
                    list_excluded)
     else:
       if not source in sources_handled_by_action:
         detail = []
         excluded_configurations = exclusions.get(source, [])
         if len(excluded_configurations) == len(spec['configurations']):
           detail.append(['ExcludedFromBuild', 'true'])
         else:
           for config_name, configuration in sorted(excluded_configurations):
             condition = _GetConfigurationCondition(config_name, configuration)
@@ skipping 22 matching lines @@
                           ])
           else:
             # Turn off precompiled header usage for source files of a
             # different type than the file that generated the
             # precompiled header.
             for extension in extensions_excluded_from_precompile:
               if source.endswith(extension):
                 detail.append(['PrecompiledHeader', ''])
                 detail.append(['ForcedIncludeFiles', ''])
 
-        group, element = _MapFileToMsBuildSourceType(source,
+        group, element = _MapFileToMsBuildSourceType(source, rule_dependencies,
                                                      extension_to_rule_name)
         grouped_sources[group].append([element, {'Include': source}] + detail)
 
 
 def _GetMSBuildProjectReferences(project):
   references = []
   if project.dependencies:
     group = ['ItemGroup']
     for dependency in project.dependencies:
       guid = dependency.guid
@@ skipping 23 matching lines @@
   gyp_path = _NormalizedSource(project.build_file)
   relative_path_of_gyp_file = gyp.common.RelativePath(gyp_path, project_dir)
 
   gyp_file = os.path.split(project.build_file)[1]
   sources, excluded_sources = _PrepareListOfSources(spec, generator_flags,
                                                     gyp_file)
   # Add rules.
   actions_to_add = {}
   props_files_of_rules = set()
   targets_files_of_rules = set()
+  rule_dependencies = set()
   extension_to_rule_name = {}
   list_excluded = generator_flags.get('msvs_list_excluded_files', True)
 
   # Don't generate rules if we are using an external builder like ninja.
   if not spec.get('msvs_external_builder'):
     _GenerateRulesForMSBuild(project_dir, options, spec,
                              sources, excluded_sources,
                              props_files_of_rules, targets_files_of_rules,
-                             actions_to_add, extension_to_rule_name)
+                             actions_to_add, rule_dependencies,
+                             extension_to_rule_name)
   else:
     rules = spec.get('rules', [])
-    _AdjustSourcesForRules(spec, rules, sources, excluded_sources)
+    _AdjustSourcesForRules(rules, sources, excluded_sources, True)
 
   sources, excluded_sources, excluded_idl = (
       _AdjustSourcesAndConvertToFilterHierarchy(spec, options,
                                                 project_dir, sources,
                                                 excluded_sources,
                                                 list_excluded, version))
 
   # Don't add actions if we are using an external builder like ninja.
   if not spec.get('msvs_external_builder'):
     _AddActions(actions_to_add, spec, project.build_file)
     _AddCopies(actions_to_add, spec)
 
     # NOTE: this stanza must appear after all actions have been decided.
     # Don't excluded sources with actions attached, or they won't run.
     excluded_sources = _FilterActionsFromExcluded(
         excluded_sources, actions_to_add)
 
   exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
   actions_spec, sources_handled_by_action = _GenerateActionsForMSBuild(
       spec, actions_to_add)
 
   _GenerateMSBuildFiltersFile(project.path + '.filters', sources,
+                              rule_dependencies,
                               extension_to_rule_name)
   missing_sources = _VerifySourcesExist(sources, project_dir)
 
   for configuration in configurations.itervalues():
     _FinalizeMSBuildSettings(spec, configuration)
 
   # Add attributes to root element
 
   import_default_section = [
       ['Import', {'Project': r'$(VCTargetsPath)\Microsoft.Cpp.Default.props'}]]
@@ skipping 19 matching lines @@
   else:
    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)
   content += _GetMSBuildToolSettingsSections(spec, configurations)
   content += _GetMSBuildSources(
-      spec, sources, exclusions, extension_to_rule_name, actions_spec,
-      sources_handled_by_action, list_excluded)
+      spec, sources, exclusions, rule_dependencies, 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)
 
   # TODO(jeanluc) File a bug to get rid of runas.  We had in MSVS:
   # has_run_as = _WriteMSVSUserFile(project.path, version, spec)
 
@@ skipping 117 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)