From 722718dcbb69f01eed7d03d29436399d81aaad44 Mon Sep 17 00:00:00 2001
From: Dmitri Plotnikov <dplotnikov@google.com>
Date: Fri, 6 Mar 2026 11:23:02 -0800
Subject: [PATCH] Rewrite IdentStep as Constant when variable value is provided
 to TypeChecker

PiperOrigin-RevId: 879728436
---
 eval/compiler/qualified_reference_resolver.cc | 11 ++-
 .../qualified_reference_resolver_test.cc      | 91 +++++++++++++++++++
 2 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/eval/compiler/qualified_reference_resolver.cc b/eval/compiler/qualified_reference_resolver.cc
index 09950bfe8..67f86ebb6 100644
--- a/eval/compiler/qualified_reference_resolver.cc
+++ b/eval/compiler/qualified_reference_resolver.cc
@@ -135,8 +135,17 @@ class ReferenceResolver : public cel::AstRewriterBase {
         expr.mutable_const_expr().set_int64_value(
             reference->value().int64_value());
         return true;
+      } else if (expr.has_ident_expr()) {
+        // "google.protobuf.NullValue.NULL_VALUE" is a special case: sometimes
+        // it is interpreted as null value and sometimes as an enum constant.
+        if (reference->value().has_null_value() &&
+            expr.ident_expr().name() ==
+                "google.protobuf.NullValue.NULL_VALUE") {
+          return false;
+        }
+        expr.set_const_expr(reference->value());
+        return true;
       } else {
-        // No update if the constant reference isn't an int (an enum value).
         return false;
       }
     }
diff --git a/eval/compiler/qualified_reference_resolver_test.cc b/eval/compiler/qualified_reference_resolver_test.cc
index 0d710a465..3fa7fca21 100644
--- a/eval/compiler/qualified_reference_resolver_test.cc
+++ b/eval/compiler/qualified_reference_resolver_test.cc
@@ -45,6 +45,7 @@ namespace google::api::expr::runtime {
 
 namespace {
 
+using ::absl_testing::IsOk;
 using ::absl_testing::IsOkAndHolds;
 using ::absl_testing::StatusIs;
 using ::cel::Ast;
@@ -343,6 +344,60 @@ TEST(ResolveReferences, EnumConstReferenceUsedSelect) {
                 })pb"));
 }
 
+// foo && bar
+constexpr char kConstReferenceExpr[] = R"(
+  id: 1
+  call_expr {
+    function: "_&&_"
+    args {
+      id: 2
+      ident_expr {
+        name: "foo"
+      }
+    }
+    args {
+      id: 5
+      ident_expr {
+        name: "bar"
+      }
+    }
+  }
+)";
+
+TEST(ResolveReferences, ConstReferenceFolded) {
+  std::unique_ptr<Ast> expr_ast = ParseTestProto(kConstReferenceExpr);
+  SourceInfo source_info;
+
+  CelFunctionRegistry func_registry;
+  ASSERT_THAT(RegisterBuiltinFunctions(&func_registry), IsOk());
+  cel::TypeRegistry type_registry;
+  Resolver registry("", func_registry.InternalGetRegistry(), type_registry,
+                    type_registry.GetComposedTypeProvider());
+  expr_ast->mutable_reference_map()[2].set_name("foo");
+  expr_ast->mutable_reference_map()[2].mutable_value().set_bool_value(true);
+  expr_ast->mutable_reference_map()[5].set_name("bar");
+  expr_ast->mutable_reference_map()[5].mutable_value().set_bool_value(false);
+  IssueCollector issues(RuntimeIssue::Severity::kError);
+
+  auto result = ResolveReferences(registry, issues, *expr_ast);
+
+  ASSERT_THAT(result, IsOkAndHolds(true));
+
+  EXPECT_THAT(ExprToProtoOrDie(expr_ast->root_expr()), EqualsProto(R"pb(
+                id: 1
+                call_expr {
+                  function: "_&&_"
+                  args {
+                    id: 2
+                    const_expr { bool_value: true }
+                  }
+                  args {
+                    id: 5
+                    const_expr { bool_value: false }
+                  }
+                })pb"));
+}
+
 TEST(ResolveReferences, ConstReferenceSkipped) {
   std::unique_ptr<Ast> expr_ast = ParseTestProto(kExpr);
   SourceInfo source_info;
@@ -388,6 +443,42 @@ TEST(ResolveReferences, ConstReferenceSkipped) {
                 })pb"));
 }
 
+constexpr char kNullValueReferenceExpr[] = R"(
+  id: 1
+  call_expr {
+    function: "_+_"
+    args {
+      id: 2
+      ident_expr {
+        name: "google.protobuf.NullValue.NULL_VALUE"
+      }
+    }
+    args {
+      id: 5
+      const_expr { int64_value: 1 }
+    }
+  }
+)";
+
+TEST(ResolveReferences, NullValueReferenceSkipped) {
+  std::unique_ptr<Ast> expr_ast = ParseTestProto(kNullValueReferenceExpr);
+  SourceInfo source_info;
+
+  CelFunctionRegistry func_registry;
+  ASSERT_THAT(RegisterBuiltinFunctions(&func_registry), IsOk());
+  cel::TypeRegistry type_registry;
+  Resolver registry("", func_registry.InternalGetRegistry(), type_registry,
+                    type_registry.GetComposedTypeProvider());
+  expr_ast->mutable_reference_map()[2].set_name(
+      "google.protobuf.NullValue.NULL_VALUE");
+  expr_ast->mutable_reference_map()[2].mutable_value().set_null_value(nullptr);
+  IssueCollector issues(RuntimeIssue::Severity::kError);
+
+  auto result = ResolveReferences(registry, issues, *expr_ast);
+
+  ASSERT_THAT(result, IsOkAndHolds(/*was_rewritten=*/false));
+}
+
 constexpr char kExtensionAndExpr[] = R"(
 id: 1
 call_expr {