Elide gn desc --tree output by default.

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"
@@ skipping 40 matching lines @@
 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);
 }
 
-// Prints dependencies of the given target (not the target itself).
+// 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());
   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 (sorted_deps[i].ptr->output_type() == Target::GROUP)
+    if (cur_dep->output_type() == Target::GROUP)
       continue;
 
     OutputString(indent +
-        sorted_deps[i].label.GetUserVisibleName(default_toolchain) + "\n");
-    RecursivePrintDeps(sorted_deps[i].ptr, default_toolchain, indent_level + 1);
+        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())
+          OutputString("...");
+      }
+    }
+
+    OutputString("\n");
+    if (print_children) {
+      RecursivePrintDeps(cur_dep, default_toolchain, seen_targets,
+                         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)
       OutputString("\nDependency tree:\n");
-    RecursivePrintDeps(target, toolchain_label, 1);
+
+    if (cmdline->HasSwitch("all")) {
+      // Show all tree deps with no eliding.
+      RecursivePrintDeps(target, toolchain_label, NULL, 1);
+    } else {
+      // 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")) {
     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 {
     if (display_header) {
-      OutputString("\nDirect dependencies "
-                   "(try also \"--all\" and \"--tree\"):\n");
+      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);
   }
@@ skipping 286 matching lines @@
     "  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"
     "      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"
-    "      Both \"deps\" and \"datadeps\" will be included.\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"
     "\n"
     "  direct_dependent_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"
@@ skipping 174 matching lines @@
   // so always display them, even for groups and such.
   PrintLibs(target, true);
   PrintLibDirs(target, true);
 
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands