gn desc: printing public_deps without --all and --tree

tools/gn/desc_builder.cc

 // Copyright (c) 2016 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 <set>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
@@ skipping 72 matching lines @@
                           std::set<const Target*>* result) {
   if (result->find(target) != result->end())
     return;  // Already did this target.
   result->insert(target);
 
   RecursiveCollectChildDeps(target, result);
 }
 
 void RecursiveCollectChildDeps(const Target* target,
                                std::set<const Target*>* result) {
-  for (const auto& pair : target->GetDeps(Target::DEPS_ALL))
+  for (const auto& pair : target->GetDeps(Target::DEPS_LINKED))
     RecursiveCollectDeps(pair.ptr, result);
 }
 
 // Common functionality for target and config description builder
 class BaseDescBuilder {
  public:
   typedef std::unique_ptr<base::Value> ValuePtr;
 
   BaseDescBuilder(const std::set<std::string>& what,
                   bool all,
@@ skipping 295 matching lines @@
 #undef CONFIG_VALUE_ARRAY_HANDLER
 
       // Libs and lib_dirs are handled specially below.
 
       FillInPrecompiledHeader(res.get(), target_->config_values());
     }
 
     if (what(variables::kDeps))
       res->SetWithoutPathExpansion(variables::kDeps, RenderDeps());
 
+    // By default RenderDeps only renders Target::DEPS_PRIVATE, in that case
+    // the output should be enriched also with Target::DEPS_PUBLIC.
+    if (!tree_ && !all_) {
+      if (what(variables::kPublicDeps)) {
+        res->SetWithoutPathExpansion(variables::kPublicDeps,
+                                     RenderDepsOf(Target::DEPS_PUBLIC));
+      }
+    }
+
+    if (what(variables::kDataDeps)) {
+      res->SetWithoutPathExpansion(variables::kDataDeps,
+                                   RenderDepsOf(Target::DEPS_DATA));
+    }
+
+    if (what(variables::kLinkedDeps)) {
+      res->SetWithoutPathExpansion(variables::kLinkedDeps,
+                                   RenderDepsOf(Target::DEPS_LINKED));
+    }
+
     // Runtime deps are special, print only when explicitly asked for and not in
     // overview mode.
     if (what_.find("runtime_deps") != what_.end())
       res->SetWithoutPathExpansion("runtime_deps", RenderRuntimeDeps());
 
     // 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
     // this difficult.
 
@@ skipping 26 matching lines @@
   // 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(base::ListValue* out,
                           const Target* target,
                           std::set<const Target*>* seen_targets,
                           int indent_level) {
     // Combine all deps into one sorted list.
     std::vector<LabelTargetPair> sorted_deps;
-    for (const auto& pair : target->GetDeps(Target::DEPS_ALL))
+    for (const auto& pair : target->GetDeps(Target::DEPS_LINKED))
       sorted_deps.push_back(pair);
     std::sort(sorted_deps.begin(), sorted_deps.end(),
               LabelPtrLabelLess<Target>());
 
     std::string indent(indent_level * 2, ' ');
 
     for (const auto& pair : sorted_deps) {
       const Target* cur_dep = pair.ptr;
       std::string str =
           indent + cur_dep->label().GetUserVisibleName(GetToolchainLabel());
@@ skipping 38 matching lines @@
 
       // Collect the deps to display.
       if (all_) {
         // Show all dependencies.
         std::set<const Target*> all_deps;
         RecursiveCollectChildDeps(target_, &all_deps);
         commands::FilterAndPrintTargetSet(all_deps, res.get());
       } else {
         // Show direct dependencies only.
         std::vector<const Target*> deps;
-        for (const auto& pair : target_->GetDeps(Target::DEPS_ALL))
+        for (const auto& pair : target_->GetDeps(Target::DEPS_PRIVATE))
           deps.push_back(pair.ptr);
-        std::sort(deps.begin(), deps.end());
         commands::FilterAndPrintTargets(&deps, res.get());
       }
     }
 
     return std::move(res);
   }
 
+  ValuePtr RenderDepsOf(Target::DepsIterationType type) {
+    auto res = base::MakeUnique<base::ListValue>();
+
+    std::vector<const Target*> deps;
+    for (const auto& pair : target_->GetDeps(type))
+      deps.push_back(pair.ptr);
+
+    commands::FilterAndPrintTargets(&deps, res.get());
+
+    return std::move(res);
+  }
+
   ValuePtr RenderRuntimeDeps() {
     auto res = base::MakeUnique<base::ListValue>();
 
     const Target* previous_from = NULL;
     for (const auto& pair : ComputeRuntimeDeps(target_)) {
       std::string str;
       if (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) {
@@ skipping 177 matching lines @@
 
 std::unique_ptr<base::DictionaryValue> DescBuilder::DescriptionForConfig(
     const Config* config,
     const std::string& what) {
   std::set<std::string> w;
   if (!what.empty())
     w.insert(what);
   ConfigDescBuilder b(config, w);
   return b.BuildDescription();
 }