Add ResolvedTargetDeps class

Which provides simpler and faster ways to parse target dependencies.

This will be used in a future CL that moves and caches target resolution
computations to a dedicated class.

Change-Id: Ic411989d136346cee72ca877e3c96021113dc901
Reviewed-on: https://gn-review.googlesource.com/c/gn/+/14881
Reviewed-by: Brett Wilson <brettw@chromium.org>
Commit-Queue: David Turner <digit@google.com>

build/gen.py

diff --git a/build/gen.py b/build/gen.py
index eae97f9..2d109ed 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -807,6 +807,7 @@
         'src/gn/path_output_unittest.cc',
         'src/gn/pattern_unittest.cc',
         'src/gn/pointer_set_unittest.cc',
+        'src/gn/resolved_target_deps_unittest.cc',
         'src/gn/runtime_deps_unittest.cc',
         'src/gn/scope_per_file_provider_unittest.cc',
         'src/gn/scope_unittest.cc',

src/gn/resolved_target_deps.h

diff --git a/src/gn/resolved_target_deps.h b/src/gn/resolved_target_deps.h
new file mode 100644
index 0000000..57e961f
--- /dev/null
+++ b/src/gn/resolved_target_deps.h
@@ -0,0 +1,90 @@
+// Copyright 2022 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_RESOLVED_TARGET_DEPS_H_
+#define TOOLS_GN_RESOLVED_TARGET_DEPS_H_
+
+#include "base/containers/span.h"
+#include "gn/label_ptr.h"
+
+#include <memory>
+
+// A class used to record the dependencies of a given Target in
+// a way that is much more efficient to iterate over than having three
+// separate LabelTargetVector instances. Technically equivalent to
+// DepsIterator, but profiling shows that this class is much faster
+// to use during graph-traversal heavy operations.
+//
+// Usage is:
+//   1) Create instance, passing const references to the LabelTargetVector
+//      instances for the private, public and data deps for the target.
+//
+//   2) Use private_deps(), public_deps(), data_deps(), linked_deps()
+//      and all_deps() to retrieve spans that cover various subsets of
+//      interests. These can be used directly in for-range loops as in:
+//
+//       for (const Target* target : resolved.linked_deps()) {
+//         ..
+//       }
+//
+class ResolvedTargetDeps {
+ public:
+  ResolvedTargetDeps() = default;
+
+  ResolvedTargetDeps(const LabelTargetVector& public_deps,
+                     const LabelTargetVector& private_deps,
+                     const LabelTargetVector& data_deps)
+      : public_count_(static_cast<uint32_t>(public_deps.size())),
+        private_count_(static_cast<uint32_t>(private_deps.size())),
+        data_count_(static_cast<uint32_t>(data_deps.size())),
+        deps_(Allocate(public_deps, private_deps, data_deps)) {}
+
+  size_t size() const { return private_count_ + public_count_ + data_count_; }
+
+  base::span<const Target*> public_deps() const {
+    return {deps_.get(), public_count_};
+  }
+
+  base::span<const Target*> private_deps() const {
+    return {deps_.get() + public_count_, private_count_};
+  }
+
+  base::span<const Target*> data_deps() const {
+    return {deps_.get() + private_count_ + public_count_, data_count_};
+  }
+
+  base::span<const Target*> linked_deps() const {
+    return {deps_.get(), private_count_ + public_count_};
+  }
+
+  base::span<const Target*> all_deps() const {
+    return {deps_.get(), private_count_ + public_count_ + data_count_};
+  }
+
+  static std::unique_ptr<const Target*[]> Allocate(
+      const LabelTargetVector& public_deps,
+      const LabelTargetVector& private_deps,
+      const LabelTargetVector& data_deps) {
+    size_t total_size =
+        private_deps.size() + public_deps.size() + data_deps.size();
+    auto result = std::make_unique<const Target*[]>(total_size);
+    const Target** ptr = result.get();
+    for (const auto& pair : public_deps)
+      *ptr++ = pair.ptr;
+    for (const auto& pair : private_deps)
+      *ptr++ = pair.ptr;
+    for (const auto& pair : data_deps)
+      *ptr++ = pair.ptr;
+    return result;
+  }
+
+ private:
+  uint32_t public_count_ = 0;
+  uint32_t private_count_ = 0;
+  uint32_t data_count_ = 0;
+  // Store the pointers in the following order: public, private, data.
+  std::unique_ptr<const Target*[]> deps_;
+};
+
+#endif  // TOOLS_GN_RESOLVED_TARGET_DEPS_H_

src/gn/resolved_target_deps_unittest.cc

diff --git a/src/gn/resolved_target_deps_unittest.cc b/src/gn/resolved_target_deps_unittest.cc
new file mode 100644
index 0000000..74d623d
--- /dev/null
+++ b/src/gn/resolved_target_deps_unittest.cc
@@ -0,0 +1,63 @@
+// Copyright 2022 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 "gn/resolved_target_deps.h"
+#include "gn/test_with_scope.h"
+#include "util/test/test.h"
+
+TEST(ResolvedTargetDeps, DefaultConstruction) {
+  ResolvedTargetDeps deps;
+  EXPECT_EQ(0u, deps.size());
+  EXPECT_TRUE(deps.public_deps().empty());
+  EXPECT_TRUE(deps.private_deps().empty());
+  EXPECT_TRUE(deps.data_deps().empty());
+  EXPECT_TRUE(deps.linked_deps().empty());
+  EXPECT_TRUE(deps.all_deps().empty());
+}
+
+TEST(ResolvedTargetDeps, Construction) {
+  TestWithScope setup;
+  TestTarget a(setup, "//foo:a", Target::STATIC_LIBRARY);
+  TestTarget b(setup, "//foo:b", Target::SOURCE_SET);
+  TestTarget c(setup, "//foo:c", Target::SOURCE_SET);
+  TestTarget d(setup, "//foo:d", Target::SOURCE_SET);
+  TestTarget e(setup, "//foo:e", Target::EXECUTABLE);
+
+  LabelTargetVector public_vec;
+  LabelTargetVector private_vec;
+  LabelTargetVector data_vec;
+
+  public_vec.emplace_back(&a);
+  public_vec.emplace_back(&b);
+  private_vec.emplace_back(&c);
+  private_vec.emplace_back(&d);
+  data_vec.emplace_back(&e);
+
+  ResolvedTargetDeps deps(public_vec, private_vec, data_vec);
+  EXPECT_EQ(5u, deps.size());
+
+  EXPECT_EQ(2u, deps.public_deps().size());
+  EXPECT_EQ(&a, deps.public_deps()[0]);
+  EXPECT_EQ(&b, deps.public_deps()[1]);
+
+  EXPECT_EQ(2u, deps.private_deps().size());
+  EXPECT_EQ(&c, deps.private_deps()[0]);
+  EXPECT_EQ(&d, deps.private_deps()[1]);
+
+  EXPECT_EQ(1u, deps.data_deps().size());
+  EXPECT_EQ(&e, deps.data_deps()[0]);
+
+  EXPECT_EQ(4u, deps.linked_deps().size());
+  EXPECT_EQ(&a, deps.linked_deps()[0]);
+  EXPECT_EQ(&b, deps.linked_deps()[1]);
+  EXPECT_EQ(&c, deps.linked_deps()[2]);
+  EXPECT_EQ(&d, deps.linked_deps()[3]);
+
+  EXPECT_EQ(5u, deps.all_deps().size());
+  EXPECT_EQ(&a, deps.all_deps()[0]);
+  EXPECT_EQ(&b, deps.all_deps()[1]);
+  EXPECT_EQ(&c, deps.all_deps()[2]);
+  EXPECT_EQ(&d, deps.all_deps()[3]);
+  EXPECT_EQ(&e, deps.all_deps()[4]);
+}