diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h b/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h
index 632eca427..bd8ca0821 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h
@@ -126,9 +126,9 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pldexp_generic(const Packet& a, con
   static constexpr int TotalBits = sizeof(Scalar) * CHAR_BIT, MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
                        ExponentBits = TotalBits - MantissaBits - 1;
 
-  constexpr Scalar max_exp_value = Scalar((ScalarI(1) << ExponentBits) + ScalarI(MantissaBits - 1));  // 278
-  const Packet max_exponent = pset1<Packet>(max_exp_value);
-  const Packet neg_max_exponent = pset1<Packet>(-max_exp_value);
+  constexpr ScalarI max_exp_value = (ScalarI(1) << ExponentBits) + ScalarI(MantissaBits - 1);  // 278
+  const Packet max_exponent = pset1<Packet>(Scalar(max_exp_value));
+  const Packet neg_max_exponent = pset1<Packet>(Scalar(-max_exp_value));
   const PacketI bias = pset1<PacketI>((ScalarI(1) << (ExponentBits - 1)) - ScalarI(1));  // 127
   const PacketI e = pcast<Packet, PacketI>(pmin(pmax(exponent, neg_max_exponent), max_exponent));
   const PacketI b = parithmetic_shift_right<2>(e);                                                     // floor(e/4);
diff --git a/Eigen/src/Core/arch/Default/Half.h b/Eigen/src/Core/arch/Default/Half.h
index f102c8347..30863279a 100644
--- a/Eigen/src/Core/arch/Default/Half.h
+++ b/Eigen/src/Core/arch/Default/Half.h
@@ -650,12 +650,8 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff) {
 
 #elif defined(EIGEN_HAS_FP16_C)
   __half_raw h;
-#if EIGEN_COMP_MSVC
-  // MSVC does not have scalar instructions.
-  h.x = _mm_extract_epi16(_mm_cvtps_ph(_mm_set_ss(ff), 0), 0);
-#else
-  h.x = _cvtss_sh(ff, 0);
-#endif
+  // Spell out the vector conversion to avoid Clang warning about the C99 compound literal used by _cvtss_sh.
+  h.x = static_cast<numext::uint16_t>(_mm_extract_epi16(_mm_cvtps_ph(_mm_set_ss(ff), 0), 0));
   return h;
 
 #else
diff --git a/test/geo_misc.cpp b/test/geo_misc.cpp
index df93ffa67..77b61ed5a 100644
--- a/test/geo_misc.cpp
+++ b/test/geo_misc.cpp
@@ -77,7 +77,7 @@ void angleaxis_edge_cases() {
     // Round-trip through quaternion
     Quaternionx q(aa);
     AngleAxisx aa2(q);
-    VERIFY(abs(aa2.angle()) < Scalar(4) * tiny);
+    VERIFY(numext::abs(aa2.angle()) < Scalar(4) * tiny);
   }
 
   // Round-trip: AngleAxis -> Matrix -> AngleAxis
@@ -92,7 +92,7 @@ void angleaxis_edge_cases() {
     aa2.fromRotationMatrix(m);
     VERIFY_IS_APPROX(aa.toRotationMatrix(), aa2.toRotationMatrix());
     // Verify angle is preserved
-    VERIFY(abs(aa2.angle() - a) < eps);
+    VERIFY(numext::abs(aa2.angle() - a) < eps);
   }
 
   // Round-trip for near-180-degree rotation
@@ -148,7 +148,7 @@ void angleaxis_edge_cases() {
     Quaternionx q(aa);
     VERIFY_IS_APPROX(q.norm(), Scalar(1));
     AngleAxisx aa2(q);
-    VERIFY(abs(aa2.angle() - a) < eps);
+    VERIFY(numext::abs(aa2.angle() - a) < eps);
     // Axis should agree (possibly with sign flip for angle > pi)
     VERIFY(aa2.axis().isApprox(axis, eps) || aa2.axis().isApprox(-axis, eps));
   }
@@ -219,7 +219,7 @@ void rotation2d_standalone() {
     Rotation2Dx half = r.slerp(Scalar(0.5), r.inverse());
     // The midpoint between a rotation and its inverse via shortest path should be ~0 or ~pi
     Scalar halfAngle = half.smallestAngle();
-    VERIFY(abs(halfAngle) < eps || abs(abs(halfAngle) - Scalar(EIGEN_PI)) < eps);
+    VERIFY(numext::abs(halfAngle) < eps || numext::abs(numext::abs(halfAngle) - Scalar(EIGEN_PI)) < eps);
   }
 
   // Rotation2D slerp interpolation: verify linearity of angle
@@ -231,7 +231,7 @@ void rotation2d_standalone() {
     Rotation2Dx rt = r0.slerp(t, r1);
     // Slerp for 2D rotations is just linear interpolation of angle along shortest path.
     Scalar expected = a0 + t * Rotation2Dx(a1 - a0).smallestAngle();
-    VERIFY(abs(Rotation2Dx(rt.angle() - expected).smallestAngle()) < eps);
+    VERIFY(numext::abs(Rotation2Dx(rt.angle() - expected).smallestAngle()) < eps);
   }
 
   // smallestAngle range
@@ -377,7 +377,7 @@ void quaternion_from_non_orthogonal_matrix() {
     VERIFY(!(numext::isnan)(q.y()));
     VERIFY(!(numext::isnan)(q.z()));
     // Should still be approximately a rotation
-    VERIFY(abs(q.norm() - Scalar(1)) < Scalar(0.01));
+    VERIFY(numext::abs(q.norm() - Scalar(1)) < Scalar(0.01));
   }
 
   // Negative trace case with non-orthogonal matrix
@@ -425,7 +425,6 @@ void quaternion_slerp_edge_cases() {
   typedef Matrix<Scalar, 3, 1> Vector3;
   typedef Matrix<Scalar, 3, 3> Matrix3;
 
-  Scalar eps = test_precision<Scalar>();
   // The slerp formula preserves unit norm to O(epsilon^2) for unit inputs.
   Scalar tight = Scalar(32) * NumTraits<Scalar>::epsilon();
 
@@ -434,7 +433,7 @@ void quaternion_slerp_edge_cases() {
     Quaternionx q = Quaternionx::UnitRandom();
     Quaternionx r = q.slerp(Scalar(0.5), q);
     VERIFY_IS_APPROX(r.coeffs(), q.coeffs());
-    VERIFY(abs(r.norm() - Scalar(1)) < tight);
+    VERIFY(numext::abs(r.norm() - Scalar(1)) < tight);
   }
 
   // slerp at t=0 and t=1
@@ -443,8 +442,8 @@ void quaternion_slerp_edge_cases() {
     Quaternionx q1 = Quaternionx::UnitRandom();
     Quaternionx r0 = q0.slerp(Scalar(0), q1);
     Quaternionx r1 = q0.slerp(Scalar(1), q1);
-    VERIFY(abs(r0.norm() - Scalar(1)) < tight);
-    VERIFY(abs(r1.norm() - Scalar(1)) < tight);
+    VERIFY(numext::abs(r0.norm() - Scalar(1)) < tight);
+    VERIFY(numext::abs(r1.norm() - Scalar(1)) < tight);
     VERIFY_IS_APPROX(r0.toRotationMatrix(), q0.toRotationMatrix());
     VERIFY_IS_APPROX(r1.toRotationMatrix(), q1.toRotationMatrix());
   }
@@ -456,7 +455,7 @@ void quaternion_slerp_edge_cases() {
     qn.coeffs() = -q.coeffs();
     for (Scalar t = 0; t <= Scalar(1.001); t += Scalar(0.25)) {
       Quaternionx r = q.slerp(t, qn);
-      VERIFY(abs(r.norm() - Scalar(1)) < tight);
+      VERIFY(numext::abs(r.norm() - Scalar(1)) < tight);
       // Should stay at the same rotation
       VERIFY_IS_APPROX(r.toRotationMatrix(), q.toRotationMatrix());
     }
@@ -468,10 +467,10 @@ void quaternion_slerp_edge_cases() {
     Quaternionx q0(AngleAxisx(Scalar(0), axis1));
     Quaternionx q1(AngleAxisx(Scalar(EIGEN_PI), axis1));
     Quaternionx mid = q0.slerp(Scalar(0.5), q1);
-    VERIFY(abs(mid.norm() - Scalar(1)) < tight);
+    VERIFY(numext::abs(mid.norm() - Scalar(1)) < tight);
     // Midpoint should be a 90-degree rotation
     AngleAxisx aa(mid);
-    VERIFY(abs(aa.angle() - Scalar(EIGEN_PI) / Scalar(2)) < test_precision<Scalar>());
+    VERIFY(numext::abs(aa.angle() - Scalar(EIGEN_PI) / Scalar(2)) < test_precision<Scalar>());
   }
 
   // slerp unit-norm preservation and rotation matrix orthogonality
@@ -480,7 +479,7 @@ void quaternion_slerp_edge_cases() {
     Quaternionx q1 = Quaternionx::UnitRandom();
     for (Scalar t = 0; t <= Scalar(1.001); t += Scalar(0.05)) {
       Quaternionx r = q0.slerp(t, q1);
-      VERIFY(abs(r.norm() - Scalar(1)) < tight);
+      VERIFY(numext::abs(r.norm() - Scalar(1)) < tight);
       Matrix3 m = r.toRotationMatrix();
       VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
       VERIFY_IS_APPROX(m.determinant(), Scalar(1));
diff --git a/test/geo_quaternion.cpp b/test/geo_quaternion.cpp
index 163cce350..911357949 100644
--- a/test/geo_quaternion.cpp
+++ b/test/geo_quaternion.cpp
@@ -253,10 +253,10 @@ void quaternion(void) {
     Vector3 axis = Vector3(Scalar(1), Scalar(2), Scalar(3)).normalized();
     for (Scalar gap : {Scalar(1e-3), Scalar(1e-6)}) {
       Scalar theta = Scalar(EIGEN_PI) - gap;
-      Quaternionx q(AngleAxisx(theta, axis));
-      Vector3 sa = q.toScaledAxis();
+      Quaternionx near_pi_quat(AngleAxisx(theta, axis));
+      Vector3 sa = near_pi_quat.toScaledAxis();
       VERIFY_IS_APPROX(sa.stableNorm(), theta);
-      VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa), q);
+      VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa), near_pi_quat);
     }
   }
 
@@ -286,13 +286,13 @@ void quaternion(void) {
       Scalar theta = -Scalar(EIGEN_PI) + Scalar(2 * EIGEN_PI) * Scalar(octant) / Scalar(kNumOctants);
       Scalar phi = Scalar(EIGEN_PI) * Scalar(octant + 1) / Scalar(kNumOctants + 1);
       Vector3 sa(angle * sin(phi) * cos(theta), angle * sin(phi) * sin(theta), angle * cos(phi));
-      Quaternionx q = Quaternionx::FromScaledAxis(sa);
-      VERIFY_IS_APPROX(q.norm(), Scalar(1));
-      Vector3 sa_rt = q.toScaledAxis();
+      Quaternionx roundtrip_quat = Quaternionx::FromScaledAxis(sa);
+      VERIFY_IS_APPROX(roundtrip_quat.norm(), Scalar(1));
+      Vector3 sa_rt = roundtrip_quat.toScaledAxis();
       VERIFY_IS_APPROX(sa_rt, sa);
       // And the other direction (quaternion -> sa -> quaternion).
-      Quaternionx q2 = Quaternionx::FromScaledAxis(sa_rt);
-      VERIFY_IS_APPROX(q2, q);
+      Quaternionx roundtrip_quat2 = Quaternionx::FromScaledAxis(sa_rt);
+      VERIFY_IS_APPROX(roundtrip_quat2, roundtrip_quat);
     }
   }
 
diff --git a/test/incomplete_LUT.cpp b/test/incomplete_LUT.cpp
index b25a301f3..315ecc136 100644
--- a/test/incomplete_LUT.cpp
+++ b/test/incomplete_LUT.cpp
@@ -49,30 +49,30 @@ void test_extract_LU() {
 
   Eigen::SparseMatrix<T> expectedMatL(5, 5);
   std::vector<Eigen::Triplet<T>> tripletsExL;
-  tripletsExL.emplace_back(0, 0, 1);
-  tripletsExL.emplace_back(1, 0, -0.25);
-  tripletsExL.emplace_back(1, 1, 1);
-  tripletsExL.emplace_back(2, 0, -0.25);
-  tripletsExL.emplace_back(2, 1, -0.0666667);
-  tripletsExL.emplace_back(2, 2, 1);
-  tripletsExL.emplace_back(3, 2, -0.25);
-  tripletsExL.emplace_back(3, 3, 1);
-  tripletsExL.emplace_back(4, 1, -0.266667);
-  tripletsExL.emplace_back(4, 3, -0.266667);
-  tripletsExL.emplace_back(4, 4, 1);
+  tripletsExL.emplace_back(0, 0, T(1));
+  tripletsExL.emplace_back(1, 0, T(-0.25));
+  tripletsExL.emplace_back(1, 1, T(1));
+  tripletsExL.emplace_back(2, 0, T(-0.25));
+  tripletsExL.emplace_back(2, 1, T(-0.0666667));
+  tripletsExL.emplace_back(2, 2, T(1));
+  tripletsExL.emplace_back(3, 2, T(-0.25));
+  tripletsExL.emplace_back(3, 3, T(1));
+  tripletsExL.emplace_back(4, 1, T(-0.266667));
+  tripletsExL.emplace_back(4, 3, T(-0.266667));
+  tripletsExL.emplace_back(4, 4, T(1));
   expectedMatL.setFromTriplets(tripletsExL.begin(), tripletsExL.end());
 
   Eigen::SparseMatrix<T> expectedMatU(5, 5);
   std::vector<Eigen::Triplet<T>> tripletsExU;
-  tripletsExU.emplace_back(0, 0, 4);
-  tripletsExU.emplace_back(0, 1, -1);
-  tripletsExU.emplace_back(1, 1, 3.75);
-  tripletsExU.emplace_back(1, 4, -1);
-  tripletsExU.emplace_back(2, 2, 4);
-  tripletsExU.emplace_back(2, 3, -1);
-  tripletsExU.emplace_back(3, 3, 3.75);
-  tripletsExU.emplace_back(3, 4, -1);
-  tripletsExU.emplace_back(4, 4, 3.46667);
+  tripletsExU.emplace_back(0, 0, T(4));
+  tripletsExU.emplace_back(0, 1, T(-1));
+  tripletsExU.emplace_back(1, 1, T(3.75));
+  tripletsExU.emplace_back(1, 4, T(-1));
+  tripletsExU.emplace_back(2, 2, T(4));
+  tripletsExU.emplace_back(2, 3, T(-1));
+  tripletsExU.emplace_back(3, 3, T(3.75));
+  tripletsExU.emplace_back(3, 4, T(-1));
+  tripletsExU.emplace_back(4, 4, T(3.46667));
   expectedMatU.setFromTriplets(tripletsExU.begin(), tripletsExU.end());
 
   VERIFY_IS_APPROX(expectedMatL, matL);
diff --git a/test/threads_runqueue.cpp b/test/threads_runqueue.cpp
index 93ce0a0f6..65c08366d 100644
--- a/test/threads_runqueue.cpp
+++ b/test/threads_runqueue.cpp
@@ -158,10 +158,10 @@ void test_empty_runqueue() {
 void test_stress_runqueue() {
   static const int kEvents = 1 << 18;
   RunQueue<int, 8> q;
-  std::atomic<int> total(0);
+  std::atomic<int64_t> total(0);
   std::vector<std::unique_ptr<std::thread>> threads;
   threads.emplace_back(new std::thread([&q, &total]() {
-    int sum = 0;
+    int64_t sum = 0;
     int pushed = 1;
     int popped = 1;
     while (pushed < kEvents || popped < kEvents) {
diff --git a/test/tuple_test.cpp b/test/tuple_test.cpp
index 7a55fddde..52f23d0eb 100644
--- a/test/tuple_test.cpp
+++ b/test/tuple_test.cpp
@@ -61,8 +61,7 @@ void basic_tuple_test() {
   VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(tuple3cat0)>::value, size_t(3));
   auto singlecat = tuple_impl::tuple_cat(tuple3);
   VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(singlecat)>::value, size_t(3));
-  auto emptycat = tuple_impl::tuple_cat();
-  VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(emptycat)>::value, size_t(0));
+  VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(tuple_impl::tuple_cat())>::value, size_t(0));
   auto tuple0cat1cat2cat3 = tuple_impl::tuple_cat(tuple0, tuple1, tuple2, tuple3);
   VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(tuple0cat1cat2cat3)>::value, size_t(6));
 
diff --git a/unsupported/Eigen/src/Tensor/TensorCostModel.h b/unsupported/Eigen/src/Tensor/TensorCostModel.h
index c165d69f2..b8789c67b 100644
--- a/unsupported/Eigen/src/Tensor/TensorCostModel.h
+++ b/unsupported/Eigen/src/Tensor/TensorCostModel.h
@@ -202,12 +202,13 @@ class TensorCostModel {
     // live data is N. A working-set-aware estimate would need each evaluator to
     // surface its unique-operand footprint; until that exists we accept a small
     // bias toward over-capping for reuse-heavy expressions.
-    if (candidate > kMemBandwidthSaturationThreads) {
+    const int mem_bandwidth_saturation_threads = kMemBandwidthSaturationThreads;
+    if (candidate > mem_bandwidth_saturation_threads) {
       bool is_memory_bound = (comp > 0) ? (mem / comp > kMemBoundThreshold) : (mem > 0);
       if (is_memory_bound) {
         double total_bytes = output_size * cost_per_coeff.total_bytes();
         if (total_bytes > kDramThresholdBytes) {
-          candidate = numext::mini(candidate, kMemBandwidthSaturationThreads);
+          candidate = numext::mini(candidate, mem_bandwidth_saturation_threads);
         }
       }
     }
diff --git a/unsupported/test/EulerAngles.cpp b/unsupported/test/EulerAngles.cpp
index 30b656179..cd275e664 100644
--- a/unsupported/test/EulerAngles.cpp
+++ b/unsupported/test/EulerAngles.cpp
@@ -264,7 +264,7 @@ void eulerangles_rand() {
 template <typename Scalar>
 void eulerangles_gimbal_lock_regression() {
   typedef Matrix<Scalar, 3, 1> Vector3;
-  const Scalar deg = Scalar(EIGEN_PI / 180.0);
+  const Scalar deg = Scalar(EIGEN_PI) / Scalar(180);
 
   check_all_var(Vector3(Scalar(10) * deg, Scalar(90) * deg, Scalar(30) * deg));
   check_all_var(Vector3(Scalar(10) * deg, Scalar(-90) * deg, Scalar(30) * deg));
diff --git a/unsupported/test/tensor_block_eval.cpp b/unsupported/test/tensor_block_eval.cpp
index df7e2a20d..72921b8a1 100644
--- a/unsupported/test/tensor_block_eval.cpp
+++ b/unsupported/test/tensor_block_eval.cpp
@@ -518,7 +518,7 @@ struct SimpleTensorGenerator<bool, NumDims> {
   bool operator()(const array<Index, NumDims>& coords) const {
     bool result = false;
     for (int i = 0; i < NumDims; ++i) {
-      result ^= coords[i];
+      result = result != (coords[i] != 0);
     }
     return result;
   }
diff --git a/unsupported/test/tensor_roll.cpp b/unsupported/test/tensor_roll.cpp
index 58c6375b0..d81226523 100644
--- a/unsupported/test/tensor_roll.cpp
+++ b/unsupported/test/tensor_roll.cpp
@@ -72,7 +72,7 @@ static void test_expr_roll(bool LValue) {
   Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
   tensor.setRandom();
 
-  array<bool, 4> dim_roll;
+  array<Index, 4> dim_roll;
   dim_roll[0] = 2;
   dim_roll[1] = 1;
   dim_roll[2] = 0;