Boost PFR as implicit fallback

test/Jamfile

@@ -15,6 +15,7 @@ import ../../config/checks/config : requires ;
 # import rules from the boost fusion test
 import ../util/test :
     test-bfl-run_with_and_without_fallback
+    test-bfl-compile_with_and_without_fallback
 ;
 
 if [ os.environ CI ]
@@ -128,7 +129,7 @@ project
     [ test-bfl-run_with_and_without_fallback sequence/deque_copy.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/deque_iterator.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/deque_hash.cpp ]
-    [ compile sequence/deque_is_constructible.cpp ]
+    [ test-bfl-compile_with_and_without_fallback sequence/deque_is_constructible.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/deque_make.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/deque_misc.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/deque_move.cpp : :
@@ -261,10 +262,10 @@ project
         : [ requires cxx11_variadic_templates cxx11_hdr_tuple ] ]
     [ test-bfl-run_with_and_without_fallback sequence/ref_vector.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/flatten_view.cpp ]
-    [ compile sequence/github-159.cpp ]
+    [ test-bfl-compile_with_and_without_fallback sequence/github-159.cpp ]
     [ test-bfl-run_with_and_without_fallback sequence/github-176.cpp ]
 
-    [ compile sequence/size.cpp ]
+    [ test-bfl-compile_with_and_without_fallback sequence/size.cpp ]
 
     [ run functional/fused.cpp ]
     [ run functional/fused_function_object.cpp ]

test/sequence/adapt_adt_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ADT(empty_adt,)
 

test/sequence/adapt_adt_named.cpp

@@ -31,6 +31,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     class point

test/sequence/adapt_adt_named_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ADT_NAMED(::empty_adt,empty_adt,)
 

test/sequence/adapt_assoc_adt.cpp

@@ -20,6 +20,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/adapt_assoc_adt_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ASSOC_ADT(empty_adt,)
 

test/sequence/adapt_assoc_adt_named.cpp

@@ -20,6 +20,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/adapt_assoc_adt_named_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_adt{};
 BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(::empty_adt,empty_adt,)
 

test/sequence/adapt_assoc_struct.cpp

@@ -38,6 +38,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/adapt_assoc_struct_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,)
 

test/sequence/adapt_assoc_struct_named.cpp

@@ -18,6 +18,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/adapt_assoc_struct_named_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(::empty_struct,empty_struct,)
 

test/sequence/adapt_assoc_tpl_adt.cpp

@@ -20,6 +20,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/adapt_assoc_tpl_adt_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_adt{};
 BOOST_FUSION_ADAPT_ASSOC_TPL_ADT((T), (empty_adt)(T),)

test/sequence/adapt_assoc_tpl_struct.cpp

@@ -33,6 +33,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/adapt_assoc_tpl_struct_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_struct{};
 BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT((T), (empty_struct)(T),)

test/sequence/adapt_struct.cpp

@@ -32,6 +32,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace namespaced_type {
   typedef int integer;
 }

test/sequence/adapt_struct_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_STRUCT(empty_struct,)
 

test/sequence/adapt_struct_named.cpp

@@ -31,6 +31,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct point

test/sequence/adapt_struct_named_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 class empty_struct{};
 BOOST_FUSION_ADAPT_STRUCT_NAMED(::empty_struct,empty_struct,)
 

test/sequence/adapt_tpl_adt.cpp

@@ -32,6 +32,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     template<typename X, typename Y>

test/sequence/adapt_tpl_adt_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_adt{};
 BOOST_FUSION_ADAPT_TPL_ADT((T), (empty_adt)(T),)

test/sequence/adapt_tpl_struct.cpp

@@ -28,6 +28,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     template<typename X, typename Y>

test/sequence/adapt_tpl_struct_empty.cpp

@@ -27,6 +27,8 @@
 #include <boost/mpl/assert.hpp>
 #include <iostream>
 
+#include "with_or_without_fallback.hpp"
+
 template <typename T>
 class empty_struct{};
 BOOST_FUSION_ADAPT_TPL_STRUCT((T), (empty_struct)(T),)

test/sequence/adt_attribute_proxy.cpp

@@ -13,6 +13,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 namespace fusion=boost::fusion;
 
 template<typename Name, typename Age>

test/sequence/array.cpp

@@ -15,6 +15,8 @@
 
 #include <boost/mpl/assert.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;

test/sequence/as_deque.cpp

@@ -16,6 +16,7 @@
 
 #include <string>
 
+#include "with_or_without_fallback.hpp"
 
 int main() {
     using namespace boost::fusion;

test/sequence/as_list.cpp

@@ -15,6 +15,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int
 main()
 {

test/sequence/as_map.cpp

@@ -17,6 +17,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/support/pair.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int
 main()
 {
@@ -29,7 +31,8 @@ main()
 
     {
         vector0<> empty;
-        std::cout << as_map(make_list(make_pair<int>('X'), make_pair<double>("Men"))) << std::endl;
+        // Conversion for std::string need to prevent 'error: ambiguous overload for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘const char [4]’)'
+        std::cout << as_map(make_list(make_pair<int>('X'), make_pair<double>(std::string("Men")))) << std::endl;
         std::cout << as_map(push_back(empty, make_pair<int>(999))) << std::endl;
     }
 

test/sequence/as_map_assoc.cpp

@@ -17,6 +17,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/fusion/support/pair.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 namespace ns
 {
     struct x_member;

test/sequence/as_set.cpp

@@ -18,6 +18,8 @@
 #include <boost/fusion/sequence/io/out.hpp>
 #include <boost/mpl/vector_c.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int
 main()
 {

test/sequence/as_vector.cpp

@@ -16,6 +16,8 @@
 #include <boost/mpl/vector_c.hpp>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 int
 main()
 {

test/sequence/back_extended_deque.cpp

@@ -20,6 +20,8 @@
 #include <boost/mpl/assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;

test/sequence/boost_array.cpp

@@ -19,6 +19,8 @@
 
 #include <boost/mpl/assert.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int main()
 {
     using namespace boost::fusion;

test/sequence/boost_tuple.cpp

@@ -33,6 +33,8 @@
 #include <iostream>
 #include <string>
 
+#include "with_or_without_fallback.hpp"
+
 int
 main()
 {

test/sequence/boost_tuple_iterator.cpp

@@ -7,6 +7,8 @@
 
 #include <boost/fusion/adapted/boost_tuple.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::tuple
 #define FUSION_TRAVERSAL_TAG forward_traversal_tag
 #define FUSION_NO_PRIOR

test/sequence/comparison.hpp

@@ -7,8 +7,13 @@
 ==============================================================================*/
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/sequence/comparison.hpp>
+#include <boost/fusion/adapted/boost_pfr/force.hpp>
+
+// TODO: force.hpp should be documented and tested that it won't adapt pfr implicitly or explicitly
 
 struct not_a_fusion_container {};
+BOOST_FUSION_FORCE_PFR_NONREFLECTABLE(not_a_fusion_container)
+
 template <typename T>
 inline bool operator==(not_a_fusion_container, T const&) { return true; }
 template <typename T>

test/sequence/cons.cpp

@@ -22,6 +22,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/mpl/lambda.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 int
 main()
 {

test/sequence/convert_boost_tuple.cpp

@@ -9,6 +9,8 @@
 #include <boost/tuple/tuple.hpp>
 #include <boost/fusion/include/boost_tuple.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::tuples::tuple
 #include "convert.hpp"
 

test/sequence/convert_deque.cpp

@@ -8,6 +8,8 @@
 
 #include <boost/fusion/include/deque.hpp>
 
+#include "with_or_without_fallback.hpp"
+
 #define FUSION_SEQUENCE boost::fusion::deque
 #include "convert.hpp"