Associate xctest files with corresponding xctest targets.

tools/gn/xcode_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/xcode_writer.h"
 
 #include <iomanip>
 #include <map>
 #include <memory>
 #include <sstream>
@@ skipping 14 matching lines @@
 #include "tools/gn/settings.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/target.h"
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 #include "tools/gn/xcode_object.h"
 
 namespace {
 
 using TargetToFileList = std::unordered_map<const Target*, Target::FileList>;
+using TargetToNativeTarget =
+    std::unordered_map<const Target*, PBXNativeTarget*>;
+using FileToTargets = std::map<SourceFile,
+                               std::vector<const Target*>,
+                               bool (*)(const SourceFile&, const SourceFile&)>;
 
 const char kEarlGreyFileNameIdentifier[] = "egtest.mm";
 const char kXCTestFileNameIdentifier[] = "xctest.mm";
 const char kXCTestModuleTargetNamePostfix[] = "_module";
+const char kXCTestFileReferenceFolder[] = "xctests/";
 
 struct SafeEnvironmentVariableInfo {
   const char* name;
   bool capture_at_generation;
 };
 
 SafeEnvironmentVariableInfo kSafeEnvironmentVariables[] = {
     {"HOME", true}, {"LANG", true},    {"PATH", true},
     {"USER", true}, {"TMPDIR", false},
 };
@@ skipping 137 matching lines @@
     std::vector<Target::FileList>* file_lists) {
   TargetToFileList xctest_files_per_target;
 
   for (const Target* target : application_targets) {
     DCHECK(IsApplicationTarget(target));
     SearchXCTestFiles(target, &xctest_files_per_target);
     file_lists->push_back(xctest_files_per_target[target]);
   }
 }
 
+// Maps each xctest file to a list of xctest application targets that contains
+// the file.
+void MapXCTestFileToApplicationTargets(
+    const std::vector<const Target*>& xctest_application_targets,
+    const std::vector<Target::FileList>& xctest_file_lists,
+    FileToTargets* xctest_file_to_application_targets) {
+  DCHECK_EQ(xctest_application_targets.size(), xctest_file_lists.size());
+
+  for (size_t i = 0; i < xctest_application_targets.size(); ++i) {
+    const Target* xctest_application_target = xctest_application_targets[i];
+    DCHECK(IsApplicationTarget(xctest_application_target));
+
+    for (const SourceFile& source : xctest_file_lists[i]) {
+      if (xctest_file_to_application_targets->find(source) ==

[sdefresne, 2017/01/05 12:14:02]

I think you can avoid doing the search twice by using the fact that insert
returns a std::pair<iterator, bool>:

  auto iter = xctest_file_to_application_targets->find(source);
  if (iter == xctest_file_to_application_targets->end()) {
    iter = xctest_file_to_application_targets->insert(
        std::make_pair(source, std::vector<const Target*>())).first;
  }
  iter->push_back(xctest_application_target);

[liaoyuke, 2017/01/05 17:43:12]

Done.

+          xctest_file_to_application_targets->end()) {
+        xctest_file_to_application_targets->insert(
+            std::make_pair(source, std::vector<const Target*>()));
+      }
+
+      (*xctest_file_to_application_targets)[source].push_back(
+          xctest_application_target);
+    }
+  }
+}
+
 class CollectPBXObjectsPerClassHelper : public PBXObjectVisitor {
  public:
   CollectPBXObjectsPerClassHelper() {}
 
   void Visit(PBXObject* object) override {
     DCHECK(object);
     objects_per_class_[object->Class()].push_back(object);
   }
 
   const std::map<PBXObjectClass, std::vector<const PBXObject*>>&
@@ skipping 204 matching lines @@
   std::vector<Target::FileList> xctest_file_lists;
   FindXCTestFilesForTargets(xctest_application_targets, &xctest_file_lists);
   DCHECK_EQ(xctest_application_targets.size(), xctest_file_lists.size());
 
   std::string build_path;
   std::unique_ptr<base::Environment> env(base::Environment::Create());
 
   main_project->AddAggregateTarget(
       "All", GetBuildScript(root_target, ninja_extra_args, env.get()));
 
+  TargetToNativeTarget xctest_application_to_module_native_target;
+
   for (const Target* target : targets) {
     switch (target->output_type()) {
       case Target::EXECUTABLE:
         if (target_os == XcodeWriter::WRITER_TARGET_OS_IOS)
           continue;
 
         main_project->AddNativeTarget(
             target->label().name(), "compiled.mach-o.executable",
             target->output_name().empty() ? target->label().name()
                                           : target->output_name(),
@@ skipping 10 matching lines @@
         // discovery of tests function for XCTest, but the compilation is done
         // via ninja and thus must prevent Xcode from linking object files via
         // this hack.
         PBXAttributes extra_attributes;
         if (IsXCTestModuleTarget(target)) {
           extra_attributes["OTHER_LDFLAGS"] = "-help";
           extra_attributes["ONLY_ACTIVE_ARCH"] = "YES";
           extra_attributes["DEBUG_INFORMATION_FORMAT"] = "dwarf";
         }
 
-        main_project->AddNativeTarget(
+        PBXNativeTarget* native_target = main_project->AddNativeTarget(
             target->label().name(), std::string(),
             RebasePath(target->bundle_data()
                            .GetBundleRootDirOutput(target->settings())
                            .value(),
                        build_settings->build_dir()),
             target->bundle_data().product_type(),
             GetBuildScript(target->label().name(), ninja_extra_args, env.get()),
             extra_attributes);
+
+        if (!IsXCTestModuleTarget(target))
+          continue;
+
+        // populate |xctest_application_to_module_native_target| for XCTest

[sdefresne, 2017/01/05 12:14:02]

s/populate/Populate/

[liaoyuke, 2017/01/05 17:43:12]

Done.

+        // module targets.
+        const Target* application_target =
+            FindXCTestApplicationTarget(target, xctest_application_targets);
+        xctest_application_to_module_native_target.insert(
+            std::make_pair(application_target, native_target));
+
         break;
       }
 
       default:
         break;
     }
   }
 
+  FileToTargets xctest_file_to_application_targets(

[sdefresne, 2017/01/05 12:14:02]

Please move this to be a real free function in the anonymous namespace instead
of a lambda.

[liaoyuke, 2017/01/05 17:43:12]

Done.

+      [](const SourceFile& lhs, const SourceFile& rhs) {
+        if (lhs.GetName() < rhs.GetName())
+          return true;
+        else if (lhs.GetName() > rhs.GetName())
+          return false;
+        else
+          return lhs.value() < rhs.value();
+      });
+  MapXCTestFileToApplicationTargets(xctest_application_targets,
+                                    xctest_file_lists,
+                                    &xctest_file_to_application_targets);
+
+  // Add xctest files to the "Compiler Sources" of corresponding xctest native
+  // targets.
+  SourceDir source_dir("//");
+  for (const auto& item : xctest_file_to_application_targets) {
+    const SourceFile& source = item.first;
+    for (const Target* xctest_application_target : item.second) {
+      std::string navigator_path =
+          kXCTestFileReferenceFolder + source.GetName();
+      std::string source_path = RebasePath(source.value(), source_dir,
+                                           build_settings->root_path_utf8());
+      PBXNativeTarget* xctest_module_native_target =
+          xctest_application_to_module_native_target[xctest_application_target];
+
+      // Test files need to be known to Xcode for proper indexing and for
+      // discovery of tests function for XCTest, but the compilation is done
+      // via ninja and thus must prevent Xcode from compiling the files by
+      // adding '-help' as per file compiler flag.
+      main_project->AddSourceFile(navigator_path, source_path,
+                                  CompilerFlags::HELP,
+                                  xctest_module_native_target);
+    }
+  }
+
   projects_.push_back(std::move(main_project));
 }
 
 void XcodeWriter::CreateSourcesProject(
     const std::vector<const Target*>& targets,
     const SourceDir& root_build_dir,
     const PBXAttributes& attributes,
     const std::string& source_path,
     const std::string& absolute_source_path,
     const std::string& config_name,
@@ skipping 96 matching lines @@
     for (auto* object : pair.second) {
       object->Print(out, 2);
     }
     out << "/* End " << ToString(pair.first) << " section */\n";
   }
 
   out << "\t};\n"
       << "\trootObject = " << project->Reference() << ";\n"
       << "}\n";
 }