Fix/rvalue and vector scalar deserializer

src/stan/io/deserializer.hpp

@@ -53,6 +53,7 @@ class deserializer {
    * @throws std::runtime_error if there aren't at least m reals left
    */
   void check_r_capacity(size_t m) const {
+    STAN_NO_RANGE_CHECKS_RETURN;
     if (pos_r_ + m > r_size_) {
       []() STAN_COLD_PATH {
         throw std::runtime_error("no more scalars to read");
@@ -66,6 +67,7 @@ class deserializer {
    * @throws std::runtime_error if there aren't at least m integers left
    */
   void check_i_capacity(size_t m) const {
+    STAN_NO_RANGE_CHECKS_RETURN;
     if (pos_i_ + m > i_size_) {
       []() STAN_COLD_PATH {
         throw std::runtime_error("no more integers to read");
@@ -324,10 +326,11 @@ class deserializer {
    * `read` functions.
    */
   template <typename Ret, typename... Sizes,
-            require_std_vector_t<Ret>* = nullptr>
+            require_std_vector_t<Ret>* = nullptr,
+            require_not_same_t<value_type_t<Ret>, T>* = nullptr>
   inline auto read(Eigen::Index m, Sizes... dims) {
     if (unlikely(m == 0)) {
-      return Ret();
+      return std::decay_t<Ret>();
     } else {
       std::decay_t<Ret> ret_vec;
       ret_vec.reserve(m);
@@ -338,6 +341,27 @@ class deserializer {
     }
   }
 
+  /**
+   * Return an `std::vector` of scalars
+   * @tparam Ret The type to return.
+   * @tparam Sizes integral types.
+   * @param m The size of the vector.
+   */
+  template <typename Ret, typename... Sizes,
+            require_std_vector_t<Ret>* = nullptr,
+            require_same_t<value_type_t<Ret>, T>* = nullptr>
+  inline auto read(Eigen::Index m) {
+    if (unlikely(m == 0)) {
+      return std::decay_t<Ret>();
+    } else {
+      check_r_capacity(m);
+      const auto* start_pos = &this->map_r_.coeffRef(this->pos_r_);
+      const auto* end_pos = &this->map_r_.coeffRef(this->pos_r_ + m);
+      this->pos_r_ += m;
+      return std::decay_t<Ret>(start_pos, end_pos);
+    }
+  }
+
   /**
    * Return the next object transformed to have the specified
    * lower bound, possibly incrementing the specified reference with the

src/stan/model/indexing/rvalue.hpp

@@ -55,6 +55,16 @@ inline T rvalue(T&& x, const char* /*name*/) {
   return std::forward<T>(x);
 }
 
+template <typename T>
+inline T& rvalue(T& x, const char* /*name*/) {
+  return x;
+}
+
+template <typename T>
+inline const T& rvalue(const T& x, const char* /*name*/) {
+  return x;
+}
+
 /**
  * Return the result of indexing a type without taking a subset. Mostly used as
  * an intermediary rvalue function when doing multiple subsets.
@@ -70,6 +80,16 @@ inline T rvalue(T&& x, const char* /*name*/, index_omni /*idx*/) {
   return std::forward<T>(x);
 }
 
+template <typename T>
+inline T& rvalue(T& x, const char* /*name*/, index_omni /*idx*/) {
+  return x;
+}
+
+template <typename T>
+inline const T& rvalue(const T& x, const char* /*name*/, index_omni /*idx*/) {
+  return x;
+}
+
 /**
  * Return the result of indexing a type without taking a subset
  *
@@ -86,6 +106,18 @@ inline T rvalue(T&& x, const char* name, index_omni /*idx1*/,
   return std::forward<T>(x);
 }
 
+template <typename T>
+inline T& rvalue(T& x, const char* name, index_omni /*idx1*/,
+                 index_omni /*idx2*/) {
+  return x;
+}
+
+template <typename T>
+inline const T& rvalue(const T& x, const char* name, index_omni /*idx1*/,
+                       index_omni /*idx2*/) {
+  return x;
+}
+
 /**
  * Return a single element of a Vector.
  *
@@ -675,6 +707,22 @@ inline auto rvalue(StdVec&& v, const char* name, index_uni idx1,
  */
 template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
 inline auto rvalue(StdVec&& v, const char* name, index_uni idx) {
+  math::check_range("array[uni, ...] index", name, v.size(), idx.n_);
+  if (std::is_rvalue_reference<StdVec>::value) {
+    return std::move(v[idx.n_ - 1]);
+  } else {
+    return v[idx.n_ - 1];
+  }
+}
+
+template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
+inline auto& rvalue(StdVec& v, const char* name, index_uni idx) {
+  math::check_range("array[uni, ...] index", name, v.size(), idx.n_);
+  return v[idx.n_ - 1];
+}
+
+template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
+inline const auto& rvalue(const StdVec& v, const char* name, index_uni idx) {
   math::check_range("array[uni, ...] index", name, v.size(), idx.n_);
   return v[idx.n_ - 1];
 }