Add accessors for underlying parser / type checker on cel::Compiler interface.

PiperOrigin-RevId: 743192974

Author: jnthntatum

compiler/BUILD

@@ -19,6 +19,7 @@ cc_library(
     hdrs = ["compiler.h"],
     deps = [
         "//checker:checker_options",
+        "//checker:type_checker",
         "//checker:type_checker_builder",
         "//checker:validation_result",
         "//parser:options",
@@ -41,6 +42,7 @@ cc_library(
         "//checker:type_checker_builder_factory",
         "//checker:validation_result",
         "//common:source",
+        "//common:type",
         "//internal:noop_delete",
         "//internal:status_macros",
         "//parser",
@@ -64,8 +66,10 @@ cc_test(
         "//checker:optional",
         "//checker:standard_library",
         "//checker:type_check_issue",
+        "//checker:type_checker",
         "//checker:validation_result",
         "//common:decl",
+        "//common:source",
         "//common:type",
         "//internal:testing",
         "//internal:testing_descriptor_pool",

compiler/compiler.h

@@ -24,6 +24,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "checker/checker_options.h"
+#include "checker/type_checker.h"
 #include "checker/type_checker_builder.h"
 #include "checker/validation_result.h"
 #include "parser/options.h"
@@ -110,6 +111,12 @@ class Compiler {
   absl::StatusOr<ValidationResult> Compile(absl::string_view source) const {
     return Compile(source, "<input>");
   }
+
+  // Accessor for the underlying type checker.
+  virtual const TypeChecker& GetTypeChecker() const = 0;
+
+  // Accessor for the underlying parser.
+  virtual const Parser& GetParser() const = 0;
 };
 
 }  // namespace cel

compiler/compiler_factory.cc

@@ -58,6 +58,9 @@ class CompilerImpl : public Compiler {
     return result;
   }
 
+  const TypeChecker& GetTypeChecker() const override { return *type_checker_; }
+  const Parser& GetParser() const override { return *parser_; }
+
  private:
   std::unique_ptr<TypeChecker> type_checker_;
   std::unique_ptr<Parser> parser_;

compiler/compiler_factory_test.cc

@@ -23,8 +23,10 @@
 #include "checker/optional.h"
 #include "checker/standard_library.h"
 #include "checker/type_check_issue.h"
+#include "checker/type_checker.h"
 #include "checker/validation_result.h"
 #include "common/decl.h"
+#include "common/source.h"
 #include "common/type.h"
 #include "compiler/compiler.h"
 #include "internal/testing.h"
@@ -51,7 +53,6 @@ TEST(CompilerFactoryTest, Works) {
       NewCompilerBuilder(cel::internal::GetSharedTestingDescriptorPool()));
 
   ASSERT_THAT(builder->AddLibrary(StandardCheckerLibrary()), IsOk());
-  builder->GetParserBuilder().GetOptions().enable_hidden_accumulator_var = true;
   ASSERT_OK_AND_ASSIGN(auto compiler, std::move(*builder).Build());
 
   ASSERT_OK_AND_ASSIGN(
@@ -164,7 +165,52 @@ TEST(CompilerFactoryTest, ParserOptions) {
   ASSERT_THAT(compiler->Compile("a.?b.orValue('foo')"), IsOk());
 }
 
-TEST(CompilerFactoryTest, DisableStandarMacros) {
+TEST(CompilerFactoryTest, GetParser) {
+  ASSERT_OK_AND_ASSIGN(
+      auto builder,
+      NewCompilerBuilder(cel::internal::GetSharedTestingDescriptorPool()));
+
+  ASSERT_OK_AND_ASSIGN(auto compiler, std::move(*builder).Build());
+
+  const cel::Parser& parser = compiler->GetParser();
+
+  ASSERT_OK_AND_ASSIGN(auto source, cel::NewSource("Or(a, b)"));
+  ASSERT_OK_AND_ASSIGN(auto ast, parser.Parse(*source));
+}
+
+TEST(CompilerFactoryTest, GetTypeChecker) {
+  ASSERT_OK_AND_ASSIGN(
+      auto builder,
+      NewCompilerBuilder(cel::internal::GetSharedTestingDescriptorPool()));
+
+  absl::Status s;
+  s.Update(builder->GetCheckerBuilder().AddVariable(
+      MakeVariableDecl("a", BoolType())));
+
+  s.Update(builder->GetCheckerBuilder().AddVariable(
+      MakeVariableDecl("b", BoolType())));
+
+  ASSERT_OK_AND_ASSIGN(
+      auto or_decl,
+      MakeFunctionDecl("Or", MakeOverloadDecl("Or_bool_bool", BoolType(),
+                                              BoolType(), BoolType())));
+  s.Update(builder->GetCheckerBuilder().AddFunction(std::move(or_decl)));
+
+  ASSERT_THAT(s, IsOk());
+  ASSERT_OK_AND_ASSIGN(auto compiler, std::move(*builder).Build());
+
+  const cel::Parser& parser = compiler->GetParser();
+
+  ASSERT_OK_AND_ASSIGN(auto source, cel::NewSource("Or(a, b)"));
+  ASSERT_OK_AND_ASSIGN(auto ast, parser.Parse(*source));
+
+  const cel::TypeChecker& checker = compiler->GetTypeChecker();
+  ASSERT_OK_AND_ASSIGN(cel::ValidationResult result,
+                       checker.Check(std::move(ast)));
+  EXPECT_TRUE(result.IsValid());
+}
+
+TEST(CompilerFactoryTest, DisableStandardMacros) {
   CompilerOptions options;
   options.parser_options.disable_standard_macros = true;