Require compile-time conformability for matrix ops

- Error on ambiguous cbind/rbind dimensions

- Error on ambiguous crossprod/tcrossprod shapes

- Add public API tests for matrix parse/constraints

Author: t-kalinowski

R/r2f-matrix.R

@@ -181,13 +181,6 @@ bind_output_mode <- function(values, context) {
     return("logical")
   }
   if ("raw" %in% modes) {
-    if (length(modes) > 1L) {
-      stop(
-        context,
-        " does not support mixing raw with other types",
-        call. = FALSE
-      )
-    }
     return("raw")
   }
   stop(context, " does not support input mode(s): ", str_flatten_commas(modes))
@@ -263,7 +256,13 @@ bind_common_dim <- function(dim_list, scalar_flags, context, label) {
         )
       }
       if (conform$unknown) {
-        warn_conformability_unknown(target, dim_list[[idx]], context)
+        stop(
+          context,
+          " requires inputs with a common ",
+          label,
+          " count",
+          call. = FALSE
+        )
       }
     }
   }
@@ -866,7 +865,12 @@ crossprod_like <- function(
     stop("non-conformable arguments in ", context, call. = FALSE)
   }
   if (conform$unknown) {
-    warn_conformability_unknown(x_eff$cols, y_eff$rows, context)
+    stop(
+      "cannot verify conformability in ",
+      context,
+      " at compile time",
+      call. = FALSE
+    )
   }
 
   m <- x_eff$rows

tests/testthat/test-bind.R

@@ -246,7 +246,7 @@ test_that("cbind rejects mixing complex with non-complex", {
   expect_error(quick(bad), "mixing complex", fixed = TRUE)
 })
 
-test_that("cbind warns when conformability cannot be verified", {
+test_that("cbind requires dimensions to be equal at compile time", {
   fn <- function(x, y, n, m) {
     declare(
       type(n = integer(1)),
@@ -257,18 +257,44 @@ test_that("cbind warns when conformability cannot be verified", {
     cbind(x, y)
   }
 
-  qfn <- NULL
-  expect_warning(
-    qfn <- quick(fn),
-    "cannot verify conformability in cbind()",
+  expect_error(
+    quick(fn),
+    "common row count",
+    fixed = TRUE
+  )
+})
+
+test_that("cbind supports symbolic dimension expressions in output shape", {
+  fn <- function(x, A, n, m) {
+    declare(
+      type(n = integer(1)),
+      type(m = integer(1)),
+      type(x = double(n)),
+      type(A = double(n, m))
+    )
+    cbind(x, A)
+  }
+
+  set.seed(99)
+  n <- 3L
+  m <- 2L
+  x <- runif(n)
+  A <- matrix(runif(n * m), nrow = n)
+  expect_bind_equal(fn, list(x, A, n, m))
+})
+
+test_that("cbind requires inferred dimensions to match", {
+  unknown_rows <- function(A, B) {
+    declare(type(A = double(NA, 2)), type(B = double(NA, 1)))
+    cbind(A, B)
+  }
+
+  q_unknown_rows <- NULL
+  expect_error(
+    q_unknown_rows <- quick(unknown_rows),
+    "common row count",
     fixed = TRUE
   )
 
-  x <- c(1.0, 2.0, 3.0)
-  y <- c(-1.0, 0.0, 1.0)
-  qres <- qfn(x, y, 3L, 3L)
-  rres <- fn(x, y, 3L, 3L)
-  expect_identical(dim(qres), dim(rres))
-  expect_identical(typeof(qres), typeof(rres))
-  expect_equal(unname(qres), unname(rres))
+  expect_null(q_unknown_rows)
 })

tests/testthat/test-matrix-inference.R

@@ -135,6 +135,26 @@ test_that("matrix ops infer destination sizes for assignments", {
   expect_quick_equal(chol2inv_infer, list(A = A_pd))
 })
 
+test_that("crossprod requires conformability at compile time", {
+  fn <- function(x, y, n, p, m, k) {
+    declare(
+      type(n = integer(1)),
+      type(p = integer(1)),
+      type(m = integer(1)),
+      type(k = integer(1)),
+      type(x = double(n, m)),
+      type(y = double(p, k))
+    )
+    crossprod(x, y)
+  }
+
+  expect_error(
+    quick(fn),
+    "cannot verify conformability in crossprod",
+    fixed = TRUE
+  )
+})
+
 test_that("matrix helpers report unsupported inputs", {
   matmul_bad_rank <- function(a, b) {
     declare(type(a = double(2, 2, 2)), type(b = double(2, 2)))

tests/testthat/test-matrix-parse.R

@@ -0,0 +1,47 @@
+# Coverage-focused tests for matrix parsing helpers.
+
+test_that("transpose parsing handles scalars and rejects rank > 2", {
+  scalar_left <- function(B) {
+    declare(type(B = double(2, 2)))
+    t(1.25) %*% B
+  }
+
+  expect_error(
+    quick(scalar_left),
+    "non-conformable arguments in %*%",
+    fixed = TRUE
+  )
+
+  rank3_left <- function(x, B) {
+    declare(type(x = double(2, 2, 2)), type(B = double(2, 2)))
+    t(x) %*% B
+  }
+
+  expect_error(
+    quick(rank3_left),
+    "t() only supports rank 0-2 inputs",
+    fixed = TRUE
+  )
+})
+
+test_that("matrix helpers validate logical args", {
+  bad_chol <- function(A) {
+    declare(type(A = double(2, 2)))
+    chol(A, pivot = 1)
+  }
+
+  expect_error(
+    quick(bad_chol),
+    "chol\\(\\) only supports literal pivot = TRUE/FALSE"
+  )
+
+  bad_diag <- function(x) {
+    declare(type(x = double(3)))
+    diag(x, names = 1)
+  }
+
+  expect_error(
+    quick(bad_diag),
+    "diag\\(\\) only supports literal names = TRUE/FALSE"
+  )
+})