Minor improvements to GN's "desc" output.

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 51 matching lines @@
                         const Label& default_toolchain,
                         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++) {
+    // 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)
+      continue;
+
     OutputString(indent +
         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();
 
@@ skipping 56 matching lines @@
   if (libs.empty())
     return;
 
   if (display_header)
     OutputString("\nlibs\n");
 
   for (size_t i = 0; i < libs.size(); i++)
     OutputString("    " + libs[i] + "\n");
 }
 
+void PrintPublic(const Target* target, bool display_header) {
+  if (display_header)
+    OutputString("\npublic\n");
+
+  if (target->all_headers_public()) {
+    OutputString("  [All headers listed in the sources are public.]\n");
+    return;
+  }
+
+  Target::FileList public_headers = target->public_headers();
+  std::sort(public_headers.begin(), public_headers.end());
+  for (size_t i = 0; i < public_headers.size(); i++)
+    OutputString("  " + public_headers[i].value() + "\n");
+}
+
+void PrintVisibility(const Target* target, bool display_header) {
+  if (display_header)
+    OutputString("\nvisibility\n");
+
+  OutputString(target->visibility().Describe(2, false));
+}
+
 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 LabelConfigVector& configs = target->configs();
   for (size_t i = 0; i < configs.size(); i++) {
     OutputString("  " +
         configs[i].label.GetUserVisibleName(toolchain_label) + "\n");
@@ skipping 82 matching lines @@
 const char kDesc_Help[] =
     "gn desc <target label> [<what to show>] [--blame] [--all | --tree]\n"
     "  Displays information about a given labeled target.\n"
     "\n"
     "Possibilities for <what to show>:\n"
     "  (If unspecified an overall summary will be displayed.)\n"
     "\n"
     "  sources\n"
     "      Source files.\n"
     "\n"
+    "  public\n"
+    "      Public header files.\n"
+    "\n"
+    "  visibility\n"
+    "      Prints which targets can depend on this one.\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"
     "      Show immediate (or, when \"--all\" or \"--tree\" is specified,\n"
     "      recursive) dependencies of the given target. \"--tree\" shows them\n"
@@ skipping 53 matching lines @@
 #define CONFIG_VALUE_HANDLER(name, type) \
     } else if (what == #name) { OUTPUT_CONFIG_VALUE(name, type)
 
   if (args.size() == 2) {
     // User specified one thing to display.
     const std::string& what = args[1];
     if (what == "configs") {
       PrintConfigs(target, false);
     } else if (what == "sources") {
       PrintSources(target, false);
+    } else if (what == "public") {
+      PrintPublic(target, false);
+    } else if (what == "visibility") {
+      PrintVisibility(target, false);
     } else if (what == "deps") {
       PrintDeps(target, false);
     } else if (what == "lib_dirs") {
       PrintLibDirs(target, false);
     } else if (what == "libs") {
       PrintLibs(target, false);
 
     CONFIG_VALUE_HANDLER(defines, std::string)
     CONFIG_VALUE_HANDLER(include_dirs, SourceDir)
     CONFIG_VALUE_HANDLER(cflags, std::string)
@@ skipping 22 matching lines @@
   // Header.
   OutputString("Target: ", DECORATION_YELLOW);
   OutputString(target->label().GetUserVisibleName(false) + "\n");
   OutputString("Type: ", DECORATION_YELLOW);
   OutputString(std::string(
       Target::GetStringForOutputType(target->output_type())) + "\n");
   OutputString("Toolchain: ", DECORATION_YELLOW);
   OutputString(target_toolchain.GetUserVisibleName(false) + "\n");
 
   PrintSources(target, true);
+  PrintPublic(target, true);
+  PrintVisibility(target, true);
   PrintConfigs(target, true);
 
   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)
   OUTPUT_CONFIG_VALUE(cflags_cc, std::string)
   OUTPUT_CONFIG_VALUE(cflags_objc, std::string)
   OUTPUT_CONFIG_VALUE(cflags_objcc, std::string)
   OUTPUT_CONFIG_VALUE(ldflags, std::string)
   PrintLibs(target, true);
   PrintLibDirs(target, true);
 
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands