Add public deps to GN

tools/gn/target.h

 // 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.
 
 #ifndef TOOLS_GN_TARGET_H_
 #define TOOLS_GN_TARGET_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 107 matching lines @@
   FileList& data() { return data_; }
 
   // Returns true if targets depending on this one should have an order
   // dependency.
   bool hard_dep() const {
     return output_type_ == ACTION ||
            output_type_ == ACTION_FOREACH ||
            output_type_ == COPY_FILES;
   }
 
-  // Linked dependencies.
-  const LabelTargetVector& deps() const { return deps_; }
-  LabelTargetVector& deps() { return deps_; }
+  // Linked private dependencies.
+  const LabelTargetVector& private_deps() const { return private_deps_; }
+  LabelTargetVector& private_deps() { return private_deps_; }
+
+  // Linked public dependencies.
+  const LabelTargetVector& public_deps() const { return public_deps_; }
+  LabelTargetVector& public_deps() { return public_deps_; }
 
   // Non-linked dependencies.
-  const LabelTargetVector& datadeps() const { return datadeps_; }
-  LabelTargetVector& datadeps() { return datadeps_; }
+  const LabelTargetVector& data_deps() const { return data_deps_; }
+  LabelTargetVector& data_deps() { return data_deps_; }
 
   // List of configs that this class inherits settings from. Once a target is
-  // resolved, this will also list all- and direct-dependent configs.
+  // resolved, this will also list all-dependent and public configs.
   const UniqueVector<LabelConfigPair>& configs() const { return configs_; }
   UniqueVector<LabelConfigPair>& configs() { return configs_; }
 
   // List of configs that all dependencies (direct and indirect) of this
   // target get. These configs are not added to this target. Note that due
   // to the way this is computed, there may be duplicates in this list.
   const UniqueVector<LabelConfigPair>& all_dependent_configs() const {
     return all_dependent_configs_;
   }
   UniqueVector<LabelConfigPair>& all_dependent_configs() {
     return all_dependent_configs_;
   }
 
   // List of configs that targets depending directly on this one get. These
-  // configs are not added to this target.
-  const UniqueVector<LabelConfigPair>& direct_dependent_configs() const {
-    return direct_dependent_configs_;
+  // configs are also added to this target.
+  const UniqueVector<LabelConfigPair>& public_configs() const {
+    return public_configs_;
   }
-  UniqueVector<LabelConfigPair>& direct_dependent_configs() {
-    return direct_dependent_configs_;
+  UniqueVector<LabelConfigPair>& public_configs() {
+    return public_configs_;
   }
 
-  // A list of a subset of deps where we'll re-export direct_dependent_configs
-  // as direct_dependent_configs of this target.
+  // A list of a subset of deps where we'll re-export public_configs as
+  // public_configs of this target.
   const UniqueVector<LabelTargetPair>& forward_dependent_configs() const {
     return forward_dependent_configs_;
   }
   UniqueVector<LabelTargetPair>& forward_dependent_configs() {
     return forward_dependent_configs_;
   }
 
   // Dependencies that can include files from this target.
   const std::set<Label>& allow_circular_includes_from() const {
     return allow_circular_includes_from_;
@@ skipping 45 matching lines @@
   // that. This is a cache of the files to prevent every target that depends on
   // a given library from recomputing the same pattern.
   const OutputFile& link_output_file() const {
     return link_output_file_;
   }
   const OutputFile& dependency_output_file() const {
     return dependency_output_file_;
   }
 
  private:
-  void ExpandGroups();
-
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
   void PullDependentTargetInfo();
 
   // These each pull specific things from dependencies to this one when all
   // deps have been resolved.
   void PullForwardedDependentConfigs();
+  void PullForwardedDependentConfigsFrom(const Target* from);
   void PullRecursiveHardDeps();
 
   // Fills the link and dependency output files when a target is resolved.
   void FillOutputFiles();
 
   // Validates the given thing when a target is resolved.
   bool CheckVisibility(Err* err) const;
   bool CheckTestonly(Err* err) const;
 
   OutputType output_type_;
   std::string output_name_;
   std::string output_extension_;
 
   FileList sources_;
   bool all_headers_public_;
   FileList public_headers_;
   bool check_includes_;
   bool complete_static_lib_;
   bool testonly_;
   FileList inputs_;
   FileList data_;
 
   bool hard_dep_;
 
-  // Note that if there are any groups in the deps, once the target is resolved
-  // these vectors will list *both* the groups as well as the groups' deps.
-  //
-  // This is because, in general, groups should be "transparent" ways to add
-  // groups of dependencies, so adding the groups deps make this happen with
-  // no additional complexity when iterating over a target's deps.
-  //
-  // However, a group may also have specific settings and configs added to it,
-  // so we also need the group in the list so we find these things. But you
-  // shouldn't need to look inside the deps of the group since those will
-  // already be added.
-  LabelTargetVector deps_;
-  LabelTargetVector datadeps_;
+  LabelTargetVector private_deps_;
+  LabelTargetVector public_deps_;
+  LabelTargetVector data_deps_;
 
   UniqueVector<LabelConfigPair> configs_;
   UniqueVector<LabelConfigPair> all_dependent_configs_;
-  UniqueVector<LabelConfigPair> direct_dependent_configs_;
+  UniqueVector<LabelConfigPair> public_configs_;
   UniqueVector<LabelTargetPair> forward_dependent_configs_;
 
   std::set<Label> allow_circular_includes_from_;
 
   bool external_;
 
   // Static libraries and source sets from transitive deps. These things need
   // to be linked only with the end target (executable, shared library). Source
   // sets do not get pushed beyond static library boundaries, and neither
   // source sets nor static libraries get pushed beyond sahred library
@@ skipping 15 matching lines @@
   // Toolchain used by this target. Null until target is resolved.
   const Toolchain* toolchain_;
 
   // Output files. Null until the target is resolved.
   OutputFile link_output_file_;
   OutputFile dependency_output_file_;
 
   DISALLOW_COPY_AND_ASSIGN(Target);
 };
 
+// Iterates over the deps of a target.
+//
+// Since there are multiple kinds of deps, this iterator allows looping over
+// each one in one loop.
+class DepsIterator {

[jamesr, 2014/09/16 20:09:25]

imho this should get its own .h/.cc

+ public:
+  enum LinkedOnly {
+    LINKED_ONLY,
+  };
+
+  // Iterate over public, private, and data deps.
+  explicit DepsIterator(const Target* t);
+
+  // Iterate over the public and private linked deps, but not the data deps.
+  DepsIterator(const Target* t, LinkedOnly);
+
+  // Returns true when there are no more targets.
+  bool done() const {
+    return !vect_stack_[0];
+  }
+
+  // Advance to the next position. This assumes there are more vectors.

[jamesr, 2014/09/16 20:09:25]

'more vectors' -> 'more targets' ?

+  //
+  // For internal use, this function tolerates an initial index equal to the
+  // length of the current vector. In this case, it will advance to the next
+  // one.
+  void Advance();
+
+  // The current dependency.
+  const LabelTargetPair& pair() const {
+    DCHECK(current_index_ < vect_stack_[0]->size());

[jamesr, 2014/09/16 20:09:25]

DCHECK_LT will print the lhs and rhs when the assertion fails which is useful
for debugging

+    return (*vect_stack_[0])[current_index_];
+  }
+
+  // The pointer to the current dependency.
+  const Target* target() const { return pair().ptr; }
+
+  // The label of the current dependency.
+  const Label& label() const { return pair().label; }
+
+ private:
+  const LabelTargetVector* vect_stack_[3];
+
+  size_t current_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(DepsIterator);
+};
+
 namespace BASE_HASH_NAMESPACE {
 
 #if defined(COMPILER_GCC)
 template<> struct hash<const Target*> {
   std::size_t operator()(const Target* t) const {
     return reinterpret_cast<std::size_t>(t);
   }
 };
 #elif defined(COMPILER_MSVC)
 inline size_t hash_value(const Target* t) {
   return reinterpret_cast<size_t>(t);
 }
 #endif  // COMPILER...
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // TOOLS_GN_TARGET_H_