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

tools/gn/substitution_writer_unittest.cc

 // Copyright 2014 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 <sstream>
 
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/err.h"
 #include "tools/gn/escape.h"
@@ skipping 88 matching lines @@
 
   EXPECT_EQ(
       "-i ${in} --out=bar\"${source_name_part}\".o",
       out.str());
 }
 
 TEST(SubstitutionWriter, SourceSubstitutions) {
   TestWithScope setup;
   Err err;
 
-  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
+  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"), {});
   target.set_output_type(Target::STATIC_LIBRARY);
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   // Call to get substitutions relative to the build dir.
   #define GetRelSubst(str, what) \
       SubstitutionWriter::GetSourceSubstitution( \
           &target, \
           setup.settings(), \
           SourceFile(str), \
@@ skipping 70 matching lines @@
       GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_TARGET_RELATIVE));
 
   #undef GetAbsSubst
   #undef GetRelSubst
 }
 
 TEST(SubstitutionWriter, TargetSubstitutions) {
   TestWithScope setup;
   Err err;
 
-  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
+  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"), {});
   target.set_output_type(Target::STATIC_LIBRARY);
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   std::string result;
   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
       &target, SUBSTITUTION_LABEL, &result));
   EXPECT_EQ("//foo/bar:baz", result);
 
   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
@@ skipping 18 matching lines @@
 
   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
       &target, SUBSTITUTION_TARGET_OUTPUT_NAME, &result));
   EXPECT_EQ("libbaz", result);
 }
 
 TEST(SubstitutionWriter, CompilerSubstitutions) {
   TestWithScope setup;
   Err err;
 
-  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
+  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"), {});
   target.set_output_type(Target::STATIC_LIBRARY);
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   // The compiler substitution is just source + target combined. So test one
   // of each of those classes of things to make sure this is hooked up.
   EXPECT_EQ("file",
             SubstitutionWriter::GetCompilerSubstitution(
                 &target, SourceFile("//foo/bar/file.txt"),
                 SUBSTITUTION_SOURCE_NAME_PART));
   EXPECT_EQ("gen/foo/bar",
             SubstitutionWriter::GetCompilerSubstitution(
                 &target, SourceFile("//foo/bar/file.txt"),
                 SUBSTITUTION_TARGET_GEN_DIR));
 }
 
 TEST(SubstitutionWriter, LinkerSubstitutions) {
   TestWithScope setup;
   Err err;
 
-  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
+  Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"), {});
   target.set_output_type(Target::SHARED_LIBRARY);
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   const Tool* tool = setup.toolchain()->GetToolForTargetFinalOutput(&target);
 
   // The compiler substitution is just target + OUTPUT_EXTENSION combined. So
   // test one target one plus the output extension.
   EXPECT_EQ(".so",
             SubstitutionWriter::GetLinkerSubstitution(
@@ skipping 32 matching lines @@
   // This tool has an output directory pattern and uses that for the
   // output name.
   Tool tool;
   SubstitutionPattern out_dir_pattern;
   ASSERT_TRUE(out_dir_pattern.Parse("{{root_out_dir}}/{{target_output_name}}",
                                     nullptr, &err));
   tool.set_default_output_dir(out_dir_pattern);
   tool.SetComplete();
 
   // Default target with no output dir overrides.
-  Target target(setup.settings(), Label(SourceDir("//foo/"), "baz"));
+  Target target(setup.settings(), Label(SourceDir("//foo/"), "baz"), {});
   target.set_output_type(Target::EXECUTABLE);
   target.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target.OnResolved(&err));
 
   // The output should expand the default from the patterns in the tool.
   SubstitutionPattern output_name;
   ASSERT_TRUE(output_name.Parse("{{output_dir}}/{{target_output_name}}.exe",
                                 nullptr, &err));
   EXPECT_EQ("./baz/baz.exe",
             SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
                 &target, &tool, output_name).value());
 
   // Override the output name to the root build dir.
   target.set_output_dir(SourceDir("//out/Debug/"));
   EXPECT_EQ("./baz.exe",
             SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
                 &target, &tool, output_name).value());
 
   // Override the output name to a new subdirectory.
   target.set_output_dir(SourceDir("//out/Debug/foo/bar"));
   EXPECT_EQ("foo/bar/baz.exe",
             SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
                 &target, &tool, output_name).value());
 }