Add support for data deps.

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 {
 
+const char kIncludeDataDeps[] = "include-datadeps";
+
 struct CompareTargetLabel {
   bool operator()(const Target* a, const Target* b) const {
     return a->label() < b->label();
   }
 };
 
 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());
 
   const std::vector<const Target*>& deps = target->deps();
   for (size_t i = 0; i < deps.size(); i++)
     RecursiveCollectDeps(deps[i], result);
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kIncludeDataDeps)) {
+    const std::vector<const Target*>& datadeps = target->datadeps();
+    for (size_t i = 0; i < datadeps.size(); i++)
+      RecursiveCollectDeps(datadeps[i], 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();
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kIncludeDataDeps)) {
+    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());
 
   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);
   }
 }
 
 void PrintDeps(const Target* target, bool display_header) {
+  const CommandLine* cmdline = CommandLine::ForCurrentProcess();
   Label toolchain_label = target->label().GetToolchainLabel();
 
   // Tree mode is separate.
-  if (CommandLine::ForCurrentProcess()->HasSwitch("tree")) {
+  if (cmdline->HasSwitch("tree")) {
     if (display_header)
       OutputString("\nDependency tree:\n");
     RecursivePrintDeps(target, toolchain_label, 1);
     return;
   }
 
   // Collect the deps to display.
   std::vector<Label> deps;
-  if (CommandLine::ForCurrentProcess()->HasSwitch("all")) {
+  if (cmdline->HasSwitch("all")) {
     if (display_header)
       OutputString("\nAll recursive dependencies:\n");
 
     std::set<Label> all_deps;
     RecursiveCollectDeps(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();
     for (size_t i = 0; i < target_deps.size(); i++)
       deps.push_back(target_deps[i]->label());
+
+    // Optionally include data deps.
+    if (cmdline->HasSwitch(kIncludeDataDeps)) {

[scottmg, 2013/08/06 20:27:58]

i feel like you probably always want to see these, at least as much as any other
dep

[brettw, 2013/08/06 21:10:22]

Okay, I removed this and included them all the time.

+      const std::vector<const Target*>& target_datadeps = target->datadeps();
+      for (size_t i = 0; i < target_datadeps.size(); i++)
+        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");
 }
 
 void PrintConfigs(const Target* target, bool display_header) {
   // Configs (don't sort since the order determines how things are processed).
   if (display_header)
@@ skipping 120 matching lines @@
     "  sources\n"
     "      Source files.\n"
     "\n"
     "  configs\n"
     "      Shows configs applied to the given target, sorted in the order\n"
     "      they're specified. This includes both configs specified in the\n"
     "      \"configs\" variable, as well as configs pushed onto this target\n"
     "      via dependencies specifying \"all\" or \"direct\" dependent\n"
     "      configs.\n"
     "\n"
-    "  deps [--all | --tree]\n"
+    "  deps [--all | --tree] [--include-datadeps]\n"
     "      Show immediate (or, when \"--all\" or \"--tree\" is specified,\n"
     "      recursive) dependencies of the given target. \"--tree\" shows them\n"
     "      in a tree format. Otherwise, they will be sorted alphabetically.\n"
     "\n"
+    "      If \"--include-datadeps\" is specified, the datadeps will be shown\n"
+    "      mixed in with the regular dependendencies.\n"
+    "\n"
     "  defines    [--blame]\n"
     "  includes   [--blame]\n"
     "  cflags     [--blame]\n"
     "  cflags_cc  [--blame]\n"
     "  cflags_cxx [--blame]\n"
     "  ldflags    [--blame]\n"
     "      Shows the given values taken from the target and all configs\n"
     "      applying. See \"--blame\" below.\n"
     "\n"
     "  --blame\n"
@@ skipping 81 matching lines @@
   PrintConfigs(target, true);
   OutputString("\n  (Use \"gn desc <label> <thing you want to see>\" to show "
                "the actual values\n   applied by the different configs. "
                "See \"gn help desc\" for more.)\n");
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands