Merge branch 'master' into dot-dot-1

Author: MichaelChirico

.ci/linters/r/eval_parse_linter.R

@@ -0,0 +1,8 @@
+eval_parse_linter = make_linter_from_xpath(
+  "//SYMBOL_FUNCTION_CALL[text() = 'parse']
+     /ancestor::expr
+     /preceding-sibling::expr[SYMBOL_FUNCTION_CALL[text() = 'eval']]
+     /parent::expr
+  ",
+  "Avoid eval(parse()); build the language directly, possibly using substitute2()."
+)

.ci/linters/rd/condition_class_docs_check.R

@@ -0,0 +1,51 @@
+# Ensure that data.table condition classes in code match documentation
+condition_classes_documentation_linter = function(rd_file) {
+  if (!grepl("\\name{data.table-condition-classes}", readChar(rd_file, 100L), fixed = TRUE)) return(invisible())
+
+  # Find condition classes in R code 
+  walk_r_ast_for_classes = function(expr) {
+    if (is.call(expr) && is.name(e <- expr[[1L]]) && as.character(e) %in% c("stopf", "warningf", "messagef", "packageStartupMessagef") && is.character(class_arg <- expr[["class"]]) && startsWith(class_arg, "dt_")) {
+      class_arg
+    } else if (is.recursive(expr)) {
+      unlist(lapply(expr, walk_r_ast_for_classes))
+    }
+  }
+
+  # Find condition classes in documentation  
+  walk_rd_ast_for_classes = function(rd_element) {
+    if (!is.list(rd_element)) return(character())
+
+    result = character()
+    if (isTRUE(attr(rd_element, "Rd_tag") == "\\code") && length(rd_element) >= 1L) {
+      content = rd_element[[1L]]
+      if (is.character(content) && startsWith(content, "dt_")) {
+        result = content
+      }
+    }
+    c(result, unlist(lapply(rd_element, walk_rd_ast_for_classes)))
+  }
+
+  code_classes = list.files("R", pattern = "\\.R$", full.names = TRUE) |>
+    lapply(\(f) lapply(parse(f), walk_r_ast_for_classes)) |>
+    unlist() |>
+    unique()
+
+  doc_classes = rd_file |>
+    tools::parse_Rd() |>
+    walk_rd_ast_for_classes() |>
+    unique()
+
+  miss_in_doc = setdiff(code_classes, doc_classes)
+  miss_in_code = setdiff(doc_classes, code_classes)
+
+  if (length(miss_in_doc) > 0L || length(miss_in_code) > 0L) {
+    if (length(miss_in_doc) > 0L) {
+      cat(sprintf("Condition classes in code but missing from docs: %s\n", toString(miss_in_doc)))
+    }
+    if (length(miss_in_code) > 0L) {
+      cat(sprintf("Condition classes in docs but not in code: %s\n", toString(miss_in_code)))
+    }
+    stop("Please sync man/datatable-condition-classes.Rd with code condition classes")
+  }
+}
+

.github/workflows/cran-status-check.yaml

@@ -0,0 +1,66 @@
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 6 * * 1,3,5' # Runs at 06:00 on Mon/Wed/Fri
+
+name: check-cran-status
+
+jobs:
+  fetch-deadlines:
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+    permissions:
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: r-lib/actions/setup-r@v2
+        with:
+          use-public-rspm: true
+
+      - uses: r-lib/actions/setup-r-dependencies@v2
+        with:
+          packages: |
+            gh
+            glue
+
+      - name: Check for existing CRAN issues
+        id: check-issues
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Count open issues with CRAN-related labels
+          ISSUE_COUNT=$(gh issue list --label "cran-deadline" --state open --json number | jq length)
+          if [ $ISSUE_COUNT -eq 0 ]; then
+            echo "should-run=true" >> $GITHUB_OUTPUT
+            echo "✅ Will run CRAN check"
+          else
+            echo "should-run=false" >> $GITHUB_OUTPUT
+            echo "⏭️ Skipping CRAN check - existing issues found"
+          fi
+
+      - name: Fetch deadline for this package
+        if: steps.check-issues.outputs.should-run == 'true'
+        shell: Rscript {0}
+        run: |
+          pkgname <- drop(read.dcf("DESCRIPTION", "Package"))
+
+          deadline <- subset(tools::CRAN_package_db(), Package == pkgname, "Deadline", drop=TRUE)
+
+          if (is.na(deadline)) {
+            quit()
+          }
+
+          gh::gh(
+            "POST /repos/{owner_repo}/issues",
+            owner_repo = Sys.getenv("GITHUB_REPOSITORY"),
+            title = paste("Fix CRAN R CMD check issues by", deadline),
+            body = glue::glue(
+              "This package is failing CRAN checks and is at risk of archival.",
+              "https://cran.r-project.org/web/checks/check_results_{pkgname}.html",
+              "This issue was opened by https://github.com/{Sys.getenv('GITHUB_REPOSITORY')}/actions/runs/{Sys.getenv('GITHUB_RUN_ID')}.",
+              .sep = "\n\n"
+            ),
+            labels = list("cran-deadline")
+          )

NEWS.md

@@ -4,6 +4,10 @@
 
 ## data.table [v1.17.99](https://github.com/Rdatatable/data.table/milestone/35)  (in development)
 
+### NOTICE OF INTENDED FUTURE POTENTIAL BREAKING CHANGES 
+
+1. `data.table(x=1, <expr>)`, where `<expr>` is an expression resulting in a 1-column matrix without column names, will eventually have names `x` and `V2`, not `x` and `V1`, consistent with `data.table(x=1, <expr>)` where `<expr>` results in an atomic vector, for example `data.table(x=1, cbind(1))` and `data.table(x=1, 1)` will both have columns named `x` and `V2`. In this release, the matrix case continues to be named `V1`, but the new behavior can be activated by setting `options(datatable.old.matrix.autoname)` to `FALSE`. See point 5 under Bug Fixes for more context; this change will provide more internal consistency as well as more consistency with `data.frame()`.
+
 ### NEW FEATURES
 
 1. New `sort_by()` method for data.tables, [#6662](https://github.com/Rdatatable/data.table/issues/6662). It uses `forder()` to improve upon the data.frame method and also match `DT[order(...)]` behavior with respect to locale. Thanks @rikivillalba for the suggestion and PR.
@@ -62,7 +66,7 @@
 
 4. In rare cases, `data.table` failed to expand ALTREP columns when assigning a full column by reference. This could result in the target column getting modified unintentionally if the next call to the data.table was a modification by reference of the source column. E.g. in `DT[, b := as.character(a)]` the string conversion gets deferred and subsequent modification of column `a` would also modify column `b`, [#5400](https://github.com/Rdatatable/data.table/issues/5400). Thanks to @aquasync for the report and Václav Tlapák for the PR.
 
-5. `data.table()` function is now more aligned with `data.frame()` with respect to the names of the output when one of its inputs is a single-column matrix object, [#4124](https://github.com/Rdatatable/data.table/issues/4124). Thanks @PavoDive for the report, @jangorecki for the PR, and @MichaelChirico for a follow-up for back-compatibility.
+5. `data.table()` function is now more aligned with `data.frame()` with respect to the names of the output when one of its inputs is a single-column matrix object, [#4124](https://github.com/Rdatatable/data.table/issues/4124), [#3193](https://github.com/Rdatatable/data.table/issues/3193), and [#5367](https://github.com/Rdatatable/data.table/issues/5367). Thanks @PavoDive for the report, @jangorecki for the PR, and @MichaelChirico for a follow-up for back-compatibility.
 
 6. Including an `ITime` object as a named input to `data.frame()` respects the provided name, i.e. `data.frame(a = as.ITime(...))` will have column `a`, [#4673](https://github.com/Rdatatable/data.table/issues/4673). Thanks @shrektan for the report and @MichaelChirico for the fix.
 
@@ -80,7 +84,9 @@
 
 13. Reference to `.SD` in `...` arguments to `lapply()`, e.g. ``lapply(list_of_tables, `[`, j=.SD[1L])`` is evaluated correctly, [#2982](https://github.com/Rdatatable/data.table/issues/2982). Thanks @franknarf1 for the report and @MichaelChirico for the fix.
 
-14. Ellipsis elements like `..1` are correctly excluded when searching for variables in "up-a-level" syntax inside `[`, [#5460](https://github.com/Rdatatable/data.table/issues/5460). Thanks @ggrothendieck for the report and @MichaelChirico for the fix.
+14. Filling columns of class Date with POSIXct (and vice versa) using `shift()` now yields a clear, informative error message specifying the class mismatch, [#5218](https://github.com/Rdatatable/data.table/issues/5218). Thanks @ashbaldry for the report and @ben-schwen for the fix.
+
+15. Ellipsis elements like `..1` are correctly excluded when searching for variables in "up-a-level" syntax inside `[`, [#5460](https://github.com/Rdatatable/data.table/issues/5460). Thanks @ggrothendieck for the report and @MichaelChirico for the fix.
 
 ### NOTES
 
@@ -99,6 +105,9 @@
    + On non-Windows systems, `fread()` now prints the reason why the file couldn't be opened, which could also be due to it being too large to map.
    + With `verbose=TRUE`, file sizes are now printed using correct binary SI prefixes (the sizes have always been reported as bytes denominated in powers of `2^10`, so e.g. `1024*1024` bytes was reported as `1 MB` where `1 MiB` or `1.05 MB` is correct).
 
+4. The default `format_list_item()` method (and hence `print.data.table()`) annotates truncated list items with their length, [#605](https://github.com/Rdatatable/data.table/issues/605). Thanks Matt Dowle for the original report (2012!) and @MichaelChirico for the fix.
+
+5. A GitHub Actions workflow is now in place to warn the entire maintainer team, as well as any contributor following the GitHub repository, when the package is at risk of archival on CRAN [#7008](https://github.com/Rdatatable/data.table/issues/7008). Thanks @tdhock for the original report and @Bisaloo and @TysonStanley for the fix.
 
 # data.table [v1.17.8](https://github.com/Rdatatable/data.table/milestone/41) (6 July 2025)
 

R/as.data.table.R

@@ -50,7 +50,7 @@ as.data.table.matrix = function(x, keep.rownames=FALSE, key=NULL, ...) {
     ans = data.table(rn=rownames(x), x, keep.rownames=FALSE)
     # auto-inferred name 'x' is not back-compatible & inconsistent, #7145
     if (ncol(x) == 1L && is.null(colnames(x)))
-      setnames(ans, 'x', 'V1')
+      setnames(ans, 'x', 'V1', skip_absent=TRUE)
     if (is.character(keep.rownames))
       setnames(ans, 'rn', keep.rownames[1L])
     return(ans)
@@ -162,7 +162,7 @@ as.data.table.list = function(x,
       xi = x[[i]] = as.POSIXct(xi)
     } else if (is.matrix(xi) || is.data.frame(xi)) {
       if (!is.data.table(xi)) {
-        if (is.matrix(xi) && NCOL(xi)<=1L && is.null(colnames(xi))) { # 1 column matrix naming #4124
+        if (is.matrix(xi) && NCOL(xi)==1L && is.null(colnames(xi)) && isFALSE(getOption('datatable.old.matrix.autoname'))) { # 1 column matrix naming #4124
           xi = x[[i]] = c(xi)
         } else {
           xi = x[[i]] = as.data.table(xi, keep.rownames=keep.rownames)  # we will never allow a matrix to be a column; always unpack the columns

R/bmerge.R

@@ -90,7 +90,7 @@ bmerge = function(i, x, icols, xcols, roll, rollends, nomatch, mult, ops, verbos
           next
         }
       }
-      stopf("Incompatible join types: %s (%s) and %s (%s). Factor columns must join to factor or character columns.", xname, x_merge_type, iname, i_merge_type)
+      stopf("Incompatible join types: %s (%s) and %s (%s). Factor columns must join to factor or character columns.", xname, x_merge_type, iname, i_merge_type, class="dt_join_type_mismatch_error")
     }
     if (x_merge_type == i_merge_type) {
       if (verbose) catf("%s has same type (%s) as %s. No coercion needed.\n", iname, x_merge_type, xname)
@@ -106,15 +106,15 @@ bmerge = function(i, x, icols, xcols, roll, rollends, nomatch, mult, ops, verbos
         coerce_col(x, xcol, x_merge_type, i_merge_type, xname, iname, from_detail=gettext(" (all-NA)"), verbose=verbose)
         next
       }
-      stopf("Incompatible join types: %s (%s) and %s (%s)", xname, x_merge_type, iname, i_merge_type)
+      stopf("Incompatible join types: %s (%s) and %s (%s)", xname, x_merge_type, iname, i_merge_type, class="dt_join_type_mismatch_error")
     }
     if (x_merge_type=="integer64" || i_merge_type=="integer64") {
       nm = c(iname, xname)
       if (x_merge_type=="integer64") { w=i; wc=icol; wclass=i_merge_type; } else { w=x; wc=xcol; wclass=x_merge_type; setfrev(nm) }  # w is which to coerce
       if (wclass=="integer" || (wclass=="double" && fitsInInt64(w[[wc]]))) {
         from_detail = if (wclass == "double") gettext(" (which has integer64 representation, e.g. no fractions)") else ""
         coerce_col(w, wc, wclass, "integer64", nm[1L], nm[2L], from_detail, verbose=verbose)
-      } else stopf("Incompatible join types: %s is type integer64 but %s is type double and cannot be coerced to integer64 (e.g. has fractions)", nm[2L], nm[1L])
+      } else stopf("Incompatible join types: %s is type integer64 but %s is type double and cannot be coerced to integer64 (e.g. has fractions)", nm[2L], nm[1L], class="dt_join_type_mismatch_error")
     } else {
       # just integer and double left
       ic_idx = which(icol == icols) # check if on is joined on multiple conditions, #6602

R/data.table.R

@@ -97,34 +97,32 @@ replace_dot_alias = function(e) {
 }
 
 .checkTypos = function(err, ref) {
+  err_str <- conditionMessage(err)
   # a slightly wonky workaround so that this still works in non-English sessions, #4989
   # generate this at run time (as opposed to e.g. onAttach) since session language is
   #   technically OK to update (though this should be rare), and since it's low-cost
   #   to do so here because we're about to error anyway.
-  missing_obj_fmt = gsub(
-    "'missing_datatable_variable____'",
+  missing_obj_regex = gsub(
+    "'____missing_datatable_variable____'",
     "'(?<obj_name>[^']+)'",
-    tryCatch(eval(parse(text="missing_datatable_variable____")), error=identity)$message
-    # eval(parse()) to avoid "no visible binding for global variable" note from R CMD check
-    # names starting with _ don't parse, so no leading _ in the name
+    # expression() to avoid "no visible binding for global variable" note from R CMD check
+    conditionMessage(tryCatch(eval(quote(`____missing_datatable_variable____`)), error=identity)),
+    fixed=TRUE
   )
-  idx = regexpr(missing_obj_fmt, err$message, perl=TRUE)
-  if (idx > 0L) {
-    start = attr(idx, "capture.start", exact=TRUE)[ , "obj_name"]
-    used = substr(
-      err$message,
-      start,
-      start + attr(idx, "capture.length", exact=TRUE)[ , "obj_name"] - 1L
-    )
-    found = agrep(used, ref, value=TRUE, ignore.case=TRUE, fixed=TRUE)
-    if (length(found)) {
-      stopf("Object '%s' not found. Perhaps you intended %s", used, brackify(found))
-    } else {
-      stopf("Object '%s' not found amongst %s", used, brackify(ref))
-    }
+  idx = regexpr(missing_obj_regex, err_str, perl=TRUE)
+  if (idx == -1L)
+    stopf("%s", err_str, domain=NA) # Don't use stopf() directly, since err_str might have '%', #6588
+  start = attr(idx, "capture.start", exact=TRUE)[ , "obj_name"]
+  used = substr(
+    err_str,
+    start,
+    start + attr(idx, "capture.length", exact=TRUE)[ , "obj_name"] - 1L
+  )
+  found = agrep(used, ref, value=TRUE, ignore.case=TRUE, fixed=TRUE)
+  if (length(found)) {
+    stopf("Object '%s' not found. Perhaps you intended %s", used, brackify(found))
   } else {
-    # Don't use stopf() directly, since err$message might have '%', #6588
-    stopf("%s", err$message, domain=NA)
+    stopf("Object '%s' not found amongst %s", used, brackify(ref))
   }
 }
 

R/groupingsets.R

@@ -4,7 +4,7 @@ rollup = function(x, ...) {
 rollup.data.table = function(x, j, by, .SDcols, id = FALSE, label = NULL, ...) {
   # input data type basic validation
   if (!is.data.table(x))
-    stopf("Argument 'x' must be a data.table object")
+    stopf("Argument 'x' must be a data.table object", class="dt_invalid_input_error")
   if (!is.character(by))
     stopf("Argument 'by' must be a character vector of column names used in grouping.")
   if (!is.logical(id))
@@ -22,7 +22,7 @@ cube = function(x, ...) {
 cube.data.table = function(x, j, by, .SDcols, id = FALSE, label = NULL, ...) {
   # input data type basic validation
   if (!is.data.table(x))
-    stopf("Argument 'x' must be a data.table object")
+    stopf("Argument 'x' must be a data.table object", class="dt_invalid_input_error")
   if (!is.character(by))
     stopf("Argument 'by' must be a character vector of column names used in grouping.")
   if (!is.logical(id))

R/merge.R

@@ -34,7 +34,7 @@ merge.data.table = function(x, y, by = NULL, by.x = NULL, by.y = NULL, all = FAL
     warningf("Supplied both `by` and `by.x`/`by.y`. `by` argument will be ignored.")
   if (!is.null(by.x)) {
     if (length(by.x) == 0L || !is.character(by.x) || !is.character(by.y))
-      stopf("A non-empty vector of column names is required for `by.x` and `by.y`.")
+      stopf("A non-empty vector of column names is required for `by.x` and `by.y`.", class="dt_invalid_input_error")
     if (!all(idx <- by.x %chin% nm_x)) {
       stopf("The following columns listed in `%s` are missing from %s: %s", "by.x", "x", brackify(by.x[!idx]))
     }

R/onLoad.R

@@ -73,28 +73,29 @@
   # In fread and fwrite we have moved back to using getOption's default argument since it is unlikely fread and fread will be called in a loop many times, plus they
   # are relatively heavy functions where the overhead in getOption() would not be noticed.  It's only really [.data.table where getOption default bit.
   # Improvement to base::getOption() now submitted (100x; 5s down to 0.05s):  https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17394
-  opts = c("datatable.verbose"="FALSE",        # datatable.<argument name>
-       "datatable.optimize"="Inf",             # datatable.<argument name>
-       "datatable.print.nrows"="100L",         # datatable.<argument name>
-       "datatable.print.topn"="5L",            # datatable.<argument name>
-       "datatable.print.class"="TRUE",         # for print.data.table
-       "datatable.print.rownames"="TRUE",      # for print.data.table
-       "datatable.print.colnames"="'auto'",    # for print.data.table
-       "datatable.print.keys"="TRUE",          # for print.data.table
-       "datatable.print.trunc.cols"="FALSE",   # for print.data.table
-       "datatable.show.indices"="FALSE",       # for print.data.table
-       "datatable.allow.cartesian"="FALSE",    # datatable.<argument name>
-       "datatable.join.many"="TRUE",           # mergelist, [.data.table #4383 #914
-       "datatable.dfdispatchwarn"="TRUE",                   # not a function argument
-       "datatable.warnredundantby"="TRUE",                  # not a function argument
-       "datatable.alloccol"="1024L",           # argument 'n' of alloc.col. Over-allocate 1024 spare column slots
-       "datatable.auto.index"="TRUE",          # DT[col=="val"] to auto add index so 2nd time faster
-       "datatable.use.index"="TRUE",           # global switch to address #1422
-       "datatable.prettyprint.char" = NULL     # FR #1091
-       )
-  for (i in setdiff(names(opts),names(options()))) {
-    eval(parse(text=paste0("options(",i,"=",opts[i],")")))
-  }
+  opts = list(
+    datatable.verbose=FALSE,            # datatable.<argument name>
+    datatable.optimize=Inf,             # datatable.<argument name>
+    datatable.print.nrows=100L,         # datatable.<argument name>
+    datatable.print.topn=5L,            # datatable.<argument name>
+    datatable.print.class=TRUE,         # for print.data.table
+    datatable.print.rownames=TRUE,      # for print.data.table
+    datatable.print.colnames='auto',    # for print.data.table
+    datatable.print.keys=TRUE,          # for print.data.table
+    datatable.print.trunc.cols=FALSE,   # for print.data.table
+    datatable.show.indices=FALSE,       # for print.data.table
+    datatable.allow.cartesian=FALSE,    # datatable.<argument name>
+    datatable.join.many=TRUE,           # mergelist, [.data.table #4383 #914
+    datatable.dfdispatchwarn=TRUE,      # not a function argument
+    datatable.warnredundantby=TRUE,     # not a function argument
+    datatable.alloccol=1024L,           # argument 'n' of alloc.col. Over-allocate 1024 spare column slots
+    datatable.auto.index=TRUE,          # DT[col=="val"] to auto add index so 2nd time faster
+    datatable.use.index=TRUE,           # global switch to address #1422
+    datatable.prettyprint.char=NULL,    # FR #1091
+    datatable.old.matrix.autoname=TRUE  # #7145: how data.table(x=1, matrix(1)) is auto-named set to change
+  )
+  opts = opts[!names(opts) %chin% names(options())]
+  options(opts)
 
   # Test R behaviour that changed in v3.1 and is now depended on
   x = 1L:3L