Refine iterable coverage

Author: t-kalinowski

R/r2f.R

@@ -822,15 +822,6 @@ seq_like_parse <- function(name, args, scope) {
       from <- seq_call$from
       to <- seq_call$to
       by <- seq_call$by
-      if (is_missing(from)) {
-        from <- NULL
-      }
-      if (is_missing(to)) {
-        to <- NULL
-      }
-      if (is_missing(by)) {
-        by <- NULL
-      }
 
       if (is.null(from) || is.null(to)) {
         stop("seq() requires both `from` and `to`", call. = FALSE)
@@ -2030,8 +2021,7 @@ r2f_for_iterable <- function(iterable, scope, ...) {
       ...,
       context = "for",
       reversed = TRUE
-    ),
-    stop_unsupported(original)
+    )
   )
 }
 

tests/testthat/test-for-iterables.R

@@ -115,6 +115,14 @@ test_that("for() iterable errors are clear", {
     s
   }
 
+  literal_iterable <- function() {
+    s <- 0L
+    for (i in 1L) {
+      s <- s + i
+    }
+    s
+  }
+
   expect_error(
     quick(unsupported_iterable),
     regexp = "unsupported iterable in for\\(\\): rev\\(list\\("
@@ -127,6 +135,10 @@ test_that("for() iterable errors are clear", {
     quick(non_integer_seq_len),
     regexp = "seq_len\\(\\) expects an integer scalar"
   )
+  expect_error(
+    quick(literal_iterable),
+    regexp = "unsupported iterable in for\\(\\): 1"
+  )
 })
 
 test_that("for() supports rev() on index iterables", {
@@ -171,6 +183,35 @@ test_that("for() supports rev() on index iterables", {
   expect_quick_identical(rev_seq_along, numeric(), c(1, 2, 3))
 })
 
+test_that("for() rev(seq()) validates scalar bounds and step", {
+  non_scalar_bounds <- function(x) {
+    declare(type(x = integer(NA)))
+    s <- 0L
+    for (i in rev(seq(1L, x))) {
+      s <- s + i
+    }
+    s
+  }
+
+  non_scalar_step <- function(x) {
+    declare(type(x = integer(NA)))
+    s <- 0L
+    for (i in rev(seq(1L, 5L, by = x))) {
+      s <- s + i
+    }
+    s
+  }
+
+  expect_error(
+    quick(non_scalar_bounds),
+    regexp = "seq\\(\\) iterable bounds must be scalars"
+  )
+  expect_error(
+    quick(non_scalar_step),
+    regexp = "seq\\(\\) iterable step must be a scalar"
+  )
+})
+
 test_that("for() supports iterating over a symbol (value iteration)", {
   sum_values <- function(x) {
     declare(type(x = double(NA)))

tests/testthat/test-internal-utils.R

@@ -117,3 +117,73 @@ test_that("defer schedules cleanup code on exit", {
   f()
   expect_true(isTRUE(e$done))
 })
+
+test_that("iterable helpers cover edge cases", {
+  expect_null(quickr:::r2f_iterable_context(NULL))
+  expect_null(quickr:::r2f_iterable_context(character()))
+  expect_null(quickr:::r2f_iterable_context("seq"))
+  expect_null(quickr:::r2f_iterable_context(c("foo", "seq")))
+  expect_identical(quickr:::r2f_iterable_context(c("[", "seq")), "[")
+  expect_identical(quickr:::r2f_iterable_context(c("for", "seq")), "for")
+
+  var_na <- quickr:::Variable("double", list(NA_integer_))
+  expect_identical(quickr:::value_length_expr(var_na), NA_integer_)
+
+  expect_identical(quickr:::seq_like_length_expr(NULL, 1L), NA_integer_)
+  expect_identical(quickr:::seq_like_length_expr(1L, 1), 1L)
+  expect_error(
+    quickr:::seq_like_length_expr(1L, 2L, 0L),
+    "invalid '\\(to - from\\)/by'"
+  )
+
+  scope <- new.env(parent = emptyenv())
+  expect_error(
+    quickr:::seq_like_parse(
+      "seq",
+      list(from = quote(expr = ), to = 5L),
+      scope
+    ),
+    "seq\\(\\) requires both `from` and `to`"
+  )
+  expect_error(
+    quickr:::seq_like_parse(
+      "seq",
+      list(from = 5L, to = quote(expr = )),
+      scope
+    ),
+    "seq\\(\\) requires both `from` and `to`"
+  )
+  out <- quickr:::seq_like_parse(
+    "seq",
+    list(from = 1L, to = 3L, by = quote(expr = )),
+    scope
+  )
+  expect_null(out$by)
+  expect_error(
+    quickr:::seq_like_parse("banana", list(), scope),
+    "unsupported iterable"
+  )
+
+  expect_false(quickr:::iterable_is_singleton_one(1L, scope))
+  expect_false(quickr:::iterable_is_singleton_one(quote(foo(1L)), scope))
+  expect_false(quickr:::iterable_is_singleton_one(quote(seq(1L)), scope))
+  expect_false(
+    quickr:::iterable_is_singleton_one(quote(seq_along(x)), scope)
+  )
+
+  scope2 <- quickr:::new_scope(function() NULL)
+  expect_error(
+    quickr:::r2f_for_iterable(quote(x), scope2),
+    "unsupported iterable in for\\(\\)"
+  )
+})
+
+test_that("iterable_is_singleton_one handles unknown iterable kinds", {
+  scope <- new.env(parent = emptyenv())
+  local_mocked_bindings(
+    seq_like_parse = function(...) list(kind = "bogus"),
+    .package = "quickr"
+  )
+
+  expect_false(quickr:::iterable_is_singleton_one(quote(seq_len(1L)), scope))
+})

tests/testthat/test-seq.R

@@ -42,6 +42,18 @@ test_that("seq_along returns linear indices for arrays", {
   )
 })
 
+test_that("seq_along requires a value", {
+  bad_seq_along <- function() {
+    out <- seq_along(NULL)
+    out
+  }
+
+  expect_error(
+    quick(bad_seq_along),
+    regexp = "seq_along\\(\\) argument must have a value"
+  )
+})
+
 test_that("seq rejects length.out and along.with", {
   bad_length_out <- function() {
     out <- seq(1L, 5L, length.out = 3L)