[PartialReassembly] Make compile with g++5.3

* A known in bug in g++5.3 leads to a compiler error due to the
  trailing return type of the generic lambda in the supportsPartialReassembly
  and hasVertexColor method
* Replacing those methods with a struct providing the ()operator should
  fix that issue

dumux/assembly/partialreassembler.hh

@@ -380,12 +380,12 @@ public:
     using ParentType::ParentType;
 };
 
-//! helper function to determine whether the an engine class has vertex colors
-template<class Engine>
-auto hasVertexColor()
+//! helper struct to determine whether the an engine class has vertex colors
+struct hasVertexColor
 {
-    return isValid([](auto&& a) -> decltype(a.vertexColor(0)) {}).template check<Engine>();
-}
+    template<class Engine>
+    auto operator()(Engine&& e) -> decltype(e.vertexColor(0)) {};
+};
 
 /*!
  * \ingroup Assembly
@@ -469,7 +469,7 @@ public:
     EntityColor dofColor(size_t idx) const
     { return engine_.dofColor(idx); }
 
-    template<bool enable = decltype(hasVertexColor<Engine>())::value,
+    template<bool enable = decltype(isValid(hasVertexColor()).template check<Engine>())::value,
              typename std::enable_if_t<enable, int> = 0>
     EntityColor vertexColor(size_t idx) const
     { return engine_.vertexColor(idx); }

dumux/nonlinear/newtonsolver.hh

@@ -49,19 +49,15 @@
 
 namespace Dumux {
 
-//! helper function detecting if an assembler supports partial reassembly
-template<class Assembler>
-auto supportsPartialReassembly(const Assembler& assembler) noexcept
+//! helper struct detecting if an assembler supports partial reassembly
+struct supportsPartialReassembly
 {
-    using SolutionVector = typename Assembler::ResidualType;
-    using Reassembler = PartialReassembler<Assembler>;
-
-    return isValid([](auto&& a) -> decltype(
-        a.assembleJacobianAndResidual(std::declval<Assembler>(),
-                                      std::declval<const SolutionVector&>(),
-                                      std::declval<const Reassembler*>())
-    ){})(assembler);
-}
+    template<class Assembler>
+    auto operator()(Assembler&& a)
+    -> decltype(a.assembleJacobianAndResidual(std::declval<const typename Assembler::ResidualType&>(),
+                                              std::declval<const PartialReassembler<Assembler>*>()))
+    {};
+};
 
 /*!
  * \ingroup Nonlinear
@@ -759,7 +755,7 @@ private:
     //! assembleLinearSystem_ for assemblers that support partial reassembly
     template<class A>
     auto assembleLinearSystem_(const A& assembler, const SolutionVector& uCurrentIter)
-    -> typename std::enable_if_t<decltype(supportsPartialReassembly(assembler))::value, void>
+    -> typename std::enable_if_t<decltype(isValid(supportsPartialReassembly())(assembler))::value, void>
     {
         assembler_->assembleJacobianAndResidual(uCurrentIter, partialReassembler_.get());
     }
@@ -767,7 +763,7 @@ private:
     //! assembleLinearSystem_ for assemblers that don't support partial reassembly
     template<class A>
     auto assembleLinearSystem_(const A& assembler, const SolutionVector& uCurrentIter)
-    -> typename std::enable_if_t<!decltype(supportsPartialReassembly(assembler))::value, void>
+    -> typename std::enable_if_t<!decltype(isValid(supportsPartialReassembly())(assembler))::value, void>
     {
         assembler_->assembleJacobianAndResidual(uCurrentIter);
     }