diff --git a/include/extractor/edge_based_graph_factory.hpp b/include/extractor/edge_based_graph_factory.hpp
index dd5454f519a..fed9074988d 100644
--- a/include/extractor/edge_based_graph_factory.hpp
+++ b/include/extractor/edge_based_graph_factory.hpp
@@ -44,7 +44,10 @@ struct TurnIndexBlock
     NodeID to_id;
 };
 #pragma pack(pop)
-static_assert(std::is_trivial<TurnIndexBlock>::value, "TurnIndexBlock is not trivial");
+static_assert(std::is_trivially_default_constructible<TurnIndexBlock>::value,
+              "TurnIndexBlock must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<TurnIndexBlock>::value,
+              "TurnIndexBlock must be trivially copyable.");
 static_assert(sizeof(TurnIndexBlock) == 12, "TurnIndexBlock is not packed correctly");
 } // namespace lookup
 
diff --git a/include/util/coordinate.hpp b/include/util/coordinate.hpp
index 3fd66e7b328..9b23c3e1e68 100644
--- a/include/util/coordinate.hpp
+++ b/include/util/coordinate.hpp
@@ -68,30 +68,45 @@ using FloatLongitude = Alias<double, tag::longitude>;
 // range checks on these (toFixed/toFloat, etc)
 using UnsafeFloatLatitude = Alias<double, tag::unsafelatitude>;
 using UnsafeFloatLongitude = Alias<double, tag::unsafelongitude>;
-static_assert(std::is_standard_layout<FixedLatitude>() &&
-                  std::is_trivially_default_constructible<FixedLatitude>() &&
-                  std::is_trivially_copyable<FixedLatitude>(),
-              "FixedLatitude is not a valid alias");
-static_assert(std::is_standard_layout<FixedLongitude>() &&
-                  std::is_trivially_default_constructible<FixedLongitude>() &&
-                  std::is_trivially_copyable<FixedLongitude>(),
-              "FixedLongitude is not a valid alias");
-static_assert(std::is_standard_layout<FloatLatitude>() &&
-                  std::is_trivially_default_constructible<FloatLatitude>() &&
-                  std::is_trivially_copyable<FloatLatitude>(),
-              "FloatLatitude is not a valid alias");
-static_assert(std::is_standard_layout<FloatLongitude>() &&
-                  std::is_trivially_default_constructible<FloatLongitude>() &&
-                  std::is_trivially_copyable<FloatLongitude>(),
-              "FloatLongitude is not a valid alias");
-static_assert(std::is_standard_layout<UnsafeFloatLatitude>() &&
-                  std::is_trivially_default_constructible<UnsafeFloatLatitude>() &&
-                  std::is_trivially_copyable<UnsafeFloatLatitude>(),
-              "UnsafeFloatLatitude is not a valid alias");
-static_assert(std::is_standard_layout<UnsafeFloatLongitude>() &&
-                  std::is_trivially_default_constructible<UnsafeFloatLongitude>() &&
-                  std::is_trivially_copyable<UnsafeFloatLongitude>(),
-              "UnsafeFloatLongitude is not a valid alias");
+static_assert(std::is_standard_layout<FixedLatitude>(), "FixedLatitude must have standard layout.");
+static_assert(std::is_trivially_default_constructible<FixedLatitude>(),
+              "FixedLatitude must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<FixedLatitude>(),
+              "FixedLatitude must be trivially copyable.");
+
+static_assert(std::is_standard_layout<FixedLongitude>(),
+              "FixedLongitude must have standard layout.");
+static_assert(std::is_trivially_default_constructible<FixedLongitude>(),
+              "FixedLongitude must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<FixedLongitude>(),
+              "FixedLongitude must be trivially copyable.");
+
+static_assert(std::is_standard_layout<FloatLatitude>(), "FloatLatitude must have standard layout.");
+static_assert(std::is_trivially_default_constructible<FloatLatitude>(),
+              "FloatLatitude must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<FloatLatitude>(),
+              "FloatLatitude must be trivially copyable.");
+
+static_assert(std::is_standard_layout<FloatLongitude>(),
+              "FloatLongitude must have standard layout.");
+static_assert(std::is_trivially_default_constructible<FloatLongitude>(),
+              "FloatLongitude must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<FloatLongitude>(),
+              "FloatLongitude must be trivially copyable.");
+
+static_assert(std::is_standard_layout<UnsafeFloatLatitude>(),
+              "UnsafeFloatLatitude must have standard layout.");
+static_assert(std::is_trivially_default_constructible<UnsafeFloatLatitude>(),
+              "UnsafeFloatLatitude must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<UnsafeFloatLatitude>(),
+              "UnsafeFloatLatitude must be trivially copyable.");
+
+static_assert(std::is_standard_layout<UnsafeFloatLongitude>(),
+              "UnsafeFloatLongitude must have standard layout.");
+static_assert(std::is_trivially_default_constructible<UnsafeFloatLongitude>(),
+              "UnsafeFloatLongitude must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<UnsafeFloatLongitude>(),
+              "UnsafeFloatLongitude must be trivially copyable.");
 
 /**
  * Converts a typed latitude from floating to fixed representation.
diff --git a/include/util/fingerprint.hpp b/include/util/fingerprint.hpp
index d28264a53a5..8e7ca1e832f 100644
--- a/include/util/fingerprint.hpp
+++ b/include/util/fingerprint.hpp
@@ -32,9 +32,12 @@ struct FingerPrint
 };
 
 static_assert(sizeof(FingerPrint) == 8, "FingerPrint has unexpected size");
-static_assert(std::is_trivial<FingerPrint>::value, "FingerPrint needs to be trivial.");
+static_assert(std::is_trivially_default_constructible<FingerPrint>::value,
+              "FingerPrint needs to be trivially default constructible.");
+static_assert(std::is_trivially_copyable<FingerPrint>::value,
+              "FingerPrint needs to be trivially copyable.");
 static_assert(std::is_standard_layout<FingerPrint>::value,
-              "FingerPrint needs have a standard layout.");
+              "FingerPrint needs to have a standard layout.");
 } // namespace osrm::util
 
 #endif /* FingerPrint_H */
diff --git a/include/util/typedefs.hpp b/include/util/typedefs.hpp
index f03c019ff0c..ab6abc750f7 100644
--- a/include/util/typedefs.hpp
+++ b/include/util/typedefs.hpp
@@ -69,18 +69,16 @@ struct turn_penalty
 } // namespace tag
 
 using OSMNodeID = osrm::Alias<std::uint64_t, tag::osm_node_id>;
-// clang-tidy fires `bugprone-throw-keyword-missing` here for unknown reason
-// NOLINTNEXTLINE(bugprone-throw-keyword-missing)
-static_assert(std::is_standard_layout<OSMNodeID>() &&
-                  std::is_trivially_default_constructible<OSMNodeID>() &&
-                  std::is_trivially_copyable<OSMNodeID>(),
-              "OSMNodeID is not a valid alias");
+static_assert(std::is_standard_layout<OSMNodeID>(), "OSMNodeID must have standard layout.");
+static_assert(std::is_trivially_default_constructible<OSMNodeID>(),
+              "OSMNodeID must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<OSMNodeID>(), "OSMNodeID must be trivially copyable.");
+
 using OSMWayID = osrm::Alias<std::uint64_t, tag::osm_way_id>;
-// NOLINTNEXTLINE(bugprone-throw-keyword-missing)
-static_assert(std::is_standard_layout<OSMWayID>() &&
-                  std::is_trivially_default_constructible<OSMWayID>() &&
-                  std::is_trivially_copyable<OSMWayID>(),
-              "OSMWayID is not a valid alias");
+static_assert(std::is_standard_layout<OSMWayID>(), "OSMWayID must have standard layout.");
+static_assert(std::is_trivially_default_constructible<OSMWayID>(),
+              "OSMWayID must be trivially default constructible.");
+static_assert(std::is_trivially_copyable<OSMWayID>(), "OSMWayID must be trivially copyable.");
 
 using DuplicatedNodeID = std::uint64_t;
 using RestrictionID = std::uint64_t;