From 4d715734bf3e120c0628d06a432829df003cc7ca Mon Sep 17 00:00:00 2001
From: Jonas Hoppe <162709928+czjhoppe@users.noreply.github.com>
Date: Tue, 3 Sep 2024 11:27:44 +0200
Subject: [PATCH] [msvc][fix] update changes for master

---
 .../mp-units/bits/get_associated_quantity.h   |  4 +--
 .../mp-units/framework/construction_helpers.h |  4 +--
 .../include/mp-units/framework/magnitude.h    |  2 +-
 .../mp-units/framework/quantity_point.h       | 14 +++++------
 .../mp-units/framework/quantity_spec.h        |  8 +++---
 .../include/mp-units/framework/reference.h    |  4 +--
 src/core/include/mp-units/framework/unit.h    |  2 +-
 test/static/chrono_test.cpp                   | 12 ++++-----
 test/static/concepts_test.cpp                 | 25 -------------------
 test/static/quantity_point_test.cpp           | 10 ++++----
 test/static/quantity_test.cpp                 | 12 ++++-----
 11 files changed, 36 insertions(+), 61 deletions(-)

diff --git a/src/core/include/mp-units/bits/get_associated_quantity.h b/src/core/include/mp-units/bits/get_associated_quantity.h
index 881c61e8..d976b17e 100644
--- a/src/core/include/mp-units/bits/get_associated_quantity.h
+++ b/src/core/include/mp-units/bits/get_associated_quantity.h
@@ -76,9 +76,9 @@ template<AssociatedUnit U>
 template<AssociatedUnit U>
 [[nodiscard]] consteval auto get_associated_quantity(U u)
 {
-  constexpr bool all_kinds = all_are_kinds(u);
+  constexpr bool all_kinds = all_are_kinds(U{});
   if constexpr (all_kinds)
-    return kind_of<get_associated_quantity_impl(u)>;
+    return kind_of<get_associated_quantity_impl(U{})>;
   else
     return get_associated_quantity_impl(u);
 }
diff --git a/src/core/include/mp-units/framework/construction_helpers.h b/src/core/include/mp-units/framework/construction_helpers.h
index 6e20ebcc..c0226e47 100644
--- a/src/core/include/mp-units/framework/construction_helpers.h
+++ b/src/core/include/mp-units/framework/construction_helpers.h
@@ -41,7 +41,7 @@ template<Reference R>
 struct delta_ {
   template<typename Rep>
     requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{}).character>
-  [[nodiscard]] constexpr quantity<R{}, std::remove_cvref_t<Rep>> operator()(Rep&& lhs) const
+  [[nodiscard]] constexpr quantity<(R{}), std::remove_cvref_t<Rep>> operator()(Rep&& lhs) const
   {
     return quantity{std::forward<Rep>(lhs), R{}};
   }
@@ -51,7 +51,7 @@ template<Reference R>
 struct absolute_ {
   template<typename Rep>
     requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{}).character>
-  [[nodiscard]] constexpr quantity_point<R{}, default_point_origin(R{}), std::remove_cvref_t<Rep>> operator()(
+  [[nodiscard]] constexpr quantity_point<(R{}), default_point_origin(R{}), std::remove_cvref_t<Rep>> operator()(
     Rep&& lhs) const
   {
     return quantity_point{quantity{std::forward<Rep>(lhs), R{}}};
diff --git a/src/core/include/mp-units/framework/magnitude.h b/src/core/include/mp-units/framework/magnitude.h
index d1632528..9c088c78 100644
--- a/src/core/include/mp-units/framework/magnitude.h
+++ b/src/core/include/mp-units/framework/magnitude.h
@@ -708,7 +708,7 @@ void to_base_specialization_of_magnitude(const volatile magnitude<Ms...>*);
 
 template<typename T>
 inline constexpr bool is_derived_from_specialization_of_magnitude =
-  requires(T* t) { to_base_specialization_of_magnitude(t); };
+  requires(T* type) { to_base_specialization_of_magnitude(type); };
 
 template<typename T>
   requires is_derived_from_specialization_of_magnitude<T>
diff --git a/src/core/include/mp-units/framework/quantity_point.h b/src/core/include/mp-units/framework/quantity_point.h
index 087fc7ab..5b449ea8 100644
--- a/src/core/include/mp-units/framework/quantity_point.h
+++ b/src/core/include/mp-units/framework/quantity_point.h
@@ -54,14 +54,14 @@ template<PointOrigin PO>
 struct point_origin_interface {
   template<PointOrigin PO, Quantity Q>
     requires ReferenceOf<std::remove_const_t<decltype(Q::reference)>, PO::quantity_spec>
-  [[nodiscard]] friend constexpr quantity_point<Q::reference, PO{}, typename Q::rep> operator+(PO, Q&& q)
+  [[nodiscard]] friend constexpr quantity_point<Q::reference, (PO{}), typename Q::rep> operator+(PO, Q&& q)
   {
     return quantity_point{std::forward<Q>(q), PO{}};
   }
 
   template<Quantity Q, PointOrigin PO>
     requires ReferenceOf<std::remove_const_t<decltype(Q::reference)>, PO::quantity_spec>
-  [[nodiscard]] friend constexpr quantity_point<Q::reference, PO{}, typename Q::rep> operator+(Q&& q, PO po)
+  [[nodiscard]] friend constexpr quantity_point<Q::reference, (PO{}), typename Q::rep> operator+(Q&& q, PO po)
   {
     return po + std::forward<Q>(q);
   }
@@ -336,35 +336,35 @@ public:
     requires detail::QuantityConvertibleTo<quantity_type, quantity<reference, ToRep>>
   [[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto in() const
   {
-    return ::mp_units::quantity_point{quantity_ref_from(PO).template in<ToRep>(), PO};
+    return ::mp_units::quantity_point{quantity_ref_from(point_origin).template in<ToRep>(), point_origin};
   }
 
   template<RepresentationOf<quantity_spec.character> ToRep, detail::UnitCompatibleWith<unit, quantity_spec> ToU>
     requires detail::QuantityConvertibleTo<quantity_type, quantity<detail::make_reference(quantity_spec, ToU{}), ToRep>>
   [[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto in(ToU) const
   {
-    return ::mp_units::quantity_point{quantity_ref_from(PO).template in<ToRep>(ToU{}), PO};
+    return ::mp_units::quantity_point{quantity_ref_from(point_origin).template in<ToRep>(ToU{}), point_origin};
   }
 
   template<detail::UnitCompatibleWith<unit, quantity_spec> ToU>
     requires requires(quantity_type q) { value_cast<ToU{}>(q); }
   [[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto force_in(ToU) const
   {
-    return ::mp_units::quantity_point{quantity_ref_from(point_origin).force_in(ToU{}), PO};
+    return ::mp_units::quantity_point{quantity_ref_from(point_origin).force_in(ToU{}), point_origin};
   }
 
   template<RepresentationOf<quantity_spec.character> ToRep>
     requires requires(quantity_type q) { value_cast<ToRep>(q); }
   [[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto force_in() const
   {
-    return ::mp_units::quantity_point{quantity_ref_from(PO).template force_in<ToRep>(), PO};
+    return ::mp_units::quantity_point{quantity_ref_from(point_origin).template force_in<ToRep>(), point_origin};
   }
 
   template<RepresentationOf<quantity_spec.character> ToRep, detail::UnitCompatibleWith<unit, quantity_spec> ToU>
     requires requires(quantity_type q) { value_cast<ToU{}, ToRep>(q); }
   [[nodiscard]] constexpr QuantityPointOf<quantity_spec> auto force_in(ToU) const
   {
-    return ::mp_units::quantity_point{quantity_ref_from(PO).template force_in<ToRep>(ToU{}), point_origin};
+    return ::mp_units::quantity_point{quantity_ref_from(point_origin).template force_in<ToRep>(ToU{}), point_origin};
   }
 
   // conversion operators
diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h
index 9be678b9..51b497e0 100644
--- a/src/core/include/mp-units/framework/quantity_spec.h
+++ b/src/core/include/mp-units/framework/quantity_spec.h
@@ -673,9 +673,9 @@ template<QuantitySpec Q>
 template<Dimension D1, Dimension D2>
 [[nodiscard]] consteval bool ingredients_dimension_less(D1 lhs, D2 rhs)
 {
-  if constexpr (lhs == rhs || lhs == dimension_one)
+  if constexpr (D1{} == D2{} || D1{} == dimension_one)
     return false;
-  else if constexpr (rhs == dimension_one)
+  else if constexpr (D2{} == dimension_one)
     return true;
   else
     return detail::type_name<D1>() < detail::type_name<D2>();
@@ -1496,9 +1496,9 @@ template<QuantitySpec Q>
 MP_UNITS_EXPORT_BEGIN
 
 template<QuantitySpec Q>
-[[nodiscard]] consteval detail::QuantityKindSpec auto get_kind(Q)
+[[nodiscard]] consteval detail::QuantityKindSpec auto get_kind(Q q)
 {
-  return kind_of<detail::get_kind_tree_root(Q{})>;
+  return kind_of<detail::get_kind_tree_root(decltype(q){})>;
 }
 
 [[nodiscard]] consteval QuantitySpec auto common_quantity_spec(QuantitySpec auto q) { return q; }
diff --git a/src/core/include/mp-units/framework/reference.h b/src/core/include/mp-units/framework/reference.h
index 9bb6b15d..35f646ee 100644
--- a/src/core/include/mp-units/framework/reference.h
+++ b/src/core/include/mp-units/framework/reference.h
@@ -288,9 +288,9 @@ template<Reference R1, Reference R2, Reference... Rest>
     } -> Unit;
   }
 {
-  return detail::reference_t<common_quantity_spec(get_quantity_spec(r1), get_quantity_spec(r2),
+  return detail::reference_t<common_quantity_spec(get_quantity_spec(R1{}), get_quantity_spec(R2{}),
                                                   get_quantity_spec(rest)...),
-                             common_unit(get_unit(r1), get_unit(r2), get_unit(rest)...)>{};
+                             common_unit(get_unit(R1{}), get_unit(R2{}), get_unit(rest)...)>{};
 }
 
 MP_UNITS_EXPORT_END
diff --git a/src/core/include/mp-units/framework/unit.h b/src/core/include/mp-units/framework/unit.h
index f6a52e4f..b00d4792 100644
--- a/src/core/include/mp-units/framework/unit.h
+++ b/src/core/include/mp-units/framework/unit.h
@@ -633,7 +633,7 @@ template<Unit From, Unit To>
 
 template<Unit U1, Unit U2>
 [[nodiscard]] consteval Unit auto common_unit(U1 u1, U2 u2)
-  requires(convertible(u1, u2))
+  requires(convertible(U1{}, U2{}))
 {
   if constexpr (is_same_v<U1, U2>)
     return u1;
diff --git a/test/static/chrono_test.cpp b/test/static/chrono_test.cpp
index a3a0d489..c4b03cd9 100644
--- a/test/static/chrono_test.cpp
+++ b/test/static/chrono_test.cpp
@@ -107,13 +107,13 @@ static_assert(is_of_type<quantity_point{sys_days{sys_days::duration{1}}},
 
 // conversion to chrono
 static_assert(
-  std::constructible_from<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
-static_assert(std::convertible_to<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
-static_assert(std::constructible_from<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
-static_assert(std::convertible_to<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
+  std::constructible_from<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
+static_assert(std::convertible_to<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
+static_assert(std::constructible_from<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
+static_assert(std::convertible_to<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
 static_assert(
-  std::constructible_from<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
-static_assert(std::convertible_to<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
+  std::constructible_from<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
+static_assert(std::convertible_to<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
 
 // units mapping
 static_assert(quantity{1ns} == 1 * ns);
diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp
index a419d8d4..52a1f96a 100644
--- a/test/static/concepts_test.cpp
+++ b/test/static/concepts_test.cpp
@@ -155,31 +155,6 @@ static_assert(!Unit<int>);
 static_assert(!Unit<std::chrono::seconds>);
 #endif
 
-// NamedUnit
-static_assert(detail::NamedUnit<struct si::metre>);
-static_assert(detail::NamedUnit<struct natural::electronvolt>);
-static_assert(!detail::NamedUnit<decltype(si::kilogram)>);
-static_assert(!detail::NamedUnit<decltype((si::kilo<(si::gram)>))>);
-static_assert(!detail::NamedUnit<decltype(si::metre / si::second)>);
-static_assert(!detail::NamedUnit<decltype(inverse(si::second))>);
-static_assert(!detail::NamedUnit<decltype(mag<10> * si::second)>);
-static_assert(!detail::NamedUnit<decltype(square(si::metre))>);
-static_assert(!detail::NamedUnit<decltype(pow<2>(si::metre))>);
-static_assert(detail::NamedUnit<struct si::standard_gravity>);
-static_assert(!detail::NamedUnit<scaled_unit<mag<10>, struct si::second>>);
-static_assert(!detail::NamedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
-static_assert(!detail::NamedUnit<struct one>);
-static_assert(!detail::NamedUnit<named_unit<"?", kind_of<(isq::length)>>>);
-static_assert(!detail::NamedUnit<named_unit<"?">>);
-static_assert(!detail::NamedUnit<named_unit<"?", si::metre / si::second>>);
-static_assert(!detail::NamedUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
-static_assert(!detail::NamedUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
-static_assert(!detail::NamedUnit<struct isq::dim_length>);
-static_assert(!detail::NamedUnit<int>);
-#if MP_UNITS_HOSTED
-static_assert(!detail::NamedUnit<std::chrono::seconds>);
-#endif
-
 // PrefixableUnit
 static_assert(PrefixableUnit<struct si::metre>);
 static_assert(PrefixableUnit<struct natural::electronvolt>);
diff --git a/test/static/quantity_point_test.cpp b/test/static/quantity_point_test.cpp
index 5bfa7055..fafbcb65 100644
--- a/test/static/quantity_point_test.cpp
+++ b/test/static/quantity_point_test.cpp
@@ -1131,12 +1131,12 @@ concept invalid_binary_operations = requires {
   requires !requires { Origin - Origin; };
 
   // unit constants
-  requires !requires { QP<si::metre, mean_sea_level, int>(1) + m; };
-  requires !requires { QP<si::metre, mean_sea_level, int>(1) - m; };
+  requires !requires { QP<(si::metre), mean_sea_level, int>(1) + m; };
+  requires !requires { QP<(si::metre), mean_sea_level, int>(1) - m; };
   requires !requires { Origin + m; };
   requires !requires { Origin - m; };
-  requires !requires { m + QP<si::metre, mean_sea_level, int>(1); };
-  requires !requires { m - QP<si::metre, mean_sea_level, int>(1); };
+  requires !requires { m + QP<(si::metre), mean_sea_level, int>(1); };
+  requires !requires { m - QP<(si::metre), mean_sea_level, int>(1); };
   requires !requires { m + Origin; };
   requires !requires { m - Origin; };
 };
@@ -1717,7 +1717,7 @@ static_assert(value_cast<m>(quantity_point{2 * km}).quantity_from_zero().numeric
 static_assert(value_cast<km>(quantity_point{2000 * m}).quantity_from_zero().numerical_value_in(km) == 2);
 static_assert(value_cast<int>(quantity_point{1.23 * m}).quantity_from_zero().numerical_value_in(m) == 1);
 static_assert(
-  value_cast<km / h>(quantity_point{2000.0 * m / (3600.0 * s)}).quantity_from_zero().numerical_value_in(km / h) == 2);
+  value_cast<(km / h)>(quantity_point{2000.0 * m / (3600.0 * s)}).quantity_from_zero().numerical_value_in(km / h) == 2);
 // lvalue references in value_cast
 namespace lvalue_tests {
 constexpr quantity_point lvalue_qp{2 * km};
diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp
index 3beeea07..6cd56773 100644
--- a/test/static/quantity_test.cpp
+++ b/test/static/quantity_test.cpp
@@ -215,16 +215,16 @@ static_assert(quantity<isq::length[km]>(1500 * m).numerical_value_in(km) == 1.5)
 
 static_assert(!std::convertible_to<quantity<one>, double>);
 static_assert(std::constructible_from<double, quantity<one>>);
-static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, double>);
-static_assert(std::constructible_from<double, quantity<isq::angular_measure[one]>>);
+static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, double>);
+static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one])>>);
 static_assert(!std::convertible_to<quantity<one>, int>);
 static_assert(std::constructible_from<int, quantity<one>>);
-static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, int>);
-static_assert(std::constructible_from<int, quantity<isq::angular_measure[one]>>);
+static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, int>);
+static_assert(std::constructible_from<int, quantity<(isq::angular_measure[one])>>);
 static_assert(!std::convertible_to<quantity<one, int>, double>);
 static_assert(std::constructible_from<double, quantity<one, int>>);
-static_assert(!std::convertible_to<quantity<isq::angular_measure[one], int>, double>);
-static_assert(std::constructible_from<double, quantity<isq::angular_measure[one], int>>);
+static_assert(!std::convertible_to<quantity<(isq::angular_measure[one]), int>, double>);
+static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one]), int>>);
 
 
 ///////////////////////////////////