Switch from pointers to optionalt

Author: smowton

src/util/expr_cast.h

@@ -1,6 +1,10 @@
-/*
-  Author: Nathan Phillips <[email protected]>
-*/
+/*******************************************************************\
+
+Module:
+
+Author: Nathan Phillips <[email protected]>
+
+\*******************************************************************/
 
 #ifndef CPROVER_UTIL_EXPR_CAST_H
 #define CPROVER_UTIL_EXPR_CAST_H
@@ -10,9 +14,11 @@
 
 #include <typeinfo>
 #include <type_traits>
+#include <functional>
+
 #include "invariant.h"
 #include "expr.h"
-
+#include "optional.h"
 
 /// \brief Check whether a reference to a generic \ref exprt is of a specific
 ///   derived class.
@@ -25,61 +31,66 @@
 template<typename T> bool can_cast_expr(const exprt &base);
 
 
-/// \brief Cast a constant pointer to a generic exprt to a specific derived
-///   class
+/// \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
-/// \param base Pointer to a generic \ref exprt
-/// \return Pointer to object of type \a T or null if \a base is not an
-///   instance of \a T
+/// \param base Reference to a generic \ref exprt
+/// \return Reference to object of type \a T or valueless optional if \a base
+///   is not an instance of \a T
 template<typename T>
-T expr_dynamic_cast(const exprt *base)
+optionalt<std::reference_wrapper<typename std::remove_reference<T>::type>>
+expr_try_dynamic_cast(const exprt &base)
 {
-  return expr_dynamic_cast<
+  return expr_try_dynamic_cast<
     T,
-    typename std::remove_const<typename std::remove_pointer<T>::type>::type,
+    typename std::remove_reference<T>::type,
+    typename std::remove_const<typename std::remove_reference<T>::type>::type,
     const exprt>(base);
 }
 
-/// \brief Cast a pointer to a generic exprt to a specific derived class
+/// \brief Try to cast a reference to a generic exprt to a specific derived
+///   class
 /// \tparam T The exprt-derived class to cast to
-/// \param base Pointer to a generic \ref exprt
-/// \return Pointer to object of type \a T or null if \a base is not an
-///   instance of \a T
+/// \param base Reference to a generic \ref exprt
+/// \return Reference to object of type \a T or valueless optional if \a base is
+///   not an instance of \a T
 template<typename T>
-T expr_dynamic_cast(exprt *base)
+optionalt<std::reference_wrapper<typename std::remove_reference<T>::type>>
+expr_try_dynamic_cast(exprt &base)
 {
-  return expr_dynamic_cast<
+  return expr_try_dynamic_cast<
     T,
-    typename std::remove_const<typename std::remove_pointer<T>::type>::type,
+    typename std::remove_reference<T>::type,
+    typename std::remove_const<typename std::remove_reference<T>::type>::type,
     exprt>(base);
 }
 
-/// \brief Cast a pointer to a generic exprt to a specific derived class
-/// \tparam T The pointer or const pointer type to \a TUnderlying to cast to
+/// \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 Pointer to a generic \ref exprt
-/// \return Pointer to object of type \a TUnderlying
-///   or null if \a base is not an instance of \a TUnderlying
-template<typename T, typename TUnderlying, typename TExpr>
-T expr_dynamic_cast(TExpr *base)
+/// \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_dynamic_cast from something that wasn't an exprt");
+    "Tried to expr_try_dynamic_cast from something that wasn't an exprt");
   static_assert(
-    std::is_pointer<T>::value,
-    "Tried to convert exprt * to non-pointer type");
+    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(base == nullptr)
-    return nullptr;
-  if(!can_cast_expr<TUnderlying>(*base))
-    return nullptr;
+  if(!can_cast_expr<TUnderlying>(base))
+    return optionalt<std::reference_wrapper<TConst>>();
   T value=static_cast<T>(base);
-  validate_expr(*value);
-  return value;
+  validate_expr(value);
+  return optionalt<std::reference_wrapper<TConst>>(value);
 }
 
 /// \brief Cast a constant reference to a generic exprt to a specific derived

unit/CMakeLists.txt

@@ -21,6 +21,9 @@ list(REMOVE_ITEM sources
     ${CMAKE_CURRENT_SOURCE_DIR}/cpp_scanner.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/float_utils.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ieee_float.cpp
+
+    # Intended to fail to compile
+    ${CMAKE_CURRENT_SOURCE_DIR}/util/expr_cast/expr_undefined_casts.cpp
 )
 
 add_executable(unit ${sources} ${headers})

unit/util/expr_cast/expr_cast.cpp

@@ -16,32 +16,35 @@ SCENARIO("expr_dynamic_cast",
 {
   symbol_exprt symbol_expr;
 
-  GIVEN("A const exprt pointer to a symbolt")
+  GIVEN("A const exprt reference to a symbolt")
   {
-    const exprt *expr_ptr=&symbol_expr;
+    const exprt &expr=symbol_expr;
 
-    THEN("Casting from exprt pointer to symbol_exprt pointer returns non-null")
+    THEN("Try-casting from exprt reference to symbol_exprt pointer "
+         "returns a value")
     {
-      REQUIRE(expr_dynamic_cast<const symbol_exprt *>(expr_ptr)!=nullptr);
+      REQUIRE(expr_try_dynamic_cast<const symbol_exprt &>(expr).has_value());
     }
 
-    THEN("Casting from exprt pointer to transt pointer returns null")
+    THEN("Casting from exprt pointer to transt pointer doesn't return a value")
     {
-      REQUIRE(expr_dynamic_cast<const transt *>(expr_ptr)==nullptr);
+      REQUIRE(!expr_try_dynamic_cast<const transt &>(expr).has_value());
     }
   }
-  GIVEN("A exprt pointer to a symbolt")
+  GIVEN("A exprt reference to a symbolt")
   {
-    exprt *expr_ptr=&symbol_expr;
+    exprt &expr=symbol_expr;
 
-    THEN("Casting from exprt pointer to symbol_exprt pointer returns non-null")
+    THEN("Casting from exprt reference to symbol_exprt reference "
+         "returns a value")
     {
-      REQUIRE(expr_dynamic_cast<symbol_exprt *>(expr_ptr)!=nullptr);
+      REQUIRE(expr_try_dynamic_cast<symbol_exprt &>(expr).has_value());
     }
 
-    THEN("Casting from exprt pointer to transt pointer returns null")
+    THEN("Casting from exprt reference to transt reference "
+         "doesn't return a value")
     {
-      REQUIRE(expr_dynamic_cast<transt *>(expr_ptr)==nullptr);
+      REQUIRE(!expr_try_dynamic_cast<transt &>(expr).has_value());
     }
   }
   GIVEN("A const exprt reference to a symbolt")

unit/util/expr_cast/expr_undefined_casts.cpp

@@ -19,31 +19,32 @@ SCENARIO("expr_dynamic_cast",
 {
   symbol_exprt symbol_expr;
 
-  GIVEN("A const exprt pointer to a symbolt")
+  GIVEN("A const exprt reference to a symbolt")
   {
-    const exprt *expr_ptr=&symbol_expr;
+    const exprt &expr=symbol_expr;
 
-    THEN("Casting from exprt pointer to ieee_float_op_exprt should not compile")
+    THEN("Casting from exprt reference to ieee_float_op_exprt "
+         "should not compile")
     {
       // This shouldn't compile
-      expr_dynamic_cast<const ieee_float_op_exprt *>(expr_ptr);
+      expr_dynamic_cast<const ieee_float_op_exprt &>(expr);
     }
-    THEN("Casting from exprt pointer to shift_exprt should not compile")
+    THEN("Casting from exprt reference to shift_exprt should not compile")
     {
       // This shouldn't compile
-      expr_dynamic_cast<const shift_exprt *>(expr_ptr);
+      expr_dynamic_cast<const shift_exprt &>(expr);
     }
     THEN(
-      "Casting from exprt pointer to non-pointer/reference should not compile")
+      "Casting from exprt reference to non-reference should not compile")
     {
       // This shouldn't compile
-      expr_dynamic_cast<symbol_exprt>(expr_ptr);
+      expr_dynamic_cast<symbol_exprt>(expr);
     }
     THEN(
       "Casting from const exprt reference to non-const symbol_exprt reference "
       "should not compile")
     {
-      expr_dynamic_cast<symbol_exprt *>(expr_ptr);
+      expr_dynamic_cast<symbol_exprt &>(expr);
     }
   }
 }