Cover all integer index types via templated operator[] on wasm

The previous patch added a `long` overload to fix `c[long]` ambiguity
on wasm32, but introduced a new ambiguity for `c[size_t]` (and any
other integer type that is not exactly R_xlen_t or long), because
the two member overloads then tie on a Conversion-rank index ICS.

Replace the single `long` overload with a SFINAE-constrained template
that accepts any integral type other than R_xlen_t and delegates to
the R_xlen_t version with an explicit cast. The template always
provides an identity match on the index, beating both the
non-template R_xlen_t overload (which requires an integral
conversion) and the built-in pointer subscript (which requires a
user-defined conversion on the object).

Compiled only when LONG_VECTOR_SUPPORT is not defined, so LP64 builds
remain unchanged.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jeroen

ChangeLog

@@ -1,9 +1,10 @@
 2026-06-23  Jeroen Ooms  <jeroen@berkeley.edu>
 
 	* inst/include/Rcpp/vector/Vector.h (Vector::operator[]): Add a
-	long-index overload on platforms without LONG_VECTOR_SUPPORT (such
-	as wasm32) to avoid ambiguity with the built-in pointer subscript
-	synthesised via the implicit Vector -> SEXP conversion
+	templated integer-index overload on platforms without
+	LONG_VECTOR_SUPPORT (such as wasm32) to avoid ambiguity with the
+	built-in pointer subscript synthesised via the implicit
+	Vector -> SEXP conversion
 
 2026-06-18  Dirk Eddelbuettel  <edd@debian.org>
 

inst/include/Rcpp/vector/Vector.h

@@ -21,6 +21,7 @@
 #define Rcpp__vector__Vector_h
 
 #include <Rcpp/vector/Subsetter.h>
+#include <type_traits>
 
 namespace Rcpp{
 
@@ -339,11 +340,17 @@ class Vector :
     inline const_Proxy operator[]( R_xlen_t i ) const { return cache.ref(i) ; }
 #ifndef LONG_VECTOR_SUPPORT
     // On platforms without long vector support (notably wasm32) R_xlen_t is
-    // int while ptrdiff_t is long, which makes c[i] with a long index
-    // ambiguous between this operator[] and the built-in pointer subscript
-    // synthesised via the implicit Vector -> SEXP conversion.
-    inline Proxy operator[]( long i ){ return cache.ref(i) ; }
-    inline const_Proxy operator[]( long i ) const { return cache.ref(i) ; }
+    // int while ptrdiff_t is long, so subscripting with any wider integer
+    // type would otherwise be ambiguous with the built-in pointer subscript
+    // synthesised via the implicit Vector -> SEXP conversion. The template
+    // overloads below provide an exact-match member candidate for every
+    // integer index type other than R_xlen_t itself.
+    template <typename T>
+    inline typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, R_xlen_t>::value, Proxy>::type
+    operator[]( T i ){ return cache.ref(static_cast<R_xlen_t>(i)) ; }
+    template <typename T>
+    inline typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, R_xlen_t>::value, const_Proxy>::type
+    operator[]( T i ) const { return cache.ref(static_cast<R_xlen_t>(i)) ; }
 #endif
 
     inline Proxy operator()( const size_t& i) {