🐣 GN: Print the import trail when parse errors occur.

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/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "tools/gn/build_settings.h"
@@ skipping 193 matching lines @@
   return &found_toolchain->second->settings;
 }
 
 void LoaderImpl::ScheduleLoadFile(const Settings* settings,
                                   const LocationRange& origin,
                                   const SourceFile& file) {
   Err err;
   pending_loads_++;
   if (!AsyncLoadFile(origin, settings->build_settings(), file,
                      base::Bind(&LoaderImpl::BackgroundLoadFile, this,
-                                settings, file),
+                                settings, file, origin),
                      &err)) {
     g_scheduler->FailWithError(err);
     DecrementPendingLoads();
   }
 }
 
 void LoaderImpl::ScheduleLoadBuildConfig(
     Settings* settings,
     const Scope::KeyValueMap& toolchain_overrides) {
   Err err;
   pending_loads_++;
   if (!AsyncLoadFile(LocationRange(), settings->build_settings(),
                      settings->build_settings()->build_config_file(),
                      base::Bind(&LoaderImpl::BackgroundLoadBuildConfig,
                                 this, settings, toolchain_overrides),
                      &err)) {
     g_scheduler->FailWithError(err);
     DecrementPendingLoads();
   }
 }
 
 void LoaderImpl::BackgroundLoadFile(const Settings* settings,
                                     const SourceFile& file_name,
+                                    const LocationRange& origin,
                                     const ParseNode* root) {
   if (!root) {
     main_loop_->PostTask(FROM_HERE,
         base::Bind(&LoaderImpl::DecrementPendingLoads, this));
     return;
   }
 
   if (g_scheduler->verbose_logging()) {
     g_scheduler->Log("Running", file_name.value() + " with toolchain " +
                      settings->toolchain_label().GetUserVisibleName(false));
   }
 
   Scope our_scope(settings->base_config());
   ScopePerFileProvider per_file_provider(&our_scope, true);
   our_scope.set_source_dir(file_name.GetDir());
 
   // Targets, etc. generated as part of running this file will end up here.
   Scope::ItemVector collected_items;
   our_scope.set_item_collector(&collected_items);
 
   ScopedTrace trace(TraceItem::TRACE_FILE_EXECUTE, file_name.value());
   trace.SetToolchain(settings->toolchain_label());
 
   Err err;
   root->Execute(&our_scope, &err);
-  if (err.has_error())
+  if (!err.has_error())
+    our_scope.CheckForUnusedVars(&err);
+
+  if (err.has_error()) {
+    if (!origin.is_null())
+      err.AppendSubErr(Err(origin, "which caused the file to be included."));
     g_scheduler->FailWithError(err);
+  }
 
-  if (!our_scope.CheckForUnusedVars(&err))
-    g_scheduler->FailWithError(err);
 
   // Pass all of the items that were defined off to the builder.
   for (auto& item : collected_items) {
     settings->build_settings()->ItemDefined(base::WrapUnique(item));
     item = nullptr;
   }
 
   trace.Done();
 
   main_loop_->PostTask(FROM_HERE, base::Bind(&LoaderImpl::DidLoadFile, this));
@@ skipping 136 matching lines @@
     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);
 }