Capabilities

All categories

Names and Identifiers

21 fully8 partially1 not

Every name an R program writes down, the Form it is written in, and the binding it resolves to.

Consider the following R code:

"f" <- function(x) { get("x") } 
`y x` <- 2
print(`y x` + f(3))

Identifiers of interest are:

• The symbols x (Normal), f (Quoted), and `y x` (Escaped).
• The function calls <-, function, {, get, +, and print (Calls, all given with Normal). Especially { is identified as a Grouping of the Function Definitions' body.
• The quoted name created by a function call get (Created).

Besides the parameter x, which is resolved in its Lexicographic Scope, the other identifiers are resolved in the Global Scope.

flowchart LR
    10["`**function** (L. 1)
*RFunctionDefinition*`"]

subgraph "flow-10" ["function(x) #123; get(#34;x#34;) #125; (L. 1)"]
    1["`**x** (L. 1)
*RSymbol*`"]
    8-get-name(["`**#34;x#34;** (L. 1)
*RSymbol*`"])
    8[["`base#58;#58;**get** (L. 1)
*RFunctionCall*`"]]
    built-in:get["`Built-In:
get`"]
    style built-in:get stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    9[["`base#58;#58;**#123;**
*RExpressionList*`"]]
    built-in:_123_["`Built-In:
#123;`"]
    style built-in:_123_ stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
end
    0["`**#34;f#34;** (L. 1)
*RString*`"]
    11[["`base#58;#58;**#60;#45;** (L. 1)
*RBinaryOp*`"]]
    built-in:_60_-["`Built-In:
#60;#45;`"]
    style built-in:_60_- stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    13{{"`**2** (L. 2)
*RNumber*`"}}
    12["`**#96;y x#96;** (L. 2)
*RSymbol*`"]
    14[["`base#58;#58;**#60;#45;** (L. 2)
*RBinaryOp*`"]]
    16(["`**#96;y x#96;** (L. 3)
*RSymbol*`"])
    18{{"`**3** (L. 3)
*RNumber*`"}}
    20[["`**f** (L. 3)
*RFunctionCall*`"]]
    21[["`base#58;#58;**#43;** (L. 3)
*RBinaryOp*`"]]
    built-in:_43_["`Built-In:
#43;`"]
    style built-in:_43_ stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    23[["`base#58;#58;**print** (L. 3)
*RFunctionCall*`"]]
    style 23 stroke:red,stroke-width:5px; 
    built-in:print["`Built-In:
print`"]
    style built-in:print stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    1 -->|"def-by-on-call"| 18
    8-get-name -->|"reads"| 1
    8 -->|"reads, returns, arg"| 8-get-name
    8 -.->|"reads, calls"| built-in:get
    linkStyle 3 stroke:gray;
    9 -->|"returns, arg"| 8
    9 -.->|"reads, calls"| built-in:_123_
    linkStyle 5 stroke:gray;
10 -.-|function| flow-10

    0 -->|"defined-by, flow"| 11
    0 -->|"defined-by"| 10
    11 -->|"reads, arg"| 10
    11 -->|"returns, arg"| 0
    11 -.->|"reads, calls"| built-in:_60_-
    linkStyle 11 stroke:gray;
    12 -->|"defined-by, flow"| 14
    12 -->|"defined-by"| 13
    14 -->|"reads, arg"| 13
    14 -->|"returns, arg"| 12
    14 -.->|"reads, calls"| built-in:_60_-
    linkStyle 16 stroke:gray;
    16 -->|"reads"| 12
    18 -->|"def-on-call"| 1
    20 -->|"reads, arg"| 18
    20 -->|"reads"| 0
    20 -->|"returns"| 8
    20 -->|"calls"| 10
    21 -->|"reads, arg"| 16
    21 -->|"reads, arg"| 20
    21 -.->|"reads, calls"| built-in:_43_
    linkStyle 25 stroke:gray;
    23 -->|"reads, returns, arg"| 21
    23 -.->|"reads, calls"| built-in:print
    linkStyle 27 stroke:gray;

"f" <- function(x) { get("x") } 
`y x` <- 2
print(`y x` + f(3))

• #Form

  A name is written plainly, as a string, in backticks, or as the argument of a call that reads it as one.

  5 children500

  • #Normal1342 tests587 slice, 371 dataflow, 162 output and 4 more

    signature tests

    function from generated load is callable, load defines variables from generated rda, load overwrites existing closure variable

    A name written as R's grammar allows it, like a or plot. Every other form ends up as one of these, and a lookup links it to the definitions that may reach it.

    Advanced RBindingsR DefinitionIdentifiers

  • #Quoted24 tests21 slice, 7 output, 3 desugar

    signature tests

    With Quotes and Namespace, assign of a backticked string defines that literal name, assign of a backticked string does not define the symbol

    A name given as a string, like "a" or 'plot'. Such a name may hold spaces, but R accepts the quotes only where it is defined, so reading it back needs backticks or a name-creating call.

    Advanced RNon-Syntactic Names

    example

    "my fn" <- function(x) x
    `my fn`(3)
    get("my fn")(3)

  • #Escaped24 tests16 slice, 8 dataflow, 2 output and 1 more

    signature tests

    non-ASCII escaped names survive, get of a name with a space, get of a backtick-defined name

    A name escaped in backticks, like `a` or `my var`. It binds and resolves like a normal name, the syntax only lifts the grammar's restriction on the characters it may hold.

    Advanced RNon-Syntactic Names

    example

    `my var` <- 1
    `my var` + 1

  • #Created314 tests83 slice, 81 output, 18 dataflow

    signature tests

    evalq into parent.frame, match.fun of get of a parameter, get0 of a parameter into a local

    A call that reads a string argument as the name it spells, such as get, get0, mget, exists, match.fun, and assign. The string counts as a use of that name, or for assign as a definition. The string may also reach the call through variables and the parameters of the functions it is in (f <- function(n) get(n)(); f("h")), and the value of such a lookup is what it finds for the call it runs in, so f("a"); f("b") tells both apart. Without an environment, the name is looked up in the frame of the function and those of the functions it is defined in, then in the global names at the call. A name only known at runtime (get(Sys.getenv("V"))) is not linked.

    R DefinitionIdentifiers

    example

    x <- 1
    r <- get("x")
    print(r)

  • #Resolved Name791 tests237 slice, 214 output, 20 dataflow

    signature tests

    get resolves x from custom env and e is read, get without envir resolves from global scope, get takes envir as its third formal, after pos

    A created name whose string argument is not a literal but folds to one. Covers string literals, variables holding one, and paste0/paste/file.path over constants, each followed like a written-out name.

    R DefinitionIdentifiers

    example

    nm <- paste0("x", 1)
    assign(nm, 42)
    get(nm)

• #Resolution29 tests28 call-graph, 1 dataflow

  signature tests

  unresolved get is reached-but-unknown, not dropped, call graph with scoped, unknown, alias, call graph with scoped alias

  Which definitions a name may reach, through the scopes around it, the environments a program builds, and the packages below them.

  25 children1681

  • #Global Scope23 tests12 slice, 6 output, 1 dataflow

    signature tests

    a maybe definition in a function does not hide the global one it may ..., falls back to the global frame, a stand-in frame that held nothing passes the write on

    Resolve a name against the bindings of the global environment, whenever no enclosing function definition binds it. Every top-level definition that may still be active is linked, so a use after an if reaches both branches' definitions.

    R DefinitionGlobal environment

    example

    x <- 1
    f <- function() x
    f()

  • #Lexicographic Scope344 tests115 slice, 101 output, 11 dataflow

    signature tests

    Double Base in Base CTX, Double Base with existing env, Access base even if overwritten

    Resolve a name to the innermost enclosing definition, and only to the global scope when no enclosing one binds it. Where a function is written decides what its body sees, not where it is called.

    R DefinitionLexical environmentAdvanced RLexical scoping

    example

    f <- function() {
      y <- 1
      g <- function() y
      g()
    }
    f()

  • #Closures1702 tests509 slice, 489 output, 67 dataflow

    signature tests

    three nested returned functions, sibling closures sharing a frame, a lazy parameter captured unforced

    Two closures from the same factory keep independent state in R, as every call of the factory makes an environment of its own. We keep one environment per definition instead, so a <<- in one closure is read as reaching the binding the other captured.

    Advanced RFunction factoriesR DefinitionScope of variables

    example

    counter <- function() {
      i <- 0
      function() {
        i <<- i + 1
        i
      }
    }
    c1 <- counter()
    c2 <- counter()
    c1()
    c1()
    r <- c2()
    print(r)

  • #Closure Capture16 tests8 output, 8 slice

    signature tests

    a sibling closure sees a write made through <<-

    A function captures the environment it was defined in, not the values that were in it. So it sees a write made to that environment after its definition, a sibling closure's <<- included. A closure a function returns without calling it reads its free variables where it is called, so the call making it does not read them.

    Advanced RFunction factoriesR DefinitionScope of variables

    example

    make <- function() {
      x <- 1
      list(get = function() x, set = function(v) x <<- v)
    }
    o <- make()
    o$set(5)
    r <- o$get()
    print(r)

  • #Dynamic Environment Resolution198 tests79 dataflow, 75 slice, 21 output

    signature tests

    new.env() call carries NewEnv origin, assign to .GlobalEnv falls through to global, assign with a numeric pos stays in the current scope

    An environment a program builds and names itself, rather than one a definition opens. Covers new.env, assign/get/local with envir=, e$x, attach, with, and aliasing such an environment through a variable. A write from within a function reaches the environment it names, a read of the whole environment (as.list(e)) sees every field written, and copies of an environment variable (g <- e) share its fields.

    R DefinitionEnvironment objects

    example

    e <- new.env()
    assign("x", 3, envir = e)
    get("x", envir = e) + e$x
    f <- function() e$y <- 4
    f()
    g <- e
    g$z <- 5
    as.list(e)

    8 children440

    • #Environment in Control Flow10 tests9 dataflow, 1 slice

      signature tests

      for-loop populates env with dynamic keys: e read in body and after loop, parallel accumulation in two envs inside for-loop: reads isolated per..., assign in while-loop to custom env: e read in body, val not in global...

      Track environment assignments and reads across branches and loop bodies, a key built at run time such as paste0("k", i) included.

    • #Environment Parent92 tests26 slice, 25 output, 5 dataflow

      signature tests

      new.env(parent=NULL): same as emptyenv(), assign does not leak, new.env(parent=e) with tracked parent env: child reads from parent vi..., rlang::new_environment(parent=emptyenv()): isolated env, assign does ...

      Specifying a parent for a newly-created environment from a dynamic or unknown expression (new.env(parent = f())). Such a parent falls back to the default (parent.frame()) instead of resolving.

      Advanced RParents

    • #Environment Parent (Tracked)1 test1 slice

      signature tests

      slice through child env with emptyenv parent: includes assign and new...

      Specifying a parent for a newly-created environment from a tracked environment variable or a constant (new.env(parent = e), new.env(parent = emptyenv())).

      Advanced RParents

    • #Environment Alias8 tests7 dataflow, 1 slice

      signature tests

      environment(f) is not the current env, alias of alias: double indirection still resolves x, alias does not see assigns made to original env AFTER alias was created

      Aliasing a tracked environment variable (alias <- e), which binds a second name to the same environment rather than a copy. A write to the original made after the alias is not reflected through it, unlike a read.

    • #Environment Alias Read2 tests2 slice

      signature tests

      slice from with via alias: traces assign, alias assignment, and new.env, slice through alias: get via alias traces back through assign and new...

      Reading through an aliased tracked environment variable (alias <- e). Every assign made up to the alias is visible through it.

    • #With77 tests28 slice, 21 output, 5 dataflow

      signature tests

      with(e, x): x resolves from envState, e is read, with untracked env falls through to default handling, with via alias: with(alias, x) resolves x from alias envState

      Evaluating an expression inside a named environment with with(data, expr). Reads of names the tracked env defines resolve, including through a computed data argument or a nested call.

    • #Parent Frame153 tests45 output, 45 slice

      signature tests

      eval.parent assigns in the caller, parent.frame()$x reads the caller's variable

      Reading via parent.frame()$name, and a write escaping through eval.parent(quote(name <- value)). Works only one call away, and storing the frame first drops the binding.

      Advanced RCall stacks

    • #Dynamic Variable Removal95 tests24 output, 23 slice, 21 dataflow

      signature tests

      rm(list=ls()) clears the whole environment, a shadowed ls does not clear the environment, a conditional rm only maybe removes the variable

      Support for rm(list=..., envir=sys.frame(N)) removing variables from a specific call frame. Negative and zero offsets are handled from within depth-1 functions. A removal from the global environment inside a function, with envir = .GlobalEnv, envir = globalenv(), or pos = 1, is seen by the callers, like a <<- would be. A removal from the environment of a closure, rm("v", envir = environment(g)), is seen by the calls of that closure, which then read what the environments around it bind.

  • #Environment Sharing1125 tests324 slice, 298 output, 63 dataflow

    signature tests

    local keeps its definitions, local returns its last value, sys.function frames with local

    Handling side-effects through environments, which act as reference types and are not copied when modified. A write through a parameter (env$f <- v, assign("f", v, envir = env)) is replayed at each call that hands over a known environment, a list is copied by R so its write stays in the function, and any other value keeps the write as an unknown side effect of the call (see Environment Alias and Side-Effects in Function Call). A call that only writes into the environment it hands over reads nothing of it, so storing a function there does not call what an earlier call stored. The value of a field (e$x, e[["x"]]) is what the environment binds it to, as long as nothing but tracked lookups, writes, and functions of the program get the environment; a read in a loop, a write into part of a field, and anything unknown writing leave it unknown.

    R DefinitionEnvironment objectsAdvanced REnvironments

    example

    e <- new.env()
    assign("x", 42, envir = e)
    print(get("x", envir = e))

  • #Search Type169 tests50 slice, 49 output

    signature tests

    exists of a name never bound, exists depends on the binding it asks about, Locally without distracting elements

    Resolve a name in call position only against function definitions, a name in value position against every binding. This is why the c <- 1 below does not shadow the call to c.

    Advanced RFunctions versus variables

    example

    c <- 1
    c(c, 2)

  • #Search Path3237 tests885 slice, 876 output, 166 dataflow

    signature tests

    link with string value, .env reaches past the data mask, Several methods of same library

    Resolve a name against the packages the search path holds, whenever no scope in the script binds it. Attached packages sit below .GlobalEnv, so a global binding shadows an export.

    R DefinitionSearch pathAdvanced RSearch path

    example

    library(dplyr)
    filter <- function(...) "mine"
    filter(1)

  • #Dynamic Search Path8 tests7 slice, 1 dataflow

    signature tests

    search() reads the library() before it, search reads an unloaded namespace, exists sees the detach of a package

    Programmatically inspecting or mutating the search path with search(), searchpaths(), or detaching by position. search() and searchpaths() read every library, attach, and detach before them, and detach/unloadNamespace remove the entry they name, but search() itself is not computed as a value.

    R DefinitionSearch path

    example

    library(stats)
    n <- search()
    print(n[2])

  • #Namespaces10 tests9 dataflow, 1 slice

    signature tests

    Double Base in Base CTX, Double Base with existing env, Access base even if overwritten

    Separate what a package's namespace holds from what attaching it puts on the search path. The imports environment a package carries for itself is not modelled.

    Advanced RNamespaces

  • #Accessing Exported Names7 tests3 desugar, 3 slice, 1 query

    signature tests

    With Quotes and Namespace, must link alias with namespace, Must link alias but not namespace origin

    Resolve a name written pkg::name to the export it names, no matter what the script binds. This depends on what the signature database knows, and an unresolved name stays unresolved rather than reported.

    Advanced RNamespaces

    example

    median <- function(x) 0
    median(1:3)
    stats::median(1:3)

  • #Accessing Internal Names1 test1 query

    Resolve a name written pkg:::name, which reaches what the namespace keeps to itself. Whether the name is genuinely internal rather than exported is not checked (see Namespace Exports).

    Advanced RNamespaces

    example

    "C_cor" %in% getNamespaceExports("stats")
    stats:::C_cor$name

  • #Namespace Exports1 test1 query

    signature tests

    an exported name accessed with ::: resolves the same, unflagged

    Know which names a package's namespace declares exported versus keeps internal. The namespace-access rule checks a ::/::: choice against what the signature database records, which omits most internal names to stay small.

    Writing R ExtensionsPackage namespaces

    example

    stats::median(1:3)
    stats:::C_cor

  • #Library Loading3028 tests837 slice, 817 output, 166 dataflow

    signature tests

    the core set follows the version, asking leaves the project untouched, oldest still respects the lower bound

    Attach a package named by library, require, attachNamespace, ... to the search path. From that point on an unbound name may resolve to one of its exports, while a binding in the script still shadows it.

    R DefinitionSearch pathAdvanced RSearch path

    example

    library(stats)
    require(utils)
    attachNamespace("tools")

  • #Library Unloading87 tests25 output, 25 slice, 1 dataflow

    signature tests

    detach undoes the attach, so a later call no longer resolves through ..., detaching another package keeps the tools export

    Undo a library attach with detach, unloadNamespace, ... Neither is modelled, so a name used after detach still resolves to the package's export.

    R DefinitionSearch path

    example

    library(stats)
    median(1:3)
    detach("package:stats")
    median(1:3)

  • #Dynamic Scope Changes1 test1 dataflow

    signature tests

    reads within local expression

    Open a scope of its own with a plain local block. A name it binds is invisible outside, while a super assignment from within reaches the enclosing scope.

    x <- 1
    local({
      x <- 2
      x
    })
    x

  • #Local with Explicit Environment214 tests77 slice, 61 output, 3 dataflow

    signature tests

    local(x <- 2, envir = .GlobalEnv) writes into the real global scope, local(x <- 2, envir = globalenv()) writes into the real global scope, local takes envir as its second formal, positionally

    Send local's body to a specific environment. Its writes land in that environment, also inside a function that binds the same name itself.

    `local`

    example

    e <- new.env()
    local(y <- 2, envir = e)
    get("y", envir = e)

  • #Anonymous Bindings2 tests2 call-graph, 1 dataflow

    signature tests

    Recursion with Recall, fibonacci with recall

    Resolve a call that does not name the function it runs, as Recall does. It is linked to the enclosing function definition, the same way a call through the function's own name is.

    fact <- function(n) if(n <= 1) 1 else n * Recall(n - 1)
    fact(5)

  show 10 more

All categories

Expressions

52 fully22 partially1 not

The calls, Operators, control flow, and function definitions an R program is built from.

• #Calls929 tests486 dataflow, 464 slice, 103 output and 3 more

  signature tests

  higher-order sum origin, a plot after the call, a loop body still calls

  Everything that is a call in R, from f(x) over an operator to a group, with the arguments it binds and the side effects it may have.

  16 children1150

  • #Grouping229 tests74 slice, 61 output, 33 desugar and 1 more

    signature tests

    using loop variable in for-body, the value of an assignment is used, an anonymous function called at once

    Read ( and { as the calls they are, mapped to their primitive implementations. A group hands on the value of its last expression, so x <- { 1; 2 } binds x to 2, and redefining `{` replaces that meaning.

    R DefinitionGrouping

    example

    x <- {
      1
      2
    }
    y <- (3)

  • #Normal Call480 tests437 slice, 123 output, 27 dataflow and 2 more

    signature tests

    Call edges for error with fn, switch arms do not see each other, a bound variable names its definition

    Link a call like f(x) or foo::bar(x, y) to the definitions its name may resolve to, and its arguments to the formals they bind. Every definition that may be active is linked, which over-approximates rather than picking one.

    R DefinitionFunction calls

    7 children520

    • #Unnamed Arguments506 tests310 slice, 126 output, 59 dataflow and 1 more

      signature tests

      load without any file argument is unknown side effect, an arbitrary call does not expose the definitions of its arguments, load with only envir argument is unknown side effect

      An argument given without a name, like f(3), which binds to a formal by position. It is matched after every named argument has taken its formal.

      R DefinitionArguments

    • #Empty Arguments99 tests29 slice, 27 output, 2 dataflow and 1 more

      signature tests

      switch falls through an empty case, Not giving first parameter, get in function

      An argument left out entirely, as the second one in foo::bar(3, ,42). It still takes a position, which is what makes m[1, ] an index access on one dimension.

      R DefinitionArguments

      example

      m <- matrix(1:6, nrow = 2)
      m[1, ]
      m[, 2]

    • #Named Arguments1981 tests683 slice, 539 output, 15 dataflow and 3 more

      signature tests

      dispatch on an opaque object is reached-but-unknown, not dropped, Not giving first argument, arguments by name in another order

      An argument given with a name, like f(x = 3), which binds to the formal of that name. Inside a call = names an argument rather than binding a name.

      R DefinitionArgument matching

    • #String Arguments2 tests2 desugar

      signature tests

      a, a b(1)

      An argument whose name is written as a string, like f('x' = 3). It binds the same formal a named argument would, the way a quoted name binds an ordinary one.

    • #Resolve Arguments129 tests69 dataflow, 30 call-graph, 30 slice and 1 more

      signature tests

      unresolved do.call target is reached-but-unknown, not dropped, a loop body may not run, a while body may not run

      Match every argument of a call to the formal it binds, exact names first, then unique prefixes (pmatch), then position. A formal behind ... matches only exactly, and an ambiguous prefix binds nothing.

      R DefinitionArgument matching

      example

      f <- function(verbose = FALSE, value = 0) c(verbose, value)
      f(TRUE, val = 3)
      f(verb = TRUE)

    • #Side-Effects in Argument631 tests194 slice, 193 output, 1 dataflow

      signature tests

      an assignment inside an argument defines its name, sapply over a closure that super-assigns, lapply over a closure that super-assigns

      An argument that binds a name while it is evaluated, as f(x <- 3) does. Whether the argument is ever forced is not modelled (see promises), so f <- function(a) 1; f(x <- 3) still believes x is 3. A call in the argument depends on the call it is handed to, so g(FALSE, f(4)) keeps g.

      R DefinitionArgument evaluation

      example

      f <- function(a) a
      f(x <- 3)
      x
      g <- function(a, b) if(a) b else 0
      g(FALSE, print("never"))

    • #Side-Effects in Function Call150 tests141 slice, 118 dataflow, 24 output

      signature tests

      a plot after the call, a nested call defined later, a closure handed down twice

      A call that binds a name outside itself, as setXTo(3) does with a super assignment. Such a write reaches the caller through several call levels, but one through a shared environment is missed.

      Advanced RSuper assignment

      example

      set_x <- function(v) x <<- v
      set_x(3)
      x

  • #Recursion306 tests84 slice, 83 output, 7 dataflow and 1 more

    signature tests

    a side effect in mutual recursion, an option set in a recursive function, A recursive helper keeps all its calls

    A call to f inside the definition of f. The name resolves to the definition it sits in, so the call links back to it rather than staying unresolved.

    fib <- function(n) if(n < 2) n else fib(n - 1) + fib(n - 2)
    fib(10)

  • #Anonymous Calls875 tests268 slice, 263 output, 4 dataflow and 1 more

    signature tests

    Call edges for error, Calling with a constant function, vapply checks the type of each result

    A call whose target is an expression rather than a name, like (function(x) x)(3) or factory(0)(). It links to the definition that expression yields, without a name being involved.

    Advanced RFirst-class functions

    example

    (function(x) x + 1)(3)
    factory <- function() function() 42
    factory()()

  • #Higher-Order Functions84 tests84 dataflow

    signature tests

    purrr map with a closure, a purrr map2 with a closure, do.call reaches the function

    A function handled as a value: handed to another function, like the callback of lapply, Reduce, or purrr::map, or picked at runtime with switch, match.fun, or do.call. A function value is followed through the dataflow wherever it goes, also as a string that names it, so the call that runs it is linked to its definition and sees its reads and side effects. Reduce hands its running result to the callback and returns what the callback returns. A function whose name is only known at runtime, like get(paste0("f", i)), is not linked.

    Advanced RFunctionals

    example

    k <- 2
    add <- function(a, b) a + b * k
    Reduce(add, 1:3)

  • #Infix Calls550 tests314 slice, 201 dataflow, 85 output and 1 more

    signature tests

    Call with hell and dots, chained bracket access with variables, sibling parameter default sees later body reassignment

    An operator written between its arguments, like x + y or x %>% f(y). It is the same call as `+`(x, y), which is why redefining the operator changes what it does.

    R DefinitionInfix and prefix operators

    example

    identical(1 + 2, `+`(1, 2))

  • #Redefinition of Built-In Functions/primitives110 tests36 slice, 23 dataflow, 23 output

    signature tests

    the global variable stays, with reading the environment, assign into an unknown environment

    A name that R defines being bound in the program, as in print <- function(x) x or `for` <- function(a,b,c) a. The redefinition wins wherever the built-in would have been used, respecting scope and order. Only ::/::: are exempt.

    R DefinitionBuiltin objects and special forms

    example

    `+` <- function(a, b) a * b
    2 + 3

  • #Functions with global side effects1828 tests651 slice, 460 output, 80 dataflow

    signature tests

    Linking points to last plot, an option set through do.call, an option set three calls deep

    A call that changes state the rest of the program reads without naming it, as setwd changes where a path points. The working directory, the options, and the graphics state are tracked, so a read links to the calls that set what it reads. Other ambient state, like environment variables or the random seed, stays an unknown side effect. A call inside a function that acts on the global environment, like source, library, or rm(envir = .GlobalEnv), affects the callers of that function as well.

    setwd("/tmp")
    read.csv("data.csv")

  • #Working Directory1067 tests301 output, 301 slice, 15 dataflow and 1 more

    signature tests

    setwd after point, called function propagates, getwd reads what setwd set

    Track the effective working directory across setwd, control-flow- and location-sensitive. Interprocedural, sourced, and loop cases are treated as unbounded.

  show 1 more
• #Index Access

  The bracket, double-bracket, dollar, and slot forms for picking an element out of a container, with names, empty positions, and multiple indices.

  7 children700

  • #Single Bracket Access707 tests216 slice, 205 output, 13 dataflow and 1 more

    signature tests

    a data.table subscript reads the caller`s variables, a negative index drops an element, an index replacement keeps the rest of the vector

    The [ call, as in x[i], x[i, ,b], or x[3][y]. The container is read as a whole without separating the cell an index picks, and writing through it is a replacement call.

    R DefinitionIndexingAdvanced RSelecting multiple elements

    example

    l <- list(a = 1, b = 2)
    l["a"]
    l[c("a", "b")]

  • #Double Bracket Access690 tests215 slice, 180 output, 44 dataflow and 1 more

    signature tests

    value of a vector given names, value of a nested list element, value of a missing list element

    The [[ call, as in x[[i]] or x[[i, b]]. Read like single-bracket access by the dataflow. The value solver picks the element a constant name (matched exactly) or position names out of a list it knows, and NULL for a name the list does not have.

    R DefinitionIndexingAdvanced RSelecting a single element

    example

    l <- list(a = 1, b = 2)
    l[["a"]]
    l[[2]]

  • #Dollar Access1447 tests420 slice, 412 output, 55 dataflow and 1 more

    signature tests

    .data names a column, not a variable, .env reaches past the data mask, environment(f) is not the current env

    The $ call, as in x$y, x$"y", or x$y$z, whose right side is a name rather than a value. On a list $ matches that name partially, so l$al reaches an element named alpha. The value solver knows the lists list(...) builds and the replacements change, with the same matching, while a field of an environment stays unknown to it.

    R DefinitionOperators

    example

    l <- list(alpha = 1)
    l$alpha
    l$al

  • #Slot Access95 tests26 output, 26 slice, 1 dataflow and 1 more

    signature tests

    Slot based access, at constant

    The @ call, which reads a slot of an S4 object. The slot name is read like any other access, without checking it against the class setClass declared.

    R DefinitionClasses

    example

    setClass("P", representation(x = "numeric"))
    p <- new("P", x = 1)
    p@x

  • #Access with Argument-Names3 tests2 slice, 1 desugar

    signature tests

    Named argument

    An index given with a name, as in x[i = 3] or x[[i=]]. It is matched like any other named argument of the underlying [ call.

  • #Access with Empty4 tests4 desugar

    signature tests

    Empty Access, Multiple with Empty, empty

    An index left out, as in x[] or x[2,,42]. The gap is an empty argument and still counts as a position.

  • #Subsetting (Multiple Indices)2 tests2 slice

    signature tests

    subset sequence, range assignment

    An index that is a vector or a condition, as in x[i > 3] or x[c(1,3)]. The index expression is read, but which elements it selects stays unknown, as vectorized operations are not evaluated.

    R DefinitionIndexing by vectorsAdvanced RSelecting multiple elements

    example

    v <- c(a = 1, b = 2, c = 3)
    v[c(1, 3)]
    v[v > 1]

• #Operators4 tests4 dataflow

  signature tests

  a chain mixing + and - reads every operand, a chain mixing precedences reads every operand, a chain mixing calls and operators reads every operand

  R's unary, binary, and special operators, the model formula, and every way a name can be bound to a value.

  15 children1131

  • #Unary Operator92 tests24 output, 24 slice, 7 dataflow and 1 more

    signature tests

    base quoting does not unquote, rlang unquotes with `!!` and `!!!`, a negative index drops an element

    An operator written before its single argument, like +3 or -3. It is a call of the operator's name with one argument.

    R DefinitionOperators

  • #Binary Operator554 tests313 slice, 206 dataflow, 85 output and 1 more

    signature tests

    a chain mixing + and - reads every operand, a chain mixing precedences reads every operand, a chain mixing calls and operators reads every operand

    An operator written between its two arguments, like 3 + 4 or 3 * 4. It is a call of the operator's name with both arguments, in the order R gives them.

    R DefinitionOperators

    13 children931

    • #Special Operator13 tests10 slice, 2 dataflow, 1 desugar

      signature tests

      data.table `:=` still assigns to the table, rlang `:=` names a column, it defines nothing, Must work with assigned custom pipes too

      An operator whose name is spelled between percent signs, like 3 %in% 4 or 3 %*% 4. The name binds like any other, so a program may define %between% itself and the infix call resolves to it.

      R DefinitionOperator tokens

      example

      `%between%` <- function(x, r) x >= r[1] & x <= r[2]
      5 %between% c(1, 10)

    • #Model Formula249 tests77 output, 77 slice, 4 desugar and 1 more

      signature tests

      a formula reads the names it binds, a formula over the columns of data, a boxplot over a formula keeps its names

      A formula written with ~, like y ~ x or y ~ x + z. Its operands are non-standard evaluation: a bare y ~ x names columns rather than variables, so neither name is read.

      k <- 2
      f <- y ~ poly(x, k)
      all.vars(f)

    • #Assignments and Bindings4 tests4 slice, 2 output

      signature tests

      full, nesting, single

      Every way to bind a name to a value, with the local and super operators, the calls doing the same, or a write through a replacement function.

      11 children821

      • #Local Left Assignment670 tests382 slice, 160 output, 116 dataflow and 1 more

        signature tests

        a redefinition hides the first binding, a later redefinition does not reach back, a chained assignment defines both names

        Bind a name in the current scope with <-, as in x <- 3. A target that is an access (x$y <- 3) rebinds the whole container through a replacement function.

        Advanced RBinding basics

      • #Local Right Assignment97 tests31 slice, 25 output, 7 dataflow and 1 more

        signature tests

        a right assignment defines its target, local define with -> in function, read after, Use Assignment on Target Side (inv)

        Bind a name with ->, as in 3 -> x. Identical to left assignment with the sides swapped.

        Advanced RBinding basics

      • #Local Equal Assignment61 tests23 slice, 16 output, 10 dataflow and 1 more

        signature tests

        an equals assignment defines its target, read previous def in cond, def in then and else read afterward

        Bind a name with =, as in x = 3. This holds only at the start of an expression, as inside a call the same token gives a named argument (f(a = 3)).

        Advanced RBinding basics

        example

        x = 3
        f <- function(a) a
        f(a = x)

      • #Local Table Assignment8 tests4 slice, 3 dataflow, 1 desugar

        Bind a column in place with data.table's :=, as in x[,a:=3,]. It is read as a write to the table, not to a name, and which columns exist stays unknown (see data masking).

      • #Super Left Assignment1689 tests516 slice, 504 output, 20 dataflow and 1 more

        signature tests

        a super-assignment two calls down, a super-assignment creates a global, sapply over a closure that super-assigns

        Bind a name in an enclosing scope with <<-, as in x <<- 42. The write leaves the function it sits in, which is what makes it a side effect of the call.

        Advanced RSuper assignment

      • #Super Right Assignment6 tests4 dataflow, 2 desugar

        signature tests

        global define with ->> in function, read after, Manual Max Function

        Bind a name in an enclosing scope with ->>, as in 42 ->> x. Identical to super left assignment with the sides swapped.

        Advanced RSuper assignment

      • #Return Value of Assignments190 tests59 slice, 48 output, 18 dataflow

        signature tests

        the value of an assignment is used, a chained assignment defines both names, Nested Global Mixed with Local Assignments

        An assignment is itself an expression that hands on the value it bound. This is what makes x <- y <- 3 bind both names and print(x <- 4) print 4.

        x <- y <- 3
        print(x <- 4)

      • #Assignment Functions476 tests322 slice, 152 dataflow, 91 output and 1 more

        signature tests

        global assign (no envir) is unchanged, chained bracket access with variables, sibling parameter default sees later body reassignment

        Bind a name given as a string, with assign, delayedAssign, ... The name has to be a resolvable string. A delayed expression runs where the name is first read, so it sees the bindings at that point and its own writes happen there, in the assign.env given.

        assign("x", 3)
        delayedAssign("y", x * 2)
        x <- 5
        y

      • #Range Assignment1 test1 slice

        signature tests

        range assignment

        Write to a range of a container, as in x[1:3] <- 3. Like every replacement call it rebinds the whole container, as which cells the range covers is not tracked.

        R DefinitionSubset assignmentAdvanced RSubassignment

        example

        x <- 1:5
        x[2:3] <- 0
        x

      • #Replacement Functions863 tests247 slice, 243 output, 60 dataflow

        signature tests

        a replaced element keeps the list, a replacement after a rebinding drops the first, a replaced function environment keeps the function

        Read a write to a call, like x[i] <- 3 or x$y <- 3, as the `[<-`(x, 3) R runs for it. The name in front is both read and rebound, under the conditions the write stands under, so a later read reaches the old binding only through the replacement. The value solver applies $<- and [[<- with a constant name or position to a list it knows (l$a$b <- 1 included, NULL removing an element), any other replacement leaves the value unknown. A named argument in such a call (g(v, k = 2) <- 3) leaves its argument edge dangling.

        Advanced RReplacement functionsR DefinitionSubset assignment

        example

        `second<-` <- function(x, value) {
          x[2] <- value
          x
        }
        v <- 1:3
        second(v) <- 9
        v

      • #Locked Bindings1 test1 query

        signature tests

        an assignment to a locked binding still redefines it

        A binding lockBinding (or lockEnvironment) makes constant. Neither is recognized as a built-in, so the assignment R would have rejected is read as an ordinary rebinding.

        R DefinitionEnvironment objects

        example

        x <- 1
        lockBinding("x", environment())
        x <- 2

      show 3 more
• #Control-Flow19 tests18 slice, 13 output, 3 dataflow

  signature tests

  useless branch (complete graph), useless branch with alias, useless branch with alias ||

  Conditionals, the three loop forms, their jumps, and how an error leaves a computation.

  9 children810

  • #if1835 tests508 slice, 484 output, 96 dataflow and 1 more

    signature tests

    useless branch (complete graph), get result drives if-then-else condition: val reads from get, if read..., a maybe definition in a function does not hide the global one it may ...

    The conditional if (x) y else z, and if (x) y without an alternative. Both branches stay possible, so a name bound in either reaches a use below, and a missing else yields NULL.

    R Definitionif

    example

    x <- if(TRUE) 1 else 2
    y <- if(FALSE) 3
    y

  • #for loop926 tests291 slice, 266 output, 65 dataflow and 1 more

    signature tests

    a loop body still calls, a while loop counting down, the counter of a while loop

    The loop for (i in 1:3) print(i), which binds its variable in the surrounding scope. The body is analyzed once for any number of iterations, so a name it binds also reaches its own next read and the reads of the functions the body calls, unless the body surely binds it anew before the call, and i stays bound after the loop. Value resolution tells the runs over a known sequence apart.

    R DefinitionLooping

    example

    for(i in 1:3) print(i)
    i

  • #while loop259 tests82 slice, 63 output, 48 dataflow and 1 more

    signature tests

    Endless while loop with variables, a loop body is evaluated, a while loop counting down

    The loop while (x) b, whose condition is read before every iteration. Whether the body ever runs is unknown to the dataflow graph, so a name it binds and the one bound before it both reach a use below. Value resolution counts the runs when it can tell the condition of each one (i <- 0; while(i < 3) i <- i + 1) and resolves the value of the last one.

    R Definitionwhile

    example

    i <- 0
    while(i < 3) i <- i + 1
    i

  • #repeat loop118 tests41 dataflow, 36 slice, 23 output and 1 more

    signature tests

    a while loop counting down, the counter of a while loop, a while loop that never runs

    The loop repeat {b; if (x) break}, which only a break or a return leaves. Like every loop the body is analyzed once, for any number of iterations. Value resolution counts the runs of a body that ends with its only if (x) break when it can tell x in each one.

    R Definitionrepeat

    example

    i <- 0
    repeat {
      i <- i + 1
      if(i > 2) break
    }
    i

  • #break135 tests50 slice, 44 output, 7 dataflow and 1 more

    signature tests

    a repeat loop runs until its break, an if before a break does not control it, an if before a conditional break does not control the loop

    Leave the innermost enclosing loop with break (break() included). The rest of the body becomes unreachable on that path, so what it would have bound does not reach a use after the loop.

    R DefinitionControl structures

    example

    for(i in 1:5) {
      if(i == 4) break
      print(i)
    }

  • #next124 tests42 slice, 39 output, 3 dataflow and 1 more

    signature tests

    next skips the rest of the body, next skips the update of one iteration, Next in while

    Start the next iteration of the innermost enclosing loop with next (next() included). The rest of the body is skipped on that path, while the loop itself continues.

    R DefinitionControl structures

    example

    for(i in 1:5) {
      if(i %% 2 == 0) next
      print(i)
    }

  • #switch203 tests56 slice, 55 output, 10 dataflow

    signature tests

    closures made in a loop with local, a value carried to the next iteration, a loop calling a function with a super assignment

    Pick a branch by name or position with switch. A branch left empty falls through to the next one, and every branch stays possible, as the selector does not narrow which of them runs. The call returns the branch it picks, so a function chosen by switch is linked to the call that runs it.

    R DefinitionControl structures

    example

    switch("b", a = , b = "ab", c = "c")
    switch(2, "one", "two")

  • #return152 tests66 slice, 30 output, 5 dataflow

    signature tests

    return parameter named, read of parameter in return, an early return

    Leave the enclosing function with return(3). Its argument becomes a value of the call, next to the implicit return of whatever path does not return early.

    Advanced RExiting a function

    example

    f <- function(x) {
      if(x > 0) return("pos")
      "non-pos"
    }
    f(1)

  • #Exceptions and Errors1145 tests297 output, 297 slice, 101 dataflow and 2 more

    signature tests

    a warning handler for an error, an error handler for a warning, an error handler for a promise

    A condition raised with stop/warning and caught with try/tryCatch/withCallingHandlers. The path on which a call throws before a write stays open, so after tryCatch({ risky(); x <- 2 }, ...) the variable x may still hold its earlier value. A handler only runs when the block may signal a condition of its class. Anything that may signal counts (an operator, a call of a built-in or of a function we cannot resolve, a variable that may force a promise), only stop, warning, and message handed constants are matched by the class they signal, so tryCatch(message("m"), warning = h) never runs h. A calling handler is linked to every warning, message, or signalCondition that may reach it, also in the functions the block calls. This holds for a handler written inline as well as for one given as a value (a variable, a list element, the result of a factory, or a parameter), which is resolved like any function value.

    R DefinitionException handlingAdvanced RConditions

    example

    tryCatch(
      stop("boom"),
      error = function(e) conditionMessage(e),
      finally = print("done")
    )

  show 1 more
• #Function Definitions73 tests32 call-graph, 28 slice, 13 dataflow and 1 more

  signature tests

  Simple S7 Generic Method and Call, Simple S7 Generic Registration with default fn, constructor + function factories recognised as callable definitions

  The parameters a function binds, their defaults, ..., promises, and the value the call hands back.

  7 children610

  • #Normal4573 tests1362 slice, 1267 output, 41 dataflow and 1 more

    signature tests

    call on.exit at the end, the shape of a data frame, with add, on.exit's append

    A function written with function(x) x. It opens a scope of its own, so its body resolves names in its lexicographic scope rather than where the call happens.

    R DefinitionFunction definitions

  • #Formals102 tests30 slice, 28 output

    signature tests

    a parameter shadows the global one, a parameter with a space is read in backticks, a backticked parameter shadows the global name

    The parameters a definition declares, with their names, defaults, ..., and the promise each is bound to.

    4 children310

    • #Named84 tests56 slice, 23 dataflow, 16 output and 1 more

      signature tests

      a parameter returned holds what its own call passes, return parameter named, read of parameter in return

      A parameter written as a name, as x in function(x) x. It binds that name in the body, where it shadows an enclosing binding of the same name.

      R DefinitionArguments

    • #Default427 tests131 slice, 121 output, 7 dataflow and 1 more

      signature tests

      a default argument sees the reassigned parameter, a default argument reads the global at call time, A call of a helper relying on the default file is kept

      A parameter with a default, as in function(x = 3) x. The default is evaluated in the function's own scope, so it may read another parameter (function(x, y = x * 2)).

      Advanced RDefault arguments

      example

      f <- function(x, y = x * 2) y
      f(3)

    • #Dot-Dot-Dot213 tests59 slice, 57 output, 9 dataflow and 1 more

      signature tests

      a closure forcing dots handed on twice, a returned closure forcing dots by ...elt, a returned closure forcing dots by position

      The variadic parameter ..., which collects every argument no other formal took. Passing it on keeps those arguments together, and a call handing it on binds them, with their names, as each known call of the function around hands them over. ..2 and ...elt(2) read only the second of them, and an argument no read sees once handed on is never forced, while a formal behind it is only matched by its exact name.

      R DefinitionDot-dot-dot

      example

      f <- function(...) sum(...)
      g <- function(...) f(..., 1)
      g(2, 3)

    • #Promises484 tests118 slice, 117 output, 58 dataflow

      signature tests

      an argument forced only once, an argument forced three calls deep, a promise forced in the caller frame

      An argument is a promise, evaluated where it was written but only when the body first reads it. When that happens is not modelled, nor are the writes that forcing it performs, so function(x = y) { y <- 3; x } does not tell us where y is read.

      R DefinitionPromise objectsAdvanced RLazy evaluation

      example

      f <- function(x = y) {
        y <- 3
        x
      }
      f()

  • #Implicit Return304 tests188 slice, 86 output, 50 dataflow

    signature tests

    call on.exit at the end, with add, on.exit's append, Calling with a constant function

    A function hands back the value of the last expression it evaluates, without a return. Every path's last expression is such a value of the call.

    R DefinitionFunction definitions

  • #Lambda SyntaxR 4.1.0+103 tests31 slice, 27 output, 5 dataflow

    signature tests

    a language object is followed into and out of a function call, Calling with constant argument using lambda, a lambda is a function

    The short form \(x) x of a function definition. It is purely syntax and binds its parameters and scopes its body exactly like the long form.

    sapply(1:3, \(x) x^2)

• #Important Built-Ins

  The base-R functions we give a meaning of their own rather than treating as opaque calls, the ones that compute on the language included.

  14 children2120

  • #Non-Strict Logical Operators17 tests9 dataflow, 8 desugar

    signature tests

    rhs has to depend on x

    The operators && and ||, which evaluate their right side only if the left one does not decide the result. The right side is read as a path that may not run, unlike the vectorized &/|.

    R DefinitionOperators

    example

    FALSE && stop("never evaluated")
    TRUE || stop("never evaluated")

  • #PipeR 4.1.0+232 tests61 slice, 55 output, 19 dataflow and 2 more

    signature tests

    With %<>% and pre-use, Basic Pipe With Placeholder and Argument Name, Chained pipe into a pipe-bind

    The native pipe |>, which is syntax rather than a call: the parser rewrites it. The left-hand side becomes the first argument or fills the _ placeholder.

    R DefinitionFunction calls

    example

    c(1, 2, 3) |> sum() |> sqrt()
    mtcars |> subset(cyl == 4)

  • #Pipe-BindR 4.1.0+5 tests4 dataflow, 1 desugar-shell

    signature tests

    Pipe-bind has no tree-sitter grammar production, Pipe-bind is disabled unless engine.r-shell.pipeBind is enabled, Chained pipe into a pipe-bind

    The experimental pipe-bind =>, which names what the pipe hands on and which R only enables under _R_USE_PIPEBIND_. It is off by default and needs engine.r-shell.pipeBind. Tree-sitter's grammar has no production for it.

    R DefinitionFunction calls

    example

    mtcars |> df => lm(mpg ~ cyl, data = df)

  • #Sequencing3 tests2 slice, 1 output, 1 query

    signature tests

    a vector times a scalar is elementwise, Overwrite in For-Loop, a built-in replacement is unchanged

    Give :, seq, ... the sequence they produce, gathered by abstract interpretation. That value lets us reason about a loop bound or an index, but seq, seq_len, seq_along, and rep are not folded even for literal arguments.

    n <- 0
    1:n
    seq_len(n)

  • #Internal and Primitive Functions1 test1 slice

    signature tests

    Without using primitive

    The .Internal and .Primitive calls a base function reaches its C implementation through. The call is kept and its arguments read, but the name .Primitive("sum") spells is not resolved the way a created name would be.

    R Definition.Internal and .Primitive

    example

    .Primitive("+")(1, 2)
    .Internal(inspect(1))

  • #Options1041 tests366 slice, 293 output

    signature tests

    Printing reads the printing options, getOption reads the option it names, a later option setting wins

    The global options options sets and getOption, .Options, printing, and formatting read. Each option is tracked by name, so getOption("digits") reaches the last options(digits = 3), print and cat reach the printing options, and an unrelated option usually stays out of a slice. withr::with_options and local_options scope a change, and eval of code that sets options counts as setting them. Where the last options(...) surely setting an option names it as an argument, getOption hands back that value, so options(cb = function() 4); getOption("cb")() calls the function. Other values are not interpreted, an options(op) restoring an unknown list may set any option, and options that change every conversion (scipen, OutDec) stay an unknown side effect. A function flowR cannot see into may read any option.

    old <- options(digits = 3)
    print(pi)
    options(old)
    getOption("digits")

  • #Graphics State1166 tests355 slice, 310 output

    signature tests

    par set before is what par reports, a graphics parameter set before it is read, a graphics parameter restored from the old values

    The graphics parameters par and layout set for the active device, the palette all devices share, and the devices opened and closed. A plot reads the state of the device it draws on, so it links to the par calls before it, a new device starts afresh, and dev.off() returns to the state of the device that becomes active. withr::with_par and the with_<device> functions scope a change. Within a function the open devices are unknown, so a device call only adds to what may hold, and grid-based plots like ggplot2 ignore the parameters.

    par(mfrow = c(1, 2))
    png("a.png")
    par(mar = c(1, 1, 1, 1))
    plot(1:10)
    dev.off()
    plot(2:3)

  • #Help3 tests2 desugar, 1 dataflow

    signature tests

    ? x

    The help calls ?, ??, help, ... ? and ?? are recognized, but their topic is read as an ordinary name where R only looks it up, and help/help.search are not known at all.

    ?sum
    help("sum")

  • #Reflection / "Computing on the Language"10 tests10 dataflow

    signature tests

    map with additional args, walk has an invisible return, substitute with env and two fields

    Code that reads or builds code, by quoting an expression, evaluating it elsewhere, parsing it from a string, or rewriting a function.

    6 children060

    • #Get Function Structure76 tests23 output, 23 slice

      signature tests

      a function read as a value keeps its body

      Read a part of a function with body, formals, args, or environment. What comes back is opaque, and the whole function is read, so asking only for formals(f) keeps all of f's body in a slice.

      R DefinitionManipulation of functions

      example

      f <- function(x) x + 1
      body(f)
      formals(f)
      environment(f)

    • #Modify Function Structure330 tests95 output, 95 slice

      signature tests

      a body written in reads what it names, environment<- decides where the body looks up, a nested replacement of the body reaches the call

      Rewrite a part of a function with body<-, formals<-, or environment<-. Like every replacement function it rebinds the name, and a later call reaches the original function through that rebinding.

      R DefinitionManipulation of functions

      example

      f <- function(x) x + 1
      body(f) <- quote(x * 2)
      f(3)

    • #Quoting167 tests45 slice, 44 output, 25 dataflow

      signature tests

      substitute with env and two fields, quote leaves nothing within it evaluated, bquote evaluates the operand of `.()` only

      Take an expression as a value with quote, substitute, bquote, ... A quoted argument is non-standard evaluation: the names in it are not read, and substitute does not reach the caller's expression.

      R DefinitionComputing on the languageAdvanced RMetaprogramming

      example

      x <- 1
      quote(x + y)
      bquote(.(x) + y)

    • #Evaluation808 tests235 slice, 222 output, 38 dataflow

      signature tests

      an evaluated capture is no longer marked as unevaluated, cli markup text is no code, cli interpolates plain braces

      Run an expression that is a value with eval, evalq, eval.parent, ... The captured code is linked where it is evaluated, also through a name bound once to quote, as.name, str2lang, or parse, but eval(expr, envir) with an environment we do not know stays an unknown side effect. A constructed call, like eval(call("f", x)) or eval(as.call(list(as.name("f"), x))), runs like a do.call of that function, also when the call is bound to a name first.

      R DefinitionEvaluation of expressionsAdvanced REvaluation

      example

      e <- quote(x + 1)
      x <- 2
      eval(e)
      n <- as.name("x")
      eval(n)

    • #String Templates619 tests170 slice, 167 output, 13 dataflow

      signature tests

      cli markup text is no code, cli interpolates plain braces, a plain string stays a string

      A string that reads the names inside it, as glue::glue("{x}"), cli::cli_alert_info("{.val {x}}"), or stringr::str_glue do. Those names resolve in the scope of the template, and one aimed at another scope (.envir, .con, glue_data) becomes an unknown side effect.

      x <- 2
      glue::glue("x plus one is {x + 1}")

    • #Parsing81 tests24 output, 24 slice, 2 dataflow

      signature tests

      eval of parsed text, simple eval use - from 2 variables, simple eval use

      Turn text into an expression with parse or str2lang, and an expression back into text with deparse. What parse produces is only reached through evaluation, and deparse is not modelled beyond reading its argument.

      R DefinitionThe parsing processR DefinitionDeparsing

      example

      eval(parse(text = "1 + 1"))
      eval(str2lang("2 * 3"))
      deparse(quote(x + y))

  show 1 more
• #Literal Values

  The values written into the source itself, which is what a resolved name and an S3 class are read from.

  7 children700

  • #Numbers622 tests347 slice, 177 dataflow, 109 desugar and 1 more

    signature tests

    Not giving first argument, using loop variable in for-body, Calling with a constant function

    Recognize numbers like 3, 3.14, the integer 3L, hexadecimals such as 0xFF and 0x1p3, as well as the typed missings NA_integer_/NA_real_, ...

    R DefinitionLiteral constants

    example

    1L
    0xFF
    1e-3
    0x1p3
    NA_real_

    1 child100

    • #Complex2 tests2 desugar

      signature tests

      2i, 1e-2i

      Recognize the imaginary literals 1i, 4.1i, 1e-2i, ... The value survives arithmetic and is told apart from 1L and a plain 1.

      R DefinitionLiteral constants

      example

      z <- 1i
      z + 2i
      3 + 2i

  • #Strings1044 tests403 slice, 297 output, 26 dataflow and 2 more

    signature tests

    built-in vector constant, gsub replaces every match, assign to parent.frame escapes

    A string literal like "a" or 'b'. Its value is kept, which is what lets it stand for a name or fold into a resolved one.

    R DefinitionLiteral constants

    1 child100

    • #Raw StringsR 4.1.0+3 tests3 desugar

      signature tests

      r"()", r"(xx)", r"--(xx)--"

      A raw string like r"(a)", in which a backslash is no escape. Its value is the same string the quoted form would give.

      r"(C:\Users\me)"
      r"[\d+]"

  • #Logical233 tests66 slice, 52 output, 35 dataflow and 1 more

    signature tests

    na.rm leaves out the missing value, an untaken branch leaves the variable alone, using variable in body

    Recognize the logicals TRUE and FALSE, ... Their short forms T and F are ordinary bindings and can be reassigned, while TRUE and FALSE are reserved.

    R DefinitionConstants

    example

    TRUE && FALSE
    T <- FALSE
    T

  • #NULL83 tests29 slice, 25 output, 1 dataflow

    signature tests

    dev.cur reads the devices opened, dev.list reads the devices opened, dev.cur reads the device switched to

    The NULL object, R's empty value. It is what an if without an else branch yields, and assigning it to a list element removes that element.

    R DefinitionNULL object

    example

    c(1, NULL, 2)
    l <- list(a = 1)
    l$a <- NULL
    length(l)

  • #Inf and NaN3 tests2 dataflow, 1 slice

    The constants Inf and NaN, which arithmetic produces rather than errors on. They are ordinary values here, and the predicates asking for them are not evaluated, as no type is inferred.

    R DefinitionConstants

    example

    1 / 0
    -1 / 0
    0 / 0
    is.nan(NA)

All categories

Non-Standard Evaluations/Semantics

1 fully5 partially1 not

The places where R does not evaluate an expression the way it is written, so a name in it may mean something other than the binding it seems to read.

• #Data Masking75 tests21 output, 21 slice, 10 dataflow

  signature tests

  a classed closure in a mask keeps its read, the verbs without a data argument mask all of them, the tidyr verbs that take data first mask the column

  A call that evaluates its arguments against the columns of a data frame first, as subset(d, col > 1), the dplyr verbs, ggplot2::aes, and data.table's := do. Which columns exist is unknown to us, so a column shadowing a variable still resolves to the variable.

  Advanced RData masks

  example

  d <- data.frame(x = 1:3)
  threshold <- 2
  subset(d, x > threshold)

• #Recycling1 test1 query

  signature tests

  two vectors of different length are not recycled

  A shorter operand is repeated to the length of the longer one. This is not modelled, so the operands are read but the length of what an operator produces is not derived from them.

  R DefinitionRecycling rulesAdvanced RVectors

  example

  c(1, 2, 3, 4) + c(10, 20)

• #Vectorized Operator or Functions456 tests134 output, 134 slice, 2 query

  signature tests

  which.max finds the position, ifelse chooses per element, sapply over an anonymous function

  An operation applied to every element of a vector at once. Comparisons, the reducing functions, and ifelse widen to the unknown value, so an index built from one selects an unknown set of elements.

  Advanced RVectorise

  example

  x <- 1:5
  x * 2
  ifelse(x > 2, "big", "small")

• #Hooks25 tests22 dataflow, 3 call-graph

  signature tests

  a handler that never runs, a warning raised two calls deep, an error handler reading a global

  Code registered to run at a point the program does not write out, with on.exit or userhooks. An on.exit body runs when the function it sits in ends, in the order add and after give, and a hook registered in a branch or loop only maybe. setHook is not modelled.

  Advanced Ron.exitR Definitionuserhooks

  example

  f <- function() {
    on.exit(print("bye"))
    1
  }
  f()

• #Precedence43 tests42 slice, 7 output, 1 dataflow

  signature tests

  def compare in loop, Must work with assigned custom pipes too, redefining assignments should work

  Which operator binds tighter, as the documentation lays it out. It decides the shape of the tree the parser hands us, so -2^2 is -(2^2) before anything else looks at it.

  R DefinitionOperator tokens

  example

  -2^2
  1:3 - 1
  !TRUE == FALSE

• #Attributes85 tests25 output, 25 slice

  signature tests

  an attribute set is read back

  The data an object carries beside its value, which is where its S3 class and its shape live.

  2 children020

  • #User-Defined1 test1 output, 1 slice

    signature tests

    setting an attribute rebinds the object

    An attribute a program sets itself, with attr or attributes. Which attributes an object carries is not part of the value we track, so only the rebinding of the object itself is seen.

    R DefinitionAttributes

    example

    x <- 1:3
    attr(x, "unit") <- "cm"
    attributes(x)

  • #Built-In23 tests11 call-graph, 7 dataflow, 7 slice

    signature tests

    Call edges with may built-in, useless branch (complete graph), unresolved get is reached-but-unknown, not dropped

    An attribute R gives a meaning of its own, such as dim, names, or the class that dispatch reads. dim<-, names<-, and class<- track shape only on a data frame.

    R DefinitionDimensional attributes

    example

    x <- 1:6
    dim(x) <- c(2, 3)
    class(x)

All categories

Object-Oriented Programming

2 fully10 partially0 not

R's object systems, the class an object carries, and the dispatch that decides which function body a generic call runs.

• #S325 tests16 output, 16 slice, 8 dataflow and 1 more

  signature tests

  A base generic picks up no unrelated method, S3 dispatch reads the object it dispatches on, A named object moves the read off the first formal

  Classes and methods built on the class attribute and UseMethod dispatch. A class is a string an object carries rather than a declaration, so what a call runs follows from the names generic.class in scope.

  Advanced RS3R DefinitionObject-oriented programming

  example

  p <- structure(list(n = "ada"), class = "pt")
  print.pt <- function(x, ...) cat("pt", x$n, "\n")
  p

  3 children120

  • #Class Construction2 tests1 dataflow, 1 query

    signature tests

    Dispatch through a base generic, a class named where an object is constructed counts as a use of that ...

    Give an object its class with structure(..., class =), class<-, or oldClass<-. A class written as a string literal is tracked and reaches the dispatch that follows it.

    R DefinitionObjects

  • #Dispatch384 tests115 dataflow, 67 slice, 66 output

    signature tests

    an as.character method run by paste, an as.character method run by sprintf, an as.character method run by file.path

    Route a generic call to the method that runs. UseMethod and a built-in generic like length or toString link to the definitions named generic.class in scope for the class the dispatched object may have, then generic.default. The class is followed through the value flow to where it is set: a structure(..., class =), a class<- or oldClass<-, a constructor function returning such an object, the implicit class of a constant, and the arguments bound to the generic at every call. A dispatch on what the calls of its function hand it is decided per call as well, through up to three calls (a generic called by a function called by another), so a slice for one call keeps only the methods that call may run, as long as each function is only ever called by name. UseMethod("f", y) dispatches on y, a replacement lab(a) <- v on the class a had before, both through a lab<- of the program and through a built-in like names<- or [<-, and printing a visible top-level value calls only the print methods of the classes it may have, so a slice for that value keeps what they print. A replacement within a function is decided per call of that function as well. Where any class is not known, every generic.class method stays a target. A group generic like Ops.foo, Math.foo, or Summary.foo is reached from the operators and functions of its group, so a == b dispatches to Ops.foo for an object of class foo, narrowed by the classes of both operands.

    R DefinitionUseMethodR DefinitionMethod dispatching

  • #Inheritance158 tests60 dataflow, 28 output, 28 slice

    signature tests

    the output of an autoprinted call, the output of an autoprinted value, the output of an autoprinted variable

    Walk the class vector with NextMethod. Where the class of the dispatched object is known, it reaches the methods of the classes after that of its own method in the class vector, then the default, and otherwise every method of the generic. A method run for several class vectors decides its NextMethod per call of the generic like the dispatch itself. It hands on the current values of the formals. The generic and object NextMethod("f", x) names change nothing within a dispatch, while in a method called directly it dispatches the generic it names on the class of the first argument.

    R DefinitionNextMethodR DefinitionInheritance

• #S414 tests8 output, 8 slice, 6 dataflow

  signature tests

  S4 new reads its class registration, S4 setMethod reads the generic it answers, S4 setClass reads the class it extends

  Formal classes and methods declared with setClass, setGeneric, and setMethod. Unlike S3 the class is declared, with named slots read through @.

  Advanced RS4

  example

  setClass("P", representation(x = "numeric"))
  setGeneric("desc", function(o) standardGeneric("desc"))
  setMethod("desc", "P", function(o) o@x)
  desc(new("P", x = 1))

  3 children120

  • #Class Construction108 tests26 output, 26 slice, 15 dataflow

    signature tests

    S4 new reads its class registration, the initialize method a subclass inherits, initialize for a class named by a variable

    Declare a class with setClass and build one with new. The new call is linked to the setClass that declared the class and calls the validity functions of the class and its superclasses and the initialize methods R selects for a new object of the class (with those they reach through callNextMethod), and a slot is read through @ like any other access.

    R DefinitionClasses

  • #Dispatch74 tests74 dataflow

    signature tests

    a show method run by print, a show method run by print of a variable, a show method run by print in a function

    Route a generic call to the method setMethod (or setReplaceMethod, for the <- generic) registered. standardGeneric evaluates the arguments it dispatches on, and the call reaches the methods R may select for their classes: the class new creates or the implicit class of a constant, followed through the value flow like in S3 dispatch. Selection follows R's distance through contains, class unions and setIs, with ANY farthest and missing for an argument not given, over every argument of the signature, and keeps the methods tied for the closest. A method registered after a top-level call is not reached by it, and a setMethod depends only on the setGeneric and on an earlier method of the same signature it may replace, not on the methods of other signatures. A method set again for the same signature, unconditionally and before every run of the call, is replaced and not reached. A call within a function is decided per call of that function as well, through up to three calls. An S3 object dispatches on its first class if setOldClass registered that class (each class of the vector extending the next) once before the methods were set, as R keeps the method it picked for a class until a method is set. Where a class is not known (another S3 object, a computed signature), every method stays a target, as no type is inferred beyond that.

    R DefinitionMethod dispatching

  • #Inheritance35 tests35 dataflow

    signature tests

    the initialize method a subclass inherits, initialize for a class named by a variable, initialize for an instantiation in a function

    Reach a parent method with callNextMethod, and inherit through contains. callNextMethod reaches the method R would select for the signature the calling method is defined for if that method did not exist, which follows the superclasses in contains nearest first. A chain of callNextMethod calls is followed method by method, whatever the class of the object, and only a computed signature falls back to every method of the generic.

    R DefinitionInheritance

• #RC/R5112 tests26 output, 26 slice, 11 dataflow

  signature tests

  a reference class states typed fields and its methods apart, reference class method mutates its field

  Reference classes made with setRefClass, whose objects are mutable and thus behave like the shared environments they are built on. A method call on an instance is linked to the method it runs, and .self is bound to that instance, so a method changing a field changes the object it was called on. The instance is found like for R6, and .self never resolves to a variable of that name outside the object. Typing is not supported.

  Advanced RR5 / Reference classes

  example

  Acc <- setRefClass("Acc",
    fields = list(bal = "numeric"),
    methods = list(dep = function(v) bal <<- bal + v))
  a <- Acc$new(bal = 0)
  a$dep(5)

• #R625 tests25 dataflow

  Classes made with R6::R6Class, read as one unit rather than as the environment behind them. Like RC an R6 object is mutable. A method call is linked to the method it runs, also on a fresh $new() and through method chains, and self and private are bound to the instance the method runs on, so a method changing self$v changes that object. The instance is found through the value flow of the receiver: a variable and every alias of it, a parameter bound to the instance at each call, what a called function returns, and a list element or field of another object holding it. As R encloses the methods by the object, self and private never resolve to variables of those names outside it. Typing, inheritance, active bindings, and handling objects fully "as units" are not supported.

  Advanced RR6

  example

  Counter <- R6::R6Class("Counter", public = list(
    i = 0,
    add = function() {
      self$i <- self$i + 1
      invisible(self)
    }
  ))
  Counter$new()$add()$i

• #R7/S75 tests5 dataflow

  signature tests

  Simple S7 Generic Method and Call, Simple S7 Generic Registration with default fn, constructor + function factories recognised as callable definitions

  Classes made with S7::new_class, read as one unit, dispatch and inheritance included. Typing is not supported, nor are objects handled fully "as units."

  R7S7

  example

  Person <- S7::new_class("Person", properties = list(name = S7::class_character))
  Person(name = "ada")@name

• #Class-Based Dependency Attribution6 tests6 query

  signature tests

  an S3 method registered for a class NOT owned by any package does not..., a bare class-name string in code does NOT introduce an unrelated pack..., a class owned by a declared but never called dependency is resolved w...

  Attribute the use of a class to the package that owns it, so a class use implies a dependency for library detection and version guessing. It is the class counterpart of resolving a name to its package.

  2 children020

  • #S3 class ownership6 tests6 query

    signature tests

    an S3 method registered for a class NOT owned by any package does not..., a bare class-name string in code does NOT introduce an unrelated pack..., a class owned by a declared but never called dependency is resolved w...

    Attribute an S3 class to the package that owns it. Only a class written as a string literal is attributed, not one from a variable or a c(...) vector.

  • #S4 class ownership1 test

    signature tests

    importClassesFrom / importMethodsFrom register their source package (S4)

    Attribute an S4 class to the package that owns it. S4 ownership is not in the signature database, so a bare class use is not attributed.

All categories

R File Structure

5 fully4 partially0 not

The lexical shape of a source file, down to its line endings and encoding.

• #Comments14 tests8 desugar, 6 slice, 1 output

  signature tests

  for-loop with comment, With comments in parameter, simple line comment

  A comment like # this is a comment, a shebang line included. It is never read as code, so no name in it resolves.

  R DefinitionComments

  example

  #!/usr/bin/env Rscript
  # a comment
  x <- 1 # a trailing comment

• #Line Directive1 test1 desugar-shell

  signature tests

  Simple line

  Recognize #line n "file" as its own node (r-shell only). It is parsed but never retargets a location, and tree-sitter reads it as a comment.

  R Definitionparse

  example

  x <- 1
  #line 42 "other.R"
  y <- 2

• #Semicolons82 tests48 slice, 32 dataflow, 24 output and 1 more

  signature tests

  loop-variable redefined within loop, Inconsistent split with semicolon, multiple redefinition with circular definition

  A semicolon separating two expressions on one line, as in a; b; c. It says the same as a newline: the expressions run in the order they are written.

  R DefinitionSeparators

  example

  a <- 1; b <- 2; a + b

• #Newlines660 tests555 slice, 145 output, 102 dataflow and 3 more

  signature tests

  reads within local expression, loop-variable redefined within loop, setNames hands back a renamed copy and leaves its argument alone

  Recognize and resolve newlines like a\nb\nc, where a newline ends an expression unless it is still incomplete. A trailing operator or an unclosed bracket continues on the next line.

  R DefinitionSeparators

  example

  x <- 1 +
    2
  y <- 1
    + 2

• #Line Endings3 tests3 parse

  signature tests

  CRLF parses identically to LF with the tree-sitter engine, CRLF parses identically to LF, lone CR parses identically to LF

  Recognize \n (Unix), \r\n (Windows), and a lone \r (classic Mac). Normalized at the r-bridge boundary, with both engines.

  x <- 1
  y <- x + 1

• #Source Encoding5 tests5 parse

  signature tests

  hex byte escapes decode to UTF-8, octal byte escapes decode to UTF-8, non-ASCII names, strings, and comments survive

  UTF-8 beyond ASCII in string literals, in a comment, and in names (plain as well as backtick-escaped). Such names bind and resolve like any other, with both engines.

  R DefinitionTokens

  example

  stärke <- "café"
  `α β` <- 2
  stärke

• #Byte-Order Mark1 test1 parse

  signature tests

  a leading BOM does not change the program

  Recognize a UTF-8 byte-order mark at the start of a file. The tree-sitter engine reads past it, the r-shell engine rejects the same input as unparsable.

• #Syntax Errors6 tests6 linter

  signature tests

  valid code has no syntax errors, missing closing parenthesis of a for head, missing closing parenthesis of a while head

  Handle source that does not parse. The syntactically-valid rule locates the region and offers a fix. The strict parser rejects the file, while tree-sitter's lax mode (off by default) drops the region.

  R DefinitionThe parsing process

  example

  x <- 1
  y <- (
  z <- 3

• #Reserved Words2 tests2 parse

  signature tests

  tree-sitter silently drops `if <- 5`, unlike r-shell, r-shell rejects `if <- 5`, matching R

  Reject a syntactic keyword like `if` or `function` where R's grammar requires an expression. The r-shell engine rejects if <- 5, while tree-sitter's grammar parses it as an ordinary assignment.

  R DefinitionReserved words

  example

  if <- 5

All categories

Project

10 fully5 partially0 not

The files around the R code, from the package metadata and the packages a version manager pins to what runs before a script does.

• #Package Metadata

  The files that describe the package itself, what it needs, and what it offers.

  5 children410

  • #DESCRIPTION2 tests

    signature tests

    Declared package names span every dependency field, Loading-Order-Plugin

    Read a package's DESCRIPTION. Its DCF records give the package name, version, R version, dependency fields, and Collate order.

    plugindescription-fileWriting R ExtensionsThe DESCRIPTION file

  • #NAMESPACE4 tests

    signature tests

    Imports are registered correctly, an importFrom names where the name comes from, an import of a whole p..., importClassesFrom / importMethodsFrom register their source package (S4)

    Read a package's NAMESPACE. Acts on import/importFrom, importClassesFrom/importMethodsFrom for S4, and export/S3method, which is what says whether a name is exported or internal.

    pluginnamespace-fileWriting R ExtensionsPackage namespaces

  • #Documentation (`.Rd`)2 tests

    signature tests

    a page without a \name{} falls back to the file name, name, docType, title, keywords, aliases, usage and arguments

    Read the .Rd pages under man/, their macros, and the indices beside them. A documented name is tied back to the page that documents it.

    pluginrd-fileWriting R ExtensionsRd format

  • #NEWS1 test

    signature tests

    Parse the News!

    Read a package's NEWS/NEWS.md. We parse the versions it announces and what each changed, which is what a version guess is checked against.

    pluginnews-fileWriting R ExtensionsPackage subdirectories

  • #Package Data (`sysdata.rda`)2 tests

    signature tests

    the package's own code reads them without anything bringing them in, a source package is tagged as data and states its objects with the ty...

    Read the R/sysdata.rda a package keeps its internal data in, and the data/ files it exports. What those bindings hold is not reconstructed.

    pluginsysdata-fileWriting R ExtensionsData in packages

• #Dependency Managers

  The lockfiles and manifests a version manager pins a project's packages with.

  7 children520

  • #renv2 tests

    signature tests

    renv.lock pins every package, a lockfile is read whatever its name is capitalized like

    Read the configuration of renv, the most widespread R project-library manager. The library it points at is neither installed nor restored.

    pluginanalyzer-package-versions-lockfilerenv

  • #packrat3 tests

    signature tests

    packrat.lock pins every package, packrat.lock contributes its RVersion, the lockfile is discovered and read, the installed library is not

    Read the configuration of packrat, the predecessor of renv. The packrat/lib library beside it is not loaded.

    pluginanalyzer-package-versions-lockfilepackrat

  • #rv2 tests

    signature tests

    rv.lock contributes its r_version, rv.lock pins every package, including builtin ones

    Read the configuration of rv, a declarative project manager in the style of cargo. Parses rproject.toml and the resolved rv.lock.

    pluginmanifest-filesrv

  • #uvr3 tests

    signature tests

    uvr.lock contributes the version of its [r] table, uvr.lock pins every package, including the dev ones, the manifest and the lockfile are read, the project library is not

    Read the configuration of uvr, an R project manager modelled on uv. Parses uvr.toml and the uvr.lock beside it.

    pluginmanifest-filesuvr

  • #rig6 tests

    signature tests

    a script lockfile sits beside its script, targets that disagree pin nothing for that package, nor for R, rproj.lock pins what its single target resolved, and its R version

    Read the configuration of rig projects and scripts. Parses rproj.toml, the inline # /// script block a script declares its dependencies in, and the resolved rproj.lock or <script>.R.lock.

    pluginmanifest-filesrig

  • #Installed Library3 tests

    signature tests

    the lockfile is discovered and read, the installed library is not, the manifest and the lockfile are read, the project library is not, the manifest, the script block and both lockfiles are read, the proje...

    Read the package library a project installs into (renv/library, packrat/lib, or the platform library). Their code is not read.

    pluginanalyzer-package-versions-library

  • #On-Demand Package Sources43 tests

    signature tests

    exports and formals of ggmirt, its code is parsed, never run, every way to write a definition

    Fetch the source of a package no signature database knows when the code uses it, from CRAN, Bioconductor, or GitHub (solver.sigdb.onDemand). The repository comes from an install_github-style call, the Remotes of the DESCRIPTION, or the configuration. The exports come from the NAMESPACE (an exportPattern matched against the names the code defines) and the formals from the functions the R/ files define at the top level, cached per package so a later analysis works offline. A fetched package counts as untrusted: its code is parsed, never run, only https to public hosts (or the configured mirrors) is used, what it states is cut down to names, formals, and a version, and it cannot take over a function that matters to security (system, eval, file and network calls), so those keep being found. Only a trusted configuration can switch this on. Function bodies are not analyzed, and a package loaded under a name only known at run time is not fetched.

    pluginanalyzer-package-versions-on-demand

    example

    remotes::install_github("masurp/ggmirt")
    library(ggmirt)
    tracePlot(fit, theta_range = c(-3, 3))

• #Startup and Discovery

  What runs before a script does and what counts as part of the project at all.

  2 children110

  • #Startup Files3 tests

    signature tests

    a discovered .Rprofile is loaded first, .Rprofile and Rprofile.site are tagged Startup and Source, .Renviron and Renviron.site are tagged Environment but not Source

    Read the files R runs or reads before a script (.Rprofile, Rprofile.site, .Renviron, Renviron.site). An .Rprofile is read as R code whose bindings precede the script, but variables set by an environment file are not interpreted.

    pluginanalyzer-rprofile-fileR DefinitionStartup

  • #Ignore Files2 tests

    signature tests

    the combined plugin respects both files, .Rbuildignore drops matching files and whole directories

    Read the .gitignore and .Rbuildignore that say which files are not part of the project. Follows gitignore globs and the regular expressions R CMD build uses.

    pluginanalyzer-ignore-file-project-discoverygitignore

• #Pre-Processors/external Tooling

  The tooling around R code rather than the R in it, such as roxygen2 blocks and woven documents.

  1 child010

  • #roxygen24 tests

    Handle the roxygen2 blocks that precede a definition. They are read as a comment and what a tag states does not reach how a name resolves, so an importFrom tag leaves the name below it unqualified.

    roxygen2

    example

    #' @param x a number
    #' @importFrom stats median
    #' @export
    mid <- function(x) median(x)