Improve error messages and reporting in GN

tools/gn/loader.h

 // 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.
 
 #ifndef TOOLS_GN_LOADER_H_
 #define TOOLS_GN_LOADER_H_
 
 #include <map>
 #include <set>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "tools/gn/label.h"
 #include "tools/gn/scope.h"
 
 namespace base {
 class MessageLoop;
 }
 
 class BuildSettings;
+class LocationRange;
 class Settings;
 class SourceFile;
 class Toolchain;
 
 // The loader manages execution of the different build files. It receives
 // requests (normally from the Builder) when new references are found, and also
 // manages loading the build config files.
 //
 // This loader class is abstract so it can be mocked out for testing the
 // Builder.
 class Loader : public base::RefCountedThreadSafe<Loader> {
  public:
   Loader();
 
   // Loads the given file in the conext of the given toolchain. The initial
   // call to this (the one that actually starts the generation) should have an
   // empty toolchain name, which will trigger the load of the default build
   // config.
   virtual void Load(const SourceFile& file,
+                    const LocationRange& origin,
                     const Label& toolchain_name) = 0;
 
   // Notification that the given toolchain has loaded. This will unblock files
   // waiting on this definition.
   virtual void ToolchainLoaded(const Toolchain* toolchain) = 0;
 
   // Returns the label of the default toolchain.
   virtual Label GetDefaultToolchain() const = 0;
 
   // Returns information about the toolchain with the given label. Will return
   // false if we haven't processed this toolchain yet.
   virtual const Settings* GetToolchainSettings(const Label& label) const = 0;
 
   // Helper function that extracts the file and toolchain name from the given
   // label, and calls Load().
-  void Load(const Label& label);
+  void Load(const Label& label, const LocationRange& origin);
 
   // Returns the build file that the given label references.
   static SourceFile BuildFileForLabel(const Label& label);
 
   // When processing the default build config, we want to capture the argument
   // of set_default_build_config. The implementation of that function uses this
   // constant as a property key to get the Label* out of the scope where the
   // label should be stored.
   static const void* kDefaultToolchainKey;
 
  protected:
   friend class base::RefCountedThreadSafe<Loader>;
   virtual ~Loader();
 };
 
 class LoaderImpl : public Loader {
  public:
   // Callback to emulate InputFileManager::AsyncLoadFile.
   typedef base::Callback<bool(const LocationRange&,
                               const BuildSettings*,
                               const SourceFile&,
                               const base::Callback<void(const ParseNode*)>&,
                               Err*)> AsyncLoadFileCallback;
 
   LoaderImpl(const BuildSettings* build_settings);
 
   // Loader implementation.
   virtual void Load(const SourceFile& file,
+                    const LocationRange& origin,
                     const Label& toolchain_name) OVERRIDE;
   virtual void ToolchainLoaded(const Toolchain* toolchain) OVERRIDE;
   virtual Label GetDefaultToolchain() const OVERRIDE;
   virtual const Settings* GetToolchainSettings(
       const Label& label) const OVERRIDE;
 
   // Sets the message loop corresponding to the main thread. By default this
   // class will use the thread active during construction, but there is not
   // a message loop active during construction all the time.
   void set_main_loop(base::MessageLoop* loop) { main_loop_ = loop; }
@@ skipping 15 matching lines @@
   }
 
  private:
   struct LoadID;
   struct ToolchainRecord;
 
   virtual ~LoaderImpl();
 
   // Schedules the input file manager to load the given file.
   void ScheduleLoadFile(const Settings* settings,
+                        const LocationRange& origin,
                         const SourceFile& file);
   void ScheduleLoadBuildConfig(
       Settings* settings,
       const Scope::KeyValueMap& toolchain_overrides);
 
   // Runs the given file on the background thread. These are called by the
   // input file manager.
   void BackgroundLoadFile(const Settings* settings,
                           const SourceFile& file_name,
                           const ParseNode* root);
@@ skipping 40 matching lines @@
   const BuildSettings* build_settings_;
   Label default_toolchain_label_;
 
   // Records for the build config file loads.
   // Owning pointers.
   typedef std::map<Label, ToolchainRecord*> ToolchainRecordMap;
   ToolchainRecordMap toolchain_records_;
 };
 
 #endif  // TOOLS_GN_LOADER_H_