Add outputs to GN's header checker.

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/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 {
 
 namespace {
 
 // Prints the given directory in a nice way for the user to view.
 std::string FormatSourceDir(const SourceDir& dir) {
 #if defined(OS_WIN)
   // On Windows we fix up system absolute paths to look like native ones.
   // Internally, they'll look like "/C:\foo\bar/"
@@ skipping 188 matching lines @@
     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 PrintCheckIncludes(const Target* target, bool display_header) {
+  if (display_header)
+    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");
+
+  Label toolchain_label = target->label().GetToolchainLabel();
+  const std::set<Label>& allow = target->allow_circular_includes_from();
+  for (std::set<Label>::const_iterator iter = allow.begin();
+       iter != allow.end(); ++iter)
+    OutputString("  " + iter->GetUserVisibleName(toolchain_label) + "\n");
+}
+
 void PrintVisibility(const Target* target, bool display_header) {
   if (display_header)
     OutputString("\nvisibility:\n");
 
   OutputString(target->visibility().Describe(2, false));
 }
 
+void PrintTestonly(const Target* target, bool display_header) {
+  if (display_header)
+    OutputString("\ntestonly:\n");
+
+  if (target->testonly())
+    OutputString("  true\n");
+  else
+    OutputString("  false\n");
+}
+
 void PrintConfigsVector(const Target* target,
                         const LabelConfigVector& configs,
                         const std::string& heading,
                         bool display_header) {
   if (configs.empty())
     return;
 
   // Don't sort since the order determines how things are processed.
   if (display_header)
     OutputString("\n" + heading + " (in order applying):\n");
@@ skipping 202 matching lines @@
     "\n"
     "  sources\n"
     "      Source files.\n"
     "\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 [--all | --tree]\n"
     "      Show immediate (or, when \"--all\" or \"--tree\" is specified,\n"
     "      recursive) dependencies of the given target. \"--tree\" shows them\n"
@@ skipping 76 matching lines @@
   const Target* target = ResolveTargetFromCommandLineString(setup, args[1]);
   if (!target)
     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 == "configs") {
+    if (what == variables::kConfigs) {
       PrintConfigs(target, false);
-    } else if (what == "direct_dependent_configs") {
+    } else if (what == variables::kDirectDependentConfigs) {
       PrintDirectDependentConfigs(target, false);
-    } else if (what == "all_dependent_configs") {
+    } else if (what == variables::kAllDependentConfigs) {
       PrintAllDependentConfigs(target, false);
-    } else if (what == "forward_dependent_configs_from") {
+    } else if (what == variables::kForwardDependentConfigsFrom) {
       PrintForwardDependentConfigsFrom(target, false);
-    } else if (what == "sources") {
+    } else if (what == variables::kSources) {
       PrintSources(target, false);
-    } else if (what == "public") {
+    } else if (what == variables::kPublic) {
       PrintPublic(target, false);
-    } else if (what == "visibility") {
+    } 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 == "inputs") {
+    } else if (what == variables::kTestonly) {
+      PrintTestonly(target, false);
+    } else if (what == variables::kInputs) {
       PrintInputs(target, false);
-    } else if (what == "script") {
+    } else if (what == variables::kScript) {
       PrintScript(target, false);
-    } else if (what == "args") {
+    } else if (what == variables::kArgs) {
       PrintArgs(target, false);
-    } else if (what == "depfile") {
+    } else if (what == variables::kDepfile) {
       PrintDepfile(target, false);
-    } else if (what == "outputs") {
+    } else if (what == variables::kOutputs) {
       PrintOutputs(target, false);
-    } else if (what == "deps") {
+    } else if (what == variables::kDeps) {
       PrintDeps(target, false);
-    } else if (what == "lib_dirs") {
+    } else if (what == variables::kLibDirs) {
       PrintLibDirs(target, false);
-    } else if (what == "libs") {
+    } else if (what == variables::kLibs) {
       PrintLibs(target, false);
 
     CONFIG_VALUE_HANDLER(defines, std::string)
     CONFIG_VALUE_HANDLER(include_dirs, SourceDir)
     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)
@@ skipping 24 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);
-  if (is_binary_output)
+  if (is_binary_output) {
     PrintPublic(target, true);
+    PrintCheckIncludes(target, true);
+    PrintAllowCircularIncludesFrom(target, true);
+  }
   PrintVisibility(target, true);
-  if (is_binary_output)
+  if (is_binary_output) {
+    PrintTestonly(target, true);
     PrintConfigs(target, true);
+  }
 
   PrintDirectDependentConfigs(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)
@@ skipping 22 matching lines @@
   // so always display them, even for groups and such.
   PrintLibs(target, true);
   PrintLibDirs(target, true);
 
   PrintDeps(target, true);
 
   return 0;
 }
 
 }  // namespace commands