From 66cc615679966a4dad4f6f6bc3a69353c6567ccc Mon Sep 17 00:00:00 2001
From: Lukas Mosimann <lukas.mosimann@cscs.ch>
Date: Thu, 25 Apr 2019 14:40:21 +0200
Subject: [PATCH] std::move, std::forward -> const_expr::move,
 const_expr::forward

---
 .../gridtools/c_bindings/function_wrapper.hpp |  4 ++--
 include/gridtools/c_bindings/generator.hpp    |  4 ++--
 include/gridtools/common/any_moveable.hpp     |  7 ++++---
 include/gridtools/common/array.hpp            |  2 +-
 include/gridtools/common/functional.hpp       |  3 ++-
 .../common/generic_metafunctions/utility.hpp  | 14 +++++---------
 .../gridtools/common/hypercube_iterator.hpp   |  4 ++--
 include/gridtools/common/pair.hpp             | 19 +++++++++++--------
 include/gridtools/common/permute_to.hpp       |  4 ++--
 include/gridtools/common/split_args.hpp       | 17 +++++++++--------
 include/gridtools/common/timer/timer.hpp      |  3 ++-
 include/gridtools/common/tuple.hpp            |  7 ++++---
 .../distributed_boundaries/bound_bc.hpp       |  5 +++--
 include/gridtools/stencil_composition/arg.hpp |  4 ++--
 .../stencil_composition/computation.hpp       |  6 +++---
 .../intermediate_expand.hpp                   |  9 +++++----
 .../make_computation.hpp                      | 11 ++++++-----
 .../backend_cuda/iterate_domain_cuda.hpp      |  2 +-
 .../backend_naive/iterate_domain_naive.hpp    |  2 +-
 .../backend_x86/iterate_domain_x86.hpp        |  2 +-
 .../stencil_composition/intermediate.hpp      |  2 +-
 .../stencil_composition/make_computation.hpp  | 14 ++++++++------
 .../stencil_composition/sid/as_const.hpp      |  2 +-
 .../stencil_composition/sid/composite.hpp     |  6 +++---
 .../stencil_composition/sid/delegate.hpp      |  2 +-
 .../stencil_composition/sid/synthetic.hpp     | 13 +++++++------
 .../backend_cuda/iterate_domain_cuda.hpp      |  2 +-
 .../backend_naive/iterate_domain_naive.hpp    |  2 +-
 .../backend_x86/iterate_domain_x86.hpp        |  2 +-
 include/gridtools/storage/data_store.hpp      |  2 +-
 include/gridtools/storage/sid.hpp             |  4 ++--
 .../gridtools/tools/computation_fixture.hpp   |  8 ++++----
 .../mpi_unit_test_driver/mpi_listener.hpp     |  2 +-
 .../gridtools/tools/regression_fixture.hpp    |  2 +-
 34 files changed, 101 insertions(+), 91 deletions(-)

diff --git a/include/gridtools/c_bindings/function_wrapper.hpp b/include/gridtools/c_bindings/function_wrapper.hpp
index 8b71831f5a..ceb021885b 100644
--- a/include/gridtools/c_bindings/function_wrapper.hpp
+++ b/include/gridtools/c_bindings/function_wrapper.hpp
@@ -80,7 +80,7 @@ namespace gridtools {
             template <class T,
                 typename std::enable_if<std::is_class<typename std::remove_reference<T>::type>::value, int>::type = 0>
             gt_handle *convert_to_c(T &&obj) {
-                return new gt_handle{std::forward<T>(obj)};
+                return new gt_handle{const_expr::forward<T>(obj)};
             }
 
             template <class T>
@@ -161,7 +161,7 @@ namespace gridtools {
         /// Wrap the functor of type `Impl` to another functor that can be invoked with the 'wrapped_t<T>' signature.
         template <class T, class Impl>
         _impl::wrapped_f<T, typename std::decay<Impl>::type> wrap(Impl &&obj) {
-            return {std::forward<Impl>(obj)};
+            return {const_expr::forward<Impl>(obj)};
         }
 
         /// Specialization for function pointers.
diff --git a/include/gridtools/c_bindings/generator.hpp b/include/gridtools/c_bindings/generator.hpp
index 49d0c0c001..c1fb105777 100644
--- a/include/gridtools/c_bindings/generator.hpp
+++ b/include/gridtools/c_bindings/generator.hpp
@@ -96,7 +96,7 @@ namespace gridtools {
             void for_each_param(TypeToStr &&type_to_str, Fun &&fun) {
                 int count = 0;
                 for_each_type<Params>(for_each_param_helper_f<TypeToStr, Fun>{
-                    std::forward<TypeToStr>(type_to_str), std::forward<Fun>(fun), count});
+                    const_expr::forward<TypeToStr>(type_to_str), const_expr::forward<Fun>(fun), count});
             };
 
             template <class CSignature>
@@ -439,7 +439,7 @@ namespace gridtools {
                 get_entities<Traits>().add(name,
                     std::bind(Traits::template generate_entity<Signature>,
                         std::placeholders::_1,
-                        std::forward<Params>(params)...));
+                        const_expr::forward<Params>(params)...));
             }
 
             template <class CSignature>
diff --git a/include/gridtools/common/any_moveable.hpp b/include/gridtools/common/any_moveable.hpp
index 7f685b3590..b691cfec4e 100644
--- a/include/gridtools/common/any_moveable.hpp
+++ b/include/gridtools/common/any_moveable.hpp
@@ -15,6 +15,7 @@
 #include <utility>
 
 #include "defs.hpp"
+#include "generic_metafunctions/utility.hpp"
 
 namespace gridtools {
 
@@ -36,7 +37,7 @@ namespace gridtools {
         struct impl : iface {
             T m_obj;
             impl(T const &obj) : m_obj(obj) {}
-            impl(T &&obj) : m_obj(std::move(obj)) {}
+            impl(T &&obj) : m_obj(const_expr::move(obj)) {}
             std::type_info const &type() const noexcept override { return typeid(T); }
         };
         std::unique_ptr<iface> m_impl;
@@ -45,12 +46,12 @@ namespace gridtools {
         any_moveable() = default;
 
         template <class Arg, class Decayed = typename std::decay<Arg>::type>
-        any_moveable(Arg &&arg) : m_impl(new impl<Decayed>(std::forward<Arg>(arg))) {}
+        any_moveable(Arg &&arg) : m_impl(new impl<Decayed>(const_expr::forward<Arg>(arg))) {}
         any_moveable(any_moveable &&) = default;
 
         template <class Arg, class Decayed = typename std::decay<Arg>::type>
         any_moveable &operator=(Arg &&obj) {
-            m_impl.reset(new impl<Decayed>(std::forward<Arg>(obj)));
+            m_impl.reset(new impl<Decayed>(const_expr::forward<Arg>(obj)));
             return *this;
         }
         any_moveable &operator=(any_moveable &&) = default;
diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index 86ee9e312f..5cf9fbfde7 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -195,7 +195,7 @@ namespace gridtools {
     template <size_t I, typename T, size_t D>
     GT_FUNCTION T &&get(array<T, D> &&arr) noexcept {
         GT_STATIC_ASSERT(I < D, "index is out of bounds");
-        return std::move(get<I>(arr));
+        return const_expr::move(get<I>(arr));
     }
 
     /** @} */
diff --git a/include/gridtools/common/functional.hpp b/include/gridtools/common/functional.hpp
index c155840cc0..ac62a1dc38 100644
--- a/include/gridtools/common/functional.hpp
+++ b/include/gridtools/common/functional.hpp
@@ -24,6 +24,7 @@
 
 #include <utility>
 
+#include "./generic_metafunctions/utility.hpp"
 #include "./host_device.hpp"
 
 #define GT_FILENAME <gridtools/common/functional.hpp>
@@ -47,7 +48,7 @@ namespace gridtools {
         struct ctor {
             template <typename... Args>
             GT_TARGET GT_FORCE_INLINE T operator()(Args &&... args) const {
-                return T{std::forward<Args>(args)...};
+                return T{const_expr::forward<Args>(args)...};
             }
 
 #ifndef BOOST_RESULT_OF_USE_DECLTYPE
diff --git a/include/gridtools/common/generic_metafunctions/utility.hpp b/include/gridtools/common/generic_metafunctions/utility.hpp
index e923405266..2083ad8498 100644
--- a/include/gridtools/common/generic_metafunctions/utility.hpp
+++ b/include/gridtools/common/generic_metafunctions/utility.hpp
@@ -13,32 +13,28 @@
 #include <type_traits>
 #include <utility>
 
+#include "../host_device.hpp"
+
 namespace gridtools {
     /**
      *  `std::forward`/`std::move` versions that are guarantied to be constexpr
      */
     namespace const_expr {
-// cuda < 9.2 doesn't have std::move/std::forward definded as `constexpr`
-#if __CUDACC__
         // defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ < 9 || __CUDACC_VER_MAJOR__ == 9 &&
         // __CUDACC_VER_MINOR__ < 2)
         template <class T>
-        __device__ __host__ typename std::remove_reference<T>::type &&move(T &&obj) noexcept {
+        GT_HOST_DEVICE typename std::remove_reference<T>::type &&move(T &&obj) noexcept {
             return static_cast<typename std::remove_reference<T>::type &&>(obj);
         }
         template <class T>
-        __device__ __host__ T &&forward(typename std::remove_reference<T>::type &obj) noexcept {
+        GT_HOST_DEVICE T &&forward(typename std::remove_reference<T>::type &obj) noexcept {
             return static_cast<T &&>(obj);
         }
         template <class T>
-        __device__ __host__ T &&forward(typename std::remove_reference<T>::type &&obj) noexcept {
+        GT_HOST_DEVICE T &&forward(typename std::remove_reference<T>::type &&obj) noexcept {
             static_assert(
                 !std::is_lvalue_reference<T>::value, "Error: obj is instantiated with an lvalue reference type");
             return static_cast<T &&>(obj);
         }
-#else
-        using std::forward;
-        using std::move;
-#endif
     } // namespace const_expr
 } // namespace gridtools
diff --git a/include/gridtools/common/hypercube_iterator.hpp b/include/gridtools/common/hypercube_iterator.hpp
index a2170b860a..20e53ce428 100644
--- a/include/gridtools/common/hypercube_iterator.hpp
+++ b/include/gridtools/common/hypercube_iterator.hpp
@@ -82,7 +82,7 @@ namespace gridtools {
         size_t InnerD = tuple_size<typename tuple_element<0, Decayed>::type>::value,
         typename std::enable_if<OuterD != 0 && InnerD == 2, int>::type = 0>
     GT_FUNCTION impl_::hypercube_view<OuterD> make_hypercube_view(Container &&cube) {
-        auto &&transposed = tuple_util::host_device::transpose(std::forward<Container>(cube));
+        auto &&transposed = tuple_util::host_device::transpose(const_expr::forward<Container>(cube));
         return {tuple_util::host_device::convert_to<array, size_t>(tuple_util::host_device::get<0>(transposed)),
             tuple_util::host_device::convert_to<array, size_t>(tuple_util::host_device::get<1>(transposed))};
     }
@@ -107,6 +107,6 @@ namespace gridtools {
         typename std::enable_if<D != 0 && std::is_convertible<size_t, typename tuple_element<0, Decayed>::type>::value,
             int>::type = 0>
     GT_FUNCTION impl_::hypercube_view<D> make_hypercube_view(Container &&sizes) {
-        return {tuple_util::host_device::convert_to<array, size_t>(std::forward<Container>(sizes))};
+        return {tuple_util::host_device::convert_to<array, size_t>(const_expr::forward<Container>(sizes))};
     }
 } // namespace gridtools
diff --git a/include/gridtools/common/pair.hpp b/include/gridtools/common/pair.hpp
index 1f3a3591ab..03de7bac86 100644
--- a/include/gridtools/common/pair.hpp
+++ b/include/gridtools/common/pair.hpp
@@ -36,16 +36,17 @@ namespace gridtools {
         GT_FUNCTION pair(const std::pair<U1, U2> &p) : pair(p.first, p.second) {}
 
         template <class U1, class U2>
-        GT_FUNCTION pair(std::pair<U1, U2> &&p) : pair(std::move(p.first), std::move(p.second)) {}
+        GT_FUNCTION pair(std::pair<U1, U2> &&p) : pair(const_expr::move(p.first), const_expr::move(p.second)) {}
 
         template <class U1, class U2>
-        GT_FUNCTION pair(U1 &&t1_, U2 &&t2_) : first(std::forward<U1>(t1_)), second(std::forward<U2>(t2_)) {}
+        GT_FUNCTION pair(U1 &&t1_, U2 &&t2_)
+            : first(const_expr::forward<U1>(t1_)), second(const_expr::forward<U2>(t2_)) {}
 
         template <class U1, class U2, typename std::enable_if<!std::is_same<pair<U1, U2>, pair>::value, int>::type = 0>
         GT_FUNCTION pair(const pair<U1, U2> &p) : first(p.first), second(p.second) {}
 
         template <class U1, class U2, typename std::enable_if<!std::is_same<pair<U1, U2>, pair>::value, int>::type = 0>
-        GT_FUNCTION pair(pair<U1, U2> &&p) : first(std::move(p.first)), second(std::move(p.second)) {}
+        GT_FUNCTION pair(pair<U1, U2> &&p) : first(const_expr::move(p.first)), second(const_expr::move(p.second)) {}
 
         template <typename U1,
             typename U2,
@@ -60,8 +61,8 @@ namespace gridtools {
             typename U2,
             typename std::enable_if<!std::is_same<pair<U1, U2>, pair>::value, int>::type = 0>
         GT_FUNCTION pair &operator=(pair<U1, U2> &&other) noexcept {
-            first = std::move(other.first);
-            second = std::move(other.second);
+            first = const_expr::move(other.first);
+            second = const_expr::move(other.second);
             return *this;
         }
 
@@ -141,7 +142,7 @@ namespace gridtools {
             }
             template <typename T1, typename T2>
             static GT_FUNCTION T1 &&move_get(pair<T1, T2> &&p) noexcept {
-                return std::move(p.first);
+                return const_expr::move(p.first);
             }
         };
         template <>
@@ -168,7 +169,8 @@ namespace gridtools {
             static GT_FUNCTION auto get(const pair<T1, T2> &p) noexcept GT_AUTO_RETURN(pair_get<I>::const_get(p));
 
             template <size_t I, class T1, class T2>
-            static GT_FUNCTION auto get(pair<T1, T2> &&p) noexcept GT_AUTO_RETURN(pair_get<I>::move_get(std::move(p)));
+            static GT_FUNCTION auto get(pair<T1, T2> &&p) noexcept GT_AUTO_RETURN(
+                pair_get<I>::move_get(const_expr::move(p)));
         };
     } // namespace pair_impl_
 
@@ -179,7 +181,8 @@ namespace gridtools {
     GT_FUNCTION auto get(const pair<T1, T2> &p) noexcept GT_AUTO_RETURN(pair_impl_::pair_get<I>::const_get(p));
 
     template <size_t I, class T1, class T2>
-    GT_FUNCTION auto get(pair<T1, T2> &&p) noexcept GT_AUTO_RETURN(pair_impl_::pair_get<I>::move_get(std::move(p)));
+    GT_FUNCTION auto get(pair<T1, T2> &&p) noexcept GT_AUTO_RETURN(
+        pair_impl_::pair_get<I>::move_get(const_expr::move(p)));
 
     template <class T1, class T2>
     pair_impl_::getter tuple_getter(pair<T1, T2> const &);
diff --git a/include/gridtools/common/permute_to.hpp b/include/gridtools/common/permute_to.hpp
index 6923c024f3..2a4d378a81 100644
--- a/include/gridtools/common/permute_to.hpp
+++ b/include/gridtools/common/permute_to.hpp
@@ -28,7 +28,7 @@ namespace gridtools {
             Res<Elems...> operator()(Src &&src) {
                 using src_t = decay_t<Src>;
                 return Res<Elems...>{
-                    tuple_util::get<meta::st_position<src_t, Elems>::value>(std::forward<Src>(src))...};
+                    tuple_util::get<meta::st_position<src_t, Elems>::value>(const_expr::forward<Src>(src))...};
             }
         };
     } // namespace impl_
@@ -62,6 +62,6 @@ namespace gridtools {
 
     template <typename Res, typename Src>
     Res permute_to(Src &&src) {
-        return impl_::permute_to_impl<Res>{}(std::forward<Src>(src));
+        return impl_::permute_to_impl<Res>{}(const_expr::forward<Src>(src));
     }
 } // namespace gridtools
diff --git a/include/gridtools/common/split_args.hpp b/include/gridtools/common/split_args.hpp
index 4b17ad350d..34247dc60c 100644
--- a/include/gridtools/common/split_args.hpp
+++ b/include/gridtools/common/split_args.hpp
@@ -23,6 +23,7 @@
 #include "../meta/type_traits.hpp"
 #include "../meta/zip.hpp"
 #include "defs.hpp"
+#include "generic_metafunctions/utility.hpp"
 
 namespace gridtools {
     namespace _impl {
@@ -49,20 +50,20 @@ namespace gridtools {
 
             template <class Args, template <class...> class L, class... Is>
             auto get_part_helper(Args &&args, L<Is...> *)
-                GT_AUTO_RETURN(std::forward_as_tuple(std::get<Is::value>(std::forward<Args>(args))...));
+                GT_AUTO_RETURN(std::forward_as_tuple(std::get<Is::value>(const_expr::forward<Args>(args))...));
 
             template <template <class...> class Pred, class Args>
             auto get_part(Args &&args) GT_AUTO_RETURN(get_part_helper(
-                std::forward<Args>(args), (GT_META_CALL(make_filtered_indicies, (Pred, Args)) *)(nullptr)));
+                const_expr::forward<Args>(args), (GT_META_CALL(make_filtered_indicies, (Pred, Args)) *)(nullptr)));
 
             template <template <class...> class Pred, class Args>
             auto raw_split_args_tuple(Args &&args)
-                GT_AUTO_RETURN(std::make_pair(get_part<Pred>(std::forward<Args>(args)),
-                    get_part<meta::not_<Pred>::template apply>(std::forward<Args>(args))));
+                GT_AUTO_RETURN(std::make_pair(get_part<Pred>(const_expr::forward<Args>(args)),
+                    get_part<meta::not_<Pred>::template apply>(const_expr::forward<Args>(args))));
 
             template <template <class...> class Pred, class Args>
-            auto split_args_tuple(Args &&args)
-                GT_AUTO_RETURN(raw_split_args_tuple<apply_to_decayed<Pred>::template apply>(std::forward<Args>(args)));
+            auto split_args_tuple(Args &&args) GT_AUTO_RETURN(
+                raw_split_args_tuple<apply_to_decayed<Pred>::template apply>(const_expr::forward<Args>(args)));
         } // namespace _split_args
     }     // namespace _impl
 
@@ -78,10 +79,10 @@ namespace gridtools {
      */
     template <template <class...> class Pred, class... Args>
     auto raw_split_args(Args &&... args)
-        GT_AUTO_RETURN(raw_split_args_tuple<Pred>(std::forward_as_tuple(std::forward<Args>(args)...)));
+        GT_AUTO_RETURN(raw_split_args_tuple<Pred>(std::forward_as_tuple(const_expr::forward<Args>(args)...)));
 
     /// A handy variation of raw_split_args that applies predicate on decayed argument types.
     template <template <class...> class Pred, class... Args>
     auto split_args(Args &&... args)
-        GT_AUTO_RETURN(split_args_tuple<Pred>(std::forward_as_tuple(std::forward<Args>(args)...)));
+        GT_AUTO_RETURN(split_args_tuple<Pred>(std::forward_as_tuple(const_expr::forward<Args>(args)...)));
 } // namespace gridtools
diff --git a/include/gridtools/common/timer/timer.hpp b/include/gridtools/common/timer/timer.hpp
index 1af11b6dbe..60b13632d2 100644
--- a/include/gridtools/common/timer/timer.hpp
+++ b/include/gridtools/common/timer/timer.hpp
@@ -9,6 +9,7 @@
  */
 #pragma once
 
+#include "../generic_metafunctions/utility.hpp"
 #include "../host_device.hpp"
 #include <cmath>
 #include <sstream>
@@ -24,7 +25,7 @@ namespace gridtools {
     template <typename TimerImpl>
     class timer {
       protected:
-        timer(std::string name) : m_name(std::move(name)) {}
+        timer(std::string name) : m_name(const_expr::move(name)) {}
 
       public:
         /**
diff --git a/include/gridtools/common/tuple.hpp b/include/gridtools/common/tuple.hpp
index 59a451149e..3bd892a8b8 100644
--- a/include/gridtools/common/tuple.hpp
+++ b/include/gridtools/common/tuple.hpp
@@ -117,7 +117,8 @@ namespace gridtools {
                                 conjunction<std::is_assignable<Ts &, Args &&>...>::value,
                     int> = 0>
             GT_FUNCTION void assign(tuple_impl<meta::index_sequence<Is...>, Args...> &&src) noexcept {
-                void((int[]){(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(std::move(src)), 0)...});
+                void((int[]){
+                    (tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(const_expr::move(src)), 0)...});
             }
         };
     } // namespace impl_
@@ -189,7 +190,7 @@ namespace gridtools {
 
         template <class Other>
         GT_FUNCTION auto operator=(Other &&other)
-            GT_AUTO_RETURN((m_impl.assign(std::forward<Other>(other).m_impl), *this));
+            GT_AUTO_RETURN((m_impl.assign(const_expr::forward<Other>(other).m_impl), *this));
     };
 
     template <class T>
@@ -255,7 +256,7 @@ namespace gridtools {
 
         template <class Arg, enable_if_t<std::is_assignable<T &, Arg &&>::value, int> = 0>
         GT_FUNCTION tuple &operator=(tuple<Arg> &&src) noexcept {
-            m_value = std::move(src).m_value;
+            m_value = const_expr::move(src).m_value;
             return *this;
         }
     };
diff --git a/include/gridtools/distributed_boundaries/bound_bc.hpp b/include/gridtools/distributed_boundaries/bound_bc.hpp
index 24c46b4f53..9d0437e2aa 100644
--- a/include/gridtools/distributed_boundaries/bound_bc.hpp
+++ b/include/gridtools/distributed_boundaries/bound_bc.hpp
@@ -219,7 +219,8 @@ namespace gridtools {
          * template argument list to the corresponding data members
          */
         template <typename ST>
-        bound_bc(BCApply bca, ST &&stores_list) : m_bcapply(bca), m_stores{std::forward<stores_type>(stores_list)} {}
+        bound_bc(BCApply bca, ST &&stores_list)
+            : m_bcapply(bca), m_stores{const_expr::forward<stores_type>(stores_list)} {}
 
         /**
          * @brief Function to retrieve the tuple of data stores to pass to the the boundary
@@ -268,7 +269,7 @@ namespace gridtools {
                 ro_store_tuple, m_stores, meta::make_index_sequence<std::tuple_size<decltype(m_stores)>::value>{});
 
             return bound_bc<BCApply, decltype(full_list), typename _impl::comm_indices<stores_type>::type>{
-                m_bcapply, std::move(full_list)};
+                m_bcapply, const_expr::move(full_list)};
         }
     };
 
diff --git a/include/gridtools/stencil_composition/arg.hpp b/include/gridtools/stencil_composition/arg.hpp
index bcffacabc2..dd9f2370b7 100644
--- a/include/gridtools/stencil_composition/arg.hpp
+++ b/include/gridtools/stencil_composition/arg.hpp
@@ -47,7 +47,7 @@ namespace gridtools {
 
         arg_storage_pair() = default;
         arg_storage_pair(const DataStoreType &val) : m_value{val} {}
-        arg_storage_pair(DataStoreType &&val) noexcept : m_value{std::move(val)} {}
+        arg_storage_pair(DataStoreType &&val) noexcept : m_value{const_expr::move(val)} {}
         ~arg_storage_pair() = default;
 
         DataStoreType m_value;
@@ -94,7 +94,7 @@ namespace gridtools {
 
         template <typename Arg>
         arg_storage_pair<plh, DataStoreType> operator=(Arg &&arg) const {
-            return {std::forward<Arg>(arg)};
+            return {const_expr::forward<Arg>(arg)};
         }
     };
 
diff --git a/include/gridtools/stencil_composition/computation.hpp b/include/gridtools/stencil_composition/computation.hpp
index 0f230c2794..b1e2721f16 100644
--- a/include/gridtools/stencil_composition/computation.hpp
+++ b/include/gridtools/stencil_composition/computation.hpp
@@ -30,7 +30,7 @@ namespace gridtools {
 
                 template <class... Args>
                 void operator()(Args &&... args) const {
-                    m_obj.run(std::forward<Args>(args)...);
+                    m_obj.run(const_expr::forward<Args>(args)...);
                 }
             };
 
@@ -78,7 +78,7 @@ namespace gridtools {
         struct impl : iface, _impl::computation_detail::impl_arg<impl<Obj>, Args>... {
             Obj m_obj;
 
-            impl(Obj &&obj) : m_obj{std::move(obj)} {}
+            impl(Obj &&obj) : m_obj{const_expr::move(obj)} {}
 
             void run(arg_storage_pair_crefs_t const &args) override {
                 tuple_util::apply(_impl::computation_detail::run_f<Obj>{m_obj}, args);
@@ -95,7 +95,7 @@ namespace gridtools {
         computation() = default;
 
         template <class Obj>
-        computation(Obj obj) : m_impl(new impl<Obj>{std::move(obj)}) {
+        computation(Obj obj) : m_impl(new impl<Obj>{const_expr::move(obj)}) {
             GT_STATIC_ASSERT((!std::is_same<typename std::decay<Obj>::type, computation>::value),
                 GT_INTERNAL_ERROR_MSG("computation move ctor got shadowed"));
             // TODO(anstaf): Check that Obj satisfies computation concept here.
diff --git a/include/gridtools/stencil_composition/expandable_parameters/intermediate_expand.hpp b/include/gridtools/stencil_composition/expandable_parameters/intermediate_expand.hpp
index 4d323a3a62..f98205316f 100644
--- a/include/gridtools/stencil_composition/expandable_parameters/intermediate_expand.hpp
+++ b/include/gridtools/stencil_composition/expandable_parameters/intermediate_expand.hpp
@@ -254,7 +254,7 @@ namespace gridtools {
 
             template <class Intermediate, class Args>
             void invoke_run(Intermediate &intermediate, Args &&args) {
-                tuple_util::apply(run_f<Intermediate>{intermediate}, std::forward<Args>(args));
+                tuple_util::apply(run_f<Intermediate>{intermediate}, const_expr::forward<Args>(args));
             }
         } // namespace expand_detail
     }     // namespace _impl
@@ -314,7 +314,7 @@ namespace gridtools {
         intermediate_expand(Grid const &grid,
             std::pair<ExpandableBoundArgStoragePairRefs, NonExpandableBoundArgStoragePairRefs> &&arg_refs)
             // expandable arg_storage_pairs are kept as a class member until run will be called.
-            : m_expandable_bound_arg_storage_pairs(std::move(arg_refs.first)),
+            : m_expandable_bound_arg_storage_pairs(const_expr::move(arg_refs.first)),
               // plain arg_storage_pairs are bound to both intermediates;
               m_intermediate(grid, arg_refs.second, false), m_intermediate_remainder(grid, arg_refs.second, false),
               m_meter("NoName") {}
@@ -325,7 +325,7 @@ namespace gridtools {
             // public constructor splits given ard_storage_pairs to expandable and plain ones and delegates to the
             // private constructor.
             : intermediate_expand(
-                  grid, split_args_tuple<_impl::expand_detail::is_expandable>(std::move(arg_storage_pairs))) {}
+                  grid, split_args_tuple<_impl::expand_detail::is_expandable>(const_expr::move(arg_storage_pairs))) {}
 
         template <class... Args, class... DataStores>
         void run(arg_storage_pair<Args, DataStores> const &... args) {
@@ -334,7 +334,8 @@ namespace gridtools {
             auto arg_groups = split_args<_impl::expand_detail::is_expandable>(args...);
             auto bound_expandable_arg_refs = tuple_util::transform(identity{}, m_expandable_bound_arg_storage_pairs);
             // concatenate expandable portion of arguments with the refs to bound expandable ard_storage_pairs
-            auto expandable_args = std::tuple_cat(std::move(bound_expandable_arg_refs), std::move(arg_groups.first));
+            auto expandable_args =
+                std::tuple_cat(const_expr::move(bound_expandable_arg_refs), const_expr::move(arg_groups.first));
             const auto &plain_args = arg_groups.second;
             // extract size from the vectors within expandable args.
             // if vectors are not of the same length assert within `get_expandable_size` fails.
diff --git a/include/gridtools/stencil_composition/expandable_parameters/make_computation.hpp b/include/gridtools/stencil_composition/expandable_parameters/make_computation.hpp
index 19d27fc239..62d086cc39 100644
--- a/include/gridtools/stencil_composition/expandable_parameters/make_computation.hpp
+++ b/include/gridtools/stencil_composition/expandable_parameters/make_computation.hpp
@@ -22,14 +22,15 @@ namespace gridtools {
         struct make_intermediate_expand_f {
             template <class Grid,
                 class... Args,
-                class ArgsPair = decltype(split_args<is_arg_storage_pair>(std::forward<Args>(std::declval<Args>())...)),
+                class ArgsPair = decltype(
+                    split_args<is_arg_storage_pair>(const_expr::forward<Args>(std::declval<Args>())...)),
                 class ArgStoragePairs = GT_META_CALL(decay_elements, typename ArgsPair::first_type),
                 class Msses = GT_META_CALL(decay_elements, typename ArgsPair::second_type)>
             intermediate_expand<Factor, IsStateful, Backend, Grid, ArgStoragePairs, Msses> operator()(
                 Grid const &grid, Args &&... args) const {
                 // split arg_storage_pair and mss descriptor arguments and forward it to intermediate constructor
-                auto &&args_pair = split_args<is_arg_storage_pair>(std::forward<Args>(args)...);
-                return {grid, std::move(args_pair.first)};
+                auto &&args_pair = split_args<is_arg_storage_pair>(const_expr::forward<Args>(args)...);
+                return {grid, const_expr::move(args_pair.first)};
             }
         };
 
@@ -46,14 +47,14 @@ namespace gridtools {
     template <class Backend, class Grid, size_t N, class Arg, class... Args, enable_if_t<is_grid<Grid>::value, int> = 0>
     auto make_expandable_computation(expand_factor<N>, Grid const &grid, Arg &&arg, Args &&... args)
         GT_AUTO_RETURN((_impl::make_intermediate_expand_f<N, GT_POSITIONAL_WHEN_DEBUGGING, Backend>{}(
-            grid, std::forward<Arg>(arg), std::forward<Args>(args)...)));
+            grid, const_expr::forward<Arg>(arg), const_expr::forward<Args>(args)...)));
 
 #undef GT_POSITIONAL_WHEN_DEBUGGING
 
     template <class Backend, class Grid, size_t N, class Arg, class... Args, enable_if_t<is_grid<Grid>::value, int> = 0>
     auto make_expandable_positional_computation(expand_factor<N>, Grid const &grid, Arg &&arg, Args &&... args)
         GT_AUTO_RETURN((_impl::make_intermediate_expand_f<N, true, Backend>{}(
-            grid, std::forward<Arg>(arg), std::forward<Args>(args)...)));
+            grid, const_expr::forward<Arg>(arg), const_expr::forward<Args>(args)...)));
 
     // user protection only, catch the case where no backend is specified
     template <class... Args>
diff --git a/include/gridtools/stencil_composition/icosahedral_grids/backend_cuda/iterate_domain_cuda.hpp b/include/gridtools/stencil_composition/icosahedral_grids/backend_cuda/iterate_domain_cuda.hpp
index 76fe1346cc..0dfd1cf801 100644
--- a/include/gridtools/stencil_composition/icosahedral_grids/backend_cuda/iterate_domain_cuda.hpp
+++ b/include/gridtools/stencil_composition/icosahedral_grids/backend_cuda/iterate_domain_cuda.hpp
@@ -56,7 +56,7 @@ namespace gridtools {
 
         template <class T>
         GT_FUNCTION_DEVICE iterate_domain_cuda(T &&obj, uint_t block_size_i, uint_t block_size_j)
-            : base_t(std::forward<T>(obj)), m_block_size_i(block_size_i), m_block_size_j(block_size_j) {}
+            : base_t(const_expr::forward<T>(obj)), m_block_size_i(block_size_i), m_block_size_j(block_size_j) {}
 
         /**
          * @brief determines whether the current (i,j) position is within the block size
diff --git a/include/gridtools/stencil_composition/icosahedral_grids/backend_naive/iterate_domain_naive.hpp b/include/gridtools/stencil_composition/icosahedral_grids/backend_naive/iterate_domain_naive.hpp
index 4bef8753bb..602cb445cc 100644
--- a/include/gridtools/stencil_composition/icosahedral_grids/backend_naive/iterate_domain_naive.hpp
+++ b/include/gridtools/stencil_composition/icosahedral_grids/backend_naive/iterate_domain_naive.hpp
@@ -27,7 +27,7 @@ namespace gridtools {
         template <class Arg>
         GT_FORCE_INLINE iterate_domain_naive(Arg &&arg)
             : iterate_domain<iterate_domain_naive<IterateDomainArguments>, IterateDomainArguments>(
-                  std::forward<Arg>(arg)) {}
+                  const_expr::forward<Arg>(arg)) {}
 
         template <class Arg, class T>
         static GT_FORCE_INLINE auto deref_impl(T &&ptr) GT_AUTO_RETURN(*ptr);
diff --git a/include/gridtools/stencil_composition/icosahedral_grids/backend_x86/iterate_domain_x86.hpp b/include/gridtools/stencil_composition/icosahedral_grids/backend_x86/iterate_domain_x86.hpp
index a93e290ec4..af7b4a1df6 100644
--- a/include/gridtools/stencil_composition/icosahedral_grids/backend_x86/iterate_domain_x86.hpp
+++ b/include/gridtools/stencil_composition/icosahedral_grids/backend_x86/iterate_domain_x86.hpp
@@ -27,7 +27,7 @@ namespace gridtools {
         template <class Arg>
         GT_FORCE_INLINE iterate_domain_x86(Arg &&arg)
             : iterate_domain<iterate_domain_x86<IterateDomainArguments>, IterateDomainArguments>(
-                  std::forward<Arg>(arg)) {}
+                  const_expr::forward<Arg>(arg)) {}
 
         template <class Arg, class T>
         static GT_FORCE_INLINE auto deref_impl(T &&ptr) GT_AUTO_RETURN(*ptr);
diff --git a/include/gridtools/stencil_composition/intermediate.hpp b/include/gridtools/stencil_composition/intermediate.hpp
index d752413db5..20319dd6b5 100644
--- a/include/gridtools/stencil_composition/intermediate.hpp
+++ b/include/gridtools/stencil_composition/intermediate.hpp
@@ -210,7 +210,7 @@ namespace gridtools {
               m_tmp_arg_storage_pair_tuple(
                   _impl::make_tmp_arg_storage_pairs<max_extent_for_tmp_t, Backend, tmp_arg_storage_pair_tuple_t>(grid)),
               // stash bound storages
-              m_bound_arg_storage_pair_tuple(std::move(arg_storage_pairs)) {
+              m_bound_arg_storage_pair_tuple(const_expr::move(arg_storage_pairs)) {
             if (timer_enabled)
                 m_meter.reset(new performance_meter_t{"NoName"});
 #ifndef NDEBUG
diff --git a/include/gridtools/stencil_composition/make_computation.hpp b/include/gridtools/stencil_composition/make_computation.hpp
index 012e469ba9..3a56c27d7b 100644
--- a/include/gridtools/stencil_composition/make_computation.hpp
+++ b/include/gridtools/stencil_composition/make_computation.hpp
@@ -38,14 +38,15 @@ namespace gridtools {
         struct make_intermediate_f {
             template <class Grid,
                 class... Args,
-                class ArgsPair = decltype(split_args<is_arg_storage_pair>(std::forward<Args>(std::declval<Args>())...)),
+                class ArgsPair = decltype(
+                    split_args<is_arg_storage_pair>(const_expr::forward<Args>(std::declval<Args>())...)),
                 class ArgStoragePairs = GT_META_CALL(decay_elements, typename ArgsPair::first_type),
                 class Msses = GT_META_CALL(decay_elements, typename ArgsPair::second_type)>
             intermediate<IsStateful, Backend, Grid, ArgStoragePairs, Msses> operator()(
                 Grid const &grid, Args &&... args) const {
                 // split arg_storage_pair and mss descriptor arguments and forward it to intermediate constructor
-                auto &&args_pair = split_args<is_arg_storage_pair>(std::forward<Args>(args)...);
-                return {grid, std::move(args_pair.first)};
+                auto &&args_pair = split_args<is_arg_storage_pair>(const_expr::forward<Args>(args)...);
+                return {grid, const_expr::move(args_pair.first)};
             }
         };
 
@@ -61,13 +62,14 @@ namespace gridtools {
     template <class Backend, class Grid, class Arg, class... Args, enable_if_t<is_grid<Grid>::value, int> = 0>
     auto make_computation(Grid const &grid, Arg &&arg, Args &&... args)
         GT_AUTO_RETURN((_impl::make_intermediate_f<GT_POSITIONAL_WHEN_DEBUGGING, Backend>{}(
-            grid, std::forward<Arg>(arg), std::forward<Args>(args)...)));
+            grid, const_expr::forward<Arg>(arg), const_expr::forward<Args>(args)...)));
 
 #undef GT_POSITIONAL_WHEN_DEBUGGING
 
     template <class Backend, class Grid, class Arg, class... Args, enable_if_t<is_grid<Grid>::value, int> = 0>
-    auto make_positional_computation(Grid const &grid, Arg &&arg, Args &&... args) GT_AUTO_RETURN(
-        (_impl::make_intermediate_f<true, Backend>{}(grid, std::forward<Arg>(arg), std::forward<Args>(args)...)));
+    auto make_positional_computation(Grid const &grid, Arg &&arg, Args &&... args)
+        GT_AUTO_RETURN((_impl::make_intermediate_f<true, Backend>{}(
+            grid, const_expr::forward<Arg>(arg), const_expr::forward<Args>(args)...)));
 
     // user protection only, catch the case where no backend is specified
     template <class... Args>
diff --git a/include/gridtools/stencil_composition/sid/as_const.hpp b/include/gridtools/stencil_composition/sid/as_const.hpp
index 1377db1294..2ca2b42f92 100644
--- a/include/gridtools/stencil_composition/sid/as_const.hpp
+++ b/include/gridtools/stencil_composition/sid/as_const.hpp
@@ -52,7 +52,7 @@ namespace gridtools {
             class Src = decay_t<SrcRef>,
             enable_if_t<std::is_pointer<GT_META_CALL(sid::ptr_type, Src)>::value, int> = 0>
         as_const_impl_::const_adapter<Src> as_const(SrcRef &&src) {
-            return as_const_impl_::const_adapter<Src>{std::forward<SrcRef>(src)};
+            return as_const_impl_::const_adapter<Src>{const_expr::forward<SrcRef>(src)};
         }
     } // namespace sid
 } // namespace gridtools
diff --git a/include/gridtools/stencil_composition/sid/composite.hpp b/include/gridtools/stencil_composition/sid/composite.hpp
index 88016dc40e..655e6a6d38 100644
--- a/include/gridtools/stencil_composition/sid/composite.hpp
+++ b/include/gridtools/stencil_composition/sid/composite.hpp
@@ -260,13 +260,13 @@ namespace gridtools {
 
                         template <class... Args, enable_if_t<sizeof...(Args) == sizeof...(Ts), int> = 0>
                         composite_entity(Args &&... args) noexcept
-                            : composite_entity(tuple<Args &&...>{std::forward<Args &&>(args)...}) {}
+                            : composite_entity(tuple<Args &&...>{const_expr::forward<Args &&>(args)...}) {}
 
                         template <template <class...> class L,
                             class... Args,
                             enable_if_t<sizeof...(Args) == sizeof...(Ts), int> = 0>
                         composite_entity(L<Args...> &&tup) noexcept
-                            : m_vals{tuple_util::generate<generators_t, vals_t>(std::move(tup))} {}
+                            : m_vals{tuple_util::generate<generators_t, vals_t>(const_expr::move(tup))} {}
 
                         GT_DECLARE_DEFAULT_EMPTY_CTOR(composite_entity);
                         composite_entity(composite_entity const &) = default;
@@ -308,7 +308,7 @@ namespace gridtools {
                     struct convert_f {
                         template <template <class...> class L, class... Ts>
                         composite_entity<remove_reference_t<Ts>...> operator()(L<Ts...> &&tup) const {
-                            return {std::move(tup)};
+                            return {const_expr::move(tup)};
                         }
                     };
                 };
diff --git a/include/gridtools/stencil_composition/sid/delegate.hpp b/include/gridtools/stencil_composition/sid/delegate.hpp
index e10f1a3da8..c9b3f3cd42 100644
--- a/include/gridtools/stencil_composition/sid/delegate.hpp
+++ b/include/gridtools/stencil_composition/sid/delegate.hpp
@@ -39,7 +39,7 @@ namespace gridtools {
 
           public:
             explicit delegate(Sid const &impl) noexcept : m_impl(impl) {}
-            explicit delegate(Sid &&impl) noexcept : m_impl(std::move(impl)) {}
+            explicit delegate(Sid &&impl) noexcept : m_impl(const_expr::move(impl)) {}
         };
 
         template <class Sid>
diff --git a/include/gridtools/stencil_composition/sid/synthetic.hpp b/include/gridtools/stencil_composition/sid/synthetic.hpp
index e27ca92f9e..cacf65cd2e 100644
--- a/include/gridtools/stencil_composition/sid/synthetic.hpp
+++ b/include/gridtools/stencil_composition/sid/synthetic.hpp
@@ -12,6 +12,7 @@
 #include <utility>
 
 #include "../../common/defs.hpp"
+#include "../../common/generic_metafunctions/utility.hpp"
 #include "../../meta/type_traits.hpp"
 
 namespace gridtools {
@@ -63,7 +64,7 @@ namespace gridtools {
                 unique_mixin &operator=(unique_mixin &&) = default;
 
                 template <class U>
-                unique_mixin(U &&obj) noexcept : mixin<Property, T>{std::forward<U>(obj)} {}
+                unique_mixin(U &&obj) noexcept : mixin<Property, T>{const_expr::forward<U>(obj)} {}
             };
 
             template <class...>
@@ -78,7 +79,7 @@ namespace gridtools {
 
                 template <property Property, class T>
                 synthetic<unique_mixin<Property, decay_t<T>>> set(T &&val) const &&noexcept {
-                    return {std::forward<T>(val), synthetic{}};
+                    return {const_expr::forward<T>(val), synthetic{}};
                 }
             };
 
@@ -87,20 +88,20 @@ namespace gridtools {
 
                 GT_DECLARE_DEFAULT_EMPTY_CTOR(synthetic);
 
-                synthetic(synthetic<Mixins...> const &&src) noexcept : Mixins(std::move(src))... {}
+                synthetic(synthetic<Mixins...> const &&src) noexcept : Mixins(const_expr::move(src))... {}
 
                 template <class T>
                 synthetic(T &&val, synthetic<Mixins...> const &&src) noexcept
-                    : Mixin{std::forward<T>(val)}, Mixins(std::move(src))... {}
+                    : Mixin{const_expr::forward<T>(val)}, Mixins(const_expr::move(src))... {}
 
                 template <property Property, class U>
                 synthetic<unique_mixin<Property, U>, Mixin, Mixins...> set() const &&noexcept {
-                    return {std::move(*this)};
+                    return {const_expr::move(*this)};
                 }
 
                 template <property Property, class T>
                 synthetic<unique_mixin<Property, decay_t<T>>, Mixin, Mixins...> set(T &&val) const &&noexcept {
-                    return {std::forward<T>(val), std::move(*this)};
+                    return {const_expr::forward<T>(val), const_expr::move(*this)};
                 }
             };
         } // namespace synthetic_impl_
diff --git a/include/gridtools/stencil_composition/structured_grids/backend_cuda/iterate_domain_cuda.hpp b/include/gridtools/stencil_composition/structured_grids/backend_cuda/iterate_domain_cuda.hpp
index df74c84281..ffc7e98eb3 100644
--- a/include/gridtools/stencil_composition/structured_grids/backend_cuda/iterate_domain_cuda.hpp
+++ b/include/gridtools/stencil_composition/structured_grids/backend_cuda/iterate_domain_cuda.hpp
@@ -64,7 +64,7 @@ namespace gridtools {
 
         template <class LocalDomain>
         GT_FUNCTION_DEVICE iterate_domain_cuda(LocalDomain &&local_domain, uint_t block_size_i, uint_t block_size_j)
-            : base_t(std::forward<LocalDomain>(local_domain)), m_block_size_i(block_size_i),
+            : base_t(const_expr::forward<LocalDomain>(local_domain)), m_block_size_i(block_size_i),
               m_block_size_j(block_size_j) {}
 
         /**
diff --git a/include/gridtools/stencil_composition/structured_grids/backend_naive/iterate_domain_naive.hpp b/include/gridtools/stencil_composition/structured_grids/backend_naive/iterate_domain_naive.hpp
index 28fc8d51f5..cce87ae98e 100644
--- a/include/gridtools/stencil_composition/structured_grids/backend_naive/iterate_domain_naive.hpp
+++ b/include/gridtools/stencil_composition/structured_grids/backend_naive/iterate_domain_naive.hpp
@@ -30,7 +30,7 @@ namespace gridtools {
         iterate_domain_naive &operator=(iterate_domain_naive const &) = delete;
 
         template <class... Args>
-        GT_FORCE_INLINE iterate_domain_naive(Args &&... args) : base_t(std::forward<Args>(args)...) {}
+        GT_FORCE_INLINE iterate_domain_naive(Args &&... args) : base_t(const_expr::forward<Args>(args)...) {}
 
         template <class Arg, class Ptr>
         static GT_FORCE_INLINE auto deref_impl(Ptr &&ptr) GT_AUTO_RETURN(*ptr);
diff --git a/include/gridtools/stencil_composition/structured_grids/backend_x86/iterate_domain_x86.hpp b/include/gridtools/stencil_composition/structured_grids/backend_x86/iterate_domain_x86.hpp
index f9042d27f9..2e34e4c9ac 100644
--- a/include/gridtools/stencil_composition/structured_grids/backend_x86/iterate_domain_x86.hpp
+++ b/include/gridtools/stencil_composition/structured_grids/backend_x86/iterate_domain_x86.hpp
@@ -30,7 +30,7 @@ namespace gridtools {
         iterate_domain_x86 &operator=(iterate_domain_x86 const &) = delete;
 
         template <class... Args>
-        GT_FORCE_INLINE iterate_domain_x86(Args &&... args) : base_t(std::forward<Args>(args)...) {}
+        GT_FORCE_INLINE iterate_domain_x86(Args &&... args) : base_t(const_expr::forward<Args>(args)...) {}
 
         template <class Arg, class Ptr>
         static GT_FORCE_INLINE auto deref_impl(Ptr &&ptr) GT_AUTO_RETURN(*ptr);
diff --git a/include/gridtools/storage/data_store.hpp b/include/gridtools/storage/data_store.hpp
index 1cb853bd32..eadc85336d 100644
--- a/include/gridtools/storage/data_store.hpp
+++ b/include/gridtools/storage/data_store.hpp
@@ -187,7 +187,7 @@ namespace gridtools {
         }
 
         data_store(data_store &&src, std::shared_ptr<StorageInfo> const &storage_info) noexcept
-            : data_store(std::move(src)) {
+            : data_store(const_expr::move(src)) {
             assert(valid());
             assert(*storage_info);
             assert(*m_shared_storage_info == *storage_info);
diff --git a/include/gridtools/storage/sid.hpp b/include/gridtools/storage/sid.hpp
index 05f360fdc9..c95f56b26b 100644
--- a/include/gridtools/storage/sid.hpp
+++ b/include/gridtools/storage/sid.hpp
@@ -131,7 +131,7 @@ namespace gridtools {
             friend decltype(sid_get_ptr_diff(impl())) sid_get_ptr_diff(host_adapter const &) { return {}; }
 
           public:
-            host_adapter(data_store<Storage, StorageInfo> obj) : m_impl(std::move(obj)) {}
+            host_adapter(data_store<Storage, StorageInfo> obj) : m_impl(const_expr::move(obj)) {}
         };
     } // namespace storage_sid_impl_
 
@@ -166,6 +166,6 @@ namespace gridtools {
      */
     template <class Storage, class StorageInfo>
     storage_sid_impl_::host_adapter<Storage, StorageInfo> as_host(data_store<Storage, StorageInfo> obj) {
-        return {std::move(obj)};
+        return {const_expr::move(obj)};
     }
 } // namespace gridtools
diff --git a/include/gridtools/tools/computation_fixture.hpp b/include/gridtools/tools/computation_fixture.hpp
index 66553d6834..e46c1f1793 100644
--- a/include/gridtools/tools/computation_fixture.hpp
+++ b/include/gridtools/tools/computation_fixture.hpp
@@ -89,7 +89,7 @@ namespace gridtools {
 
         template <class Storage = storage_type, class T = typename Storage::data_t>
         Storage make_storage(T &&obj = {}) const {
-            return {{m_d1, m_d2, m_d3}, std::forward<T>(obj)};
+            return {{m_d1, m_d2, m_d3}, const_expr::forward<T>(obj)};
         }
 
         template <class Storage = storage_type>
@@ -134,7 +134,7 @@ namespace gridtools {
 
         template <class Location, class Storage = storage_type<Location>, class T = typename Storage::data_t>
         Storage make_storage(T &&obj = {}) const {
-            return {{m_d1, Location::n_colors::value, m_d2, m_d3}, std::forward<T>(obj)};
+            return {{m_d1, Location::n_colors::value, m_d2, m_d3}, const_expr::forward<T>(obj)};
         }
 
         template <class Location, class Storage = storage_type<Location>>
@@ -144,7 +144,7 @@ namespace gridtools {
 
         template <class Location, class Storage = storage_type_4d<Location>, class T = typename Storage::data_t>
         Storage make_storage_4d(uint_t dim, T &&val = {}) {
-            return {{d1(), Location::n_colors::value, d2(), d3(), dim}, std::forward<T>(val)};
+            return {{d1(), Location::n_colors::value, d2(), d3(), dim}, const_expr::forward<T>(val)};
         }
 
         template <class Location, class Storage = storage_type_4d<Location>>
@@ -178,7 +178,7 @@ namespace gridtools {
 
         template <class... Args>
         auto make_computation(Args &&... args) const
-            GT_AUTO_RETURN(::gridtools::make_computation<backend_t>(make_grid(), std::forward<Args>(args)...));
+            GT_AUTO_RETURN(::gridtools::make_computation<backend_t>(make_grid(), const_expr::forward<Args>(args)...));
 
         template <class Expected, class Actual>
         void verify(
diff --git a/include/gridtools/tools/mpi_unit_test_driver/mpi_listener.hpp b/include/gridtools/tools/mpi_unit_test_driver/mpi_listener.hpp
index cb83051395..95da58f971 100644
--- a/include/gridtools/tools/mpi_unit_test_driver/mpi_listener.hpp
+++ b/include/gridtools/tools/mpi_unit_test_driver/mpi_listener.hpp
@@ -63,7 +63,7 @@ class mpi_listener : public testing::EmptyTestEventListener {
     /// TODO : it might be an idea to use a resizeable buffer
     template <typename... Args>
     void printf_helper(const char *s, Args &&... args) {
-        snprintf(buffer_, sizeof(buffer_), s, std::forward<Args>(args)...);
+        snprintf(buffer_, sizeof(buffer_), s, const_expr::forward<Args>(args)...);
         print(buffer_);
     }
 
diff --git a/include/gridtools/tools/regression_fixture.hpp b/include/gridtools/tools/regression_fixture.hpp
index 9303b1ec87..791e526e2a 100644
--- a/include/gridtools/tools/regression_fixture.hpp
+++ b/include/gridtools/tools/regression_fixture.hpp
@@ -26,7 +26,7 @@ namespace gridtools {
         template <class... Args>
         void verify(Args &&... args) const {
             if (s_needs_verification)
-                computation_fixture<HaloSize, Axis>::verify(std::forward<Args>(args)...);
+                computation_fixture<HaloSize, Axis>::verify(const_expr::forward<Args>(args)...);
         }
 
         template <class Comp>