Fix test mixed-type-safety-1.cpp.output

Author: filipsajdak

regression-tests/test-results/gcc-10-c++20/mixed-type-safety-1.cpp.output

@@ -49,14 +49,14 @@ auto use([[maybe_unused]] auto const& unnamed_param_1) -> void{}
 
 #line 16 "mixed-forwarding.cpp2"
 auto apply_implicit_forward(auto&& t) -> void
-requires (std::is_same_v<std::pair<X,X>, CPP2_TYPEOF(t)>) {
+CPP2_REQUIRES (std::is_same_v<std::pair<X,X>, CPP2_TYPEOF(t)>) {
 #line 17 "mixed-forwarding.cpp2"
     copy_from(t.first);             // copies
     copy_from(CPP2_FORWARD(t).second);// moves
 }
 #line 20 "mixed-forwarding.cpp2"
 auto apply_explicit_forward(auto&& t) -> void
-requires (std::is_same_v<std::pair<X,X>, CPP2_TYPEOF(t)>) {
+CPP2_REQUIRES (std::is_same_v<std::pair<X,X>, CPP2_TYPEOF(t)>) {
 #line 21 "mixed-forwarding.cpp2"
     copy_from(CPP2_FORWARD(t).first);// moves
     copy_from(CPP2_FORWARD(t).second);// moves

regression-tests/test-results/mixed-forwarding.cpp

@@ -132,10 +132,10 @@ auto operator--(number_line_pre_decrement<1>& x,int) -> number_line_pre_decremen
 
 #line 4 "mixed-increment-decrement.cpp2"
     template <typename T> auto iterator<T>::operator++() & -> iterator<T>&
-requires (true) {++x; return (*this); }
+CPP2_REQUIRES (true) {++x; return (*this); }
 #line 4 "mixed-increment-decrement.cpp2"
     template <typename T> auto iterator<T>::operator++(int) & -> iterator<T>
-requires (true)  { auto ret = *this; ++*this; return ret; }
+CPP2_REQUIRES (true)  { auto ret = *this; ++*this; return ret; }
 
 
     template <typename T> iterator<T>::iterator(iterator const& that)
@@ -163,26 +163,26 @@ template <typename T> auto iterator2<T>::operator=(iterator2&& that) noexcept ->
 template <typename T> iterator2<T>::iterator2(){}
 #line 10 "mixed-increment-decrement.cpp2"
 template<typename T> auto operator++(iterator2<T>& it) -> iterator2<T>&
-requires (true) {++it.x; return it; }
+CPP2_REQUIRES (true) {++it.x; return it; }
 #line 10 "mixed-increment-decrement.cpp2"
 template<typename T> auto operator++(iterator2<T>& it,int) -> iterator2<T>
-requires (true)  { auto ret = it; ++it; return ret; }
+CPP2_REQUIRES (true)  { auto ret = it; ++it; return ret; }
 
 #line 36 "mixed-increment-decrement.cpp2"
   [[nodiscard]] auto number::operator-([[maybe_unused]] auto const& unnamed_param_2) const& -> int { return 0;  }
 
 #line 48 "mixed-increment-decrement.cpp2"
 template<cpp2::i8 Op, cpp2::i32 Id> auto operator++(number_line<Op,Id>& x) -> number_line<Op,Id>&
-requires (bool(Op & 1))  { return x;  }
+CPP2_REQUIRES (bool(Op & 1))  { return x;  }
 #line 48 "mixed-increment-decrement.cpp2"
 template<cpp2::i8 Op, cpp2::i32 Id> auto operator++(number_line<Op,Id>& x,int) -> number_line<Op,Id>
-requires (bool(Op & 1))  { auto ret = x; ++x; return ret; }
+CPP2_REQUIRES (bool(Op & 1))  { auto ret = x; ++x; return ret; }
 #line 49 "mixed-increment-decrement.cpp2"
 template<cpp2::i8 Op, cpp2::i32 Id> auto operator--(number_line<Op,Id>& x) -> number_line<Op,Id>&
-requires (bool(Op & 2))  { return x;  }
+CPP2_REQUIRES (bool(Op & 2))  { return x;  }
 #line 49 "mixed-increment-decrement.cpp2"
 template<cpp2::i8 Op, cpp2::i32 Id> auto operator--(number_line<Op,Id>& x,int) -> number_line<Op,Id>
-requires (bool(Op & 2))  { auto ret = x; ++x; return ret; }
+CPP2_REQUIRES (bool(Op & 2))  { auto ret = x; ++x; return ret; }
 
 #line 51 "mixed-increment-decrement.cpp2"
 auto operator++(number_line_pre_increment<0>& x) -> number_line_pre_increment<0>& { return x;  }

regression-tests/test-results/mixed-increment-decrement.cpp

@@ -48,7 +48,7 @@ auto parameter_styles(
     std::string&& d, 
     auto&& e
     ) -> void
-requires (std::is_same_v<std::string, CPP2_TYPEOF(e)>) 
+CPP2_REQUIRES (std::is_same_v<std::string, CPP2_TYPEOF(e)>) 
 #line 15 "mixed-parameter-passing-with-forward.cpp2"
 {
     int z {12}; 

regression-tests/test-results/mixed-parameter-passing-with-forward.cpp

@@ -41,7 +41,7 @@ auto print(cpp2::impl::in<std::string> msg, cpp2::impl::in<bool> b) -> void;
 
 #line 13 "mixed-type-safety-1.cpp2"
 template<typename T> auto print(cpp2::impl::in<std::string> msg, T const& x) -> void
-requires (!(std::convertible_to<T,bool>))  { 
+CPP2_REQUIRES (!(std::convertible_to<T,bool>))  { 
 
 #line 15 "mixed-type-safety-1.cpp2"
     std::cout << msg << x << "\n";  }

regression-tests/test-results/mixed-type-safety-1.cpp

@@ -35,11 +35,11 @@ auto main() -> int;
 
 #line 3 "pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2"
   element::element(auto&& n)
-requires (std::is_same_v<std::string, CPP2_TYPEOF(n)>) 
+CPP2_REQUIRES (std::is_same_v<std::string, CPP2_TYPEOF(n)>) 
                                                     : name{ CPP2_FORWARD(n) }{}
 #line 3 "pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2"
   auto element::operator=(auto&& n) -> element& 
-requires (std::is_same_v<std::string, CPP2_TYPEOF(n)>) {
+CPP2_REQUIRES (std::is_same_v<std::string, CPP2_TYPEOF(n)>) {
                                                     name = CPP2_FORWARD(n);
                                                     return *this; }
 

regression-tests/test-results/pure2-bugfix-for-requires-clause-in-forward-declaration.cpp

@@ -21,7 +21,7 @@ auto main() -> int;
 
 #line 1 "pure2-bugfix-for-requires-clause-unbraced-function-initializer.cpp2"
 template<typename T> auto f() -> void
-requires (std::regular<T>)  { g(T());  }
+CPP2_REQUIRES (std::regular<T>)  { g(T());  }
 #line 2 "pure2-bugfix-for-requires-clause-unbraced-function-initializer.cpp2"
 auto main() -> int                 {}
 

regression-tests/test-results/pure2-bugfix-for-requires-clause-unbraced-function-initializer.cpp

@@ -22,7 +22,7 @@ auto main() -> int;
 
 #line 1 "pure2-function-multiple-forward-arguments.cpp2"
 auto fun(auto&& s1, auto&& s2, auto&& s3) -> void
-requires (std::is_same_v<std::string, CPP2_TYPEOF(s1)> && std::is_same_v<std::string, CPP2_TYPEOF(s2)> && std::is_same_v<std::string, CPP2_TYPEOF(s3)>) {
+CPP2_REQUIRES (std::is_same_v<std::string, CPP2_TYPEOF(s1)> && std::is_same_v<std::string, CPP2_TYPEOF(s2)> && std::is_same_v<std::string, CPP2_TYPEOF(s3)>) {
 #line 2 "pure2-function-multiple-forward-arguments.cpp2"
     std::cout << CPP2_FORWARD(s1) << CPP2_FORWARD(s2) << CPP2_FORWARD(s3) << std::endl;
 }

regression-tests/test-results/pure2-function-multiple-forward-arguments.cpp

@@ -558,13 +558,13 @@ auto f_copy([[maybe_unused]] auto ...unnamed_param_1) -> void{}
 [[nodiscard]] auto pred_copy([[maybe_unused]] auto ...unnamed_param_1) -> auto { return true;  }
 #line 5 "pure2-last-use.cpp2"
 template<typename T> [[nodiscard]] constexpr auto identity(T&& x) -> auto&&
-requires (std::is_reference_v<T>) {return CPP2_FORWARD(x); }
+CPP2_REQUIRES (std::is_reference_v<T>) {return CPP2_FORWARD(x); }
 #line 6 "pure2-last-use.cpp2"
 [[nodiscard]] auto identity_copy(auto x) -> auto
-requires (std::copyable<decltype(x)>)  { return cpp2::move(x); }
+CPP2_REQUIRES (std::copyable<decltype(x)>)  { return cpp2::move(x); }
 #line 7 "pure2-last-use.cpp2"
 [[nodiscard]] auto identity_copy(auto&& x) -> auto
-requires (!(std::copyable<decltype(x)>))  { return std::move(cpp2::move(x));  }
+CPP2_REQUIRES (!(std::copyable<decltype(x)>))  { return std::move(cpp2::move(x));  }
 
 #line 9 "pure2-last-use.cpp2"
 auto issue_313() -> void{

regression-tests/test-results/pure2-last-use.cpp

@@ -89,7 +89,7 @@ bool testing_enabled {false};
 
 #line 8 "pure2-print.cpp2"
     template<typename T> 
-requires (true) inline CPP2_CONSTEXPR T outer::object_alias{ 42 };
+CPP2_REQUIRES (true) inline CPP2_CONSTEXPR T outer::object_alias{ 42 };
 #line 9 "pure2-print.cpp2"
 
 #line 12 "pure2-print.cpp2"
@@ -163,7 +163,7 @@ requires (true) inline CPP2_CONSTEXPR T outer::object_alias{ 42 };
 
 #line 67 "pure2-print.cpp2"
         auto outer::mytype::variadic(auto const& ...x) -> void
-requires ((std::is_convertible_v<CPP2_TYPEOF(x), int> && ...)) {(std::cout << ... << x); }
+CPP2_REQUIRES ((std::is_convertible_v<CPP2_TYPEOF(x), int> && ...)) {(std::cout << ... << x); }
 
 #line 70 "pure2-print.cpp2"
     auto outer::test() -> void{
@@ -190,7 +190,7 @@ requires ((std::is_convertible_v<CPP2_TYPEOF(x), int> && ...)) {(std::cout << ..
 
 #line 96 "pure2-print.cpp2"
     template<typename ...Args> auto outer::print(std::ostream& out, Args const& ...args) -> void
-requires (cpp2::impl::cmp_greater_eq(sizeof...(Args),0u)) {
+CPP2_REQUIRES (cpp2::impl::cmp_greater_eq(sizeof...(Args),0u)) {
 #line 97 "pure2-print.cpp2"
         (out << ... << args);
     }

regression-tests/test-results/pure2-print.cpp

@@ -59,7 +59,7 @@ X<T,U>::X(){}
 #line 10 "pure2-requires-clauses.cpp2"
 template<typename T, typename U> [[nodiscard]] auto f
     (auto&& a, auto&& b) -> int
-requires (std::is_same_v<T,int> && std::is_same_v<U,int> && std::is_same_v<int, CPP2_TYPEOF(a)> && std::is_same_v<int, CPP2_TYPEOF(b)>) 
+CPP2_REQUIRES (std::is_same_v<T,int> && std::is_same_v<U,int> && std::is_same_v<int, CPP2_TYPEOF(a)> && std::is_same_v<int, CPP2_TYPEOF(b)>) 
 
 #line 14 "pure2-requires-clauses.cpp2"
 {
@@ -68,11 +68,11 @@ requires (std::is_same_v<T,int> && std::is_same_v<U,int> && std::is_same_v<int,
 
 #line 18 "pure2-requires-clauses.cpp2"
 [[nodiscard]] constexpr auto f(auto const& x) -> int
-requires (true)  { return x;  }
+CPP2_REQUIRES (true)  { return x;  }
 
 #line 20 "pure2-requires-clauses.cpp2"
 template<typename T> 
-requires (std::same_as<T,cpp2::i32>) T const v {0}; 
+CPP2_REQUIRES (std::same_as<T,cpp2::i32>) T const v {0}; 
 
 #line 22 "pure2-requires-clauses.cpp2"
 auto main() -> int{

regression-tests/test-results/pure2-requires-clauses.cpp

@@ -39,7 +39,7 @@ auto main() -> int;
 
 #line 2 "pure2-type-constraints.cpp2"
 auto print(auto const& r) -> void
-requires (std::regular<CPP2_TYPEOF(r)>) {
+CPP2_REQUIRES (std::regular<CPP2_TYPEOF(r)>) {
 #line 3 "pure2-type-constraints.cpp2"
     std::cout << "satisfies std::regular\n";
 }

regression-tests/test-results/pure2-type-constraints.cpp

@@ -5612,7 +5612,7 @@ class cppfront
                     }
                 }
                 else {
-                    printer.print_extra("requires (");
+                    printer.print_extra("CPP2_REQUIRES (");
                 }
 
                 if (n.requires_clause_expression) {