diff --git a/Firestore/core/src/api/expressions.h b/Firestore/core/src/api/expressions.h
index 3cd5d5cfc68..c90dcce2eb7 100644
--- a/Firestore/core/src/api/expressions.h
+++ b/Firestore/core/src/api/expressions.h
@@ -43,7 +43,7 @@ class Expr {
 
 class Selectable : public Expr {
  public:
-  virtual ~Selectable() override = default;
+  ~Selectable() override = default;
   virtual const std::string& alias() const = 0;
 };
 
diff --git a/Firestore/core/src/api/pipeline_result.h b/Firestore/core/src/api/pipeline_result.h
index c8db550178a..093500dcd1e 100644
--- a/Firestore/core/src/api/pipeline_result.h
+++ b/Firestore/core/src/api/pipeline_result.h
@@ -51,7 +51,7 @@ class PipelineResult {
 
   PipelineResult() = default;
 
-  PipelineResult(model::Document document)
+  explicit PipelineResult(model::Document document)
       : internal_key_{document->key()},
         value_{document->shared_data()},
         // TODO(pipeline): add create time support
diff --git a/Firestore/core/src/api/query_snapshot.cc b/Firestore/core/src/api/query_snapshot.cc
index 4e94d6f11e3..e2a10034a27 100644
--- a/Firestore/core/src/api/query_snapshot.cc
+++ b/Firestore/core/src/api/query_snapshot.cc
@@ -17,6 +17,7 @@
 #include "Firestore/core/src/api/query_snapshot.h"
 
 #include <utility>
+#include <vector>
 
 #include "Firestore/core/src/api/document_change.h"
 #include "Firestore/core/src/api/document_snapshot.h"
diff --git a/Firestore/core/src/api/query_snapshot.h b/Firestore/core/src/api/query_snapshot.h
index 58d7c65bf03..5a48ab37793 100644
--- a/Firestore/core/src/api/query_snapshot.h
+++ b/Firestore/core/src/api/query_snapshot.h
@@ -20,6 +20,7 @@
 #include <functional>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "Firestore/core/src/api/api_fwd.h"
 #include "Firestore/core/src/api/document_change.h"
diff --git a/Firestore/core/src/api/realtime_pipeline_snapshot.h b/Firestore/core/src/api/realtime_pipeline_snapshot.h
index 0b326376287..6a2fd958f32 100644
--- a/Firestore/core/src/api/realtime_pipeline_snapshot.h
+++ b/Firestore/core/src/api/realtime_pipeline_snapshot.h
@@ -68,4 +68,4 @@ class RealtimePipelineSnapshot {
 }  // namespace firestore
 }  // namespace firebase
 
-#endif  // FIRESTORE_CORE_SRC_API_REAL_TIME_PIPELINE_SNAPSHOT_H_
+#endif  // FIRESTORE_CORE_SRC_API_REALTIME_PIPELINE_SNAPSHOT_H_
diff --git a/Firestore/core/src/core/expressions_eval.cc b/Firestore/core/src/core/expressions_eval.cc
index 4ae269cec62..8c2cd3b12ee 100644
--- a/Firestore/core/src/core/expressions_eval.cc
+++ b/Firestore/core/src/core/expressions_eval.cc
@@ -447,6 +447,7 @@ EvaluateResult CoreEq::CompareToResult(const EvaluateResult& left,
     case model::StrictEqualsResult::kNull:
       return EvaluateResult::NewNull();
   }
+  HARD_FAIL("Unhandled case in switch statement");
 }
 
 EvaluateResult CoreNeq::CompareToResult(const EvaluateResult& left,
@@ -469,6 +470,7 @@ EvaluateResult CoreNeq::CompareToResult(const EvaluateResult& left,
     case model::StrictEqualsResult::kNull:
       return EvaluateResult::NewNull();
   }
+  HARD_FAIL("Unhandled case in switch statement");
 }
 
 EvaluateResult CoreLt::CompareToResult(const EvaluateResult& left,
@@ -584,8 +586,8 @@ template <typename T>
 bool ProcessUtf8(const std::string& s,
                  T* result,
                  std::function<void(T*, uint32_t, absl::string_view)> func) {
-  int i = 0;
-  const int len = s.size();
+  size_t i = 0;
+  const size_t len = s.size();
   const unsigned char* data = reinterpret_cast<const unsigned char*>(s.data());
 
   while (i < len) {
diff --git a/Firestore/core/src/core/view.cc b/Firestore/core/src/core/view.cc
index 6bd612491d6..e1ccb6b838b 100644
--- a/Firestore/core/src/core/view.cc
+++ b/Firestore/core/src/core/view.cc
@@ -20,10 +20,10 @@
 #include <utility>
 #include <valarray>
 
+#include "Firestore/core/src/core/pipeline_run.h"
 #include "Firestore/core/src/core/target.h"
 #include "Firestore/core/src/model/document_set.h"
 #include "Firestore/core/src/util/hard_assert.h"  // For HARD_ASSERT and HARD_FAIL
-#include "pipeline_run.h"
 
 namespace firebase {
 namespace firestore {
diff --git a/Firestore/core/test/unit/core/expressions/arithmetic_test.cc b/Firestore/core/test/unit/core/expressions/arithmetic_test.cc
index 1364fd6c38a..9e9d6c8f606 100644
--- a/Firestore/core/test/unit/core/expressions/arithmetic_test.cc
+++ b/Firestore/core/test/unit/core/expressions/arithmetic_test.cc
@@ -67,13 +67,15 @@ class ModFunctionTest : public ArithmeticExpressionsTest {};
 
 TEST_F(AddFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant(2LL)})),
+      EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                             SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(3LL)));
+  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant(2.5)})),
+              Returns(Value(3.5)));
   EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant(2.5)})),
-      Returns(Value(3.5)));
-  EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1.0), SharedConstant(2LL)})),
+      EvaluateExpr(*AddExpr(
+          {SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(3.0)));
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant(1.0), SharedConstant(2.0)})),
@@ -81,9 +83,9 @@ TEST_F(AddFunctionTest, BasicNumerics) {
 }
 
 TEST_F(AddFunctionTest, BasicNonNumerics) {
-  EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant("1")})),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant("1")})),
+              ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant("1"), SharedConstant(1.0)})),
       ReturnsError());
@@ -95,12 +97,14 @@ TEST_F(AddFunctionTest, BasicNonNumerics) {
 TEST_F(AddFunctionTest, DoubleLongAdditionOverflow) {
   // Note: C++ double can represent Long.MAX_VALUE + 1.0 exactly, unlike some JS
   // representations.
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(9223372036854775807LL),
-                                     SharedConstant(1.0)})),
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {SharedConstant(static_cast<int64_t>(9223372036854775807LL)),
+                   SharedConstant(1.0)})),
               Returns(Value(9.223372036854776e+18)));
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(9.223372036854776e+18),
-                                     SharedConstant(100LL)})),
-              Returns(Value(9.223372036854776e+18 + 100.0)));
+  EXPECT_THAT(
+      EvaluateExpr(*AddExpr({SharedConstant(9.223372036854776e+18),
+                             SharedConstant(static_cast<int64_t>(100LL))})),
+      Returns(Value(9.223372036854776e+18 + 100.0)));
 }
 
 TEST_F(AddFunctionTest, DoubleAdditionOverflow) {
@@ -124,31 +128,33 @@ TEST_F(AddFunctionTest, SumPosAndNegInfinityReturnNaN) {
 TEST_F(AddFunctionTest, LongAdditionOverflow) {
   EXPECT_THAT(EvaluateExpr(
                   *AddExpr({SharedConstant(std::numeric_limits<int64_t>::max()),
-                            SharedConstant(1LL)})),
+                            SharedConstant(static_cast<int64_t>(1LL))})),
               ReturnsError());  // Expect error due to overflow
   EXPECT_THAT(EvaluateExpr(
                   *AddExpr({SharedConstant(std::numeric_limits<int64_t>::min()),
-                            SharedConstant(-1LL)})),
+                            SharedConstant(static_cast<int64_t>(-1LL))})),
               ReturnsError());  // Expect error due to overflow
   EXPECT_THAT(EvaluateExpr(*AddExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<int64_t>::max())})),
               ReturnsError());  // Expect error due to overflow
 }
 
 TEST_F(AddFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant(nan_val)})),
-      Returns(Value(nan_val)));
+  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant(nan_val)})),
+              Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant(1.0), SharedConstant(nan_val)})),
       Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(9007199254740991LL),
-                                     SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {SharedConstant(static_cast<int64_t>(9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(-9007199254740991LL),
-                                     SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {SharedConstant(static_cast<int64_t>(-9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant(std::numeric_limits<double>::max()),
@@ -177,12 +183,16 @@ TEST_F(AddFunctionTest, NanNotNumberTypeReturnError) {
 
 TEST_F(AddFunctionTest, MultiArgument) {
   // EvaluateExpr handles single expression, so nest calls for multi-arg
-  auto add12 = AddExpr({SharedConstant(1LL), SharedConstant(2LL)});
-  EXPECT_THAT(EvaluateExpr(*AddExpr({add12, SharedConstant(3LL)})),
+  auto add12 = AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                        SharedConstant(static_cast<int64_t>(2LL))});
+  EXPECT_THAT(EvaluateExpr(
+                  *AddExpr({add12, SharedConstant(static_cast<int64_t>(3LL))})),
               Returns(Value(6LL)));
 
-  auto add10_2 = AddExpr({SharedConstant(1.0), SharedConstant(2LL)});
-  EXPECT_THAT(EvaluateExpr(*AddExpr({add10_2, SharedConstant(3LL)})),
+  auto add10_2 =
+      AddExpr({SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))});
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {add10_2, SharedConstant(static_cast<int64_t>(3LL))})),
               Returns(Value(6.0)));
 }
 
@@ -190,13 +200,16 @@ TEST_F(AddFunctionTest, MultiArgument) {
 
 TEST_F(SubtractFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1LL), SharedConstant(2LL)})),
+      EvaluateExpr(*SubtractExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(-1LL)));
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1LL), SharedConstant(2.5)})),
+      EvaluateExpr(*SubtractExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant(2.5)})),
       Returns(Value(-1.5)));
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1.0), SharedConstant(2LL)})),
+      EvaluateExpr(*SubtractExpr(
+          {SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(-1.0)));
   EXPECT_THAT(
       EvaluateExpr(*SubtractExpr({SharedConstant(1.0), SharedConstant(2.0)})),
@@ -205,7 +218,8 @@ TEST_F(SubtractFunctionTest, BasicNumerics) {
 
 TEST_F(SubtractFunctionTest, BasicNonNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1LL), SharedConstant("1")})),
+      EvaluateExpr(*SubtractExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant("1")})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*SubtractExpr({SharedConstant("1"), SharedConstant(1.0)})),
@@ -229,27 +243,30 @@ TEST_F(SubtractFunctionTest, DoubleSubtractionOverflow) {
 TEST_F(SubtractFunctionTest, LongSubtractionOverflow) {
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::min()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::max()),
-                   SharedConstant(-1LL)})),
+                   SharedConstant(static_cast<int64_t>(-1LL))})),
               ReturnsError());
 }
 
 TEST_F(SubtractFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(EvaluateExpr(*SubtractExpr(
-                  {SharedConstant(1LL), SharedConstant(nan_val)})),
-              Returns(Value(nan_val)));
+  EXPECT_THAT(
+      EvaluateExpr(*SubtractExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(nan_val)})),
+      Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(1.0), SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*SubtractExpr({SharedConstant(9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*SubtractExpr(
+                  {SharedConstant(static_cast<int64_t>(9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*SubtractExpr({SharedConstant(-9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*SubtractExpr(
+                  {SharedConstant(static_cast<int64_t>(-9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<double>::max()),
@@ -279,10 +296,10 @@ TEST_F(SubtractFunctionTest, NanNotNumberTypeReturnError) {
 TEST_F(SubtractFunctionTest, PositiveInfinity) {
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
 }
@@ -290,10 +307,10 @@ TEST_F(SubtractFunctionTest, PositiveInfinity) {
 TEST_F(SubtractFunctionTest, NegativeInfinity) {
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(std::numeric_limits<double>::infinity())));
 }
@@ -313,13 +330,16 @@ TEST_F(SubtractFunctionTest, PositiveInfinityNegativeInfinity) {
 
 TEST_F(MultiplyFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(1LL), SharedConstant(2LL)})),
+      EvaluateExpr(*MultiplyExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(2LL)));
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(3LL), SharedConstant(2.5)})),
+      EvaluateExpr(*MultiplyExpr(
+          {SharedConstant(static_cast<int64_t>(3LL)), SharedConstant(2.5)})),
       Returns(Value(7.5)));
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(1.0), SharedConstant(2LL)})),
+      EvaluateExpr(*MultiplyExpr(
+          {SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(2.0)));
   EXPECT_THAT(
       EvaluateExpr(*MultiplyExpr({SharedConstant(1.32), SharedConstant(2.0)})),
@@ -328,7 +348,8 @@ TEST_F(MultiplyFunctionTest, BasicNumerics) {
 
 TEST_F(MultiplyFunctionTest, BasicNonNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(1LL), SharedConstant("1")})),
+      EvaluateExpr(*MultiplyExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant("1")})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*MultiplyExpr({SharedConstant("1"), SharedConstant(1.0)})),
@@ -340,11 +361,13 @@ TEST_F(MultiplyFunctionTest, BasicNonNumerics) {
 
 TEST_F(MultiplyFunctionTest, DoubleLongMultiplicationOverflow) {
   // C++ double handles this fine
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(9223372036854775807LL),
-                                          SharedConstant(100.0)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(9223372036854775807LL)),
+                   SharedConstant(100.0)})),
               Returns(Value(9.223372036854776e+20)));  // Approx
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(9223372036854775807LL),
-                                          SharedConstant(100LL)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(9223372036854775807LL)),
+                   SharedConstant(static_cast<int64_t>(100LL))})),
               ReturnsError());  // Integer overflow
 }
 
@@ -362,36 +385,39 @@ TEST_F(MultiplyFunctionTest, DoubleMultiplicationOverflow) {
 TEST_F(MultiplyFunctionTest, LongMultiplicationOverflow) {
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::max()),
-                   SharedConstant(10LL)})),
+                   SharedConstant(static_cast<int64_t>(10LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::min()),
-                   SharedConstant(10LL)})),
+                   SharedConstant(static_cast<int64_t>(10LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(-10LL),
+                  {SharedConstant(static_cast<int64_t>(-10LL)),
                    SharedConstant(std::numeric_limits<int64_t>::max())})),
               ReturnsError());
   // Note: min * -10 overflows
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(-10LL),
+                  {SharedConstant(static_cast<int64_t>(-10LL)),
                    SharedConstant(std::numeric_limits<int64_t>::min())})),
               ReturnsError());
 }
 
 TEST_F(MultiplyFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(1LL), SharedConstant(nan_val)})),
-              Returns(Value(nan_val)));
+  EXPECT_THAT(
+      EvaluateExpr(*MultiplyExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(nan_val)})),
+      Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(1.0), SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(-9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(-9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<double>::max()),
@@ -421,10 +447,10 @@ TEST_F(MultiplyFunctionTest, NanNotNumberTypeReturnError) {
 TEST_F(MultiplyFunctionTest, PositiveInfinity) {
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(std::numeric_limits<double>::infinity())));
 }
@@ -432,10 +458,10 @@ TEST_F(MultiplyFunctionTest, PositiveInfinity) {
 TEST_F(MultiplyFunctionTest, NegativeInfinity) {
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
 }
@@ -453,11 +479,14 @@ TEST_F(MultiplyFunctionTest,
 }
 
 TEST_F(MultiplyFunctionTest, MultiArgument) {
-  auto mult12 = MultiplyExpr({SharedConstant(1LL), SharedConstant(2LL)});
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({mult12, SharedConstant(3LL)})),
+  auto mult12 = MultiplyExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                              SharedConstant(static_cast<int64_t>(2LL))});
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {mult12, SharedConstant(static_cast<int64_t>(3LL))})),
               Returns(Value(6LL)));
 
-  auto mult23 = MultiplyExpr({SharedConstant(2LL), SharedConstant(3LL)});
+  auto mult23 = MultiplyExpr({SharedConstant(static_cast<int64_t>(2LL)),
+                              SharedConstant(static_cast<int64_t>(3LL))});
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(1.0), mult23})),
               Returns(Value(6.0)));
 }
@@ -466,13 +495,16 @@ TEST_F(MultiplyFunctionTest, MultiArgument) {
 
 TEST_F(DivideFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(2LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(5LL)));
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(2.0)})),
+      EvaluateExpr(*DivideExpr(
+          {SharedConstant(static_cast<int64_t>(10LL)), SharedConstant(2.0)})),
       Returns(Value(5.0)));
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10.0), SharedConstant(3LL)})),
+      EvaluateExpr(*DivideExpr(
+          {SharedConstant(10.0), SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(10.0 / 3.0)));
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant(10.0), SharedConstant(7.0)})),
@@ -481,7 +513,8 @@ TEST_F(DivideFunctionTest, BasicNumerics) {
 
 TEST_F(DivideFunctionTest, BasicNonNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(1LL), SharedConstant("1")})),
+      EvaluateExpr(*DivideExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant("1")})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant("1"), SharedConstant(1.0)})),
@@ -493,16 +526,20 @@ TEST_F(DivideFunctionTest, BasicNonNumerics) {
 
 TEST_F(DivideFunctionTest, LongDivision) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(3LL)));  // Integer division
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(-10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                                SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(-3LL)));  // Integer division
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(-3LL)));  // Integer division
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(-10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                                SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(3LL)));  // Integer division
 }
 
@@ -519,7 +556,8 @@ TEST_F(DivideFunctionTest, DoubleDivisionOverflow) {
 
 TEST_F(DivideFunctionTest, ByZero) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(1LL), SharedConstant(0LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                SharedConstant(static_cast<int64_t>(0LL))})),
       ReturnsError());  // Integer division by zero is error
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant(1.1), SharedConstant(0.0)})),
@@ -535,10 +573,12 @@ TEST_F(DivideFunctionTest, ByZero) {
 TEST_F(DivideFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(1LL), SharedConstant(nan_val)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                SharedConstant(nan_val)})),
       Returns(Value(nan_val)));
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(nan_val), SharedConstant(1LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(nan_val),
+                                SharedConstant(static_cast<int64_t>(1LL))})),
       Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant(1.0), SharedConstant(nan_val)})),
@@ -573,10 +613,10 @@ TEST_F(DivideFunctionTest, NanNotNumberTypeReturnError) {
 TEST_F(DivideFunctionTest, PositiveInfinity) {
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(0.0)));
 }
@@ -584,10 +624,10 @@ TEST_F(DivideFunctionTest, PositiveInfinity) {
 TEST_F(DivideFunctionTest, NegativeInfinity) {
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(-0.0)));  // Note: -0.0
 }
@@ -607,7 +647,8 @@ TEST_F(DivideFunctionTest, PositiveInfinityNegativeInfinityReturnsNan) {
 
 TEST_F(ModFunctionTest, DivisorZeroThrowsError) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(42LL), SharedConstant(0LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(42LL)),
+                             SharedConstant(static_cast<int64_t>(0LL))})),
       ReturnsError());
   // Note: C++ doesn't distinguish -0LL from 0LL
   // EXPECT_TRUE(AssertResultEquals(
@@ -625,7 +666,8 @@ TEST_F(ModFunctionTest, DivisorZeroThrowsError) {
 
 TEST_F(ModFunctionTest, DividendZeroReturnsZero) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(0LL), SharedConstant(42LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(0LL)),
+                             SharedConstant(static_cast<int64_t>(42LL))})),
       Returns(Value(0LL)));
   // Note: C++ doesn't distinguish -0LL from 0LL
   // EXPECT_THAT(
@@ -642,25 +684,29 @@ TEST_F(ModFunctionTest, DividendZeroReturnsZero) {
 
 TEST_F(ModFunctionTest, LongPositivePositive) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(1LL)));
 }
 
 TEST_F(ModFunctionTest, LongNegativeNegative) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(-1LL)));  // C++ % behavior
 }
 
 TEST_F(ModFunctionTest, LongPositiveNegative) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(1LL)));  // C++ % behavior
 }
 
 TEST_F(ModFunctionTest, LongNegativePositive) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(-1LL)));  // C++ % behavior
 }
 
@@ -694,16 +740,20 @@ TEST_F(ModFunctionTest, DoubleNegativePositive) {
 
 TEST_F(ModFunctionTest, LongPerfectlyDivisible) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(5LL))})),
       Returns(Value(0LL)));
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(5LL))})),
       Returns(Value(0LL)));
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(-5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(-5LL))})),
       Returns(Value(0LL)));
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(-5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(-5LL))})),
       Returns(Value(0LL)));
 }
 
@@ -723,11 +773,12 @@ TEST_F(ModFunctionTest, DoublePerfectlyDivisible) {
 }
 
 TEST_F(ModFunctionTest, NonNumericsReturnError) {
+  EXPECT_THAT(EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                     SharedConstant("1")})),
+              ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant("1")})),
-      ReturnsError());
-  EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant("1"), SharedConstant(10LL)})),
+      EvaluateExpr(*ModExpr(
+          {SharedConstant("1"), SharedConstant(static_cast<int64_t>(10LL))})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*ModExpr({SharedConstant("1"), SharedConstant("1")})),
@@ -736,9 +787,9 @@ TEST_F(ModFunctionTest, NonNumericsReturnError) {
 
 TEST_F(ModFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(1LL), SharedConstant(nan_val)})),
-      Returns(Value(nan_val)));
+  EXPECT_THAT(EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant(nan_val)})),
+              Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*ModExpr({SharedConstant(1.0), SharedConstant(nan_val)})),
       Returns(Value(nan_val)));
@@ -761,7 +812,7 @@ TEST_F(ModFunctionTest, NanNotNumberTypeReturnError) {
 
 TEST_F(ModFunctionTest, NumberPosInfinityReturnSelf) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(1.0)));  // fmod(1, inf) -> 1
   EXPECT_THAT(EvaluateExpr(*ModExpr(
@@ -777,7 +828,7 @@ TEST_F(ModFunctionTest, NumberPosInfinityReturnSelf) {
 TEST_F(ModFunctionTest, PosInfinityNumberReturnNaN) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::quiet_NaN())));
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
@@ -791,7 +842,7 @@ TEST_F(ModFunctionTest, PosInfinityNumberReturnNaN) {
 
 TEST_F(ModFunctionTest, NumberNegInfinityReturnSelf) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(1.0)));  // fmod(1, -inf) -> 1
   EXPECT_THAT(EvaluateExpr(*ModExpr(
@@ -807,7 +858,7 @@ TEST_F(ModFunctionTest, NumberNegInfinityReturnSelf) {
 TEST_F(ModFunctionTest, NegInfinityNumberReturnNaN) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::quiet_NaN())));
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
diff --git a/Firestore/core/test/unit/core/expressions/array_test.cc b/Firestore/core/test/unit/core/expressions/array_test.cc
index dd77d14c2bb..80e6e1ee892 100644
--- a/Firestore/core/test/unit/core/expressions/array_test.cc
+++ b/Firestore/core/test/unit/core/expressions/array_test.cc
@@ -250,7 +250,8 @@ TEST_F(ArrayContainsTest, ValueNotFoundInArray) {
   auto array_to_search =
       SharedConstant(Array(Value(42LL), Value("matang"), Value(true)));
   EXPECT_THAT(
-      EvaluateExpr(*ArrayContainsExpr({array_to_search, SharedConstant(4LL)})),
+      EvaluateExpr(*ArrayContainsExpr(
+          {array_to_search, SharedConstant(static_cast<int64_t>(4LL))})),
       Returns(Value(false)));
 }
 
@@ -362,7 +363,8 @@ TEST_F(ArrayLengthTest, NotArrayTypeReturnsError) {
   // Test with other non-array types.
   EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr({SharedConstant("notAnArray")})),
               ReturnsError());
-  EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr({SharedConstant(123LL)})),
+  EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr(
+                  {SharedConstant(static_cast<int64_t>(123LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr({SharedConstant(true)})),
               ReturnsError());
diff --git a/Firestore/core/test/unit/core/expressions/comparison_test.cc b/Firestore/core/test/unit/core/expressions/comparison_test.cc
index c3d4de483fe..1113fd5d4b6 100644
--- a/Firestore/core/test/unit/core/expressions/comparison_test.cc
+++ b/Firestore/core/test/unit/core/expressions/comparison_test.cc
@@ -206,7 +206,8 @@ TEST_F(EqFunctionTest, NaNComparisonsReturnFalse) {
 // eq.null_missingInMap_equality
 TEST_F(EqFunctionTest, NullContainerEquality) {
   auto null_array = SharedConstant(testutil::Array(testutil::Value(nullptr)));
-  EXPECT_THAT(EvaluateExpr(*EqExpr({null_array, SharedConstant(1LL)})),
+  EXPECT_THAT(EvaluateExpr(*EqExpr(
+                  {null_array, SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(testutil::Value(false)));
   EXPECT_THAT(EvaluateExpr(*EqExpr({null_array, SharedConstant("1")})),
               Returns(testutil::Value(false)));
diff --git a/Firestore/core/test/unit/core/expressions/debug_test.cc b/Firestore/core/test/unit/core/expressions/debug_test.cc
index 9b6ed4df06a..ae527a16573 100644
--- a/Firestore/core/test/unit/core/expressions/debug_test.cc
+++ b/Firestore/core/test/unit/core/expressions/debug_test.cc
@@ -117,8 +117,9 @@ TEST_F(DebugTest, IsErrorFieldMissingReturnsFalse) {
 }
 
 TEST_F(DebugTest, IsErrorNonErrorReturnsFalse) {
-  EXPECT_THAT(EvaluateExpr(*IsErrorExpr(SharedConstant(42LL))),
-              Returns(Value(false)));
+  EXPECT_THAT(
+      EvaluateExpr(*IsErrorExpr(SharedConstant(static_cast<int64_t>(42LL)))),
+      Returns(Value(false)));
 }
 
 TEST_F(DebugTest, IsErrorExplicitNullReturnsFalse) {
diff --git a/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc b/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc
index 02a66579b84..e84c450a512 100644
--- a/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc
+++ b/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc
@@ -92,12 +92,14 @@ class MirroringSemanticsTest : public ::testing::Test {
   const std::shared_ptr<Expr> NULL_INPUT = SharedConstant(nullptr);
   // Error: Integer division by zero
   const std::shared_ptr<Expr> ERROR_INPUT =
-      DivideExpr({SharedConstant(1LL), SharedConstant(0LL)});
+      DivideExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                  SharedConstant(static_cast<int64_t>(0LL))});
   // Unset: Field that doesn't exist in the default test document
   const std::shared_ptr<Expr> UNSET_INPUT =
       std::make_shared<Field>("non-existent-field");
   // Valid: A simple valid input for binary tests
-  const std::shared_ptr<Expr> VALID_INPUT = SharedConstant(42LL);
+  const std::shared_ptr<Expr> VALID_INPUT =
+      SharedConstant(static_cast<int64_t>(42LL));
 };
 
 // --- Unary Function Tests ---
diff --git a/Firestore/core/test/unit/core/expressions/string_test.cc b/Firestore/core/test/unit/core/expressions/string_test.cc
index 17ca21fd914..404f9f1eb0a 100644
--- a/Firestore/core/test/unit/core/expressions/string_test.cc
+++ b/Firestore/core/test/unit/core/expressions/string_test.cc
@@ -83,7 +83,8 @@ TEST_F(ByteLengthTest, EmptyByte) {
 }
 
 TEST_F(ByteLengthTest, NonStringOrBytesReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*ByteLengthExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(
+                  *ByteLengthExpr(SharedConstant(static_cast<int64_t>(123LL)))),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*ByteLengthExpr(SharedConstant(true))),
               ReturnsError());
@@ -352,7 +353,8 @@ TEST_F(StrConcatTest, MultipleStringChildrenReturnsCombination) {
 
 TEST_F(StrConcatTest, MultipleNonStringChildrenReturnsError) {
   EXPECT_THAT(
-      EvaluateExpr(*StrConcatExpr({SharedConstant("foo"), SharedConstant(42LL),
+      EvaluateExpr(*StrConcatExpr({SharedConstant("foo"),
+                                   SharedConstant(static_cast<int64_t>(42LL)),
                                    SharedConstant("bar")})),
       ReturnsError());
 }
@@ -392,15 +394,17 @@ TEST_F(StrConcatTest, LargeStrings) {
 
 // --- EndsWith Tests ---
 TEST_F(EndsWithTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(*EndsWithExpr(SharedConstant(42LL),
-                                         SharedConstant("search"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*EndsWithExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                 SharedConstant("search"))),
+      ReturnsError());
 }
 
 TEST_F(EndsWithTest, GetNonStringSuffixIsError) {
-  EXPECT_THAT(EvaluateExpr(*EndsWithExpr(SharedConstant("search"),
-                                         SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*EndsWithExpr(SharedConstant("search"),
+                                 SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(EndsWithTest, GetEmptyInputsReturnsTrue) {
@@ -441,14 +445,15 @@ TEST_F(EndsWithTest, GetLargeSuffixReturnsFalse) {
 
 // --- Like Tests ---
 TEST_F(LikeTest, GetNonStringLikeIsError) {
-  EXPECT_THAT(
-      EvaluateExpr(*LikeExpr(SharedConstant(42LL), SharedConstant("search"))),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*LikeExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                     SharedConstant("search"))),
+              ReturnsError());
 }
 
 TEST_F(LikeTest, GetNonStringValueIsError) {
   EXPECT_THAT(
-      EvaluateExpr(*LikeExpr(SharedConstant("ear"), SharedConstant(42LL))),
+      EvaluateExpr(*LikeExpr(SharedConstant("ear"),
+                             SharedConstant(static_cast<int64_t>(42LL)))),
       ReturnsError());
 }
 
@@ -495,15 +500,17 @@ TEST_F(LikeTest, GetDynamicLike) {
 
 // --- RegexContains Tests ---
 TEST_F(RegexContainsTest, GetNonStringRegexIsError) {
-  EXPECT_THAT(EvaluateExpr(*RegexContainsExpr(SharedConstant(42LL),
-                                              SharedConstant("search"))),
+  EXPECT_THAT(EvaluateExpr(
+                  *RegexContainsExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                     SharedConstant("search"))),
               ReturnsError());
 }
 
 TEST_F(RegexContainsTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(*RegexContainsExpr(SharedConstant("ear"),
-                                              SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*RegexContainsExpr(
+          SharedConstant("ear"), SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(RegexContainsTest, GetInvalidRegexIsError) {
@@ -553,15 +560,17 @@ TEST_F(RegexContainsTest, GetDynamicRegex) {
 
 // --- RegexMatch Tests ---
 TEST_F(RegexMatchTest, GetNonStringRegexIsError) {
-  EXPECT_THAT(EvaluateExpr(*RegexMatchExpr(SharedConstant(42LL),
-                                           SharedConstant("search"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*RegexMatchExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                   SharedConstant("search"))),
+      ReturnsError());
 }
 
 TEST_F(RegexMatchTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(
-                  *RegexMatchExpr(SharedConstant("ear"), SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*RegexMatchExpr(SharedConstant("ear"),
+                                   SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(RegexMatchTest, GetInvalidRegexIsError) {
@@ -617,15 +626,17 @@ TEST_F(RegexMatchTest, GetDynamicRegex) {
 
 // --- StartsWith Tests ---
 TEST_F(StartsWithTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(*StartsWithExpr(SharedConstant(42LL),
-                                           SharedConstant("search"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*StartsWithExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                   SharedConstant("search"))),
+      ReturnsError());
 }
 
 TEST_F(StartsWithTest, GetNonStringPrefixIsError) {
-  EXPECT_THAT(EvaluateExpr(*StartsWithExpr(SharedConstant("search"),
-                                           SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*StartsWithExpr(SharedConstant("search"),
+                                   SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(StartsWithTest, GetEmptyInputsReturnsTrue) {
@@ -666,14 +677,16 @@ TEST_F(StartsWithTest, GetLargePrefixReturnsFalse) {
 
 // --- StrContains Tests ---
 TEST_F(StrContainsTest, ValueNonStringIsError) {
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant(42LL),
-                                            SharedConstant("value"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*StrContainsExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                    SharedConstant("value"))),
+      ReturnsError());
 }
 
 TEST_F(StrContainsTest, SubStringNonStringIsError) {
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant("search space"),
-                                            SharedConstant(42LL))),
+  EXPECT_THAT(EvaluateExpr(
+                  *StrContainsExpr(SharedConstant("search space"),
+                                   SharedConstant(static_cast<int64_t>(42LL)))),
               ReturnsError());
 }
 
@@ -725,8 +738,9 @@ TEST_F(ToLowerTest, Empty) {
 }
 
 TEST_F(ToLowerTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*ToLowerExpr(SharedConstant(123LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*ToLowerExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(ToLowerTest, Null) {
@@ -746,8 +760,9 @@ TEST_F(ToUpperTest, Empty) {
 }
 
 TEST_F(ToUpperTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*ToUpperExpr(SharedConstant(123LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*ToUpperExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(ToUpperTest, Null) {
@@ -776,7 +791,9 @@ TEST_F(TrimTest, Empty) {
 }
 
 TEST_F(TrimTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*TrimExpr(SharedConstant(123LL))), ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*TrimExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(TrimTest, Null) {
@@ -800,8 +817,9 @@ TEST_F(ReverseTest, Unicode) {
 }
 
 TEST_F(ReverseTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*ReverseExpr(SharedConstant(123LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*ReverseExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(ReverseTest, Null) {
diff --git a/Firestore/core/test/unit/core/expressions/timestamp_test.cc b/Firestore/core/test/unit/core/expressions/timestamp_test.cc
index b91dbbff7db..d2fbbaea9f3 100644
--- a/Firestore/core/test/unit/core/expressions/timestamp_test.cc
+++ b/Firestore/core/test/unit/core/expressions/timestamp_test.cc
@@ -48,20 +48,21 @@ TEST_F(UnixMicrosToTimestampTest, StringTypeReturnsError) {
 }
 
 TEST_F(UnixMicrosToTimestampTest, ZeroValueReturnsTimestampEpoch) {
-  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(Timestamp(0, 0))));
 }
 
 TEST_F(UnixMicrosToTimestampTest, IntTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(1000000LL))),
-      Returns(Value(Timestamp(1, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(1000000LL)))),
+              Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(UnixMicrosToTimestampTest, LongTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(9876543210LL))),
-      Returns(Value(Timestamp(9876, 543210000))));
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
+              Returns(Value(Timestamp(9876, 543210000))));
 }
 
 TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeReturnsTimestamp) {
@@ -70,9 +71,9 @@ TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeReturnsTimestamp) {
   timestamp.which_value_type = google_firestore_v1_Value_timestamp_value_tag;
   timestamp.timestamp_value.seconds = -1;
   timestamp.timestamp_value.nanos = 990000000;
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(-10000LL))),
-      Returns(nanopb::MakeMessage(timestamp)));
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
+              Returns(nanopb::MakeMessage(timestamp)));
 }
 
 TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeOverflowReturnsError) {
@@ -86,8 +87,8 @@ TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeOverflowReturnsError) {
       Returns(Value(Timestamp(-62135596800LL, 0))));
 
   // Test value just below the boundary (using subtraction)
-  auto below_min_expr =
-      SubtractExpr({SharedConstant(min_micros), SharedConstant(1LL)});
+  auto below_min_expr = SubtractExpr(
+      {SharedConstant(min_micros), SharedConstant(static_cast<int64_t>(1LL))});
   EXPECT_THAT(
       EvaluateExpr(*UnixMicrosToTimestampExpr(std::move(below_min_expr))),
       testutil::ReturnsError());  // Fully qualify
@@ -123,25 +124,27 @@ TEST_F(UnixMillisToTimestampTest, StringTypeReturnsError) {
 }
 
 TEST_F(UnixMillisToTimestampTest, ZeroValueReturnsTimestampEpoch) {
-  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(Timestamp(0, 0))));
 }
 
 TEST_F(UnixMillisToTimestampTest, IntTypeReturnsTimestamp) {
-  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(1000LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(1000LL)))),
               Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(UnixMillisToTimestampTest, LongTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(9876543210LL))),
-      Returns(Value(Timestamp(9876543, 210000000))));
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
+              Returns(Value(Timestamp(9876543, 210000000))));
 }
 
 TEST_F(UnixMillisToTimestampTest, LongTypeNegativeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(-10000LL))),
-      Returns(Value(Timestamp(-10, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
+              Returns(Value(Timestamp(-10, 0))));
 }
 
 TEST_F(UnixMillisToTimestampTest, LongTypeNegativeOverflowReturnsError) {
@@ -187,25 +190,27 @@ TEST_F(UnixSecondsToTimestampTest, StringTypeReturnsError) {
 }
 
 TEST_F(UnixSecondsToTimestampTest, ZeroValueReturnsTimestampEpoch) {
-  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(Timestamp(0, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, IntTypeReturnsTimestamp) {
-  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, LongTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(9876543210LL))),
-      Returns(Value(Timestamp(9876543210LL, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
+              Returns(Value(Timestamp(9876543210LL, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, LongTypeNegativeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(-10000LL))),
-      Returns(Value(Timestamp(-10000LL, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
+              Returns(Value(Timestamp(-10000LL, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, LongTypeNegativeOverflowReturnsError) {
@@ -244,7 +249,8 @@ class TimestampToUnixMicrosTest : public TimestampExpressionsTest {};
 using testutil::TimestampToUnixMicrosExpr;  // Add using declaration
 
 TEST_F(TimestampToUnixMicrosTest, NonTimestampTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMicrosExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMicrosExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               testutil::ReturnsError());
 }
 
@@ -324,7 +330,8 @@ class TimestampToUnixMillisTest : public TimestampExpressionsTest {};
 using testutil::TimestampToUnixMillisExpr;  // Add using declaration
 
 TEST_F(TimestampToUnixMillisTest, NonTimestampTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMillisExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMillisExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               testutil::ReturnsError());
 }
 
@@ -397,7 +404,8 @@ class TimestampToUnixSecondsTest : public TimestampExpressionsTest {};
 using testutil::TimestampToUnixSecondsExpr;  // Add using declaration
 
 TEST_F(TimestampToUnixSecondsTest, NonTimestampTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampToUnixSecondsExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampToUnixSecondsExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               testutil::ReturnsError());
 }
 
@@ -475,55 +483,55 @@ using testutil::ReturnsNull;       // Add using declaration for null checks
 using testutil::TimestampAddExpr;  // Add using declaration
 
 TEST_F(TimestampAddTest, TimestampAddStringTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant("abc"),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant("abc"), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               testutil::ReturnsError());
 }
 
 TEST_F(TimestampAddTest, TimestampAddZeroValueReturnsTimestampEpoch) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(epoch)));
 }
 
 TEST_F(TimestampAddTest, TimestampAddIntTypeReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(9876543210LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
               Returns(Value(Timestamp(9876543210LL, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeNegativeReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(-10000LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
               Returns(Value(Timestamp(-10000LL, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeNegativeOverflowReturnsError) {
   Timestamp min_ts(-62135596800LL, 0);
   // Test adding 0 (boundary)
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(min_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(min_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(min_ts)));
   // Test adding -1 (overflow)
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(min_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(-1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(min_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(-1LL)))),
               testutil::ReturnsError());
 }
 
@@ -533,73 +541,73 @@ TEST_F(TimestampAddTest, TimestampAddLongTypePositiveOverflowReturnsError) {
   EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
                   SharedConstant(max_ts),
                   SharedConstant("microsecond"),  // Smallest unit
-                  SharedConstant(0LL))),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(max_ts)));  // Expect the same max timestamp
 
   // Test adding 1 microsecond (should overflow)
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(max_ts),
-                                             SharedConstant("microsecond"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(max_ts), SharedConstant("microsecond"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               testutil::ReturnsError());
 
   // Test adding 1 second to a timestamp close to max
   Timestamp near_max_ts(253402300799LL, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(near_max_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(near_max_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(near_max_ts)));
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(near_max_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(near_max_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               testutil::ReturnsError());
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeMinuteReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("minute"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("minute"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(60, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeHourReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant("hour"), SharedConstant(1LL))),
-      Returns(Value(Timestamp(3600, 0))));
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("hour"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              Returns(Value(Timestamp(3600, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeDayReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant("day"), SharedConstant(1LL))),
-      Returns(Value(Timestamp(86400, 0))));
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("day"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              Returns(Value(Timestamp(86400, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeMillisecondReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("millisecond"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("millisecond"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(0, 1000000))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeMicrosecondReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("microsecond"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("microsecond"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(0, 1000))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddInvalidTimeUnitReturnsError) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant("abc"), SharedConstant(1LL))),
-      testutil::ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("abc"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              testutil::ReturnsError());
 }
 
 TEST_F(TimestampAddTest, TimestampAddInvalidAmountReturnsError) {
@@ -620,16 +628,16 @@ TEST_F(TimestampAddTest, TimestampAddNullAmountReturnsNull) {
 
 TEST_F(TimestampAddTest, TimestampAddNullTimeUnitReturnsNull) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant(nullptr), SharedConstant(1LL))),
-      ReturnsNull());
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant(nullptr),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              ReturnsNull());
 }
 
 TEST_F(TimestampAddTest, TimestampAddNullTimestampReturnsNull) {
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(nullptr),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(nullptr), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               ReturnsNull());
 }
 
diff --git a/Firestore/core/test/unit/core/pipeline/collection_group_test.cc b/Firestore/core/test/unit/core/pipeline/collection_group_test.cc
index c3e1c21eb71..4f12261a038 100644
--- a/Firestore/core/test/unit/core/pipeline/collection_group_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/collection_group_test.cc
@@ -229,8 +229,8 @@ TEST_F(CollectionGroupTest, WhereOnValues) {
 
 TEST_F(CollectionGroupTest, WhereInequalityOnValues) {
   RealtimePipeline pipeline = StartPipeline("users");
-  auto where_expr =
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(80LL)});
+  auto where_expr = GtExpr({std::make_shared<Field>("score"),
+                            SharedConstant(static_cast<int64_t>(80LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
@@ -249,8 +249,8 @@ TEST_F(CollectionGroupTest, WhereInequalityOnValues) {
 
 TEST_F(CollectionGroupTest, WhereNotEqualOnValues) {
   RealtimePipeline pipeline = StartPipeline("users");
-  auto where_expr =
-      NeqExpr({std::make_shared<Field>("score"), SharedConstant(50LL)});
+  auto where_expr = NeqExpr({std::make_shared<Field>("score"),
+                             SharedConstant(static_cast<int64_t>(50LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
diff --git a/Firestore/core/test/unit/core/pipeline/collection_test.cc b/Firestore/core/test/unit/core/pipeline/collection_test.cc
index 5e02ad433e9..b5962732de1 100644
--- a/Firestore/core/test/unit/core/pipeline/collection_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/collection_test.cc
@@ -223,8 +223,8 @@ TEST_F(CollectionTest, WhereOnValues) {
 
 TEST_F(CollectionTest, WhereInequalityOnValues) {
   RealtimePipeline pipeline = StartPipeline("/users");  // Use RealtimePipeline
-  auto where_expr =
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(80LL)});
+  auto where_expr = GtExpr({std::make_shared<Field>("score"),
+                            SharedConstant(static_cast<int64_t>(80LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
@@ -238,8 +238,8 @@ TEST_F(CollectionTest, WhereInequalityOnValues) {
 
 TEST_F(CollectionTest, WhereNotEqualOnValues) {
   RealtimePipeline pipeline = StartPipeline("/users");  // Use RealtimePipeline
-  auto where_expr =
-      NeqExpr({std::make_shared<Field>("score"), SharedConstant(50LL)});
+  auto where_expr = NeqExpr({std::make_shared<Field>("score"),
+                             SharedConstant(static_cast<int64_t>(50LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
diff --git a/Firestore/core/test/unit/core/pipeline/complex_test.cc b/Firestore/core/test/unit/core/pipeline/complex_test.cc
index 9fa651a96dd..abfe8b23d51 100644
--- a/Firestore/core/test/unit/core/pipeline/complex_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/complex_test.cc
@@ -129,7 +129,8 @@ TEST_F(ComplexPipelineTest, WhereWithMaxNumberOfStages) {
   for (int i = 1; i <= num_of_fields; ++i) {
     std::string field_name = "field_" + std::to_string(i);
     pipeline = pipeline.AddingStage(std::make_shared<Where>(
-        GtExpr({std::make_shared<Field>(field_name), SharedConstant(0LL)})));
+        GtExpr({std::make_shared<Field>(field_name),
+                SharedConstant(static_cast<int64_t>(0LL))})));
   }
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -382,14 +383,15 @@ TEST_F(ComplexPipelineTest, WhereWithNestedAddFunctionMaxDepth) {
                                 []() { return Value(0LL); });
 
   std::shared_ptr<Expr> add_func =
-      AddExpr({std::make_shared<Field>("field_1"), SharedConstant(1LL)});
+      AddExpr({std::make_shared<Field>("field_1"),
+               SharedConstant(static_cast<int64_t>(1LL))});
   for (int i = 1; i < depth; ++i) {
-    add_func = AddExpr({add_func, SharedConstant(1LL)});
+    add_func = AddExpr({add_func, SharedConstant(static_cast<int64_t>(1LL))});
   }
 
   RealtimePipeline pipeline = StartPipeline("/" + COLLECTION_ID);
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(GtExpr({add_func, SharedConstant(0LL)})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      GtExpr({add_func, SharedConstant(static_cast<int64_t>(0LL))})));
 
   // Since field_1 starts at 0, adding 1 repeatedly will always result in > 0
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -437,7 +439,8 @@ TEST_F(ComplexPipelineTest, WhereWithLargeNumberOfConjunctions) {
   for (int i = 1; i <= num_of_fields; ++i) {
     std::string field_name = "field_" + std::to_string(i);
     and_conditions1.push_back(
-        GtExpr({std::make_shared<Field>(field_name), SharedConstant(0LL)}));
+        GtExpr({std::make_shared<Field>(field_name),
+                SharedConstant(static_cast<int64_t>(0LL))}));
     // Use LtExpr and a large number for the second condition
     and_conditions2.push_back(
         LtExpr({std::make_shared<Field>(field_name),
diff --git a/Firestore/core/test/unit/credentials/empty_credentials_provider_test.cc b/Firestore/core/test/unit/credentials/empty_credentials_provider_test.cc
index 8affd58f34c..b625a7eecb4 100644
--- a/Firestore/core/test/unit/credentials/empty_credentials_provider_test.cc
+++ b/Firestore/core/test/unit/credentials/empty_credentials_provider_test.cc
@@ -18,6 +18,7 @@
 #include "Firestore/core/src/credentials/credentials_fwd.h"
 
 #include "Firestore/core/src/util/statusor.h"
+#include "gtest/gtest-death-test.h"
 #include "gtest/gtest.h"
 
 namespace firebase {
@@ -29,7 +30,11 @@ TEST(EmptyAuthCredentialsProvider, GetToken) {
   credentials_provider.GetToken([](util::StatusOr<AuthToken> result) {
     EXPECT_TRUE(result.ok());
     const AuthToken& token = result.ValueOrDie();
+#if DEBUG
+    EXPECT_DEATH(token.token(), "user_.is_authenticated()");
+#else
     EXPECT_ANY_THROW(token.token());
+#endif
     const User& user = token.user();
     EXPECT_EQ("", user.uid());
     EXPECT_FALSE(user.is_authenticated());
diff --git a/Firestore/core/test/unit/testutil/expression_test_util.cc b/Firestore/core/test/unit/testutil/expression_test_util.cc
index 0c90fa449ad..a2b19e2e354 100644
--- a/Firestore/core/test/unit/testutil/expression_test_util.cc
+++ b/Firestore/core/test/unit/testutil/expression_test_util.cc
@@ -44,7 +44,7 @@ const std::vector<std::shared_ptr<Expr>>
         SharedConstant(-std::numeric_limits<double>::max()),
         SharedConstant(std::numeric_limits<int64_t>::min()),
         SharedConstant(-kMaxLongExactlyRepresentableAsDouble),
-        SharedConstant(-1LL),
+        SharedConstant(static_cast<int64_t>(-1LL)),
         SharedConstant(-0.5),
         SharedConstant(-std::numeric_limits<double>::min()),  // -MIN_NORMAL
         SharedConstant(
@@ -57,8 +57,8 @@ const std::vector<std::shared_ptr<Expr>>
                                                              // (denormalized)
         SharedConstant(std::numeric_limits<double>::min()),  // MIN_NORMAL
         SharedConstant(0.5),
-        SharedConstant(1LL),
-        SharedConstant(42LL),
+        SharedConstant(static_cast<int64_t>(1LL)),
+        SharedConstant(static_cast<int64_t>(42LL)),
         SharedConstant(kMaxLongExactlyRepresentableAsDouble),
         SharedConstant(std::numeric_limits<int64_t>::max()),
         SharedConstant(std::numeric_limits<double>::max()),
@@ -81,7 +81,7 @@ const std::vector<std::shared_ptr<Expr>>
         // C++
         SharedConstant("santé"), SharedConstant("santé et bonheur")};
 
-const auto ComparisonValueTestData::BYTE_VALUES =
+const std::vector<std::shared_ptr<Expr>> ComparisonValueTestData::BYTE_VALUES =
     std::vector<std::shared_ptr<Expr>>{
         SharedConstant(*BlobValue()),  // Empty - use default constructor
         SharedConstant(*BlobValue(0, 2, 56, 42)),  // Use variadic args
@@ -109,8 +109,9 @@ const std::vector<std::shared_ptr<Expr>> ComparisonValueTestData::GEO_VALUES = {
 
 const std::vector<std::shared_ptr<Expr>> ComparisonValueTestData::ARRAY_VALUES =
     {SharedConstant(Array()),
-     SharedConstant(Array(true, 15LL)),
-     SharedConstant(Array(1LL, 2LL)),
+     SharedConstant(Array(true, static_cast<int64_t>(15LL))),
+     SharedConstant(
+         Array(static_cast<int64_t>(1LL), static_cast<int64_t>(2LL))),
      SharedConstant(Array(Value(Timestamp(12, 0)))),
      SharedConstant(Array("foo")),
      SharedConstant(Array("foo", "bar")),
diff --git a/Firestore/core/test/unit/testutil/expression_test_util.h b/Firestore/core/test/unit/testutil/expression_test_util.h
index fab0296b44a..3386c03d2fb 100644
--- a/Firestore/core/test/unit/testutil/expression_test_util.h
+++ b/Firestore/core/test/unit/testutil/expression_test_util.h
@@ -445,19 +445,27 @@ struct ComparisonValueTestData {
       results.push_back({value, value});
     }
 
-    results.push_back({SharedConstant(-42LL), SharedConstant(-42.0)});
-    results.push_back({SharedConstant(-42.0), SharedConstant(-42LL)});
-    results.push_back({SharedConstant(42LL), SharedConstant(42.0)});
-    results.push_back({SharedConstant(42.0), SharedConstant(42LL)});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(-42LL)), SharedConstant(-42.0)});
+    results.push_back(
+        {SharedConstant(-42.0), SharedConstant(static_cast<int64_t>(-42LL))});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(42LL)), SharedConstant(42.0)});
+    results.push_back(
+        {SharedConstant(42.0), SharedConstant(static_cast<int64_t>(42LL))});
 
     results.push_back({SharedConstant(0.0), SharedConstant(-0.0)});
     results.push_back({SharedConstant(-0.0), SharedConstant(0.0)});
 
-    results.push_back({SharedConstant(0LL), SharedConstant(-0.0)});
-    results.push_back({SharedConstant(-0.0), SharedConstant(0LL)});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(0LL)), SharedConstant(-0.0)});
+    results.push_back(
+        {SharedConstant(-0.0), SharedConstant(static_cast<int64_t>(0LL))});
 
-    results.push_back({SharedConstant(0LL), SharedConstant(0.0)});
-    results.push_back({SharedConstant(0.0), SharedConstant(0LL)});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(0LL)), SharedConstant(0.0)});
+    results.push_back(
+        {SharedConstant(0.0), SharedConstant(static_cast<int64_t>(0LL))});
 
     return results;
   }
diff --git a/Firestore/core/test/unit/timestamp_test.cc b/Firestore/core/test/unit/timestamp_test.cc
index b9d4e9c40dd..bdd8247c266 100644
--- a/Firestore/core/test/unit/timestamp_test.cc
+++ b/Firestore/core/test/unit/timestamp_test.cc
@@ -17,11 +17,13 @@
 #include "Firestore/core/include/firebase/firestore/timestamp.h"
 
 #include <cmath>
+#include <cstdio>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "Firestore/core/src/util/warnings.h"
+#include "gtest/gtest-death-test.h"
 #include "gtest/gtest.h"
 
 SUPPRESS_COMMA_WARNINGS_BEGIN()
@@ -275,6 +277,19 @@ TEST(Timestamp, Comparison) {
 }
 
 TEST(Timestamp, InvalidArguments) {
+#if !defined(NDEBUG)
+  // Negative nanoseconds.
+  ASSERT_DEATH(Timestamp(0, -1), "nanoseconds");
+  ASSERT_DEATH(Timestamp(100, -1), "nanoseconds");
+  ASSERT_DEATH(Timestamp(100, -12346789), "nanoseconds");
+
+  // Nanoseconds that are more than one second.
+  ASSERT_DEATH(Timestamp(0, 999999999 + 1), "nanoseconds");
+
+  // Seconds beyond supported range.
+  ASSERT_DEATH(Timestamp(kLowerBound - 1, 0), "seconds");
+  ASSERT_DEATH(Timestamp(kUpperBound + 1, 0), "seconds");
+#else
   // Negative nanoseconds.
   ASSERT_ANY_THROW(Timestamp(0, -1));
   ASSERT_ANY_THROW(Timestamp(100, -1));
@@ -286,6 +301,7 @@ TEST(Timestamp, InvalidArguments) {
   // Seconds beyond supported range.
   ASSERT_ANY_THROW(Timestamp(kLowerBound - 1, 0));
   ASSERT_ANY_THROW(Timestamp(kUpperBound + 1, 0));
+#endif
 }
 
 TEST(Timestamp, InvalidArgumentsChrono) {
@@ -293,10 +309,33 @@ TEST(Timestamp, InvalidArgumentsChrono) {
   // system clock-based time_point on this platform can represent values this
   // large.
   if (CanSystemClockDurationHold(Sec(kUpperBound + 1))) {
-    ASSERT_ANY_THROW(Timestamp::FromTimePoint(TimePoint{Sec(kUpperBound + 1)}));
+    auto action = [] {
+      Timestamp::FromTimePoint(TimePoint{Sec(kUpperBound + 1)});
+    };
+
+#if ABSL_HAVE_EXCEPTIONS
+    // Expect a C++ exception to be thrown
+    printf("Testing upper bound with exceptions\n");
+    ASSERT_ANY_THROW(action());
+#else
+    // Expect the process to terminate
+    printf("Testing upper bound without exceptions\n");
+    ASSERT_DEATH(action(), "Timestamp seconds out of range");
+#endif
   }
+
   if (CanSystemClockDurationHold(Sec(kLowerBound - 1))) {
-    ASSERT_ANY_THROW(Timestamp::FromTimePoint(TimePoint{Sec(kLowerBound - 1)}));
+    auto action = [] {
+      Timestamp::FromTimePoint(TimePoint{Sec(kLowerBound - 1)});
+    };
+
+#if ABSL_HAVE_EXCEPTIONS
+    printf("Testing lower bound with exceptions\n");
+    ASSERT_ANY_THROW(action());
+#else
+    printf("Testing lower bound without exceptions\n");
+    ASSERT_DEATH(action(), "Timestamp seconds out of range");
+#endif
   }
 }
 
diff --git a/cmake/external/abseil-cpp.cmake b/cmake/external/abseil-cpp.cmake
index 0d8c33ed940..2ebf6a252bd 100644
--- a/cmake/external/abseil-cpp.cmake
+++ b/cmake/external/abseil-cpp.cmake
@@ -26,6 +26,14 @@ ExternalProject_Add(
 
   PREFIX ${PROJECT_BINARY_DIR}
 
+  CMAKE_ARGS
+    -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+    -DCMAKE_CXX_STANDARD=11
+    -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+    -DBUILD_TESTING=OFF
+    -DABSL_PROPAGATE_CXX_STD=ON
+    -DABSL_ENABLE_EXCEPTIONS=1
+
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
diff --git a/scripts/build.sh b/scripts/build.sh
index f9a79ef0960..db28386fa90 100755
--- a/scripts/build.sh
+++ b/scripts/build.sh
@@ -271,6 +271,7 @@ xcb_flags=("${xcb_flags[@]}" "${buildcache_xcb_flags[@]}")
 cmake_options=(
   -Wdeprecated
   -DCMAKE_BUILD_TYPE=Debug
+  -DABSL_ENABLE_EXCEPTIONS=1
 )
 
 if [[ -n "${SANITIZERS:-}" ]]; then