Capabilities

All categories

Names and Identifiers

20 fully8 partially2 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:_["`Built-In:
#123;`"]
    style built-in:_ 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:_-["`Built-In:
#60;#45;`"]
    style built-in:_- 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:_["`Built-In:
#43;`"]
    style built-in:_ stroke:gray,fill:gray,stroke-width:2px,opacity:.8;
    23[["`base#58;#58;**print** (L. 3)
*RFunctionCall*`"]]
    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:_
    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:_-
    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:_-
    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:_
    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

  • #Normal911 tests306 slice, 275 dataflow, 66 output and 3 more

    signature tests

    simple variable, function from generated load is callable, load defines variables from generated rda

    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

  • #Quoted19 tests16 slice, 7 output, 3 desugar

    signature tests

    'f'(), With Quotes and Namespace, Assign to Given String

    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)

  • #Escaped18 tests10 slice, 8 dataflow, 1 output and 1 more

    signature tests

    one distractor, without distractors, one hundred distractors

    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

  • #Created5 tests4 slice, 2 output, 1 dataflow

    signature tests

    get reads the definition of the name it resolves to, get with an unresolvable name drops the definition it reads, exists with the name in a variable

    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. A name only known at runtime (get(Sys.getenv("V"))) is not linked.

    R DefinitionIdentifiers

    example

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

  • #Resolved Name46 tests27 slice, 20 dataflow, 8 output

    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, higher-order fn, with alias chain

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

  25 children1582

  • #Global Scope20 tests10 slice, 4 output

    signature tests

    Same variables, 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 Scope34 tests14 slice, 10 dataflow, 4 output

    signature tests

    Double Base, Simple Assign Break, Double Base in Base CTX

    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()

  • #Closures40 tests35 slice, 18 output, 10 dataflow

    signature tests

    Calling a function which returns another, double nested functions, Two possible exit points to bind y closure

    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 Capture1 test1 output, 1 slice

    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.

    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 Resolution117 tests78 dataflow, 39 slice, 1 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.

    R DefinitionEnvironment objects

    example

    e <- new.env()
    assign("x", 3, envir = e)
    get("x", envir = e) + e$x

    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 Parent6 tests5 dataflow, 1 slice

      signature tests

      new.env(parent=NULL): same as emptyenv(), assign does not leak, new.env() without parent uses default (parent.frame()), tracked normally, new.env(parent=e) with tracked parent env: child reads from parent vi...

      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

      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

      alias of alias: double indirection still resolves x, alias does not see assigns made to original env AFTER alias was created, alias snapshots envState: get via alias resolves x assigned before alias

      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

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

    • #With12 tests7 slice, 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 Frame2 tests2 output, 2 slice

      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 Removal22 tests20 dataflow, 3 output, 2 slice

      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. Currently handles negative and zero offsets from within depth-1 functions.

  • #Environment Sharing42 tests23 dataflow, 19 slice, 10 output

    signature tests

    multiple assigns to same env all read e, attach(e) injects env contents into scope, local with custom env: x not in global scope

    Handling side-effects through environments, which act as reference types and are not copied when modified. A write through a parameter is kept as an unknown side effect of the call (see Environment Alias and Side-Effects in Function Call).

    R DefinitionEnvironment objectsAdvanced REnvironments

    example

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

  • #Search Type3 tests2 slice, 1 output

    signature tests

    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 Path90 tests89 dataflow, 1 output, 1 slice

    signature tests

    Link usually, Link with variable, No dependencies set

    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 Path1 test1 dataflow

    signature tests

    search() is an ordinary call, not linked to library()

    Programmatically inspecting or mutating the search path with search(), searchpaths(), or detaching by position. None of this is modelled, and search() reads as an unknown call.

    R DefinitionSearch path

    example

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

  • #Namespaces10 tests9 dataflow, 1 slice

    signature tests

    Double Base, Simple Assign Break, Double Base in Base CTX

    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 Names8 tests4 desugar, 3 slice, 1 query

    signature tests

    With Namespace, x::f(), With Quotes and Namespace

    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

    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 Loading87 tests86 dataflow, 1 slice

    signature tests

    the resolved (assumed) R version is reported for analysis, solver.sigdb.enabled: false disables resolution and unloads the database, an explicitly namespaced call is returned as written (already qualified)

    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 Unloading1 test1 dataflow

    signature tests

    detach does not undo the attach, so a later call still resolves throu...

    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 Environment16 tests15 slice, 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. new.env() and globalenv() work, but inside a function that already binds the name the write lands in that frame instead.

    `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 fully20 partially1 not

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

• #Calls646 tests280 slice, 272 dataflow, 72 desugar and 3 more

  signature tests

  higher-order sum origin, built-in function as a value, quoted call

  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.

  15 children1140

  • #Grouping111 tests77 desugar, 22 slice, 13 dataflow and 1 more

    signature tests

    completely constant, simple constant for-loop, using loop variable in for-body

    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 Call212 tests173 slice, 50 output, 21 dataflow and 2 more

    signature tests

    Call edges for error with fn, R call-position semantics: a non-function binding is skipped, a funct..., Nested calling

    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 Arguments257 tests201 slice, 59 dataflow, 44 output 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 Arguments5 tests2 dataflow, 2 slice, 1 desugar

      signature tests

      get in function, Not giving first parameter, f(1,)

      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 Arguments54 tests35 slice, 15 dataflow, 13 output and 2 more

      signature tests

      ifelse with reordering, return parameter named, dispatch on an opaque object is reached-but-unknown, not dropped

      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 Arguments3 tests3 desugar

      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 Arguments93 tests37 dataflow, 28 call-graph, 28 slice and 1 more

      signature tests

      unresolved do.call target is reached-but-unknown, not dropped, Call with hell and dots, higher-order fn

      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 Argument9 tests8 slice, 7 output, 1 dataflow

      signature tests

      Support assignments in function calls

      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.

      R DefinitionArgument evaluation

      example

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

    • #Side-Effects in Function Call22 tests14 slice, 9 dataflow, 5 output

      signature tests

      assign to parent.frame escapes, `<<-` escapes through nested calls, default-argument promise `<<-` escapes

      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

  • #Recursion4 tests4 call-graph

    signature tests

    recursion, fibonacci with recall, ping-pong-rec

    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 Calls12 tests6 slice, 4 dataflow, 3 output and 1 more

    signature tests

    Call edges for error, Calling with a constant function, Calling with constant argument

    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()()

  • #Infix Calls538 tests278 slice, 201 dataflow, 69 desugar and 1 more

    signature tests

    all variables, compare condition, all same variables

    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/primitives13 tests13 slice, 2 output

    signature tests

    redefine in local scope, redefining assignments should work

    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 effects59 tests34 slice, 25 dataflow, 5 output

    signature tests

    Sink, Effects by pdf, Removing breaks link

    A call that changes state the rest of the program reads without naming it, as setwd changes where a path points. Only the working directory is interpreted, while other ambient state such as the options stays an unknown side effect.

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

  • #Working Directory15 tests15 dataflow, 15 resolve

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

• #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 Access35 tests13 dataflow, 13 slice, 9 desugar and 1 more

    signature tests

    chained dollar, single constant, chained constant

    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 Access44 tests38 slice, 4 desugar, 3 output and 1 more

    signature tests

    double constant, One Constant, Empty

    The [[ call, as in x[[i]] or x[[i, b]]. Read like single-bracket access, without modelling the difference in what R returns.

    R DefinitionIndexingAdvanced RSelecting a single element

    example

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

  • #Dollar Access33 tests18 slice, 13 dataflow, 11 output and 1 more

    signature tests

    dollar constant, chained mixed constant, nested assign

    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.

    R DefinitionOperators

    example

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

  • #Slot Access2 tests1 dataflow, 1 desugar

    signature tests

    at constant, Slot based access

    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, Empty Access, Multiple with 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 Operator14 tests7 dataflow, 7 desugar

    signature tests

    ? x, Comment Breaks for Unary

    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 Operator542 tests277 slice, 206 dataflow, 69 desugar 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

      1 %xx% 2, Must work with assigned custom pipes too, must link alias with namespace

      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 Formula14 tests7 desugar, 4 output, 4 slice and 1 more

      signature tests

      simple formula, Comment Breaks for Unary, call in the lhs of a formula

      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, single, nesting

      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 Assignment389 tests275 slice, 116 dataflow, 60 output and 1 more

        signature tests

        quoted definition, Loop Definitions, dominating definition after the if is the only loop-back origin

        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 Assignment19 tests7 dataflow, 6 desugar, 6 slice

        signature tests

        "1 -> x -> y", "x <- 1 -> y", local define with -> in function, read after

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

        Advanced RBinding basics

      • #Local Equal Assignment21 tests10 dataflow, 6 desugar, 5 slice

        signature tests

        local define with = in function, read after, redefining assignments should work, Manual Max Function

        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 Assignment12 tests5 desugar, 4 slice, 3 dataflow

        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 Assignment55 tests31 slice, 20 dataflow, 19 output and 1 more

        signature tests

        Nested Global Assignments, `<<-` escapes through nested calls, default-argument promise `<<-` escapes

        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 Assignment10 tests6 desugar, 4 dataflow

        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 Assignments24 tests18 dataflow, 6 slice

        signature tests

        "x <- y <- z", Nested Global Assignments, Repeat

        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 Functions459 tests284 slice, 152 dataflow, 62 output and 1 more

        signature tests

        global assign (no envir) is unchanged, "x <- y <- z", simple assign

        Bind a name given as a string, with assign, delayedAssign, ... The name has to be a resolvable string, and what a delayed assignment does when forced is not modelled.

        assign("x", 3)
        delayedAssign("y", x * 2)
        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 Functions23 tests13 slice, 10 dataflow, 9 output

        signature tests

        work with s3, nested assign, assign on access

        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. 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

        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-Flow14 tests13 slice, 8 output, 3 dataflow

  signature tests

  useless branch I, useless branch II, useless branch (complete graph)

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

  9 children810

  • #if140 tests62 dataflow, 52 desugar, 28 slice and 1 more

    signature tests

    useless branch I, useless branch II, completely constant

    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 loop51 tests31 slice, 19 dataflow, 6 output and 1 more

    signature tests

    a loop body still calls, Single-vector for Loop, simple constant for-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 i stays bound after the loop.

    R DefinitionLooping

    example

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

  • #while loop41 tests20 slice, 17 dataflow, 4 desugar and 1 more

    signature tests

    a loop body is evaluated, Endless while loop with variables, Loop Definitions

    The loop while (x) b, whose condition is read before every iteration. Whether the body ever runs is unknown, so a name it binds and the one bound before it both reach a use below.

    R Definitionwhile

    example

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

  • #repeat loop23 tests13 slice, 10 dataflow, 2 desugar

    signature tests

    repeat with body, simple constant repeat, Next

    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.

    R Definitionrepeat

    example

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

  • #break15 tests7 dataflow, 7 slice, 2 desugar and 1 more

    signature tests

    Break in condition (for), Break in condition (while), Break in condition (repeat)

    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)
    }

  • #next6 tests3 dataflow, 3 slice, 2 desugar

    signature tests

    Next, Next (while), 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)
    }

  • #switch1 test1 slice

    signature tests

    Switch with named arguments

    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.

    R DefinitionControl structures

    example

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

  • #return41 tests36 slice, 5 dataflow

    signature tests

    return parameter named, read of parameter in return, simple 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 Errors78 tests59 dataflow, 12 output, 12 slice and 2 more

    signature tests

    Call edges for error, Call edges for error with fn, Call edges with may built-in

    A condition raised with stop/warning and caught with try/tryCatch. The path on which a call throws before a write is not kept open, so tryCatch({ risky(); x <- 2 }, ...) loses x. A handler is read as an ordinary function definition.

    R DefinitionException handlingAdvanced RConditions

    example

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

  show 1 more
• #Function Definitions60 tests30 call-graph, 18 slice, 12 dataflow and 1 more

  signature tests

  Registration with setGeneric, Simple S7 Generic Registration, Simple S7 Generic Method and Call

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

  7 children610

  • #Normal174 tests124 slice, 51 output, 41 dataflow and 1 more

    signature tests

    unknown read in function, call on.exit at the end, on.exit closure reads last value

    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

  • #Formals

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

    4 children310

    • #Named81 tests52 slice, 22 dataflow, 15 output and 1 more

      signature tests

      read of parameter, read of one parameter, return parameter named

      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

    • #Default26 tests20 slice, 11 output, 7 dataflow and 1 more

      signature tests

      Read first parameter, sibling parameter default sees later body reassignment, default-argument promise `<<-` escapes

      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-Dot10 tests5 dataflow, 3 desugar, 3 slice

      signature tests

      parameter shadows, Return ..., redefining {

      The variadic parameter ..., which collects every argument no other formal took. Passing it on keeps those arguments together, 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)

    • #Promises12 tests7 dataflow, 5 slice, 4 output

      signature tests

      Parameters binding context, Late bindings of parameter in body, Late bindings of parameter in parameters

      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 Return173 tests130 slice, 49 dataflow, 38 output

    signature tests

    parameter shadows, read of parameter, Read first parameter

    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+6 tests5 dataflow, 2 slice

    signature tests

    Calling with constant argument using lambda, assign in condition, global definition

    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.

  13 children2110

  • #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+29 tests20 dataflow, 6 slice, 3 desugar-shell and 2 more

    signature tests

    With %>%, With %<>%, Basic Pipe

    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

    Overwrite in For-Loop

    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))

  • #Options1 test1 slice

    signature tests

    Configuring options

    The global options options sets and getOption reads. Option values are not tracked, so getOption("digits") does not reach a preceding options(digits = 3). Unlike the working directory they are not interpreted at all.

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

  • #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

    map2, simple map, across with user fn

    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 Structure1 test1 output, 1 slice

      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 Structure4 tests4 output, 4 slice

      Rewrite a part of a function with body<-, formals<-, or environment<-. Like every replacement function it rebinds the name, so a later call reaches the new part as well as the original one.

      R DefinitionManipulation of functions

      example

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

    • #Quoting27 tests25 dataflow, 2 slice, 1 output

      signature tests

      quoted call, substituted call, quoted definition

      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)

    • #Evaluation55 tests37 dataflow, 19 slice, 6 output

      signature tests

      an evaluated capture is no longer marked as unevaluated, cli_abort stays an error exit rather than a template, eval with an unresolvable expr is an unknown side effect

      Run an expression that is a value with eval, evalq, eval.parent, ... eval(expr, envir) runs in an environment we may not know, so it is marked an unknown side effect.

      R DefinitionEvaluation of expressionsAdvanced REvaluation

      example

      e <- quote(x + 1)
      x <- 2
      eval(e)

    • #String Templates15 tests13 dataflow, 2 output, 2 slice

      signature tests

      cli_abort stays an error exit rather than a template, every interpolation of one template gets a vertex of its own

      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}")

    • #Parsing2 tests2 dataflow

      signature tests

      simple eval use, simple eval use - from 2 variables

      Turn text into an expression with parse, 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"))
      deparse(quote(x + y))

• #Literal Values

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

  7 children700

  • #Numbers599 tests277 slice, 172 desugar-shell, 165 desugar-tree-sitter and 2 more

    signature tests

    built-in constant, two files, simple constant repeat

    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

    • #Complex3 tests3 desugar

      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

  • #Strings135 tests74 slice, 38 desugar, 26 dataflow and 1 more

    signature tests

    built-in vector constant, missing source, conditional

    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+6 tests6 desugar

      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+]"

  • #Logical107 tests56 desugar, 35 dataflow, 16 slice and 1 more

    signature tests

    completely constant, simple constant while, 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

  • #NULL2 tests1 dataflow, 1 slice

    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 Masking10 tests10 dataflow

  signature tests

  a classed closure in a mask keeps its read, a masked name the caller binds reads the data as well

  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

  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 Functions2 tests2 query

  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")

• #Hooks15 tests12 dataflow, 3 call-graph

  signature tests

  call on.exit at the end, on.exit closure reads last value, call on.exit with stuff afterward

  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, while setHook is not modelled.

  Advanced Ron.exitR Definitionuserhooks

  example

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

• #Precedence33 tests32 slice, 4 output, 1 dataflow

  signature tests

  def compare in loop, Must work with assigned custom pipes too, if-then

  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

• #Attributes

  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

    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

    useless branch I, useless branch II, Call edges with may built-in

    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 fully9 partially1 not

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

• #S319 tests10 output, 10 slice, 8 dataflow and 1 more

  signature tests

  Simple S3 dispatch, Respect Later-Defs, Two-Targets S3 dispatch

  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

  • #Dispatch8 tests8 dataflow

    signature tests

    Simple S3 dispatch, Respect Later-Defs, Two-Targets S3 dispatch

    Route a generic call to the method that runs. UseMethod links to every definition named generic.class in scope, so the class an object carries narrows the target only where it is known (heavily over-approximating).

    R DefinitionUseMethodR DefinitionMethod dispatching

  • #Inheritance1 test1 dataflow

    signature tests

    Simple S3 dispatch with NextMethod

    Walk the class vector with NextMethod. It reaches the generic's methods, the one it stands in included, rather than only the next class in the vector.

    R DefinitionNextMethodR DefinitionInheritance

• #S412 tests7 output, 7 slice, 5 dataflow

  signature tests

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

  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 children111

  • #Class Construction2 tests2 dataflow

    signature tests

    S4 new reads its class registration, S4 setClass reads the class it extends

    Declare a class with setClass and build one with new. The new call is linked to the setClass that declared the class, and a slot is read through @ like any other access.

    R DefinitionClasses

  • #Dispatch2 tests2 dataflow

    signature tests

    S4 setMethod, S4 setMethod reads the generic it answers

    Route a generic call to the method setMethod registered. The generic reaches its methods through the chain they register in, but the signature does not narrow which of them runs, as no type is inferred for the argument.

    R DefinitionMethod dispatching

  • #Inheritance1 test1 dataflow

    signature tests

    S4 setClass reads the class it extends

    Reach a parent method with callNextMethod, and inherit through contains. callNextMethod is left unresolved, so nothing links it to the method it would call, unlike S3 inheritance.

    R DefinitionInheritance

• #RC/R52 tests1 dataflow, 1 output, 1 slice

  Reference classes made with setRefClass, whose objects are mutable and thus behave like the shared environments they are built on. $new() and $method() on an instance are unknown side effects, and no call links to the body it runs.

  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)

• #R6

  Classes made with R6::R6Class, read as one unit rather than as the environment behind them. Like RC an R6 object is mutable, and typing, inheritance, private/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

  Registration with setGeneric, Simple S7 Generic Registration, Simple S7 Generic Method and Call

  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

  simple line comment, With comments in parameter, single

  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

• #Semicolons62 tests32 dataflow, 28 slice, 6 output and 1 more

  signature tests

  loop-variable redefined within loop, Next, Next (while)

  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

• #Newlines359 tests271 slice, 87 dataflow, 66 output and 2 more

  signature tests

  directly together, multiple occurrences of same variable, reads within local expression

  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 Errors3 tests3 linter

  signature tests

  unbalanced brace, missing closing parenthesis, valid code has no syntax errors

  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

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

  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

9 fully4 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

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

    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

  • #NAMESPACE3 tests

    signature tests

    Functions are exported, Imports are registered correctly, 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.

  5 children410

  • #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

  • #Installed Library2 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

    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

• #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)

All categories

System, I/O, FFI, and Other Files

0 fully9 partially0 not

Everything a program reaches for beyond its own code, from files it sources to calls it makes out of R.

• #Sourcing External Files12 tests8 dataflow, 7 slice

  signature tests

  missing source, conditional, multiple source

  Pull another file's code into the analysis with source, sys.source, ... A sourced file's top-level bindings become visible to the code below the call. Only source is handled so far, and only where its path resolves.

  source("helpers.R")
  sys.source("setup.R", envir = environment())

• #Handling Binary Files2 tests1 output, 1 slice

  signature tests

  a source package is tagged as data and states its objects with the ty...

  Files a program writes objects to and reads them back from, with save, load, readRDS, ... A load binds names we cannot know, so neither the names nor the values behind them are reconstructed.

  R Definitionsave

  example

  save(x, file = "x.RData")
  load("x.RData")
  readRDS("y.rds")

• #I/O3 tests3 output, 3 slice

  Reading and writing data files with read.csv, write.csv, ... What a file contains does not enter the analysis, which is also why the columns of a data frame stay unknown.

  R DefinitionOperating system access

  example

  d <- read.csv("in.csv")
  write.csv(d, "out.csv")

• #Foreign Function Interface1 test1 query

  Calling out to compiled code with .C, .Call, .External, .Fortran, ... The call carries an unknown side effect, like a write through a shared environment, and the foreign code itself is not analyzed.

  .Call("my_c_fn", 1)
  .Fortran("my_f_sub", x = 1)

• #System Calls1 test1 linter

  signature tests

  unknown system

  Handle system, system.*, ... An injectable command built from user input is flagged by the problematic-inputs and unescaped-arguments rules.

  R DefinitionOperating system access

  example

  system("ls -la")
  system2("git", c("status"))

• #R-Markdown files2 tests

  Support R-Markdown files as R sources. Code chunks are extracted, but not inline r expr or the params of the YAML front matter.

  R Markdown

• #Jupyter Notebook1 test

  Support Jupyter Notebooks as R sources. Cells are read in document order, not execution order, and the kernel is not checked.

  Jupyter Notebook Format

• #Quarto1 test

  Support Quarto files as R sources. Code chunks are extracted, but not inline r expr or the params of the YAML front matter.

  Quarto

• #Sweave10 tests

  signature tests

  unnamed

  Support for Sweave files as R sources. Code chunks are extracted, \Sexpr{} inline expressions are not.

  Sweave

All categories

Types

0 fully1 partially3 not

What a value is, how we infer it from the code, and the coercions R applies between types.

• #Primitive2 tests2 query

  The atomic types numeric, character, logical, ... typeof, class, and mode are not evaluated and resolve to the unknown top value, so not even a literal yields its type.

  R DefinitionBasic types

  example

  typeof(1L)
  class(1)
  mode("a")

• #Non-Primitive1 test1 query

  The composite types a list, a data frame, or an object has. None of them is tracked, so class(list(1, 2)) resolves to the unknown top value.

  R DefinitionVector objects

• #Inference1 test1 query

  Derive the type of an expression from the code that produces it. A type predicate never narrows a branch, so if(is.numeric(1)) y <- 1 else y <- "a" still leaves y as both alternatives.

• #Coercion3 tests3 query

  The type R silently converts a value to, as c(1, "a") or TRUE + 1 do. A vector is not unified, so c(1, "a") keeps a number beside a string, and the as.* converters are not evaluated.

  R DefinitionBasic types

  example

  c(1, "a")
  TRUE + 1
  as.integer("3")