ReadonlyastReadonlydataflowReadonlylinesReadonlystatementsthe top-level statements, in order
Readonlytargetthe top-level assignments name <- value that are the only statement on their line, see lineByLine
the line and name of the criterion
Whether every line is whole: no statement continues on the next line and nothing but statements, separated
by ;, is written on a line. A comment is no statement, so a line holding one is not whole either.
the string literals in double quotes that hold no escape, in the order they are written
whether some call reads code as it is written or the frame it runs in, like quote(x), substitute(x), or match.call()
Whether the program may read a name as data, so renaming a variable would change what it finds: a call that
looks a name up or binds one by its spelling (get, assign, exists), reads code as written, or dispatches by name.
Whether the program depends on the frame its statements run in, so moving them into another (local({...}))
changes what they do: a call that binds or removes names (assign, rm), evaluates code in an environment,
or reads its frame (environment()), and any super-assignment.
Staticargumentsthe arguments of a call, undefined for an empty one
Staticiswhether node is an assignment of any kind, <-, =, ->, <<- or ->>
StaticisStaticiswhether node is all the left side of a pipe takes: a name, a constant, a call, or a range of them (see ?Syntax)
Staticofwhether a package the program attaches exports name, whose binding R locks against a <<-
how call names what it calls, with the namespace it may give (stats::filter)
what the built-in configuration states about the call, undefined for a call of something the program defines
the calls below node, the operators and accesses R calls as functions included
Optionalnode: RNodeWithParentwhether the condition is a single logical, so that negating it swaps the branches and nothing else
Whether call can be made another way, through do.call or with an argument wrapped, without the callee
noticing: flowR processes it as any call and the callee only uses the values of its arguments. A function the
program defines qualifies where it neither quotes a parameter nor asks whether one was supplied.
Whether evaluating node computes a value and nothing else, as flowR states of every call within it: no
assignment, and only calls of built-ins stated CallProp.Pure without an impure tag. A function
definition is a value, whatever its body does once called.
whether a call takes name as a name it deparses (save(x)), which a non-syntactic name breaks
every node below node (the whole program if there is none) in the order they are written
Optionalnode: RNodeWithParentwhere name is written in the program, as the flowR search finds it
whether R prints nothing for statement at the top level: an assignment, a loop, or a call returning invisibly
the code between the given positions, both inclusive
whether a string literal spells name out, so a renaming would leave it behind
whether a call reads node as it is written rather than for its value, like the package in library("x")
the token node is made of, the name of a call rather than the call
A program to mutate, as flowR sees it: the statements of its normalized AST, the dataflow graph, and what the built-in configuration states about the calls it makes. Passes ask this instead of reading the code as text.