keep vector and matrix layouts unchanged

Caching the length in proxy_cache and the column count in Matrix added
data members, changing the layout of List, CharacterVector and Matrix.
Packages pass these by reference across shared libraries compiled
against different Rcpp versions: rust hands a List to revdbayes through
an XPtr function pointer, and lite, threshr and evmissing reach the same
path. In the 2026-10-06 reverse-dependency run revdbayes read a size
that rust never wrote and failed name lookup with 'Index out of bounds'.

ncol() is now derived from the cached length and nrow(), and proxy_cache
reads the length on demand; only the cold warning helper and the cached
atomic-vector length remain.

Author: kevinushey

ChangeLog

@@ -1,11 +1,13 @@
 2026-09-30  Kevin Ushey <kevinushey@gmail.com>
 
 	* inst/include/Rcpp/vector/traits.h: Move the out-of-bounds warning into
-	a cold, out-of-line helper; cache the vector length in proxy_cache
-	* inst/include/Rcpp/vector/Vector.h: Return the cached length from
-	size() and length() rather than calling Rf_xlength() each time
-	* inst/include/Rcpp/vector/Matrix.h: Cache the number of columns
-	* inst/include/Rcpp/vector/SubMatrix.h: Idem
+	a cold, out-of-line helper; add get_size() to the vector caches
+	* inst/include/Rcpp/vector/Vector.h: Return the length cached by
+	r_vector_cache from size() and length() rather than calling
+	Rf_xlength() each time
+	* inst/include/Rcpp/vector/Matrix.h: Derive ncol() from the cached
+	length and nrow() instead of reading the dim attribute; document that
+	no data members may be added, as the layout is shared across packages
 
 2026-09-22  Iñaki Ucar <iucar@fedoraproject.org>
 

inst/NEWS.Rd

@@ -27,8 +27,11 @@
       warnings (Iñaki in \ghpr{1508} closing \ghit{1497})
       \item The \code{col} constructor now uses \code{nrow} in an
       initialization (Iñaki in \ghpr{1509})
-      \item Bounds-checked element access is faster, and vector lengths and
-      matrix column counts are now cached (Kevin in \ghpr{1511} closing
+      \item Bounds-checked element access is faster, \code{size()} of
+      atomic vectors uses the cached length, and \code{ncol()} no longer
+      reads the \code{dim} attribute; object layouts are unchanged, as
+      packages such as \pkg{rust} and \pkg{revdbayes} exchange Rcpp
+      objects across shared libraries (Kevin in \ghpr{1511} closing
       \ghit{1510})
     }
     \item Changes in Rcpp Documentation:

inst/include/Rcpp/vector/Matrix.h

@@ -27,8 +27,11 @@ namespace Rcpp{
 
 template <int RTYPE, template <class> class StoragePolicy = PreserveStorage >
 class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, true, Matrix<RTYPE,StoragePolicy> > {
+    // The only data member. Packages pass Rcpp objects by reference across
+    // shared-library boundaries (e.g. rust calls into revdbayes through XPtr
+    // function pointers), and the two sides may have been compiled against
+    // different Rcpp versions. Adding a member changes the layout they share.
     int nrows ;
-    int ncols ;
 
 public:
     using Vector<RTYPE, StoragePolicy>::size; 	// disambiguate diamond pattern for g++-6 and later
@@ -50,33 +53,33 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
     typedef typename VECTOR::Proxy Proxy ;
     typedef typename VECTOR::const_Proxy const_Proxy ;
 
-    Matrix() : VECTOR(Dimension(0, 0)), nrows(0), ncols(0) {}
+    Matrix() : VECTOR(Dimension(0, 0)), nrows(0) {}
 
-    Matrix(SEXP x) : VECTOR(x), nrows( VECTOR::dims()[0] ), ncols( VECTOR::dims()[1] ) {}
+    Matrix(SEXP x) : VECTOR(x), nrows( VECTOR::dims()[0] ) {}
 
-    Matrix( const Dimension& dims) : VECTOR( Rf_allocMatrix( RTYPE, dims[0], dims[1] ) ), nrows(dims[0]), ncols(dims[1]) {
+    Matrix( const Dimension& dims) : VECTOR( Rf_allocMatrix( RTYPE, dims[0], dims[1] ) ), nrows(dims[0]) {
         if( dims.size() != 2 ) throw not_a_matrix();
         VECTOR::init() ;
     }
-    Matrix( const int& nrows_, const int& ncols_) : VECTOR( Dimension( nrows_, ncols_ ) ),
-      nrows(nrows_), ncols(ncols_)
+    Matrix( const int& nrows_, const int& ncols) : VECTOR( Dimension( nrows_, ncols ) ),
+      nrows(nrows_)
     {}
 
     template <typename Iterator>
-    Matrix( const int& nrows_, const int& ncols_, Iterator start ) :
-        VECTOR( start, start + (static_cast<R_xlen_t>(nrows_)*ncols_) ),
-        nrows(nrows_), ncols(ncols_)
+    Matrix( const int& nrows_, const int& ncols, Iterator start ) :
+        VECTOR( start, start + (static_cast<R_xlen_t>(nrows_)*ncols) ),
+        nrows(nrows_)
     {
         VECTOR::attr( "dim" ) = Dimension( nrows, ncols ) ;
     }
 
-    Matrix( const int& n) : VECTOR( Dimension( n, n ) ), nrows(n), ncols(n) {}
+    Matrix( const int& n) : VECTOR( Dimension( n, n ) ), nrows(n) {}
 
 
-    Matrix( const Matrix& other) : VECTOR( other.get__() ), nrows(other.nrows), ncols(other.ncols) {}
+    Matrix( const Matrix& other) : VECTOR( other.get__() ), nrows(other.nrows) {}
 
     template <bool NA, typename MAT>
-    Matrix( const MatrixBase<RTYPE,NA,MAT>& other ) : VECTOR( Rf_allocMatrix( RTYPE, static_cast<int>(other.nrow()), static_cast<int>(other.ncol()) ) ), nrows(static_cast<int>(other.nrow())), ncols(static_cast<int>(other.ncol())) {
+    Matrix( const MatrixBase<RTYPE,NA,MAT>& other ) : VECTOR( Rf_allocMatrix( RTYPE, static_cast<int>(other.nrow()), static_cast<int>(other.ncol()) ) ), nrows(static_cast<int>(other.nrow())) {
         import_matrix_expression<NA,MAT>( other, nrows, ncol() ) ;
     }
 
@@ -87,21 +90,23 @@ class Matrix : public Vector<RTYPE, StoragePolicy>, public MatrixBase<RTYPE, tru
         if( ! ::Rf_isMatrix(x) ) throw not_a_matrix();
         VECTOR::set__( x ) ;
         nrows = other.nrows ;
-        ncols = other.ncols ;
         return *this ;
     }
     Matrix& operator=( const SubMatrix<RTYPE>& ) ;
 
-    explicit Matrix( const no_init_matrix& obj) : VECTOR(Rf_allocMatrix(RTYPE, obj.nrow(), obj.ncol())), nrows(obj.nrow()), ncols(obj.ncol()) {}
+    explicit Matrix( const no_init_matrix& obj) : VECTOR(Rf_allocMatrix(RTYPE, obj.nrow(), obj.ncol())), nrows(obj.nrow()) {}
 
+    // A matrix has exactly nrow * ncol elements, so the column count follows
+    // from the (cached) length without reading the dim attribute. Only an
+    // empty matrix, which may still have columns, needs the attribute.
     inline int ncol() const {
-        return ncols ;
+        return nrows == 0 ? VECTOR::dims()[1] : static_cast<int>( VECTOR::size() / nrows ) ;
     }
     inline int nrow() const {
         return nrows ;
     }
     inline int cols() const {
-        return ncols ;
+        return ncol() ;
     }
     inline int rows() const {
         return nrows ;

inst/include/Rcpp/vector/SubMatrix.h

@@ -56,7 +56,7 @@ class SubMatrix : public Rcpp::MatrixBase< RTYPE, true, SubMatrix<RTYPE> > {
 } ;
 
 template <int RTYPE, template <class> class StoragePolicy >
-Matrix<RTYPE,StoragePolicy>::Matrix( const SubMatrix<RTYPE>& sub ) : VECTOR( Rf_allocMatrix( RTYPE, sub.nrow(), sub.ncol() )), nrows(sub.nrow()), ncols(sub.ncol()) {
+Matrix<RTYPE,StoragePolicy>::Matrix( const SubMatrix<RTYPE>& sub ) : VECTOR( Rf_allocMatrix( RTYPE, sub.nrow(), sub.ncol() )), nrows(sub.nrow()) {
     int nc = sub.ncol() ;
     iterator start = VECTOR::begin() ;
 	iterator rhs_it ;
@@ -73,7 +73,6 @@ Matrix<RTYPE,StoragePolicy>& Matrix<RTYPE,StoragePolicy>::operator=( const SubMa
     int nc = sub.ncol(), nr = sub.nrow() ;
     if( nc != nrow() || nr != ncol() ){
         nrows = nr ;
-        ncols = nc ;
         VECTOR::set__( Rf_allocMatrix( RTYPE, nr, nc ) ) ;
 	}
 	iterator start = VECTOR::begin() ;

inst/include/Rcpp/vector/traits.h

@@ -84,15 +84,17 @@ namespace traits{
 		typedef typename r_vector_proxy<RTYPE, StoragePolicy>::type proxy ;
 		typedef typename r_vector_const_proxy<RTYPE, StoragePolicy>::type const_proxy ;
 
-		proxy_cache(): p(0), size(0){}
+		proxy_cache(): p(0){}
 		~proxy_cache(){}
 		void update( const VECTOR& v ){
 			p = const_cast<VECTOR*>(&v) ;
-			size = ::Rf_xlength(v.get__());
 		}
 		inline iterator get() const { return iterator( proxy(*p, 0 ) ) ;}
 		inline const_iterator get_const() const { return const_iterator( const_proxy(*p, 0) ) ; }
-		inline R_xlen_t get_size() const { return size; }
+		// Not cached: a size member here would change the layout of List and
+		// CharacterVector, which packages pass by reference across
+		// shared-library boundaries (see the note in Matrix.h).
+		inline R_xlen_t get_size() const { return ::Rf_xlength(p->get__()); }
 
 		inline proxy ref() { check_index(0); return proxy(*p,0) ; }
 		inline proxy ref(R_xlen_t i) { check_index(i); return proxy(*p,i);}
@@ -102,10 +104,10 @@ namespace traits{
 
 	private:
 		VECTOR* p ;
-		R_xlen_t size ;
 
 		void check_index(R_xlen_t i) const {
 #ifndef RCPP_NO_BOUNDS_CHECK
+			R_xlen_t size = get_size() ;
 			if (i >= size) {
 				warn_index_out_of_bounds(i, size); // #nocov
 			}