GN: Separately track labels and origins for lists of stuff

tools/gn/command_desc.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 <algorithm>
 #include <set>
 #include <sstream>
 
 #include "base/command_line.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_extractors.h"
 #include "tools/gn/item.h"
 #include "tools/gn/item_node.h"
 #include "tools/gn/label.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
 
 namespace commands {
 
 namespace {
 
-struct CompareTargetLabel {
-  bool operator()(const Target* a, const Target* b) const {
-    return a->label() < b->label();
-  }
-};
-
 void RecursiveCollectChildDeps(const Target* target, std::set<Label>* result);
 
 void RecursiveCollectDeps(const Target* target, std::set<Label>* result) {
   if (result->find(target->label()) != result->end())
     return;  // Already did this target.
   result->insert(target->label());
 
   RecursiveCollectChildDeps(target, result);
 }
 
 void RecursiveCollectChildDeps(const Target* target, std::set<Label>* result) {
-  const std::vector<const Target*>& deps = target->deps();
+  const LabelTargetVector& deps = target->deps();
   for (size_t i = 0; i < deps.size(); i++)
-    RecursiveCollectDeps(deps[i], result);
+    RecursiveCollectDeps(deps[i].ptr, result);
 
-  const std::vector<const Target*>& datadeps = target->datadeps();
+  const LabelTargetVector& datadeps = target->datadeps();
   for (size_t i = 0; i < datadeps.size(); i++)
-    RecursiveCollectDeps(datadeps[i], result);
+    RecursiveCollectDeps(datadeps[i].ptr, result);
 }
 
 // Prints dependencies of the given target (not the target itself).
 void RecursivePrintDeps(const Target* target,
                         const Label& default_toolchain,
                         int indent_level) {
-  std::vector<const Target*> sorted_deps = target->deps();
-  const std::vector<const Target*> datadeps = target->datadeps();
-  for (size_t i = 0; i < datadeps.size(); i++)
-    sorted_deps.push_back(datadeps[i]);
-  std::sort(sorted_deps.begin(), sorted_deps.end(), CompareTargetLabel());
+  LabelTargetVector sorted_deps = target->deps();
+  const LabelTargetVector& datadeps = target->datadeps();
+  sorted_deps.insert(sorted_deps.end(), datadeps.begin(), datadeps.end());
+  std::sort(sorted_deps.begin(), sorted_deps.end(),
+            LabelPtrLabelLess<Target>());
 
   std::string indent(indent_level * 2, ' ');
   for (size_t i = 0; i < sorted_deps.size(); i++) {
     OutputString(indent +
-        sorted_deps[i]->label().GetUserVisibleName(default_toolchain) + "\n");
-    RecursivePrintDeps(sorted_deps[i], default_toolchain, indent_level + 1);
+        sorted_deps[i].label.GetUserVisibleName(default_toolchain) + "\n");
+    RecursivePrintDeps(sorted_deps[i].ptr, default_toolchain, indent_level + 1);
   }
 }
 
 void PrintDeps(const Target* target, bool display_header) {
   const CommandLine* cmdline = CommandLine::ForCurrentProcess();
   Label toolchain_label = target->label().GetToolchainLabel();
 
   // Tree mode is separate.
   if (cmdline->HasSwitch("tree")) {
     if (display_header)
@@ skipping 12 matching lines @@
     RecursiveCollectChildDeps(target, &all_deps);
     for (std::set<Label>::iterator i = all_deps.begin();
          i != all_deps.end(); ++i)
       deps.push_back(*i);
   } else {
     if (display_header) {
       OutputString("\nDirect dependencies "
                    "(try also \"--all\" and \"--tree\"):\n");
     }
 
-    const std::vector<const Target*>& target_deps = target->deps();
+    const LabelTargetVector& target_deps = target->deps();
     for (size_t i = 0; i < target_deps.size(); i++)
-      deps.push_back(target_deps[i]->label());
+      deps.push_back(target_deps[i].label);
 
-    const std::vector<const Target*>& target_datadeps = target->datadeps();
+    const LabelTargetVector& target_datadeps = target->datadeps();
     for (size_t i = 0; i < target_datadeps.size(); i++)
-      deps.push_back(target_datadeps[i]->label());
+      deps.push_back(target_datadeps[i].label);
   }
 
   std::sort(deps.begin(), deps.end());
   for (size_t i = 0; i < deps.size(); i++)
     OutputString("  " + deps[i].GetUserVisibleName(toolchain_label) + "\n");
 }
 
 // libs and lib_dirs are special in that they're inherited. We don't currently
 // implement a blame feature for this since the bottom-up inheritance makes
 // this difficult.
@@ skipping 20 matching lines @@
   for (size_t i = 0; i < libs.size(); i++)
     OutputString("    " + libs[i] + "\n");
 }
 
 void PrintConfigs(const Target* target, bool display_header) {
   // Configs (don't sort since the order determines how things are processed).
   if (display_header)
     OutputString("\nConfigs (in order applying):\n");
 
   Label toolchain_label = target->label().GetToolchainLabel();
-  const std::vector<const Config*>& configs = target->configs();
+  const LabelConfigVector& configs = target->configs();
   for (size_t i = 0; i < configs.size(); i++) {
     OutputString("  " +
-        configs[i]->label().GetUserVisibleName(toolchain_label) + "\n");
+        configs[i].label.GetUserVisibleName(toolchain_label) + "\n");
   }
 }
 
 void PrintSources(const Target* target, bool display_header) {
   if (display_header)
     OutputString("\nSources:\n");
 
   Target::FileList sources = target->sources();
   std::sort(sources.begin(), sources.end());
   for (size_t i = 0; i < sources.size(); i++)
     OutputString("  " + sources[i].value() + "\n");
 }
 
-// Attempts to attribute the gen dependency of the given target to some source
-// code and outputs the string to the output stream.
-//
-// The attribution of the source of the dependencies is stored in the ItemNode
-// which is the parallel structure to the target dependency map, so we have
-// to jump through a few loops to find everything.
-void OutputSourceOfDep(const Target* target,
-                       const Label& dep_label,
-                       std::ostream& out) {
-  ItemTree& item_tree = target->settings()->build_settings()->item_tree();
-  base::AutoLock lock(item_tree.lock());
-
-  const ItemNode* target_node = target->item_node();
-  CHECK(target_node);
-  ItemNode* dep_node = item_tree.GetExistingNodeLocked(dep_label);
-  CHECK(dep_node);
-
-  const ItemNode::ItemNodeMap& direct_deps = target_node->direct_dependencies();
-  ItemNode::ItemNodeMap::const_iterator found = direct_deps.find(dep_node);
-  if (found == direct_deps.end())
+// Attribute the origin for attributing from where a target came from. Does
+// nothing if the input is null or it does not have a location.
+void OutputSourceOfDep(const ParseNode* origin, std::ostream& out) {
+  if (!origin)
     return;
-
-  const Location& location = found->second.begin();
+  Location location = origin->GetRange().begin();
   out << "       (Added by " + location.file()->name().value() << ":"
       << location.line_number() << ")\n";
 }
 
 // Templatized writer for writing out different config value types.
 template<typename T> struct DescValueWriter {};
 template<> struct DescValueWriter<std::string> {
   void operator()(const std::string& str, std::ostream& out) const {
     out << "    " << str << "\n";
   }
@@ skipping 23 matching lines @@
   for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
     if ((iter.cur().*getter)().empty())
       continue;
 
     // Optional blame sub-head.
     if (display_blame) {
       const Config* config = iter.GetCurrentConfig();
       if (config) {
         // Source of this value is a config.
         out << "  From " << config->label().GetUserVisibleName(false) << "\n";
-        OutputSourceOfDep(target, config->label(), out);
+        OutputSourceOfDep(iter.origin(), out);
       } else {
         // Source of this value is the target itself.
         out << "  From " << target->label().GetUserVisibleName(false) << "\n";
       }
     }
 
     // Actual values.
     ConfigValuesToStream(iter.cur(), getter, writer, out);
   }
 
@@ skipping 148 matching lines @@
   OUTPUT_CONFIG_VALUE(ldflags, std::string)
   PrintLibs(target, true);
   PrintLibDirs(target, true);
 
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands