Attempt porting to clang

 * clang refuses constexpr initializer_list, I think it might be correct
 * some template type deduction in auto deduced types is failing, I helped it along
 * Cannot get regular template user defined literal compiling, revert to gnu extension

This still doesn't compile however:

value_parser returns something dependent on array_parser
array_parser returns something dependent on value_parser

I'm not sure how gcc is able to compile this with auto return deduction, but
clang really doesn't like it

@elbeno

CMakeLists.txt

@@ -23,6 +23,7 @@ else()
     -ftemplate-backtrace-limit=0
     -ffunction-sections
     -Wall -Wextra -Werror -pedantic-errors
+    -Wno-gnu-string-literal-operator-template
     -Wcast-align
     -Wcast-qual
     -Wctor-dtor-privacy

src/include/cx_json_parser.h

@@ -597,40 +597,43 @@ namespace JSON
       return value_proxy{0, object_storage, string_storage};
     }
 
+    using Value_Proxy = value_proxy<NumObjects, cx::vector<value, NumObjects>,
+                                   cx::basic_string<char, StringSize>>;
+
     template <typename K,
               std::enable_if_t<!std::is_integral<K>::value, int> = 0>
     constexpr auto operator[](const K& s) const {
-      return value_proxy{0, object_storage, string_storage}[s];
+      return Value_Proxy{0, object_storage, string_storage}[s];
     }
     template <typename K,
               std::enable_if_t<!std::is_integral<K>::value, int> = 0>
     constexpr auto operator[](const K& s) {
-      return value_proxy{0, object_storage, string_storage}[s];
+      return Value_Proxy{0, object_storage, string_storage}[s];
     }
     constexpr auto object_Size() const {
-      return value_proxy{0, object_storage, string_storage}.object_Size();
+      return Value_Proxy{0, object_storage, string_storage}.object_Size();
     }
 
     constexpr auto operator[](std::size_t idx) const {
-      return value_proxy{0, object_storage, string_storage}[idx];
+      return Value_Proxy{0, object_storage, string_storage}[idx];
     }
     constexpr auto operator[](std::size_t idx) {
-      return value_proxy{0, object_storage, string_storage}[idx];
+      return Value_Proxy{0, object_storage, string_storage}[idx];
     }
     constexpr auto array_Size() const {
-      return value_proxy{0, object_storage, string_storage}.array_Size();
+      return Value_Proxy{0, object_storage, string_storage}.array_Size();
     }
 
     constexpr auto is_Null() const { return object_storage[0].is_Null(); }
 
     constexpr decltype(auto) to_String() const {
-      return value_proxy{0, object_storage, string_storage}.to_String();
+      return Value_Proxy{0, object_storage, string_storage}.to_String();
     }
     constexpr decltype(auto) to_String() {
-      return value_proxy{0, object_storage, string_storage}.to_String();
+      return Value_Proxy{0, object_storage, string_storage}.to_String();
     }
     constexpr auto string_Size() const {
-      return value_proxy{0, object_storage, string_storage}.string_Size();
+      return Value_Proxy{0, object_storage, string_storage}.string_Size();
     }
 
     constexpr decltype(auto) to_Number() const { return object_storage[0].to_Number(); }
@@ -650,16 +653,19 @@ namespace JSON
 
   namespace literals
   {
+
+    // why cannot we get regular literal operator template here?
     template <typename T, T... Ts>
     constexpr auto operator "" _json()
     {
-      constexpr std::initializer_list<T> il{Ts...};
+      std::initializer_list<T> il{Ts...};
       // I tried using structured bindings here, but g++ says:
       // "error: decomposition declaration cannot be declared 'constexpr'"
       constexpr auto S = sizes<Ts...>();
       return value_wrapper<S.num_objects, S.string_size>(
           std::string_view(il.begin(), il.size()));
     }
+
   }
 
 }

src/test/algorithm.cpp

@@ -128,62 +128,65 @@ void algo_tests_nonmod()
 
 void algo_tests_mod()
 {
+  using std::begin;
+  using std::end;
+
   {
-    constexpr auto il = {1, 3, 5, 7, 9};
+    constexpr int il[] = {1, 3, 5, 7, 9};
     constexpr auto vec = [&] () {
         cx::vector<int, 5> v;
-        cx::copy(il.begin(), il.end(), cx::back_insert_iterator(v));
+        cx::copy(begin(il), end(il), cx::back_insert_iterator(v));
         return v;
     }();
     static_assert(vec.size() == 5, "copy fail");
   }
 
   {
-    constexpr auto il = {1, 2, 5, 7, 4};
+    constexpr int il[] = {1, 2, 5, 7, 4};
     constexpr auto vec = [&] () {
         cx::vector<int, 5> v;
-        cx::copy_if(il.begin(), il.end(), cx::back_insert_iterator(v),
+        cx::copy_if(begin(il), end(il), cx::back_insert_iterator(v),
                     [] (auto i) { return i % 2 == 0; });
         return v;
     }();
     static_assert(vec.size() == 2, "copy_if fail");
   }
 
   {
-    constexpr auto il = {1, 3, 5, 7, 9};
+    constexpr int il[] = {1, 3, 5, 7, 9};
     constexpr auto vec = [&] () {
         cx::vector<int, 5> v;
-        cx::copy_n(il.begin(), 3, cx::back_insert_iterator(v));
+        cx::copy_n(begin(il), 3, cx::back_insert_iterator(v));
         return v;
     }();
     static_assert(vec.size() == 3, "copy_n fail");
   }
 
   {
-    constexpr auto il = {1, 3, 5, 7, 9};
+    constexpr int il[] = {1, 3, 5, 7, 9};
     constexpr auto vec = [&] () {
         cx::vector<int, 5> v = {0,0,0,0,0};
-        cx::copy_backward(il.begin(), il.end(), v.end());
+        cx::copy_backward(begin(il), end(il), v.end());
         return v;
     }();
     static_assert(vec.size() == 5 && vec[0] == 1 && vec[4] == 9, "copy_backward fail");
   }
 
   {
-    constexpr auto il = {1, 3, 5, 7, 9};
+    constexpr int il[] = {1, 3, 5, 7, 9};
     constexpr auto vec = [&] () {
         cx::vector<int, 5> v;
-        cx::move(il.begin(), il.end(), cx::back_insert_iterator(v));
+        cx::move(begin(il), end(il), cx::back_insert_iterator(v));
         return v;
     }();
     static_assert(vec.size() == 5, "move fail");
   }
 
   {
-    constexpr auto il = {1, 3, 5, 7, 9};
+    constexpr int il[] = {1, 3, 5, 7, 9};
     constexpr auto vec = [&] () {
         cx::vector<int, 5> v = {0,0,0,0,0};
-        cx::move_backward(il.begin(), il.end(), v.end());
+        cx::move_backward(begin(il), end(il), v.end());
         return v;
     }();
     static_assert(vec.size() == 5 && vec[0] == 1 && vec[4] == 9, "move_backward fail");