Materialize fill constructors before matrix(): reshape() needs an array SOURCE

matrix() was on the fill-constructor pass-through whitelist, so
matrix(numeric(6), 3, 2) reached the reshape() lowering as the scalar
literal 0.0_c_double claiming array dims. That only compiled because
hoist_unless_name() used to materialize every non-name; when it learned
to skip literals (earlier on this branch), the emitted
reshape(0.0_c_double, ...) became a gfortran error -- and
matrix(logical(k), ...) kept working only because the literal regex
does not match .false.. Drop matrix from the whitelist so fills
materialize into a hoisted array temporary like any other array
consumer, restoring the pre-cleanup code shape deliberately instead of
by regex accident.

Found by codex review (fable-final round); regression relative to main.

Author: mns-nordicals

R/r2f-constructors.R

@@ -165,19 +165,20 @@ r2f_handlers[["rep.int"]] <- function(args, scope, ..., hoist = NULL) {
 
 # Compile a zero-fill constructor call: a single scalar literal carrying
 # array dims. Whole-array assignment broadcasts that correctly, and
-# c()/array()/matrix() spread or pad it explicitly, so those contexts keep
-# the scalar form. Any other consumer (elementwise ops, reductions, ...)
-# needs a real array expression -- an expression like `numeric(2) + 1`
-# would otherwise contribute one element where its dims claim two -- so
-# materialize the fill into a hoisted temporary there.
+# c()/array() spread it as an implied-do, so those contexts keep the
+# scalar form. Any other consumer (elementwise ops, reductions,
+# matrix() -- whose reshape() lowering needs an array SOURCE, not a
+# scalar literal) needs a real array expression -- an expression like
+# `numeric(2) + 1` would otherwise contribute one element where its dims
+# claim two -- so materialize the fill into a hoisted temporary there.
 fill_constructor_value <- function(literal, mode, args, scope, ..., hoist) {
   var <- Variable(mode = mode, dims = r2dims(args, scope))
   out <- Fortran(literal, var)
   if (passes_as_scalar(var)) {
     return(out)
   }
   parent_call <- parent_call_name(list(...)$calls)
-  if (parent_call %in% c("<-", "=", "<<-", "c", "array", "matrix")) {
+  if (parent_call %in% c("<-", "=", "<<-", "c", "array")) {
     return(out)
   }
   materialize_via_hoist(literal, mode, var@dims, hoist, "fill constructor")

tests/testthat/test-recycling.R

@@ -236,6 +236,36 @@ test_that("fill constructors materialize where an array is required", {
   expect_quick_identical(symbolic, list(c(5, 6), 3L))
 })
 
+test_that("fill constructors materialize inside matrix()", {
+  # matrix() lowers non-scalar data through reshape(), whose SOURCE must
+  # be an array. Fills used to pass through as scalar literals with
+  # claimed dims and relied on hoist_unless_name() to materialize them;
+  # once that helper learned to skip literals, the generated
+  # reshape(0.0_c_double, ...) failed to compile (and logical(k) only
+  # kept working because the literal regex missed `.false.`). Fills now
+  # materialize before matrix() like any other array consumer.
+  numeric_fill <- function() {
+    matrix(numeric(6), 3, 2)
+  }
+  expect_quick_identical(numeric_fill, list())
+
+  integer_fill <- function() {
+    matrix(integer(6), 3, 2)
+  }
+  expect_quick_identical(integer_fill, list())
+
+  logical_fill <- function() {
+    matrix(logical(6), 3, 2)
+  }
+  expect_quick_identical(logical_fill, list())
+
+  assigned <- function() {
+    x <- matrix(numeric(6), 3, 2)
+    x
+  }
+  expect_quick_identical(assigned, list())
+})
+
 test_that("matrix(scalar, m, n) materializes where an array is required", {
   reduced <- function() {
     sum(matrix(2, 2, 3))