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

tools/gn/analyzer.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/analyzer.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
-#include "base/strings/string_util.h"
 #include "base/values.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
+#include "tools/gn/input_file.h"
 #include "tools/gn/loader.h"
 #include "tools/gn/location.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/target.h"
 
 using LabelSet = Analyzer::LabelSet;
 using SourceFileSet = Analyzer::SourceFileSet;
 using TargetSet = Analyzer::TargetSet;
 
 namespace {
@@ skipping 17 matching lines @@
   LabelSet invalid_labels;
 };
 
 LabelSet LabelsFor(const TargetSet& targets) {
   LabelSet labels;
   for (auto* target : targets)
     labels.insert(target->label());
   return labels;
 }
 
-bool AnyBuildFilesWereModified(const SourceFileSet& source_files) {
-  for (auto* file : source_files) {
-    if (base::EndsWith(file->value(), ".gn", base::CompareCase::SENSITIVE) ||
-        base::EndsWith(file->value(), ".gni", base::CompareCase::SENSITIVE) ||
-        base::EndsWith(file->value(), "build/vs_toolchain.py",
-                       base::CompareCase::SENSITIVE))
-      return true;
-  }
-  return false;
-}
-
 TargetSet Intersect(const TargetSet& l, const TargetSet& r) {
   TargetSet result;
   std::set_intersection(l.begin(), l.end(), r.begin(), r.end(),
                         std::inserter(result, result.begin()));
   return result;
 }
 
 std::vector<std::string> GetStringVector(const base::DictionaryValue& dict,
                                          const std::string& key,
                                          Err* err) {
@@ skipping 138 matching lines @@
     WriteLabels(default_toolchain, *value, "test_targets", outputs.test_labels);
   }
 
   if (!base::JSONWriter::Write(*value.get(), &output))
     *err = Err(Location(), "Failed to marshal JSON value for output");
   return output;
 }
 
 }  // namespace
 
-Analyzer::Analyzer(const Builder& builder)
+Analyzer::Analyzer(const BuildSettings& build_settings, const Builder& builder)
     : all_targets_(builder.GetAllResolvedTargets()),
-      default_toolchain_(builder.loader()->GetDefaultToolchain()) {
+      default_toolchain_(builder.loader()->GetDefaultToolchain()),
+      build_config_file_(build_settings.build_config_file()) {
   for (const auto* target : all_targets_) {
     labels_to_targets_[target->label()] = target;
     for (const auto& dep_pair : target->GetDeps(Target::DEPS_ALL))
       dep_map_.insert(std::make_pair(dep_pair.ptr, target));
   }
   for (const auto* target : all_targets_) {
     if (dep_map_.find(target) == dep_map_.end())
       roots_.insert(target);
   }
 }
@@ skipping 14 matching lines @@
   for (const auto& label : InvalidLabels(inputs.compile_labels))
     invalid_labels.insert(label);
   for (const auto& label : InvalidLabels(inputs.test_labels))
     invalid_labels.insert(label);
   if (!invalid_labels.empty()) {
     outputs.error = "Invalid targets";
     outputs.invalid_labels = invalid_labels;
     return OutputsToJSON(outputs, default_toolchain_, err);
   }
 
-  // TODO(crbug.com/555273): We can do smarter things when we detect changes
-  // to build files. For example, if all of the ninja files are unchanged,
-  // we know that we can ignore changes to .gn* files. Also, for most .gn
-  // files, we can treat a change as simply affecting every target, config,
-  // or toolchain defined in that file.
-  if (AnyBuildFilesWereModified(inputs.source_files)) {
+  if (WereMainGNFilesModified(inputs.source_files)) {
     outputs.status = "Found dependency (all)";
     if (inputs.compile_included_all) {
       outputs.compile_includes_all = true;
     } else {
       outputs.compile_labels.insert(inputs.compile_labels.begin(),
                                     inputs.compile_labels.end());
       outputs.compile_labels.insert(inputs.test_labels.begin(),
                                     inputs.test_labels.end());
     }
     outputs.test_labels = inputs.test_labels;
@@ skipping 72 matching lines @@
       filtered->insert(target);
     } else {
       for (const auto& pair : target->GetDeps(Target::DEPS_ALL))
         FilterTarget(pair.ptr, seen, filtered);
     }
   }
 }
 
 bool Analyzer::TargetRefersToFile(const Target* target,
                                   const SourceFile* file) const {
+  for (const auto* cur_file : target->input_files()) {
+    if (cur_file->name() == *file)
+      return true;
+  }
   for (const auto& cur_file : target->sources()) {
     if (cur_file == *file)
       return true;
   }
   for (const auto& cur_file : target->public_headers()) {
     if (cur_file == *file)
       return true;
   }
   for (const auto& cur_file : target->inputs()) {
     if (cur_file == *file)
@@ skipping 30 matching lines @@
 void Analyzer::AddAllRefsTo(const Target* target, TargetSet* results) const {
   if (results->find(target) != results->end())
     return;  // Already found this target.
   results->insert(target);
 
   auto dep_begin = dep_map_.lower_bound(target);
   auto dep_end = dep_map_.upper_bound(target);
   for (auto cur_dep = dep_begin; cur_dep != dep_end; cur_dep++)
     AddAllRefsTo(cur_dep->second, results);
 }
+
+bool Analyzer::WereMainGNFilesModified(
+    const SourceFileSet& source_files) const {
+  for (auto* file : source_files) {
+    if (file->value() == "//.gn" || *file == build_config_file_)

[brettw, 2017/06/28 20:49:40]

Somewhat annoyingly, the dotfile can be overridden on the command line. This was
used by nacl (not sure if it still is) and some other projects that wanted to be
DEPSed in in weird ways. I think we will still want to support this.

Setup has a dotfile_name_ member that we can expose a getter for and pass to the
analyzer. The annoying thing will be that this is a base::FilePath. I think we
can call SourceDir.ResolveRelativeFile with the UTF-8 version of the
base::FilePath to convert here. You can use "//" for the SourceDir to resolve
against (the input should be absolute).

[alex-ac, 2017/06/29 10:26:57]

Done.

+      return true;
+  }
+  return false;
+}