Introduce Bind expression factory helper

PiperOrigin-RevId: 913778503

Author: TristonianJones

common/expr_factory.h

@@ -352,6 +352,29 @@ class ExprFactory {
     return expr;
   }
 
+  template <typename NextIdFunc, typename BindVar, typename BindExpr,
+            typename RestExpr,
+            typename = std::enable_if_t<
+                std::is_invocable_r<ExprId, NextIdFunc>::value>,
+            typename = std::enable_if_t<IsStringLike<BindVar>::value>,
+            typename = std::enable_if_t<IsExprLike<BindExpr>::value>,
+            typename = std::enable_if_t<IsExprLike<RestExpr>::value>>
+  Expr NewBind(NextIdFunc next_id, BindVar bind_var, BindExpr bind_expr,
+               RestExpr rest_expr) {
+    Expr expr;
+    expr.set_id(next_id());
+    auto& comprehension_expr = expr.mutable_comprehension_expr();
+    comprehension_expr.set_iter_var("#unused");
+    comprehension_expr.set_iter_range(
+        NewList(next_id(), std::vector<cel::ListExprElement>{}));
+    comprehension_expr.set_accu_var(bind_var);
+    comprehension_expr.set_accu_init(std::move(bind_expr));
+    comprehension_expr.set_loop_condition(NewBoolConst(next_id(), false));
+    comprehension_expr.set_loop_step(NewIdent(next_id(), bind_var));
+    comprehension_expr.set_result(std::move(rest_expr));
+    return expr;
+  }
+
  private:
   friend class MacroExprFactory;
   friend class ParserMacroExprFactory;

parser/macro_expr_factory_test.cc

@@ -15,6 +15,7 @@
 #include "parser/macro_expr_factory.h"
 
 #include <cstdint>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/string_view.h"
@@ -39,6 +40,7 @@ class TestMacroExprFactory final : public MacroExprFactory {
     return NewUnspecified(NextId());
   }
 
+  using MacroExprFactory::NewBind;
   using MacroExprFactory::NewBoolConst;
   using MacroExprFactory::NewCall;
   using MacroExprFactory::NewComprehension;
@@ -69,6 +71,8 @@ class TestMacroExprFactory final : public MacroExprFactory {
 
 namespace {
 
+using ::testing::IsEmpty;
+
 TEST(MacroExprFactory, CopyUnspecified) {
   TestMacroExprFactory factory;
   EXPECT_EQ(factory.Copy(factory.NewUnspecified()), factory.NewUnspecified(2));
@@ -147,5 +151,52 @@ TEST(MacroExprFactory, CopyComprehension) {
           factory.NewIdent(11, "foo"), factory.NewIdent(12, "bar")));
 }
 
+TEST(MacroExprFactory, NewBind) {
+  TestMacroExprFactory factory;
+  Expr bind_expr = factory.NewIdent(10, "x");
+  Expr rest_expr = factory.NewIdent(20, "y");
+
+  auto next_id = [id = 100]() mutable { return id++; };
+
+  Expr expr =
+      factory.NewBind(next_id, "a", std::move(bind_expr), std::move(rest_expr));
+
+  EXPECT_EQ(expr.id(), 100);
+  ASSERT_TRUE(expr.has_comprehension_expr());
+
+  const auto& comp = expr.comprehension_expr();
+  EXPECT_EQ(comp.iter_var(), "#unused");
+
+  ASSERT_TRUE(comp.has_iter_range());
+  EXPECT_EQ(comp.iter_range().id(), 101);
+  EXPECT_EQ(comp.iter_range().kind_case(), ExprKindCase::kListExpr);
+  EXPECT_THAT(comp.iter_range().list_expr().elements(), IsEmpty());
+
+  EXPECT_EQ(comp.accu_var(), "a");
+
+  ASSERT_TRUE(comp.has_accu_init());
+  Expr expected_bind_expr;
+  expected_bind_expr.set_id(10);
+  expected_bind_expr.mutable_ident_expr().set_name("x");
+  EXPECT_EQ(comp.accu_init(), expected_bind_expr);
+
+  ASSERT_TRUE(comp.has_loop_condition());
+  EXPECT_EQ(comp.loop_condition().id(), 102);
+  EXPECT_EQ(comp.loop_condition().kind_case(), ExprKindCase::kConstant);
+  EXPECT_TRUE(comp.loop_condition().const_expr().has_bool_value());
+  EXPECT_FALSE(comp.loop_condition().const_expr().bool_value());
+
+  ASSERT_TRUE(comp.has_loop_step());
+  EXPECT_EQ(comp.loop_step().id(), 103);
+  EXPECT_EQ(comp.loop_step().kind_case(), ExprKindCase::kIdentExpr);
+  EXPECT_EQ(comp.loop_step().ident_expr().name(), "a");
+
+  ASSERT_TRUE(comp.has_result());
+  Expr expected_rest_expr;
+  expected_rest_expr.set_id(20);
+  expected_rest_expr.mutable_ident_expr().set_name("y");
+  EXPECT_EQ(comp.result(), expected_rest_expr);
+}
+
 }  // namespace
 }  // namespace cel