diff --git a/eval/compiler/cel_expression_builder_flat_impl.h b/eval/compiler/cel_expression_builder_flat_impl.h
index ac6f46ce1..36f2746d3 100644
--- a/eval/compiler/cel_expression_builder_flat_impl.h
+++ b/eval/compiler/cel_expression_builder_flat_impl.h
@@ -44,7 +44,7 @@ namespace google::api::expr::runtime {
 class CelExpressionBuilderFlatImpl : public CelExpressionBuilder {
  public:
   CelExpressionBuilderFlatImpl(
-      absl::Nonnull<std::shared_ptr<cel::runtime_internal::RuntimeEnv>> env,
+      ABSL_NONNULL std::shared_ptr<cel::runtime_internal::RuntimeEnv> env,
       const cel::RuntimeOptions& options)
       : env_(std::move(env)),
         flat_expr_builder_(env_, options, /*use_legacy_type_provider=*/true) {
@@ -52,7 +52,7 @@ class CelExpressionBuilderFlatImpl : public CelExpressionBuilder {
   }
 
   explicit CelExpressionBuilderFlatImpl(
-      absl::Nonnull<std::shared_ptr<cel::runtime_internal::RuntimeEnv>> env)
+      ABSL_NONNULL std::shared_ptr<cel::runtime_internal::RuntimeEnv> env)
       : CelExpressionBuilderFlatImpl(std::move(env), cel::RuntimeOptions()) {}
 
   absl::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
@@ -99,7 +99,7 @@ class CelExpressionBuilderFlatImpl : public CelExpressionBuilder {
       std::unique_ptr<cel::Ast> converted_ast,
       std::vector<absl::Status>* warnings) const;
 
-  absl::Nonnull<std::shared_ptr<cel::runtime_internal::RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<cel::runtime_internal::RuntimeEnv> env_;
   FlatExprBuilder flat_expr_builder_;
 };
 
diff --git a/eval/compiler/constant_folding.cc b/eval/compiler/constant_folding.cc
index 554d5432d..e4314115b 100644
--- a/eval/compiler/constant_folding.cc
+++ b/eval/compiler/constant_folding.cc
@@ -79,12 +79,12 @@ enum class IsConst {
 class ConstantFoldingExtension : public ProgramOptimizer {
  public:
   ConstantFoldingExtension(
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nullable<std::shared_ptr<google::protobuf::Arena>> shared_arena,
-      absl::Nonnull<google::protobuf::Arena*> arena,
-      absl::Nullable<std::shared_ptr<google::protobuf::MessageFactory>>
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> shared_arena,
+      google::protobuf::Arena* ABSL_NONNULL arena,
+      ABSL_NULLABLE std::shared_ptr<google::protobuf::MessageFactory>
           shared_message_factory,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
       const TypeProvider& type_provider)
       : shared_arena_(std::move(shared_arena)),
         shared_message_factory_(std::move(shared_message_factory)),
@@ -105,10 +105,9 @@ class ConstantFoldingExtension : public ProgramOptimizer {
   // if the comprehension variables are only used in a const way.
   static constexpr size_t kComprehensionSlotCount = 0;
 
-  absl::Nullable<std::shared_ptr<google::protobuf::Arena>> shared_arena_;
+  ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> shared_arena_;
   ABSL_ATTRIBUTE_UNUSED
-  absl::Nullable<std::shared_ptr<google::protobuf::MessageFactory>>
-      shared_message_factory_;
+  ABSL_NULLABLE std::shared_ptr<google::protobuf::MessageFactory> shared_message_factory_;
   Activation empty_;
   FlatExpressionEvaluatorState state_;
 
@@ -252,8 +251,8 @@ absl::Status ConstantFoldingExtension::OnPostVisit(PlannerContext& context,
 }  // namespace
 
 ProgramOptimizerFactory CreateConstantFoldingOptimizer(
-    absl::Nullable<std::shared_ptr<google::protobuf::Arena>> arena,
-    absl::Nullable<std::shared_ptr<google::protobuf::MessageFactory>> message_factory) {
+    ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> arena,
+    ABSL_NULLABLE std::shared_ptr<google::protobuf::MessageFactory> message_factory) {
   return
       [shared_arena = std::move(arena),
        shared_message_factory = std::move(message_factory)](
@@ -262,11 +261,11 @@ ProgramOptimizerFactory CreateConstantFoldingOptimizer(
         // If one was explicitly provided during planning or none was explicitly
         // provided during configuration, request one from the planning context.
         // Otherwise use the one provided during configuration.
-        absl::Nonnull<google::protobuf::Arena*> arena =
+        google::protobuf::Arena* ABSL_NONNULL arena =
             context.HasExplicitArena() || shared_arena == nullptr
                 ? context.MutableArena()
                 : shared_arena.get();
-        absl::Nonnull<google::protobuf::MessageFactory*> message_factory =
+        google::protobuf::MessageFactory* ABSL_NONNULL message_factory =
             context.HasExplicitMessageFactory() ||
                     shared_message_factory == nullptr
                 ? context.MutableMessageFactory()
diff --git a/eval/compiler/constant_folding.h b/eval/compiler/constant_folding.h
index 532ba2b4b..24a52c7de 100644
--- a/eval/compiler/constant_folding.h
+++ b/eval/compiler/constant_folding.h
@@ -33,8 +33,8 @@ namespace cel::runtime_internal {
 // extension.
 google::api::expr::runtime::ProgramOptimizerFactory
 CreateConstantFoldingOptimizer(
-    absl::Nullable<std::shared_ptr<google::protobuf::Arena>> arena = nullptr,
-    absl::Nullable<std::shared_ptr<google::protobuf::MessageFactory>> message_factory =
+    ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> arena = nullptr,
+    ABSL_NULLABLE std::shared_ptr<google::protobuf::MessageFactory> message_factory =
         nullptr);
 
 }  // namespace cel::runtime_internal
diff --git a/eval/compiler/constant_folding_test.cc b/eval/compiler/constant_folding_test.cc
index b738f18e6..dcdc2ccd0 100644
--- a/eval/compiler/constant_folding_test.cc
+++ b/eval/compiler/constant_folding_test.cc
@@ -82,7 +82,7 @@ class UpdatedConstantFoldingTest : public testing::Test {
                   type_registry_.GetComposedTypeProvider()) {}
 
  protected:
-  absl::Nonnull<std::shared_ptr<RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<RuntimeEnv> env_;
   google::protobuf::Arena arena_;
   cel::FunctionRegistry& function_registry_;
   cel::TypeRegistry& type_registry_;
diff --git a/eval/compiler/flat_expr_builder.h b/eval/compiler/flat_expr_builder.h
index 5427b00ec..52cb769eb 100644
--- a/eval/compiler/flat_expr_builder.h
+++ b/eval/compiler/flat_expr_builder.h
@@ -44,8 +44,7 @@ namespace google::api::expr::runtime {
 class FlatExprBuilder {
  public:
   FlatExprBuilder(
-      absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>>
-          env,
+      ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env,
       const cel::RuntimeOptions& options, bool use_legacy_type_provider = false)
       : env_(std::move(env)),
         options_(options),
@@ -55,8 +54,7 @@ class FlatExprBuilder {
         use_legacy_type_provider_(use_legacy_type_provider) {}
 
   FlatExprBuilder(
-      absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>>
-          env,
+      ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env,
       const cel::FunctionRegistry& function_registry,
       const cel::TypeRegistry& type_registry,
       const cel::RuntimeOptions& options, bool use_legacy_type_provider = false)
@@ -98,7 +96,7 @@ class FlatExprBuilder {
  private:
   const cel::TypeProvider& GetTypeProvider() const;
 
-  const absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>>
+  const ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv>
       env_;
 
   cel::RuntimeOptions options_;
diff --git a/eval/compiler/flat_expr_builder_extensions.cc b/eval/compiler/flat_expr_builder_extensions.cc
index be31714ce..9a3443007 100644
--- a/eval/compiler/flat_expr_builder_extensions.cc
+++ b/eval/compiler/flat_expr_builder_extensions.cc
@@ -300,7 +300,7 @@ std::vector<ExecutionPath> ProgramBuilder::FlattenSubexpressions() {
   return out;
 }
 
-absl::Nullable<Subexpression*> ProgramBuilder::EnterSubexpression(
+Subexpression* ABSL_NULLABLE ProgramBuilder::EnterSubexpression(
     const cel::Expr* expr, size_t size_hint) {
   Subexpression* subexpr = MakeSubexpression(expr);
   if (subexpr == nullptr) {
@@ -320,7 +320,7 @@ absl::Nullable<Subexpression*> ProgramBuilder::EnterSubexpression(
   return subexpr;
 }
 
-absl::Nullable<Subexpression*> ProgramBuilder::ExitSubexpression(
+Subexpression* ABSL_NULLABLE ProgramBuilder::ExitSubexpression(
     const cel::Expr* expr) {
   ABSL_DCHECK(expr == current_->self_);
   ABSL_DCHECK(GetSubexpression(expr) == current_);
@@ -333,7 +333,7 @@ absl::Nullable<Subexpression*> ProgramBuilder::ExitSubexpression(
   return result;
 }
 
-absl::Nullable<Subexpression*> ProgramBuilder::GetSubexpression(
+Subexpression* ABSL_NULLABLE ProgramBuilder::GetSubexpression(
     const cel::Expr* expr) {
   auto it = subprogram_map_.find(expr);
   if (it == subprogram_map_.end()) {
diff --git a/eval/compiler/flat_expr_builder_extensions.h b/eval/compiler/flat_expr_builder_extensions.h
index cc224be0d..a83f6862d 100644
--- a/eval/compiler/flat_expr_builder_extensions.h
+++ b/eval/compiler/flat_expr_builder_extensions.h
@@ -86,7 +86,7 @@ class ProgramBuilder {
   class Subexpression {
    private:
     using Element = absl::variant<std::unique_ptr<ExpressionStep>,
-                                  absl::Nonnull<Subexpression*>>;
+                                  Subexpression* ABSL_NONNULL>;
 
     using TreePlan = std::vector<Element>;
     using FlattenedPlan = std::vector<std::unique_ptr<const ExpressionStep>>;
@@ -120,7 +120,7 @@ class ProgramBuilder {
       return true;
     }
 
-    void AddSubexpression(absl::Nonnull<Subexpression*> expr) {
+    void AddSubexpression(Subexpression* ABSL_NONNULL expr) {
       ABSL_DCHECK(absl::holds_alternative<TreePlan>(program_));
       ABSL_DCHECK(owner_ == expr->owner_);
       elements().push_back(expr);
@@ -187,7 +187,7 @@ class ProgramBuilder {
     // The expression is removed from the elements array.
     //
     // Returns nullptr if child is not an element of this subexpression.
-    absl::Nullable<Subexpression*> ExtractChild(Subexpression* child);
+    Subexpression* ABSL_NULLABLE ExtractChild(Subexpression* child);
 
     // Flatten the subexpression.
     //
@@ -217,7 +217,7 @@ class ProgramBuilder {
     absl::variant<TreePlan, FlattenedPlan, RecursiveProgram> program_;
 
     const cel::Expr* self_;
-    absl::Nullable<const cel::Expr*> parent_;
+    const cel::Expr* ABSL_NULLABLE parent_;
     ProgramBuilder* owner_;
   };
 
@@ -239,7 +239,7 @@ class ProgramBuilder {
   // added.
   //
   // May return null if the builder is not currently planning an expression.
-  absl::Nullable<Subexpression*> current() { return current_; }
+  Subexpression* ABSL_NULLABLE current() { return current_; }
 
   // Enter a subexpression context.
   //
@@ -250,26 +250,26 @@ class ProgramBuilder {
   //
   // May return nullptr if the expression is already indexed in the program
   // builder.
-  absl::Nullable<Subexpression*> EnterSubexpression(const cel::Expr* expr,
-                                                    size_t size_hint = 0);
+  Subexpression* ABSL_NULLABLE EnterSubexpression(const cel::Expr* expr,
+                                                  size_t size_hint = 0);
 
   // Exit a subexpression context.
   //
   // Sets insertion point to parent.
   //
   // Returns the new current() value or nullptr if called out of order.
-  absl::Nullable<Subexpression*> ExitSubexpression(const cel::Expr* expr);
+  Subexpression* ABSL_NULLABLE ExitSubexpression(const cel::Expr* expr);
 
   // Return the subexpression mapped to the given expression.
   //
   // Returns nullptr if the mapping doesn't exist either due to the
   // program being overwritten or not encountering the expression.
-  absl::Nullable<Subexpression*> GetSubexpression(const cel::Expr* expr);
+  Subexpression* ABSL_NULLABLE GetSubexpression(const cel::Expr* expr);
 
   // Return the extracted subexpression mapped to the given index.
   //
   // Returns nullptr if the mapping doesn't exist
-  absl::Nullable<Subexpression*> GetExtractedSubexpression(size_t index) {
+  Subexpression* ABSL_NULLABLE GetExtractedSubexpression(size_t index) {
     if (index >= extracted_subexpressions_.size()) {
       return nullptr;
     }
@@ -289,13 +289,13 @@ class ProgramBuilder {
 
  private:
   static std::vector<std::unique_ptr<const ExpressionStep>>
-  FlattenSubexpression(absl::Nonnull<Subexpression*> expr);
+  FlattenSubexpression(Subexpression* ABSL_NONNULL expr);
 
-  absl::Nullable<Subexpression*> MakeSubexpression(const cel::Expr* expr);
+  Subexpression* ABSL_NULLABLE MakeSubexpression(const cel::Expr* expr);
 
-  absl::Nullable<Subexpression*> root_;
-  std::vector<absl::Nonnull<Subexpression*>> extracted_subexpressions_;
-  absl::Nullable<Subexpression*> current_;
+  Subexpression* ABSL_NULLABLE root_;
+  std::vector<Subexpression* ABSL_NONNULL> extracted_subexpressions_;
+  Subexpression* ABSL_NULLABLE current_;
   SubprogramMap subprogram_map_;
 };
 
@@ -391,14 +391,14 @@ class PlannerContext {
     return issue_collector_;
   }
 
-  absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool() const {
+  const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool() const {
     return environment_->descriptor_pool.get();
   }
 
   // Returns `true` if an arena was explicitly provided during planning.
   bool HasExplicitArena() const { return explicit_arena_; }
 
-  absl::Nonnull<google::protobuf::Arena*> MutableArena() {
+  google::protobuf::Arena* ABSL_NONNULL MutableArena() {
     if (!explicit_arena_ && arena_ == nullptr) {
       arena_ = std::make_shared<google::protobuf::Arena>();
     }
@@ -410,7 +410,7 @@ class PlannerContext {
   // planning.
   bool HasExplicitMessageFactory() const { return message_factory_ != nullptr; }
 
-  absl::Nonnull<google::protobuf::MessageFactory*> MutableMessageFactory() {
+  google::protobuf::MessageFactory* ABSL_NONNULL MutableMessageFactory() {
     return HasExplicitMessageFactory() ? message_factory_.get()
                                        : environment_->MutableMessageFactory();
   }
diff --git a/eval/compiler/flat_expr_builder_extensions_test.cc b/eval/compiler/flat_expr_builder_extensions_test.cc
index a9d5df433..85c45b9ad 100644
--- a/eval/compiler/flat_expr_builder_extensions_test.cc
+++ b/eval/compiler/flat_expr_builder_extensions_test.cc
@@ -68,7 +68,7 @@ class PlannerContextTest : public testing::Test {
         issue_collector_(RuntimeIssue::Severity::kError) {}
 
  protected:
-  absl::Nonnull<std::shared_ptr<RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<RuntimeEnv> env_;
   cel::TypeRegistry& type_registry_;
   cel::FunctionRegistry& function_registry_;
   cel::RuntimeOptions options_;
diff --git a/eval/compiler/flat_expr_builder_test.cc b/eval/compiler/flat_expr_builder_test.cc
index 2a7ef1a8d..3277e1d92 100644
--- a/eval/compiler/flat_expr_builder_test.cc
+++ b/eval/compiler/flat_expr_builder_test.cc
@@ -2395,9 +2395,9 @@ struct ConstantFoldingTestCase {
 
 class UnknownFunctionImpl : public cel::Function {
   absl::StatusOr<Value> Invoke(absl::Span<const Value> args,
-                               absl::Nonnull<const google::protobuf::DescriptorPool*>,
-                               absl::Nonnull<google::protobuf::MessageFactory*>,
-                               absl::Nonnull<google::protobuf::Arena*>) const override {
+                               const google::protobuf::DescriptorPool* ABSL_NONNULL,
+                               google::protobuf::MessageFactory* ABSL_NONNULL,
+                               google::protobuf::Arena* ABSL_NONNULL) const override {
     return cel::UnknownValue();
   }
 };
diff --git a/eval/compiler/instrumentation_test.cc b/eval/compiler/instrumentation_test.cc
index c3caf39c1..3d4d3a396 100644
--- a/eval/compiler/instrumentation_test.cc
+++ b/eval/compiler/instrumentation_test.cc
@@ -65,7 +65,7 @@ class InstrumentationTest : public ::testing::Test {
   }
 
  protected:
-  absl::Nonnull<std::shared_ptr<RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<RuntimeEnv> env_;
   cel::RuntimeOptions options_;
   cel::FunctionRegistry& function_registry_;
   cel::TypeRegistry& type_registry_;
diff --git a/eval/compiler/regex_precompilation_optimization.cc b/eval/compiler/regex_precompilation_optimization.cc
index b7cff7986..32078fa62 100644
--- a/eval/compiler/regex_precompilation_optimization.cc
+++ b/eval/compiler/regex_precompilation_optimization.cc
@@ -174,7 +174,7 @@ class RegexPrecompilationOptimization : public ProgramOptimizer {
  private:
   absl::optional<std::string> GetConstantString(
       PlannerContext& context,
-      absl::Nullable<ProgramBuilder::Subexpression*> subexpression,
+      ProgramBuilder::Subexpression* ABSL_NULLABLE subexpression,
       const Expr& call_expr, const Expr& re_expr) const {
     if (re_expr.has_const_expr() && re_expr.const_expr().has_string_value()) {
       return re_expr.const_expr().string_value();
@@ -215,7 +215,7 @@ class RegexPrecompilationOptimization : public ProgramOptimizer {
 
   absl::Status RewritePlan(
       PlannerContext& context,
-      absl::Nonnull<ProgramBuilder::Subexpression*> subexpression,
+      ProgramBuilder::Subexpression* ABSL_NONNULL subexpression,
       const Expr& call, const Expr& subject,
       std::shared_ptr<const RE2> regex_program) {
     if (subexpression->IsRecursive()) {
@@ -227,7 +227,7 @@ class RegexPrecompilationOptimization : public ProgramOptimizer {
   }
 
   absl::Status RewriteRecursivePlan(
-      absl::Nonnull<ProgramBuilder::Subexpression*> subexpression,
+      ProgramBuilder::Subexpression* ABSL_NONNULL subexpression,
       const Expr& call, const Expr& subject,
       std::shared_ptr<const RE2> regex_program) {
     auto program = subexpression->ExtractRecursiveProgram();
diff --git a/eval/compiler/regex_precompilation_optimization_test.cc b/eval/compiler/regex_precompilation_optimization_test.cc
index 9e05b41d3..1ca026e0f 100644
--- a/eval/compiler/regex_precompilation_optimization_test.cc
+++ b/eval/compiler/regex_precompilation_optimization_test.cc
@@ -95,7 +95,7 @@ class RegexPrecompilationExtensionTest : public testing::TestWithParam<bool> {
     };
   }
 
-  absl::Nonnull<std::shared_ptr<RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<RuntimeEnv> env_;
   CelExpressionBuilderFlatImpl builder_;
   CelTypeRegistry& type_registry_;
   CelFunctionRegistry& function_registry_;
diff --git a/eval/eval/cel_expression_flat_impl.cc b/eval/eval/cel_expression_flat_impl.cc
index 5456a539d..0eba8d24d 100644
--- a/eval/eval/cel_expression_flat_impl.cc
+++ b/eval/eval/cel_expression_flat_impl.cc
@@ -50,9 +50,9 @@ using ::cel::runtime_internal::RuntimeEnv;
 EvaluationListener AdaptListener(const CelEvaluationListener& listener) {
   if (!listener) return nullptr;
   return [&](int64_t expr_id, const Value& value,
-             absl::Nonnull<const google::protobuf::DescriptorPool*>,
-             absl::Nonnull<google::protobuf::MessageFactory*>,
-             absl::Nonnull<google::protobuf::Arena*> arena) -> absl::Status {
+             const google::protobuf::DescriptorPool* ABSL_NONNULL,
+             google::protobuf::MessageFactory* ABSL_NONNULL,
+             google::protobuf::Arena* ABSL_NONNULL arena) -> absl::Status {
     if (value->Is<cel::OpaqueValue>()) {
       // Opaque types are used to implement some optimized operations.
       // These aren't representable as legacy values and shouldn't be
@@ -68,8 +68,8 @@ EvaluationListener AdaptListener(const CelEvaluationListener& listener) {
 
 CelExpressionFlatEvaluationState::CelExpressionFlatEvaluationState(
     google::protobuf::Arena* arena,
-    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
+    const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
     const FlatExpression& expression)
     : state_(expression.MakeEvaluatorState(descriptor_pool, message_factory,
                                            arena)) {}
@@ -105,7 +105,7 @@ absl::StatusOr<CelValue> CelExpressionFlatImpl::Evaluate(
 
 absl::StatusOr<std::unique_ptr<CelExpressionRecursiveImpl>>
 CelExpressionRecursiveImpl::Create(
-    absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env,
+    ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env,
     FlatExpression flat_expr) {
   if (flat_expr.path().empty() ||
       flat_expr.path().front()->GetNativeTypeId() !=
diff --git a/eval/eval/cel_expression_flat_impl.h b/eval/eval/cel_expression_flat_impl.h
index 1024b4757..fa355c97b 100644
--- a/eval/eval/cel_expression_flat_impl.h
+++ b/eval/eval/cel_expression_flat_impl.h
@@ -38,8 +38,8 @@ class CelExpressionFlatEvaluationState : public CelEvaluationState {
  public:
   CelExpressionFlatEvaluationState(
       google::protobuf::Arena* arena,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
       const FlatExpression& expr);
 
   google::protobuf::Arena* arena() { return state_.arena(); }
@@ -56,8 +56,7 @@ class CelExpressionFlatEvaluationState : public CelEvaluationState {
 class CelExpressionFlatImpl : public CelExpression {
  public:
   CelExpressionFlatImpl(
-      absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>>
-          env,
+      ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env,
       FlatExpression flat_expression)
       : env_(std::move(env)), flat_expression_(std::move(flat_expression)) {}
 
@@ -92,7 +91,7 @@ class CelExpressionFlatImpl : public CelExpression {
   const FlatExpression& flat_expression() const { return flat_expression_; }
 
  private:
-  absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env_;
   FlatExpression flat_expression_;
 };
 
@@ -115,8 +114,7 @@ class CelExpressionRecursiveImpl : public CelExpression {
 
  public:
   static absl::StatusOr<std::unique_ptr<CelExpressionRecursiveImpl>> Create(
-      absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>>
-          env,
+      ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env,
       FlatExpression flat_expression);
 
   // Move-only
@@ -159,8 +157,7 @@ class CelExpressionRecursiveImpl : public CelExpression {
 
  private:
   explicit CelExpressionRecursiveImpl(
-      absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>>
-          env,
+      ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env,
       FlatExpression flat_expression)
       : env_(std::move(env)),
         flat_expression_(std::move(flat_expression)),
@@ -168,7 +165,7 @@ class CelExpressionRecursiveImpl : public CelExpression {
                   flat_expression_.path()[0].get())
                   ->wrapped()) {}
 
-  absl::Nonnull<std::shared_ptr<const cel::runtime_internal::RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const cel::runtime_internal::RuntimeEnv> env_;
   FlatExpression flat_expression_;
   const DirectExpressionStep* root_;
 };
diff --git a/eval/eval/comprehension_slots.h b/eval/eval/comprehension_slots.h
index e5b39c3c3..34e086108 100644
--- a/eval/eval/comprehension_slots.h
+++ b/eval/eval/comprehension_slots.h
@@ -43,7 +43,7 @@ class ComprehensionSlot final {
     return value_;
   }
 
-  absl::Nonnull<cel::Value*> mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  cel::Value* ABSL_NONNULL mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_DCHECK(Has());
 
     return &value_;
@@ -55,7 +55,7 @@ class ComprehensionSlot final {
     return attribute_;
   }
 
-  absl::Nonnull<AttributeTrail*> mutable_attribute()
+  AttributeTrail* ABSL_NONNULL mutable_attribute()
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_DCHECK(Has());
 
@@ -118,7 +118,7 @@ class ComprehensionSlots final {
   ComprehensionSlots(ComprehensionSlots&&) = delete;
   ComprehensionSlots& operator=(ComprehensionSlots&&) = delete;
 
-  absl::Nonnull<Slot*> Get(size_t index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  Slot* ABSL_NONNULL Get(size_t index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     ABSL_DCHECK_LT(index, size());
 
     return &slots_[index];
diff --git a/eval/eval/const_value_step_test.cc b/eval/eval/const_value_step_test.cc
index 1e0e98168..777e48760 100644
--- a/eval/eval/const_value_step_test.cc
+++ b/eval/eval/const_value_step_test.cc
@@ -37,8 +37,8 @@ using ::testing::Eq;
 using ::testing::HasSubstr;
 
 absl::StatusOr<CelValue> RunConstantExpression(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
-    const Expr* expr, const Constant& const_expr, google::protobuf::Arena* arena) {
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env, const Expr* expr,
+    const Constant& const_expr, google::protobuf::Arena* arena) {
   CEL_ASSIGN_OR_RETURN(auto step,
                        CreateConstValueStep(const_expr, expr->id(), arena));
 
@@ -60,7 +60,7 @@ class ConstValueStepTest : public ::testing::Test {
   ConstValueStepTest() : env_(NewTestingRuntimeEnv()) {}
 
  protected:
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
diff --git a/eval/eval/container_access_step_test.cc b/eval/eval/container_access_step_test.cc
index 96c883a89..cf21ebe41 100644
--- a/eval/eval/container_access_step_test.cc
+++ b/eval/eval/container_access_step_test.cc
@@ -54,7 +54,7 @@ using ::testing::HasSubstr;
 using TestParamType = std::tuple<bool, bool, bool>;
 
 CelValue EvaluateAttributeHelper(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     google::protobuf::Arena* arena, CelValue container, CelValue key,
     bool use_recursive_impl, bool receiver_style, bool enable_unknown,
     const std::vector<CelAttributePattern>& patterns) {
@@ -119,7 +119,7 @@ class ContainerAccessStepTest : public ::testing::Test {
                                    receiver_style, enable_unknown,
                                    use_recursive_impl, patterns);
   }
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
@@ -154,7 +154,7 @@ class ContainerAccessStepUniformityTest
                                    receiver_style, enable_unknown,
                                    use_recursive_impl, patterns);
   }
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
diff --git a/eval/eval/create_list_step_test.cc b/eval/eval/create_list_step_test.cc
index 7077be48c..383f90e6d 100644
--- a/eval/eval/create_list_step_test.cc
+++ b/eval/eval/create_list_step_test.cc
@@ -70,7 +70,7 @@ using ::testing::UnorderedElementsAre;
 
 // Helper method. Creates simple pipeline containing Select step and runs it.
 absl::StatusOr<CelValue> RunExpression(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     const std::vector<int64_t>& values, google::protobuf::Arena* arena,
     bool enable_unknowns) {
   ExecutionPath path;
@@ -107,7 +107,7 @@ absl::StatusOr<CelValue> RunExpression(
 
 // Helper method. Creates simple pipeline containing Select step and runs it.
 absl::StatusOr<CelValue> RunExpressionWithCelValues(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     const std::vector<CelValue>& values, google::protobuf::Arena* arena,
     bool enable_unknowns) {
   ExecutionPath path;
@@ -150,7 +150,7 @@ class CreateListStepTest : public testing::TestWithParam<bool> {
   CreateListStepTest() : env_(NewTestingRuntimeEnv()) {}
 
  protected:
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
diff --git a/eval/eval/create_map_step_test.cc b/eval/eval/create_map_step_test.cc
index 978579ba9..91d052bf0 100644
--- a/eval/eval/create_map_step_test.cc
+++ b/eval/eval/create_map_step_test.cc
@@ -129,7 +129,7 @@ absl::StatusOr<ExecutionPath> CreateRecursiveProgram(
 // builds Map and runs it.
 // Equivalent to {key0: value0, ...}
 absl::StatusOr<CelValue> RunCreateMapExpression(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     const std::vector<std::pair<CelValue, CelValue>>& values,
     google::protobuf::Arena* arena, bool enable_unknowns, bool enable_recursive_program) {
   Activation activation;
@@ -167,7 +167,7 @@ class CreateMapStepTest
   }
 
  protected:
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
@@ -182,7 +182,7 @@ TEST_P(CreateMapStepTest, TestCreateEmptyMap) {
 
 // Test message creation if unknown argument is passed
 TEST(CreateMapStepTest, TestMapCreateWithUnknown) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   UnknownSet unknown_set;
   std::vector<std::pair<CelValue, CelValue>> entries;
@@ -200,7 +200,7 @@ TEST(CreateMapStepTest, TestMapCreateWithUnknown) {
 }
 
 TEST(CreateMapStepTest, TestMapCreateWithError) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   UnknownSet unknown_set;
   absl::Status error = absl::CancelledError();
@@ -217,7 +217,7 @@ TEST(CreateMapStepTest, TestMapCreateWithError) {
 }
 
 TEST(CreateMapStepTest, TestMapCreateWithErrorRecursiveProgram) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   UnknownSet unknown_set;
   absl::Status error = absl::CancelledError();
@@ -234,7 +234,7 @@ TEST(CreateMapStepTest, TestMapCreateWithErrorRecursiveProgram) {
 }
 
 TEST(CreateMapStepTest, TestMapCreateWithUnknownRecursiveProgram) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   UnknownSet unknown_set;
   std::vector<std::pair<CelValue, CelValue>> entries;
diff --git a/eval/eval/create_struct_step_test.cc b/eval/eval/create_struct_step_test.cc
index 758dff2bf..7024e6ab2 100644
--- a/eval/eval/create_struct_step_test.cc
+++ b/eval/eval/create_struct_step_test.cc
@@ -111,7 +111,7 @@ absl::StatusOr<ExecutionPath> MakeRecursivePath(absl::string_view field) {
 // Helper method. Creates simple pipeline containing CreateStruct step that
 // builds message and runs it.
 absl::StatusOr<CelValue> RunExpression(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     absl::string_view field, const CelValue& value, google::protobuf::Arena* arena,
     bool enable_unknowns, bool enable_recursive_planning) {
   google::protobuf::LinkMessageReflection<google::api::expr::runtime::TestMessage>();
@@ -146,7 +146,7 @@ absl::StatusOr<CelValue> RunExpression(
 }
 
 void RunExpressionAndGetMessage(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     absl::string_view field, const CelValue& value, google::protobuf::Arena* arena,
     TestMessage* test_msg, bool enable_unknowns,
     bool enable_recursive_planning) {
@@ -164,7 +164,7 @@ void RunExpressionAndGetMessage(
 }
 
 void RunExpressionAndGetMessage(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     absl::string_view field, std::vector<CelValue> values, google::protobuf::Arena* arena,
     TestMessage* test_msg, bool enable_unknowns,
     bool enable_recursive_planning) {
@@ -194,7 +194,7 @@ class CreateCreateStructStepTest
   bool enable_recursive_planning() { return std::get<1>(GetParam()); }
 
  protected:
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
@@ -246,7 +246,7 @@ TEST_P(CreateCreateStructStepTest, TestEmptyMessageCreation) {
 }
 
 TEST(CreateCreateStructStepTest, TestMessageCreateError) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   TestMessage test_msg;
   absl::Status error = absl::CancelledError();
@@ -260,7 +260,7 @@ TEST(CreateCreateStructStepTest, TestMessageCreateError) {
 }
 
 TEST(CreateCreateStructStepTest, TestMessageCreateErrorRecursive) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   TestMessage test_msg;
   absl::Status error = absl::CancelledError();
@@ -275,7 +275,7 @@ TEST(CreateCreateStructStepTest, TestMessageCreateErrorRecursive) {
 
 // Test message creation if unknown argument is passed
 TEST(CreateCreateStructStepTest, TestMessageCreateWithUnknown) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   TestMessage test_msg;
   UnknownSet unknown_set;
@@ -289,7 +289,7 @@ TEST(CreateCreateStructStepTest, TestMessageCreateWithUnknown) {
 
 // Test message creation if unknown argument is passed
 TEST(CreateCreateStructStepTest, TestMessageCreateWithUnknownRecursive) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   Arena arena;
   TestMessage test_msg;
   UnknownSet unknown_set;
diff --git a/eval/eval/equality_steps_test.cc b/eval/eval/equality_steps_test.cc
index 6aff09881..a355e864c 100644
--- a/eval/eval/equality_steps_test.cc
+++ b/eval/eval/equality_steps_test.cc
@@ -205,7 +205,7 @@ struct EqualsTestCase {
 
 class EqualsTest : public ::testing::TestWithParam<EqualsTestCase> {};
 
-Value MakeValue(InputType type, absl::Nonnull<google::protobuf::Arena*> arena) {
+Value MakeValue(InputType type, google::protobuf::Arena* ABSL_NONNULL arena) {
   switch (type) {
     case InputType::kInt1:
       return IntValue(1);
diff --git a/eval/eval/evaluator_core.cc b/eval/eval/evaluator_core.cc
index f6ba4b020..8c9695c27 100644
--- a/eval/eval/evaluator_core.cc
+++ b/eval/eval/evaluator_core.cc
@@ -155,9 +155,9 @@ absl::StatusOr<cel::Value> ExecutionFrame::Evaluate(
 }
 
 FlatExpressionEvaluatorState FlatExpression::MakeEvaluatorState(
-    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-    absl::Nonnull<google::protobuf::Arena*> arena) const {
+    const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+    google::protobuf::Arena* ABSL_NONNULL arena) const {
   return FlatExpressionEvaluatorState(path_.size(), comprehension_slots_size_,
                                       type_provider_, descriptor_pool,
                                       message_factory, arena);
diff --git a/eval/eval/evaluator_core.h b/eval/eval/evaluator_core.h
index 20f5e2eaf..f81c1c318 100644
--- a/eval/eval/evaluator_core.h
+++ b/eval/eval/evaluator_core.h
@@ -103,9 +103,9 @@ class FlatExpressionEvaluatorState {
   FlatExpressionEvaluatorState(
       size_t value_stack_size, size_t comprehension_slot_count,
       const cel::TypeProvider& type_provider,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena)
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena)
       : value_stack_(value_stack_size),
         // We currently use comprehension_slot_count because it is less of an
         // over estimate than value_stack_size. In future we should just
@@ -129,24 +129,24 @@ class FlatExpressionEvaluatorState {
 
   const cel::TypeProvider& type_provider() { return type_provider_; }
 
-  absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool() {
+  const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool() {
     return descriptor_pool_;
   }
 
-  absl::Nonnull<google::protobuf::MessageFactory*> message_factory() {
+  google::protobuf::MessageFactory* ABSL_NONNULL message_factory() {
     return message_factory_;
   }
 
-  absl::Nonnull<google::protobuf::Arena*> arena() { return arena_; }
+  google::protobuf::Arena* ABSL_NONNULL arena() { return arena_; }
 
  private:
   EvaluatorStack value_stack_;
   cel::runtime_internal::IteratorStack iterator_stack_;
   ComprehensionSlots comprehension_slots_;
   const cel::TypeProvider& type_provider_;
-  absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool_;
-  absl::Nonnull<google::protobuf::MessageFactory*> message_factory_;
-  absl::Nonnull<google::protobuf::Arena*> arena_;
+  const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool_;
+  google::protobuf::MessageFactory* ABSL_NONNULL message_factory_;
+  google::protobuf::Arena* ABSL_NONNULL arena_;
 };
 
 // Context needed for evaluation. This is sufficient for supporting
@@ -155,13 +155,12 @@ class FlatExpressionEvaluatorState {
 class ExecutionFrameBase {
  public:
   // Overload for test usages.
-  ExecutionFrameBase(
-      const cel::ActivationInterface& activation,
-      const cel::RuntimeOptions& options,
-      const cel::TypeProvider& type_provider,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena)
+  ExecutionFrameBase(const cel::ActivationInterface& activation,
+                     const cel::RuntimeOptions& options,
+                     const cel::TypeProvider& type_provider,
+                     const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+                     google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+                     google::protobuf::Arena* ABSL_NONNULL arena)
       : activation_(&activation),
         callback_(),
         options_(&options),
@@ -175,13 +174,14 @@ class ExecutionFrameBase {
         max_iterations_(options.comprehension_max_iterations),
         iterations_(0) {}
 
-  ExecutionFrameBase(
-      const cel::ActivationInterface& activation, EvaluationListener callback,
-      const cel::RuntimeOptions& options,
-      const cel::TypeProvider& type_provider,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena, ComprehensionSlots& slots)
+  ExecutionFrameBase(const cel::ActivationInterface& activation,
+                     EvaluationListener callback,
+                     const cel::RuntimeOptions& options,
+                     const cel::TypeProvider& type_provider,
+                     const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+                     google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+                     google::protobuf::Arena* ABSL_NONNULL arena,
+                     ComprehensionSlots& slots)
       : activation_(&activation),
         callback_(std::move(callback)),
         options_(&options),
@@ -203,15 +203,15 @@ class ExecutionFrameBase {
 
   const cel::TypeProvider& type_provider() { return type_provider_; }
 
-  absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool() const {
+  const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool() const {
     return descriptor_pool_;
   }
 
-  absl::Nonnull<google::protobuf::MessageFactory*> message_factory() const {
+  google::protobuf::MessageFactory* ABSL_NONNULL message_factory() const {
     return message_factory_;
   }
 
-  absl::Nonnull<google::protobuf::Arena*> arena() const { return arena_; }
+  google::protobuf::Arena* ABSL_NONNULL arena() const { return arena_; }
 
   const AttributeUtility& attribute_utility() const {
     return attribute_utility_;
@@ -254,15 +254,15 @@ class ExecutionFrameBase {
   }
 
  protected:
-  absl::Nonnull<const cel::ActivationInterface*> activation_;
+  const cel::ActivationInterface* ABSL_NONNULL activation_;
   EvaluationListener callback_;
-  absl::Nonnull<const cel::RuntimeOptions*> options_;
+  const cel::RuntimeOptions* ABSL_NONNULL options_;
   const cel::TypeProvider& type_provider_;
-  absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool_;
-  absl::Nonnull<google::protobuf::MessageFactory*> message_factory_;
-  absl::Nonnull<google::protobuf::Arena*> arena_;
+  const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool_;
+  google::protobuf::MessageFactory* ABSL_NONNULL message_factory_;
+  google::protobuf::Arena* ABSL_NONNULL arena_;
   AttributeUtility attribute_utility_;
-  absl::Nonnull<ComprehensionSlots*> slots_;
+  ComprehensionSlots* ABSL_NONNULL slots_;
   const int max_iterations_;
   int iterations_;
 };
@@ -413,7 +413,7 @@ class FlatExpression {
   FlatExpression(ExecutionPath path, size_t comprehension_slots_size,
                  const cel::TypeProvider& type_provider,
                  const cel::RuntimeOptions& options,
-                 absl::Nullable<std::shared_ptr<google::protobuf::Arena>> arena = nullptr)
+                 ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> arena = nullptr)
       : path_(std::move(path)),
         subexpressions_({path_}),
         comprehension_slots_size_(comprehension_slots_size),
@@ -426,7 +426,7 @@ class FlatExpression {
                  size_t comprehension_slots_size,
                  const cel::TypeProvider& type_provider,
                  const cel::RuntimeOptions& options,
-                 absl::Nullable<std::shared_ptr<google::protobuf::Arena>> arena = nullptr)
+                 ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> arena = nullptr)
       : path_(std::move(path)),
         subexpressions_(std::move(subexpressions)),
         comprehension_slots_size_(comprehension_slots_size),
@@ -441,9 +441,9 @@ class FlatExpression {
   // Create new evaluator state instance with the configured options and type
   // provider.
   FlatExpressionEvaluatorState MakeEvaluatorState(
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena) const;
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena) const;
 
   // Evaluate the expression.
   //
@@ -477,7 +477,7 @@ class FlatExpression {
   cel::RuntimeOptions options_;
   // Arena used during planning phase, may hold constant values so should be
   // kept alive.
-  absl::Nullable<std::shared_ptr<google::protobuf::Arena>> arena_;
+  ABSL_NULLABLE std::shared_ptr<google::protobuf::Arena> arena_;
 };
 
 }  // namespace google::api::expr::runtime
diff --git a/eval/eval/evaluator_stack.h b/eval/eval/evaluator_stack.h
index e85d72e50..dcde7c3be 100644
--- a/eval/eval/evaluator_stack.h
+++ b/eval/eval/evaluator_stack.h
@@ -313,12 +313,12 @@ class EvaluatorStack {
   // Preallocate stack.
   void Reserve(size_t size);
 
-  absl::NullabilityUnknown<cel::Value*> values_ = nullptr;
-  absl::NullabilityUnknown<cel::Value*> values_begin_ = nullptr;
-  absl::NullabilityUnknown<AttributeTrail*> attributes_ = nullptr;
-  absl::NullabilityUnknown<AttributeTrail*> attributes_begin_ = nullptr;
-  absl::NullabilityUnknown<cel::Value*> values_end_ = nullptr;
-  absl::NullabilityUnknown<void*> data_ = nullptr;
+  cel::Value* ABSL_NULLABILITY_UNKNOWN values_ = nullptr;
+  cel::Value* ABSL_NULLABILITY_UNKNOWN values_begin_ = nullptr;
+  AttributeTrail* ABSL_NULLABILITY_UNKNOWN attributes_ = nullptr;
+  AttributeTrail* ABSL_NULLABILITY_UNKNOWN attributes_begin_ = nullptr;
+  cel::Value* ABSL_NULLABILITY_UNKNOWN values_end_ = nullptr;
+  void* ABSL_NULLABILITY_UNKNOWN data_ = nullptr;
   size_t max_size_ = 0;
 };
 
diff --git a/eval/eval/ident_step.cc b/eval/eval/ident_step.cc
index d3b911510..ec28ad9a4 100644
--- a/eval/eval/ident_step.cc
+++ b/eval/eval/ident_step.cc
@@ -84,7 +84,7 @@ absl::Status IdentStep::Evaluate(ExecutionFrame* frame) const {
   return absl::OkStatus();
 }
 
-absl::StatusOr<absl::Nonnull<ComprehensionSlots::Slot*>> LookupSlot(
+absl::StatusOr<ComprehensionSlots::Slot* ABSL_NONNULL> LookupSlot(
     absl::string_view name, size_t slot_index, ExecutionFrameBase& frame) {
   ComprehensionSlots::Slot* slot = frame.comprehension_slots().Get(slot_index);
   if (!slot->Has()) {
diff --git a/eval/eval/lazy_init_step.cc b/eval/eval/lazy_init_step.cc
index c4e5b1355..ecc41b3f9 100644
--- a/eval/eval/lazy_init_step.cc
+++ b/eval/eval/lazy_init_step.cc
@@ -81,7 +81,7 @@ class DirectLazyInitStep final : public DirectExpressionStep {
 
  private:
   const size_t slot_index_;
-  const absl::Nonnull<const DirectExpressionStep*> subexpression_;
+  const DirectExpressionStep* ABSL_NONNULL const subexpression_;
 };
 
 class BindStep : public DirectExpressionStep {
@@ -204,7 +204,7 @@ std::unique_ptr<DirectExpressionStep> CreateDirectBlockStep(
 }
 
 std::unique_ptr<DirectExpressionStep> CreateDirectLazyInitStep(
-    size_t slot_index, absl::Nonnull<const DirectExpressionStep*> subexpression,
+    size_t slot_index, const DirectExpressionStep* ABSL_NONNULL subexpression,
     int64_t expr_id) {
   return std::make_unique<DirectLazyInitStep>(slot_index, subexpression,
                                               expr_id);
diff --git a/eval/eval/lazy_init_step.h b/eval/eval/lazy_init_step.h
index e902dd27d..787bbacda 100644
--- a/eval/eval/lazy_init_step.h
+++ b/eval/eval/lazy_init_step.h
@@ -60,7 +60,7 @@ std::unique_ptr<DirectExpressionStep> CreateDirectBlockStep(
 // Creates a direct step representing accessing a lazily evaluated alias from
 // a bind or block.
 std::unique_ptr<DirectExpressionStep> CreateDirectLazyInitStep(
-    size_t slot_index, absl::Nonnull<const DirectExpressionStep*> subexpression,
+    size_t slot_index, const DirectExpressionStep* ABSL_NONNULL subexpression,
     int64_t expr_id);
 
 // Creates a step representing accessing a lazily evaluated alias from
diff --git a/eval/eval/logic_step_test.cc b/eval/eval/logic_step_test.cc
index a27e7eb56..ac32013e2 100644
--- a/eval/eval/logic_step_test.cc
+++ b/eval/eval/logic_step_test.cc
@@ -104,7 +104,7 @@ class LogicStepTest : public testing::TestWithParam<bool> {
   }
 
  private:
-  absl::Nonnull<std::shared_ptr<class RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<class RuntimeEnv> env_;
   Arena arena_;
 };
 
diff --git a/eval/eval/select_step.cc b/eval/eval/select_step.cc
index 99f0da90d..cb6bc3746 100644
--- a/eval/eval/select_step.cc
+++ b/eval/eval/select_step.cc
@@ -75,11 +75,11 @@ absl::optional<Value> CheckForMarkedAttributes(const AttributeTrail& trail,
   return absl::nullopt;
 }
 
-void TestOnlySelect(
-    const StructValue& msg, const std::string& field,
-    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-    absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) {
+void TestOnlySelect(const StructValue& msg, const std::string& field,
+                    const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+                    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+                    google::protobuf::Arena* ABSL_NONNULL arena,
+                    Value* ABSL_NONNULL result) {
   absl::StatusOr<bool> has_field = msg.HasFieldByName(field);
 
   if (!has_field.ok()) {
@@ -89,11 +89,11 @@ void TestOnlySelect(
   *result = BoolValue{*has_field};
 }
 
-void TestOnlySelect(
-    const MapValue& map, const StringValue& field_name,
-    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-    absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) {
+void TestOnlySelect(const MapValue& map, const StringValue& field_name,
+                    const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+                    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+                    google::protobuf::Arena* ABSL_NONNULL arena,
+                    Value* ABSL_NONNULL result) {
   // Field presence only supports string keys containing valid identifier
   // characters.
   absl::Status presence =
diff --git a/eval/eval/select_step_test.cc b/eval/eval/select_step_test.cc
index 86e0fb51e..ca68ead61 100644
--- a/eval/eval/select_step_test.cc
+++ b/eval/eval/select_step_test.cc
@@ -190,7 +190,7 @@ class SelectStepTest : public testing::Test {
   }
 
  protected:
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   google::protobuf::Arena arena_;
 };
 
diff --git a/eval/eval/shadowable_value_step_test.cc b/eval/eval/shadowable_value_step_test.cc
index 10ad88e70..70df76133 100644
--- a/eval/eval/shadowable_value_step_test.cc
+++ b/eval/eval/shadowable_value_step_test.cc
@@ -31,7 +31,7 @@ using ::google::protobuf::Arena;
 using ::testing::Eq;
 
 absl::StatusOr<CelValue> RunShadowableExpression(
-    const absl::Nonnull<std::shared_ptr<const RuntimeEnv>>& env,
+    const ABSL_NONNULL std::shared_ptr<const RuntimeEnv>& env,
     std::string identifier, cel::Value value, const Activation& activation,
     Arena* arena) {
   CEL_ASSIGN_OR_RETURN(
@@ -48,7 +48,7 @@ absl::StatusOr<CelValue> RunShadowableExpression(
 }
 
 TEST(ShadowableValueStepTest, TestEvaluateNoShadowing) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   std::string type_name = "google.api.expr.runtime.TestMessage";
 
   Activation activation;
@@ -65,7 +65,7 @@ TEST(ShadowableValueStepTest, TestEvaluateNoShadowing) {
 }
 
 TEST(ShadowableValueStepTest, TestEvaluateShadowedIdentifier) {
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env = NewTestingRuntimeEnv();
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env = NewTestingRuntimeEnv();
   std::string type_name = "int";
   auto shadow_value = CelValue::CreateInt64(1024L);
 
diff --git a/eval/eval/ternary_step_test.cc b/eval/eval/ternary_step_test.cc
index 6bda49c33..7221a860b 100644
--- a/eval/eval/ternary_step_test.cc
+++ b/eval/eval/ternary_step_test.cc
@@ -115,7 +115,7 @@ class LogicStepTest : public testing::TestWithParam<bool> {
   }
 
  private:
-  absl::Nonnull<std::shared_ptr<const RuntimeEnv>> env_;
+  ABSL_NONNULL std::shared_ptr<const RuntimeEnv> env_;
   Arena arena_;
 };
 
@@ -353,7 +353,7 @@ TEST_P(TernaryStepDirectTest, Shortcircuiting) {
     }
 
    private:
-    absl::Nonnull<bool*> was_called_;
+    bool* ABSL_NONNULL was_called_;
   };
 
   bool lhs_was_called = false;
diff --git a/eval/internal/adapter_activation_impl.cc b/eval/internal/adapter_activation_impl.cc
index bc1658aca..de0bb9faf 100644
--- a/eval/internal/adapter_activation_impl.cc
+++ b/eval/internal/adapter_activation_impl.cc
@@ -35,9 +35,9 @@ using ::google::api::expr::runtime::CelFunction;
 
 absl::StatusOr<bool> AdapterActivationImpl::FindVariable(
     absl::string_view name,
-    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-    absl::Nonnull<google::protobuf::Arena*> arena, absl::Nonnull<Value*> result) const {
+    const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+    google::protobuf::Arena* ABSL_NONNULL arena, Value* ABSL_NONNULL result) const {
   // This implementation should only be used during interop, when we can
   // always assume the memory manager is backed by a protobuf arena.
 
diff --git a/eval/internal/adapter_activation_impl.h b/eval/internal/adapter_activation_impl.h
index 5ef29a261..eb0c903ae 100644
--- a/eval/internal/adapter_activation_impl.h
+++ b/eval/internal/adapter_activation_impl.h
@@ -43,10 +43,10 @@ class AdapterActivationImpl : public ActivationInterface {
 
   absl::StatusOr<bool> FindVariable(
       absl::string_view name,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena,
-      absl::Nonnull<Value*> result) const override;
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena,
+      Value* ABSL_NONNULL result) const override;
 
   std::vector<FunctionOverloadReference> FindFunctionOverloads(
       absl::string_view name) const override;
diff --git a/eval/public/cel_expr_builder_factory.cc b/eval/public/cel_expr_builder_factory.cc
index 6bec1167c..8d323152d 100644
--- a/eval/public/cel_expr_builder_factory.cc
+++ b/eval/public/cel_expr_builder_factory.cc
@@ -66,8 +66,7 @@ std::unique_ptr<CelExpressionBuilder> CreateCelExpressionBuilder(
   }
 
   cel::RuntimeOptions runtime_options = ConvertToRuntimeOptions(options);
-  absl::Nullable<std::shared_ptr<google::protobuf::MessageFactory>>
-      shared_message_factory;
+  ABSL_NULLABLE std::shared_ptr<google::protobuf::MessageFactory> shared_message_factory;
   if (message_factory != nullptr) {
     shared_message_factory = std::shared_ptr<google::protobuf::MessageFactory>(
         message_factory,
diff --git a/eval/public/cel_function.cc b/eval/public/cel_function.cc
index be34db7f9..17c8e6edd 100644
--- a/eval/public/cel_function.cc
+++ b/eval/public/cel_function.cc
@@ -55,9 +55,9 @@ bool CelFunction::MatchArguments(absl::Span<const cel::Value> arguments) const {
 
 absl::StatusOr<Value> CelFunction::Invoke(
     absl::Span<const cel::Value> arguments,
-    absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-    absl::Nonnull<google::protobuf::Arena*> arena) const {
+    const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+    google::protobuf::Arena* ABSL_NONNULL arena) const {
   std::vector<CelValue> legacy_args;
   legacy_args.reserve(arguments.size());
 
diff --git a/eval/public/cel_function.h b/eval/public/cel_function.h
index 204b4dc7b..f30c06d8a 100644
--- a/eval/public/cel_function.h
+++ b/eval/public/cel_function.h
@@ -67,9 +67,9 @@ class CelFunction : public ::cel::Function {
   // Implements cel::Function.
   absl::StatusOr<cel::Value> Invoke(
       absl::Span<const cel::Value> arguments,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena) const override;
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena) const override;
 
   // CelFunction descriptor
   const CelFunctionDescriptor& descriptor() const { return descriptor_; }
diff --git a/eval/public/cel_type_registry.h b/eval/public/cel_type_registry.h
index 097d143a9..89651342e 100644
--- a/eval/public/cel_type_registry.h
+++ b/eval/public/cel_type_registry.h
@@ -59,8 +59,8 @@ class CelTypeRegistry {
       : CelTypeRegistry(google::protobuf::DescriptorPool::generated_pool(),
                         google::protobuf::MessageFactory::generated_factory()) {}
 
-  CelTypeRegistry(absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-                  absl::Nullable<google::protobuf::MessageFactory*> message_factory)
+  CelTypeRegistry(const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+                  google::protobuf::MessageFactory* ABSL_NULLABLE message_factory)
       : modern_type_registry_(descriptor_pool, message_factory) {}
 
   ~CelTypeRegistry() = default;
diff --git a/eval/public/structs/cel_proto_wrap_util.cc b/eval/public/structs/cel_proto_wrap_util.cc
index a039cc330..ae45a66d1 100644
--- a/eval/public/structs/cel_proto_wrap_util.cc
+++ b/eval/public/structs/cel_proto_wrap_util.cc
@@ -190,7 +190,7 @@ class DynamicMap : public CelMap {
 // Adapter for usage with CEL_RETURN_IF_ERROR and CEL_ASSIGN_OR_RETURN.
 class ReturnCelValueError {
  public:
-  explicit ReturnCelValueError(absl::Nonnull<google::protobuf::Arena*> arena)
+  explicit ReturnCelValueError(google::protobuf::Arena* ABSL_NONNULL arena)
       : arena_(arena) {}
 
   CelValue operator()(const absl::Status& status) const {
@@ -200,7 +200,7 @@ class ReturnCelValueError {
   }
 
  private:
-  absl::Nonnull<google::protobuf::Arena*> arena_;
+  google::protobuf::Arena* ABSL_NONNULL arena_;
 };
 
 struct IgnoreErrorAndReturnNullptr {
diff --git a/eval/public/structs/legacy_type_info_apis.h b/eval/public/structs/legacy_type_info_apis.h
index d3de418ce..15a96a81a 100644
--- a/eval/public/structs/legacy_type_info_apis.h
+++ b/eval/public/structs/legacy_type_info_apis.h
@@ -61,7 +61,7 @@ class LegacyTypeInfoApis {
   virtual absl::string_view GetTypename(
       const MessageWrapper& wrapped_message) const = 0;
 
-  virtual absl::Nullable<const google::protobuf::Descriptor*> GetDescriptor(
+  virtual const google::protobuf::Descriptor* ABSL_NULLABLE GetDescriptor(
       const MessageWrapper& wrapped_message) const {
     return nullptr;
   }
diff --git a/eval/public/structs/legacy_type_provider.cc b/eval/public/structs/legacy_type_provider.cc
index 4df74cbc1..16ead9709 100644
--- a/eval/public/structs/legacy_type_provider.cc
+++ b/eval/public/structs/legacy_type_provider.cc
@@ -152,11 +152,11 @@ class LegacyValueBuilder final : public cel::ValueBuilder {
 
 }  // namespace
 
-absl::StatusOr<absl::Nullable<cel::ValueBuilderPtr>>
+absl::StatusOr<ABSL_NULLABLE cel::ValueBuilderPtr>
 LegacyTypeProvider::NewValueBuilder(
     absl::string_view name,
-    absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-    absl::Nonnull<google::protobuf::Arena*> arena) const {
+    google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+    google::protobuf::Arena* ABSL_NONNULL arena) const {
   if (auto type_adapter = ProvideLegacyType(name); type_adapter.has_value()) {
     const auto* mutation_apis = type_adapter->mutation_apis();
     if (mutation_apis == nullptr) {
diff --git a/eval/public/structs/legacy_type_provider.h b/eval/public/structs/legacy_type_provider.h
index 380bdebda..97ef9e40a 100644
--- a/eval/public/structs/legacy_type_provider.h
+++ b/eval/public/structs/legacy_type_provider.h
@@ -60,10 +60,10 @@ class LegacyTypeProvider : public cel::TypeReflector {
     return absl::nullopt;
   }
 
-  absl::StatusOr<absl::Nullable<cel::ValueBuilderPtr>> NewValueBuilder(
+  absl::StatusOr<ABSL_NULLABLE cel::ValueBuilderPtr> NewValueBuilder(
       absl::string_view name,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena) const final;
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena) const final;
 
  protected:
   absl::StatusOr<absl::optional<cel::Type>> FindTypeImpl(
diff --git a/eval/public/structs/proto_message_type_adapter.h b/eval/public/structs/proto_message_type_adapter.h
index 4e2025a8d..991e09d00 100644
--- a/eval/public/structs/proto_message_type_adapter.h
+++ b/eval/public/structs/proto_message_type_adapter.h
@@ -51,7 +51,7 @@ class ProtoMessageTypeAdapter : public LegacyTypeInfoApis,
   absl::string_view GetTypename(
       const MessageWrapper& wrapped_message) const override;
 
-  absl::Nullable<const google::protobuf::Descriptor*> GetDescriptor(
+  const google::protobuf::Descriptor* ABSL_NULLABLE GetDescriptor(
       const MessageWrapper& wrapped_message) const override {
     return descriptor_;
   }
diff --git a/eval/tests/modern_benchmark_test.cc b/eval/tests/modern_benchmark_test.cc
index 46afe6520..d2592dbf7 100644
--- a/eval/tests/modern_benchmark_test.cc
+++ b/eval/tests/modern_benchmark_test.cc
@@ -108,7 +108,7 @@ std::unique_ptr<const cel::Runtime> StandardRuntimeOrDie(
 }
 
 template <typename T>
-Value WrapMessageOrDie(const T& message, absl::Nonnull<google::protobuf::Arena*> arena) {
+Value WrapMessageOrDie(const T& message, google::protobuf::Arena* ABSL_NONNULL arena) {
   auto value = extensions::ProtoMessageToValue(
       message, internal::GetTestingDescriptorPool(),
       internal::GetTestingMessageFactory(), arena);
@@ -155,9 +155,9 @@ static void BM_Eval(benchmark::State& state) {
 BENCHMARK(BM_Eval)->Range(1, 10000);
 
 absl::Status EmptyCallback(int64_t expr_id, const Value&,
-                           absl::Nonnull<const google::protobuf::DescriptorPool*>,
-                           absl::Nonnull<google::protobuf::MessageFactory*>,
-                           absl::Nonnull<google::protobuf::Arena*>) {
+                           const google::protobuf::DescriptorPool* ABSL_NONNULL,
+                           google::protobuf::MessageFactory* ABSL_NONNULL,
+                           google::protobuf::Arena* ABSL_NONNULL) {
   return absl::OkStatus();
 }
 
@@ -371,27 +371,27 @@ class RequestMapImpl : public CustomMapValueInterface {
   size_t Size() const override { return 3; }
 
   absl::Status ListKeys(
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena,
-      absl::Nonnull<ListValue*> result) const override {
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena,
+      ListValue* ABSL_NONNULL result) const override {
     return absl::UnimplementedError("Unsupported");
   }
 
-  absl::StatusOr<absl::Nonnull<ValueIteratorPtr>> NewIterator() const override {
+  absl::StatusOr<ABSL_NONNULL ValueIteratorPtr> NewIterator() const override {
     return absl::UnimplementedError("Unsupported");
   }
 
   std::string DebugString() const override { return "RequestMapImpl"; }
 
   absl::Status ConvertToJsonObject(
-      absl::Nonnull<const google::protobuf::DescriptorPool*>,
-      absl::Nonnull<google::protobuf::MessageFactory*>,
-      absl::Nonnull<google::protobuf::Message*>) const override {
+      const google::protobuf::DescriptorPool* ABSL_NONNULL,
+      google::protobuf::MessageFactory* ABSL_NONNULL,
+      google::protobuf::Message* ABSL_NONNULL) const override {
     return absl::UnimplementedError("Unsupported");
   }
 
-  CustomMapValue Clone(absl::Nonnull<google::protobuf::Arena*> arena) const override {
+  CustomMapValue Clone(google::protobuf::Arena* ABSL_NONNULL arena) const override {
     return CustomMapValue(google::protobuf::Arena::Create<RequestMapImpl>(arena), arena);
   }
 
@@ -399,10 +399,10 @@ class RequestMapImpl : public CustomMapValueInterface {
   // Called by `Find` after performing various argument checks.
   absl::StatusOr<bool> Find(
       const Value& key,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena,
-      absl::Nonnull<Value*> result) const override {
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena,
+      Value* ABSL_NONNULL result) const override {
     auto string_value = As<StringValue>(key);
     if (!string_value) {
       return false;
@@ -422,9 +422,9 @@ class RequestMapImpl : public CustomMapValueInterface {
   // Called by `Has` after performing various argument checks.
   absl::StatusOr<bool> Has(
       const Value& key,
-      absl::Nonnull<const google::protobuf::DescriptorPool*> descriptor_pool,
-      absl::Nonnull<google::protobuf::MessageFactory*> message_factory,
-      absl::Nonnull<google::protobuf::Arena*> arena) const override {
+      const google::protobuf::DescriptorPool* ABSL_NONNULL descriptor_pool,
+      google::protobuf::MessageFactory* ABSL_NONNULL message_factory,
+      google::protobuf::Arena* ABSL_NONNULL arena) const override {
     return absl::UnimplementedError("Unsupported.");
   }