Skip to content

Capabilities

Jump to bottom
github-actions[bot] edited this page Sep 3, 2026 · 1 revision

Generated from 'doc-capabilities.ts' on 2026-09-03, 22:43:54 UTC (v2.15.8, R v4.5.0), please do not edit directly.

Each capability has an id that can be used to link to it (use the link symbol to get a direct link to the capability). The internal id is also mentioned in the capability description. This id can be used to reference the capability in a labeled test within flowR. Besides, we use colored bullets like this:
🟩 flowR is capable of handling this feature fully
🔶 flowR is capable of handling this feature partially
🔴 flowR is not capable of handling this feature

☁️ This could be a feature diagram... ☁️

Note

The capabilities are a qualitative measure of the features that flowR can handle. Statements like "flowR can fully handle 50/80 capabilities" are discouraged as the capabilities may have a vastly different granularity. Please prefer using a statement like "flowR has only partial support for feature 'XY'" (or simply reference this document) within the flowR sources.

  1. Names and Identifiers 🔗
    The recognition of syntactical and non-syntactical names, including their resolutions to corresponding definitions. (internal ID: names-and-identifiers)

    Consider the following R code:

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

    Identifiers of interest are:

    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*`"]
    6(["`**#34;x#34;** (L. 1)
*RString*`"])
    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
    6 -->|"reads"| 1
    8 -->|"reads, returns, arg"| 6
    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;
    Loading
    R Code of the (simplified) Dataflow Graph

    The analysis required 2.2 ms (including parse and normalize, using the tree-sitter engine) within the generation environment. No signature database is mounted for these generated graphs, so library() calls attach no package exports; base-R names are still qualified via the generated base-package store (e.g. acf as stats::acf). We encountered unknown side effects (with ids: 23 (linked)) during the analysis.

    "f" <- function(x) { get("x") } 
`y x` <- 2
print(`y x` + f(3))
    23 children (7 fully, 15 partially, 1 not supported)

    1. Form 🔗
      (internal ID: form)

      4 children (3 fully, 1 partially, 0 not supported)
      1. Normal 🔗 (959 tests, slice: 339, resolve: 1, desugar-tree-sitter: 65, desugar-shell: 66, dataflow: 277, and backed with output: 63)
        🟩 Recognize symbol uses like a, plot, ... (i.e., "normal variables or function calls").
        See Advanced R/Bindings and R Definition/Identifiers for more info. (internal ID: name-normal)
      2. Quoted 🔗 (19 tests, slice: 16, desugar: 3, and backed with output: 6)
        🟩 Recognize "a", 'plot', ... In general, R allows to envelop names in quotations to allow for special characters such as spaces in variable names. However, this only works in the context of definitions. To access these names as variables, one has to either use function such as get or escape the name with backticks.
        See Advanced R/Non-Syntactic Names for more info. (internal ID: name-quoted)
      3. Escaped 🔗 (19 tests, slice: 11, dataflow: 8, and backed with output: 1)
        🟩 Recognize `a`, `plot`, ...
        See Advanced R/Non-Syntactic Names for more info. (internal ID: name-escaped)
      4. Created 🔗 (33 tests, slice: 19, dataflow: 14)
        🔶 Recognize functions which resolve strings as identifiers, such as get, ...
        See flowr#633 for more info. (internal ID: name-created)

    2. Resolution 🔗 (29 tests, dataflow: 1, call-graph: 28)
      (internal ID: resolution)

      19 children (4 fully, 14 partially, 1 not supported)

      1. Global Scope 🔗 (19 tests, slice: 8, and backed with output: 4)
        🟩 For example, tracking a big table of current identifier bindings (internal ID: global-scope)

      2. Lexicographic Scope 🔗 (38 tests, slice: 14, dataflow: 11, and backed with output: 4)
        🟩 For example, support function definition scopes (internal ID: lexicographic-scope)

      3. Closures 🔗 (33 tests, slice: 23, dataflow: 10, and backed with output: 4)
        🔶 Handling function factories and friends. Currently, we do not have enough tests to be sure. (internal ID: closures)

      4. Dynamic Environment Resolution 🔗 (77 tests, slice: 17, dataflow: 60)
        🔶 For example, using new.env and friends. Supports new.env/new.environment/rlang::new_environment, assign/get/local with envir=, dollar-sign access (e$x), attach, with/within, and env-variable aliasing (alias <- e). Static parent-argument resolution (parent = e, parent = emptyenv()) is supported. (internal ID: dynamic-environment-resolution)

        6 children (0 fully, 6 partially, 0 not supported)
        1. Environment in Conditionals 🔗 (6 tests, slice: 1, dataflow: 5)
          🔶 Tracking environment assignments and reads across if-then-else branches. flowR propagates envState through branch merging, but cross-branch name resolution inside the env is not guaranteed. (internal ID: environment-in-conditionals)
        2. Environment in Loops 🔗 (4 tests, dataflow: 4)
          🔶 Tracking environment assignments inside loop constructs (for, while, repeat). The env variable is correctly attributed in each iteration body, but dynamic key generation (e.g., paste0) prevents static name resolution. (internal ID: environment-in-loops)
        3. Environment Parent 🔗 (6 tests, slice: 1, dataflow: 5)
          🔶 Specifying a parent for a newly-created environment (new.env(parent = e), new.env(parent = emptyenv())). Tracked-env-variable parents and emptyenv()/NULL are resolved statically; dynamic or unknown parents fall back to the default (parent.frame()). (internal ID: environment-parent)
        4. Environment Alias 🔗 (9 tests, slice: 2, dataflow: 7)
          🔶 Aliasing a tracked environment variable (alias <- e). The envState snapshot at assignment time is propagated, so assigns made BEFORE the alias are visible through it. Assigns made AFTER the alias to the original variable are not reflected. (internal ID: environment-alias)
        5. With / Within 🔗 (8 tests, slice: 5, dataflow: 3)
          🔶 Evaluating an expression inside a named environment with with(data, expr) or within(data, expr). When data is a tracked env variable, reads of names defined in that env resolve correctly. Writes inside expr are ephemeral (not persisted back to the env). (internal ID: environment-with)
        6. Dynamic Variable Removal 🔗 (19 tests, dataflow: 19, and backed with output: 2)
          🔶 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. (internal ID: dynamic-variable-removal)

      5. Environment Sharing 🔗 (27 tests, slice: 7, dataflow: 20)
        🔴 Handling side-effects by environments which are not copied when modified (internal ID: environment-sharing)

      6. Search Type 🔗 (4 tests, slice: 2)
        🟩 Separating the resolution for functions and symbols. (internal ID: search-type)

      7. Search Path 🔗 (85 tests, dataflow: 85)
        🔶 Handling R's search path as explained in Advanced R. Attached packages and attached environments are placed below .GlobalEnv (so global bindings shadow package exports, matching R), attaching inside/through function calls propagates to the caller, and re-attaching is a no-op. Not yet handled: dynamic search/fn_env manipulation. (internal ID: search-path)

      8. Namespaces 🔗 (11 tests, slice: 1, dataflow: 10)
        🔶 Handling R's namespaces as explained in Advanced R (internal ID: namespaces)

      9. Accessing Exported Names 🔗 (7 tests, slice: 3, desugar: 4)
        🔶 Resolving calls with :: to their origin. Accessing external files is allowed, although the name of packages etc. is not resolved correctly. (internal ID: accessing-exported-names)

      10. Accessing Internal Names 🔗
        🔶 Similar to :: but for internal names. (internal ID: accessing-internal-names)

      11. Library Loading 🔗 (87 tests, slice: 1, dataflow: 86)
        🔶 Resolve libraries identified with library, require, attachNamespace, ... and attach them to the search path (internal ID: library-loading)

      12. Dynamic Scope Changes 🔗 (1 test, dataflow: 1)
        🔶 Manually changing scopes like local (internal ID: dynamic-scope-changes)

      13. Anonymous Bindings 🔗 (3 tests, dataflow: 1, call-graph: 2)
        🟩 Support for Recall (internal ID: anonymous-bindings)

  2. Expressions 🔗
    (internal ID: expressions)

    71 children (49 fully, 16 partially, 6 not supported)

    1. Function Calls 🔗 (726 tests, slice: 313, resolve: 1, desugar: 106, dataflow: 274, call-graph: 31, and backed with output: 55)
      (internal ID: function-calls)

      65 children (43 fully, 16 partially, 6 not supported)

      1. Grouping 🔗 (146 tests, slice: 22, desugar: 111, dataflow: 13, and backed with output: 12)
        🟩 Recognize groups done with (, {, ... (more precisely, their default mapping to the primitive implementations). (internal ID: grouping)

      2. Normal Call 🔗 (223 tests, slice: 180, desugar-tree-sitter: 22, desugar-shell: 23, dataflow: 20, and backed with output: 47)
        🟩 Recognize and resolve calls like f(x), foo::bar(x, y), ... (internal ID: call-normal)

        7 children (5 fully, 2 partially, 0 not supported)
        1. Unnamed Arguments 🔗 (282 tests, slice: 220, desugar: 3, dataflow: 59, and backed with output: 42)
          🟩 Recognize and resolve calls like f(3), foo::bar(3, c(1,2)), ... (internal ID: unnamed-arguments)
        2. Empty Arguments 🔗 (7 tests, slice: 4, desugar: 1, dataflow: 2)
          🟩 Essentially a special form of an unnamed argument as in foo::bar(3, ,42), ... (internal ID: empty-arguments)
        3. Named Arguments 🔗 (55 tests, slice: 37, desugar-tree-sitter: 3, desugar-shell: 4, dataflow: 14, and backed with output: 13)
          🟩 Recognize and resolve calls like f(x = 3), foo::bar(x = 3, y = 4), ... (internal ID: named-arguments)
        4. String Arguments 🔗 (9 tests, desugar: 9)
          🟩 Recognize and resolve calls like f('x' = 3), foo::bar('x' = 3, "y" = 4), ... (internal ID: string-arguments)
        5. Resolve Arguments 🔗 (98 tests, slice: 33, dataflow: 37, call-graph: 28)
          🟩 Correctly bind arguments (including pmatch). Currently, we do not have a correct implementation for pmatch. Furthermore, more tests would be nice. (internal ID: resolve-arguments)
        6. Side-Effects in Argument 🔗 (2 tests, slice: 1, dataflow: 1)
          🔶 Handle side-effects of arguments (e.g., f(x <- 3), f(x = y <- 3), ...). We have not enough tests to be sure (internal ID: side-effects-in-argument)
        7. Side-Effects in Function Call 🔗 (23 tests, slice: 14, dataflow: 9, and backed with output: 5)
          🔶 Handle side-effects of function calls (e.g., setXTo(3), ...) for example achieved with the super assignment. We need more tests and handlings. Furthermore, we do not detect side effects with external files, network, logging, etc. (internal ID: side-effects-in-function-call)

      3. Recursion 🔗 (4 tests, call-graph: 4)
        🟩 Recognize and resolve recursive calls like f(3) inside the definition of f, ... (internal ID: recursion)

      4. Anonymous Calls 🔗 (9 tests, slice: 3, desugar: 2, dataflow: 4)
        🟩 Recognize and resolve calls like (function(x) x)(3), factory(0)(), ... (internal ID: call-anonymous)

      5. Infix Calls 🔗 (618 tests, slice: 312, desugar: 103, dataflow: 203, and backed with output: 55)
        🟩 Recognize and resolve calls like x + y, x %>% f(y), ... (internal ID: infix-calls)

      6. Redefinition of Built-In Functions/primitives 🔗 (12 tests, slice: 12, and backed with output: 1)
        🔶 Handle cases like print <- function(x) x, `for` <- function(a,b,c) a, ... Currently, we can not handle all of them there are no tests. Still wip as part of desugaring (internal ID: redefinition-of-built-in-functions-primitives)

      7. Functions with global side effects 🔗 (54 tests, slice: 30, dataflow: 24, and backed with output: 2)
        🔶 Support functions like setwd which have an impact on the subsequent program. (internal ID: functions-with-global-side-effects)

      8. Working Directory 🔗 (15 tests, resolve: 15, dataflow: 15)
        🔶 Track the effective working directory across setwd (control-flow- and location-sensitive) to resolve relative file paths. Interprocedural, sourced, and loop cases are treated as unbounded rather than guessed. (internal ID: working-directory)

      9. Index Access 🔗
        (internal ID: index-access)

        7 children (7 fully, 0 partially, 0 not supported)
        1. Single Bracket Access 🔗 (35 tests, slice: 17, desugar: 9, dataflow: 9, and backed with output: 2)
          🟩 Detect calls like x[i], x[i, ,b], x[3][y], ... This does not include the real separation of cells, which is handled extra. (internal ID: single-bracket-access)
        2. Double Bracket Access 🔗 (43 tests, slice: 37, desugar: 4, dataflow: 2)
          🟩 Detect calls like x[[i]], x[[i, b]], ... Similar to single bracket. (internal ID: double-bracket-access)
        3. Dollar Access 🔗 (24 tests, slice: 9, desugar: 2, dataflow: 13)
          🟩 Detect calls like x$y, x$"y", x$y$z, ... (internal ID: dollar-access)
        4. Slot Access 🔗 (2 tests, desugar: 1, dataflow: 1)
          🟩 Detect calls like x@y, x@y@z, ... (internal ID: slot-access)
        5. Access with Argument-Names 🔗 (3 tests, slice: 2, desugar: 1)
          🟩 Detect calls like x[i = 3], x[[i=]], ... (internal ID: access-with-argument-names)
        6. Access with Empty 🔗 (4 tests, desugar: 4)
          🟩 Detect calls like x[], x[2,,42], ... (internal ID: access-with-empty)
        7. Subsetting (Multiple Indices) 🔗 (4 tests, slice: 4)
          🟩 Detect calls like x[i > 3], x[c(1,3)], ... (internal ID: subsetting-multiple)

      10. Operators 🔗 (4 tests, dataflow: 4)
        (internal ID: operators)

        15 children (11 fully, 3 partially, 1 not supported)

        1. Unary Operator 🔗 (14 tests, desugar: 7, dataflow: 7)
          🟩 Recognize and resolve calls like +3, -3, ... (internal ID: unary-operator)

        2. Binary Operator 🔗 (621 tests, slice: 310, desugar: 103, dataflow: 208, and backed with output: 55)
          🟩 Recognize and resolve calls like 3 + 4, 3 * 4, ... (internal ID: binary-operator)

          13 children (9 fully, 3 partially, 1 not supported)

          1. Special Operator 🔗 (14 tests, slice: 11, desugar: 1, dataflow: 2)
            🟩 Recognize and resolve calls like 3 %in% 4, 3 %*% 4, ... (internal ID: special-operator)

          2. Model Formula 🔗 (14 tests, slice: 4, desugar: 7, dataflow: 3, and backed with output: 4)
            🔶 Recognize and resolve calls like y ~ x, y ~ x + z, ... including their implicit redefinitions of some functions. Currently, we do not handle their redefinition and only treat model formulas as normal binary operators (internal ID: model-formula)

          3. Assignments and Bindings 🔗 (7 tests, slice: 7, and backed with output: 4)
            (internal ID: assignments-and-bindings)

            11 children (8 fully, 2 partially, 1 not supported)
            1. Local Left Assignment 🔗 (433 tests, slice: 311, desugar: 8, dataflow: 114, and backed with output: 59)
              🟩 Handle x <- 3, x$y <- 3, ... (internal ID: local-left-assignment)
            2. Local Right Assignment 🔗 (19 tests, slice: 6, desugar: 6, dataflow: 7)
              🟩 Handle 3 -> x, 3 -> x$y, ... (internal ID: local-right-assignment)
            3. Local Equal Assignment 🔗 (23 tests, slice: 5, desugar: 6, dataflow: 12)
              🟩 Handle x = 3, x$y := 3, ... (internal ID: local-equal-assignment)
            4. Local Table Assignment 🔗 (12 tests, slice: 4, desugar: 5, dataflow: 3)
              🟩 Handle x[,a:=3,], ... (internal ID: local-table-assignment)
            5. Super Left Assignment 🔗 (45 tests, slice: 17, desugar: 6, dataflow: 22, and backed with output: 5)
              🟩 Handle x <<- 42, x$y <<- 42, ... (internal ID: super-left-assignment)
            6. Super Right Assignment 🔗 (10 tests, desugar: 6, dataflow: 4)
              🟩 Handle 42 ->> x, 42 ->> x$y, ... (internal ID: super-right-assignment)
            7. Return Value of Assignments 🔗 (26 tests, slice: 8, dataflow: 18)
              🟩 Handle x <- 3 returning 3, e.g., in x <- y <- 3 (internal ID: return-value-of-assignments)
            8. Assignment Functions 🔗 (505 tests, slice: 317, desugar: 33, dataflow: 155, and backed with output: 59)
              🔶 Handle assign(x, 3), delayedAssign(x, 3), ... Currently we can not handle all of them and tests are rare. (internal ID: assignment-functions)
            9. Range Assignment 🔗 (2 tests, slice: 2)
              🟩 Handle x[1:3] <- 3, x$y[1:3] <- 3, ... (internal ID: range-assignment)
            10. Replacement Functions 🔗 (14 tests, slice: 9, dataflow: 5, and backed with output: 4)
              🔶 Handle x[i] <- 3, x$y <- 3, ... as `[<-`(x, 3), ... Currently work in progress as part of the desugaring but still untested. (internal ID: replacement-functions)
            11. Locked Bindings 🔗
              🔴 Handle lockBinding(x, 3), ... (internal ID: locked-bindings)

      11. Control-Flow 🔗 (16 tests, slice: 13, dataflow: 3, and backed with output: 8)
        (internal ID: control-flow)

        9 children (8 fully, 1 partially, 0 not supported)
        1. if 🔗 (152 tests, slice: 32, desugar: 52, dataflow: 68, and backed with output: 5)
          🟩 Handle if (x) y else z, if (x) y, ... (internal ID: if)
        2. for loop 🔗 (52 tests, slice: 31, desugar: 2, dataflow: 19, and backed with output: 5)
          🟩 Handle for (i in 1:3) print(i), ... (internal ID: for-loop)
        3. while loop 🔗 (46 tests, slice: 25, desugar: 4, dataflow: 17, and backed with output: 1)
          🟩 Handle while (x) b, ... (internal ID: while-loop)
        4. repeat loop 🔗 (26 tests, slice: 14, desugar: 2, dataflow: 10)
          🟩 Handle repeat {b; if (x) break}, ... (internal ID: repeat-loop)
        5. break 🔗 (15 tests, slice: 6, desugar: 2, dataflow: 7)
          🟩 Handle break (including break()) ... (internal ID: break)
        6. next 🔗 (8 tests, slice: 3, desugar: 2, dataflow: 3)
          🟩 Handle next (including next()) ... (internal ID: next)
        7. switch 🔗 (1 test, slice: 1)
          🟩 Handle switch(3, "a", "b", "c"), ... (internal ID: switch)
        8. return 🔗 (41 tests, slice: 36, dataflow: 5)
          🟩 Handle return(3), ... in function definitions (internal ID: return)
        9. Exceptions and Errors 🔗 (75 tests, slice: 8, dataflow: 60, controlflow: 6, call-graph: 1, and backed with output: 8)
          🔶 Handle try, stop, ... (internal ID: exceptions-and-errors)

      12. Function Definitions 🔗 (61 tests, slice: 19, dataflow: 12, call-graph: 30, and backed with output: 1)
        (internal ID: function-definitions)

        7 children (6 fully, 1 partially, 0 not supported)

        1. Normal 🔗 (176 tests, slice: 122, desugar: 12, dataflow: 41, and backed with output: 45)
          🟩 Handle function() 3, ... (internal ID: normal-definition)

        2. Formals 🔗
          (internal ID: formals)

          4 children (3 fully, 1 partially, 0 not supported)
          1. Named 🔗 (85 tests, slice: 56, desugar: 7, dataflow: 22, and backed with output: 14)
            🟩 Handle function(x) x, ... (internal ID: formals-named)
          2. Default 🔗 (28 tests, slice: 19, desugar: 2, dataflow: 7, and backed with output: 8)
            🟩 Handle function(x = 3) x, ... (internal ID: formals-default)
          3. Dot-Dot-Dot 🔗 (11 tests, slice: 3, desugar: 3, dataflow: 5)
            🟩 Handle function(...) 3, ... (internal ID: formals-dot-dot-dot)
          4. Promises 🔗 (10 tests, slice: 3, dataflow: 7)
            🔶 Handle function(x = y) { y <- 3; x }, function(x = { x <- 3; x}) { x * x }, ... A default argument resolves in the function's own environment and an argument passed in resolves in the caller's, both as R does it. We do not model when a promise is forced: a delayedAssigned expression is linked to every binding it may be forced against, which never misses the one that feeds it but may name others as well. What forcing does is not modelled either, so the writes a promise performs when it is forced (delayedAssign("x", { x <- 99; 2 }), where reading x yields 2 and leaves x at 99) do not reach the reads that follow. (internal ID: formals-promises)

        3. Implicit Return 🔗 (185 tests, slice: 136, dataflow: 49, and backed with output: 36)
          🟩 Handle the return of function() 3, ... (internal ID: implicit-return)

        4. Lambda Syntax 🔗 (7 tests, slice: 2, dataflow: 5)
          🟩 Support \(x) x, ... (internal ID: lambda-syntax)

      13. Important Built-Ins 🔗
        (internal ID: important-built-ins)

        12 children (1 fully, 6 partially, 5 not supported)

        1. Non-Strict Logical Operators 🔗 (29 tests, desugar: 20, dataflow: 9)
          🟩 Handle &&, ||, ... (internal ID: non-strict-logical-operators)

        2. Pipe and Pipe-Bind 🔗 (19 tests, slice: 2, desugar: 2, dataflow: 15)
          🔶 Handle the new (4.1) pipe and pipe-bind syntax: |>, and =>.; Similarly support the other pipe binds (internal ID: pipe-and-pipe-bind)

        3. Sequencing 🔗 (2 tests, slice: 2, and backed with output: 1)
          🔴 Handle :, seq, ... by gathering value information using abstract interpretation. (internal ID: built-in-sequencing)

        4. Internal and Primitive Functions 🔗 (1 test, slice: 1)
          🔶 Handle .Internal, .Primitive, ... In general we can not handle them as they refer to non-R code. We currently do not support them when used with the function. (internal ID: built-in-internal-and-primitive-functions)

        5. Options 🔗
          🔴 Handle options, getOption, ... Currently, we do not support the function at all. (internal ID: built-in-options)

        6. Help 🔗 (3 tests, desugar: 2, dataflow: 1)
          🔶 Handle help, ?, ... We do not support the function in a sensible way but just ignore it (although this does not happen resolved). (internal ID: built-in-help)

        7. Reflection / "Computing on the Language" 🔗 (10 tests, dataflow: 10)
          (internal ID: reflection-"computing-on-the-language")

          6 children (0 fully, 3 partially, 3 not supported)
          1. Get Function Structure 🔗
            🔴 Handle body, formals, environment to access the respective parts of a function. We do not support the functions at all. (internal ID: get-function-structure)
          2. Modify Function Structure 🔗
            🔴 Handle body<-, formals<-, environment<- to modify the respective parts of a function. We do not support the functions at all. (internal ID: modify-function-structure)
          3. Quoting 🔗 (26 tests, slice: 1, dataflow: 25)
            🔶 Handle quote, substitute, bquote, ... A quoted argument is marked as non-standard evaluation as a whole, so nothing within it counts as read. We model the escapes back to standard evaluation that a quoting function offers: rlang's !!/!!! (in expr, quo, enquo, ... and in data-masking arguments) and bquote's .(). Base quote/substitute have no such escape, and substitute does not reach the caller's expression when used on a function argument. (internal ID: built-in-quoting)
          4. Evaluation 🔗 (51 tests, slice: 14, dataflow: 37)
            🔶 Handle eval, evalq, eval.parent, ... eval of a string we can resolve is analyzed as if it were written in its place. A language object reaches the eval that forces it even across assignments, branches, loop iterations, and function calls, and its names resolve in the scope evaluating it, as R does. eval(expr, envir) runs elsewhere, so we mark the call as an unknown side effect instead of guessing. evalq quotes its first argument and we do not follow it into the given environment. (internal ID: built-in-evaluation)
          5. String Templates 🔗
            🔶 Handle glue::glue("{x}"), cli::cli_alert_info("{.val {x}}"), stringr::str_glue/str_interp, ... The {...} of a template carries R code that runs where the call is, so we analyze it as if it were written there: it reads, it writes, and its side effects land in the calling scope. Doubled delimiters escape, .open/.close are honored when they are literal, and cli markup ({.cls ...}) contributes only the interpolations nested in it. A template aimed at another scope (.envir, .con, glue_data) is marked as an unknown side effect instead. (internal ID: string-templates)
          6. Parsing 🔗
            🔴 Handle parse, deparse, ... We handle them as unknown function calls, but not specifically besides that. (internal ID: built-in-parsing)

    2. Literal Values 🔗
      (internal ID: literal-values)

      6 children (6 fully, 0 partially, 0 not supported)

      1. Numbers 🔗 (684 tests, slice: 313, desugar-tree-sitter: 199, desugar-shell: 207, dataflow: 164, and backed with output: 66)
        🟩 Recognize numbers like 3, 3.14, NA, float-hex, ... (internal ID: numbers)

      2. Strings 🔗 (143 tests, slice: 72, desugar: 45, dataflow: 26, and backed with output: 24)
        🟩 Recognize strings like "a", 'b', ... (internal ID: strings)

        1 child (1 fully, 0 partially, 0 not supported)
        1. Raw Strings 🔗 (7 tests, desugar: 7)
          🟩 Recognize raw strings like r"(a)", ... (internal ID: raw-strings)

      3. Logical 🔗 (116 tests, slice: 22, desugar: 56, dataflow: 38, and backed with output: 2)
        🟩 Recognize the logicals TRUE and FALSE, ... (internal ID: logical)

      4. NULL 🔗 (2 tests, slice: 1, dataflow: 1)
        🟩 Recognize NULL (internal ID: null)

      5. Inf and NaN 🔗 (3 tests, slice: 1, dataflow: 2)
        🟩 Recognize Inf and NaN (internal ID: inf-and-nan)

  3. Non-Standard Evaluations/Semantics 🔗
    (internal ID: non-standard-evaluations-semantics)

    7 children (1 fully, 2 partially, 4 not supported)

    1. Data Masking 🔗 (10 tests, dataflow: 10)
      🔶 Handle subset(d, col > 1), dplyr verbs, ggplot2::aes, data.table :=, ... In a masked argument, a name the caller binds is read as that variable and any other name is taken to come from the data. Which names a data frame actually offers is unknown to us, so a column shadowing a variable of the same name still resolves to the variable. rlang's !!/!!! and its := name-value pair are recognised; [ on a data.table does not mask its j/by yet. (internal ID: data-masking)

    2. Recycling 🔗
      🔴 Handle recycling of vectors as explained in Advanced R. We do not support recycling. (internal ID: recycling)

    3. Vectorized Operator or Functions 🔗
      🔴 Handle vectorized operations as explained in Advanced R. We do not support vectorized operations. (internal ID: vectorized-operator-or-functions)

    4. Hooks 🔗 (15 tests, dataflow: 12, call-graph: 3)
      🔶 Handle hooks like userhooks and on.exit. We support on.exit and rlang's on_load/run_on_load/on_package_load, whose expressions we analyze where they are registered. setHook and the other user hooks are not modelled. (internal ID: hooks)

    5. Precedence 🔗 (39 tests, slice: 38, dataflow: 1, and backed with output: 4)
      🟩 Handle the precedence of operators as explained in the Documentation. We handle the precedence of operators (implicitly with the parser). (internal ID: precedence)

    6. Attributes 🔗
      (internal ID: attributes)

      2 children (0 fully, 0 partially, 2 not supported)
      1. User-Defined 🔗
        🔴 Handle attributes like attr, attributes, ... We do not support attributes. (internal ID: user-defined)
      2. Built-In 🔗 (25 tests, slice: 7, dataflow: 7, call-graph: 11)
        🔴 Handle built-in attributes like dim, ... We do not support them. (internal ID: built-in)

  4. Types 🔗
    (internal ID: types)

    11 children (0 fully, 7 partially, 4 not supported)

    1. Primitive 🔗
      🔴 Recognize and resolve primitive types like numeric, character, ... We do not support typing currently. (internal ID: types-primitive)

    2. Non-Primitive 🔗
      🔴 Recognize and resolve non-primitive/composite types. We do not support typing currently. (internal ID: types-non-primitive)

    3. Inference 🔗
      🔴 Infer types from the code. We do not support typing currently. (internal ID: types-inference)

    4. Coercion 🔗
      🔴 Handle coercion of types. We do not support typing currently. (internal ID: types-coercion)

    5. Object-Oriented Programming 🔗
      (internal ID: object-oriented-programming)

      7 children (0 fully, 7 partially, 0 not supported)

      1. S3 🔗 (19 tests, slice: 10, dataflow: 8, call-graph: 1, and backed with output: 10)
        🔶 Handle S3 classes and methods as one unit (with attributes etc.). Including Dispatch and Inheritance. We do not support typing currently and do not handle objects of these classes "as units."
        See Advanced R/S3 for more info. (internal ID: oop-s3)

      2. S4 🔗 (12 tests, slice: 7, dataflow: 5, and backed with output: 7)
        🔶 Handle S4 classes and methods as one unit. Including Dispatch and Inheritance We do not support typing currently and do not handle objects of these classes "as units."
        See Advanced R/S4 for more info. (internal ID: oop-s4)

      3. R6 🔗
        🔶 _Handle R6 classes and methods as one unit. We do not support typing, inheritance, private/active bindings, or handling objects fully "as units."
        See Advanced R/R6 for more info. (internal ID: oop-r6)

      4. R7/S7 🔗 (5 tests, dataflow: 5)
        🔶 Handle R7 classes and methods as one unit. Including Dispatch and Inheritance, as well as its Reference Semantics, Validators, ... We do not support typing currently and do not handle objects of these classes "as units."
        See R7 and S7 for more info. (internal ID: oop-r7-s7)

      5. Class-Based Dependency Attribution 🔗
        🔶 Attribute the use of a class to the package that owns it (registers a method for it and exports a same-named constructor), so a class use implies a dependency for library detection and version guessing (backed by the signature database's class-ownership map). (internal ID: oop-class-dependency-attribution)

        2 children (0 fully, 2 partially, 0 not supported)
        1. S3 class ownership 🔗
          🔶 The signature database records which package owns each S3 class. A class use is attributed to the owning package -- both from a project's NAMESPACE S3method(generic, class) registrations (e.g. S3method("as.irts","zoo") marks zoo used) and from class-name string literals in plain code (inherits(x, "zoo"), methods::is, new, structure(..., class=)), marking the owner used and bounding its version below by the same-named constructor's export history. Class names that come from a variable or a c(...) vector, and method-definition names like print.zoo, are not yet resolved. (internal ID: class-owner-s3)
        2. S4 class ownership 🔗
          🔶 A project's importClassesFrom/importMethodsFrom NAMESPACE directives are tracked, so the source package is attached and marked used like a plain importFrom. S4 class ownership itself (exportClasses, setClass) is not yet recorded in the signature database, so a bare S4 class use is not attributed to its owning package. (internal ID: class-owner-s4)

  5. Structure 🔗
    (internal ID: structure)

    3 children (3 fully, 0 partially, 0 not supported)
    1. Comments 🔗 (19 tests, slice: 10, desugar-tree-sitter: 8, desugar-shell: 9, and backed with output: 3)
      🟩 Recognize comments like # this is a comment, ... and line-directives (internal ID: comments)
    2. Semicolons 🔗 (70 tests, slice: 33, desugar: 5, dataflow: 32, and backed with output: 4)
      🟩 Recognize and resolve semicolons like a; b; c, ... (internal ID: semicolons)
    3. Newlines 🔗 (400 tests, slice: 295, desugar: 11, dataflow: 94, and backed with output: 64)
      🟩 Recognize and resolve newlines like a b c, ... (internal ID: newlines)

  6. System, I/O, FFI, and Other Files 🔗
    (internal ID: system-i-o-ffi-and-other-files)

    9 children (1 fully, 4 partially, 4 not supported)
    1. Sourcing External Files 🔗 (15 tests, slice: 7, dataflow: 8)
      🔶 Handle source, sys.source, ... We are currently working on supporting the inclusion of external files. Currently we can handle source. (internal ID: sourcing-external-files)
    2. Handling Binary Riles 🔗
      🔴 Handle files dumped with, e.g., save, ... due to their frequent usage. We do not support binary files. (internal ID: handling-binary-riles)
    3. I/O 🔗
      🔴 Handle read.csv, write.csv, ... We do not support I/O for the time being but treat them as unknown function calls. (internal ID: i-o)
    4. Foreign Function Interface 🔗
      🔴 Handle .Fortran, C,... We do not support FFI but treat them as unknown function calls. (internal ID: foreign-function-interface)
    5. System Calls 🔗
      🔴 Handle system, system.*, ... We do not support system calls but treat them as unknown function calls. (internal ID: system-calls)
    6. R-Markdown files 🔗 (6 tests)
      🟩 Support R-Markdown files as R sources. (internal ID: file:rmd)
    7. Jupyter Notebook 🔗 (3 tests)
      🔶 Support Jupyter Notebooks as R sources. (internal ID: file:ipynb)
    8. Quarto 🔗 (3 tests)
      🔶 Support Quarto files as R sources. (internal ID: file:qmd)
    9. Sweave 🔗 (12 tests)
      🔶 Support for Sweave files as R sources. (internal ID: file:rnw)

  7. Pre-Processors/external Tooling 🔗
    🟩 Handle pre-processors like knitr, rmarkdown, roxygen2 ... We do not support pre-processors for the time being (being unable to handle things like @importFrom) (internal ID: pre-processors-external-tooling)

Currently maintained by Florian Sihler and Oliver Gerstl at Ulm University
Email | GitHub | Penguins | Portfolio

💮 flowR Home (Landing Page)

Clone this wiki locally