Update exercise2 to use the type checker and demonstrate configuring variables.

PiperOrigin-RevId: 755002119

Author: jnthntatum

codelab/BUILD

@@ -69,17 +69,21 @@ cc_library(
     srcs = ["exercise2.cc"],
     hdrs = ["exercise2.h"],
     deps = [
+        ":cel_compiler",
+        "//compiler",
+        "//compiler:compiler_factory",
+        "//compiler:standard_library",
         "//eval/public:activation",
         "//eval/public:builtin_func_registrar",
         "//eval/public:cel_expr_builder_factory",
         "//eval/public:cel_expression",
         "//eval/public:cel_options",
         "//eval/public:cel_value",
         "//internal:status_macros",
-        "//parser",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
+        "@com_google_cel_spec//proto/cel/expr:checked_cc_proto",
         "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto",
         "@com_google_googleapis//google/rpc/context:attribute_context_cc_proto",
         "@com_google_protobuf//:protobuf",

codelab/exercise2.cc

@@ -15,29 +15,33 @@
 #include "codelab/exercise2.h"
 
 #include <memory>
-#include <string>
 
+#include "cel/expr/checked.pb.h"
 #include "cel/expr/syntax.pb.h"
 #include "google/rpc/context/attribute_context.pb.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "codelab/cel_compiler.h"
+#include "compiler/compiler.h"
+#include "compiler/compiler_factory.h"
+#include "compiler/standard_library.h"
 #include "eval/public/activation.h"
 #include "eval/public/builtin_func_registrar.h"
 #include "eval/public/cel_expr_builder_factory.h"
 #include "eval/public/cel_expression.h"
 #include "eval/public/cel_options.h"
 #include "eval/public/cel_value.h"
 #include "internal/status_macros.h"
-#include "parser/parser.h"
 #include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
 
 namespace cel_codelab {
 namespace {
 
-using ::cel::expr::ParsedExpr;
-using ::google::api::expr::parser::Parse;
+using ::cel::expr::CheckedExpr;
 using ::google::api::expr::runtime::Activation;
 using ::google::api::expr::runtime::CelError;
 using ::google::api::expr::runtime::CelExpression;
@@ -48,23 +52,45 @@ using ::google::api::expr::runtime::InterpreterOptions;
 using ::google::api::expr::runtime::RegisterBuiltinFunctions;
 using ::google::rpc::context::AttributeContext;
 
+absl::StatusOr<std::unique_ptr<cel::Compiler>> MakeCelCompiler() {
+  // Note: we are using the generated descriptor pool here for simplicity, but
+  // it has the drawback of including all message types that are linked into the
+  // binary instead of just the ones expected for the CEL environment.
+  google::protobuf::LinkMessageReflection<AttributeContext>();
+  CEL_ASSIGN_OR_RETURN(
+      std::unique_ptr<cel::CompilerBuilder> builder,
+      cel::NewCompilerBuilder(google::protobuf::DescriptorPool::generated_pool()));
+
+  CEL_RETURN_IF_ERROR(builder->AddLibrary(cel::StandardCompilerLibrary()));
+  // === Start Codelab ===
+  // Add 'AttributeContext' as a context message to the type checker and a
+  // boolean variable 'bool_var'. Relevant functions are on the
+  // TypeCheckerBuilder class (see CompilerBuilder::GetCheckerBuilder).
+  //
+  // We're reusing the same compiler for both evaluation paths here for brevity,
+  // but it's likely a better fit to configure a separate compiler per use case.
+  // === End Codelab ===
+
+  return builder->Build();
+}
+
 // Parse a cel expression and evaluate it against the given activation and
 // arena.
-absl::StatusOr<bool> ParseAndEvaluate(absl::string_view cel_expr,
-                                      const Activation& activation,
-                                      google::protobuf::Arena* arena) {
-  CEL_ASSIGN_OR_RETURN(ParsedExpr parsed_expr, Parse(cel_expr));
-
+absl::StatusOr<bool> EvalCheckedExpr(const CheckedExpr& checked_expr,
+                                     const Activation& activation,
+                                     google::protobuf::Arena* arena) {
   // Setup a default environment for building expressions.
   InterpreterOptions options;
-  std::unique_ptr<CelExpressionBuilder> builder =
-      CreateCelExpressionBuilder(options);
+  std::unique_ptr<CelExpressionBuilder> builder = CreateCelExpressionBuilder(
+      google::protobuf::DescriptorPool::generated_pool(),
+      google::protobuf::MessageFactory::generated_factory(), options);
   CEL_RETURN_IF_ERROR(
       RegisterBuiltinFunctions(builder->GetRegistry(), options));
 
+  // Note, the expression_plan below is reusable for different inputs, but we
+  // create one just in time for evaluation here.
   CEL_ASSIGN_OR_RETURN(std::unique_ptr<CelExpression> expression_plan,
-                       builder->CreateExpression(&parsed_expr.expr(),
-                                                 &parsed_expr.source_info()));
+                       builder->CreateExpression(&checked_expr));
 
   CEL_ASSIGN_OR_RETURN(CelValue result,
                        expression_plan->Evaluate(activation, arena));
@@ -80,26 +106,38 @@ absl::StatusOr<bool> ParseAndEvaluate(absl::string_view cel_expr,
 }
 }  // namespace
 
-absl::StatusOr<bool> ParseAndEvaluate(absl::string_view cel_expr,
-                                      bool bool_var) {
+absl::StatusOr<bool> CompileAndEvaluateWithBoolVar(absl::string_view cel_expr,
+                                                   bool bool_var) {
+  CEL_ASSIGN_OR_RETURN(std::unique_ptr<cel::Compiler> compiler,
+                       MakeCelCompiler());
+
+  CEL_ASSIGN_OR_RETURN(CheckedExpr checked_expr,
+                       CompileToCheckedExpr(*compiler, cel_expr));
+
   Activation activation;
   google::protobuf::Arena arena;
   // === Start Codelab ===
   // Update the activation to bind the bool argument to 'bool_var'
   // === End Codelab ===
 
-  return ParseAndEvaluate(cel_expr, activation, &arena);
+  return EvalCheckedExpr(checked_expr, activation, &arena);
 }
 
-absl::StatusOr<bool> ParseAndEvaluate(absl::string_view cel_expr,
-                                      const AttributeContext& context) {
+absl::StatusOr<bool> CompileAndEvaluateWithContext(
+    absl::string_view cel_expr, const AttributeContext& context) {
+  CEL_ASSIGN_OR_RETURN(std::unique_ptr<cel::Compiler> compiler,
+                       MakeCelCompiler());
+
+  CEL_ASSIGN_OR_RETURN(CheckedExpr checked_expr,
+                       CompileToCheckedExpr(*compiler, cel_expr));
+
   Activation activation;
   google::protobuf::Arena arena;
   // === Start Codelab ===
   // Update the activation to bind the AttributeContext.
   // === End Codelab ===
 
-  return ParseAndEvaluate(cel_expr, activation, &arena);
+  return EvalCheckedExpr(checked_expr, activation, &arena);
 }
 
 }  // namespace cel_codelab

codelab/exercise2.h

@@ -21,17 +21,17 @@
 
 namespace cel_codelab {
 
-// Parse a cel expression and evaluate it. Binds a simple boolean to the
+// Compile a cel expression and evaluate it. Binds a simple boolean to the
 // activation as 'bool_var' for use in the expression.
 //
 // cel_expr should result in a bool, otherwise an InvalidArgument error is
 // returned.
-absl::StatusOr<bool> ParseAndEvaluate(absl::string_view cel_expr,
-                                      bool bool_var);
+absl::StatusOr<bool> CompileAndEvaluateWithBoolVar(absl::string_view cel_expr,
+                                                   bool bool_var);
 
-// Parse a cel expression and evaluate it. Binds an instance of the
+// Compile a cel expression and evaluate it. Binds an instance of the
 // AttributeContext message to the activation (binding the subfields directly).
-absl::StatusOr<bool> ParseAndEvaluate(
+absl::StatusOr<bool> CompileAndEvaluateWithContext(
     absl::string_view cel_expr,
     const google::rpc::context::AttributeContext& context);
 

codelab/exercise2_test.cc

@@ -29,14 +29,18 @@ using ::google::protobuf::TextFormat;
 using ::testing::HasSubstr;
 
 TEST(Exercise2Var, Simple) {
-  EXPECT_THAT(ParseAndEvaluate("bool_var", false), IsOkAndHolds(false));
-  EXPECT_THAT(ParseAndEvaluate("bool_var", true), IsOkAndHolds(true));
-  EXPECT_THAT(ParseAndEvaluate("bool_var || true", false), IsOkAndHolds(true));
-  EXPECT_THAT(ParseAndEvaluate("bool_var && false", true), IsOkAndHolds(false));
+  EXPECT_THAT(CompileAndEvaluateWithBoolVar("bool_var", false),
+              IsOkAndHolds(false));
+  EXPECT_THAT(CompileAndEvaluateWithBoolVar("bool_var", true),
+              IsOkAndHolds(true));
+  EXPECT_THAT(CompileAndEvaluateWithBoolVar("bool_var || true", false),
+              IsOkAndHolds(true));
+  EXPECT_THAT(CompileAndEvaluateWithBoolVar("bool_var && false", true),
+              IsOkAndHolds(false));
 }
 
 TEST(Exercise2Var, WrongTypeResultError) {
-  EXPECT_THAT(ParseAndEvaluate("'not a bool'", false),
+  EXPECT_THAT(CompileAndEvaluateWithBoolVar("'not a bool'", false),
               StatusIs(absl::StatusCode::kInvalidArgument,
                        HasSubstr("expected 'bool' result got 'string")));
 }
@@ -50,13 +54,17 @@ TEST(Exercise2Context, Simple) {
                                           )pb",
                                           &context));
 
-  EXPECT_THAT(ParseAndEvaluate("source.ip == '192.168.28.1'", context),
-              IsOkAndHolds(true));
-  EXPECT_THAT(ParseAndEvaluate("request.host == 'api.example.com'", context),
+  EXPECT_THAT(
+      CompileAndEvaluateWithContext("source.ip == '192.168.28.1'", context),
+      IsOkAndHolds(true));
+  EXPECT_THAT(CompileAndEvaluateWithContext("request.host == 'api.example.com'",
+                                            context),
               IsOkAndHolds(false));
-  EXPECT_THAT(ParseAndEvaluate("request.host == 'www.example.com'", context),
+  EXPECT_THAT(CompileAndEvaluateWithContext("request.host == 'www.example.com'",
+                                            context),
               IsOkAndHolds(true));
-  EXPECT_THAT(ParseAndEvaluate("destination.ip != '192.168.56.1'", context),
+  EXPECT_THAT(CompileAndEvaluateWithContext("destination.ip != '192.168.56.1'",
+                                            context),
               IsOkAndHolds(false));
 }
 
@@ -65,7 +73,7 @@ TEST(Exercise2Context, WrongTypeResultError) {
 
   // For this codelab, we expect the bind default option which will return
   // proto api defaults for unset fields.
-  EXPECT_THAT(ParseAndEvaluate("request.host", context),
+  EXPECT_THAT(CompileAndEvaluateWithContext("request.host", context),
               StatusIs(absl::StatusCode::kInvalidArgument,
                        HasSubstr("expected 'bool' result got 'string")));
 }

codelab/exercise3_test.cc

@@ -28,7 +28,7 @@ using ::google::rpc::context::AttributeContext;
 
 // Helper for a simple CelExpression with no context.
 absl::StatusOr<bool> TruthTableTest(absl::string_view statement) {
-  return ParseAndEvaluate(statement, /*unused*/ false);
+  return CompileAndEvaluateWithBoolVar(statement, /*unused*/ false);
 }
 
 TEST(Exercise3, LogicalOr) {
@@ -85,25 +85,29 @@ TEST(Exercise3, Ternary) {
 }
 
 TEST(Exercise3, BadFieldAccess) {
-  // This type of error is normally caught by the type checker, but we can
-  // surface it here since we are only parsing. The following expressions are
-  // mistaken from the field 'request.host'
   AttributeContext context;
 
+  // This type of error is normally caught by the type checker, to allow
+  // it to surface here we use the dyn() operator to defer checking to runtime.
+  // typo-ed field name from 'request.host'
   EXPECT_THAT(
-      ParseAndEvaluate("request.hostname == 'localhost' && true", context),
+      CompileAndEvaluateWithContext(
+          "dyn(request).hostname == 'localhost' && true", context),
       StatusIs(absl::StatusCode::kNotFound, "no_such_field : hostname"));
   // Wrong
   EXPECT_THAT(
-      ParseAndEvaluate("request.hostname == 'localhost' && false", context),
+      CompileAndEvaluateWithContext(
+          "dyn(request).hostname == 'localhost' && false", context),
       StatusIs(absl::StatusCode::kNotFound, "no_such_field : hostname"));
 
   // Wrong
   EXPECT_THAT(
-      ParseAndEvaluate("request.hostname == 'localhost' || true", context),
+      CompileAndEvaluateWithContext(
+          "dyn(request).hostname == 'localhost' || true", context),
       StatusIs(absl::StatusCode::kNotFound, "no_such_field : hostname"));
   EXPECT_THAT(
-      ParseAndEvaluate("request.hostname == 'localhost' || false", context),
+      CompileAndEvaluateWithContext(
+          "dyn(request).hostname == 'localhost' || false", context),
       StatusIs(absl::StatusCode::kNotFound, "no_such_field : hostname"));
 }
 

codelab/solutions/BUILD

@@ -52,6 +52,13 @@ cc_library(
     srcs = ["exercise2.cc"],
     hdrs = ["//codelab:exercise2.h"],
     deps = [
+        "//checker:type_checker_builder",
+        "//codelab:cel_compiler",
+        "//common:decl",
+        "//common:type",
+        "//compiler",
+        "//compiler:compiler_factory",
+        "//compiler:standard_library",
         "//eval/public:activation",
         "//eval/public:activation_bind_helper",
         "//eval/public:builtin_func_registrar",
@@ -60,10 +67,10 @@ cc_library(
         "//eval/public:cel_options",
         "//eval/public:cel_value",
         "//internal:status_macros",
-        "//parser",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
+        "@com_google_cel_spec//proto/cel/expr:checked_cc_proto",
         "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto",
         "@com_google_googleapis//google/rpc/context:attribute_context_cc_proto",
         "@com_google_protobuf//:protobuf",