No public description

PiperOrigin-RevId: 942390020

Author: CEL Dev Team

runtime/activation.cc

@@ -102,14 +102,14 @@ std::vector<FunctionOverloadReference> Activation::FindFunctionOverloads(
 
 bool Activation::InsertOrAssignValue(absl::string_view name, Value value) {
   return values_
-      .insert_or_assign(name, ValueEntry{std::move(value), absl::nullopt})
+      .insert_or_assign(name, ValueEntry{std::move(value), std::nullopt})
       .second;
 }
 
 bool Activation::InsertOrAssignValueProvider(absl::string_view name,
                                              ValueProvider provider) {
   return values_
-      .insert_or_assign(name, ValueEntry{absl::nullopt, std::move(provider)})
+      .insert_or_assign(name, ValueEntry{std::nullopt, std::move(provider)})
       .second;
 }
 

runtime/activation_test.cc

@@ -79,7 +79,7 @@ TEST_F(ActivationTest, ValueNotFound) {
 
   EXPECT_THAT(activation.FindVariable("var1", descriptor_pool(),
                                       message_factory(), arena()),
-              IsOkAndHolds(Eq(absl::nullopt)));
+              IsOkAndHolds(Eq(std::nullopt)));
 }
 
 TEST_F(ActivationTest, InsertValue) {
@@ -122,11 +122,11 @@ TEST_F(ActivationTest, InsertProviderForwardsNotFound) {
       "var1",
       [](absl::string_view name, const google::protobuf::DescriptorPool* absl_nonnull,
          google::protobuf::MessageFactory* absl_nonnull,
-         google::protobuf::Arena* absl_nonnull) { return absl::nullopt; }));
+         google::protobuf::Arena* absl_nonnull) { return std::nullopt; }));
 
   EXPECT_THAT(activation.FindVariable("var1", descriptor_pool(),
                                       message_factory(), arena()),
-              IsOkAndHolds(Eq(absl::nullopt)));
+              IsOkAndHolds(Eq(std::nullopt)));
 }
 
 TEST_F(ActivationTest, InsertProviderForwardsStatus) {
@@ -355,10 +355,10 @@ TEST_F(ActivationTest, MoveAssignment) {
   // NOLINTBEGIN(bugprone-use-after-move)
   EXPECT_THAT(moved_from.FindVariable("val", descriptor_pool(),
                                       message_factory(), arena()),
-              IsOkAndHolds(Eq(absl::nullopt)));
+              IsOkAndHolds(Eq(std::nullopt)));
   EXPECT_THAT(moved_from.FindVariable("val_provided", descriptor_pool(),
                                       message_factory(), arena()),
-              IsOkAndHolds(Eq(absl::nullopt)));
+              IsOkAndHolds(Eq(std::nullopt)));
   EXPECT_THAT(moved_from.FindFunctionOverloads("Fn"), SizeIs(0));
   EXPECT_THAT(moved_from.GetUnknownAttributes(), SizeIs(0));
   EXPECT_THAT(moved_from.GetMissingAttributes(), SizeIs(0));
@@ -405,10 +405,10 @@ TEST_F(ActivationTest, MoveCtor) {
   // NOLINTBEGIN(bugprone-use-after-move)
   EXPECT_THAT(moved_from.FindVariable("val", descriptor_pool(),
                                       message_factory(), arena()),
-              IsOkAndHolds(Eq(absl::nullopt)));
+              IsOkAndHolds(Eq(std::nullopt)));
   EXPECT_THAT(moved_from.FindVariable("val_provided", descriptor_pool(),
                                       message_factory(), arena()),
-              IsOkAndHolds(Eq(absl::nullopt)));
+              IsOkAndHolds(Eq(std::nullopt)));
   EXPECT_THAT(moved_from.FindFunctionOverloads("Fn"), SizeIs(0));
   EXPECT_THAT(moved_from.GetUnknownAttributes(), SizeIs(0));
   EXPECT_THAT(moved_from.GetMissingAttributes(), SizeIs(0));

runtime/embedder_context_test.cc

@@ -29,11 +29,11 @@ TEST(EmbedderContextTest, From) {
   struct TestScope {};
   EmbedderContext context = EmbedderContext::From<TestScope>(int64_t{42});
   EXPECT_THAT((context.Get<TestScope, int64_t>()), Optional(42));
-  EXPECT_EQ((context.Get<TestScope, uint64_t>()), absl::nullopt);
+  EXPECT_EQ((context.Get<TestScope, uint64_t>()), std::nullopt);
 
   EmbedderContext context2 = EmbedderContext::From<TestScope>(uint64_t{42});
   EXPECT_THAT((context2.Get<TestScope, uint64_t>()), Optional(42));
-  EXPECT_EQ((context2.Get<TestScope, int64_t>()), absl::nullopt);
+  EXPECT_EQ((context2.Get<TestScope, int64_t>()), std::nullopt);
 
   // Side effect, but checking that we keep a dense range.
   EXPECT_EQ(cel::TypeIdInSet<TestScope>::Size(), 2);
@@ -47,7 +47,7 @@ TEST(EmbedderContextTest, FromOutOfLine) {
   EXPECT_THAT((context.Get<TestScope, int64_t>()), Optional(42));
   EXPECT_THAT((context.Get<TestScope, uint64_t>()), Optional(43));
   EXPECT_THAT((context.Get<TestScope, double>()), Optional(44));
-  EXPECT_EQ((context.Get<TestScope, bool>()), absl::nullopt);
+  EXPECT_EQ((context.Get<TestScope, bool>()), std::nullopt);
 
   // Note: Referencing a type not intended to be stored will still reserve a
   // slot in the TypeIdInSet.
@@ -76,7 +76,7 @@ TEST(EmbedderContextTest, FromPtrs) {
 TEST(EmbedderContextTest, FromDefaultScope) {
   EmbedderContext context = EmbedderContext::From(int64_t{42});
   EXPECT_THAT((context.Get<int64_t>()), Optional(42));
-  EXPECT_EQ((context.Get<uint64_t>()), absl::nullopt);
+  EXPECT_EQ((context.Get<uint64_t>()), std::nullopt);
 }
 
 // These death assertions are only enabled when compiled in debug mode.

runtime/function_registry.cc

@@ -50,7 +50,7 @@ class ActivationFunctionProviderImpl
     std::vector<cel::FunctionOverloadReference> overloads =
         activation.FindFunctionOverloads(descriptor.name());
 
-    std::optional<FunctionOverloadReference> matching_overload = absl::nullopt;
+    std::optional<FunctionOverloadReference> matching_overload = std::nullopt;
 
     for (const auto& overload : overloads) {
       if (overload.descriptor.ShapeMatches(descriptor)) {

runtime/function_registry_test.cc

@@ -124,7 +124,7 @@ TEST(FunctionRegistryTest, DefaultLazyProviderNoOverloadFound) {
       provider.GetFunction({"LazyFunc", false, {cel::Kind::kInt64}},
                            activation));
 
-  EXPECT_EQ(func, absl::nullopt);
+  EXPECT_EQ(func, std::nullopt);
 }
 
 TEST(FunctionRegistryTest, DefaultLazyProviderReturnsImpl) {