Improve error messages and reporting in GN

tools/gn/loader.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/loader.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file_manager.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/trace.h"
 
+namespace {
+
+struct SourceFileAndOrigin {
+  SourceFileAndOrigin(const SourceFile& f, const LocationRange& o)
+      : file(f),
+        origin(o) {
+  }
+
+  SourceFile file;
+  LocationRange origin;
+};
+
+}  // namespace
+
 // Identifies one time a file is loaded in a given toolchain so we don't load
 // it more than once.
 struct LoaderImpl::LoadID {
   LoadID() {}
   LoadID(const SourceFile& f, const Label& tc_name)
       : file(f),
         toolchain_name(tc_name) {
   }
 
   bool operator<(const LoadID& other) const {
@@ skipping 21 matching lines @@
         is_config_loaded(false) {
     settings.set_default_toolchain_label(default_toolchain_label);
     settings.set_toolchain_label(toolchain_label);
   }
 
   Settings settings;
 
   bool is_toolchain_loaded;
   bool is_config_loaded;
 
-  std::vector<SourceFile> waiting_on_me;
+  std::vector<SourceFileAndOrigin> waiting_on_me;
 };
 
 // -----------------------------------------------------------------------------
 
 const void* Loader::kDefaultToolchainKey = &kDefaultToolchainKey;
 
 Loader::Loader() {
 }
 
 Loader::~Loader() {
 }
 
-void Loader::Load(const Label& label) {
-  Load(BuildFileForLabel(label), label.GetToolchainLabel());
+void Loader::Load(const Label& label, const LocationRange& origin) {
+  Load(BuildFileForLabel(label), origin, label.GetToolchainLabel());
 }
 
 // static
 SourceFile Loader::BuildFileForLabel(const Label& label) {
   return SourceFile(label.dir().value() + "BUILD.gn");
 }
 
 // -----------------------------------------------------------------------------
 
 LoaderImpl::LoaderImpl(const BuildSettings* build_settings)
     : main_loop_(base::MessageLoop::current()),
       pending_loads_(0),
       build_settings_(build_settings) {
 }
 
 LoaderImpl::~LoaderImpl() {
   STLDeleteContainerPairSecondPointers(toolchain_records_.begin(),
                                        toolchain_records_.end());
 }
 
 void LoaderImpl::Load(const SourceFile& file,
-    const Label& in_toolchain_name) {
+                      const LocationRange& origin,
+                      const Label& in_toolchain_name) {
   const Label& toolchain_name = in_toolchain_name.is_null()
       ? default_toolchain_label_ : in_toolchain_name;
   LoadID load_id(file, toolchain_name);
   if (!invocations_.insert(load_id).second)
     return;  // Already in set, so this file was already loaded or schedulerd.
 
   if (toolchain_records_.empty()) {
     // Nothing loaded, need to load the default build config. The intial load
     // should not specify a toolchain.
     DCHECK(toolchain_name.is_null());
 
     ToolchainRecord* record =
         new ToolchainRecord(build_settings_, Label(), Label());
     toolchain_records_[Label()] = record;
 
     // The default build config is no dependent on the toolchain definition,
     // since we need to load the build config before we know what the default
     // toolchain name is.
     record->is_toolchain_loaded = true;
 
-    record->waiting_on_me.push_back(file);
+    record->waiting_on_me.push_back(SourceFileAndOrigin(file, origin));
     ScheduleLoadBuildConfig(&record->settings, Scope::KeyValueMap());
     return;
   }
 
   ToolchainRecord* record;
   if (toolchain_name.is_null())
     record = toolchain_records_[default_toolchain_label_];
   else
     record = toolchain_records_[toolchain_name];
 
   if (!record) {
     DCHECK(!default_toolchain_label_.is_null());
 
     // No reference to this toolchain found yet, make one.
     record = new ToolchainRecord(build_settings_, toolchain_name,
                                  default_toolchain_label_);
     toolchain_records_[toolchain_name] = record;
 
     // Schedule a load of the toolchain using the default one.
-    Load(BuildFileForLabel(toolchain_name), default_toolchain_label_);
+    Load(BuildFileForLabel(toolchain_name), origin, default_toolchain_label_);
   }
 
   if (record->is_config_loaded)
-    ScheduleLoadFile(&record->settings, file);
+    ScheduleLoadFile(&record->settings, origin, file);
   else
-    record->waiting_on_me.push_back(file);
+    record->waiting_on_me.push_back(SourceFileAndOrigin(file, origin));
 }
 
 void LoaderImpl::ToolchainLoaded(const Toolchain* toolchain) {
   ToolchainRecord* record = toolchain_records_[toolchain->label()];
   if (!record) {
     DCHECK(!default_toolchain_label_.is_null());
     record = new ToolchainRecord(build_settings_, toolchain->label(),
                                  default_toolchain_label_);
     toolchain_records_[toolchain->label()] = record;
   }
@@ skipping 24 matching lines @@
   } else {
     found_toolchain = toolchain_records_.find(label);
   }
 
   if (found_toolchain == toolchain_records_.end())
     return NULL;
   return &found_toolchain->second->settings;
 }
 
 void LoaderImpl::ScheduleLoadFile(const Settings* settings,
+                                  const LocationRange& origin,
                                   const SourceFile& file) {
   Err err;
   pending_loads_++;
-  if (!AsyncLoadFile(LocationRange(), settings->build_settings(), file,
+  if (!AsyncLoadFile(origin, settings->build_settings(), file,
                      base::Bind(&LoaderImpl::BackgroundLoadFile, this,
                                 settings, file),
                      &err)) {
     g_scheduler->FailWithError(err);
     DecrementPendingLoads();
   }
 }
 
 void LoaderImpl::ScheduleLoadBuildConfig(
     Settings* settings,
@@ skipping 162 matching lines @@
     }
   } else {
     record = found_toolchain->second;
   }
 
   DCHECK(!record->is_config_loaded);
   DCHECK(record->is_toolchain_loaded);
   record->is_config_loaded = true;
 
   // Schedule all waiting file loads.
-  for (size_t i = 0; i < record->waiting_on_me.size(); i++)
-    ScheduleLoadFile(&record->settings, record->waiting_on_me[i]);
+  for (size_t i = 0; i < record->waiting_on_me.size(); i++) {
+    ScheduleLoadFile(&record->settings, record->waiting_on_me[i].origin,
+                     record->waiting_on_me[i].file);
+  }
   record->waiting_on_me.clear();
 
   DecrementPendingLoads();
 }
 
 void LoaderImpl::DecrementPendingLoads() {
   DCHECK(pending_loads_ > 0);
   pending_loads_--;
   if (pending_loads_ == 0 && !complete_callback_.is_null())
     complete_callback_.Run();
 }
 
 bool LoaderImpl::AsyncLoadFile(
     const LocationRange& origin,
     const BuildSettings* build_settings,
     const SourceFile& file_name,
     const base::Callback<void(const ParseNode*)>& callback,
     Err* err) {
   if (async_load_file_.is_null()) {
     return g_scheduler->input_file_manager()->AsyncLoadFile(
         origin, build_settings, file_name, callback, err);
   }
   return async_load_file_.Run(
       origin, build_settings, file_name, callback, err);
 }