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

tools/gn/scope.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/scope.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "tools/gn/parse_tree.h"
+#include "tools/gn/source_file.h"
 #include "tools/gn/template.h"
 
 namespace {
 
 // FLags set in the mode_flags_ of a scope. If a bit is set, it applies
 // recursively to all dependent scopes.
 const unsigned kProcessingBuildConfigFlag = 1;
 const unsigned kProcessingImportFlag = 2;
 
 // Returns true if this variable name should be considered private. Private
@@ skipping 12 matching lines @@
       mark_dest_used(false) {
 }
 
 Scope::MergeOptions::~MergeOptions() {
 }
 
 Scope::ProgrammaticProvider::~ProgrammaticProvider() {
   scope_->RemoveProvider(this);
 }
 
-Scope::Scope(const Settings* settings)
+Scope::Scope(const Settings* settings,
+             const std::set<uint32_t>& source_files_hashes)
     : const_containing_(nullptr),
       mutable_containing_(nullptr),
       settings_(settings),
       mode_flags_(0),
-      item_collector_(nullptr) {
-}
+      item_collector_(nullptr),
+      source_files_hashes_(source_files_hashes) {}
 
 Scope::Scope(Scope* parent)
     : const_containing_(nullptr),
       mutable_containing_(parent),
       settings_(parent->settings()),
       mode_flags_(0),
-      item_collector_(nullptr) {
-}
+      item_collector_(nullptr),
+      source_files_hashes_(parent->source_files_hashes_) {}
 
 Scope::Scope(const Scope* parent)
     : const_containing_(parent),
       mutable_containing_(nullptr),
       settings_(parent->settings()),
       mode_flags_(0),
-      item_collector_(nullptr) {
-}
+      item_collector_(nullptr),
+      source_files_hashes_(parent->source_files_hashes_) {}
 
 Scope::~Scope() {
 }
 
 void Scope::DetachFromContaining() {
   const_containing_ = nullptr;
   mutable_containing_ = nullptr;
 }
 
 bool Scope::HasValues(SearchNested search_nested) const {
@@ skipping 257 matching lines @@
               "same target type in your current scope. It's unfortunate that "
               "I'm too stupid\nto tell you the location of where the target "
               "defaults were set. Usually\nthis happens in the BUILDCONFIG.gn "
               "file or in a related .gni file.\n");
           return false;
         }
       }
     }
 
     std::unique_ptr<Scope>& dest_scope = dest->target_defaults_[current_name];
-    dest_scope = base::MakeUnique<Scope>(settings_);
+    dest_scope = base::MakeUnique<Scope>(settings_, source_files_hashes_);
     pair.second->NonRecursiveMergeTo(dest_scope.get(), options, node_for_err,
                                      "<SHOULDN'T HAPPEN>", err);
   }
 
   // Sources assignment filter.
   if (sources_assignment_filter_) {
     if (!options.clobber_existing) {
       if (dest->GetSourcesAssignmentFilter()) {
         // Sources assignment filter present in both the source and the dest.
         std::string desc_string(desc_for_err);
@@ skipping 37 matching lines @@
             "Executing " + desc_string + " should not conflict with anything "
             "in the current\nscope."));
         return false;
       }
     }
 
     // Be careful to delete any pointer we're about to clobber.
     dest->templates_[current_name] = pair.second;
   }
 
+  // Source files.
+  dest->source_files_hashes_.insert(source_files_hashes_.begin(),
+                                    source_files_hashes_.end());
+
   return true;
 }
 
 std::unique_ptr<Scope> Scope::MakeClosure() const {
   std::unique_ptr<Scope> result;
   if (const_containing_) {
     // We reached the top of the mutable scope stack. The result scope just
     // references the const scope (which will never change).
     result.reset(new Scope(const_containing_));
   } else if (mutable_containing_) {
     // There are more nested mutable scopes. Recursively go up the stack to
     // get the closure.
     result = mutable_containing_->MakeClosure();
   } else {
     // This is a standalone scope, just copy it.
-    result.reset(new Scope(settings_));
+    result.reset(new Scope(settings_, source_files_hashes_));
   }
 
   // Want to clobber since we've flattened some nested scopes, and our parent
   // scope may have a duplicate value set.
   MergeOptions options;
   options.clobber_existing = true;
 
   // Add in our variables and we're done.
   Err err;
   NonRecursiveMergeTo(result.get(), options, nullptr, "<SHOULDN'T HAPPEN>",
                       &err);
   DCHECK(!err.has_error());
   return result;
 }
 
 Scope* Scope::MakeTargetDefaults(const std::string& target_type) {
   std::unique_ptr<Scope>& dest = target_defaults_[target_type];
-  dest = base::MakeUnique<Scope>(settings_);
+  dest = base::MakeUnique<Scope>(settings_, source_files_hashes_);
   return dest.get();
 }
 
 const Scope* Scope::GetTargetDefaults(const std::string& target_type) const {
   NamedScopeMap::const_iterator found = target_defaults_.find(target_type);
   if (found != target_defaults_.end())
     return found->second.get();
   if (containing())
     return containing()->GetTargetDefaults(target_type);
   return nullptr;
@@ skipping 44 matching lines @@
 }
 
 const SourceDir& Scope::GetSourceDir() const {
   if (!source_dir_.is_null())
     return source_dir_;
   if (containing())
     return containing()->GetSourceDir();
   return source_dir_;
 }
 
+void Scope::AddSourceFile(const SourceFile& source_file) {
+  source_files_hashes_.insert(base::Hash(source_file.value()));
+}
+
 Scope::ItemVector* Scope::GetItemCollector() {
   if (item_collector_)
     return item_collector_;
   if (mutable_containing())
     return mutable_containing()->GetItemCollector();
   return nullptr;
 }
 
 void Scope::SetProperty(const void* key, void* value) {
   if (!value) {
@@ skipping 31 matching lines @@
     return false;
   for (const auto& pair : a) {
     const auto& found_b = b.find(pair.first);
     if (found_b == b.end())
       return false;  // Item in 'a' but not 'b'.
     if (pair.second.value != found_b->second.value)
       return false;  // Values for variable in 'a' and 'b' are different.
   }
   return true;
 }