Merge pull request #4210 from pleroy/Clang

Fix warnings emitted by Clang

Author: pleroy

Makefile

@@ -115,10 +115,11 @@ SHARED_ARGS   := \
 	-fbracket-depth=257                                           \
 	-fexceptions                                                  \
 	-ferror-limit=1000                                            \
-	-ffp-contract=off                                              \
+	-ffp-contract=off                                             \
 	-fno-omit-frame-pointer                                       \
 	-fno-char8_t                                                  \
 	-Wall -Wpedantic                                              \
+	-Wno-c++23-extensions                                         \
 	-Wno-char-subscripts                                          \
 	-Wno-elaborated-enum-class                                    \
 	-Wno-gnu-anonymous-struct                                     \

base/push_pull_callback_test.cpp

@@ -52,7 +52,7 @@ TEST(PushPullCallback, 4136) {
       int x;
       bool const more = executor->callback().Pull(x);
       if (!more) {
-        auto const result = executor->get();
+        [[maybe_unused]] auto const result = executor->get();
         delete executor;
         break;
       }

functions/accurate_table_generator_body.hpp

@@ -660,8 +660,7 @@ absl::StatusOr<cpp_rational> StehléZimmermannSimultaneousFullSearch(
   // This mutex is not contended as it is only held exclusively when we have
   // found a solution.
   absl::Mutex lock;
-  std::optional<absl::StatusOr<cpp_rational>> status_or_solution
-      GUARDED_BY(lock);
+  std::optional<absl::StatusOr<cpp_rational>> status_or_solution;
 
   auto search_one_slice = [argument_scale,
                            &lock,

functions/sin_cos_test.cpp

@@ -119,7 +119,6 @@ TEST_F(SinCosTest, AccurateTableIndex) {
 
   constexpr std::int64_t table_spacing_bits = 9;
   constexpr double table_spacing_reciprocal = 1 << table_spacing_bits;
-  constexpr double table_spacing = 1.0 / table_spacing_reciprocal;
   static const __m128d mantissa_index_bits =
       _mm_castsi128_pd(_mm_cvtsi64_si128(0x0000'0000'0000'01ff));
   std::mt19937_64 random(42);
@@ -143,7 +142,6 @@ TEST_F(SinCosTest, AccurateTableIndex) {
 TEST_F(SinCosTest, ReduceIndex) {
   static constexpr std::int64_t iterations = 100;
 
-  static constexpr std::int64_t π_over_2_zeroes = 18;
   static const __m128d sign_bit =
       _mm_castsi128_pd(_mm_cvtsi64_si128(0x8000'0000'0000'0000));
   static constexpr double mantissa_reduce_shifter =
@@ -156,7 +154,6 @@ TEST_F(SinCosTest, ReduceIndex) {
 
     __m128d const n_128d = _mm_round_sd(
         _mm_setzero_pd(), _mm_set_sd(θ * (2 / π)), _MM_FROUND_RINT);
-    double const n_double = _mm_cvtsd_f64(n_128d);
     std::int64_t const n = _mm_cvtsd_si64(n_128d);
 
     double const abs_θ = std::abs(θ);

geometry/pair_test.cpp

@@ -445,13 +445,13 @@ TEST_F(PairDeathTest, SerializationError) {
   serialization::Pair message;
   pv_.WriteToMessage(&message);
   EXPECT_DEATH({
-    PP const pp = PP::ReadFromMessage(message);
+    [[maybe_unused]] PP const pp = PP::ReadFromMessage(message);
   }, "has_point");
   EXPECT_DEATH({
-    VP const vp = VP::ReadFromMessage(message);
+    [[maybe_unused]] VP const vp = VP::ReadFromMessage(message);
   }, "has_multivector");
   EXPECT_DEATH({
-    VV const vv = VV::ReadFromMessage(message);
+    [[maybe_unused]] VV const vv = VV::ReadFromMessage(message);
   }, "has_multivector");
 }
 

mathematica/integrator_plots.cpp

@@ -465,10 +465,9 @@ class WorkErrorGraphGenerator {
             problem,
             append_state,
             /*tolerance_to_error_ratio=*/
-            [time_step_index, tolerance, this](
-                Time const& current_step_size,
-                SecondOrderODE::State const& state,
-                SecondOrderODE::State::Error const& error) {
+            [tolerance](Time const& current_step_size,
+                        SecondOrderODE::State const& state,
+                        SecondOrderODE::State::Error const& error) {
               return tolerance / error.position_error[0].Norm();
             },
             AdaptiveStepSizeIntegrator<SecondOrderODE>::Parameters{
@@ -516,10 +515,9 @@ class WorkErrorGraphGenerator {
             first_order_problem,
             append_first_order_state,
             /*tolerance_to_error_ratio=*/
-            [time_step_index, tolerance, this](
-                Time const& current_step_size,
-                FirstOrderODE::State const& state,
-                FirstOrderODE::State::Error const& error) {
+            [tolerance](Time const& current_step_size,
+                        FirstOrderODE::State const& state,
+                        FirstOrderODE::State::Error const& error) {
               return tolerance / std::get<0>(error).Norm();
             },
             AdaptiveStepSizeIntegrator<FirstOrderODE>::Parameters{

numerics/angle_reduction_body.hpp

@@ -17,7 +17,7 @@ using namespace principia::quantities::_si;
 // A somewhat arbitrary value above which we fail argument reduction.
 // TODO(phl): We *really* need a proper angle reduction.
 double const reduction_threshold =
-    std::numeric_limits<std::int64_t>::max() / 2.0;
+    static_cast<double>(std::numeric_limits<std::int64_t>::max() / 2);
 
 template<>
 inline constexpr Angle one_π<Angle> = π * Radian;

physics/ephemeris_body.hpp

@@ -581,7 +581,6 @@ Ephemeris<Frame>::ComputeGravitationalJerkOnMassiveBody(
     absl::ReaderMutexLock l(&lock_);
     degrees_of_freedom.reserve(bodies_.size());
     for (int b = 0; b < bodies_.size(); ++b) {
-      auto const& current_body = bodies_[b];
       auto const& current_body_trajectory = trajectories_[b];
       degrees_of_freedom.push_back(
           current_body_trajectory->EvaluateDegreesOfFreedomLocked(t));

physics/equipotential_test.cpp

@@ -107,7 +107,7 @@ class EquipotentialTest : public ::testing::Test {
         ComputePositionInWorld(t, reference_frame, body2);
     auto const body2_body1 = body1_position - body2_position;
 
-    auto const& binormal = plane.UnitBinormals().front();
+    auto const binormal = plane.UnitBinormals().front();
     Rotation<World, World> const rot_l4(-60 * Degree, binormal);
     auto const body2_l4 = rot_l4(body2_body1);
     auto const l4 = body2_l4 + body2_position;