Preserve long fill lengths

Author: t-kalinowski

R/classes.R

@@ -339,6 +339,14 @@ Variable := new_class(
     # storage (0/1) rather than Fortran LOGICAL.
     logical_as_int = prop_bool(default = FALSE),
 
+    # Fortran kind for integer variables. User-facing R integers remain c_int;
+    # pointer-sized compiler locals opt into c_ptrdiff_t explicitly.
+    integer_kind = prop_enum(
+      c("c_int", "c_ptrdiff_t"),
+      default = "c_int",
+      exact = TRUE
+    ),
+
     # TRUE when the variable is available via host association and should not
     # be redeclared in the local scope.
     host_associated = prop_bool(default = FALSE),
@@ -350,7 +358,13 @@ Variable := new_class(
 
   validator = function(self) {
     if (isTRUE(self@logical_as_int) && !identical(self@mode, "logical")) {
-      "`logical_as_int` can only be TRUE when `mode` is 'logical'"
+      return("`logical_as_int` can only be TRUE when `mode` is 'logical'")
+    }
+    if (
+      !identical(self@integer_kind, "c_int") &&
+        !identical(self@mode, "integer")
+    ) {
+      "`integer_kind` can only differ from 'c_int' when `mode` is 'integer'"
     }
   }
 )

R/manifest.R

@@ -73,7 +73,11 @@ var_storage_bytes <- function(var) {
   switch(
     var@mode,
     double = 8,
-    integer = 4,
+    integer = if (identical(var@integer_kind, "c_ptrdiff_t")) {
+      .Machine$sizeof.pointer
+    } else {
+      4
+    },
     complex = 16,
     logical = 4,
     raw = 1,
@@ -196,7 +200,7 @@ iso_c_binding_symbols <- function(
         switch(
           var@mode,
           double = "c_double",
-          integer = "c_int",
+          integer = var@integer_kind,
           complex = "c_double_complex",
           logical = if (isTRUE(logical_is_c_int(var))) "c_int",
           raw = "c_int8_t",
@@ -262,7 +266,7 @@ emit_decl_line <- function(
   type <- switch(
     var@mode,
     double = "real(c_double)",
-    integer = "integer(c_int)",
+    integer = glue("integer({var@integer_kind})"),
     complex = "complex(c_double_complex)",
     logical = if (logical_as_int(var)) "integer(c_int)" else "logical",
     raw = "integer(c_int8_t)",
@@ -371,7 +375,7 @@ r2f.scope <- function(scope, include_errors = FALSE) {
     type <- switch(
       var@mode,
       double = "real(c_double)",
-      integer = "integer(c_int)",
+      integer = glue("integer({var@integer_kind})"),
       complex = "complex(c_double_complex)",
       logical = if (logical_as_int(var)) "integer(c_int)" else "logical",
       raw = "integer(c_int8_t)",

R/r2f-constructors.R

@@ -60,9 +60,16 @@ r2f_handlers[["c"]] <- function(args, scope = NULL, ...) {
           call. = FALSE
         )
       }
-      spread_var <- spread_var %||% scope_unique_var(scope, "integer")
+      spread_var <- spread_var %||%
+        scope_unique_var(
+          scope,
+          "integer",
+          integer_kind = "c_ptrdiff_t"
+        )
       ff[[j]] <- Fortran(
-        glue("({ff[[j]]}, {spread_var}=1, int({len_f}))"),
+        glue(
+          "({ff[[j]]}, {spread_var}=1_c_ptrdiff_t, int({len_f}, kind=c_ptrdiff_t))"
+        ),
         ff[[j]]@value
       )
     }

tests/testthat/test-recycling.R

@@ -237,6 +237,21 @@ test_that("fill constructors spread inside c()", {
   expect_quick_identical(logical_fill, list(c(TRUE, FALSE)))
 })
 
+test_that("symbolic fill spreading preserves pointer-sized lengths", {
+  fn <- function(x) {
+    declare(type(x = double(NA)))
+    c(numeric(length(x)), 1)
+  }
+  fsub <- as.character(r2f(fn))
+  expect_match(fsub, "integer(c_ptrdiff_t) :: tmp1_", fixed = TRUE)
+  expect_match(
+    fsub,
+    "tmp1_=1_c_ptrdiff_t, int(x__len_, kind=c_ptrdiff_t)",
+    fixed = TRUE
+  )
+  expect_quick_identical(fn, list(c(2, 4, 6)))
+})
+
 test_that("fill constructors materialize where an array is required", {
   # A fill reaching c() through an expression is a real array, not a
   # scalar literal with claimed dims (which emitted one element where the