help("walkAST").packagesOf() for Globals failed to return the package of the
globals if the global doesn't have a closure, e.g. base::pi
and data.table::.N.[[<- and [<- for Globals, to complement $<-.Globals object guarantee that the
where and the class attributes are always the last two
attributes and in that order.c() for Globals would lose the where environment for any
functions appended.cleanup() assumed it was safe to call env$.packageName on each
scanned environment, but that might not be true. A classed
environment could be such that $() gives an error, rather than
returning something.globalsOf() gained argument locals, which controls whether
globals that exist in "local" environments of a function should be
considered or not, e.g. in f <- local({ a <- 1; function() a }),
should a be considered a global of f() or not. For backward
compatibility reasons, the default is locals = TRUE, but this
might become locals = FALSE in a later release.
Any globals.* options specific to this packages can now be set
via environment variables R_GLOBALS_* when the package is loaded.
For example, R_GLOBALS_DEBUG=true sets option globals.debug = TRUE.
as.Globals(list(a = NULL)) and c(Globals(), list(a = NULL))
would include the calling environment instead of an empty
environment as part of the where attribute.Now findGlobals(function(x) x <- x) identifies x as a global
variable.
Now findGlobals(function(x) x[1] <- 0) identifies x as a global
variable. Same for other variants like x[[1]] <- 0 and x$a <- 0.
Now findGlobals(function(z) x <- z$x) identifies x as a global
variable.
Now findGlobals(quote({ f <- function(x) x; x })) identifies x
as a global variable. Previously, the x of the function would
hide the global x.
globalsOf() could produce "Error in vapply(where, FUN = envname,
FUN.VALUE = NA_character_, USE.NAMES = FALSE) : values must be
length 1, but FUN(X[[2]]) result is length 10". This would happen
if for instance argument envir has attributes set.
findGlobals() works around a bug in stats:::[.formula of R (<
4.1.0) that revealed itself when scanning formulas with NULL
components.
findGlobals() would not pass down argument dotdotdot when
recursively parsing assignments.
findGlobals() could return ... as a global also when used in
formulas. Now it respects argument dotdotdot = "ignore" and
parses formulas accordingly, otherwise formulas will be parsed
using dotdotdot = "return".
findGlobals(expr) now also scans any attributes of expr for
globals, e.g. purrr::partial() puts the original function in
attribute body. Argument attributes controls which attributes,
if any, should be scanned. Default is to scan all attributes.
findGlobals(), globalsOf(), and globalsByName() now
recognizes and returns values for ..1, ..2, etc. like they do
for ....
cleanup() now also drop exported and non-exported
NativeSymbolInfo objects.
cleanup() gained support for dropping NativeSymbolInfo objects.findGlobals() did not pass down argument method in recursive
calls.
findGlobals(expr) would fail to identify globals in anonymous
function calls, e.g. expr <- as.call(list(function(...) NOT_FOUND, quote(FOUND))).
Calls like findGlobals(~ NULL) with NULLs on the right-hand side
could throw "Error in if (length(ans) == 0L ||
as.character(ans[[1L]])[1L] == "~") { : missing value where
TRUE/FALSE needed". Solved by working around what looks like a bug
in the stats package causing subsetting on formulas with NULLs to
fail.
cleanup(..., drop = c(..., "base-packages")) for Globals would
drop base R objects with names not exported by the corresponding
base R package. Similarly, drop = c(..., "primitive") would drop
primitive R objects with names not exported by any base R package.
findGlobals(), globalsOf(), and globalsByName() did not
handle ..1, ..2, etc.
findGlobals() and globalsOf() produces warnings on
'..., ..1, ..2, etc.
findGlobals(function() NULL, substitute = TRUE, trace = TRUE)
would throw "Error in environment(w$enterLocal) : object 'w' not
found".
findGlobals(function() { a; a <- a + 1 }) would fail to identify
a as a global variable whereas it was properly identified with { a <- a + 1; a }.globalsOf() could produce "Error in vapply(where, FUN = envname,
FUN.VALUE = NA_character_, USE.NAMES = FALSE) : values must be
length 1, but FUN(X[[...]]) result is length ...". This was
because the internal envname(env) did not always handle when
class(env) != "environment".findGlobals(), globalsOf(), and packagesOf() no longer
return elements sorted by name.findGlobals() would not identify a as a global in
expressions of type a[1] = ... and names(a) = ... although it
did for a[1] <- ... and names(a) <- ....cleanup() for Globals should now be much faster. Previously,
it could be very slow the first time it was called in a fresh R
session, especially if the user had a large number of packages
installed and/or the package libraries were on slow drives.globals::findGlobals().globals::findGlobals(x), where x is a list, iterated over x
incorrectly assuming no method dispatching on x would take
place. For instance, if x contained an fst::fst_table object,
then "Error in .subset2(x, i, exact = exact) : subscript out of
bounds" would be produced.
globals::findGlobals() could produce a "Warning in is.na(x):
is.na() applied to non-(list or vector) of type 'NULL'" in R (<
3.5.0).
findGlobals() is now significantly faster for elements
that are long lists with many elements of basic data types. This
is because elements of such basic data type cannot contain globals
and can therefore be skipped early in the search for globals.findGlobals() identifies a as a global also when
it is part of LHS expressions of type a[1] <- ... and names(a) <- ....globals::findGlobals() incorrectly identified a as a global in
expression of type a <- pkg::a.
If ... was passed to globalsByName(names), an error would be
produced unless it was the last entry in names.
findGlobals() identifies x as a global variable in
x <- x + 1 and likewise for x + 1 -> x. Note that ditto
using <<- and ->> was already identifying x as a global.findGlobals(..., trace = TRUE) now outputs only to standard
error. Previously, some of the output went to standard output.globalsOf(..., recursive = TRUE) would result in "Error in
match.fun(FUN) : node stack overflow" if one of the globals
identified was a function that called itself recursively (either
directly or indirectly).walkAST() could produce error "Cannot walk expression. Unknown
object type '...'" for objects of type environment.walkAST() could produce error "Cannot walk expression. Unknown
object type '...'" for objects of type list, expression and
S4.Globals that are part of a formula are now identified.
findGlobals(..., trace = TRUE) will now show low-level parse
information as the abstract syntax tree (AST) is walked.
SOFTWARE QUALITY:
walkAST() could produce error "Cannot walk expression. Unknown
object type 'nnn'" for expressions of type builtin, closure
and special.globals.debug, which when TRUE enables debugging output.globalsOf(..., recursive = TRUE) would in some cases scan an
incorrect subset of already identified globals.
globalsOf(..., recursive = TRUE) failed to skip objects part of
package namespaces that where defined via a local() statement.
globalsOf() identifies also globals in locally defined
functions. This can be disabled with argument recursive = FALSE.
findGlobals() now takes both closures (functions) and
expressions.
c(x, list()) where x is a Globals object would give an error
reporting that the list does not have named elements.Globals() and as.Globals() now accepts an empty list as input
as well.walkAST(quote( function(x=NULL) 0 )) would give a sanity check
error due to the NULL argument. Thank you GitHub user 'billy34'
for reporting on this.Added walkAST(), which can be used to tweak expressions.
Added globalsByName() for locating and retrieving a set of known
global variables.
Added c(), $<-(), names(), unique() for Globals objects.
Improved as.Globals() for lists.
globalsOf(..., mustExist = TRUE) when
it fails to locate a global also gives information on the
expression that is problematic.cleanup() for Globals did not cleanup functions in core package
environments named package:<name>.findGlobals() is updated to handle the case where a local
variable is overwriting a global one with the same name, e.g. { a <- b; b <- 1 }. Now b is correctly identified as a global
object. Previously it would have been missed. For backward
compatibility, the previous behavior can be obtained using
argument method = "conservative".globalsOf() now returns attribute where specifying where each
global object is located.cleanup() now only drops objects that are located in one of
the "base" packages; previously it would also drop copies of such
objects, e.g. FUN <- base::sample.globalsOf() failed to return global variables with value NULL.
They were identified but silently dropped.findGlobals() and globalsOf() gained argument dotdotdot.getGlobals() to globalsOf().Added [() for Globals.
findGlobals() and getGlobals() gained argument substitute.
Added cleanup(..., method = "internals").
Added Globals class with methods cleanup() and packagesOf().
Added as.Globals() to coerce lists to Globals objects.
getGlobals() gained argument mustExist for controlling whether
to give an error when the corresponding object for an identified
global cannot be found or to silently drop the missing global.
findGlobals() and getGlobals() gained argument method for
controlling whether a "conservative" or a "liberal" algorithm
for identifying true globals should be used.