Add public deps to GN

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/deps_iterator.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/item.h"
 #include "tools/gn/label.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/substitution_writer.h"
 #include "tools/gn/target.h"
 #include "tools/gn/variables.h"
 
 namespace commands {
@@ skipping 20 matching lines @@
 
 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 LabelTargetVector& deps = target->deps();
-  for (size_t i = 0; i < deps.size(); i++)
-    RecursiveCollectDeps(deps[i].ptr, result);
-
-  const LabelTargetVector& datadeps = target->datadeps();
-  for (size_t i = 0; i < datadeps.size(); i++)
-    RecursiveCollectDeps(datadeps[i].ptr, result);
+  for (DepsIterator iter(target); !iter.done(); iter.Advance())
+    RecursiveCollectDeps(iter.target(), result);
 }
 
 // Prints dependencies of the given target (not the target itself). If the
 // set is non-null, new targets encountered will be added to the set, and if
 // a dependency is in the set already, it will not be recused into. When the
 // set is null, all dependencies will be printed.
 void RecursivePrintDeps(const Target* target,
                         const Label& default_toolchain,
                         std::set<const Target*>* seen_targets,
                         int indent_level) {
-  LabelTargetVector sorted_deps = target->deps();
-  const LabelTargetVector& datadeps = target->datadeps();
-  sorted_deps.insert(sorted_deps.end(), datadeps.begin(), datadeps.end());
+  // Combine all deps into one sorted list.
+  std::vector<LabelTargetPair> sorted_deps;
+  for (DepsIterator iter(target); !iter.done(); iter.Advance())
+    sorted_deps.push_back(iter.pair());
   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++) {
     const Target* cur_dep = sorted_deps[i].ptr;
 
-    // Don't print groups. Groups are flattened such that the deps of the
-    // group are added directly to the target that depended on the group.
-    // Printing and recursing into groups here will cause such targets to be
-    // duplicated.
-    //
-    // It would be much more intuitive to do the opposite and not display the
-    // deps that were copied from the group to the target and instead display
-    // the group, but the source of those dependencies is not tracked.
-    if (cur_dep->output_type() == Target::GROUP)
-      continue;
-
     OutputString(indent +
         cur_dep->label().GetUserVisibleName(default_toolchain));
     bool print_children = true;
     if (seen_targets) {
       if (seen_targets->find(cur_dep) == seen_targets->end()) {
         // New target, mark it visited.
         seen_targets->insert(cur_dep);
       } else {
         // Already seen.
         print_children = false;
         // Only print "..." if something is actually elided, which means that
         // the current target has children.
-        if (!cur_dep->deps().empty() || !cur_dep->datadeps().empty())
+        if (!cur_dep->public_deps().empty() ||
+            !cur_dep->private_deps().empty() ||
+            !cur_dep->data_deps().empty())
           OutputString("...");
       }
     }
 
     OutputString("\n");
     if (print_children) {
       RecursivePrintDeps(cur_dep, default_toolchain, seen_targets,
                          indent_level + 1);
     }
   }
@@ skipping 15 matching lines @@
       // Don't recurse into duplicates.
       std::set<const Target*> seen_targets;
       RecursivePrintDeps(target, toolchain_label, &seen_targets, 1);
     }
     return;
   }
 
   // Collect the deps to display.
   std::vector<Label> deps;
   if (cmdline->HasSwitch("all")) {
+    // Show all dependencies.
     if (display_header)
       OutputString("\nAll recursive dependencies:\n");
 
     std::set<Label> all_deps;
     RecursiveCollectChildDeps(target, &all_deps);
     for (std::set<Label>::iterator i = all_deps.begin();
          i != all_deps.end(); ++i)
       deps.push_back(*i);
   } else {
+    // Show direct dependencies only.
     if (display_header) {
       OutputString(
           "\nDirect dependencies "
           "(try also \"--all\", \"--tree\", or even \"--all --tree\"):\n");
     }
-
-    const LabelTargetVector& target_deps = target->deps();
-    for (size_t i = 0; i < target_deps.size(); i++)
-      deps.push_back(target_deps[i].label);
-
-    const LabelTargetVector& target_datadeps = target->datadeps();
-    for (size_t i = 0; i < target_datadeps.size(); i++)
-      deps.push_back(target_datadeps[i].label);
+    for (DepsIterator iter(target); !iter.done(); iter.Advance())
+      deps.push_back(iter.label());
   }
 
   std::sort(deps.begin(), deps.end());
   for (size_t i = 0; i < deps.size(); i++)
     OutputString("  " + deps[i].GetUserVisibleName(toolchain_label) + "\n");
 }
 
 void PrintForwardDependentConfigsFrom(const Target* target,
                                       bool display_header) {
   if (target->forward_dependent_configs().empty())
@@ skipping 127 matching lines @@
     OutputString("  " +
         configs[i].label.GetUserVisibleName(toolchain_label) + "\n");
   }
 }
 
 void PrintConfigs(const Target* target, bool display_header) {
   PrintConfigsVector(target, target->configs().vector(), "configs",
                      display_header);
 }
 
-void PrintDirectDependentConfigs(const Target* target, bool display_header) {
-  PrintConfigsVector(target, target->direct_dependent_configs(),
-                     "direct_dependent_configs", display_header);
+void PrintPublicConfigs(const Target* target, bool display_header) {
+  PrintConfigsVector(target, target->public_configs(),
+                     "public_configs", display_header);
 }
 
 void PrintAllDependentConfigs(const Target* target, bool display_header) {
   PrintConfigsVector(target, target->all_dependent_configs(),
                      "all_dependent_configs", display_header);
 }
 
 void PrintFileList(const Target::FileList& files,
                    const std::string& header,
                    bool indent_extra,
@@ skipping 182 matching lines @@
     "      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"
     "      Show immediate (or, when \"--all\" or \"--tree\" is specified,\n"
     "      recursive) dependencies of the given target. \"--tree\" shows them\n"
     "      in a tree format with duplicates elided (noted by \"...\").\n"
     "      \"--all\" shows them sorted alphabetically. Using both flags will\n"
-    "      print a tree with no omissions. Both \"deps\" and \"datadeps\"\n"
-    "      will be included.\n"
+    "      print a tree with no omissions. The \"deps\", \"public_deps\", and\n"
+    "      \"data_deps\" will all be included.\n"
     "\n"
-    "  direct_dependent_configs\n"
+    "  public_configs\n"
     "  all_dependent_configs\n"
     "      Shows the labels of configs applied to targets that depend on this\n"
     "      one (either directly or all of them).\n"
     "\n"
     "  forward_dependent_configs_from\n"
     "      Shows the labels of dependencies for which dependent configs will\n"
     "      be pushed to targets depending on the current one.\n"
     "\n"
     "  script\n"
     "  args\n"
@@ skipping 62 matching lines @@
     return 1;
 
 #define CONFIG_VALUE_HANDLER(name, type) \
     } else if (what == #name) { OUTPUT_CONFIG_VALUE(name, type)
 
   if (args.size() == 3) {
     // User specified one thing to display.
     const std::string& what = args[2];
     if (what == variables::kConfigs) {
       PrintConfigs(target, false);
-    } else if (what == variables::kDirectDependentConfigs) {
-      PrintDirectDependentConfigs(target, false);
+    } else if (what == variables::kPublicConfigs) {
+      PrintPublicConfigs(target, false);
     } else if (what == variables::kAllDependentConfigs) {
       PrintAllDependentConfigs(target, false);
     } else if (what == variables::kForwardDependentConfigsFrom) {
       PrintForwardDependentConfigsFrom(target, false);
     } else if (what == variables::kSources) {
       PrintSources(target, false);
     } else if (what == variables::kPublic) {
       PrintPublic(target, false);
     } else if (what == variables::kCheckIncludes) {
       PrintCheckIncludes(target, false);
@@ skipping 66 matching lines @@
     PrintPublic(target, true);
     PrintCheckIncludes(target, true);
     PrintAllowCircularIncludesFrom(target, true);
   }
   PrintVisibility(target, true);
   if (is_binary_output) {
     PrintTestonly(target, true);
     PrintConfigs(target, true);
   }
 
-  PrintDirectDependentConfigs(target, true);
+  PrintPublicConfigs(target, true);
   PrintAllDependentConfigs(target, true);
   PrintForwardDependentConfigsFrom(target, true);
 
   PrintInputs(target, true);
 
   if (is_binary_output) {
     OUTPUT_CONFIG_VALUE(defines, std::string)
     OUTPUT_CONFIG_VALUE(include_dirs, SourceDir)
     OUTPUT_CONFIG_VALUE(cflags, std::string)
     OUTPUT_CONFIG_VALUE(cflags_c, std::string)
@@ skipping 20 matching lines @@
   // so always display them, even for groups and such.
   PrintLibs(target, true);
   PrintLibDirs(target, true);
 
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands