Why are declarations and allocations done on different lines in write_array?

I'm looking at code like the below for write_array, log_prob, and other places we do FnReadParam

      // ex in log_prob
      stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
      //...
      Eigen::Matrix<local_scalar_t__, -1, -1> VV;
      VV = Eigen::Matrix<local_scalar_t__, -1, -1>(N, M);
      current_statement__ = 1;
      VV = in__.matrix(N, M);

Is there a reason why this is not just

Eigen::Matrix<double, -1, -1> VV = in__.matrix(N, M);

This would probably be a lot easier for the C++ compiler to optimize. For example see the godbolt link below with the example assembly output for both versions above

https://godbolt.org/z/3yqJfN (gcc)
https://godbolt.org/z/KawadE (clang)

The assembly for the way things are done now (top view, left part of diff view) has a lot more stuff than the simpler method (bottom view, right part of diff view). The current method also has to do an extra allocation and deletion.

I tried parsing out how to do the simpler method but I got lost at pp_compiler_internal_fn where the compiler does

  | Some FnReadParam -> (
    match es with
    | {Expr.Fixed.pattern= Lit (Str, base_type); _} :: dims ->
        pf ppf "@[<hov 2>in__.%s(@,%a)@]" base_type (list ~sep:comma pp_expr)
          dims

For the VV = in__.matrix(N, M);, but couldn't find where the original declaration and initialization is for

      Eigen::Matrix<double, -1, -1> VV;
      VV = Eigen::Matrix<double>(N, M);

Any pointers on where to look?

Start at pp_compiler_internal_fn and trace the FnReadParam generation used by write_array and log_prob, comparing it with the declaration and assignment shown in the generated C++. Use the linked GCC and Clang Godbolt examples to verify the allocation difference. Done would mean documenting the generation path and deciding whether combining declaration and initialization is an appropriate compiler change.