Implement tracking of BUILD.gn files used to define target, toolchain or

tools/gn/ninja_binary_target_writer_unittest.cc

 // Copyright (c) 2013 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/ninja_binary_target_writer.h"
 
 #include <sstream>
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/target.h"
 #include "tools/gn/test_with_scope.h"
 
 TEST(NinjaBinaryTargetWriter, SourceSet) {
   Err err;
   TestWithScope setup;
 
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"), {});
   target.set_output_type(Target::SOURCE_SET);
   target.visibility().SetPublic();
   target.sources().push_back(SourceFile("//foo/input1.cc"));
   target.sources().push_back(SourceFile("//foo/input2.cc"));
   // Also test object files, which should be just passed through to the
   // dependents to link.
   target.sources().push_back(SourceFile("//foo/input3.o"));
   target.sources().push_back(SourceFile("//foo/input4.obj"));
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
@@ skipping 16 matching lines @@
         "build obj/foo/bar.input1.o: cxx ../../foo/input1.cc\n"
         "build obj/foo/bar.input2.o: cxx ../../foo/input2.cc\n"
         "\n"
         "build obj/foo/bar.stamp: stamp obj/foo/bar.input1.o "
             "obj/foo/bar.input2.o ../../foo/input3.o ../../foo/input4.obj\n";
     std::string out_str = out.str();
     EXPECT_EQ(expected, out_str);
   }
 
   // A shared library that depends on the source set.
-  Target shlib_target(setup.settings(), Label(SourceDir("//foo/"), "shlib"));
+  Target shlib_target(setup.settings(), Label(SourceDir("//foo/"), "shlib"),
+                      {});
   shlib_target.set_output_type(Target::SHARED_LIBRARY);
   shlib_target.public_deps().push_back(LabelTargetPair(&target));
   shlib_target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(shlib_target.OnResolved(&err));
 
   {
     std::ostringstream out;
     NinjaBinaryTargetWriter writer(&shlib_target, out);
     writer.Run();
 
@@ skipping 13 matching lines @@
             "|| obj/foo/bar.stamp\n"
         "  ldflags =\n"
         "  libs =\n"
         "  output_extension = .so\n"
         "  output_dir = \n";
     std::string out_str = out.str();
     EXPECT_EQ(expected, out_str);
   }
 
   // A static library that depends on the source set (should not link it).
-  Target stlib_target(setup.settings(), Label(SourceDir("//foo/"), "stlib"));
+  Target stlib_target(setup.settings(), Label(SourceDir("//foo/"), "stlib"),
+                      {});
   stlib_target.set_output_type(Target::STATIC_LIBRARY);
   stlib_target.public_deps().push_back(LabelTargetPair(&target));
   stlib_target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(stlib_target.OnResolved(&err));
 
   {
     std::ostringstream out;
     NinjaBinaryTargetWriter writer(&stlib_target, out);
     writer.Run();
 
@@ skipping 151 matching lines @@
   }
 }
 
 // This tests that output extension and output dir overrides apply, and input
 // dependencies are applied.
 TEST(NinjaBinaryTargetWriter, OutputExtensionAndInputDeps) {
   Err err;
   TestWithScope setup;
 
   // An action for our library to depend on.
-  Target action(setup.settings(), Label(SourceDir("//foo/"), "action"));
+  Target action(setup.settings(), Label(SourceDir("//foo/"), "action"), {});
   action.set_output_type(Target::ACTION_FOREACH);
   action.visibility().SetPublic();
   action.SetToolchain(setup.toolchain());
   ASSERT_TRUE(action.OnResolved(&err));
 
   // A shared library w/ the output_extension set to a custom value.
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "shlib"));
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "shlib"), {});
   target.set_output_type(Target::SHARED_LIBRARY);
   target.set_output_extension(std::string("so.6"));
   target.set_output_dir(SourceDir("//out/Debug/foo/"));
   target.sources().push_back(SourceFile("//foo/input1.cc"));
   target.sources().push_back(SourceFile("//foo/input2.cc"));
   target.public_deps().push_back(LabelTargetPair(&action));
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   std::ostringstream out;
@@ skipping 27 matching lines @@
   std::string out_str = out.str();
   EXPECT_EQ(expected, out_str);
 }
 
 // Tests libs are applied.
 TEST(NinjaBinaryTargetWriter, LibsAndLibDirs) {
   Err err;
   TestWithScope setup;
 
   // A shared library w/ libs and lib_dirs.
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "shlib"));
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "shlib"), {});
   target.set_output_type(Target::SHARED_LIBRARY);
   target.config_values().libs().push_back(LibFile(SourceFile("//foo/lib1.a")));
   target.config_values().libs().push_back(LibFile("foo"));
   target.config_values().lib_dirs().push_back(SourceDir("//foo/bar/"));
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   std::ostringstream out;
   NinjaBinaryTargetWriter writer(&target, out);
   writer.Run();
@@ skipping 16 matching lines @@
   EXPECT_EQ(expected, out_str);
 }
 
 TEST(NinjaBinaryTargetWriter, EmptyOutputExtension) {
   Err err;
   TestWithScope setup;
 
   // This test is the same as OutputExtensionAndInputDeps, except that we call
   // set_output_extension("") and ensure that we get an empty one and override
   // the output prefix so that the name matches the target exactly.
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "shlib"));
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "shlib"), {});
   target.set_output_type(Target::SHARED_LIBRARY);
   target.set_output_prefix_override(true);
   target.set_output_extension(std::string());
   target.sources().push_back(SourceFile("//foo/input1.cc"));
   target.sources().push_back(SourceFile("//foo/input2.cc"));
 
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   std::ostringstream out;
@@ skipping 21 matching lines @@
 
   std::string out_str = out.str();
   EXPECT_EQ(expected, out_str);
 }
 
 TEST(NinjaBinaryTargetWriter, SourceSetDataDeps) {
   Err err;
   TestWithScope setup;
 
   // This target is a data (runtime) dependency of the intermediate target.
-  Target data(setup.settings(), Label(SourceDir("//foo/"), "data_target"));
+  Target data(setup.settings(), Label(SourceDir("//foo/"), "data_target"), {});
   data.set_output_type(Target::EXECUTABLE);
   data.visibility().SetPublic();
   data.SetToolchain(setup.toolchain());
   ASSERT_TRUE(data.OnResolved(&err));
 
   // Intermediate source set target.
-  Target inter(setup.settings(), Label(SourceDir("//foo/"), "inter"));
+  Target inter(setup.settings(), Label(SourceDir("//foo/"), "inter"), {});
   inter.set_output_type(Target::SOURCE_SET);
   inter.visibility().SetPublic();
   inter.data_deps().push_back(LabelTargetPair(&data));
   inter.SetToolchain(setup.toolchain());
   inter.sources().push_back(SourceFile("//foo/inter.cc"));
   ASSERT_TRUE(inter.OnResolved(&err)) << err.message();
 
   // Write out the intermediate target.
   std::ostringstream inter_out;
   NinjaBinaryTargetWriter inter_writer(&inter, inter_out);
@@ skipping 11 matching lines @@
       "target_out_dir = obj/foo\n"
       "target_output_name = inter\n"
       "\n"
       "build obj/foo/inter.inter.o: cxx ../../foo/inter.cc\n"
       "\n"
       "build obj/foo/inter.stamp: stamp obj/foo/inter.inter.o || "
           "./data_target\n";
   EXPECT_EQ(inter_expected, inter_out.str());
 
   // Final target.
-  Target exe(setup.settings(), Label(SourceDir("//foo/"), "exe"));
+  Target exe(setup.settings(), Label(SourceDir("//foo/"), "exe"), {});
   exe.set_output_type(Target::EXECUTABLE);
   exe.public_deps().push_back(LabelTargetPair(&inter));
   exe.SetToolchain(setup.toolchain());
   exe.sources().push_back(SourceFile("//foo/final.cc"));
   ASSERT_TRUE(exe.OnResolved(&err));
 
   std::ostringstream final_out;
   NinjaBinaryTargetWriter final_writer(&exe, final_out);
   final_writer.Run();
 
@@ skipping 19 matching lines @@
       "  libs =\n"
       "  output_extension = \n"
       "  output_dir = \n";
   EXPECT_EQ(final_expected, final_out.str());
 }
 
 TEST(NinjaBinaryTargetWriter, SharedLibraryModuleDefinitionFile) {
   Err err;
   TestWithScope setup;
 
-  Target shared_lib(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  Target shared_lib(setup.settings(), Label(SourceDir("//foo/"), "bar"), {});
   shared_lib.set_output_type(Target::SHARED_LIBRARY);
   shared_lib.SetToolchain(setup.toolchain());
   shared_lib.sources().push_back(SourceFile("//foo/sources.cc"));
   shared_lib.sources().push_back(SourceFile("//foo/bar.def"));
   ASSERT_TRUE(shared_lib.OnResolved(&err));
 
   std::ostringstream out;
   NinjaBinaryTargetWriter writer(&shared_lib, out);
   writer.Run();
 
@@ skipping 13 matching lines @@
       "  libs =\n"
       "  output_extension = .so\n"
       "  output_dir = \n";
   EXPECT_EQ(expected, out.str());
 }
 
 TEST(NinjaBinaryTargetWriter, LoadableModule) {
   Err err;
   TestWithScope setup;
 
-  Target loadable_module(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  Target loadable_module(setup.settings(), Label(SourceDir("//foo/"), "bar"),
+                         {});
   loadable_module.set_output_type(Target::LOADABLE_MODULE);
   loadable_module.visibility().SetPublic();
   loadable_module.SetToolchain(setup.toolchain());
   loadable_module.sources().push_back(SourceFile("//foo/sources.cc"));
   ASSERT_TRUE(loadable_module.OnResolved(&err)) << err.message();
 
   std::ostringstream out;
   NinjaBinaryTargetWriter writer(&loadable_module, out);
   writer.Run();
 
   const char loadable_expected[] =
       "defines =\n"
       "include_dirs =\n"
       "cflags =\n"
       "cflags_cc =\n"
       "root_out_dir = .\n"
       "target_out_dir = obj/foo\n"
       "target_output_name = libbar\n"
       "\n"
       "build obj/foo/libbar.sources.o: cxx ../../foo/sources.cc\n"
       "\n"
       "build ./libbar.so: solink_module obj/foo/libbar.sources.o\n"
       "  ldflags =\n"
       "  libs =\n"
       "  output_extension = .so\n"
       "  output_dir = \n";
   EXPECT_EQ(loadable_expected, out.str());
 
   // Final target.
-  Target exe(setup.settings(), Label(SourceDir("//foo/"), "exe"));
+  Target exe(setup.settings(), Label(SourceDir("//foo/"), "exe"), {});
   exe.set_output_type(Target::EXECUTABLE);
   exe.public_deps().push_back(LabelTargetPair(&loadable_module));
   exe.SetToolchain(setup.toolchain());
   exe.sources().push_back(SourceFile("//foo/final.cc"));
   ASSERT_TRUE(exe.OnResolved(&err)) << err.message();
 
   std::ostringstream final_out;
   NinjaBinaryTargetWriter final_writer(&exe, final_out);
   final_writer.Run();
 
@@ skipping 20 matching lines @@
 
 TEST(NinjaBinaryTargetWriter, WinPrecompiledHeaders) {
   Err err;
 
   // This setup's toolchain does not have precompiled headers defined.
   TestWithScope setup;
 
   // A precompiled header toolchain.
   Settings pch_settings(setup.build_settings(), "withpch/");
   Toolchain pch_toolchain(&pch_settings,
-                          Label(SourceDir("//toolchain/"), "withpch"));
+                          Label(SourceDir("//toolchain/"), "withpch"), {});
   pch_settings.set_toolchain_label(pch_toolchain.label());
   pch_settings.set_default_toolchain_label(setup.toolchain()->label());
 
   // Declare a C++ compiler that supports PCH.
   std::unique_ptr<Tool> cxx_tool(new Tool);
   TestWithScope::SetCommandForTool(
       "c++ {{source}} {{cflags}} {{cflags_cc}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
       cxx_tool.get());
   cxx_tool->set_outputs(SubstitutionList::MakeForTest(
       "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o"));
   cxx_tool->set_precompiled_header_type(Tool::PCH_MSVC);
   pch_toolchain.SetTool(Toolchain::TYPE_CXX, std::move(cxx_tool));
 
   // Add a C compiler as well.
   std::unique_ptr<Tool> cc_tool(new Tool);
   TestWithScope::SetCommandForTool(
       "cc {{source}} {{cflags}} {{cflags_c}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
       cc_tool.get());
   cc_tool->set_outputs(SubstitutionList::MakeForTest(
       "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o"));
   cc_tool->set_precompiled_header_type(Tool::PCH_MSVC);
   pch_toolchain.SetTool(Toolchain::TYPE_CC, std::move(cc_tool));
   pch_toolchain.ToolchainSetupComplete();
 
   // This target doesn't specify precompiled headers.
   {
     Target no_pch_target(&pch_settings,
-                         Label(SourceDir("//foo/"), "no_pch_target"));
+                         Label(SourceDir("//foo/"), "no_pch_target"), {});
     no_pch_target.set_output_type(Target::SOURCE_SET);
     no_pch_target.visibility().SetPublic();
     no_pch_target.sources().push_back(SourceFile("//foo/input1.cc"));
     no_pch_target.sources().push_back(SourceFile("//foo/input2.c"));
     no_pch_target.config_values().cflags_c().push_back("-std=c99");
     no_pch_target.SetToolchain(&pch_toolchain);
     ASSERT_TRUE(no_pch_target.OnResolved(&err));
 
     std::ostringstream out;
     NinjaBinaryTargetWriter writer(&no_pch_target, out);
@@ skipping 13 matching lines @@
                "withpch_cc ../../foo/input2.c\n"
         "\n"
         "build withpch/obj/foo/no_pch_target.stamp: "
                "withpch_stamp withpch/obj/foo/no_pch_target.input1.o "
                "withpch/obj/foo/no_pch_target.input2.o\n";
     EXPECT_EQ(no_pch_expected, out.str());
   }
 
   // This target specifies PCH.
   {
-    Target pch_target(&pch_settings,
-                      Label(SourceDir("//foo/"), "pch_target"));
+    Target pch_target(&pch_settings, Label(SourceDir("//foo/"), "pch_target"),
+                      {});
     pch_target.config_values().set_precompiled_header("build/precompile.h");
     pch_target.config_values().set_precompiled_source(
         SourceFile("//build/precompile.cc"));
     pch_target.set_output_type(Target::SOURCE_SET);
     pch_target.visibility().SetPublic();
     pch_target.sources().push_back(SourceFile("//foo/input1.cc"));
     pch_target.sources().push_back(SourceFile("//foo/input2.c"));
     pch_target.SetToolchain(&pch_toolchain);
     ASSERT_TRUE(pch_target.OnResolved(&err));
 
@@ skipping 42 matching lines @@
 
 TEST(NinjaBinaryTargetWriter, GCCPrecompiledHeaders) {
   Err err;
 
   // This setup's toolchain does not have precompiled headers defined.
   TestWithScope setup;
 
   // A precompiled header toolchain.
   Settings pch_settings(setup.build_settings(), "withpch/");
   Toolchain pch_toolchain(&pch_settings,
-                          Label(SourceDir("//toolchain/"), "withpch"));
+                          Label(SourceDir("//toolchain/"), "withpch"), {});
   pch_settings.set_toolchain_label(pch_toolchain.label());
   pch_settings.set_default_toolchain_label(setup.toolchain()->label());
 
   // Declare a C++ compiler that supports PCH.
   std::unique_ptr<Tool> cxx_tool(new Tool);
   TestWithScope::SetCommandForTool(
       "c++ {{source}} {{cflags}} {{cflags_cc}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
       cxx_tool.get());
   cxx_tool->set_outputs(SubstitutionList::MakeForTest(
@@ skipping 10 matching lines @@
       cc_tool.get());
   cc_tool->set_outputs(SubstitutionList::MakeForTest(
       "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o"));
   cc_tool->set_precompiled_header_type(Tool::PCH_GCC);
   pch_toolchain.SetTool(Toolchain::TYPE_CC, std::move(cc_tool));
   pch_toolchain.ToolchainSetupComplete();
 
   // This target doesn't specify precompiled headers.
   {
     Target no_pch_target(&pch_settings,
-                         Label(SourceDir("//foo/"), "no_pch_target"));
+                         Label(SourceDir("//foo/"), "no_pch_target"), {});
     no_pch_target.set_output_type(Target::SOURCE_SET);
     no_pch_target.visibility().SetPublic();
     no_pch_target.sources().push_back(SourceFile("//foo/input1.cc"));
     no_pch_target.sources().push_back(SourceFile("//foo/input2.c"));
     no_pch_target.config_values().cflags_c().push_back("-std=c99");
     no_pch_target.SetToolchain(&pch_toolchain);
     ASSERT_TRUE(no_pch_target.OnResolved(&err));
 
     std::ostringstream out;
     NinjaBinaryTargetWriter writer(&no_pch_target, out);
@@ skipping 13 matching lines @@
                "withpch_cc ../../foo/input2.c\n"
         "\n"
         "build withpch/obj/foo/no_pch_target.stamp: "
                "withpch_stamp withpch/obj/foo/no_pch_target.input1.o "
                "withpch/obj/foo/no_pch_target.input2.o\n";
     EXPECT_EQ(no_pch_expected, out.str());
   }
 
   // This target specifies PCH.
   {
-    Target pch_target(&pch_settings,
-                      Label(SourceDir("//foo/"), "pch_target"));
+    Target pch_target(&pch_settings, Label(SourceDir("//foo/"), "pch_target"),
+                      {});
     pch_target.config_values().set_precompiled_source(
         SourceFile("//build/precompile.h"));
     pch_target.config_values().cflags_c().push_back("-std=c99");
     pch_target.set_output_type(Target::SOURCE_SET);
     pch_target.visibility().SetPublic();
     pch_target.sources().push_back(SourceFile("//foo/input1.cc"));
     pch_target.sources().push_back(SourceFile("//foo/input2.c"));
     pch_target.SetToolchain(&pch_toolchain);
     ASSERT_TRUE(pch_target.OnResolved(&err));
 
@@ skipping 56 matching lines @@
 }
 
 // This tests that output extension and output dir overrides apply, and input
 // dependencies are applied.
 TEST(NinjaBinaryTargetWriter, InputFiles) {
   Err err;
   TestWithScope setup;
 
   // This target has one input.
   {
-    Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+    Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"), {});
     target.set_output_type(Target::SOURCE_SET);
     target.visibility().SetPublic();
     target.sources().push_back(SourceFile("//foo/input1.cc"));
     target.sources().push_back(SourceFile("//foo/input2.cc"));
     target.inputs().push_back(SourceFile("//foo/input.data"));
     target.SetToolchain(setup.toolchain());
     ASSERT_TRUE(target.OnResolved(&err));
 
     std::ostringstream out;
     NinjaBinaryTargetWriter writer(&target, out);
@@ skipping 14 matching lines @@
           " | ../../foo/input.data\n"
         "\n"
         "build obj/foo/bar.stamp: stamp obj/foo/bar.input1.o "
             "obj/foo/bar.input2.o\n";
 
     EXPECT_EQ(expected, out.str());
   }
 
   // This target has multiple inputs.
   {
-    Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+    Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"), {});
     target.set_output_type(Target::SOURCE_SET);
     target.visibility().SetPublic();
     target.sources().push_back(SourceFile("//foo/input1.cc"));
     target.sources().push_back(SourceFile("//foo/input2.cc"));
     target.inputs().push_back(SourceFile("//foo/input1.data"));
     target.inputs().push_back(SourceFile("//foo/input2.data"));
     target.SetToolchain(setup.toolchain());
     ASSERT_TRUE(target.OnResolved(&err));
 
     std::ostringstream out;
@@ skipping 15 matching lines @@
           " | obj/foo/bar.inputs.stamp\n"
         "build obj/foo/bar.input2.o: cxx ../../foo/input2.cc"
           " | obj/foo/bar.inputs.stamp\n"
         "\n"
         "build obj/foo/bar.stamp: stamp obj/foo/bar.input1.o "
             "obj/foo/bar.input2.o\n";
 
     EXPECT_EQ(expected, out.str());
   }
 }