Reorder and hide functions in expr_cast

Author: reuk

src/util/expr_cast.h

@@ -35,6 +35,42 @@ template<typename T> bool can_cast_expr(const exprt &base);
 /// validate particular types.
 inline void validate_expr(const exprt &) {}
 
+namespace detail
+{
+
+// We hide this in a namespace so that only functions that it only
+// participates in overload resolution when explicitly requested.
+
+/// \brief Try to cast a reference to a generic exprt to a specific derived
+///    class
+/// \tparam T The reference or const reference type to \a TUnderlying to cast
+///    to
+/// \tparam TUnderlying An exprt-derived class type
+/// \tparam TExpr The original type to cast from, either exprt or const exprt
+/// \param base Reference to a generic \ref exprt
+/// \return Reference to object of type \a TUnderlying
+///   or valueless optional if \a base is not an instance of \a TUnderlying
+template<typename T, typename TConst, typename TUnderlying, typename TExpr>
+optionalt<std::reference_wrapper<TConst>> expr_try_dynamic_cast(TExpr &base)
+{
+  static_assert(
+    std::is_same<typename std::remove_const<TExpr>::type, exprt>::value,
+    "Tried to expr_try_dynamic_cast from something that wasn't an exprt");
+  static_assert(
+    std::is_reference<T>::value,
+    "Tried to convert exprt & to non-reference type");
+  static_assert(
+    std::is_base_of<exprt, TUnderlying>::value,
+    "The template argument T must be derived from exprt.");
+  if(!can_cast_expr<TUnderlying>(base))
+    return optionalt<std::reference_wrapper<TConst>>();
+  T value=static_cast<T>(base);
+  validate_expr(value);
+  return optionalt<std::reference_wrapper<TConst>>(value);
+}
+
+} // namespace detail
+
 /// \brief Try to cast a constant reference to a generic exprt to a specific
 ///   derived class
 /// \tparam T The exprt-derived class to cast to
@@ -45,7 +81,7 @@ template<typename T>
 optionalt<std::reference_wrapper<typename std::remove_reference<T>::type>>
 expr_try_dynamic_cast(const exprt &base)
 {
-  return expr_try_dynamic_cast<
+  return detail::expr_try_dynamic_cast<
     T,
     typename std::remove_reference<T>::type,
     typename std::remove_const<typename std::remove_reference<T>::type>::type,
@@ -62,41 +98,50 @@ template<typename T>
 optionalt<std::reference_wrapper<typename std::remove_reference<T>::type>>
 expr_try_dynamic_cast(exprt &base)
 {
-  return expr_try_dynamic_cast<
+  return detail::expr_try_dynamic_cast<
     T,
     typename std::remove_reference<T>::type,
     typename std::remove_const<typename std::remove_reference<T>::type>::type,
     exprt>(base);
 }
 
-/// \brief Try to cast a reference to a generic exprt to a specific derived
-///    class
-/// \tparam T The reference or const reference type to \a TUnderlying to cast
-///    to
+namespace detail
+{
+
+// We hide this in a namespace so that only functions that it only
+// participates in overload resolution when explicitly requested.
+
+/// \brief Cast a reference to a generic exprt to a specific derived class
+/// \tparam T The reference or const reference type to \a TUnderlying to cast to
 /// \tparam TUnderlying An exprt-derived class type
 /// \tparam TExpr The original type to cast from, either exprt or const exprt
 /// \param base Reference to a generic \ref exprt
-/// \return Reference to object of type \a TUnderlying
-///   or valueless optional if \a base is not an instance of \a TUnderlying
-template<typename T, typename TConst, typename TUnderlying, typename TExpr>
-optionalt<std::reference_wrapper<TConst>> expr_try_dynamic_cast(TExpr &base)
+/// \return Reference to object of type \a T
+/// \throw std::bad_cast If \a base is not an instance of \a TUnderlying
+/// \remark If CBMC assertions (PRECONDITION) are set to abort then this will
+///   abort rather than throw if \a base is not an instance of \a TUnderlying
+template<typename T, typename TUnderlying, typename TExpr>
+T expr_dynamic_cast(TExpr &base)
 {
   static_assert(
     std::is_same<typename std::remove_const<TExpr>::type, exprt>::value,
-    "Tried to expr_try_dynamic_cast from something that wasn't an exprt");
+    "Tried to expr_dynamic_cast from something that wasn't an exprt");
   static_assert(
     std::is_reference<T>::value,
     "Tried to convert exprt & to non-reference type");
   static_assert(
     std::is_base_of<exprt, TUnderlying>::value,
     "The template argument T must be derived from exprt.");
+  PRECONDITION(can_cast_expr<TUnderlying>(base));
   if(!can_cast_expr<TUnderlying>(base))
-    return optionalt<std::reference_wrapper<TConst>>();
+    throw std::bad_cast();
   T value=static_cast<T>(base);
   validate_expr(value);
-  return optionalt<std::reference_wrapper<TConst>>(value);
+  return value;
 }
 
+} // namespace detail
+
 /// \brief Cast a constant reference to a generic exprt to a specific derived
 ///   class
 /// \tparam T The exprt-derived class to cast to
@@ -108,7 +153,7 @@ optionalt<std::reference_wrapper<TConst>> expr_try_dynamic_cast(TExpr &base)
 template<typename T>
 T expr_dynamic_cast(const exprt &base)
 {
-  return expr_dynamic_cast<
+  return detail::expr_dynamic_cast<
     T,
     typename std::remove_const<typename std::remove_reference<T>::type>::type,
     const exprt>(base);
@@ -124,42 +169,12 @@ T expr_dynamic_cast(const exprt &base)
 template<typename T>
 T expr_dynamic_cast(exprt &base)
 {
-  return expr_dynamic_cast<
+  return detail::expr_dynamic_cast<
     T,
     typename std::remove_const<typename std::remove_reference<T>::type>::type,
     exprt>(base);
 }
 
-/// \brief Cast a reference to a generic exprt to a specific derived class
-/// \tparam T The reference or const reference type to \a TUnderlying to cast to
-/// \tparam TUnderlying An exprt-derived class type
-/// \tparam TExpr The original type to cast from, either exprt or const exprt
-/// \param base Reference to a generic \ref exprt
-/// \return Reference to object of type \a T
-/// \throw std::bad_cast If \a base is not an instance of \a TUnderlying
-/// \remark If CBMC assertions (PRECONDITION) are set to abort then this will
-///   abort rather than throw if \a base is not an instance of \a TUnderlying
-template<typename T, typename TUnderlying, typename TExpr>
-T expr_dynamic_cast(TExpr &base)
-{
-  static_assert(
-    std::is_same<typename std::remove_const<TExpr>::type, exprt>::value,
-    "Tried to expr_dynamic_cast from something that wasn't an exprt");
-  static_assert(
-    std::is_reference<T>::value,
-    "Tried to convert exprt & to non-reference type");
-  static_assert(
-    std::is_base_of<exprt, TUnderlying>::value,
-    "The template argument T must be derived from exprt.");
-  PRECONDITION(can_cast_expr<TUnderlying>(base));
-  if(!can_cast_expr<TUnderlying>(base))
-    throw std::bad_cast();
-  T value=static_cast<T>(base);
-  validate_expr(value);
-  return value;
-}
-
-
 inline void validate_operands(
   const exprt &value,
   exprt::operandst::size_type number,