Enhance GN's "desc" command to support configs.

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 <stddef.h>
 
 #include <algorithm>
 #include <set>
 #include <sstream>
 
 #include "base/command_line.h"
 #include "build/build_config.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/runtime_deps.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/substitution_writer.h"
+#include "tools/gn/switches.h"
 #include "tools/gn/target.h"
 #include "tools/gn/variables.h"
 
 namespace commands {
 
 namespace {
 
 // Desc-specific command line switches.
 const char kBlame[] = "blame";
 const char kTree[] = "tree";
@@ skipping 78 matching lines @@
   }
 }
 
 void PrintDeps(const Target* target, bool display_header) {
   const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
   Label toolchain_label = target->label().GetToolchainLabel();
 
   // Tree mode is separate.
   if (cmdline->HasSwitch(kTree)) {
     if (display_header)
-      OutputString("\nDependency tree:\n");
+      OutputString("\nDependency tree\n");
 
     if (cmdline->HasSwitch("all")) {
       // Show all tree deps with no eliding.
       RecursivePrintDeps(target, toolchain_label, nullptr, 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.
   if (cmdline->HasSwitch("all")) {
     // Show all dependencies.
     if (display_header)
-      OutputString("\nAll recursive dependencies:\n");
+      OutputString("\nAll recursive dependencies\n");
 
     std::set<const Target*> all_deps;
     RecursiveCollectChildDeps(target, &all_deps);
     FilterAndPrintTargetSet(display_header, all_deps);
   } else {
     std::vector<const Target*> deps;
     // Show direct dependencies only.
     if (display_header) {
       OutputString(
           "\nDirect dependencies "
-          "(try also \"--all\", \"--tree\", or even \"--all --tree\"):\n");
+          "(try also \"--all\", \"--tree\", or even \"--all --tree\")\n");
     }
     for (const auto& pair : target->GetDeps(Target::DEPS_ALL))
       deps.push_back(pair.ptr);
     std::sort(deps.begin(), deps.end());
     FilterAndPrintTargets(display_header, &deps);
   }
 }
 
 // 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
@@ skipping 17 matching lines @@
 
   if (display_header)
     OutputString("\nlibs\n");
 
   for (size_t i = 0; i < libs.size(); i++)
     OutputString("    " + libs[i].value() + "\n");
 }
 
 void PrintPublic(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\npublic:\n");
+    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 (const auto& hdr : public_headers)
     OutputString("  " + hdr.value() + "\n");
 }
 
 void PrintCheckIncludes(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\ncheck_includes:\n");
+    OutputString("\ncheck_includes\n");
 
   if (target->check_includes())
     OutputString("  true\n");
   else
     OutputString("  false\n");
 }
 
 void PrintAllowCircularIncludesFrom(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\nallow_circular_includes_from:\n");
+    OutputString("\nallow_circular_includes_from\n");
 
   Label toolchain_label = target->label().GetToolchainLabel();
   for (const auto& cur : target->allow_circular_includes_from())
     OutputString("  " + cur.GetUserVisibleName(toolchain_label) + "\n");
 }
 
 void PrintVisibility(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\nvisibility:\n");
+    OutputString("\nvisibility\n");
 
   OutputString(target->visibility().Describe(2, false));
 }
 
 void PrintTestonly(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\ntestonly:\n");
+    OutputString("\ntestonly\n");
 
   if (target->testonly())
     OutputString("  true\n");
   else
     OutputString("  false\n");
 }
 
 // Recursively prints subconfigs of a config.
 void PrintSubConfigs(const Config* config, int indent_level) {
   if (config->configs().empty())
     return;
 
   std::string indent(indent_level * 2, ' ');
   Label toolchain_label = config->label().GetToolchainLabel();
   for (const auto& pair : config->configs()) {
     OutputString(
         indent + pair.label.GetUserVisibleName(toolchain_label) + "\n");
     PrintSubConfigs(pair.ptr, indent_level + 1);
   }
 }
 
 // This allows configs stored as either std::vector<LabelConfigPair> or
 // UniqueVector<LabelConfigPair> to be printed.
 template <class VectorType>
-void PrintConfigsVector(const Target* target,
+void PrintConfigsVector(const Item* item,
                         const VectorType& configs,
                         const std::string& heading,
                         bool display_header) {
   if (configs.empty())
     return;
 
   bool tree = base::CommandLine::ForCurrentProcess()->HasSwitch(kTree);
 
   // Don't sort since the order determines how things are processed.
   if (display_header) {
     if (tree)
-      OutputString("\n" + heading + " tree (in order applying):\n");
+      OutputString("\n" + heading + " tree (in order applying)\n");
     else
-      OutputString("\n" + heading + " (in order applying, try also --tree):\n");
+      OutputString("\n" + heading + " (in order applying, try also --tree)\n");
   }
 
-  Label toolchain_label = target->label().GetToolchainLabel();
+  Label toolchain_label = item->label().GetToolchainLabel();
   for (const auto& config : configs) {
     OutputString("  " + config.label.GetUserVisibleName(toolchain_label) +
                  "\n");
     if (tree)
       PrintSubConfigs(config.ptr, 2);  // 2 = start with double-indent.
   }
 }
 
 void PrintConfigs(const Target* target, bool display_header) {
   PrintConfigsVector(target, target->configs().vector(), "configs",
                      display_header);
 }
 
+void PrintConfigs(const Config* config, bool display_header) {
+  PrintConfigsVector(config, config->configs().vector(), "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,
                    bool display_header) {
   if (files.empty())
     return;
 
   if (display_header)
-    OutputString("\n" + header + ":\n");
+    OutputString("\n" + header + "\n");
 
   std::string indent = indent_extra ? "    " : "  ";
 
   Target::FileList sorted = files;
   std::sort(sorted.begin(), sorted.end());
   for (const auto& elem : sorted)
     OutputString(indent + elem.value() + "\n");
 }
 
 void PrintSources(const Target* target, bool display_header) {
   PrintFileList(target->sources(), "sources", false, display_header);
 }
 
 void PrintInputs(const Target* target, bool display_header) {
   PrintFileList(target->inputs(), "inputs", false, display_header);
 }
 
 void PrintOutputs(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\noutputs:\n");
+    OutputString("\noutputs\n");
 
   if (target->output_type() == Target::ACTION) {
     // Action, print out outputs, don't apply sources to it.
     for (const auto& elem : target->action_values().outputs().list()) {
       OutputString("  " + elem.AsString() + "\n");
     }
   } else if (target->output_type() == Target::CREATE_BUNDLE) {
     std::vector<SourceFile> output_files;
     target->bundle_data().GetOutputsAsSourceFiles(target->settings(),
                                                   &output_files);
     PrintFileList(output_files, "", true, false);
   } else {
     const SubstitutionList& outputs = target->action_values().outputs();
     if (!outputs.required_types().empty()) {
       // Display the pattern and resolved pattern separately, since there are
       // subtitutions used.
-      OutputString("  Output pattern:\n");
+      OutputString("  Output pattern\n");
       for (const auto& elem : outputs.list())
         OutputString("    " + elem.AsString() + "\n");
 
       // Now display what that resolves to given the sources.
-      OutputString("\n  Resolved output file list:\n");
+      OutputString("\n  Resolved output file list\n");
     }
 
     // Resolved output list.
     std::vector<SourceFile> output_files;
     SubstitutionWriter::ApplyListToSources(target->settings(), outputs,
                                            target->sources(), &output_files);
     PrintFileList(output_files, "", true, false);
   }
 }
 
 void PrintScript(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\nscript:\n");
+    OutputString("\nscript\n");
   OutputString("  " + target->action_values().script().value() + "\n");
 }
 
 void PrintArgs(const Target* target, bool display_header) {
   if (display_header)
-    OutputString("\nargs:\n");
+    OutputString("\nargs\n");
   for (const auto& elem : target->action_values().args().list()) {
     OutputString("  " + elem.AsString() + "\n");
   }
 }
 
 void PrintDepfile(const Target* target, bool display_header) {
   if (target->action_values().depfile().empty())
     return;
   if (display_header)
-    OutputString("\ndepfile:\n");
+    OutputString("\ndepfile\n");
   OutputString("  " + target->action_values().depfile().AsString() + "\n");
 }
 
 // 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;
   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";
   }
 };
+
 template<> struct DescValueWriter<SourceDir> {
   void operator()(const SourceDir& dir, std::ostream& out) const {
     out << "    " << FormatSourceDir(dir) << "\n";
   }
 };
 
+template<> struct DescValueWriter<LibFile> {
+  void operator()(const LibFile& lib, std::ostream& out) const {
+    if (lib.is_source_file())
+      out << "    " << lib.source_file().value() << "\n";
+    else
+      out << "    " << lib.value() << "\n";
+  }
+};
+
 // Writes a given config value type to the string, optionally with attribution.
 // This should match RecursiveTargetConfigToStream in the order it traverses.
 template<typename T> void OutputRecursiveTargetConfig(
     const Target* target,
     const char* header_name,
     const std::vector<T>& (ConfigValues::* getter)() const) {
   bool display_blame =
       base::CommandLine::ForCurrentProcess()->HasSwitch(kBlame);
 
   DescValueWriter<T> writer;
@@ skipping 15 matching lines @@
         out << "  From " << target->label().GetUserVisibleName(false) << "\n";
       }
     }
 
     // Actual values.
     ConfigValuesToStream(iter.cur(), getter, writer, out);
   }
 
   std::string out_str = out.str();
   if (!out_str.empty()) {
-    OutputString("\n" + std::string(header_name) + "\n");
+    if (header_name)
+      OutputString("\n" + std::string(header_name) + "\n");
     OutputString(out_str);
   }
 }
+
+template<typename T> void OutputConfigValueArray(
+    const ConfigValues& values,
+    const char* header_name,
+    const std::vector<T>& (ConfigValues::* getter)() const) {
+  std::ostringstream out;
+
+  DescValueWriter<T> writer;
+  for (const T& cur : (values.*getter)())
+    writer(cur, out);
+
+  std::string out_str = out.str();
+  if (!out_str.empty()) {
+    if (header_name)
+      OutputString("\n" + std::string(header_name) + "\n");
+    OutputString(out_str);
+  }
+}
 
 void PrintRuntimeDeps(const Target* target) {
   bool display_blame =
       base::CommandLine::ForCurrentProcess()->HasSwitch(kBlame);
   Label toolchain = target->label().GetToolchainLabel();
 
   const Target* previous_from = NULL;
   for (const auto& pair : ComputeRuntimeDeps(target)) {
     if (display_blame) {
       // Generally a target's runtime deps will be listed sequentially, so
       // group them and don't duplicate the "from" label for two in a row.
       if (previous_from == pair.second) {
         OutputString("  ");  // Just indent.
       } else {
         previous_from = pair.second;
         OutputString("From ");
         OutputString(pair.second->label().GetUserVisibleName(toolchain));
         OutputString("\n  ");  // Make the file name indented.
       }
     }
     OutputString(pair.first.value());
     OutputString("\n");
   }
 }
 
+// If "what" is empty, prints all PCH info. If "what" is nonempty, prints only
+// the things that match (if any). Returns true if anything was printed.
+bool PrintPrecompiledHeaderInfo(const ConfigValues& values,
+                                const std::string& what,
+                                bool display_headers) {
+  bool found_match = false;
+  if (what == variables::kPrecompiledHeader || what.empty()) {
+    if (!values.precompiled_header().empty()) {
+      if (display_headers)
+        OutputString("\nprecompiled_header\n");
+      OutputString(values.precompiled_header() + "\n");
+    }
+    found_match = true;
+  }
+  if (what == variables::kPrecompiledSource || what.empty()) {
+    if (!values.precompiled_source().is_null()) {
+      if (display_headers)
+        OutputString("\nprecompiled_source\n");
+      OutputString(values.precompiled_source().value() + "\n");
+    }
+    found_match = true;
+  }
+  return found_match;
+}
+
+bool PrintTarget(const Target* target,
+                 const std::string& what,
+                 bool display_target_header) {
+  if (display_target_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->label().GetToolchainLabel().GetUserVisibleName(false) + "\n");
+  }
+
+  // Display headers when outputting everything.
+  bool display_headers = what.empty();
+  bool is_binary_output = target->IsBinary();
+
+  bool found_match = false;
+
+  // General target meta variables.
+  if (what.empty() || what == variables::kVisibility) {
+    PrintVisibility(target, display_headers);
+    found_match = true;
+  }
+  if (what.empty() || what == variables::kTestonly) {
+    PrintTestonly(target, display_headers);
+    found_match  = true;
+  }
+
+  // Binary target meta variables.
+  if (is_binary_output) {
+    if (what.empty() || what == variables::kCheckIncludes) {
+      PrintCheckIncludes(target, display_headers);
+      found_match = true;
+    }
+    if (what.empty() || what == variables::kAllowCircularIncludesFrom) {
+      PrintAllowCircularIncludesFrom(target, display_headers);
+      found_match = true;
+    }
+  }
+
+  // Sources and inputs.
+  if (what.empty() || what == variables::kSources) {
+    PrintSources(target, display_headers);
+    found_match = true;
+  }
+  if (what.empty() || what == variables::kPublic) {
+    PrintPublic(target, display_headers);
+    found_match = true;
+  }
+  if (what.empty() || what == variables::kInputs) {
+    PrintInputs(target, display_headers);
+    found_match = true;
+  }
+
+  // Configs. Configs set directly on a target are only relevant for binary
+  // targets
+  if (is_binary_output && (what.empty() || what == variables::kConfigs)) {
+    PrintConfigs(target, display_headers);
+    found_match = true;
+  }
+
+  // Dependent/public configs can be applied to anything.
+  if (what.empty() || what == variables::kPublicConfigs) {
+    PrintPublicConfigs(target, display_headers);
+    found_match = true;
+  }
+  if (what.empty() || what == variables::kAllDependentConfigs) {
+    PrintAllDependentConfigs(target, display_headers);
+    found_match = true;
+  }
+
+  // Action values.
+  if (target->output_type() == Target::ACTION ||
+      target->output_type() == Target::ACTION_FOREACH) {
+    if (what.empty() || what == variables::kScript) {
+      PrintScript(target, display_headers);
+      found_match = true;
+    }
+    if (what.empty() || what == variables::kArgs) {
+      PrintArgs(target, display_headers);
+      found_match = true;
+    }
+    if (what.empty() || what == variables::kDepfile) {
+      PrintDepfile(target, display_headers);
+      found_match = true;
+    }
+  }
+
+  // Outputs.
+  if (target->output_type() == Target::ACTION ||
+      target->output_type() == Target::ACTION_FOREACH ||
+      target->output_type() == Target::COPY_FILES ||
+      target->output_type() == Target::CREATE_BUNDLE) {
+    if (what.empty() || what == variables::kOutputs) {
+      PrintOutputs(target, display_headers);
+      found_match = true;
+    }
+  }
+
+  // Values from configs only apply to binary targets.
+  if (is_binary_output) {
+    #define CONFIG_VALUE_ARRAY_HANDLER(name, type) \
+      if (what.empty() || what == #name) { \
+        OutputRecursiveTargetConfig<type>( \
+            target, display_headers ? #name : nullptr, &ConfigValues::name); \
+        found_match = true; \
+      }
+
+    CONFIG_VALUE_ARRAY_HANDLER(arflags, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(asmflags, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(cflags, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(cflags_c, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(cflags_cc, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(cflags_objc, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(cflags_objcc, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(defines, std::string)
+    CONFIG_VALUE_ARRAY_HANDLER(include_dirs, SourceDir)
+    CONFIG_VALUE_ARRAY_HANDLER(ldflags, std::string)
+    // Libs and lib_dirs are handled specially below.
+
+    #undef CONFIG_VALUE_ARRAY_HANDLER
+
+    found_match |= PrintPrecompiledHeaderInfo(target->config_values(),
+                                              what, display_headers);
+  }
+
+  // Deps
+  if (what.empty() || what == "deps") {
+    PrintDeps(target, display_headers);
+    found_match = true;
+  }
+
+  // Runtime deps are special, print only when explicitly asked for and not in
+  // overview mode.
+  if (what == "runtime_deps") {
+    PrintRuntimeDeps(target);
+    found_match = true;
+  }
+
+  // Libs can be part of any target and get recursively pushed up the chain,
+  // so display them regardless of target type.
+  if (what.empty() || what == variables::kLibs) {
+    PrintLibs(target, display_headers);
+    found_match = true;
+  }
+  if (what.empty() || what == variables::kLibDirs) {
+    PrintLibDirs(target, display_headers);
+    found_match = true;
+  }
+
+  if (!found_match) {
+    OutputString("Don't know how to display \"" + what + "\" for \"" +
+        Target::GetStringForOutputType(target->output_type()) + "\".\n");
+    return false;
+  }
+  return true;
+}
+
+bool PrintConfig(const Config* config,
+                 const std::string& what,
+                 bool display_config_header) {
+  const ConfigValues& values = config->resolved_values();
+
+  if (display_config_header) {
+    OutputString("Config: ", DECORATION_YELLOW);
+    OutputString(config->label().GetUserVisibleName(false) + "\n");
+    OutputString("Toolchain: ", DECORATION_YELLOW);
+    OutputString(
+        config->label().GetToolchainLabel().GetUserVisibleName(false) + "\n");
+    if (what.empty() && !config->configs().empty()) {
+      OutputString(
+          "(This is a composite config, the values below are after the\n"
+          "expansion of the child configs.)\n");
+    }
+  }
+
+  // Display headers when outputting everything.
+  bool display_headers = what.empty();
+
+  if (what.empty() || what == variables::kConfigs)
+    PrintConfigs(config, display_headers);
+
+#define CONFIG_VALUE_ARRAY_HANDLER(name, type) \
+  if (what.empty() || what == #name) { \
+    OutputConfigValueArray<type>(values, display_headers ? #name : nullptr, \
+                                 &ConfigValues::name); \
+    found_match = true; \
+  }
+
+  bool found_match = false;
+
+  CONFIG_VALUE_ARRAY_HANDLER(arflags, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(asmflags, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(cflags, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(cflags_c, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(cflags_cc, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(cflags_objc, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(cflags_objcc, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(defines, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(include_dirs, SourceDir)
+  CONFIG_VALUE_ARRAY_HANDLER(ldflags, std::string)
+  CONFIG_VALUE_ARRAY_HANDLER(lib_dirs, SourceDir)
+  CONFIG_VALUE_ARRAY_HANDLER(libs, LibFile)
+
+#undef CONFIG_VALUE_ARRAY_HANDLER
+
+  // Handles all PCH-related variables.
+  found_match |= PrintPrecompiledHeaderInfo(config->resolved_values(),
+                                            what, display_headers);
+
+  if (!found_match) {
+    OutputString("Don't know how to display \"" + what + "\" for a config.\n");
+    return false;
+  }
+  return true;
+}
+
 }  // namespace
 
 // desc ------------------------------------------------------------------------
 
 const char kDesc[] = "desc";
 const char kDesc_HelpShort[] =
-    "desc: Show lots of insightful information about a target.";
+    "desc: Show lots of insightful information about a target or config.";
 const char kDesc_Help[] =
-    "gn desc <out_dir> <target label> [<what to show>] [--blame]\n"
-    "\n"
-    "  Displays information about a given labeled target for the given build.\n"
-    "  The build parameters will be taken for the build in the given\n"
-    "  <out_dir>.\n"
+    "gn desc <out_dir> <label or pattern> [<what to show>] [--blame]\n"
+    "\n"
+    "  Displays information about a given target or config. The build\n"
+    "  build parameters will be taken for the build in the given <out_dir>.\n"
+    "\n"
+    "  The <label or pattern> can be a target label, a config label, or a\n"
+    "  label pattern (see \"gn help label_pattern\"). A label pattern will\n"
+    "  only match targets.\n"
     "\n"
     "Possibilities for <what to show>\n"
+    "\n"
     "  (If unspecified an overall summary will be displayed.)\n"
     "\n"
-    "  sources\n"
-    "      Source files.\n"
-    "\n"
+    "  all_dependent_configs\n"
+    "  allow_circular_includes_from\n"
+    "  arflags [--blame]\n"
+    "  args\n"
+    "  cflags [--blame]\n"
+    "  cflags_cc [--blame]\n"
+    "  cflags_cxx [--blame]\n"
+    "  check_includes\n"
+    "  configs [--tree] (see below)\n"
+    "  defines [--blame]\n"
+    "  depfile\n"
+    "  deps [--all] [--tree] (see below)\n"
+    "  include_dirs [--blame]\n"
     "  inputs\n"
-    "      Additional input dependencies.\n"
-    "\n"
-    "  public\n"
-    "      Public header files.\n"
-    "\n"
-    "  check_includes\n"
-    "      Whether \"gn check\" checks this target for include usage.\n"
-    "\n"
-    "  allow_circular_includes_from\n"
-    "      Permit includes from these targets.\n"
-    "\n"
-    "  visibility\n"
-    "      Prints which targets can depend on this one.\n"
-    "\n"
-    "  testonly\n"
-    "      Whether this target may only be used in tests.\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\n"
-    "      Show immediate or recursive dependencies. See below for flags that\n"
-    "      control deps printing.\n"
-    "\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"
-    "  script\n"
-    "  args\n"
-    "  depfile\n"
-    "      Actions only. The script and related values.\n"
-    "\n"
-    "  outputs\n"
-    "      Outputs for script and copy target types.\n"
-    "\n"
-    "  arflags       [--blame]\n"
-    "  defines       [--blame]\n"
-    "  include_dirs  [--blame]\n"
-    "  cflags        [--blame]\n"
-    "  cflags_cc     [--blame]\n"
-    "  cflags_cxx    [--blame]\n"
-    "  ldflags       [--blame]\n"
+    "  ldflags [--blame]\n"
     "  lib_dirs\n"
     "  libs\n"
-    "      Shows the given values taken from the target and all configs\n"
-    "      applying. See \"--blame\" below.\n"
+    "  outputs\n"
+    "  public_configs\n"
+    "  public\n"
+    "  script\n"
+    "  sources\n"
+    "  testonly\n"
+    "  visibility\n"
     "\n"
     "  runtime_deps\n"
     "      Compute all runtime deps for the given target. This is a\n"
     "      computed list and does not correspond to any GN variable, unlike\n"
     "      most other values here.\n"
     "\n"
     "      The output is a list of file names relative to the build\n"
     "      directory. See \"gn help runtime_deps\" for how this is computed.\n"
     "      This also works with \"--blame\" to see the source of the\n"
     "      dependency.\n"
     "\n"
     "Shared flags\n"
     "\n"
+    ALL_TOOLCHAINS_SWITCH_HELP
+    "\n"
+    "Target flags\n"
+    "\n"
     "  --blame\n"
-    "      Used with any value specified by a config, this will name\n"
-    "      the config that specified the value. This doesn't currently work\n"
-    "      for libs and lib_dirs because those are inherited and are more\n"
-    "      complicated to figure out the blame (patches welcome).\n"
+    "      Used with any value specified on a config, this will name\n"
+    "      the config that cause that target to get the flag. This doesn't\n"
+    "      currently work for libs and lib_dirs because those are inherited\n"
+    "      and are more complicated to figure out the blame (patches\n"
+    "      welcome).\n"
     "\n"
-    "Flags that control how deps are printed\n"
+    "Configs\n"
+    "\n"
+    "  The \"configs\" section will list all configs that apply. For targets\n"
+    "  this will include configs specified in the \"configs\" variable of\n"
+    "  the target, and also configs pushed onto this target via public\n"
+    "  or \"all dependent\" configs.\n"
+    "\n"
+    "  Configs can have child configs. Specifying --tree will show the\n"
+    "  hierarchy.\n"
+    "\n"
+    "Printing deps\n"
+    "\n"
+    "  Deps will include all public, private, and data deps (TODO this could\n"
+    "  be clarified and enhanced) sorted in order applying. The following\n"
+    "  may be used:\n"
     "\n"
     "  --all\n"
     "      Collects all recursive dependencies and prints a sorted flat list.\n"
     "      Also usable with --tree (see below).\n"
     "\n"
     TARGET_PRINTING_MODE_COMMAND_LINE_HELP
     "\n"
     TARGET_TESTONLY_FILTER_COMMAND_LINE_HELP
     "\n"
     "  --tree\n"
@@ skipping 23 matching lines @@
     "      Summarizes the given target.\n"
     "\n"
     "  gn desc out/Foo :base_unittests deps --tree\n"
     "      Shows a dependency tree of the \"base_unittests\" project in\n"
     "      the current directory.\n"
     "\n"
     "  gn desc out/Debug //base defines --blame\n"
     "      Shows defines set for the //base:base target, annotated by where\n"
     "      each one was set from.\n";
 
-#define OUTPUT_CONFIG_VALUE(name, type) \
-    OutputRecursiveTargetConfig<type>(target, #name, &ConfigValues::name);
-
 int RunDesc(const std::vector<std::string>& args) {
   if (args.size() != 2 && args.size() != 3) {
     Err(Location(), "You're holding it wrong.",
         "Usage: \"gn desc <out_dir> <target_name> [<what to display>]\"")
         .PrintToStdout();
     return 1;
   }
+  const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
 
   // Deliberately leaked to avoid expensive process teardown.
   Setup* setup = new Setup;
   setup->build_settings().set_check_for_bad_items(false);
   if (!setup->DoSetup(args[0], false))
     return 1;
   if (!setup->Run())
     return 1;
 
-  const Target* target = ResolveTargetFromCommandLineString(setup, args[1]);
-  if (!target)
+  // Resolve target(s) and config from inputs.
+  UniqueVector<const Target*> target_matches;
+  UniqueVector<const Config*> config_matches;
+  UniqueVector<const Toolchain*> toolchain_matches;
+  UniqueVector<SourceFile> file_matches;
+
+  std::vector<std::string> target_list;
+  target_list.push_back(args[1]);
+
+  if (!ResolveFromCommandLineInput(
+          setup, target_list, cmdline->HasSwitch(switches::kAllToolchains),
+          &target_matches, &config_matches, &toolchain_matches, &file_matches))
     return 1;
 
-#define CONFIG_VALUE_HANDLER(name, type) \
-    } else if (what == #name) { OUTPUT_CONFIG_VALUE(name, type)
+  std::string what_to_print;
+  if (args.size() == 3)
+    what_to_print = args[2];
 
-  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::kPublicConfigs) {
-      PrintPublicConfigs(target, false);
-    } else if (what == variables::kAllDependentConfigs) {
-      PrintAllDependentConfigs(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);
-    } else if (what == variables::kAllowCircularIncludesFrom) {
-      PrintAllowCircularIncludesFrom(target, false);
-    } else if (what == variables::kVisibility) {
-      PrintVisibility(target, false);
-    } else if (what == variables::kTestonly) {
-      PrintTestonly(target, false);
-    } else if (what == variables::kInputs) {
-      PrintInputs(target, false);
-    } else if (what == variables::kScript) {
-      PrintScript(target, false);
-    } else if (what == variables::kArgs) {
-      PrintArgs(target, false);
-    } else if (what == variables::kDepfile) {
-      PrintDepfile(target, false);
-    } else if (what == variables::kOutputs) {
-      PrintOutputs(target, false);
-    } else if (what == variables::kDeps) {
-      PrintDeps(target, false);
-    } else if (what == variables::kLibDirs) {
-      PrintLibDirs(target, false);
-    } else if (what == variables::kLibs) {
-      PrintLibs(target, false);
-    } else if (what == "runtime_deps") {
-      PrintRuntimeDeps(target);
-//  }  Hidden closing brace in macro below.
+  bool multiple_outputs = (target_matches.size() + config_matches.size()) > 1;
 
-    CONFIG_VALUE_HANDLER(defines, std::string)
-    CONFIG_VALUE_HANDLER(include_dirs, SourceDir)
-    CONFIG_VALUE_HANDLER(arflags, std::string)
-    CONFIG_VALUE_HANDLER(asmflags, std::string)
-    CONFIG_VALUE_HANDLER(cflags, std::string)
-    CONFIG_VALUE_HANDLER(cflags_c, std::string)
-    CONFIG_VALUE_HANDLER(cflags_cc, std::string)
-    CONFIG_VALUE_HANDLER(cflags_objc, std::string)
-    CONFIG_VALUE_HANDLER(cflags_objcc, std::string)
-    CONFIG_VALUE_HANDLER(ldflags, std::string)
+  // Display headers for each target when printing all values, or when printing
+  // multiple targets or configs.
+  bool display_item_header = multiple_outputs || what_to_print.empty();
 
-    } else {
-      OutputString("Don't know how to display \"" + what + "\".\n");
+  bool printed_output = false;
+  for (const Target* target : target_matches) {
+    if (printed_output)
+      OutputString("\n\n");
+    printed_output = true;
+
+    if (!PrintTarget(target, what_to_print, display_item_header))
       return 1;
-    }
+  }
+  for (const Config* config : config_matches) {
+    if (printed_output)
+      OutputString("\n\n");
+    printed_output = true;
 
-#undef CONFIG_VALUE_HANDLER
-    return 0;
+    if (!PrintConfig(config, what_to_print, display_item_header))
+      return 1;
   }
 
-  // Display summary.
-
-  // Display this only applicable to binary targets.
-  bool is_binary_output =
-    target->output_type() != Target::GROUP &&
-    target->output_type() != Target::COPY_FILES &&
-    target->output_type() != Target::ACTION &&
-    target->output_type() != Target::ACTION_FOREACH &&
-    target->output_type() != Target::BUNDLE_DATA &&
-    target->output_type() != Target::CREATE_BUNDLE;
-
-  // Generally we only want to display toolchains on labels when the toolchain
-  // is different than the default one for this target (which we always print
-  // in the header).
-  Label target_toolchain = target->label().GetToolchainLabel();
-
-  // 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);
-  if (is_binary_output) {
-    PrintPublic(target, true);
-    PrintCheckIncludes(target, true);
-    PrintAllowCircularIncludesFrom(target, true);
-  }
-  PrintVisibility(target, true);
-  if (is_binary_output) {
-    PrintTestonly(target, true);
-    PrintConfigs(target, true);
-  }
-
-  PrintPublicConfigs(target, true);
-  PrintAllDependentConfigs(target, true);
-
-  PrintInputs(target, true);
-
-  if (is_binary_output) {
-    OUTPUT_CONFIG_VALUE(defines, std::string)
-    OUTPUT_CONFIG_VALUE(include_dirs, SourceDir)
-    OUTPUT_CONFIG_VALUE(asmflags, std::string)
-    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)
-
-    if (target->output_type() == Target::STATIC_LIBRARY)
-      OUTPUT_CONFIG_VALUE(arflags, std::string)
-    else if (target->output_type() != Target::SOURCE_SET)
-      OUTPUT_CONFIG_VALUE(ldflags, std::string)
-  }
-
-  if (target->output_type() == Target::ACTION ||
-      target->output_type() == Target::ACTION_FOREACH) {
-    PrintScript(target, true);
-    PrintArgs(target, true);
-    PrintDepfile(target, true);
-  }
-
-  if (target->output_type() == Target::ACTION ||
-      target->output_type() == Target::ACTION_FOREACH ||
-      target->output_type() == Target::COPY_FILES ||
-      target->output_type() == Target::CREATE_BUNDLE) {
-    PrintOutputs(target, true);
-  }
-
-  // Libs can be part of any target and get recursively pushed up the chain,
-  // so always display them, even for groups and such.
-  PrintLibs(target, true);
-  PrintLibDirs(target, true);
-
-  PrintDeps(target, true);
-
   return 0;
 }
 
 }  // namespace commands