Remove MPL and dependencies (#19)

* Remove MPL usage

* Remove BOOST_WORKAROUND

* Remove comment

* Remove MPL deps

* Add test case

* Refine test

Author: yaito3014

.github/workflows/ci.yml

@@ -204,14 +204,9 @@ jobs:
             libs/assert \
             libs/config \
             libs/core \
-            libs/io \
-            libs/mpl \
-            libs/predef \
             libs/preprocessor \
             libs/static_assert \
-            libs/throw_exception \
-            libs/type_traits \
-            libs/utility
+            libs/throw_exception
 
       - name: Build upstream Boost libraries (Ubuntu)
         if: matrix.os.name == 'ubuntu' && steps.cache-boost.outputs.cache-hit != 'true'

CMakeLists.txt

@@ -128,13 +128,6 @@ list(APPEND iris_x4_boost_deps config)
 list(APPEND iris_x4_boost_deps static_assert)
 list(APPEND iris_x4_boost_deps throw_exception)
 
-# Everything required by `mpl`
-list(APPEND iris_x4_boost_deps mpl)
-list(APPEND iris_x4_boost_deps io)
-list(APPEND iris_x4_boost_deps predef)
-list(APPEND iris_x4_boost_deps type_traits)
-list(APPEND iris_x4_boost_deps utility)
-
 # ---------------------------------------------
 list(REMOVE_DUPLICATES iris_x4_boost_deps)
 

README.md

@@ -46,8 +46,7 @@ Note: Boost dependency is going to be removed entirely in the near future.
 ```console
 git submodule update --init --depth 1 --recursive -- \
     tools/build tools/boost_install libs/assert libs/config \
-    libs/core libs/io libs/mpl libs/predef libs/preprocessor \
-    libs/static_assert libs/throw_exception libs/type_traits libs/utility
+    libs/core libs/preprocessor libs/static_assert libs/throw_exception
 
 # Linux
 ./bootstrap.sh

include/iris/x4/numeric/utils/extract_int.hpp

@@ -261,7 +261,7 @@ template<
 >
 struct extract_int
 {
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4127)   // conditional expression is constant
 # pragma warning(disable: 4459)   // declaration hides global declaration
@@ -300,7 +300,7 @@ struct extract_int
         }
         return false;
     }
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#ifdef _MSC_VER
 # pragma warning(pop)
 #endif
 
@@ -343,7 +343,7 @@ struct extract_int
 template<class T, unsigned Radix, class Accumulator, bool Accumulate>
 struct extract_int<T, Radix, 1, -1, Accumulator, Accumulate>
 {
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4127)   // conditional expression is constant
 # pragma warning(disable: 4459)   // declaration hides global declaration
@@ -397,7 +397,7 @@ struct extract_int<T, Radix, 1, -1, Accumulator, Accumulate>
         first = it;
         return true;
     }
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#ifdef _MSC_VER
 # pragma warning(pop)
 #endif
 

include/iris/x4/numeric/utils/extract_real.hpp

@@ -24,8 +24,7 @@
 #include <cassert>
 #include <cmath>
 
-// TODO: fix this
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4100)   // 'p': unreferenced formal parameter
 #endif
@@ -253,7 +252,7 @@ struct extract_real
     }
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#ifdef _MSC_VER
 # pragma warning(pop)
 #endif
 

include/iris/x4/traits/substitution.hpp

@@ -16,10 +16,6 @@
 
 #include <iris/alloy/traits.hpp>
 
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/equal.hpp>
-#include <boost/mpl/filter_view.hpp>
-
 #include <optional>
 #include <type_traits>
 
@@ -38,10 +34,22 @@ constexpr bool is_substitute_v = is_substitute<T, Attr>::value;
 template<class Variant, X4Attribute Attr>
 struct variant_has_substitute;
 
-// TODO: reduce MPL usage
-
 namespace detail {
 
+template<class TTuple, class UTuple, class IndexSeq = std::make_index_sequence<alloy::tuple_size_v<TTuple>>>
+struct is_all_substitute_for_tuple_impl {};
+
+template<class TTuple, class UTuple, std::size_t... Is>
+struct is_all_substitute_for_tuple_impl<TTuple, UTuple, std::index_sequence<Is...>>
+    : std::conjunction<is_substitute<alloy::tuple_element_t<Is, TTuple>, alloy::tuple_element_t<Is, UTuple>>...> {};
+
+template<class TTuple, class UTuple>
+struct is_all_substitute_for_tuple : std::false_type {};
+
+template<class TTuple, class UTuple>
+    requires is_same_size_sequence_v<TTuple, UTuple>
+struct is_all_substitute_for_tuple<TTuple, UTuple> : is_all_substitute_for_tuple_impl<TTuple, UTuple> {};
+
 template<class T, X4Attribute Attr>
 struct value_type_is_substitute
     : is_substitute<container_value_t<T>, container_value_t<Attr>>
@@ -56,7 +64,7 @@ template<class T, X4Attribute Attr>
         alloy::is_tuple_like<Attr>
     >
 struct is_substitute_impl<T, Attr>
-    : boost::mpl::equal<T, Attr, is_substitute<boost::mpl::_1, boost::mpl::_2>>
+    : is_all_substitute_for_tuple<T, Attr>
 {};
 
 template<class T, X4Attribute Attr>

test/x4/CMakeLists.txt

@@ -91,6 +91,7 @@ x4_define_tests(
     with
     with_local
     x3_rule_problem
+    alloy_wrong_substitute_test_case
 )
 
 x4_define_test(rule_separate_tu rule_separate_tu.cpp rule_separate_tu_grammar.cpp)

test/x4/alloy_wrong_substitute_test_case.cpp

@@ -0,0 +1,91 @@
+#include "iris_x4_test.hpp"
+
+#include <iris/x4/auxiliary/eps.hpp>
+#include <iris/x4/operator/alternative.hpp>
+#include <iris/x4/rule.hpp>
+
+#include <iris/alloy/adapt.hpp>
+#include <iris/alloy/tuple.hpp>
+
+#include <iris/rvariant.hpp>
+
+namespace alloy_wrong_substitute_test_case {
+
+struct A
+{
+    int foo;
+    int bar;
+};
+
+struct B
+{
+    int hoge;
+    std::string fuga;
+};
+
+} // alloy_wrong_substitute_test_case
+
+namespace iris::alloy {
+
+// If enabled, `B` can be wrongly treated as substitutable to `A`
+template<>
+struct adaptor<alloy_wrong_substitute_test_case::A>
+{
+   using getters_list = make_getters_list<
+       &alloy_wrong_substitute_test_case::A::foo,
+       &alloy_wrong_substitute_test_case::A::bar
+   >;
+};
+
+template<>
+struct adaptor<alloy_wrong_substitute_test_case::B>
+{
+    using getters_list = make_getters_list<
+        &alloy_wrong_substitute_test_case::B::hoge,
+        &alloy_wrong_substitute_test_case::B::fuga
+    >;
+};
+
+} // iris::alloy
+
+namespace ast {
+
+using A = alloy_wrong_substitute_test_case::A;
+using B = alloy_wrong_substitute_test_case::B;
+using AorB = iris::rvariant<
+    alloy_wrong_substitute_test_case::A,
+    alloy_wrong_substitute_test_case::B
+>;
+
+} // ast
+
+using ARule = x4::rule<struct a_tag, ast::A>;
+using BRule = x4::rule<struct b_tag, ast::B>;
+using AorBRule = x4::rule<struct a_or_b_tag, ast::AorB>;
+
+constexpr ARule a;
+constexpr BRule b;
+constexpr AorBRule a_or_b;
+
+IRIS_X4_DECLARE(ARule);
+IRIS_X4_DECLARE(BRule);
+IRIS_X4_DECLARE(AorBRule);
+
+constexpr auto a_def = x4::eps;
+
+constexpr auto b_def = x4::eps;
+
+constexpr auto a_or_b_def = a | b;
+
+IRIS_X4_DEFINE(a);
+IRIS_X4_DEFINE(b);
+IRIS_X4_DEFINE(a_or_b);
+
+IRIS_X4_INSTANTIATE(AorBRule, const char*, x4::unused_type);
+
+TEST_CASE("alloy_wrong_substitute_test_case")
+{
+    const char* ptr = nullptr;
+    ast::AorB result;
+    (void)a_or_b.parse(ptr, nullptr, x4::unused, result);
+}