Support different project toolchains

tools/gn/visual_studio_writer.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/visual_studio_writer.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
@@ skipping 164 matching lines @@
 
 }  // namespace
 
 VisualStudioWriter::SolutionEntry::SolutionEntry(const std::string& _name,
                                                  const std::string& _path,
                                                  const std::string& _guid)
     : name(_name), path(_path), guid(_guid), parent_folder(nullptr) {}
 
 VisualStudioWriter::SolutionEntry::~SolutionEntry() = default;
 
+VisualStudioWriter::SolutionProject::SolutionProject(
+    const std::string& _name,
+    const std::string& _path,
+    const std::string& _guid,
+    const std::string& _label_dir_path,
+    const std::string& _config_platform)
+    : SolutionEntry(_name, _path, _guid),
+      label_dir_path(_label_dir_path),
+      config_platform(_config_platform) {}
+
+VisualStudioWriter::SolutionProject::~SolutionProject() = default;
+
 VisualStudioWriter::VisualStudioWriter(const BuildSettings* build_settings)
     : build_settings_(build_settings) {
   const Value* value = build_settings->build_args().GetArgOverride("is_debug");
   is_debug_config_ = value == nullptr || value->boolean_value();
   config_platform_ = "Win32";
   value = build_settings->build_args().GetArgOverride(variables::kTargetCpu);
   if (value != nullptr && value->string_value() == "x64")
     config_platform_ = "x64";
 
   windows_kits_include_dirs_ = GetWindowsKitsIncludeDirs();
 }
 
 VisualStudioWriter::~VisualStudioWriter() {
   STLDeleteContainerPointers(projects_.begin(), projects_.end());
   STLDeleteContainerPointers(folders_.begin(), folders_.end());
 }
 
 // static
 bool VisualStudioWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                           Builder* builder,
                                           Err* err) {
   std::vector<const Target*> targets = builder->GetAllResolvedTargets();
 
   VisualStudioWriter writer(build_settings);
   writer.projects_.reserve(targets.size());
   writer.folders_.reserve(targets.size());
 
-  std::set<std::string> processed_targets;
   for (const Target* target : targets) {
-    // Skip targets which are duplicated in vector.
-    std::string target_path =
-        target->label().dir().value() + target->label().name();
-    if (processed_targets.find(target_path) != processed_targets.end())
-      continue;
-
     // Skip actions and groups.
     if (target->output_type() == Target::GROUP ||
         target->output_type() == Target::COPY_FILES ||
         target->output_type() == Target::ACTION ||
         target->output_type() == Target::ACTION_FOREACH) {
       continue;
     }
 
     if (!writer.WriteProjectFiles(target, err))
       return false;
-
-    processed_targets.insert(target_path);
   }
 
   if (writer.projects_.empty()) {
     *err = Err(Location(), "No Visual Studio projects generated.");
     return false;
   }
 
   writer.ResolveSolutionFolders();
   return writer.WriteSolutionFile(err);
 }
 
 bool VisualStudioWriter::WriteProjectFiles(const Target* target, Err* err) {
+  std::string project_name = target->label().name();
+  std::string project_config_platform = config_platform_;
+  if (!target->settings()->is_default()) {
+    project_name += "_" + target->toolchain()->label().name();
+    project_config_platform = target->toolchain()
+                                  ->settings()
+                                  ->build_settings()
+                                  ->build_args()
+                                  .GetArgOverride(variables::kCurrentCpu)
+                                  ->string_value();
+    if (project_config_platform == "x86")
+      project_config_platform = "Win32";
+  }
+
   SourceFile target_file = GetTargetOutputDir(target).ResolveRelativeFile(
-      Value(nullptr, target->label().name() + ".vcxproj"), err);
+      Value(nullptr, project_name + ".vcxproj"), err);
   if (target_file.is_null())
     return false;
 
   base::FilePath vcxproj_path = build_settings_->GetFullPath(target_file);
   std::string vcxproj_path_str = FilePathToUTF8(vcxproj_path);
 
-  projects_.push_back(
-      new SolutionEntry(target->label().name(), vcxproj_path_str,
-                        MakeGuid(vcxproj_path_str, kGuidSeedProject)));
-  projects_.back()->label_dir_path =
-      FilePathToUTF8(build_settings_->GetFullPath(target->label().dir()));
+  projects_.push_back(new SolutionProject(
+      project_name, vcxproj_path_str,
+      MakeGuid(vcxproj_path_str, kGuidSeedProject),
+      FilePathToUTF8(build_settings_->GetFullPath(target->label().dir())),
+      project_config_platform));
 
   std::stringstream vcxproj_string_out;
   if (!WriteProjectFileContents(vcxproj_string_out, *projects_.back(), target,
                                 err)) {
     projects_.pop_back();
     return false;
   }
 
   // Only write the content to the file if it's different. That is
   // both a performance optimization and more importantly, prevents
@@ skipping 21 matching lines @@
                                  ".vcxproj.filters for writing");
       return false;
     }
   }
 
   return true;
 }
 
 bool VisualStudioWriter::WriteProjectFileContents(
     std::ostream& out,
-    const SolutionEntry& solution_project,
+    const SolutionProject& solution_project,
     const Target* target,
     Err* err) {
   PathOutput path_output(GetTargetOutputDir(target),
                          build_settings_->root_path_utf8(),
                          EscapingMode::ESCAPE_NONE);
 
   out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
   XmlElementWriter project(
       out, "Project",
       XmlAttributes("DefaultTargets", "Build")
           .add("ToolsVersion", kVisualStudioVersion)
           .add("xmlns", "http://schemas.microsoft.com/developer/msbuild/2003"));
 
   {
     scoped_ptr<XmlElementWriter> configurations = project.SubElement(
         "ItemGroup", XmlAttributes("Label", "ProjectConfigurations"));
     std::string config_name = is_debug_config_ ? "Debug" : "Release";
     scoped_ptr<XmlElementWriter> project_config = configurations->SubElement(
         "ProjectConfiguration",
-        XmlAttributes("Include", config_name + '|' + config_platform_));
+        XmlAttributes("Include",
+                      config_name + '|' + solution_project.config_platform));
     project_config->SubElement("Configuration")->Text(config_name);
-    project_config->SubElement("Platform")->Text(config_platform_);
+    project_config->SubElement("Platform")
+        ->Text(solution_project.config_platform);
   }
 
   {
     scoped_ptr<XmlElementWriter> globals =
         project.SubElement("PropertyGroup", XmlAttributes("Label", "Globals"));
     globals->SubElement("ProjectGuid")->Text(solution_project.guid);
     globals->SubElement("Keyword")->Text("Win32Proj");
     globals->SubElement("RootNamespace")->Text(target->label().name());
     globals->SubElement("IgnoreWarnCompileDuplicatedFilename")->Text("true");
     globals->SubElement("PreferredToolArchitecture")->Text("x64");
@@ skipping 287 matching lines @@
     out << "Project(\"" << kGuidTypeProject << "\") = \"" << project->name
         << "\", \"" << RebasePath(project->path, solution_dir, "/") << "\", \""
         << project->guid << "\"" << std::endl;
     out << "EndProject" << std::endl;
   }
 
   out << "Global" << std::endl;
 
   out << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution"
       << std::endl;
-  const std::string config_mode =
-      std::string(is_debug_config_ ? "Debug" : "Release") + '|' +
-      config_platform_;
+  const std::string config_mode_prefix =
+      std::string(is_debug_config_ ? "Debug" : "Release") + '|';
+  const std::string config_mode = config_mode_prefix + config_platform_;
   out << "\t\t" << config_mode << " = " << config_mode << std::endl;
   out << "\tEndGlobalSection" << std::endl;
 
   out << "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution"
       << std::endl;
-  for (const SolutionEntry* project : projects_) {
+  for (const SolutionProject* project : projects_) {
+    const std::string project_config_mode =
+        config_mode_prefix + project->config_platform;
     out << "\t\t" << project->guid << '.' << config_mode
-        << ".ActiveCfg = " << config_mode << std::endl;
+        << ".ActiveCfg = " << project_config_mode << std::endl;
     out << "\t\t" << project->guid << '.' << config_mode
-        << ".Build.0 = " << config_mode << std::endl;
+        << ".Build.0 = " << project_config_mode << std::endl;
   }
   out << "\tEndGlobalSection" << std::endl;
 
   out << "\tGlobalSection(SolutionProperties) = preSolution" << std::endl;
   out << "\t\tHideSolutionNode = FALSE" << std::endl;
   out << "\tEndGlobalSection" << std::endl;
 
   out << "\tGlobalSection(NestedProjects) = preSolution" << std::endl;
   for (const SolutionEntry* folder : folders_) {
     if (folder->parent_folder) {
       out << "\t\t" << folder->guid << " = " << folder->parent_folder->guid
           << std::endl;
     }
   }
   for (const SolutionEntry* project : projects_) {
     out << "\t\t" << project->guid << " = " << project->parent_folder->guid
         << std::endl;
   }
   out << "\tEndGlobalSection" << std::endl;
 
   out << "EndGlobal" << std::endl;
 }
 
 void VisualStudioWriter::ResolveSolutionFolders() {
   root_folder_path_.clear();
 
   // Get all project directories. Create solution folder for each directory.
   std::map<base::StringPiece, SolutionEntry*> processed_paths;
-  for (SolutionEntry* project : projects_) {
+  for (SolutionProject* project : projects_) {
     base::StringPiece folder_path = project->label_dir_path;
     if (IsSlash(folder_path[folder_path.size() - 1]))
       folder_path = folder_path.substr(0, folder_path.size() - 1);
     auto it = processed_paths.find(folder_path);
     if (it != processed_paths.end()) {
       project->parent_folder = it->second;
     } else {
       std::string folder_path_str = folder_path.as_string();
       SolutionEntry* folder = new SolutionEntry(
           FindLastDirComponent(SourceDir(folder_path)).as_string(),
@@ skipping 20 matching lines @@
         if (common_prefix_len < root_folder_path_.size()) {
           if (IsSlash(root_folder_path_[common_prefix_len - 1]))
             --common_prefix_len;
           root_folder_path_ = root_folder_path_.substr(0, common_prefix_len);
         }
       }
     }
   }
 
   // Create also all parent folders up to |root_folder_path_|.
-  SolutionEntries additional_folders;
+  SolutionFolders additional_folders;
   for (SolutionEntry* folder : folders_) {
     if (folder->path == root_folder_path_)
       continue;
 
     base::StringPiece parent_path;
     while ((parent_path = FindParentDir(&folder->path)) != root_folder_path_) {
       auto it = processed_paths.find(parent_path);
       if (it != processed_paths.end()) {
         folder = it->second;
       } else {
@@ skipping 10 matching lines @@
                   additional_folders.end());
 
   // Sort folders by path.
   std::sort(folders_.begin(), folders_.end(),
             [](const SolutionEntry* a, const SolutionEntry* b) {
               return a->path < b->path;
             });
 
   // Match subfolders with their parents. Since |folders_| are sorted by path we
   // know that parent folder always precedes its children in vector.
-  SolutionEntries parents;
+  SolutionFolders parents;
   for (SolutionEntry* folder : folders_) {
     while (!parents.empty()) {
       if (base::StartsWith(folder->path, parents.back()->path,
                            base::CompareCase::SENSITIVE)) {
         folder->parent_folder = parents.back();
         break;
       } else {
         parents.pop_back();
       }
     }
     parents.push_back(folder);
   }
 }