Remove uses of __ that would be visible to Cpp1

I used `__` (double underscore) in some names on the grounds that I considered cppfront part of the implementation, but it's not part of the ISO C++ implementation and it's just barely possible that some of the uses could conflict with some implementation macro, so let's just avoid it for compatibility's sake

Also take out `enum` streaming for now while I work further on friend lowering

Author: hsutter

include/cpp2util.h

@@ -17,8 +17,8 @@
 //      #include'd by generated Cpp1 code
 //===========================================================================
 
-#ifndef __CPP2_UTIL
-#define __CPP2_UTIL
+#ifndef CPP2_UTIL_H
+#define CPP2_UTIL_H
 
 //  If this implementation doesn't support source_location yet, disable it
 //  TODO: technically this test should have <version> included first, but GEFN
@@ -241,6 +241,14 @@
                                     // these redundant goto's to avoid 'unused label' warnings
 
 
+#if defined(_MSC_VER)
+   // MSVC can't handle 'inline constexpr' yet in all cases
+    #define CPP2_CONSTEXPR const
+#else
+    #define CPP2_CONSTEXPR constexpr
+#endif
+
+
 namespace cpp2 {
 
 
@@ -265,18 +273,18 @@ using u32       = std::uint32_t      ;
 using u64       = std::uint64_t      ;
 
 //  Discouraged: Variable precision names
-//                short
-using ushort    = unsigned short;
-//                int
-using ulong     = unsigned long;
-//                long
-using longlong  = long long;
-using ulonglong = unsigned long long;
+//                 short
+using ushort     = unsigned short;
+//                 int
+using ulong      = unsigned long;
+//                 long
+using longlong   = long long;
+using ulonglong  = unsigned long long;
 using longdouble = long double;
 
 //  Strongly discouraged, for compatibility/interop only
-using __schar   = signed char;      // normally use i8 instead
-using __uchar   = unsigned char;    // normally use u8 instead
+using _schar     = signed char;      // normally use i8 instead
+using _uchar     = unsigned char;    // normally use u8 instead
 
 
 //-----------------------------------------------------------------------

regression-tests/pure2-enum.cpp2

@@ -41,7 +41,6 @@ main: () = {
 
     std::cout << "x.to_string() is (x.to_string())$\n";
     std::cout << "x2.to_string() is (x2.to_string())$\n";
-    std::cout << "using << prints " << x << "\n";
 
     std::cout << "with if else: ";
     if x == skat_game::diamonds {       // ok, can compare two skat_games
@@ -85,13 +84,13 @@ main: () = {
     f2 := file_attributes::cached;
     std::cout << "f2.get_raw_value() is (f2.get_raw_value())$\n";
 
-    std::cout << "f  is " << f  << "\n";
-    std::cout << "f2 is " << f2 << "\n";
+    std::cout << "f  is " << f.to_string() << "\n";
+    std::cout << "f2 is " << f2.to_string() << "\n";
 
     f2.clear( f2 );
-    std::cout << "f2 is " << f2 << "\n";
+    std::cout << "f2 is " << f2.to_string() << "\n";
     f2.set(file_attributes::cached);
-    std::cout << "f2 is " << f2 << "\n";
+    std::cout << "f2 is " << f2.to_string() << "\n";
 
     std::cout << "f. get_raw_value() is (f. get_raw_value())$\n";
     std::cout << "f2.get_raw_value() is (f2.get_raw_value())$\n";
@@ -104,8 +103,8 @@ main: () = {
     f  |= file_attributes::obsolete;
     f2 |= file_attributes::current;
 
-    std::cout << "f  is " << f  << "\n";
-    std::cout << "f2 is " << f2 << "\n";
+    std::cout << "f  is " << f.to_string() << "\n";
+    std::cout << "f2 is " << f2.to_string() << "\n";
     std::cout << "f. get_raw_value() is (f. get_raw_value())$\n";
     std::cout << "f2.get_raw_value() is (f2.get_raw_value())$\n";
     std::cout << "f  == f2   is (f  == f2  )$\n";

regression-tests/test-results/clang-12/pure2-enum.cpp.execution

@@ -1,6 +1,5 @@
 x.to_string() is clubs
 x2.to_string() is clubs
-using << prints clubs
 with if else: clubs
 with inspect: clubs
 

regression-tests/test-results/clang-12/pure2-print.cpp.output

@@ -1,5 +1,5 @@
 pure2-print.cpp2:52:80: warning: unused parameter 't' [-Wunused-parameter]
-        template<typename T> [[nodiscard]] auto outer::mytype::values(T const& t) const& -> values__ret{
+        template<typename T> [[nodiscard]] auto outer::mytype::values(T const& t) const& -> values_ret{
                                                                                ^
 pure2-print.cpp2:63:53: warning: unused parameter 'x' [-Wunused-parameter]
         auto outer::mytype::variadic(auto const& ...x) -> void{}

regression-tests/test-results/gcc-10/pure2-enum.cpp.execution

@@ -1,6 +1,5 @@
 x.to_string() is clubs
 x2.to_string() is clubs
-using << prints clubs
 with if else: clubs
 with inspect: clubs
 

regression-tests/test-results/gcc-10/pure2-print.cpp.output

@@ -3,8 +3,8 @@ In file included from pure2-print.cpp:7:
 pure2-print.cpp2:7:1: note: in expansion of macro ‘CPP2_REQUIRES_’
 ../../../include/cpp2util.h:10005:33: error: expected initializer before ‘static_assert’
 pure2-print.cpp2:89:1: note: in expansion of macro ‘CPP2_REQUIRES_’
-pure2-print.cpp2:6:24: error: ‘constexpr const T outer::object_alias’ is not a static data member of ‘class outer’
-pure2-print.cpp2:6:31: error: template definition of non-template ‘constexpr const T outer::object_alias’
+pure2-print.cpp2:6:29: error: ‘constexpr const T outer::object_alias’ is not a static data member of ‘class outer’
+pure2-print.cpp2:6:36: error: template definition of non-template ‘constexpr const T outer::object_alias’
 pure2-print.cpp2:88:37: error: no declaration matches ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::cmp_greater_eq(sizeof (Args)..., 0)’
 pure2-print.cpp2:88:37: note: no functions named ‘void outer::print(std::ostream&, const Args& ...) requires  cpp2::cmp_greater_eq(sizeof (Args)..., 0)’
 pure2-print.cpp2:4:7: note: ‘class outer’ defined here

regression-tests/test-results/gcc-13/pure2-enum.cpp.execution

@@ -1,6 +1,5 @@
 x.to_string() is clubs
 x2.to_string() is clubs
-using << prints clubs
 with if else: clubs
 with inspect: clubs
 

regression-tests/test-results/mixed-inspect-templates.cpp

@@ -32,11 +32,11 @@ struct my_type {};
 
 #line 8 "mixed-inspect-templates.cpp2"
 [[nodiscard]] auto fun(auto const& v) -> std::string{
-    return [&] () -> std::string { auto&& __expr = v;
-        if (cpp2::is<std::vector>(__expr)) { if constexpr( requires{"std::vector";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::vector")),std::string> ) return "std::vector"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::array>(__expr)) { if constexpr( requires{"std::array";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::array")),std::string> ) return "std::array"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::variant>(__expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<my_type>(__expr)) { if constexpr( requires{"my_type";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("my_type")),std::string> ) return "my_type"; else return std::string{}; else return std::string{}; }
+    return [&] () -> std::string { auto&& _expr = v;
+        if (cpp2::is<std::vector>(_expr)) { if constexpr( requires{"std::vector";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::vector")),std::string> ) return "std::vector"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<std::array>(_expr)) { if constexpr( requires{"std::array";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::array")),std::string> ) return "std::array"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<std::variant>(_expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<my_type>(_expr)) { if constexpr( requires{"my_type";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("my_type")),std::string> ) return "my_type"; else return std::string{}; else return std::string{}; }
         else return "unknown"; }
     (); 
 }

regression-tests/test-results/mixed-inspect-values-2.cpp

@@ -38,9 +38,9 @@ constexpr auto empty = [](auto&& x){
 [[nodiscard]] auto main() -> int{
     auto i {15}; 
 
-    std::cout << [&] () -> std::string { auto&& __expr = i;
-        if (cpp2::is(__expr, (less_than(10)))) { if constexpr( requires{"i less than 10";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i less than 10")),std::string> ) return "i less than 10"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; else return std::string{}; else return std::string{}; }
+    std::cout << [&] () -> std::string { auto&& _expr = i;
+        if (cpp2::is(_expr, (less_than(10)))) { if constexpr( requires{"i less than 10";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i less than 10")),std::string> ) return "i less than 10"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(_expr, in(11, 20))) { if constexpr( requires{"i is between 11 and 20";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("i is between 11 and 20")),std::string> ) return "i is between 11 and 20"; else return std::string{}; else return std::string{}; }
         else return "i is out of our interest"; }
     () << std::endl;
 

regression-tests/test-results/mixed-inspect-values.cpp

@@ -55,13 +55,13 @@ auto test(auto const& x) -> void;
 
 auto test(auto const& x) -> void{
     auto forty_two {42}; 
-    std::cout << [&] () -> std::string { auto&& __expr = x;
-        if (cpp2::is(__expr, 0)) { if constexpr( requires{"zero";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("zero")),std::string> ) return "zero"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, (in(1, 2)))) { if constexpr( requires{"1 or 2";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("1 or 2")),std::string> ) return "1 or 2"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, in_2_3)) { if constexpr( requires{"3";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("3")),std::string> ) return "3"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is(__expr, std::move(forty_two))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<int>(__expr)) { if constexpr( requires{"integer " + cpp2::to_string(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + cpp2::to_string(x))),std::string> ) return "integer " + cpp2::to_string(x); else return std::string{}; else return std::string{}; }
-        else if (cpp2::is<std::string>(__expr)) { if constexpr( requires{cpp2::as<std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::as<std::string>(x))),std::string> ) return cpp2::as<std::string>(x); else return std::string{}; else return std::string{}; }
+    std::cout << [&] () -> std::string { auto&& _expr = x;
+        if (cpp2::is(_expr, 0)) { if constexpr( requires{"zero";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("zero")),std::string> ) return "zero"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(_expr, (in(1, 2)))) { if constexpr( requires{"1 or 2";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("1 or 2")),std::string> ) return "1 or 2"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(_expr, in_2_3)) { if constexpr( requires{"3";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("3")),std::string> ) return "3"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is(_expr, std::move(forty_two))) { if constexpr( requires{"the answer";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("the answer")),std::string> ) return "the answer"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<int>(_expr)) { if constexpr( requires{"integer " + cpp2::to_string(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("integer " + cpp2::to_string(x))),std::string> ) return "integer " + cpp2::to_string(x); else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<std::string>(_expr)) { if constexpr( requires{cpp2::as<std::string>(x);} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((cpp2::as<std::string>(x))),std::string> ) return cpp2::as<std::string>(x); else return std::string{}; else return std::string{}; }
         else return "(no match)"; }
     () << "\n";
 }

regression-tests/test-results/mixed-inspect-with-typeof-of-template-arg-list.cpp

@@ -28,8 +28,8 @@ auto calc() {
 
 #line 7 "mixed-inspect-with-typeof-of-template-arg-list.cpp2"
 [[nodiscard]] auto fun(auto const& v) -> int{
-    return [&] () -> int { auto&& __expr = v;
-        if (cpp2::is<int>(__expr)) { if constexpr( requires{calc<1,2>();} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((calc<1,2>())),int> ) return calc<1,2>(); else return int{}; else return int{}; }
+    return [&] () -> int { auto&& _expr = v;
+        if (cpp2::is<int>(_expr)) { if constexpr( requires{calc<1,2>();} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((calc<1,2>())),int> ) return calc<1,2>(); else return int{}; else return int{}; }
         else return 0; }
     (); 
 }

regression-tests/test-results/mixed-multiple-return-values.cpp

@@ -13,10 +13,10 @@
 #include <iostream>
 #include <random>
 #include <string>
-struct f__ret { int i; std::string s; };
+struct f_ret { int i; std::string s; };
 
 #line 6 "mixed-multiple-return-values.cpp2"
-[[nodiscard]] auto f() -> f__ret;
+[[nodiscard]] auto f() -> f_ret;
 
 
 #line 22 "mixed-multiple-return-values.cpp2"
@@ -40,7 +40,7 @@ bool flip_a_coin() {
 
 
 #line 6 "mixed-multiple-return-values.cpp2"
-[[nodiscard]] auto f() -> f__ret{
+[[nodiscard]] auto f() -> f_ret{
         cpp2::deferred_init<int> i;
         cpp2::deferred_init<std::string> s;
     //  note: i and s are uninitialized!

regression-tests/test-results/msvc-2022/pure2-enum.cpp.execution

@@ -1,6 +1,5 @@
 x.to_string() is clubs
 x2.to_string() is clubs
-using << prints clubs
 with if else: clubs
 with inspect: clubs
 

regression-tests/test-results/pure2-bugfix-for-name-lookup-and-value-decoration.cpp

@@ -10,9 +10,9 @@
 
 //=== Cpp2 type definitions and function declarations ===========================
 
-struct vals__ret { int i; };
+struct vals_ret { int i; };
 
-[[nodiscard]] auto vals() -> vals__ret;
+[[nodiscard]] auto vals() -> vals_ret;
 
 
 #line 6 "pure2-bugfix-for-name-lookup-and-value-decoration.cpp2"
@@ -21,7 +21,7 @@ struct vals__ret { int i; };
 
 //=== Cpp2 function definitions =================================================
 
-[[nodiscard]] auto vals() -> vals__ret{
+[[nodiscard]] auto vals() -> vals_ret{
         cpp2::deferred_init<int> i;
 #line 2 "pure2-bugfix-for-name-lookup-and-value-decoration.cpp2"
     i.construct(42);

regression-tests/test-results/pure2-cpp1-multitoken-fundamental-types-error.cpp2.output

@@ -3,30 +3,30 @@ pure2-cpp1-multitoken-fundamental-types-error.cpp2(3,8): error: 'signed short in
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(3,8): error: 'signed short int' is an old-style C/C++ multi-word keyword type
     - most such types should be used only for interoperability with older code
     - using those when you need them is fine, but name them with these short names instead:
-        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, __schar, __uchar
+        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, _schar, _uchar
     - see also cpp2util.h > "Convenience names for integer types"
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(4,8): error: 'short int signed' - did you mean 'short'?
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(4,8): error: 'short int signed' is an old-style C/C++ multi-word keyword type
     - most such types should be used only for interoperability with older code
     - using those when you need them is fine, but name them with these short names instead:
-        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, __schar, __uchar
+        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, _schar, _uchar
     - see also cpp2util.h > "Convenience names for integer types"
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(5,8): error: 'long long unsigned int' - did you mean 'ulonglong'?
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(5,8): error: 'long long unsigned int' is an old-style C/C++ multi-word keyword type
     - most such types should be used only for interoperability with older code
     - using those when you need them is fine, but name them with these short names instead:
-        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, __schar, __uchar
+        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, _schar, _uchar
     - see also cpp2util.h > "Convenience names for integer types"
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(6,8): error: 'long double' - did you mean 'long'?
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(6,8): error: 'long double' is an old-style C/C++ multi-word keyword type
     - most such types should be used only for interoperability with older code
     - using those when you need them is fine, but name them with these short names instead:
-        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, __schar, __uchar
+        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, _schar, _uchar
     - see also cpp2util.h > "Convenience names for integer types"
-pure2-cpp1-multitoken-fundamental-types-error.cpp2(7,8): error: 'unsigned char' - did you mean 'u8' (usually best) or 'cpp2::__uchar'?
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(7,8): error: 'unsigned char' - did you mean 'u8' (usually best) or 'cpp2::_uchar'?
 pure2-cpp1-multitoken-fundamental-types-error.cpp2(7,8): error: 'unsigned char' is an old-style C/C++ multi-word keyword type
     - most such types should be used only for interoperability with older code
     - using those when you need them is fine, but name them with these short names instead:
-        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, __schar, __uchar
+        short, ushort, int, uint, long, ulong, longlong, ulonglong, longdouble, _schar, _uchar
     - see also cpp2util.h > "Convenience names for integer types"