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

tools/gn/target_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/target.h"
 
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/build_settings.h"
@@ skipping 73 matching lines @@
   Err err;
 
   // Set up a dependency chain of a -> b -> c
   TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
   TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
   TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
   a.private_deps().push_back(LabelTargetPair(&b));
   b.private_deps().push_back(LabelTargetPair(&c));
 
   // Normal non-inherited config.
-  Config config(setup.settings(), Label(SourceDir("//foo/"), "config"));
+  Config config(setup.settings(), Label(SourceDir("//foo/"), "config"), {});
   ASSERT_TRUE(config.OnResolved(&err));
   c.configs().push_back(LabelConfigPair(&config));
 
   // All dependent config.
-  Config all(setup.settings(), Label(SourceDir("//foo/"), "all"));
+  Config all(setup.settings(), Label(SourceDir("//foo/"), "all"), {});
   ASSERT_TRUE(all.OnResolved(&err));
   c.all_dependent_configs().push_back(LabelConfigPair(&all));
 
   // Direct dependent config.
-  Config direct(setup.settings(), Label(SourceDir("//foo/"), "direct"));
+  Config direct(setup.settings(), Label(SourceDir("//foo/"), "direct"), {});
   ASSERT_TRUE(direct.OnResolved(&err));
   c.public_configs().push_back(LabelConfigPair(&direct));
 
   ASSERT_TRUE(c.OnResolved(&err));
   ASSERT_TRUE(b.OnResolved(&err));
   ASSERT_TRUE(a.OnResolved(&err));
 
   // B should have gotten both dependent configs from C.
   ASSERT_EQ(2u, b.configs().size());
   EXPECT_EQ(&all, b.configs()[0].ptr);
@@ skipping 22 matching lines @@
   EXPECT_EQ(&all, a_fwd.all_dependent_configs()[0].ptr);
 }
 
 // Tests that dependent configs don't propagate between toolchains.
 TEST(Target, NoDependentConfigsBetweenToolchains) {
   TestWithScope setup;
   Err err;
 
   // Create another toolchain.
   Toolchain other_toolchain(setup.settings(),
-                            Label(SourceDir("//other/"), "toolchain"));
+                            Label(SourceDir("//other/"), "toolchain"), {});
   TestWithScope::SetupToolchain(&other_toolchain);
 
   // Set up a dependency chain of |a| -> |b| -> |c| where |a| has a different
   // toolchain.
   Target a(setup.settings(),
            Label(SourceDir("//foo/"), "a", other_toolchain.label().dir(),
-                 other_toolchain.label().name()));
+                 other_toolchain.label().name()),
+           {});
   a.set_output_type(Target::EXECUTABLE);
   EXPECT_TRUE(a.SetToolchain(&other_toolchain, &err));
   TestTarget b(setup, "//foo:b", Target::EXECUTABLE);
   TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
   a.private_deps().push_back(LabelTargetPair(&b));
   b.private_deps().push_back(LabelTargetPair(&c));
 
   // All dependent config.
-  Config all_dependent(setup.settings(), Label(SourceDir("//foo/"), "all"));
+  Config all_dependent(setup.settings(), Label(SourceDir("//foo/"), "all"), {});
   ASSERT_TRUE(all_dependent.OnResolved(&err));
   c.all_dependent_configs().push_back(LabelConfigPair(&all_dependent));
 
   // Public config.
-  Config public_config(setup.settings(), Label(SourceDir("//foo/"), "public"));
+  Config public_config(setup.settings(), Label(SourceDir("//foo/"), "public"),
+                       {});
   ASSERT_TRUE(public_config.OnResolved(&err));
   c.public_configs().push_back(LabelConfigPair(&public_config));
 
   // Another public config.
-  Config public_config2(setup.settings(),
-                        Label(SourceDir("//foo/"), "public2"));
+  Config public_config2(setup.settings(), Label(SourceDir("//foo/"), "public2"),
+                        {});
   ASSERT_TRUE(public_config2.OnResolved(&err));
   b.public_configs().push_back(LabelConfigPair(&public_config2));
 
   ASSERT_TRUE(c.OnResolved(&err));
   ASSERT_TRUE(b.OnResolved(&err));
   ASSERT_TRUE(a.OnResolved(&err));
 
   // B should have gotten the configs from C.
   ASSERT_EQ(3u, b.configs().size());
   EXPECT_EQ(&public_config2, b.configs()[0].ptr);
@@ skipping 291 matching lines @@
   product.set_testonly(false);
   product.private_deps().push_back(LabelTargetPair(&testlib));
   ASSERT_FALSE(product.OnResolved(&err));
 }
 
 TEST(Target, PublicConfigs) {
   TestWithScope setup;
   Err err;
 
   Label pub_config_label(SourceDir("//a/"), "pubconfig");
-  Config pub_config(setup.settings(), pub_config_label);
+  Config pub_config(setup.settings(), pub_config_label, {});
   LibFile lib_name("testlib");
   pub_config.own_values().libs().push_back(lib_name);
   ASSERT_TRUE(pub_config.OnResolved(&err));
 
   // This is the destination target that has a public config.
   TestTarget dest(setup, "//a:a", Target::SOURCE_SET);
   dest.public_configs().push_back(LabelConfigPair(&pub_config));
   ASSERT_TRUE(dest.OnResolved(&err));
 
   // This target has a public dependency on dest.
@@ skipping 21 matching lines @@
 }
 
 // Tests that configs are ordered properly between local and pulled ones.
 TEST(Target, ConfigOrdering) {
   TestWithScope setup;
   Err err;
 
   // Make Dep1. It has all_dependent_configs and public_configs.
   TestTarget dep1(setup, "//:dep1", Target::SOURCE_SET);
   Label dep1_all_config_label(SourceDir("//"), "dep1_all_config");
-  Config dep1_all_config(setup.settings(), dep1_all_config_label);
+  Config dep1_all_config(setup.settings(), dep1_all_config_label, {});
   ASSERT_TRUE(dep1_all_config.OnResolved(&err));
   dep1.all_dependent_configs().push_back(LabelConfigPair(&dep1_all_config));
 
   Label dep1_public_config_label(SourceDir("//"), "dep1_public_config");
-  Config dep1_public_config(setup.settings(), dep1_public_config_label);
+  Config dep1_public_config(setup.settings(), dep1_public_config_label, {});
   ASSERT_TRUE(dep1_public_config.OnResolved(&err));
   dep1.public_configs().push_back(LabelConfigPair(&dep1_public_config));
   ASSERT_TRUE(dep1.OnResolved(&err));
 
   // Make Dep2 with the same structure.
   TestTarget dep2(setup, "//:dep2", Target::SOURCE_SET);
   Label dep2_all_config_label(SourceDir("//"), "dep2_all_config");
-  Config dep2_all_config(setup.settings(), dep2_all_config_label);
+  Config dep2_all_config(setup.settings(), dep2_all_config_label, {});
   ASSERT_TRUE(dep2_all_config.OnResolved(&err));
   dep2.all_dependent_configs().push_back(LabelConfigPair(&dep2_all_config));
 
   Label dep2_public_config_label(SourceDir("//"), "dep2_public_config");
-  Config dep2_public_config(setup.settings(), dep2_public_config_label);
+  Config dep2_public_config(setup.settings(), dep2_public_config_label, {});
   ASSERT_TRUE(dep2_public_config.OnResolved(&err));
   dep2.public_configs().push_back(LabelConfigPair(&dep2_public_config));
   ASSERT_TRUE(dep2.OnResolved(&err));
 
   // This target depends on both previous targets.
   TestTarget target(setup, "//:foo", Target::SOURCE_SET);
   target.private_deps().push_back(LabelTargetPair(&dep1));
   target.private_deps().push_back(LabelTargetPair(&dep2));
 
   // It also has a private and public config.
   Label public_config_label(SourceDir("//"), "public");
-  Config public_config(setup.settings(), public_config_label);
+  Config public_config(setup.settings(), public_config_label, {});
   ASSERT_TRUE(public_config.OnResolved(&err));
   target.public_configs().push_back(LabelConfigPair(&public_config));
 
   Label private_config_label(SourceDir("//"), "private");
-  Config private_config(setup.settings(), private_config_label);
+  Config private_config(setup.settings(), private_config_label, {});
   ASSERT_TRUE(private_config.OnResolved(&err));
   target.configs().push_back(LabelConfigPair(&private_config));
 
   // Resolve to get the computed list of configs applying.
   ASSERT_TRUE(target.OnResolved(&err));
   const auto& computed = target.configs();
 
   // Order should be:
   // 1. local private
   // 2. local public
   // 3. inherited all dependent
   // 4. inherited public
   ASSERT_EQ(6u, computed.size());
   EXPECT_EQ(private_config_label, computed[0].label);
   EXPECT_EQ(public_config_label, computed[1].label);
   EXPECT_EQ(dep1_all_config_label, computed[2].label);
   EXPECT_EQ(dep2_all_config_label, computed[3].label);
   EXPECT_EQ(dep1_public_config_label, computed[4].label);
   EXPECT_EQ(dep2_public_config_label, computed[5].label);
 }
 
 // Tests that different link/depend outputs work for solink tools.
 TEST(Target, LinkAndDepOutputs) {
   TestWithScope setup;
   Err err;
 
-  Toolchain toolchain(setup.settings(), Label(SourceDir("//tc/"), "tc"));
+  Toolchain toolchain(setup.settings(), Label(SourceDir("//tc/"), "tc"), {});
 
   std::unique_ptr<Tool> solink_tool(new Tool());
   solink_tool->set_output_prefix("lib");
   solink_tool->set_default_output_extension(".so");
 
   const char kLinkPattern[] =
       "{{root_out_dir}}/{{target_output_name}}{{output_extension}}";
   SubstitutionPattern link_output = SubstitutionPattern::MakeForTest(
       kLinkPattern);
   solink_tool->set_link_output(link_output);
 
   const char kDependPattern[] =
       "{{root_out_dir}}/{{target_output_name}}{{output_extension}}.TOC";
   SubstitutionPattern depend_output = SubstitutionPattern::MakeForTest(
       kDependPattern);
   solink_tool->set_depend_output(depend_output);
 
   solink_tool->set_outputs(SubstitutionList::MakeForTest(
       kLinkPattern, kDependPattern));
 
   toolchain.SetTool(Toolchain::TYPE_SOLINK, std::move(solink_tool));
 
-  Target target(setup.settings(), Label(SourceDir("//a/"), "a"));
+  Target target(setup.settings(), Label(SourceDir("//a/"), "a"), {});
   target.set_output_type(Target::SHARED_LIBRARY);
   target.SetToolchain(&toolchain);
   ASSERT_TRUE(target.OnResolved(&err));
 
   EXPECT_EQ("./liba.so", target.link_output_file().value());
   EXPECT_EQ("./liba.so.TOC", target.dependency_output_file().value());
 
   ASSERT_EQ(1u, target.runtime_outputs().size());
   EXPECT_EQ("./liba.so", target.runtime_outputs()[0].value());
 }
 
 // Tests that runtime_outputs works without an explicit link_output for
 // solink tools.
 TEST(Target, RuntimeOuputs) {
   TestWithScope setup;
   Err err;
 
-  Toolchain toolchain(setup.settings(), Label(SourceDir("//tc/"), "tc"));
+  Toolchain toolchain(setup.settings(), Label(SourceDir("//tc/"), "tc"), {});
 
   std::unique_ptr<Tool> solink_tool(new Tool());
   solink_tool->set_output_prefix("");
   solink_tool->set_default_output_extension(".dll");
 
   // Say the linker makes a DLL< an import library, and a symbol file we want
   // to treat as a runtime output.
   const char kLibPattern[] =
       "{{root_out_dir}}/{{target_output_name}}{{output_extension}}.lib";
   const char kDllPattern[] =
       "{{root_out_dir}}/{{target_output_name}}{{output_extension}}";
   const char kPdbPattern[] =
       "{{root_out_dir}}/{{target_output_name}}.pdb";
   SubstitutionPattern pdb_pattern =
       SubstitutionPattern::MakeForTest(kPdbPattern);
 
   solink_tool->set_outputs(
       SubstitutionList::MakeForTest(kLibPattern, kDllPattern, kPdbPattern));
 
   // Say we only want the DLL and symbol file treaded as runtime outputs.
   solink_tool->set_runtime_outputs(SubstitutionList::MakeForTest(
       kDllPattern, kPdbPattern));
 
   toolchain.SetTool(Toolchain::TYPE_SOLINK, std::move(solink_tool));
 
-  Target target(setup.settings(), Label(SourceDir("//a/"), "a"));
+  Target target(setup.settings(), Label(SourceDir("//a/"), "a"), {});
   target.set_output_type(Target::SHARED_LIBRARY);
   target.SetToolchain(&toolchain);
   ASSERT_TRUE(target.OnResolved(&err));
 
   EXPECT_EQ("./a.dll.lib", target.link_output_file().value());
   EXPECT_EQ("./a.dll.lib", target.dependency_output_file().value());
 
   ASSERT_EQ(2u, target.runtime_outputs().size());
   EXPECT_EQ("./a.dll", target.runtime_outputs()[0].value());
   EXPECT_EQ("./a.pdb", target.runtime_outputs()[1].value());
@@ skipping 196 matching lines @@
   final_target.inputs().push_back(object_file);
   EXPECT_TRUE(final_target.OnResolved(&err));
 
   AssertSchedulerHasOneUnknownFileMatching(&final_target, object_file);
 }
 
 TEST(Target, ResolvePrecompiledHeaders) {
   TestWithScope setup;
   Err err;
 
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"), {});
 
   // Target with no settings, no configs, should be a no-op.
   EXPECT_TRUE(target.ResolvePrecompiledHeaders(&err));
 
   // Config with PCH values.
-  Config config_1(setup.settings(), Label(SourceDir("//foo/"), "c1"));
+  Config config_1(setup.settings(), Label(SourceDir("//foo/"), "c1"), {});
   std::string pch_1("pch.h");
   SourceFile pcs_1("//pcs.cc");
   config_1.own_values().set_precompiled_header(pch_1);
   config_1.own_values().set_precompiled_source(pcs_1);
   ASSERT_TRUE(config_1.OnResolved(&err));
   target.configs().push_back(LabelConfigPair(&config_1));
 
   // No PCH info specified on target, but the config specifies one, the
   // values should get copied to the target.
   EXPECT_TRUE(target.ResolvePrecompiledHeaders(&err));
   EXPECT_EQ(pch_1, target.config_values().precompiled_header());
   EXPECT_TRUE(target.config_values().precompiled_source() == pcs_1);
 
   // Now both target and config have matching PCH values. Resolving again
   // should be a no-op since they all match.
   EXPECT_TRUE(target.ResolvePrecompiledHeaders(&err));
   EXPECT_TRUE(target.config_values().precompiled_header() == pch_1);
   EXPECT_TRUE(target.config_values().precompiled_source() == pcs_1);
 
   // Second config with different PCH values.
-  Config config_2(setup.settings(), Label(SourceDir("//foo/"), "c2"));
+  Config config_2(setup.settings(), Label(SourceDir("//foo/"), "c2"), {});
   std::string pch_2("pch2.h");
   SourceFile pcs_2("//pcs2.cc");
   config_2.own_values().set_precompiled_header(pch_2);
   config_2.own_values().set_precompiled_source(pcs_2);
   ASSERT_TRUE(config_2.OnResolved(&err));
   target.configs().push_back(LabelConfigPair(&config_2));
 
   // This should be an error since they don't match.
   EXPECT_FALSE(target.ResolvePrecompiledHeaders(&err));
 
@@ skipping 130 matching lines @@
   ASSERT_EQ(c.bundle_data().file_rules().size(), 1u);
   ASSERT_EQ(c.bundle_data().file_rules()[0].sources().size(), 1u);
   ASSERT_EQ(c.bundle_data().bundle_deps().size(), 1u);
 
   // E does not have any bundle_data information but gets a list of
   // bundle_deps to propagate them during target resolution.
   ASSERT_TRUE(e.bundle_data().file_rules().empty());
   ASSERT_TRUE(e.bundle_data().assets_catalog_sources().empty());
   ASSERT_EQ(e.bundle_data().bundle_deps().size(), 2u);
 }