Test ill-formedness and add missing constraints on Multivector::Write…

…ToMessage.

geometry/frame_test.cpp

@@ -5,6 +5,7 @@
 #include "google/protobuf/descriptor.h"
 #include "gtest/gtest.h"
 #include "serialization/geometry.pb.h"
+#include "testing_utilities/check_well_formedness.hpp"  // 🧙 For PRINCIPIA_CHECK_ILL_FORMED.
 
 namespace principia {
 namespace geometry {
@@ -13,7 +14,7 @@ using namespace principia::base::_concepts;
 using namespace principia::geometry::_frame;
 
 class FrameTest : public testing::Test {
- protected:
+ public:
   using World1 = Frame<serialization::Frame::TestTag,
                        Inertial,
                        Handedness::Right,
@@ -44,15 +45,15 @@ class FrameTest : public testing::Test {
 
 using FrameDeathTest = FrameTest;
 
-// Uncomment to check that non-serializable frames are detected at compile-time.
-#if 0
-TEST_F(FrameTest, SerializationCompilationError) {
-  serialization::Frame message;
-  F1::ReadFromMessage(&message);
-  F2::ReadFromMessage(&message);
-  F3::ReadFromMessage(&message);
-}
-#endif
+// Check that non-serializable frames are detected at compile-time.
+PRINCIPIA_CHECK_WELL_FORMED(FrameTest::World1::ReadFromMessage(message),
+                            WITH<serialization::Frame> message);
+PRINCIPIA_CHECK_ILL_FORMED(FrameTest::F1::ReadFromMessage(message),
+                           WITH<serialization::Frame> message);
+PRINCIPIA_CHECK_ILL_FORMED(FrameTest::F2::ReadFromMessage(message),
+                           WITH<serialization::Frame> message);
+PRINCIPIA_CHECK_ILL_FORMED(FrameTest::F3::ReadFromMessage(message),
+                           WITH<serialization::Frame> message);
 
 TEST_F(FrameDeathTest, SerializationError) {
   EXPECT_DEATH({

geometry/grassmann.hpp

@@ -59,7 +59,8 @@ class Multivector<Scalar, Frame, 1> final {
       Multivector<S, Frame, 1> const& multivector) const;
 
   void WriteToMessage(
-      not_null<serialization::Multivector*> message) const;
+      not_null<serialization::Multivector*> message) const
+    requires serializable<Frame>;
   static Multivector ReadFromMessage(serialization::Multivector const& message)
     requires serializable<Frame>;
 
@@ -96,7 +97,8 @@ class Multivector<Scalar, Frame, 2> final {
   Multivector OrthogonalizationAgainst(
       Multivector<S, Frame, 2> const& multivector) const;
 
-  void WriteToMessage(not_null<serialization::Multivector*> message) const;
+  void WriteToMessage(not_null<serialization::Multivector*> message) const
+    requires serializable<Frame>;
   static Multivector ReadFromMessage(serialization::Multivector const& message)
     requires serializable<Frame>;
 
@@ -129,7 +131,8 @@ class Multivector<Scalar, Frame, 3> final {
   Scalar Norm() const;
   Square<Scalar> Norm²() const;
 
-  void WriteToMessage(not_null<serialization::Multivector*> message) const;
+  void WriteToMessage(not_null<serialization::Multivector*> message) const
+    requires serializable<Frame>;
   static Multivector ReadFromMessage(serialization::Multivector const& message)
     requires serializable<Frame>;
 

geometry/grassmann_body.hpp

@@ -179,21 +179,24 @@ Multivector<Scalar, Frame, 2>::OrthogonalizationAgainst(
 
 template<quantity Scalar, typename Frame>
 void Multivector<Scalar, Frame, 1>::WriteToMessage(
-      not_null<serialization::Multivector*> const message) const {
+    not_null<serialization::Multivector*> const message) const
+  requires serializable<Frame> {
   Frame::WriteToMessage(message->mutable_frame());
   coordinates_.WriteToMessage(message->mutable_vector());
 }
 
 template<quantity Scalar, typename Frame>
 void Multivector<Scalar, Frame, 2>::WriteToMessage(
-      not_null<serialization::Multivector*> const message) const {
+    not_null<serialization::Multivector*> const message) const
+  requires serializable<Frame> {
   Frame::WriteToMessage(message->mutable_frame());
   coordinates_.WriteToMessage(message->mutable_bivector());
 }
 
 template<quantity Scalar, typename Frame>
 void Multivector<Scalar, Frame, 3>::WriteToMessage(
-      not_null<serialization::Multivector*> const message) const {
+    not_null<serialization::Multivector*> const message) const
+  requires serializable<Frame> {
   Frame::WriteToMessage(message->mutable_frame());
   coordinates_.WriteToMessage(message->mutable_trivector());
 }

geometry/grassmann_test.cpp

@@ -20,6 +20,7 @@
 #include "quantities/uk.hpp"
 #include "testing_utilities/algebra.hpp"
 #include "testing_utilities/almost_equals.hpp"
+#include "testing_utilities/check_well_formedness.hpp"  // 🧙 For PRINCIPIA_CHECK_ILL_FORMED.
 
 namespace principia {
 namespace geometry {
@@ -64,12 +65,13 @@ struct TransparentWedge final {
 };
 
 class GrassmannTest : public testing::Test {
- protected:
+ public:
   using World = Frame<serialization::Frame::TestTag,
                       Inertial,
                       Handedness::Right,
                       serialization::Frame::TEST>;
 
+protected:
   R3Element<Length> const null_displacement_ = {0 * Metre,
                                                 0 * Metre,
                                                 0 * Metre};
@@ -290,15 +292,32 @@ TEST_F(GrassmannTest, Normalize) {
   EXPECT_THAT(Normalize(u), Eq(Trivector<double, World>(-1)));
 }
 
-// Uncomment to check that non-serializable frames are detected at compile-time.
-#if 0
-TEST_F(GrassmannTest, SerializationCompilationError) {
-  using F = Frame<struct FrameTag>;
-  Vector<Length, F> v;
-  serialization::Multivector message;
-  v.WriteToMessage(&message);
-}
-#endif
+// Check that non-serializable frames are detected at compile-time.
+
+using F = Frame<struct FrameTag>;
+
+PRINCIPIA_CHECK_WELL_FORMED(v.WriteToMessage(&message),
+                            WITH<Vector<Length, GrassmannTest::World>> v,
+                            WITH<serialization::Multivector> message);
+PRINCIPIA_CHECK_ILL_FORMED(v.WriteToMessage(&message),
+                           WITH<Vector<Length, F>> v,
+                           WITH<serialization::Multivector> message);
+PRINCIPIA_CHECK_ILL_FORMED(v.WriteToMessage(&message),
+                           WITH<Bivector<Length, F>> v,
+                           WITH<serialization::Multivector> message);
+PRINCIPIA_CHECK_ILL_FORMED(v.WriteToMessage(&message),
+                           WITH<Trivector<Length, F>> v,
+                           WITH<serialization::Multivector> message);
+
+PRINCIPIA_CHECK_WELL_FORMED(
+    (Vector<Length, GrassmannTest::World>::ReadFromMessage(message)),
+    WITH<serialization::Multivector> message);
+PRINCIPIA_CHECK_ILL_FORMED((Vector<Length, F>::ReadFromMessage(message)),
+                           WITH<serialization::Multivector> message);
+PRINCIPIA_CHECK_ILL_FORMED((Bivector<Length, F>::ReadFromMessage(message)),
+                           WITH<serialization::Multivector> message);
+PRINCIPIA_CHECK_ILL_FORMED((Trivector<Length, F>::ReadFromMessage(message)),
+                           WITH<serialization::Multivector> message);
 
 TEST_F(GrassmannDeathTest, SerializationError) {
   using V = Vector<Length, World>;

numerics/polynomial_in_monomial_basis_test.cpp

@@ -16,6 +16,7 @@
 #include "serialization/geometry.pb.h"
 #include "serialization/numerics.pb.h"
 #include "testing_utilities/almost_equals.hpp"
+#include "testing_utilities/check_well_formedness.hpp"  // 🧙 For PRINCIPIA_CHECK_ILL_FORMED.
 #include "testing_utilities/matchers.hpp"
 
 #define PRINCIPIA_USE_IACA 0
@@ -42,7 +43,7 @@ using namespace principia::testing_utilities::_almost_equals;
 using namespace principia::testing_utilities::_matchers;
 
 class PolynomialInMonomialBasisTest : public ::testing::Test {
- protected:
+ public:
   using World = Frame<serialization::Frame::TestTag,
                       Inertial,
                       Handedness::Right,
@@ -53,6 +54,7 @@ class PolynomialInMonomialBasisTest : public ::testing::Test {
   using P2P = PolynomialInMonomialBasis<Position<World>, Instant, 2>;
   using P17 = PolynomialInMonomialBasis<Displacement<World>, Time, 17>;
 
+ protected:
   PolynomialInMonomialBasisTest()
       : coefficients_({
             Displacement<World>({0 * Metre,
@@ -146,13 +148,13 @@ TEST_F(PolynomialInMonomialBasisTest, Evaluate2P) {
   EXPECT_THAT(v, AlmostEquals(Velocity<World>({1 * Metre / Second,
                                                1 * Metre / Second,
                                                0 * Metre / Second}), 0));
-
-  // This doesn't compile (and rightly so).
-#if 0
-  p.Primitive();
-#endif
 }
 
+PRINCIPIA_CHECK_WELL_FORMED(p.Primitive(),
+                            WITH<PolynomialInMonomialBasisTest::P2A> p);
+PRINCIPIA_CHECK_ILL_FORMED(p.Primitive(),
+                           WITH<PolynomialInMonomialBasisTest::P2P> p);
+
 // Check that a polynomial of high order may be declared.
 TEST_F(PolynomialInMonomialBasisTest, Evaluate17) {
   P17::Coefficients const coefficients;