Fix the issue regarding "Clean up code: .str().length() #2577"

src/stan/io/serializer.hpp

@@ -29,9 +29,17 @@ class serializer {
    */
   void check_r_capacity(size_t m) const {
     if (pos_r_ + m > r_size_) {
-      []() STAN_COLD_PATH {
-        throw std::runtime_error("no more storage available to write");
-      }();
+      [](auto r_size_, auto pos_r_, auto m)
+          STAN_COLD_PATH {
+            throw std::runtime_error(
+          std::string("In serializer: Storage capacity [") +
+          std::to_string(r_size_) +
+          "] exceeded while writing value of size [" +
+           std::to_string(m) + "] from position [" +
+            std::to_string(pos_r_) +
+             "]. This is an internal error, if you see it please report it as" +
+             " an issue on the Stan github repository.");
+          }(r_size_, pos_r_, m);
     }
   }
 

src/stan/model/indexing/access_helpers.hpp

@@ -40,8 +40,51 @@ inline auto colwise_reverse(const T& x) {
  * @param y The value to assign from.
  */
 template <typename T1, typename T2,
-          require_any_not_t<is_var_matrix<T1>, is_eigen<T2>>* = nullptr>
-void assign_impl(T1&& x, T2&& y) {
+          require_all_t<is_stan_scalar<T1>, is_stan_scalar<T2>>* = nullptr>
+void assign_impl(T1&& x, T2&& y, const char* name) {
+  x = std::forward<T2>(y);
+}
+
+/**
+ * Base case of assignment
+ * @tparam T1 Any type that's not a var matrix.
+ * @tparam T2 Any type that's not a var matrix.
+ * @param x The value to assign to
+ * @param y The value to assign from.
+ */
+template <typename T1, typename T2,
+          require_any_not_t<is_var_matrix<T1>, is_eigen<T2>>* = nullptr,
+          require_all_t<is_matrix<T1>, is_matrix<T2>>* = nullptr>
+void assign_impl(T1&& x, T2&& y, const char* name) {
+  // We are allowed to assign to fully uninitialized matrix
+  if (x.size() != 0) {
+    static constexpr const char* obj_type
+        = is_vector<T1>::value ? "vector" : "matrix";
+    stan::math::check_size_match(
+        (std::string(obj_type) + " assign columns").c_str(), name, x.cols(),
+        "right hand side columns", y.cols());
+    stan::math::check_size_match(
+        (std::string(obj_type) + " assign rows").c_str(), name, x.rows(),
+        "right hand side rows", y.rows());
+  }
+  x = std::forward<T2>(y);
+}
+
+/**
+ * Base case of assignment
+ * @tparam T1 Any type that's not a var matrix.
+ * @tparam T2 Any type that's not a var matrix.
+ * @param x The value to assign to
+ * @param y The value to assign from.
+ */
+template <typename T1, typename T2,
+          require_all_t<is_std_vector<T1>, is_std_vector<T2>>* = nullptr>
+void assign_impl(T1&& x, T2&& y, const char* name) {
+  // We are allowed to assign to fully uninitialized matrix
+  if (unlikely(x.size() != 0)) {
+    stan::math::check_size_match("assign array size", name, x.size(),
+                                 "right hand side", y.size());
+  }
   x = std::forward<T2>(y);
 }
 
@@ -60,7 +103,17 @@ void assign_impl(T1&& x, T2&& y) {
  */
 template <typename Mat1, typename Mat2, require_var_matrix_t<Mat1>* = nullptr,
           require_eigen_st<std::is_arithmetic, Mat2>* = nullptr>
-void assign_impl(Mat1&& x, Mat2&& y) {
+void assign_impl(Mat1&& x, Mat2&& y, const char* name) {
+  if (x.size() != 0) {
+    static constexpr const char* obj_type
+        = is_vector<Mat1>::value ? "vector" : "matrix";
+    stan::math::check_size_match(
+        (std::string(obj_type) + " assign columns").c_str(), name, x.cols(),
+        "right hand side columns", y.cols());
+    stan::math::check_size_match(
+        (std::string(obj_type) + " assign rows").c_str(), name, x.rows(),
+        "right hand side rows", y.rows());
+  }
   auto prev_vals = stan::math::to_arena(x.val());
   x.vi_->val_ = std::forward<Mat2>(y);
   stan::math::reverse_pass_callback([x, prev_vals]() mutable {

src/stan/model/indexing/assign_varmat.hpp

@@ -111,8 +111,8 @@ template <typename Vec1, typename Vec2, require_var_vector_t<Vec1>* = nullptr,
           internal::require_var_vector_or_arithmetic_eigen<Vec2>* = nullptr>
 inline void assign(Vec1&& x, const Vec2& y, const char* name,
                    const index_multi& idx) {
-  stan::math::check_size_match("vector[multi] assign", "left hand side",
-                               idx.ns_.size(), name, y.size());
+  stan::math::check_size_match("vector[multi] assign", name, idx.ns_.size(),
+                               "right hand side", y.size());
   const auto x_size = x.size();
   const auto assign_size = idx.ns_.size();
   arena_t<std::vector<int>> x_idx(assign_size);
@@ -229,8 +229,8 @@ inline void assign(Mat1&& x, const Vec& y, const char* name, index_uni row_idx,
   stan::math::check_range("matrix[uni, multi] assign", name, x.rows(),
                           row_idx.n_);
   const auto assign_cols = col_idx.ns_.size();
-  stan::math::check_size_match("matrix[uni, multi] assign", "left hand side",
-                               assign_cols, name, y.size());
+  stan::math::check_size_match("matrix[uni, multi] assign columns", name,
+                               assign_cols, "right hand side", y.size());
   const int row_idx_val = row_idx.n_ - 1;
   arena_t<std::vector<int>> x_idx(assign_cols);
   arena_t<Eigen::Matrix<double, -1, 1>> prev_val(assign_cols);
@@ -310,10 +310,10 @@ template <typename Mat1, typename Mat2,
 inline void assign(Mat1&& x, const Mat2& y, const char* name,
                    const index_multi& idx) {
   const auto assign_rows = idx.ns_.size();
-  stan::math::check_size_match("matrix[multi] assign", "left hand side rows",
-                               assign_rows, name, y.rows());
-  stan::math::check_size_match("matrix[multi] assign", "left hand side columns",
-                               x.cols(), name, y.cols());
+  stan::math::check_size_match("matrix[multi] assign rows", name, assign_rows,
+                               "right hand side rows", y.rows());
+  stan::math::check_size_match("matrix[multi] assign columns", name, x.cols(),
+                               "right hand side rows", y.cols());
   arena_t<std::vector<int>> x_idx(assign_rows);
   arena_t<Eigen::Matrix<double, -1, -1>> prev_vals(assign_rows, x.cols());
   Eigen::Matrix<double, -1, -1> y_val_idx(assign_rows, x.cols());
@@ -392,10 +392,11 @@ inline void assign(Mat1&& x, const Mat2& y, const char* name,
                    const index_multi& row_idx, const index_multi& col_idx) {
   const auto assign_rows = row_idx.ns_.size();
   const auto assign_cols = col_idx.ns_.size();
-  stan::math::check_size_match("matrix[multi,multi] assign", "left hand side",
-                               assign_rows, name, y.rows());
-  stan::math::check_size_match("matrix[multi,multi] assign", "left hand side",
-                               assign_cols, name, y.cols());
+  stan::math::check_size_match("matrix[multi,multi] assign rows", name,
+                               assign_rows, "right hand side rows", y.rows());
+  stan::math::check_size_match("matrix[multi,multi] assign columns", name,
+                               assign_cols, "right hand side columns",
+                               y.cols());
   using arena_vec = std::vector<int, stan::math::arena_allocator<int>>;
   using pair_type = std::pair<int, arena_vec>;
   arena_vec x_col_idx(assign_cols);
@@ -514,8 +515,9 @@ template <typename Mat1, typename Mat2, typename Idx,
 inline void assign(Mat1&& x, const Mat2& y, const char* name,
                    const Idx& row_idx, const index_multi& col_idx) {
   const auto assign_cols = col_idx.ns_.size();
-  stan::math::check_size_match("matrix[..., multi] assign", "left hand side",
-                               assign_cols, name, y.cols());
+  stan::math::check_size_match("matrix[..., multi] assign columns", name,
+                               assign_cols, "right hand side columns",
+                               y.cols());
   std::unordered_set<int> x_set;
   const auto& y_eval = y.eval();
   x_set.reserve(assign_cols);