allow as_array_or_scalar to return a holder of a map for std vector types

Author: SteveBronder

stan/math/prim/fun/as_array_or_scalar.hpp

@@ -69,12 +69,8 @@ template <typename T, require_std_vector_t<T>* = nullptr,
 inline auto as_array_or_scalar(T&& v) {
   using arr_t = Eigen::Array<value_type_t<T>, Eigen::Dynamic, 1>;
   using T_map = Eigen::Map<const arr_t>;
-  if constexpr (std::is_rvalue_reference_v<T&&>) {
-    return make_holder([](auto&& x) { return T_map(x.data(), x.size()); },
-                       std::forward<T>(v));
-  } else {
-    return arr_t(T_map(v.data(), v.size()));
-  }
+  return make_holder([](auto&& x) { return T_map(x.data(), x.size()).matrix().array(); },
+                      std::forward<T>(v));
 }
 
 /**

stan/math/prim/fun/as_column_vector_or_scalar.hpp

@@ -64,6 +64,13 @@ inline auto as_column_vector_or_scalar(T&& a) {
 /**
  * Converts `std::vector` to a column vector.
  *
+ * @note The math library's reverse mode assumes that `Eigen::Map`
+ *  types are allocated and owned elsewhere so we cannot just return
+ *  back a map here else the reverse mode library
+ *  may try to access into a dangling pointer. Instead we wrap
+ *  the `Eigen::Map` in a `Holder` to trick the reverse mode library
+ *  into not thinking this is a map. The `.array().matrix()` inside the
+ *  holder is so that the holder thinks it is returning an expression.
  * @tparam T `std::vector` type.
  * @param a Specified vector.
  * @return input converted to a column vector.
@@ -74,13 +81,10 @@ inline auto as_column_vector_or_scalar(T&& a) {
   using optionally_const_vector
       = std::conditional_t<std::is_const<std::remove_reference_t<T>>::value,
                            const plain_vector, plain_vector>;
+
   using T_map = Eigen::Map<optionally_const_vector>;
-  if constexpr (std::is_rvalue_reference_v<T&&>) {
-    return make_holder([](auto&& x) { return T_map(x.data(), x.size()); },
-                       std::forward<T>(a));
-  } else {
-    return plain_vector(T_map(a.data(), a.size()));
-  }
+  return make_holder([](auto&& x) { return T_map(x.data(), x.size()).array().matrix(); },
+                      std::forward<T>(a));
 }
 
 }  // namespace math