Implement most of P0451 - Constexpr for std::complex

[mclow.lists]

Summary

This patch implements most of https://wg21.link/P0451r1 - the notable exception being division.
The current implementation of complex division in libc++ uses logb, fmax, and a couple of other primitives that are not constexpr. The paper has some approaches for dealing with this, but I haven't implemented those yet. I wanted to get all the mechanical bits out first.

Note that there are tests for division being constexpr; they currently fail.

[mclow.lists]

More context in the diff, and removed some tabs.
Also commented out the constexpr tests for divide, since they fail at the moment.

include/complex

public:
     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);
 
-    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<T>& operator= (const T&);  // constexpr in C++2a
+    complex<T>& operator+=(const T&);  // constexpr in C++2a
+    complex<T>& operator-=(const T&);  // constexpr in C++2a
+    complex<T>& operator*=(const T&);  // constexpr in C++2a
+    complex<T>& operator/=(const T&);  // constexpr in C++2a
 
     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>&);
+    template<class X> complex<T>& operator= (const complex<X>&); // constexpr in C++2a
+    template<class X> complex<T>& operator+=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<T>& operator-=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<T>& operator*=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<T>& operator/=(const complex<X>&); // constexpr in C++2a
 };
 
 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);
-    constexpr float imag() const;
-    void imag(float);
-
-    complex<float>& operator= (float);
-    complex<float>& operator+=(float);
-    complex<float>& operator-=(float);
-    complex<float>& operator*=(float);
-    complex<float>& operator/=(float);
+    constexpr float real() const;  // constexpr in C++14
+    void real(float);              // constexpr in C++2a
+    constexpr float imag() const;  // constexpr in C++14
+    void imag(float);              // constexpr in C++2a
+
+    complex<float>& operator= (float);  // constexpr in C++2a
+    complex<float>& operator+=(float);  // constexpr in C++2a
+    complex<float>& operator-=(float);  // constexpr in C++2a
+    complex<float>& operator*=(float);  // constexpr in C++2a
+    complex<float>& operator/=(float);  // constexpr in C++2a
 
     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>&);
+    template<class X> complex<float>& operator= (const complex<X>&); // constexpr in C++2a
+    template<class X> complex<float>& operator+=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<float>& operator-=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<float>& operator*=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<float>& operator/=(const complex<X>&); // constexpr in C++2a
 };
 
 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);
-    constexpr double imag() const;
-    void imag(double);
-
-    complex<double>& operator= (double);
-    complex<double>& operator+=(double);
-    complex<double>& operator-=(double);
-    complex<double>& operator*=(double);
-    complex<double>& operator/=(double);
+    constexpr double real() const; // constexpr in C++14
+    void real(double);             // constexpr in C++2a
+    constexpr double imag() const; // constexpr in C++14
+    void imag(double);             // constexpr in C++2a
+
+    complex<double>& operator= (double);  // constexpr in C++2a
+    complex<double>& operator+=(double);  // constexpr in C++2a
+    complex<double>& operator-=(double);  // constexpr in C++2a
+    complex<double>& operator*=(double);  // constexpr in C++2a
+    complex<double>& operator/=(double);  // constexpr in C++2a
     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>&);
+    template<class X> complex<double>& operator= (const complex<X>&); // constexpr in C++2a
+    template<class X> complex<double>& operator+=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<double>& operator-=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<double>& operator*=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<double>& operator/=(const complex<X>&); // constexpr in C++2a
 };
 
 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);
-    constexpr long double imag() const;
-    void imag(long double);
-
+    constexpr long double real() const; // constexpr in C++14
+    void real(long double);             // constexpr in C++2a
+    constexpr long double imag() const; // constexpr in C++14
+    void imag(double);                  // constexpr in C++2a
+
+    complex<long double>& operator= (long double);  // constexpr in C++2a
+    complex<long double>& operator+=(long double);  // constexpr in C++2a
+    complex<long double>& operator-=(long double);  // constexpr in C++2a
+    complex<long double>& operator*=(long double);  // constexpr in C++2a
+    complex<long double>& operator/=(long double);  // constexpr in C++2a
     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>&);
+
+    template<class X> complex<long double>& operator= (const complex<X>&); // constexpr in C++2a
+    template<class X> complex<long double>& operator+=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<long double>& operator-=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<long double>& operator*=(const complex<X>&); // constexpr in C++2a
+    template<class X> complex<long double>& operator/=(const complex<X>&); // constexpr in C++2a
 };
 
 // 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> 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> complex<T> operator+(const complex<T>&, const complex<T>&); // constexpr in C++2a
+template<class T> complex<T> operator+(const complex<T>&, const T&);          // constexpr in C++2a
+template<class T> complex<T> operator+(const T&, const complex<T>&);          // constexpr in C++2a
+template<class T> complex<T> operator-(const complex<T>&, const complex<T>&); // constexpr in C++2a
+template<class T> complex<T> operator-(const complex<T>&, const T&);          // constexpr in C++2a
+template<class T> complex<T> operator-(const T&, const complex<T>&);          // constexpr in C++2a
+template<class T> complex<T> operator*(const complex<T>&, const complex<T>&); // constexpr in C++2a
+template<class T> complex<T> operator*(const complex<T>&, const T&);          // constexpr in C++2a
+template<class T> complex<T> operator*(const T&, const complex<T>&);          // constexpr in C++2a
+template<class T> complex<T> operator/(const complex<T>&, const complex<T>&); // constexpr in C++2a
+template<class T> complex<T> operator/(const complex<T>&, const T&);          // constexpr in C++2a
+template<class T> complex<T> operator/(const T&, const complex<T>&);          // constexpr in C++2a
+template<class T> complex<T> operator+(const complex<T>&);                    // constexpr in C++2a
+template<class T> complex<T> operator-(const complex<T>&);                    // constexpr in C++2a
+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>
   basic_istream<charT, traits>&
   operator>>(basic_istream<charT, traits>&, complex<T>&);
 template<class T, class charT, class traits>
   basic_ostream<charT, traits>&
   operator<<(basic_ostream<charT, traits>&, const complex<T>&);
 

 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>&);
+template<class T>              T norm(const complex<T>&);  // constexpr in C++2a
                      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>&);
+template<class T>      complex<T>           conj(const complex<T>&);  // constexpr in C++2a
                        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>           proj(const complex<T>&);
+template<class T>    complex<T>           proj(const complex<T>&);  // constexpr in C++2a
                      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& = 0);
 
 // 26.3.8 transcendentals:

 #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> _LIBCPP_CONSTEXPR_AFTER_CXX17 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>
 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 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 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void imag(value_type __im) {__im_ = __im;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    complex& operator= (const value_type& __re) {__re_ = __re; __im_ = value_type(); 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 _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 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 void real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 void imag(value_type __im) {__im_ = __im;}
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    complex& operator= (float __re) {__re_ = __re; __im_ = value_type(); 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 _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)
-        {__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;}
-
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    complex& operator= (double __re) {__re_ = __re; __im_ = value_type(); 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 _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 void _LIBCPP_CONSTEXPR_AFTER_CXX17 real(value_type __re) {__re_ = __re;}
+    _LIBCPP_INLINE_VISIBILITY void _LIBCPP_CONSTEXPR_AFTER_CXX17 imag(value_type __im) {__im_ = __im;}
 
-    _LIBCPP_INLINE_VISIBILITY 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;}
-
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    complex& operator= (long double __re) {__re_ = __re; __im_ = value_type(); 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 _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;
 }
 
 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();
     _Tp __ac = __a * __c;
if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
             __x = _Tp(INFINITY) * (__a * __c - __b * __d);
             __y = _Tp(INFINITY) * (__a * __d + __b * __c);
         }
     }
     return complex<_Tp>(__x, __y);
 }
 
 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>
+// _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();
if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
             __x = _Tp(0) * (__a * __c + __b * __d);
             __y = _Tp(0) * (__b * __c - __a * __d);
         }
     }
     return complex<_Tp>(__x, __y);
 }
 
 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);
 }
 
 
 
 // proj
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 complex<_Tp>
 proj(const complex<_Tp>& __c)
 {
     std::complex<_Tp> __r = __c;
     if (__libcpp_isinf_or_builtin(__c.real()) || __libcpp_isinf_or_builtin(__c.imag()))
         __r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
     return __r;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     is_floating_point<_Tp>::value,
     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 >::type
 proj(_Tp __re)
 {
     if (__libcpp_isinf_or_builtin(__re))
         __re = abs(__re);
     return complex<_Tp>(__re);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     is_integral<_Tp>::value,
     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 >::type
 proj(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator= (const T&);
+// constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(std::complex<T> lhs, const T& rhs)
+{
+    return (lhs = rhs) == rhs;
+}
+
 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);
+
+#if TEST_STD_VER > 17
+    TEST_CONSTEXPR std::complex<T> c1{8,-2};
+    static_assert(constexpr_test(c1, T(2)), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator/=(const T& rhs);
+// constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(std::complex<T> lhs, const T& rhs, const std::complex<T>& expected)
+{
+    return (lhs /= rhs) == expected;
+}
+
 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);
+
+#if TEST_STD_VER > 17
+    TEST_CONSTEXPR std::complex<T> c1{8,-2};
+    TEST_CONSTEXPR std::complex<T> c2{4,-1};
+    static_assert(constexpr_test(c1, T(2), c2), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator-=(const T& rhs);
+// constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(std::complex<T> lhs, const T& rhs, const std::complex<T>& expected)
+{
+    return (lhs -= rhs) == expected;
+}
+
 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);
+
+#if TEST_STD_VER > 17
+    TEST_CONSTEXPR std::complex<T> c1{6,-1};
+    TEST_CONSTEXPR std::complex<T> c2{4,-1};
+    static_assert(constexpr_test(c1, T(2), c2), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator+=(const T& rhs);
+// constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(std::complex<T> lhs, const T& rhs, const std::complex<T>& expected)
+{
+    return (lhs += rhs) == expected;
+}
+
 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);
+
+#if TEST_STD_VER > 17
+    TEST_CONSTEXPR std::complex<T> c1{4,-1};
+    TEST_CONSTEXPR std::complex<T> c2{6,-1};
+    static_assert(constexpr_test(c1, T(2), c2), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // complex& operator*=(const T& rhs);
+// constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(std::complex<T> lhs, const T& rhs, const std::complex<T>& expected)
+{
+    return (lhs *= rhs) == expected;
+}
+
 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);
+
+#if TEST_STD_VER > 17
+    TEST_CONSTEXPR std::complex<T> c1{4,-1};
+    TEST_CONSTEXPR std::complex<T> c2{8,-2};
+    static_assert(constexpr_test(c1, T(2), c2), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 // void imag(T val);
 
 #include <complex>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_real(T val)
+{
+    std::complex<T> c1{};
+    c1.real(val);
+    return c1.real() == val;
+}
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_imag(T val)
+{
+    std::complex<T> c1{};
+    c1.imag(val);
+    return c1.imag() == val;
+}
+
+template <class T>
 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
+#if TEST_STD_VER > 17
+    static_assert(constexpr_real<T>(T(4.7)), "" );
+    static_assert(constexpr_imag<T>(T(4.7)), "" );
+#endif
 }
 
 template <class T>
 void
 test()
 {
     std::complex<T> c;
     assert(c.real() == 0);

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs / rhs == x;
+}
+
+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_CONSTEXPR std::complex<T> lhs(-4.0, 7.5);
+    TEST_CONSTEXPR std::complex<T> rhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T>   x(1.5, 2.5);
     test(lhs, rhs, x);
+// #if TEST_STD_VER > 17
+//     static_assert(constexpr_test(lhs, rhs, x), "");
+// #endif
 }
 
 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)

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test (const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
+{
+    return lhs / rhs == x;
+}
+
+template <class T>
 void
 test()
 {
-    std::complex<T> lhs(-4.0, 7.5);
-    T rhs(2);
-    std::complex<T>   x(-2, 3.75);
+    TEST_CONSTEXPR std::complex<T> lhs(-4.0, 7.5);
+    TEST_CONSTEXPR T rhs(2);
+    TEST_CONSTEXPR std::complex<T>   x(-2, 3.75);
     test(lhs, rhs, x);
+// #if TEST_STD_VER > 17
+//     static_assert(constexpr_test(lhs, rhs, x), "");
+// #endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs - rhs == x;
+}
+
+template <class T>
 void
 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_CONSTEXPR std::complex<T> lhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T> rhs(3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(-2.0, -2.0);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
     {
-    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_CONSTEXPR std::complex<T> lhs(1.5, -2.5);
+    TEST_CONSTEXPR std::complex<T> rhs(-3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(5.0, -7.0);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs + rhs == x;
+}
+
+template <class T>
 void
 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_CONSTEXPR std::complex<T> lhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T> rhs(3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(5.0, 7.0);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
     {
-    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_CONSTEXPR std::complex<T> lhs(1.5, -2.5);
+    TEST_CONSTEXPR std::complex<T> rhs(-3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(-2.0, 2.0);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
+{
+    return lhs + rhs == x;
+}
+
+template <class T>
 void
 test()
 {
     {
-    std::complex<T> lhs(1.5, 2.5);
-    T rhs(3.5);
-    std::complex<T>   x(5.0, 2.5);
+    TEST_CONSTEXPR std::complex<T> lhs(1.5, 2.5);
+    TEST_CONSTEXPR T rhs(3.5);
+    TEST_CONSTEXPR std::complex<T>   x(5.0, 2.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
     {
-    std::complex<T> lhs(1.5, -2.5);
-    T rhs(-3.5);
-    std::complex<T>   x(-2.0, -2.5);
+    TEST_CONSTEXPR std::complex<T> lhs(1.5, -2.5);
+    TEST_CONSTEXPR T rhs(-3.5);
+    TEST_CONSTEXPR std::complex<T>   x(-2.0, -2.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs * rhs == x;
+}
+
+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_CONSTEXPR std::complex<T> lhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T> rhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T>   x(-4.0, 7.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
 }
 
 // test edges
 
 void test_edges()
 {
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T>& lhs, const T& rhs, std::complex<T> x)
+{
+    return lhs * rhs == x;
+}
+
+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_CONSTEXPR std::complex<T> lhs(1.5, 2.5);
+    TEST_CONSTEXPR T rhs(1.5);
+    TEST_CONSTEXPR std::complex<T>   x(2.25, 3.75);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs / rhs == x;
+}
+
+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_CONSTEXPR T lhs(-8.5);
+    TEST_CONSTEXPR std::complex<T> rhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T>   x(-1.5, 2.5);
     test(lhs, rhs, x);
+// #if TEST_STD_VER > 17
+//     static_assert(constexpr_test(lhs, rhs, x), "");
+// #endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs - rhs == x;
+}
+
+template <class T>
 void
 test()
 {
     {
-    T lhs(1.5);
-    std::complex<T> rhs(3.5, 4.5);
-    std::complex<T>   x(-2.0, -4.5);
+    TEST_CONSTEXPR T lhs(1.5);
+    TEST_CONSTEXPR std::complex<T> rhs(3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(-2.0, -4.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
     {
-    T lhs(1.5);
-    std::complex<T> rhs(-3.5, 4.5);
-    std::complex<T>   x(5.0, -4.5);
+    TEST_CONSTEXPR T lhs(1.5);
+    TEST_CONSTEXPR std::complex<T> rhs(-3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(5.0, -4.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs + rhs == x;
+}
+
+template <class T>
 void
 test()
 {
     {
-    T lhs(1.5);
-    std::complex<T> rhs(3.5, 4.5);
-    std::complex<T>   x(5.0, 4.5);
+    TEST_CONSTEXPR T lhs(1.5);
+    TEST_CONSTEXPR std::complex<T> rhs(3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(5.0, 4.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
     {
-    T lhs(1.5);
-    std::complex<T> rhs(-3.5, 4.5);
-    std::complex<T>   x(-2.0, 4.5);
+    TEST_CONSTEXPR T lhs(1.5);
+    TEST_CONSTEXPR std::complex<T> rhs(-3.5, 4.5);
+    TEST_CONSTEXPR std::complex<T>   x(-2.0, 4.5);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
     }
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   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);
 }
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const T& lhs, const std::complex<T>& rhs, std::complex<T> x)
+{
+    return lhs * rhs == x;
+}
+
+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_CONSTEXPR T lhs(1.5);
+    TEST_CONSTEXPR std::complex<T> rhs(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T>   x(2.25, 3.75);
     test(lhs, rhs, x);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(lhs, rhs, x), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   operator-(const complex<T>& lhs);
+//   constexpr in c++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T> &z)
+{
+    std::complex<T> c = -z;
+    return c.real() == -z.real() && c.imag() == -z.imag();
+}
+
 template <class T>
 void
 test()
 {
-    std::complex<T> z(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T> z(1.5, 2.5);
     assert(z.real() == 1.5);
     assert(z.imag() == 2.5);
-    std::complex<T> c = -z;
+    TEST_CONSTEXPR std::complex<T> c = -z;
     assert(c.real() == -1.5);
     assert(c.imag() == -2.5);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(z), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   operator+(const complex<T>&);
+//   constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T> &z)
+{
+    std::complex<T> c = +z;
+    return c.real() == z.real() && c.imag() == z.imag();
+}
+
 template <class T>
 void
 test()
 {
-    std::complex<T> z(1.5, 2.5);
+    TEST_CONSTEXPR std::complex<T> z(1.5, 2.5);
     assert(z.real() == 1.5);
     assert(z.imag() == 2.5);
-    std::complex<T> c = +z;
+    TEST_CONSTEXPR std::complex<T> c = +z;
     assert(c.real() == 1.5);
     assert(c.imag() == 2.5);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(z), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

test/std/numerics/complex.number/complex.value.ops/conj.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   conj(const complex<T>& x);
+//   constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T> &z, std::complex<T> x)
+{
+    return conj(z) == x;
+}
+
 template <class T>
 void
 test(const std::complex<T>& z, std::complex<T> x)
 {
     assert(conj(z) == x);
 }
 
 template <class T>
 void
 test()
 {
-    test(std::complex<T>(1, 2), std::complex<T>(1, -2));
-    test(std::complex<T>(-1, 2), std::complex<T>(-1, -2));
-    test(std::complex<T>(1, -2), std::complex<T>(1, 2));
-    test(std::complex<T>(-1, -2), std::complex<T>(-1, 2));
+    typedef std::complex<T> C;
+    
+    TEST_CONSTEXPR C v12  ( 1,  2);
+    TEST_CONSTEXPR C v1_2 ( 1, -2);
+    TEST_CONSTEXPR C v_12 (-1,  2);
+    TEST_CONSTEXPR C v_1_2(-1, -2);
+    
+    test(v12,   v1_2);
+    test(v_12,  v_1_2);
+    test(v1_2,  v12);
+    test(v_1_2, v_12);
+
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(v12,   v1_2 ), "");
+    static_assert(constexpr_test(v_12,  v_1_2), "");
+    static_assert(constexpr_test(v1_2,  v12  ), "");
+    static_assert(constexpr_test(v_1_2, v_12 ), "");
+#endif
+    
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

test/std/numerics/complex.number/complex.value.ops/imag.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   T
 //   imag(const complex<T>& x);
+//   constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test()
+{
+    std::complex<T> z(1.5, 2.5);
+    return imag(z) == 2.5;
+}
+
 template <class T>
 void
 test()
 {
     std::complex<T> z(1.5, 2.5);
     assert(imag(z) == 2.5);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test<T>(), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }

test/std/numerics/complex.number/complex.value.ops/norm.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   T
 //   norm(const complex<T>& x);
+//   constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
 #include "../cases.h"
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T> &z, T expected)
+{
+    return norm(z) == expected;
+}
+
+template <class T>
 void
 test()
 {
-    std::complex<T> z(3, 4);
+    TEST_CONSTEXPR std::complex<T> z(3, 4);
     assert(norm(z) == 25);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test<T>(z, 25), "");
+#endif
 }
 
 void test_edges()
 {
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         double r = norm(testcases[i]);

test/std/numerics/complex.number/complex.value.ops/proj.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   complex<T>
 //   proj(const complex<T>& x);
+//   constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
 #include "../cases.h"
 
 template <class T>
+TEST_CONSTEXPR bool
+constexpr_test(const std::complex<T> &z, std::complex<T> x)
+{
+    return proj(z) == x;
+}
+
+
+template <class T>
 void
 test(const std::complex<T>& z, std::complex<T> x)
 {
     assert(proj(z) == x);
 }
 
 template <class T>
 void
 test()
 {
-    test(std::complex<T>(1, 2), std::complex<T>(1, 2));
-    test(std::complex<T>(-1, 2), std::complex<T>(-1, 2));
-    test(std::complex<T>(1, -2), std::complex<T>(1, -2));
-    test(std::complex<T>(-1, -2), std::complex<T>(-1, -2));
+    typedef std::complex<T> C;
+    
+    TEST_CONSTEXPR C v12  ( 1,  2);
+    TEST_CONSTEXPR C v1_2 ( 1, -2);
+    TEST_CONSTEXPR C v_12 (-1,  2);
+    TEST_CONSTEXPR C v_1_2(-1, -2);
+    
+    test(v12,   v12);
+    test(v_12,  v_12);
+    test(v1_2,  v1_2);
+    test(v_1_2, v_1_2);
+
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test(v12,   v12), "");
+    static_assert(constexpr_test(v_12,  v_12), "");
+    static_assert(constexpr_test(v1_2,  v1_2), "");
+    static_assert(constexpr_test(v_1_2, v_1_2), "");
+#endif
 }
 
 void test_edges()
 {
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
         std::complex<double> r = proj(testcases[i]);

test/std/numerics/complex.number/complex.value.ops/real.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <complex>
 
 // template<class T>
 //   T
 //   real(const complex<T>& x);
+//   constexpr in C++20
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
+template <class T>
+TEST_CONSTEXPR bool
+constexpr_test()
+{
+    std::complex<T> z(1.5, 2.5);
+    return real(z) == 1.5;
+}
+
 template <class T>
 void
 test()
 {
     std::complex<T> z(1.5, 2.5);
     assert(real(z) == 1.5);
+#if TEST_STD_VER > 17
+    static_assert(constexpr_test<T>(), "");
+#endif
 }
 
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
 }