diff --git a/tools/branch_coverage.cc b/tools/branch_coverage.cc index e2d679eb1..589cc9aab 100644 --- a/tools/branch_coverage.cc +++ b/tools/branch_coverage.cc @@ -107,7 +107,7 @@ class BranchCoverageImpl : public BranchCoverage { BranchCoverage::NodeCoverageStats StatsForNode( int64_t expr_id) const override; - const NavigableAst& ast() const override; + const NavigableProtoAst& ast() const override; const CheckedExpr& expr() const override; // Initializes the coverage implementation. This should be called by the @@ -124,10 +124,10 @@ class BranchCoverageImpl : public BranchCoverage { // Infer it the node is boolean typed. Check the type map if available. // Otherwise infer typing based on built-in functions. - bool InferredBoolType(const AstNode& node) const; + bool InferredBoolType(const NavigableProtoAstNode& node) const; CheckedExpr expr_; - NavigableAst ast_; + NavigableProtoAst ast_; mutable absl::Mutex coverage_nodes_mu_; absl::flat_hash_map coverage_nodes_ ABSL_GUARDED_BY(coverage_nodes_mu_); @@ -167,11 +167,12 @@ BranchCoverage::NodeCoverageStats BranchCoverageImpl::StatsForNode( return stats; } -const NavigableAst& BranchCoverageImpl::ast() const { return ast_; } +const NavigableProtoAst& BranchCoverageImpl::ast() const { return ast_; } const CheckedExpr& BranchCoverageImpl::expr() const { return expr_; } -bool BranchCoverageImpl::InferredBoolType(const AstNode& node) const { +bool BranchCoverageImpl::InferredBoolType( + const NavigableProtoAstNode& node) const { int64_t expr_id = node.expr()->id(); const auto* checker_type = FindCheckerType(expr_, expr_id); if (checker_type != nullptr) { @@ -183,8 +184,8 @@ bool BranchCoverageImpl::InferredBoolType(const AstNode& node) const { } void BranchCoverageImpl::Init() ABSL_NO_THREAD_SAFETY_ANALYSIS { - ast_ = NavigableAst::Build(expr_.expr()); - for (const AstNode& node : ast_.Root().DescendantsPreorder()) { + ast_ = NavigableProtoAst::Build(expr_.expr()); + for (const NavigableProtoAstNode& node : ast_.Root().DescendantsPreorder()) { int64_t expr_id = node.expr()->id(); CoverageNode& coverage_node = coverage_nodes_[expr_id]; diff --git a/tools/branch_coverage.h b/tools/branch_coverage.h index 34abc70b5..128faefed 100644 --- a/tools/branch_coverage.h +++ b/tools/branch_coverage.h @@ -54,7 +54,8 @@ class BranchCoverage { virtual NodeCoverageStats StatsForNode(int64_t expr_id) const = 0; - virtual const NavigableAst& ast() const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0; + virtual const NavigableProtoAst& ast() const + ABSL_ATTRIBUTE_LIFETIME_BOUND = 0; virtual const cel::expr::CheckedExpr& expr() const ABSL_ATTRIBUTE_LIFETIME_BOUND = 0; }; diff --git a/tools/navigable_ast.cc b/tools/navigable_ast.cc index fe274b826..63fb9e971 100644 --- a/tools/navigable_ast.cc +++ b/tools/navigable_ast.cc @@ -67,9 +67,9 @@ NodeKind GetNodeKind(const Expr& expr) { // Get the traversal relationship from parent to the given node. // Note: these depend on the ast_visitor utility's traversal ordering. -ChildKind GetChildKind( - const common_internal::NavigableAstNodeData& parent_node, - size_t child_index) { +ChildKind GetChildKind(const common_internal::NavigableAstNodeData< + NavigableProtoAstNode>& parent_node, + size_t child_index) { constexpr size_t kComprehensionRangeArgIndex = google::api::expr::runtime::ITER_RANGE; constexpr size_t kComprehensionInitArgIndex = @@ -122,26 +122,27 @@ class NavigableExprBuilderVisitor : public google::api::expr::runtime::AstVisitorBase { public: NavigableExprBuilderVisitor( - absl::AnyInvocable()> node_factory, - absl::AnyInvocable< - common_internal::NavigableAstNodeData&(AstNode&)> + absl::AnyInvocable()> node_factory, + absl::AnyInvocable&(NavigableProtoAstNode&)> node_data_accessor) : node_factory_(std::move(node_factory)), node_data_accessor_(std::move(node_data_accessor)), - metadata_(std::make_unique< - common_internal::NavigableAstMetadata>()) {} + metadata_(std::make_unique>()) {} - common_internal::NavigableAstNodeData& NodeDataAt(size_t index) { + common_internal::NavigableAstNodeData& NodeDataAt( + size_t index) { return node_data_accessor_(*metadata_->nodes[index]); } void PreVisitExpr(const Expr* expr, const SourcePosition* position) override { - AstNode* parent = parent_stack_.empty() - ? nullptr - : metadata_->nodes[parent_stack_.back()].get(); + NavigableProtoAstNode* parent = + parent_stack_.empty() ? nullptr + : metadata_->nodes[parent_stack_.back()].get(); size_t index = metadata_->nodes.size(); metadata_->nodes.push_back(node_factory_()); - AstNode* node = metadata_->nodes[index].get(); + NavigableProtoAstNode* node = metadata_->nodes[index].get(); auto& node_data = NodeDataAt(index); node_data.parent = parent; node_data.expr = expr; @@ -170,7 +171,8 @@ class NavigableExprBuilderVisitor size_t idx = parent_stack_.back(); parent_stack_.pop_back(); metadata_->postorder.push_back(metadata_->nodes[idx].get()); - common_internal::NavigableAstNodeData& node = NodeDataAt(idx); + common_internal::NavigableAstNodeData& node = + NodeDataAt(idx); if (!parent_stack_.empty()) { auto& parent_node_data = NodeDataAt(parent_stack_.back()); parent_node_data.tree_size += node.tree_size; @@ -179,28 +181,32 @@ class NavigableExprBuilderVisitor } } - std::unique_ptr> Consume() && { + std::unique_ptr> + Consume() && { return std::move(metadata_); } private: - absl::AnyInvocable()> node_factory_; - absl::AnyInvocable&(AstNode&)> + absl::AnyInvocable()> node_factory_; + absl::AnyInvocable&(NavigableProtoAstNode&)> node_data_accessor_; - std::unique_ptr> metadata_; + std::unique_ptr> + metadata_; std::vector parent_stack_; }; } // namespace -NavigableAst NavigableAst::Build(const Expr& expr) { +NavigableProtoAst NavigableProtoAst::Build(const Expr& expr) { NavigableExprBuilderVisitor visitor( - []() { return absl::WrapUnique(new AstNode()); }, - [](AstNode& node) -> common_internal::NavigableAstNodeData& { + []() { return absl::WrapUnique(new NavigableProtoAstNode()); }, + [](NavigableProtoAstNode& node) + -> common_internal::NavigableAstNodeData& { return node.data_; }); AstTraverse(&expr, /*source_info=*/nullptr, &visitor); - return NavigableAst(std::move(visitor).Consume()); + return NavigableProtoAst(std::move(visitor).Consume()); } } // namespace cel diff --git a/tools/navigable_ast.h b/tools/navigable_ast.h index 2c61ddd37..06fe809b1 100644 --- a/tools/navigable_ast.h +++ b/tools/navigable_ast.h @@ -30,27 +30,29 @@ namespace cel { -class NavigableAst; +class NavigableProtoAst; // Wrapper around a CEL AST node that exposes traversal information. -class AstNode { +class NavigableProtoAstNode { public: using ExprType = const cel::expr::Expr; // A const Span like type that provides pre-order traversal for a sub tree. // provides .begin() and .end() returning bidirectional iterators to - // const AstNode&. + // const NavigableProtoAstNode&. using PreorderRange = common_internal::NavigableAstRange< - common_internal::PreorderTraits>; + common_internal::PreorderTraits>; // A const Span like type that provides post-order traversal for a sub tree. // provides .begin() and .end() returning bidirectional iterators to - // const AstNode&. + // const NavigableProtoAstNode&. using PostorderRange = common_internal::NavigableAstRange< - common_internal::PostorderTraits>; + common_internal::PostorderTraits>; // The parent of this node or nullptr if it is a root. - const AstNode* absl_nullable parent() const { return data_.parent; } + const NavigableProtoAstNode* absl_nullable parent() const { + return data_.parent; + } const cel::expr::Expr* absl_nonnull expr() const { return data_.expr; @@ -72,7 +74,7 @@ class AstNode { // self on the longest path). size_t height() const { return data_.height; } - absl::Span children() const { + absl::Span children() const { return absl::MakeConstSpan(data_.children); } @@ -80,7 +82,8 @@ class AstNode { // semantics. Each node is visited immediately before all of its descendants. // // example: - // for (const cel::AstNode& node : ast.Root().DescendantsPreorder()) { + // for (const cel::NavigableProtoAstNode& node : + // ast.Root().DescendantsPreorder()) { // ... // } // @@ -103,13 +106,13 @@ class AstNode { } private: - friend class NavigableAst; + friend class NavigableProtoAst; - AstNode() = default; - AstNode(const AstNode&) = delete; - AstNode& operator=(const AstNode&) = delete; + NavigableProtoAstNode() = default; + NavigableProtoAstNode(const NavigableProtoAstNode&) = delete; + NavigableProtoAstNode& operator=(const NavigableProtoAstNode&) = delete; - common_internal::NavigableAstNodeData data_; + common_internal::NavigableAstNodeData data_; }; // NavigableExpr provides a view over a CEL AST that allows for generalized @@ -120,32 +123,32 @@ class AstNode { // // Pointers to AstNodes are owned by this instance and must not outlive it. // -// `NavigableAst` and Navigable nodes are independent of the input Expr and may -// outlive it, but may contain dangling pointers if the input Expr is modified -// or destroyed. -class NavigableAst { +// `NavigableProtoAst` and Navigable nodes are independent of the input Expr and +// may outlive it, but may contain dangling pointers if the input Expr is +// modified or destroyed. +class NavigableProtoAst { public: - static NavigableAst Build(const cel::expr::Expr& expr); + static NavigableProtoAst Build(const cel::expr::Expr& expr); // Default constructor creates an empty instance. // // Operations other than equality are undefined on an empty instance. // - // This is intended for composed object construction, a new NavigableAst + // This is intended for composed object construction, a new NavigableProtoAst // should be obtained from the Build factory function. - NavigableAst() = default; + NavigableProtoAst() = default; // Move only. - NavigableAst(const NavigableAst&) = delete; - NavigableAst& operator=(const NavigableAst&) = delete; - NavigableAst(NavigableAst&&) = default; - NavigableAst& operator=(NavigableAst&&) = default; + NavigableProtoAst(const NavigableProtoAst&) = delete; + NavigableProtoAst& operator=(const NavigableProtoAst&) = delete; + NavigableProtoAst(NavigableProtoAst&&) = default; + NavigableProtoAst& operator=(NavigableProtoAst&&) = default; // Return ptr to the AST node with id if present. Otherwise returns nullptr. // // If ids are non-unique, the first pre-order node encountered with id is // returned. - const AstNode* absl_nullable FindId(int64_t id) const { + const NavigableProtoAstNode* absl_nullable FindId(int64_t id) const { auto it = metadata_->id_to_node.find(id); if (it == metadata_->id_to_node.end()) { return nullptr; @@ -154,7 +157,7 @@ class NavigableAst { } // Return ptr to the AST node representing the given Expr protobuf node. - const AstNode* absl_nullable FindExpr( + const NavigableProtoAstNode* absl_nullable FindExpr( const cel::expr::Expr* expr) const { auto it = metadata_->expr_to_node.find(expr); if (it == metadata_->expr_to_node.end()) { @@ -164,7 +167,7 @@ class NavigableAst { } // The root of the AST. - const AstNode& Root() const { return *metadata_->nodes[0]; } + const NavigableProtoAstNode& Root() const { return *metadata_->nodes[0]; } // Check whether the source AST used unique IDs for each node. // @@ -177,11 +180,11 @@ class NavigableAst { // Equality operators test for identity. They are intended to distinguish // moved-from or uninitialized instances from initialized. - bool operator==(const NavigableAst& other) const { + bool operator==(const NavigableProtoAst& other) const { return metadata_ == other.metadata_; } - bool operator!=(const NavigableAst& other) const { + bool operator!=(const NavigableProtoAst& other) const { return metadata_ != other.metadata_; } @@ -189,14 +192,20 @@ class NavigableAst { explicit operator bool() const { return metadata_ != nullptr; } private: - using AstMetadata = common_internal::NavigableAstMetadata; + using AstMetadata = + common_internal::NavigableAstMetadata; - explicit NavigableAst(std::unique_ptr metadata) + explicit NavigableProtoAst(std::unique_ptr metadata) : metadata_(std::move(metadata)) {} std::unique_ptr metadata_; }; +// Type aliases for backwards compatibility. +// To be removed. +using AstNode = NavigableProtoAstNode; +using NavigableAst = NavigableProtoAst; + } // namespace cel #endif // THIRD_PARTY_CEL_CPP_TOOLS_NAVIGABLE_AST_H_ diff --git a/tools/navigable_ast_test.cc b/tools/navigable_ast_test.cc index 49d5cd5f8..a42f1d5fc 100644 --- a/tools/navigable_ast_test.cc +++ b/tools/navigable_ast_test.cc @@ -32,15 +32,15 @@ using ::testing::IsEmpty; using ::testing::Pair; using ::testing::SizeIs; -TEST(NavigableAst, Basic) { +TEST(NavigableProtoAst, Basic) { Expr const_node; const_node.set_id(1); const_node.mutable_const_expr()->set_int64_value(42); - NavigableAst ast = NavigableAst::Build(const_node); + NavigableProtoAst ast = NavigableProtoAst::Build(const_node); EXPECT_TRUE(ast.IdsAreUnique()); - const AstNode& root = ast.Root(); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.expr(), &const_node); EXPECT_THAT(root.children(), IsEmpty()); @@ -50,15 +50,15 @@ TEST(NavigableAst, Basic) { EXPECT_EQ(root.parent_relation(), ChildKind::kUnspecified); } -TEST(NavigableAst, DefaultCtorEmpty) { +TEST(NavigableProtoAst, DefaultCtorEmpty) { Expr const_node; const_node.set_id(1); const_node.mutable_const_expr()->set_int64_value(42); - NavigableAst ast = NavigableAst::Build(const_node); + NavigableProtoAst ast = NavigableProtoAst::Build(const_node); EXPECT_EQ(ast, ast); - NavigableAst empty; + NavigableProtoAst empty; EXPECT_NE(ast, empty); EXPECT_EQ(empty, empty); @@ -66,31 +66,31 @@ TEST(NavigableAst, DefaultCtorEmpty) { EXPECT_TRUE(static_cast(ast)); EXPECT_FALSE(static_cast(empty)); - NavigableAst moved = std::move(ast); + NavigableProtoAst moved = std::move(ast); EXPECT_EQ(ast, empty); EXPECT_FALSE(static_cast(ast)); EXPECT_TRUE(static_cast(moved)); } -TEST(NavigableAst, FindById) { +TEST(NavigableProtoAst, FindById) { Expr const_node; const_node.set_id(1); const_node.mutable_const_expr()->set_int64_value(42); - NavigableAst ast = NavigableAst::Build(const_node); + NavigableProtoAst ast = NavigableProtoAst::Build(const_node); - const AstNode& root = ast.Root(); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(ast.FindId(const_node.id()), &root); EXPECT_EQ(ast.FindId(-1), nullptr); } MATCHER_P(AstNodeWrapping, expr, "") { - const AstNode* ptr = arg; + const NavigableProtoAstNode* ptr = arg; return ptr != nullptr && ptr->expr() == expr; } -TEST(NavigableAst, ToleratesNonUnique) { +TEST(NavigableProtoAst, ToleratesNonUnique) { Expr call_node; call_node.set_id(1); call_node.mutable_call_expr()->set_function(cel::builtin::kNot); @@ -98,9 +98,9 @@ TEST(NavigableAst, ToleratesNonUnique) { const_node->mutable_const_expr()->set_bool_value(false); const_node->set_id(1); - NavigableAst ast = NavigableAst::Build(call_node); + NavigableProtoAst ast = NavigableProtoAst::Build(call_node); - const AstNode& root = ast.Root(); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(ast.FindId(1), &root); EXPECT_EQ(ast.FindExpr(&call_node), &root); @@ -108,24 +108,24 @@ TEST(NavigableAst, ToleratesNonUnique) { EXPECT_THAT(ast.FindExpr(const_node), AstNodeWrapping(const_node)); } -TEST(NavigableAst, FindByExprPtr) { +TEST(NavigableProtoAst, FindByExprPtr) { Expr const_node; const_node.set_id(1); const_node.mutable_const_expr()->set_int64_value(42); - NavigableAst ast = NavigableAst::Build(const_node); + NavigableProtoAst ast = NavigableProtoAst::Build(const_node); - const AstNode& root = ast.Root(); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(ast.FindExpr(&const_node), &root); EXPECT_EQ(ast.FindExpr(&Expr::default_instance()), nullptr); } -TEST(NavigableAst, Children) { +TEST(NavigableProtoAst, Children) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("1 + 2")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.expr(), &parsed_expr.expr()); EXPECT_THAT(root.children(), SizeIs(2)); @@ -151,11 +151,11 @@ TEST(NavigableAst, Children) { EXPECT_EQ(child2->child_index(), 1); } -TEST(NavigableAst, UnspecifiedExpr) { +TEST(NavigableProtoAst, UnspecifiedExpr) { Expr expr; expr.set_id(1); - NavigableAst ast = NavigableAst::Build(expr); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(expr); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.expr(), &expr); EXPECT_THAT(root.children(), SizeIs(0)); @@ -164,11 +164,11 @@ TEST(NavigableAst, UnspecifiedExpr) { EXPECT_EQ(root.node_kind(), NodeKind::kUnspecified); } -TEST(NavigableAst, ParentRelationSelect) { +TEST(NavigableProtoAst, ParentRelationSelect) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("a.b")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); ASSERT_THAT(root.children(), SizeIs(1)); const auto* child = root.children()[0]; @@ -177,11 +177,11 @@ TEST(NavigableAst, ParentRelationSelect) { EXPECT_EQ(child->node_kind(), NodeKind::kIdent); } -TEST(NavigableAst, ParentRelationCallReceiver) { +TEST(NavigableProtoAst, ParentRelationCallReceiver) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("a.b()")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); ASSERT_THAT(root.children(), SizeIs(1)); const auto* child = root.children()[0]; @@ -190,12 +190,12 @@ TEST(NavigableAst, ParentRelationCallReceiver) { EXPECT_EQ(child->node_kind(), NodeKind::kIdent); } -TEST(NavigableAst, ParentRelationCreateStruct) { +TEST(NavigableProtoAst, ParentRelationCreateStruct) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("com.example.Type{field: '123'}")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kStruct); ASSERT_THAT(root.children(), SizeIs(1)); @@ -205,11 +205,11 @@ TEST(NavigableAst, ParentRelationCreateStruct) { EXPECT_EQ(child->node_kind(), NodeKind::kConstant); } -TEST(NavigableAst, ParentRelationCreateMap) { +TEST(NavigableProtoAst, ParentRelationCreateMap) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("{'a': 123}")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kMap); ASSERT_THAT(root.children(), SizeIs(2)); @@ -223,11 +223,11 @@ TEST(NavigableAst, ParentRelationCreateMap) { EXPECT_EQ(value->node_kind(), NodeKind::kConstant); } -TEST(NavigableAst, ParentRelationCreateList) { +TEST(NavigableProtoAst, ParentRelationCreateList) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[123]")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kList); ASSERT_THAT(root.children(), SizeIs(1)); @@ -237,11 +237,11 @@ TEST(NavigableAst, ParentRelationCreateList) { EXPECT_EQ(child->node_kind(), NodeKind::kConstant); } -TEST(NavigableAst, ParentRelationComprehension) { +TEST(NavigableProtoAst, ParentRelationComprehension) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[1].all(x, x < 2)")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kComprehension); ASSERT_THAT(root.children(), SizeIs(5)); @@ -258,18 +258,18 @@ TEST(NavigableAst, ParentRelationComprehension) { EXPECT_EQ(finish->parent_relation(), ChildKind::kComprensionResult); } -TEST(NavigableAst, DescendantsPostorder) { +TEST(NavigableProtoAst, DescendantsPostorder) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("1 + (x * 3)")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kCall); std::vector constants; std::vector node_kinds; - for (const AstNode& node : root.DescendantsPostorder()) { + for (const NavigableProtoAstNode& node : root.DescendantsPostorder()) { if (node.node_kind() == NodeKind::kConstant) { constants.push_back(node.expr()->const_expr().int64_value()); } @@ -282,18 +282,18 @@ TEST(NavigableAst, DescendantsPostorder) { EXPECT_THAT(constants, ElementsAre(1, 3)); } -TEST(NavigableAst, DescendantsPreorder) { +TEST(NavigableProtoAst, DescendantsPreorder) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("1 + (x * 3)")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kCall); std::vector constants; std::vector node_kinds; - for (const AstNode& node : root.DescendantsPreorder()) { + for (const NavigableProtoAstNode& node : root.DescendantsPreorder()) { if (node.node_kind() == NodeKind::kConstant) { constants.push_back(node.expr()->const_expr().int64_value()); } @@ -306,17 +306,17 @@ TEST(NavigableAst, DescendantsPreorder) { EXPECT_THAT(constants, ElementsAre(1, 3)); } -TEST(NavigableAst, DescendantsPreorderComprehension) { +TEST(NavigableProtoAst, DescendantsPreorderComprehension) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[1, 2, 3].map(x, x + 1)")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kComprehension); std::vector> node_kinds; - for (const AstNode& node : root.DescendantsPreorder()) { + for (const NavigableProtoAstNode& node : root.DescendantsPreorder()) { node_kinds.push_back( std::make_pair(node.node_kind(), node.parent_relation())); } @@ -339,11 +339,11 @@ TEST(NavigableAst, DescendantsPreorderComprehension) { Pair(NodeKind::kIdent, ChildKind::kComprensionResult))); } -TEST(NavigableAst, TreeSize) { +TEST(NavigableProtoAst, TreeSize) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[1, 2, 3].map(x, x + 1)")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kComprehension); @@ -354,11 +354,11 @@ TEST(NavigableAst, TreeSize) { EXPECT_EQ(it->tree_size(), 1); } -TEST(NavigableAst, Height) { +TEST(NavigableProtoAst, Height) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[1, 2, 3].map(x, x + 1)")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kComprehension); @@ -369,17 +369,17 @@ TEST(NavigableAst, Height) { EXPECT_EQ(it->height(), 1); } -TEST(NavigableAst, DescendantsPreorderCreateMap) { +TEST(NavigableProtoAst, DescendantsPreorderCreateMap) { ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("{'key1': 1, 'key2': 2}")); - NavigableAst ast = NavigableAst::Build(parsed_expr.expr()); - const AstNode& root = ast.Root(); + NavigableProtoAst ast = NavigableProtoAst::Build(parsed_expr.expr()); + const NavigableProtoAstNode& root = ast.Root(); EXPECT_EQ(root.node_kind(), NodeKind::kMap); std::vector> node_kinds; - for (const AstNode& node : root.DescendantsPreorder()) { + for (const NavigableProtoAstNode& node : root.DescendantsPreorder()) { node_kinds.push_back( std::make_pair(node.node_kind(), node.parent_relation())); }