[libc++] [C++20] [P0415] Constexpr for std::complex.

[philnik]

Summary

This patch adds constexpr to <complex> header: operators, member operators, and member functions (real, imag, norm, conj).

https://eel.is/c++draft/complex.numbers
https://wg21.link/p0415

[ldionne]

Nice! Are you looking for a review now, or it's just a WIP patch? Ideally you'd fix the TODOs you already noted before we take a look, unless you have specific questions/concerns.

[ldionne]

(Requesting changes so it shows up properly in my review queue)

[curdeius]

@ldionne, I'd appreciate if you (or somebody else) could tell me what you think about the way I test the constexpr. I wanted to avoid duplication but on a second thought, I think that run-time tests can actually go through compile-time (constexpr) branch and so leave the non-constexpr branch untested.
Another thing in which I'd need guidance is how to test the primary implementation (not specializations for float, double, long double). Is there another floating-point type I can use in tests? Maybe some sort of short float?
Oh, and should integral types be tested with complex<T>?

[ldionne]

In D79555#2025500, @curdeius wrote:

@ldionne, I'd appreciate if you (or somebody else) could tell me what you think about the way I test the constexpr. I wanted to avoid duplication but on a second thought, I think that run-time tests can actually go through compile-time (constexpr) branch and so leave the non-constexpr branch untested.

I think it's fine -- avoiding duplication is pretty important IMO. I don't think the compiler will try to evaluate this using the constexpr evaluator if it's not marked as constexpr. If we wanted to be really really sure, we could also make sure the values we use in the test are thought to be potentially-runtime by calling a function defined in a different TU. That would be somewhat more complicated, but imagine the following setup:

// in support.cpp
template <typename T>
T identity(T t) { return t; }

template int identity(int);
template float identity(float);
// etc...

Then, let's say you have a test that is potentially constexpr like this:

template <class T>
TEST_CONSTEXPR_CXX20 bool test(T zero) {
    T lhs(1.5 + zero);
    std::complex<T> rhs(3.5 + zero, 4.5);
    std::complex<T>   x(5.0 + zero, 4.5);
    test(lhs, rhs, x);
}

You could now call it once at runtime and once at compile-time:

int main(int argc, char** argv) {
    test<float>(identity<float>(0)); // runtime test
    static_assert(test<float>(0)); // compile-time test
}

Since identity is defined in a different TU, the compiler would really have to generate code for the runtime tests. There's a few different ways to do this, another way I can think of is to piggy back on argc or just a (volatile?) global variable. But the idea is the same. If there's interest, we can look into setting this up more widely for amphibious (constexpr/not constexpr) tests.

Another thing in which I'd need guidance is how to test the primary implementation (not specializations for float, double, long double). Is there another floating-point type I can use in tests? Maybe some sort of short float?

I'm seeing this on cppreference:

The specializations std::complex<float>, std::complex<double>, and std::complex<long double> are LiteralTypes for representing and manipulating complex numbers. The effect of instantiating the template complex for any other type is unspecified.

I don't think we test other specializations in our other complex tests, do we? If not, I'd say it's OK to not test it... Maybe I'm not being imaginative enough?

Oh, and should integral types be tested with complex<T>?

Like I said above, I don't think so. Please LMK if you disagree.

What *does* need to be tested however is the interaction between std::complex<T> and U where T in {float, double, long double} and U is an integral type. But you seem to be testing this correct (e.g. in conj.pass.cpp).

libcxx/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp

34

Nit: this spacing seems to have changed?

[curdeius]

Fix edge cases. Fix operator* and operator/.
Use "shortcuts" to avoid NaN in constexpr evaluation (disallowed).

One remaining problem.
2 tests:

• complex_divides_complex.pass.cpp
• complex_times_complex.pass.cpp

do not pass on clang unless additional parameter --param=compile_flags='-fconstexpr-steps=4000000' is given.
That's because they test all the edge cases and each pair thereof and clang has too low a limit for the maximum number of constexpr execution steps.
I thought about splitting these tests somehow but given their (combinatoric) nature, it's pretty awkward.

I don't know how I should pass this compile flag only for these tests and only for clang (I know of ADDITIONAL_COMPILE_FLAGS but I cannot exclude gcc with that).

TODO:

• Test (at least locally) a different floating-point type (e.g. float128) to catch missing constexpr markers in the default implementation (non-specialization).

[curdeius]

Fix diff.

[curdeius]

• Revert unrelated changes in cases.h.

[curdeius]

• Add missing constexpr on generic implementation.
• Add missing static asserts in tests.

[curdeius]

• Bump version in status.

[curdeius]

• Fix pre-C++20 modes. Ugly duplication :/.

[curdeius]

• Clean up.

[curdeius]

I've tested the non-specialization with __float128 and fixed missing constexpr there. The tests mainly pass apart from those testing operators * and / that use copysign which is ambiguous (already in non-constexpr context so I didn't pursue it any further). It's implementation-specific anyway.

[ldionne]

Can you please ping once you think this is ready to review? For now, I'll "request changes" so it shows up correctly in the review queue.

[curdeius]

• Hack to add a compile flag only to clang.
• Rebase

[curdeius]

• Fix apple-clang.
• Add header guards.

[curdeius]

@ldionne, it's ready for review (at least the first glance).

[ldionne]

Can you rebase onto main so that CI runs again? You'll also need to fix a few details like the cxx2a_status page which has changed.

libcxx/include/complex

921

I think we really need to unfork these implementations and use the same one in all standard modes. It looks like the only difference is pretty much that you're calling the _constexpr variations when is_constant_evaluated() in the C++20 version. Would it be possible to always call e.g. __libcpp_scalbn, and then have that function check for is_constant_evaluated() and use a constexpr-friendly implementation in that case?

[curdeius]

• Use __libcpp_is_constant_evaluated in *_constexpr helper functions.
• Update status page and feature test macros.
• Rebase.

[curdeius]

• Fix pre-C++14 builds.

[curdeius]

libcxx/include/complex

586–615

I guess I need to do the same #if dance as below, so as not to change the current runtime behaviour.

601

Oops. Should be __builtin_copysign (without l).

820

Oops. Will remove in next update.

921

Done. The solution is IMO still a bit ugly (with those #ifdefs), but it's much better than before.
Thanks for the suggestion.

[curdeius]

• Small fixes.

[curdeius]

• Revert whitespace changes.

[curdeius]

Ping.

• Rebase.
• Revert whitespace changes.

[• Quuxplusone]

libcxx/include/complex

237–238

I think numeric_limits gives you the best chance of making things work generically with non-base-2 types (not that such things exist).
I've been starting to comment #include lines with the stuff we need them for; although I admit in this case it's pretty obvious what <limits> is always needed for ;)

601

The l is still there.

612

Here _LIBCPP_CONSTEXPR_AFTER_CXX17 can be just constexpr, because this code is enabled only when _LIBCPP_STD_VER > 17.

724

IIUC these two operator* implementations are identical except that the C++20 one has an extra block under __libcpp_is_constant_evaluated, and then also replaces copysign with __copysign_constexpr even outside that block.
Would it be possible to combine the operator* implementations through judicious use of #if (for the first diff) and #define _LIBCPP_COMPLEX_COPYSIGN __copysign_constexpr (for the second diff)?

(Also, my ADL senses are on high alert through this entire function, but I guess we expect _Tp always to be a primitive type, so ADL doesn't matter here.)

862

Above you used _Tp(0) for zero. I think _Tp(0) is clearer than _Tp{}, and you should use _Tp(0) down here too.

921

Whatever you did to "unfork" the implementations seems maybe to have been lost between February and late-March. I still see two largely identical implementations of operator/ here (like the two operator*s above).

libcxx/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp

30

These three helper functions can stay returning void; only the test on line 55 needs to return bool.
(I do wish the helpers weren't named the same name as the top-level test.)
This comment applies to many of these test files.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333519)

The existing tests that use ADDITIONAL_COMPILE_FLAGS do it like this:

// REQUIRES: -faligned-allocation
// ADDITIONAL_COMPILE_FLAGS: -faligned-allocation

Could we do something similar here?

I also question the "hpp"-ness of complex_divide_complex.pass.hpp. It certainly shouldn't have a header guard against multiple inclusion; but I don't think its filename should involve either "hpp" (it's not a header) nor ".pass." (the filename isn't intended for parsing by the test runner).
Of course those naming issues all disappear if you are able to do REQUIRES: -fconstexpr-steps=4500000 here.

And of course that issue will disappear if you can figure out how to squeeze some extra "cycles" out of the constexpr algorithm and/or test case. See below.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.hpp

35–36 ↗

(On Diff #333519)

Incidentally, this is a very silly series of (pre-existing) helper functions. I think you could take this suggested edit and then delete lines 24-30.

This comment applies to many of these tests.

49 ↗

(On Diff #333519)

I wonder whether the repeated calculation of classify is driving up your constexpr "cycle count"; maybe it could make sense to put at the top of this function

int classification[N];
for (unsigned i=0; i < N; ++i)
  classification[i] = classify(testcases[i]);

You're still doing O(N^2) divisions, though, which is probably the more salient problem, and harder to work around. :P

libcxx/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp

28

This entire test could be

assert(+std::complex<T>(1.5, -2.5) == std::complex<T>(1.5, -2.5));
assert(+std::complex<T>(-1.5, 2.5) == std::complex<T>(-1.5, 2.5));
return true;

and ta-da, we've more than doubled our test coverage. :P

[curdeius]

There's something fishy with my rebase.

[curdeius]

Fix rebase. Apply some review comments.

• Revert whitespace changes.
• Use numeric_limits.
• Use _Tp(0).

[curdeius]

• Simplify tests (mainly helper functions).

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333519)

Using REQUIRES as you suggest would disable the tests for gcc... And I'm not sure we want this.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.hpp

49 ↗

(On Diff #333519)

Yeah, computing the result of classify once does drive the count down... it's almost ok for the multiplication (1.7M and the default clang's limit is 1M).
But it's still at 3.5M for the division.

I'm all ears if anyone has an idea how to remove this ugly .hpp hack (which only purpose is to pass -fconstexpr-steps=N to clang, and to clang only).
What I'd like is to do something like ADDITIONAL_COMPILE_FLAGS: (apple-clang || clang) -fconstexpr-steps=N or whatever else that does this.
I've tried different lit magic, but to no avail.

[• Quuxplusone]

Looks like your new rebase succeeded in preserving the "unforked" implementations of operator* and operator/. They LGTM code-wise now.
No comment on the math part. It seems like complex_times_complex.pass.cpp does a pretty thorough job of testing its behavior, though, so I trust it.

libcxx/include/complex

853

My impression is that you don't need these dangling elses (lines 739, 750, 777) for any C++ reason (like, the else on line 739 is not saving you from having to resolve and instantiate fmax on line 741). Do they improve codegen? If not, I say eliminate them — splitting unbraced control-flow structures across #if/#endif in this way is not-good. (Consider what happens if you replace line 741 with two lines of code, for example.)

[curdeius]

• Get rid of dangling "else"s.

libcxx/include/complex

853

Good catch. Eliminated.

[curdeius]

libcxx/include/complex

724

Concerning ADL, it's unspecified by the standard what happens if _Tp is other than float, double, long double. Even less if it's a non-primitive type :).

[curdeius]

Friendly ping.

[danilaml]

ping?

[ldionne]

Sorry for sitting on this for so long. Let's push this through now.

libcxx/include/complex

586

We already jump through some hoops in <math.h> to provide copysign. Would it make sense to try and unify those in some way? Maybe create a __copysign function that is constexpr whenever it can be, and then call that from copysign. Here, we'd call __copysign directly, which has the right constexpr-ness. WDYT? I'm trying to avoid proliferating helper functions that might be useful elsewhere in just this header, since it means we'll reinvent the wheel in the future eventually.

Also, I don't understand why we're guarding the use of the builtin on _LIBCPP_STD_VER and not __has_builtin.

Same comment applies to other general functions below like fabs & friends. I think it may be a good idea to tackle those as a separate patch, then this patch would be a lot simpler.

771

I think we can remove the #if _LIBCPP_STD_VER > 17 check here. In C++ <= 17, __libcpp_is_constant_evaluated() will just return false, so this if will never be entered (but it still needs to parse).

Also, I believe a comment saying something like "catch all corner cases that would otherwise cause invalid operations if evaluated in a constant expression" wouldn't hurt. This applies here and everywhere else where the same pattern appears.

libcxx/test/std/numerics/complex.number/cases.h

182

We can't use builtins like that in the tests unless we know all supported compilers do support that builtin. Is it the case?

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

I'm quite worried by the need to add this. It means that if we somehow went crazy in the implementation and used a huge number of steps to implement the functionality, we wouldn't catch it with the tests. I'd like to suggest something like this to remove the need to pass -fconstexpr-steps:

// Helper to avoid blowing the number of steps in constexpr
template <typename F>
TEST_CONSTEXPR void chunk(std::size_t N, F f) {
  for (std::size_t i = (N/5) * 0; i != (N/5) * 1; ++i) f(i);
  for (std::size_t i = (N/5) * 1; i != (N/5) * 2; ++i) f(i);
  for (std::size_t i = (N/5) * 2; i != (N/5) * 3; ++i) f(i);
  for (std::size_t i = (N/5) * 3; i != (N/5) * 4; ++i) f(i);
  for (std::size_t i = (N/5) * 4; i != N;         ++i) f(i);
}

This is just an idea, and it's untested code, but basically I think we could add a generic helper to help us chunk large ranges into several for loops instead of one giant loop. Then we'd use it something like

TEST_CONSTEXPR_CXX20
bool test_edges() {
  const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
  int classification[N];
  for (unsigned i=0; i < N; ++i)
    classification[i] = classify(testcases[i]);

  chunk(N, [](int i) {
    for (int j = 0; j != N; ++j) {
      std::complex<double> r = testcases[i] / testcases[j];
      switch (classification[i]) {
        ...
      };
    }
  });
}

[curdeius]

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

I'm not sure I understand what you propose.
The fact that we go over the max. constexpr steps, is because of static_assert(test_edges());.
Which is a single constexpr expression to compute.
And so, even splitting up testcases to 20 pieces still hits the limit on clang (obviously with the default constexpr-steps limit).
It has as well a disadvantage of reducing the test coverage.

On the other hand, I agree that all this file splitting is a burden.
Would it be doable to have sth like // ADDITIONAL_COMPILE_FLAGS_IF_SUPPORTED: -fconstexpr-steps=3500000?

[ldionne]

libcxx/docs/Cxx2aStatusPaperStatus.csv

8 ↗

(On Diff #333776)

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

Hmmmmm, yeah, I guess my suggestion was quite silly in retrospect. I didn't realize the constexpr step limit was on the overall constexpr evaluation, but that's the only thing that makes sense now that I think of it. Let's take this discussion to D106798.

[philnik]

Commandeering to finish this, since it's been laying around for over a year and it seems like it's almost finished.

libcxx/include/complex

586

We already jump through some hoops in <math.h> to provide copysign. Would it make sense to try and unify those in some way? Maybe create a __copysign function that is constexpr whenever it can be, and then call that from copysign. Here, we'd call __copysign directly, which has the right constexpr-ness. WDYT? I'm trying to avoid proliferating helper functions that might be useful elsewhere in just this header, since it means we'll reinvent the wheel in the future eventually.

Also, I don't understand why we're guarding the use of the builtin on _LIBCPP_STD_VER and not __has_builtin.

Same comment applies to other general functions below like fabs & friends. I think it may be a good idea to tackle those as a separate patch, then this patch would be a lot simpler.

[philnik]

• Rebase
• Address comments

libcxx/include/complex

586

I think with the refactoring of math.h this comment doesn't apply anymore.

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.clang.pass.cpp

11 ↗

(On Diff #333776)

Doesn't apply anymore, since we have mechanisms for increasing constexpr execution limits now.

[philnik]

Remove old status paper

[ldionne]

LGTM w/ green CI and assuming the answer to my question is "yes" (i.e. you didn't slip a change to the non-constexpr code path).

libcxx/include/complex

1061–1075

Can you confirm that this is the old implementation, we only changed calls to foo to __constexpr_foo?

[philnik]

Try to fix CI

libcxx/include/complex

1061–1075

Yes.

[philnik]

Next try

[philnik]

Try to fix CI

[philnik]

Try to work around windows bugs

[philnik]

Replace INFINITY with numeric_limits<_Tp>::infinity()

[philnik]

Replace INFINITY and NAN in more places

[jdoerfert]

FWIW, this broke the CUDA buildbots: https://lab.llvm.org/buildbot/#/builders/1/builds/41521

Tag: @tra

[philnik]

In D79555#4038864, @jdoerfert wrote:

FWIW, this broke the CUDA buildbots: https://lab.llvm.org/buildbot/#/builders/1/builds/41521

Tag: @tra

That looks to me like a problem with the cuda wrappers, given that we don't support cuda and we don't have any __host__ or __device__ tags.

[ldionne]

Thanks for the heads up @jdoerfert.

It looks like Clang-cuda is re-defining <complex> in clang/lib/Headers/cuda_wrappers/complex. I'm not sure how that works but that is likely the issue. I'd wait to hear back from the Clang-cuda folks what they think the exact issue is before considering a revert, since it really seems to me like libc++ isn't doing anything wrong.

[tra]

In D79555#4040527, @ldionne wrote:

Thanks for the heads up @jdoerfert.

It looks like Clang-cuda is re-defining <complex> in clang/lib/Headers/cuda_wrappers/complex. I'm not sure how that works but that is likely the issue. I'd wait to hear back from the Clang-cuda folks what they think the exact issue is before considering a revert, since it really seems to me like libc++ isn't doing anything wrong.

I'm aware of the broken bots, just didn't get a chance to deal with them yet.

It's not a libc++ problem, so I don't think we need to revert.

CUDA headers need to grow additional magic to make new libc++ code work on the GPU side. It's unfortunate that we need to play catch up here, but short of introducing CUDA support to libc++ itself, there's not much else we can do.

I'm a bit puzzled why things didn't work, though, as normally CUDA compilation should've treated constexpr functions as __host__ __device__, and should've allowed __constexpr_fmax() etc... It's possible that we may have triggered yet another new corner case.

[tra]

Something like https://reviews.llvm.org/D141555 should unbreak CUDA. It can probably get reduced a bit, as we may not have sufficiently functional builtins on the GPU, so it's still a WIP.

I can't say that I like copy/pasting libc++ code into clang headers. I think it would be great if we could directly add necessary attributes to specific functions when libc++ headers are compiled as CUDA.

libcxx/include/cmath

740 ↗

(On Diff #487181)

Nit: this should be // !__has_constexpr_builtin(__builtin_logb)

781 ↗

(On Diff #487181)

Nit: // !has_constexpr_builtin(builtin_scalbln)

[philnik]

In D79555#4045429, @tra wrote:

CUDA headers need to grow additional magic to make new libc++ code work on the GPU side. It's unfortunate that we need to play catch up here, but short of introducing CUDA support to libc++ itself, there's not much else we can do.

If you're interested in doing that you can post an RFC and tell us what would be required for that.

Closing this, since it doesn't seem to be a libc++ problem.

libcxx/include/cmath

781 ↗

(On Diff #487181)

Thanks! Fixed in 5d9ef6ec3f13e9ca865b25c3e068f2846ff71fa1.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_bind_front``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bit_cast``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            *unimplemented*
     ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_complex``                   ``201711L``      
+    ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_dynamic_alloc``             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_misc``                      *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_utility``                   ``201811L``
     ------------------------------------------------- -----------------

libcxx/include/complex

public:
 
     complex(const T& re = T(), const T& im = T()); // constexpr in C++14
     complex(const complex&);  // constexpr in C++14
     template<class X> complex(const complex<X>&);  // constexpr in C++14
 
     T real() const; // constexpr in C++14
     T imag() const; // constexpr in C++14
 
-    void real(T);
-    void imag(T);
+    void real(T); // constexpr in C++20
+    void imag(T); // constexpr in C++20
 
-    complex<T>& operator= (const T&);
-    complex<T>& operator+=(const T&);
-    complex<T>& operator-=(const T&);
-    complex<T>& operator*=(const T&);
-    complex<T>& operator/=(const T&);
-
-    complex& operator=(const complex&);
-    template<class X> complex<T>& operator= (const complex<X>&);
-    template<class X> complex<T>& operator+=(const complex<X>&);
-    template<class X> complex<T>& operator-=(const complex<X>&);
-    template<class X> complex<T>& operator*=(const complex<X>&);
-    template<class X> complex<T>& operator/=(const complex<X>&);
+    complex<T>& operator= (const T&); // constexpr in C++20
+    complex<T>& operator+=(const T&); // constexpr in C++20
+    complex<T>& operator-=(const T&); // constexpr in C++20
+    complex<T>& operator*=(const T&); // constexpr in C++20
+    complex<T>& operator/=(const T&); // constexpr in C++20
+
+    complex& operator=(const complex&); // constexpr in C++20
+    template<class X> complex<T>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<T>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 template<>
 class complex<float>
 {
 public:
     typedef float value_type;
 
     constexpr complex(float re = 0.0f, float im = 0.0f);
     explicit constexpr complex(const complex<double>&);
     explicit constexpr complex(const complex<long double>&);
 
     constexpr float real() const;
-    void real(float);
+    void real(float); // constexpr in C++20
     constexpr float imag() const;
-    void imag(float);
+    void imag(float); // constexpr in C++20
 
-    complex<float>& operator= (float);
-    complex<float>& operator+=(float);
-    complex<float>& operator-=(float);
-    complex<float>& operator*=(float);
-    complex<float>& operator/=(float);
-
-    complex<float>& operator=(const complex<float>&);
-    template<class X> complex<float>& operator= (const complex<X>&);
-    template<class X> complex<float>& operator+=(const complex<X>&);
-    template<class X> complex<float>& operator-=(const complex<X>&);
-    template<class X> complex<float>& operator*=(const complex<X>&);
-    template<class X> complex<float>& operator/=(const complex<X>&);
+    complex<float>& operator= (float); // constexpr in C++20
+    complex<float>& operator+=(float); // constexpr in C++20
+    complex<float>& operator-=(float); // constexpr in C++20
+    complex<float>& operator*=(float); // constexpr in C++20
+    complex<float>& operator/=(float); // constexpr in C++20
+
+    complex<float>& operator=(const complex<float>&); // constexpr in C++20
+    template<class X> complex<float>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<float>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 template<>
 class complex<double>
 {
 public:
     typedef double value_type;
 
     constexpr complex(double re = 0.0, double im = 0.0);
     constexpr complex(const complex<float>&);
     explicit constexpr complex(const complex<long double>&);
 
     constexpr double real() const;
-    void real(double);
+    void real(double); // constexpr in C++20
     constexpr double imag() const;
-    void imag(double);
+    void imag(double); // constexpr in C++20
 
-    complex<double>& operator= (double);
-    complex<double>& operator+=(double);
-    complex<double>& operator-=(double);
-    complex<double>& operator*=(double);
-    complex<double>& operator/=(double);
-    complex<double>& operator=(const complex<double>&);
-
-    template<class X> complex<double>& operator= (const complex<X>&);
-    template<class X> complex<double>& operator+=(const complex<X>&);
-    template<class X> complex<double>& operator-=(const complex<X>&);
-    template<class X> complex<double>& operator*=(const complex<X>&);
-    template<class X> complex<double>& operator/=(const complex<X>&);
+    complex<double>& operator= (double); // constexpr in C++20
+    complex<double>& operator+=(double); // constexpr in C++20
+    complex<double>& operator-=(double); // constexpr in C++20
+    complex<double>& operator*=(double); // constexpr in C++20
+    complex<double>& operator/=(double); // constexpr in C++20
+    complex<double>& operator=(const complex<double>&); // constexpr in C++20
+
+    template<class X> complex<double>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<double>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 template<>
 class complex<long double>
 {
 public:
     typedef long double value_type;
 
     constexpr complex(long double re = 0.0L, long double im = 0.0L);
     constexpr complex(const complex<float>&);
     constexpr complex(const complex<double>&);
 
     constexpr long double real() const;
-    void real(long double);
+    void real(long double); // constexpr in C++20
     constexpr long double imag() const;
-    void imag(long double);
+    void imag(long double); // constexpr in C++20
 
-    complex<long double>& operator=(const complex<long double>&);
-    complex<long double>& operator= (long double);
-    complex<long double>& operator+=(long double);
-    complex<long double>& operator-=(long double);
-    complex<long double>& operator*=(long double);
-    complex<long double>& operator/=(long double);
-
-    template<class X> complex<long double>& operator= (const complex<X>&);
-    template<class X> complex<long double>& operator+=(const complex<X>&);
-    template<class X> complex<long double>& operator-=(const complex<X>&);
-    template<class X> complex<long double>& operator*=(const complex<X>&);
-    template<class X> complex<long double>& operator/=(const complex<X>&);
+    complex<long double>& operator=(const complex<long double>&); // constexpr in C++20
+    complex<long double>& operator= (long double); // constexpr in C++20
+    complex<long double>& operator+=(long double); // constexpr in C++20
+    complex<long double>& operator-=(long double); // constexpr in C++20
+    complex<long double>& operator*=(long double); // constexpr in C++20
+    complex<long double>& operator/=(long double); // constexpr in C++20
+
+    template<class X> complex<long double>& operator= (const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator+=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator-=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator*=(const complex<X>&); // constexpr in C++20
+    template<class X> complex<long double>& operator/=(const complex<X>&); // constexpr in C++20
 };
 
 // 26.3.6 operators:
-template<class T> complex<T> operator+(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator+(const complex<T>&, const T&);
-template<class T> complex<T> operator+(const T&, const complex<T>&);
-template<class T> complex<T> operator-(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator-(const complex<T>&, const T&);
-template<class T> complex<T> operator-(const T&, const complex<T>&);
-template<class T> complex<T> operator*(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator*(const complex<T>&, const T&);
-template<class T> complex<T> operator*(const T&, const complex<T>&);
-template<class T> complex<T> operator/(const complex<T>&, const complex<T>&);
-template<class T> complex<T> operator/(const complex<T>&, const T&);
-template<class T> complex<T> operator/(const T&, const complex<T>&);
-template<class T> complex<T> operator+(const complex<T>&);
-template<class T> complex<T> operator-(const complex<T>&);
+template<class T> complex<T> operator+(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator+(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator+(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator-(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator-(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator-(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator*(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator*(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator*(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator/(const complex<T>&, const complex<T>&); // constexpr in C++20
+template<class T> complex<T> operator/(const complex<T>&, const T&);          // constexpr in C++20
+template<class T> complex<T> operator/(const T&, const complex<T>&);          // constexpr in C++20
+template<class T> complex<T> operator+(const complex<T>&);                    // constexpr in C++20
+template<class T> complex<T> operator-(const complex<T>&);                    // constexpr in C++20
 template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
 template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
 template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14
 template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14
 template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14
 template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14
 
 template<class T, class charT, class traits>

 template<class T> T abs(const complex<T>&);
 
 template<class T>              T arg(const complex<T>&);
                      long double arg(long double);
                           double arg(double);
 template<Integral T>      double arg(T);
                           float  arg(float);
 
-template<class T>              T norm(const complex<T>&);
-                     long double norm(long double);
-                          double norm(double);
-template<Integral T>      double norm(T);
-                          float  norm(float);
-
-template<class T>      complex<T>           conj(const complex<T>&);
-                       complex<long double> conj(long double);
-                       complex<double>      conj(double);
-template<Integral T>   complex<double>      conj(T);
-                       complex<float>       conj(float);
+template<class T>              T norm(const complex<T>&); // constexpr in C++20
+                     long double norm(long double);       // constexpr in C++20
+                          double norm(double);            // constexpr in C++20
+template<Integral T>      double norm(T);                 // constexpr in C++20
+                          float  norm(float);             // constexpr in C++20
+
+template<class T>      complex<T>           conj(const complex<T>&); // constexpr in C++20
+                       complex<long double> conj(long double);       // constexpr in C++20
+                       complex<double>      conj(double);            // constexpr in C++20
+template<Integral T>   complex<double>      conj(T);                 // constexpr in C++20
+                       complex<float>       conj(float);             // constexpr in C++20
 
 template<class T>    complex<T>           proj(const complex<T>&);
                      complex<long double> proj(long double);
                      complex<double>      proj(double);
 template<Integral T> complex<double>      proj(T);
                      complex<float>       proj(float);
 
 template<class T> complex<T> polar(const T&, const T& = T());

 
 }  // std
 
 */
 
 #include <__config>
 #include <type_traits>
 #include <stdexcept>
+// TODO: Should we use FLT_RADIX from <cfloat> or __FLT_RADIX__ from <limits> or numeric_limits<T>::radix from <limits>?
+#include <limits>
 #include <cmath>
 #include <iosfwd>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream> // for std::basic_ostringstream
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
 
-template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
-template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
+template<class _Tp> _LIBCPP_CONSTEXPR_AFTER_CXX17 complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
+template<class _Tp> _LIBCPP_CONSTEXPR_AFTER_CXX17 complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS complex
 {
 public:
     typedef _Tp value_type;
 private:
     value_type __re_;
     value_type __im_;
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     complex(const value_type& __re = value_type(), const value_type& __im = value_type())
         : __re_(__re), __im_(__im) {}
     template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     complex(const complex<_Xp>& __c)
         : __re_(__c.real()), __im_(__c.imag()) {}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (const value_type& __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
 template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
public:
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (float __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (float __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(float __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(float __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(float __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(float __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 template<>
 class _LIBCPP_TEMPLATE_VIS complex<double>
 {
     double __re_;
     double __im_;
 public:
     typedef double value_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
         : __re_(__re), __im_(__im) {}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
     _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (double __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (double __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(double __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(double __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(double __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(double __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 template<>
 class _LIBCPP_TEMPLATE_VIS complex<long double>
 {
     long double __re_;
     long double __im_;
 public:
     typedef long double value_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
         : __re_(__re), __im_(__im) {}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
 
-    _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (long double __re)
         {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator+=(long double __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator-=(long double __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(long double __re) {__re_ += __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(long double __re) {__re_ -= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator= (const complex<_Xp>& __c)
         {
             __re_ = __c.real();
             __im_ = __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator+=(const complex<_Xp>& __c)
         {
             __re_ += __c.real();
             __im_ += __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator-=(const complex<_Xp>& __c)
         {
             __re_ -= __c.real();
             __im_ -= __c.imag();
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator*=(const complex<_Xp>& __c)
         {
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
 };
 
 inline
 _LIBCPP_CONSTEXPR

 inline
 _LIBCPP_CONSTEXPR
 complex<long double>::complex(const complex<double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
 // 26.3.6 operators:
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__x);
     __t += __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator+(const complex<_Tp>& __x, const _Tp& __y)
 {
     complex<_Tp> __t(__x);
     __t += __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator+(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__y);
     __t += __x;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__x);
     __t -= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator-(const complex<_Tp>& __x, const _Tp& __y)
 {
     complex<_Tp> __t(__x);
     __t -= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator-(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(-__y);
     __t += __x;
     return __t;
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp>
+constexpr _Tp __copysign_constexpr(_Tp __lcpp_x, _Tp __lcpp_y);
+
+template <>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr float __copysign_constexpr(float __lcpp_x, float __lcpp_y)
+{
+    return __builtin_copysignf(__lcpp_x, __lcpp_y);
+}
+
+template <>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr double __copysign_constexpr(double __lcpp_x, double __lcpp_y)
+{
+    return __builtin_copysignl(__lcpp_x, __lcpp_y);
+}
+
+template <>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr long double __copysign_constexpr(long double __lcpp_x, long double __lcpp_y)
+{
+    return __builtin_copysignl(__lcpp_x, __lcpp_y);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp
+__abs_constexpr(_Tp __lcpp_x) _NOEXCEPT {
+  return (__lcpp_x < _Tp(0)) ? -__lcpp_x : __lcpp_x;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+typename enable_if
+<
+    is_integral<_Tp>::value,
+    _Tp
+>::type
+__copysign_constexpr(_Tp __lcpp_x, _Tp __lcpp_y)
+{
+    if (__lcpp_y < _Tp(0)) {
+        return -abs(__lcpp_x);
+    }
+    return abs(__lcpp_x);
+}
+
+template<class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
+complex<_Tp>
+operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
+{
+    _Tp __a = __z.real();
+    _Tp __b = __z.imag();
+    _Tp __c = __w.real();
+    _Tp __d = __w.imag();
+    if (__libcpp_is_constant_evaluated()) {
+        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
+        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
+        bool __z_inf = __libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b);
+        bool __w_inf = __libcpp_isinf_or_builtin(__c) || __libcpp_isinf_or_builtin(__d);
+        bool __z_nan = !__z_inf && (
+            (__libcpp_isnan_or_builtin(__a) && __libcpp_isnan_or_builtin(__b))
+            || (__libcpp_isnan_or_builtin(__a) && __b == _Tp(0))
+            || (__a == _Tp(0) && __libcpp_isnan_or_builtin(__b))
+        );
+        bool __w_nan = !__w_inf && (
+            (__libcpp_isnan_or_builtin(__c) && __libcpp_isnan_or_builtin(__d))
+            || (__libcpp_isnan_or_builtin(__c) && __d == _Tp(0))
+            || (__c == _Tp(0) && __libcpp_isnan_or_builtin(__d))
+        );
+        if (__z_nan || __w_nan) {
+            return complex<_Tp>(_Tp(NAN), _Tp(0));
+        }
+        if (__z_inf || __w_inf) {
+            if (__z_zero || __w_zero) {
+                return complex<_Tp>(_Tp(NAN), _Tp(0));
+            }
+            return complex<_Tp>(_Tp(INFINITY), _Tp(INFINITY));
+        }
+        bool __z_nonzero_nan = !__z_inf && !__z_nan && (__libcpp_isnan_or_builtin(__a) || __libcpp_isnan_or_builtin(__b));
+        bool __w_nonzero_nan = !__w_inf && !__w_nan && (__libcpp_isnan_or_builtin(__c) || __libcpp_isnan_or_builtin(__d));
+        if (__z_nonzero_nan || __w_nonzero_nan) {
+            return complex<_Tp>(_Tp(NAN), _Tp(0));
+        }
+    }
+    _Tp __ac = __a * __c;
+    _Tp __bd = __b * __d;
+    _Tp __ad = __a * __d;
+    _Tp __bc = __b * __c;
+    _Tp __x = __ac - __bd;
+    _Tp __y = __ad + __bc;
+    if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
+    {
+        bool __recalc = false;
+        if (__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b))
+        {
+            if (__libcpp_is_constant_evaluated()) {
+                __a = __copysign_constexpr(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+                __b = __copysign_constexpr(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+                if (__libcpp_isnan_or_builtin(__c))
+                    __c = __copysign_constexpr(_Tp(0), __c);
+                if (__libcpp_isnan_or_builtin(__d))
+                    __d = __copysign_constexpr(_Tp(0), __d);
+            } else {
+                if (__libcpp_is_constant_evaluated()) {
+                    __a = __copysign_constexpr(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+                    __b = __copysign_constexpr(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+                    if (__libcpp_isnan_or_builtin(__c))
+                        __c = __copysign_constexpr(_Tp(0), __c);
+                    if (__libcpp_isnan_or_builtin(__d))
+                        __d = __copysign_constexpr(_Tp(0), __d);
+                } else {
+                    __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+                    __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+                    if (__libcpp_isnan_or_builtin(__c))
+                        __c = copysign(_Tp(0), __c);
+                    if (__libcpp_isnan_or_builtin(__d))
+                        __d = copysign(_Tp(0), __d);
+                }
+            }
+            __recalc = true;
+        }
+        if (__libcpp_isinf_or_builtin(__c) || __libcpp_isinf_or_builtin(__d))
+        {
+            if (__libcpp_is_constant_evaluated()) {
+                __c = __copysign_constexpr(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+                __d = __copysign_constexpr(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+                if (__libcpp_isnan_or_builtin(__a))
+                    __a = __copysign_constexpr(_Tp(0), __a);
+                if (__libcpp_isnan_or_builtin(__b))
+                    __b = __copysign_constexpr(_Tp(0), __b);
+                __recalc = true;
+            } else {
+                __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+                __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+                if (__libcpp_isnan_or_builtin(__a))
+                    __a = copysign(_Tp(0), __a);
+                if (__libcpp_isnan_or_builtin(__b))
+                    __b = copysign(_Tp(0), __b);
+                __recalc = true;
+            }
+        }
+        if (!__recalc && (__libcpp_isinf_or_builtin(__ac) || __libcpp_isinf_or_builtin(__bd) ||
+                          __libcpp_isinf_or_builtin(__ad) || __libcpp_isinf_or_builtin(__bc)))
+        {
+            if (__libcpp_is_constant_evaluated()) {
+                if (__libcpp_isnan_or_builtin(__a))
+                    __a = __copysign_constexpr(_Tp(0), __a);
+                if (__libcpp_isnan_or_builtin(__b))
+                    __b = __copysign_constexpr(_Tp(0), __b);
+                if (__libcpp_isnan_or_builtin(__c))
+                    __c = __copysign_constexpr(_Tp(0), __c);
+                if (__libcpp_isnan_or_builtin(__d))
+                    __d = __copysign_constexpr(_Tp(0), __d);
+            } else {
+                if (__libcpp_isnan_or_builtin(__a))
+                    __a = copysign(_Tp(0), __a);
+                if (__libcpp_isnan_or_builtin(__b))
+                    __b = copysign(_Tp(0), __b);
+                if (__libcpp_isnan_or_builtin(__c))
+                    __c = copysign(_Tp(0), __c);
+                if (__libcpp_isnan_or_builtin(__d))
+                    __d = copysign(_Tp(0), __d);
+            }
+            __recalc = true;
+        }
+        if (__recalc)
+        {
+            __x = _Tp(INFINITY) * (__a * __c - __b * __d);
+            __y = _Tp(INFINITY) * (__a * __d + __b * __c);
+        }
+    }
+    return complex<_Tp>(__x, __y);
+}
+#else
 template<class _Tp>
 complex<_Tp>
 operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
 {
     _Tp __a = __z.real();
     _Tp __b = __z.imag();
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
     _Tp __ac = __a * __c;
     _Tp __bd = __b * __d;
     _Tp __ad = __a * __d;
     _Tp __bc = __b * __c;
     _Tp __x = __ac - __bd;
     _Tp __y = __ad + __bc;
     if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
     {
         bool __recalc = false;
         if (__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b))
if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
         if (__recalc)
         {
             __x = _Tp(INFINITY) * (__a * __c - __b * __d);
             __y = _Tp(INFINITY) * (__a * __d + __b * __c);
         }
     }
     return complex<_Tp>(__x, __y);
 }
+#endif
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator*(const complex<_Tp>& __x, const _Tp& __y)
 {
     complex<_Tp> __t(__x);
     __t *= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator*(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__y);
     __t *= __x;
     return __t;
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp
+__fmax_constexpr(_Tp __lcpp_x, _Tp __lcpp_y) _NOEXCEPT {
+  // Treat NaNs as smaller.
+  if (__libcpp_isnan_or_builtin(__lcpp_x))
+    return __lcpp_y;
+  if (__libcpp_isnan_or_builtin(__lcpp_y))
+    return __lcpp_x;
+  return __lcpp_x < __lcpp_y ? __lcpp_y : __lcpp_x;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp
+__fabs_constexpr(_Tp __lcpp_x) _NOEXCEPT {
+  return (__lcpp_x < _Tp{}) ? -__lcpp_x : __lcpp_x;
+}
+
+template <class _Tp>
+constexpr _Tp __logb_constexpr(_Tp __lcpp_x) {
+  if(__lcpp_x == _Tp(0)) {
+    // raise FE_DIVBYZERO
+    return -_Tp(INFINITY);
+  }
+
+  if(__libcpp_isinf_or_builtin(__lcpp_x))
+    return _Tp(INFINITY);
+
+  if(__libcpp_isnan_or_builtin(__lcpp_x))
+    return _Tp(NAN);
+
+  __lcpp_x = __fabs_constexpr(__lcpp_x);
+  unsigned long long __exp = 0;
+  while (__lcpp_x >= __FLT_RADIX__) {
+    __lcpp_x /= __FLT_RADIX__;
+    __exp += 1;
+  }
+  return _Tp(__exp);
+}
+
+template <class _Tp>
+constexpr _Tp __scalbn_constexpr(_Tp __lcpp_x, int __lcpp_exp) {
+  if(__lcpp_x == _Tp(0))
+    return __lcpp_x;
+
+  if(__libcpp_isinf_or_builtin(__lcpp_x))
+    return __lcpp_x;
+
+  if (__lcpp_exp == _Tp(0))
+    return __lcpp_x;
+
+  if(__libcpp_isnan_or_builtin(__lcpp_x))
+    return _Tp(NAN);
+
+  _Tp __mult{1};
+  if (__lcpp_exp > 0) {
+    __mult = __FLT_RADIX__;
+    --__lcpp_exp;
+  } else {
+    ++__lcpp_exp;
+    __lcpp_exp = -__lcpp_exp;
+    __mult /= __FLT_RADIX__;
+  }
+
+  while (__lcpp_exp > 0) {
+    if (!(__lcpp_exp & 1)) {
+      __mult *= __mult;
+      __lcpp_exp >>= 1;
+    } else {
+      __lcpp_x *= __mult;
+      --__lcpp_exp;
+    }
+  }
+  return __lcpp_x;
+}
+
+template<class _Tp>
+_LIBCPP_CONSTEXPR_AFTER_CXX17
+complex<_Tp>
+operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
+{
+    int __ilogbw = 0;
+    _Tp __a = __z.real();
+    _Tp __b = __z.imag();
+    _Tp __c = __w.real();
+    _Tp __d = __w.imag();
+    _Tp __logbw{};
+    if (__libcpp_is_constant_evaluated()) {
+        __logbw = __logb_constexpr(
+            __fmax_constexpr(__fabs_constexpr(__c), __fabs_constexpr(__d)));
+    } else {
+        __logbw = logb(fmax(fabs(__c), fabs(__d)));
+    }
+    if (__libcpp_isfinite_or_builtin(__logbw))
+    {
+        __ilogbw = static_cast<int>(__logbw);
+        if (__libcpp_is_constant_evaluated()) {
+            __c = __scalbn_constexpr(__c, -__ilogbw);
+            __d = __scalbn_constexpr(__d, -__ilogbw);
+        } else {
+            __c = scalbn(__c, -__ilogbw);
+            __d = scalbn(__d, -__ilogbw);
+        }
+    }
+    if (__libcpp_is_constant_evaluated()) {
+        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
+        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
+        bool __z_inf = __libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b);
+        bool __w_inf = __libcpp_isinf_or_builtin(__c) || __libcpp_isinf_or_builtin(__d);
+        bool __z_nan = !__z_inf && (
+            (__libcpp_isnan_or_builtin(__a) && __libcpp_isnan_or_builtin(__b))
+            || (__libcpp_isnan_or_builtin(__a) && __b == _Tp(0))
+            || (__a == _Tp(0) && __libcpp_isnan_or_builtin(__b))
+        );
+        bool __w_nan = !__w_inf && (
+            (__libcpp_isnan_or_builtin(__c) && __libcpp_isnan_or_builtin(__d))
+            || (__libcpp_isnan_or_builtin(__c) && __d == _Tp(0))
+            || (__c == _Tp(0) && __libcpp_isnan_or_builtin(__d))
+        );
+        if ((__z_nan || __w_nan) || (__z_inf && __w_inf)) {
+            return complex<_Tp>(_Tp(NAN), _Tp(0));
+        }
+        bool __z_nonzero_nan = !__z_inf && !__z_nan && (__libcpp_isnan_or_builtin(__a) || __libcpp_isnan_or_builtin(__b));
+        bool __w_nonzero_nan = !__w_inf && !__w_nan && (__libcpp_isnan_or_builtin(__c) || __libcpp_isnan_or_builtin(__d));
+        if (__z_nonzero_nan || __w_nonzero_nan) {
+            if (__w_zero) {
+                return complex<_Tp>(_Tp(INFINITY), _Tp(INFINITY));
+            }
+            return complex<_Tp>(_Tp(NAN), _Tp(0));
+        }
+        if (__w_inf) {
+            return complex<_Tp>(_Tp(0), _Tp(0));
+        }
+        if (__z_inf) {
+            return complex<_Tp>(_Tp(INFINITY), _Tp(INFINITY));
+        }
+        if (__w_zero) {
+            if (__z_zero) {
+                return complex<_Tp>(_Tp(NAN), _Tp(0));
+            }
+            return complex<_Tp>(_Tp(INFINITY), _Tp(INFINITY));
+        }
+    }
+    _Tp __denom = __c * __c + __d * __d;
+    _Tp __x{};
+    _Tp __y{};
+    if (__libcpp_is_constant_evaluated()) {
+        __x = __scalbn_constexpr((__a * __c + __b * __d) / __denom, -__ilogbw);
+        __y = __scalbn_constexpr((__b * __c - __a * __d) / __denom, -__ilogbw);
+    } else {
+        __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
+        __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
+    }
+    if (__libcpp_is_constant_evaluated()) {
+        if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
+        {
+            if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) || !__libcpp_isnan_or_builtin(__b)))
+            {
+                __x = __copysign_constexpr(_Tp(INFINITY), __c) * __a;
+                __y = __copysign_constexpr(_Tp(INFINITY), __c) * __b;
+            }
+            else if ((__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
+            {
+                __a = __copysign_constexpr(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+                __b = __copysign_constexpr(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+                __x = _Tp(INFINITY) * (__a * __c + __b * __d);
+                __y = _Tp(INFINITY) * (__b * __c - __a * __d);
+            }
+            else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
+            {
+                __c = __copysign_constexpr(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+                __d = __copysign_constexpr(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+                __x = _Tp(0) * (__a * __c + __b * __d);
+                __y = _Tp(0) * (__b * __c - __a * __d);
+            }
+        }
+    } else {
+        if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
+        {
+            if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) || !__libcpp_isnan_or_builtin(__b)))
+            {
+                __x = copysign(_Tp(INFINITY), __c) * __a;
+                __y = copysign(_Tp(INFINITY), __c) * __b;
+            }
+            else if ((__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
+            {
+                __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+                __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+                __x = _Tp(INFINITY) * (__a * __c + __b * __d);
+                __y = _Tp(INFINITY) * (__b * __c - __a * __d);
+            }
+            else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
+            {
+                __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+                __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+                __x = _Tp(0) * (__a * __c + __b * __d);
+                __y = _Tp(0) * (__b * __c - __a * __d);
+            }
+        }
+    }
+    return complex<_Tp>(__x, __y);
+}
+#else
 template<class _Tp>
 complex<_Tp>
 operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
 {
     int __ilogbw = 0;
     _Tp __a = __z.real();
     _Tp __b = __z.imag();
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
     _Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
     if (__libcpp_isfinite_or_builtin(__logbw))
     {
         __ilogbw = static_cast<int>(__logbw);
         __c = scalbn(__c, -__ilogbw);
         __d = scalbn(__d, -__ilogbw);
     }
     _Tp __denom = __c * __c + __d * __d;
     _Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
     _Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
     if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
     {
         if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) || !__libcpp_isnan_or_builtin(__b)))
         {
             __x = copysign(_Tp(INFINITY), __c) * __a;
             __y = copysign(_Tp(INFINITY), __c) * __b;
         }
         else if ((__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
         {
             __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
             __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
             __x = _Tp(INFINITY) * (__a * __c + __b * __d);
             __y = _Tp(INFINITY) * (__b * __c - __a * __d);
         }
         else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
         {
             __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
             __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
             __x = _Tp(0) * (__a * __c + __b * __d);
             __y = _Tp(0) * (__b * __c - __a * __d);
         }
     }
     return complex<_Tp>(__x, __y);
 }
+#endif
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator/(const complex<_Tp>& __x, const _Tp& __y)
 {
     return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator/(const _Tp& __x, const complex<_Tp>& __y)
 {
     complex<_Tp> __t(__x);
     __t /= __y;
     return __t;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator+(const complex<_Tp>& __x)
 {
     return __x;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 operator-(const complex<_Tp>& __x)
 {
     return complex<_Tp>(-__x.real(), -__x.imag());
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11

 arg(_Tp __re)
 {
     return atan2f(0.F, __re);
 }
 
 // norm
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _Tp
 norm(const complex<_Tp>& __c)
 {
     if (__libcpp_isinf_or_builtin(__c.real()))
         return abs(__c.real());
     if (__libcpp_isinf_or_builtin(__c.imag()))
         return abs(__c.imag());
     return __c.real() * __c.real() + __c.imag() * __c.imag();
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
 norm(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
     return static_cast<_ValueType>(__re) * __re;
 }
 
 // conj
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 conj(const complex<_Tp>& __c)
 {
     return complex<_Tp>(__c.real(), -__c.imag());
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 conj(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
     return _ComplexType(__re);
 }
 
 

libcxx/include/version

 __cpp_lib_char8_t                                       201811L <atomic> <filesystem> <istream>
                                                                 <limits> <locale> <ostream>
                                                                 <string> <string_view>
 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      201806L <concepts>
+__cpp_lib_constexpr_complex                             201711L <complex>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
 __cpp_lib_constexpr_misc                                201811L <array> <functional> <iterator>
                                                                 <string_view> <tuple> <utility>
 __cpp_lib_constexpr_swap_algorithms                     201806L <algorithm>
 __cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>

 #   define __cpp_lib_atomic_wait                        201907L
 # endif
 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
+# define __cpp_lib_constexpr_complex                       201711L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
 // # define __cpp_lib_constexpr_misc                       201811L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # define __cpp_lib_constexpr_utility                    201811L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L

libcxx/test/std/language.support/support.limits/support.limits.general/complex.version.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
 // <complex>
 
 // Test the feature test macros defined by <complex>
 
-/*  Constant                  Value
-    __cpp_lib_complex_udls    201309L [C++14]
+/*  Constant                       Value
+    __cpp_lib_complex_udls         201309L [C++14]
+    __cpp_lib_constexpr_complex    201711L [C++2a]
 */
 
 #include <complex>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should not be defined before c++14"
 # endif
 
+# ifdef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should not be defined before c++2a"
+# endif
+
 #elif TEST_STD_VER == 14
 
 # ifndef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should be defined in c++14"
 # endif
 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++14"
 # endif
 
+# ifdef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should not be defined before c++2a"
+# endif
+
 #elif TEST_STD_VER == 17
 
 # ifndef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should be defined in c++17"
 # endif
 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++17"
 # endif
 
+# ifdef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should not be defined before c++2a"
+# endif
+
 #elif TEST_STD_VER > 17
 
 # ifndef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should be defined in c++2a"
 # endif
 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++2a"
 # endif
 
+# ifndef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_complex != 201711L
+#   error "__cpp_lib_constexpr_complex should have the value 201711L in c++2a"
+# endif
+
 #endif // TEST_STD_VER > 17
 
 int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_boyer_moore_searcher                 201603L [C++17]
     __cpp_lib_byte                                 201603L [C++17]
     __cpp_lib_char8_t                              201811L [C++2a]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             201806L [C++2a]
+    __cpp_lib_constexpr_complex                    201711L [C++2a]
     __cpp_lib_constexpr_dynamic_alloc              201907L [C++2a]
     __cpp_lib_constexpr_misc                       201811L [C++2a]
     __cpp_lib_constexpr_swap_algorithms            201806L [C++2a]
     __cpp_lib_constexpr_utility                    201811L [C++2a]
     __cpp_lib_destroying_delete                    201806L [C++2a]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++2a]
     __cpp_lib_erase_if                             202002L [C++2a]

 # ifdef __cpp_lib_complex_udls
 #   error "__cpp_lib_complex_udls should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_concepts
 #   error "__cpp_lib_concepts should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 

 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++14"
 # endif
 
 # ifdef __cpp_lib_concepts
 #   error "__cpp_lib_concepts should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 

 # if __cpp_lib_complex_udls != 201309L
 #   error "__cpp_lib_complex_udls should have the value 201309L in c++17"
 # endif
 
 # ifdef __cpp_lib_concepts
 #   error "__cpp_lib_concepts should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 

 #     error "__cpp_lib_concepts should have the value 201806L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_concepts
 #     error "__cpp_lib_concepts should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_constexpr_complex
+#   error "__cpp_lib_constexpr_complex should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_complex != 201711L
+#   error "__cpp_lib_constexpr_complex should have the value 201711L in c++2a"
+# endif
+
 # ifndef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2a"
 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2a"
 # endif
 
 # if !defined(_LIBCPP_VERSION)

libcxx/test/std/numerics/complex.number/cases.h

 // test cases
 
 #ifndef CASES_H
 #define CASES_H
 
 #include <complex>
 #include <cassert>
 
-const std::complex<double> testcases[] =
+TEST_CONSTEXPR_CXX20 const std::complex<double> testcases[] =
 {
     std::complex<double>( 1.e-6,  1.e-6),
     std::complex<double>(-1.e-6,  1.e-6),
     std::complex<double>(-1.e-6, -1.e-6),
     std::complex<double>( 1.e-6, -1.e-6),
 
     std::complex<double>( 1.e+6,  1.e-6),
     std::complex<double>(-1.e+6,  1.e-6),
TEST_CONSTEXPR_CXX20 const std::complex<double> testcases[] =
     std::complex<double>(1, INFINITY),
     std::complex<double>(2, INFINITY),
     std::complex<double>(INFINITY, INFINITY)
 };
 
 enum {zero, non_zero, inf, NaN, non_zero_nan};
 
 template <class T>
-int
+TEST_CONSTEXPR_CXX20 int
 classify(const std::complex<T>& x)
 {
     if (x == std::complex<T>())
         return zero;
-    if (std::isinf(x.real()) || std::isinf(x.imag()))
+    if (__builtin_isinf(x.real()) || __builtin_isinf(x.imag()))
         return inf;
-    if (std::isnan(x.real()) && std::isnan(x.imag()))
+    if (__builtin_isnan(x.real()) && __builtin_isnan(x.imag()))
         return NaN;
-    if (std::isnan(x.real()))
+    if (__builtin_isnan(x.real()))
     {
         if (x.imag() == T(0))
             return NaN;
         return non_zero_nan;
     }
-    if (std::isnan(x.imag()))
+    if (__builtin_isnan(x.imag()))
     {
         if (x.real() == T(0))
             return NaN;
         return non_zero_nan;
     }
     return non_zero;
 }
 

libcxx/test/std/numerics/complex.number/cmplx.over/conj.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// template<class T>      complex<T>           conj(const complex<T>&);
-//                        complex<long double> conj(long double);
-//                        complex<double>      conj(double);
-// template<Integral T>   complex<double>      conj(T);
-//                        complex<float>       conj(float);
+// template<class T>      complex<T>           conj(const complex<T>&); // constexpr in C++20
+//                        complex<long double> conj(long double);       // constexpr in C++20
+//                        complex<double>      conj(double);            // constexpr in C++20
+// template<Integral T>   complex<double>      conj(T);                 // constexpr in C++20
+//                        complex<float>       conj(float);             // constexpr in C++20
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
-void
-test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
-{
-    static_assert((std::is_same<decltype(std::conj(x)), std::complex<double> >::value), "");
-    assert(std::conj(x) == conj(std::complex<double>(x, 0)));
+TEST_CONSTEXPR_CXX20 bool
+test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0) {
+  static_assert(
+      (std::is_same<decltype(std::conj(x)), std::complex<double> >::value), "");
+  return true;
 }
 
 template <class T>
-void
-test(T x, typename std::enable_if<std::is_floating_point<T>::value>::type* = 0)
-{
-    static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), "");
-    assert(std::conj(x) == conj(std::complex<T>(x, 0)));
+TEST_CONSTEXPR_CXX20 bool
+test(T x,
+     typename std::enable_if<std::is_floating_point<T>::value>::type* = 0) {
+  static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value),
+                "");
+  return true;
 }
 
 template <class T>
-void
-test(T x, typename std::enable_if<!std::is_integral<T>::value &&
-                                  !std::is_floating_point<T>::value>::type* = 0)
-{
-    static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value), "");
-    assert(std::conj(x) == conj(std::complex<T>(x, 0)));
+TEST_CONSTEXPR_CXX20 bool
+test(T x,
+     typename std::enable_if<!std::is_integral<T>::value &&
+                             !std::is_floating_point<T>::value>::type* = 0) {
+  static_assert((std::is_same<decltype(std::conj(x)), std::complex<T> >::value),
+                "");
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    test<T>(0);
-    test<T>(1);
-    test<T>(10);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test<int>();
     test<unsigned>();
     test<long long>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test<int>());
+    static_assert(test<unsigned>());
+    static_assert(test<long long>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/cmplx.over/norm.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<Arithmetic T>
 //   T
-//   norm(T x);
+//   norm(T x); // constexpr in C++20
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
-void
-test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0)
-{
-    static_assert((std::is_same<decltype(std::norm(x)), double>::value), "");
-    assert(std::norm(x) == norm(std::complex<double>(static_cast<double>(x), 0)));
+TEST_CONSTEXPR_CXX20 bool
+test(T x, typename std::enable_if<std::is_integral<T>::value>::type* = 0) {
+  return true;
 }
 
 template <class T>
-void
-test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0)
-{
-    static_assert((std::is_same<decltype(std::norm(x)), T>::value), "");
-    assert(std::norm(x) == norm(std::complex<T>(x, 0)));
+TEST_CONSTEXPR_CXX20 bool
+test(T x, typename std::enable_if<!std::is_integral<T>::value>::type* = 0) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    test<T>(0);
-    test<T>(1);
-    test<T>(10);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test<int>();
     test<unsigned>();
     test<long long>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test<int>());
+    static_assert(test<unsigned>());
+    static_assert(test<long long>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/assignment_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator=(const complex&);
-// template<class X> complex& operator= (const complex<X>&);
+// template<class X> complex& operator= (const complex<X>&); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T, class X>
-void
-test()
-{
-    std::complex<T> c;
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    std::complex<T> c2(1.5, 2.5);
-    c = c2;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 2.5);
-    std::complex<X> c3(3.5, -4.5);
-    c = c3;
-    assert(c.real() == 3.5);
-    assert(c.imag() == -4.5);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float, float>();
     test<float, double>();
     test<float, long double>();
 
     test<double, float>();
     test<double, double>();
     test<double, long double>();
 
     test<long double, float>();
     test<long double, double>();
     test<long double, long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float, float>());
+    static_assert(test<float, double>());
+    static_assert(test<float, long double>());
+
+    static_assert(test<double, float>());
+    static_assert(test<double, double>());
+    static_assert(test<double, long double>());
+
+    static_assert(test<long double, float>());
+    static_assert(test<long double, double>());
+    static_assert(test<long double, long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/assignment_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator= (const T&);
+// complex& operator= (const T&); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c;
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    c = 1.5;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 0);
-    c = -1.5;
-    assert(c.real() == -1.5);
-    assert(c.imag() == 0);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator/=(const complex& rhs);
+// complex& operator/=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c(-4, 7.5);
-    const std::complex<T> c2(1.5, 2.5);
-    assert(c.real() == -4);
-    assert(c.imag() == 7.5);
-    c /= c2;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 2.5);
-    c /= c2;
-    assert(c.real() == 1);
-    assert(c.imag() == 0);
+TEST_CONSTEXPR_CXX20 bool test() {
 
-    std::complex<T> c3;
 
-    c3 = c;
-    std::complex<int> ic (1,1);
-    c3 /= ic;
-    assert(c3.real() ==  0.5);
-    assert(c3.imag() == -0.5);
+  std::complex<int> ic(1, 1);
+  assert(c3.real() == 0.5);
 
-    c3 = c;
-    std::complex<float> fc (1,1);
-    c3 /= fc;
-    assert(c3.real() ==  0.5);
-    assert(c3.imag() == -0.5);
-
+  std::complex<float> fc(1, 1);
+  assert(c3.real() == 0.5);
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator/=(const T& rhs);
+// complex& operator/=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c(1);
-    assert(c.real() == 1);
-    assert(c.imag() == 0);
-    c /= 0.5;
-    assert(c.real() == 2);
-    assert(c.imag() == 0);
-    c /= 0.5;
-    assert(c.real() == 4);
-    assert(c.imag() == 0);
-    c /= -0.5;
-    assert(c.real() == -8);
-    assert(c.imag() == 0);
-    c.imag(2);
-    c /= 0.5;
-    assert(c.real() == -16);
-    assert(c.imag() == 4);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/minus_equal_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator-=(const complex& rhs);
+// complex& operator-=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c;
-    const std::complex<T> c2(1.5, 2.5);
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    c -= c2;
-    assert(c.real() == -1.5);
-    assert(c.imag() == -2.5);
-    c -= c2;
-    assert(c.real() == -3);
-    assert(c.imag() == -5);
+TEST_CONSTEXPR_CXX20 bool test() {
 
-    std::complex<T> c3;
 
-    c3 = c;
-    std::complex<int> ic (1,1);
-    c3 -= ic;
-    assert(c3.real() == -4);
-    assert(c3.imag() == -6);
+  std::complex<int> ic(1, 1);
 
-    c3 = c;
-    std::complex<float> fc (1,1);
-    c3 -= fc;
-    assert(c3.real() == -4);
-    assert(c3.imag() == -6);
+  std::complex<float> fc(1, 1);
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/minus_equal_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator-=(const T& rhs);
+// complex& operator-=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c;
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    c -= 1.5;
-    assert(c.real() == -1.5);
-    assert(c.imag() == 0);
-    c -= 1.5;
-    assert(c.real() == -3);
-    assert(c.imag() == 0);
-    c -= -1.5;
-    assert(c.real() == -1.5);
-    assert(c.imag() == 0);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/plus_equal_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator+=(const complex& rhs);
+// complex& operator+=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c;
-    const std::complex<T> c2(1.5, 2.5);
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    c += c2;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 2.5);
-    c += c2;
-    assert(c.real() == 3);
-    assert(c.imag() == 5);
+TEST_CONSTEXPR_CXX20 bool test() {
 
-    std::complex<T> c3;
 
-    c3 = c;
-    std::complex<int> ic (1,1);
-    c3 += ic;
-    assert(c3.real() == 4);
-    assert(c3.imag() == 6);
+  std::complex<int> ic(1, 1);
 
-    c3 = c;
-    std::complex<float> fc (1,1);
-    c3 += fc;
-    assert(c3.real() == 4);
-    assert(c3.imag() == 6);
+  std::complex<float> fc(1, 1);
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/plus_equal_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator+=(const T& rhs);
+// complex& operator+=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c;
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    c += 1.5;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 0);
-    c += 1.5;
-    assert(c.real() == 3);
-    assert(c.imag() == 0);
-    c += -1.5;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 0);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/times_equal_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator*=(const complex& rhs);
+// complex& operator*=(const complex& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c(1);
-    const std::complex<T> c2(1.5, 2.5);
-    assert(c.real() == 1);
-    assert(c.imag() == 0);
-    c *= c2;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 2.5);
-    c *= c2;
-    assert(c.real() == -4);
-    assert(c.imag() == 7.5);
+TEST_CONSTEXPR_CXX20 bool test() {
 
-    std::complex<T> c3;
 
-    c3 = c;
-    std::complex<int> ic (1,1);
-    c3 *= ic;
-    assert(c3.real() == -11.5);
-    assert(c3.imag() ==   3.5);
+  std::complex<int> ic(1, 1);
+  assert(c3.imag() == 3.5);
 
-    c3 = c;
-    std::complex<float> fc (1,1);
-    c3 *= fc;
-    assert(c3.real() == -11.5);
-    assert(c3.imag() ==   3.5);
+  std::complex<float> fc(1, 1);
+  assert(c3.imag() == 3.5);
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.member.ops/times_equal_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// complex& operator*=(const T& rhs);
+// complex& operator*=(const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c(1);
-    assert(c.real() == 1);
-    assert(c.imag() == 0);
-    c *= 1.5;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 0);
-    c *= 1.5;
-    assert(c.real() == 2.25);
-    assert(c.imag() == 0);
-    c *= -1.5;
-    assert(c.real() == -3.375);
-    assert(c.imag() == 0);
-    c.imag(2);
-    c *= 1.5;
-    assert(c.real() == -5.0625);
-    assert(c.imag() == 3);
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.members/real_imag.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
-// void real(T val);
-// void imag(T val);
+// void real(T val); // constexpr in C++20
+// void imag(T val); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test_constexpr()
-{
+TEST_CONSTEXPR_CXX20 void test_constexpr() {
 #if TEST_STD_VER > 11
     constexpr std::complex<T> c1;
     static_assert(c1.real() == 0, "");
     static_assert(c1.imag() == 0, "");
     constexpr std::complex<T> c2(3);
     static_assert(c2.real() == 3, "");
     static_assert(c2.imag() == 0, "");
     constexpr std::complex<T> c3(3, 4);
     static_assert(c3.real() == 3, "");
     static_assert(c3.imag() == 4, "");
 #endif
 }
 
 template <class T>
-void
-test()
-{
-    std::complex<T> c;
-    assert(c.real() == 0);
-    assert(c.imag() == 0);
-    c.real(3.5);
-    assert(c.real() == 3.5);
-    assert(c.imag() == 0);
-    c.imag(4.5);
-    assert(c.real() == 3.5);
-    assert(c.imag() == 4.5);
-    c.real(-4.5);
-    assert(c.real() == -4.5);
-    assert(c.imag() == 4.5);
-    c.imag(-5.5);
-    assert(c.real() == -4.5);
-    assert(c.imag() == -5.5);
+TEST_CONSTEXPR_CXX20 bool test() {
 
-    test_constexpr<T> ();
+  test_constexpr<T>();
+  return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
-    test_constexpr<int> ();
+int main(int, char**) {
+  test_constexpr<int>();
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator/(const complex<T>& lhs, const complex<T>& rhs);
+//   operator/(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs / rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs,
+                               const std::complex<T>& rhs, std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    std::complex<T> lhs(-4.0, 7.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(1.5, 2.5);
-    test(lhs, rhs, x);
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::complex<T> x(1.5, 2.5);
+  return true;
 }
 
-void test_edges()
-{
-    const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
-    for (unsigned i = 0; i < N; ++i)
-    {
-        for (unsigned j = 0; j < N; ++j)
-        {
-            std::complex<double> r = testcases[i] / testcases[j];
-            switch (classify(testcases[i]))
-            {
-            case zero:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero:
-                    assert(classify(r) == zero);
-                    break;
-                case inf:
-                    assert(classify(r) == zero);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case non_zero:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == inf);
-                    break;
-                case non_zero:
-                    assert(classify(r) == non_zero);
-                    break;
-                case inf:
-                    assert(classify(r) == zero);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case inf:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == inf);
-                    break;
-                case non_zero:
-                    assert(classify(r) == inf);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case NaN:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            case non_zero_nan:
-                switch (classify(testcases[j]))
-                {
-                case zero:
-                    assert(classify(r) == inf);
-                    break;
-                case non_zero:
-                    assert(classify(r) == NaN);
-                    break;
-                case inf:
-                    assert(classify(r) == NaN);
-                    break;
-                case NaN:
-                    assert(classify(r) == NaN);
-                    break;
-                case non_zero_nan:
-                    assert(classify(r) == NaN);
-                    break;
-                }
-                break;
-            }
-        }
-    }
+TEST_CONSTEXPR_CXX20 bool test_edges() {
+  for (unsigned i = 0; i < N; ++i) {
+    for (unsigned j = 0; j < N; ++j) {
+      switch (classify(testcases[i])) {
+        switch (classify(testcases[j])) {
+        switch (classify(testcases[j])) {
+        switch (classify(testcases[j])) {
+        switch (classify(testcases[j])) {
+        switch (classify(testcases[j])) {
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test_edges());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator/(const complex<T>& lhs, const T& rhs);
+//   operator/(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs / rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs, const T& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    std::complex<T> lhs(-4.0, 7.5);
-    T rhs(2);
-    std::complex<T>   x(-2, 3.75);
-    test(lhs, rhs, x);
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::complex<T> x(-2, 3.75);
+  return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp

 //   operator==(const complex<T>& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test_constexpr()
-{
-#if TEST_STD_VER > 11
-    {
-    constexpr std::complex<T> lhs(1.5,  2.5);
-    constexpr std::complex<T> rhs(1.5, -2.5);
-    static_assert( !(lhs == rhs), "");
-    }
-    {
-    constexpr std::complex<T> lhs(1.5, 2.5);
-    constexpr std::complex<T> rhs(1.5, 2.5);
-    static_assert(lhs == rhs, "");
-    }
-#endif
-}
-
-template <class T>
-void
+TEST_CONSTEXPR_CXX20 bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
     assert( !(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
     assert(lhs == rhs);
     }
-    test_constexpr<T> ();
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//    test_constexpr<int> ();
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp

 //   operator==(const complex<T>& lhs, const T& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr std::complex<T> lhs(1.5, 2.5);
     constexpr T rhs(-2.5);
     static_assert(!(lhs == rhs), "");
     }
#if TEST_STD_VER > 11
     constexpr std::complex<T> lhs(1.5, 0);
     constexpr T rhs(1.5);
     static_assert( (lhs == rhs), "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
     assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(-2.5);
     assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
     assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
     assert( (lhs == rhs));
     }
 
     test_constexpr<T> ();
-    }
+    return true;
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int> ();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_minus_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const complex<T>& lhs, const complex<T>& rhs);
+//   operator-(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs - rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs,
+                               const std::complex<T>& rhs, std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(3.5, 4.5);
     std::complex<T>   x(-2.0, -2.0);
     test(lhs, rhs, x);
-    }
     {
     std::complex<T> lhs(1.5, -2.5);
     std::complex<T> rhs(-3.5, 4.5);
     std::complex<T>   x(5.0, -7.0);
     test(lhs, rhs, x);
     }
+    return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_minus_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const complex<T>& lhs, const T& rhs);
+//   operator-(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs - rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs, const T& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(3.5);
     std::complex<T>   x(-2.0, 2.5);
     test(lhs, rhs, x);
-    }
     {
     std::complex<T> lhs(1.5, -2.5);
     T rhs(-3.5);
     std::complex<T>   x(5.0, -2.5);
     test(lhs, rhs, x);
     }
+    return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp

 //   operator!=(const complex<T>& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr std::complex<T> lhs(1.5,  2.5);
     constexpr std::complex<T> rhs(1.5, -2.5);
     static_assert(lhs != rhs, "");
     }
     {
     constexpr std::complex<T> lhs(1.5, 2.5);
     constexpr std::complex<T> rhs(1.5, 2.5);
     static_assert(!(lhs != rhs), "" );
     }
 #endif
 }
 
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
     assert(!(lhs != rhs));
     }
 
     test_constexpr<T> ();
-    }
+    return true;
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//   test_constexpr<int> ();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp

 //   operator!=(const complex<T>& lhs, const T& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr std::complex<T> lhs(1.5,  2.5);
     constexpr T rhs(-2.5);
     static_assert(lhs != rhs, "");
     }
#if TEST_STD_VER > 11
     constexpr std::complex<T> lhs(1.5, 0);
     constexpr T rhs(1.5);
     static_assert( !(lhs != rhs), "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 bool
 test()
 {
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5,  0);
     T rhs(-2.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
     assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
     assert( !(lhs != rhs));
     }
 
     test_constexpr<T> ();
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int> ();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_plus_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const complex<T>& lhs, const complex<T>& rhs);
+//   operator+(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs + rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs,
+                               const std::complex<T>& rhs, std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(3.5, 4.5);
     std::complex<T>   x(5.0, 7.0);
     test(lhs, rhs, x);
-    }
     {
     std::complex<T> lhs(1.5, -2.5);
     std::complex<T> rhs(-3.5, 4.5);
     std::complex<T>   x(-2.0, 2.0);
     test(lhs, rhs, x);
     }
+
+    return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_plus_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const complex<T>& lhs, const T& rhs);
+//   operator+(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs + rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs, const T& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(3.5);
     std::complex<T>   x(5.0, 2.5);
     test(lhs, rhs, x);
-    }
     {
     std::complex<T> lhs(1.5, -2.5);
     T rhs(-3.5);
     std::complex<T>   x(-2.0, -2.5);
     test(lhs, rhs, x);
     }
+
+    return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_times_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator*(const complex<T>& lhs, const complex<T>& rhs);
+//   operator*(const complex<T>& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../cases.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs * rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs,
+                               const std::complex<T>& rhs, std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    std::complex<T> lhs(1.5, 2.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(-4.0, 7.5);
-    test(lhs, rhs, x);
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::complex<T> x(-4.0, 7.5);
+  return true;
 }
 
 // test edges
 
-void test_edges()
+TEST_CONSTEXPR_CXX20 bool test_edges()
 {
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         for (unsigned j = 0; j < N; ++j)
         {
             std::complex<double> r = testcases[i] * testcases[j];
             switch (classify(testcases[i]))
for (unsigned i = 0; i < N; ++i)
                 case non_zero_nan:
                     assert(classify(r) == NaN);
                     break;
                 }
                 break;
             }
         }
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
     test_edges();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+    static_assert(test_edges());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/complex_times_scalar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator*(const complex<T>& lhs, const T& rhs);
+//   operator*(const complex<T>& lhs, const T& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
-{
-    assert(lhs * rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const std::complex<T>& lhs, const T& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    std::complex<T> lhs(1.5, 2.5);
-    T rhs(1.5);
-    std::complex<T>   x(2.25, 3.75);
-    test(lhs, rhs, x);
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::complex<T> x(2.25, 3.75);
+  return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator/(const T& lhs, const complex<T>& rhs);
+//   operator/(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs / rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const T& lhs, const std::complex<T>& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    T lhs(-8.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(-1.5, 2.5);
-    test(lhs, rhs, x);
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::complex<T> x(-1.5, 2.5);
+  return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp

 //   operator==(const T& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr T lhs(-2.5);
     constexpr std::complex<T> rhs(1.5,  2.5);
     static_assert(!(lhs == rhs), "");
     }
#if TEST_STD_VER > 11
     constexpr T lhs(1.5);
     constexpr std::complex<T> rhs(1.5, 0);
     static_assert(lhs == rhs, "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 bool
 test()
 {
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
     assert(!(lhs == rhs));
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
     assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
     assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
     assert(lhs == rhs);
     }
 
     test_constexpr<T> ();
+    return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int>();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_minus_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const T& lhs, const complex<T>& rhs);
+//   operator-(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs - rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const T& lhs, const std::complex<T>& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     T lhs(1.5);
     std::complex<T> rhs(3.5, 4.5);
     std::complex<T>   x(-2.0, -4.5);
     test(lhs, rhs, x);
-    }
     {
     T lhs(1.5);
     std::complex<T> rhs(-3.5, 4.5);
     std::complex<T>   x(5.0, -4.5);
     test(lhs, rhs, x);
     }
+    return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp

 //   operator!=(const T& lhs, const complex<T>& rhs);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 void
 test_constexpr()
 {
 #if TEST_STD_VER > 11
     {
     constexpr T lhs(-2.5);
     constexpr std::complex<T> rhs(1.5,  2.5);
     static_assert (lhs != rhs, "");
     }
#if TEST_STD_VER > 11
     constexpr T lhs(1.5);
     constexpr std::complex<T> rhs(1.5, 0);
     static_assert (!(lhs != rhs), "");
     }
 #endif
 }
 
 template <class T>
-void
+TEST_CONSTEXPR_CXX20 bool
 test()
 {
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
     assert (lhs != rhs);
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
     assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
     assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
     assert (!(lhs != rhs));
     }
 
     test_constexpr<T> ();
-    }
+    return true;
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
-//     test_constexpr<int>();
+
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_plus_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const T& lhs, const complex<T>& rhs);
+//   operator+(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs + rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const T& lhs, const std::complex<T>& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    {
+TEST_CONSTEXPR_CXX20 bool test() {
     T lhs(1.5);
     std::complex<T> rhs(3.5, 4.5);
     std::complex<T>   x(5.0, 4.5);
     test(lhs, rhs, x);
-    }
     {
     T lhs(1.5);
     std::complex<T> rhs(-3.5, 4.5);
     std::complex<T>   x(-2.0, 4.5);
     test(lhs, rhs, x);
     }
+    return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/scalar_times_complex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator*(const T& lhs, const complex<T>& rhs);
+//   operator*(const T& lhs, const complex<T>& rhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
-{
-    assert(lhs * rhs == x);
+TEST_CONSTEXPR_CXX20 bool test(const T& lhs, const std::complex<T>& rhs,
+                               std::complex<T> x) {
+  return true;
 }
 
 template <class T>
-void
-test()
-{
-    T lhs(1.5);
-    std::complex<T> rhs(1.5, 2.5);
-    std::complex<T>   x(2.25, 3.75);
-    test(lhs, rhs, x);
+TEST_CONSTEXPR_CXX20 bool test() {
+  std::complex<T> x(2.25, 3.75);
+  return true;
 }
 
-int main(int, char**)
-{
-    test<float>();
-    test<double>();
-    test<long double>();
+int main(int, char**) {
 
+#if TEST_STD_VER > 17
+  static_assert(test<float>());
+  static_assert(test<double>());
+  static_assert(test<long double>());
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/unary_minus.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator-(const complex<T>& lhs);
+//   operator-(const complex<T>& lhs); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> z(1.5, 2.5);
-    assert(z.real() == 1.5);
-    assert(z.imag() == 2.5);
-    std::complex<T> c = -z;
-    assert(c.real() == -1.5);
-    assert(c.imag() == -2.5);
+TEST_CONSTEXPR_CXX20 bool test() {
+  assert(z.real() == T(1.5));
+  assert(z.imag() == T(2.5));
+  assert(c.real() == T(-1.5));
+  assert(c.imag() == T(-2.5));
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/complex.number/complex.ops/unary_plus.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
-//   operator+(const complex<T>&);
+//   operator+(const complex<T>&); // constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-void
-test()
-{
-    std::complex<T> z(1.5, 2.5);
-    assert(z.real() == 1.5);
-    assert(z.imag() == 2.5);
-    std::complex<T> c = +z;
-    assert(c.real() == 1.5);
-    assert(c.imag() == 2.5);
+TEST_CONSTEXPR_CXX20 bool test() {
+  assert(z.real() == T(1.5));
+  assert(z.imag() == T(2.5));
+  assert(c.real() == T(1.5));
+  assert(c.imag() == T(2.5));
+  return true;
 }
 
 int main(int, char**)
 {
     test<float>();
     test<double>();
     test<long double>();
 
+#if TEST_STD_VER > 17
+    static_assert(test<float>());
+    static_assert(test<double>());
+    static_assert(test<long double>());
+#endif
+
     return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

# C++2a
     "unimplemented": True,
     "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    }, {
     "name": "__cpp_lib_constexpr_dynamic_alloc",
     "values": { "c++2a": int(201907) },
     "headers": ["memory"]
    },
+  {"name": "__cpp_lib_constexpr_complex",
+   "values": {
+     "c++2a": int(201711),
+   },
+   "headers": ["complex"],
+   },
 ]], key=lambda tc: tc["name"])
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
 # For example, when threads are not supported, any feature-test-macro test
 # that includes <thread> should be marked as UNSUPPORTED, because including
 # <thread> is a hard error in that case.

libcxx/www/cxx2a_status.html

 -->
   <tr><td><a href="https://wg21.link/P0463R1">P0463R1</a></td><td>LWG</td><td>Endian just Endian</td><td>Toronto</td><td>Complete</td><td>7.0</td></tr>
   <tr><td><a href="https://wg21.link/P0674R1">P0674R1</a></td><td>LWG</td><td>Extending make_shared to Support Arrays</td><td>Toronto</td><td></td><td></td></tr>
 
     <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0020R6">P0020R6</a></td><td>LWG</td><td>Floating Point Atomic</td><td>Albuquerque</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0053R7">P0053R7</a></td><td>LWG</td><td>C++ Synchronized Buffered Ostream</td><td>Albuquerque</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0202R3">P0202R3</a></td><td>LWG</td><td>Add constexpr modifiers to functions in &lt;algorithm&gt; and &lt;utility&gt; Headers</td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0415R1">P0415R1</a></td><td>LWG</td><td>Constexpr for <tt>std::complex</tt></td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
+  <tr><td><a href="https://wg21.link/P0415R1">P0415R1</a></td><td>LWG</td><td>Constexpr for <tt>std::complex</tt></td><td>Albuquerque</td><td>Complete</td><td>12.0</td></tr>
   <tr><td><a href="https://wg21.link/P0439R0">P0439R0</a></td><td>LWG</td><td>Make <tt>std::memory_order</tt> a scoped enumeration</td><td>Albuquerque</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0457R2">P0457R2</a></td><td>LWG</td><td>String Prefix and Suffix Checking</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
   <tr><td><a href="https://wg21.link/P0550R2">P0550R2</a></td><td>LWG</td><td>Transformation Trait <tt>remove_cvref</tt></td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
   <tr><td><a href="https://wg21.link/P0600R1">P0600R1</a></td><td>LWG</td><td>nodiscard in the Library</td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
   <tr><td><a href="https://wg21.link/P0616R0">P0616R0</a></td><td>LWG</td><td>de-pessimize legacy <numeric> algorithms with std::move</td><td>Albuquerque</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0653R2">P0653R2</a></td><td>LWG</td><td>Utility to convert a pointer to a raw pointer</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
   <tr><td><a href="https://wg21.link/P0718R2">P0718R2</a></td><td>LWG</td><td>Atomic shared_ptr</td><td>Albuquerque</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0767R1">P0767R1</a></td><td>CWG</td><td>Deprecate POD</td><td>Albuquerque</td><td>Complete</td><td>7.0</td></tr>