ConstReadonlyargumentRoles: (The roles of several definitions' formals, sharing the built-in lookups.
Readonlycall: {What one call of a function means: what flowR states about it, how R binds its arguments, and which of them it does not simply evaluate.
Readonlyargument: {The same as FunctionSemantics.call.props, for one argument.
Readonlymask: (names: readonly (...)[]) => numberThe mask the given ArgProp member names stand for; see maskOfNames.
Readonlyvocabulary: Readonly<Record<(...), (...)>>the ArgProp bits as words, in ascending bit order
Readonlywords: (props: (...) | (...)) => (...)[]What an argument is used for, as words; see wordsOf.
Readonlydeferred: {The ones it evaluates at a time flowR cannot pin down.
The reads that may be the one forcing binding: every read of it that no other read always precedes, since an earlier read would already have forced it and cached the value.
Where each name is bound and read, built once and shared by every deferred expression in the graph.
Links the expression rooted at expr to the bindings it may meet when it is evaluated.
Optionalforces: ForceSitesLinks the writes an expression performs to the uses that may observe them, for a call evaluating the expression at a point control flow can pin down (eval).
Optionalcfg: ControlFlowGraph<(...)>Readonlymatch: {R's argument matching -- exact, then partial, then positional.
Find all arguments of a function call that have a given argument property using the function signature.
The formal names a call binds against, whichever of flowR's sources knows them; see formalsOf.
Whether the call hands on the dots of the function it is in (g(...)), so that what it binds depends on the calls of that function, see MatchArgs.onCallAndLink.
Binds a call's graph args to the params of the definition it calls and mutates graph, adding an EdgeType.DefinesOnCall and a EdgeType.DefinedByOnCall edge per bound pair.
Binds a call's arguments to the formals of whatever it calls, looking the formals up itself.
Binds a call's AST args to the formal paramNames.
Binds a call's graph args against the formals, reading nothing from the graph, so it also serves a function whose parameters are not in the AST at all.
Leaves unforced what the known calls of a function hand to its dots that no read of the dots sees once they are handed on, as R never evaluates it: with f <- function(...) g(...) and g <- function(a, b) b, f(u, v) forces v only.
Readonlynse: {The arguments a call does not evaluate.
Drops the mask mark from names the caller binds to a value: while filter(d, k) is processed k has no
read yet. A name bound to a function keeps its mark, as filter(d, id > 2) next to id <- function(...)
still means the column. Hands back the masking call and the names it just unmarked, undefined when
name does not mask at all, so linkMasksToData need not ask a second time.
Links every name the data masks of calls supply to the data it comes from: id in filter(df, id > 2)
is a column of df, so it reads df. Run once every mark has settled, as adding the read makes
suppliedByMask false for the name; a call whose first argument is masked too has no data to link
against.
Whether the vertex is a name a data mask may supply, which is every name appearing in the mask.
Whether id is a name a data mask supplied, which the mark the masking call carries is what records.
Unlike suppliedByMask this survives linkMasksToData, so ask this one after the dataflow
is complete and that one while a call is still being processed.
Whether id is a name the data mask supplies, i.e. a use the caller does not bind itself.
Drops the non-standard-evaluation mark from the outgoing edges of id that which accepts, and reports them.
The ids an Unquote escape hands back to standard evaluation, the markers themselves excluded.
Readonlyprops: {What flowR states a call does (it reads a file, it asks the user, ...).
Keep only the properties in the stated properties that are in the property selector.
Whether stated properties carry every property of a selector.
Whether stated properties carry at least one property of a selector, or state anything about their behavior at all.
Optionalselector: PropSelectorChecks whether a PropSelector is a bitfield of CallProps.
Checks whether a PropSelector is a SemanticCallTag.
Joins the CallProps and SemanticCallTags of two stated properties. It merges the tags itself, as the array helpers would make loading the configuration expensive.
Transforms a property selector into a unique string identifier.
Gets the string labels for stated properties, see CallPropWords.
The PropMask the given CallProp/SemanticCallTag member names stand for, unknown ones ignored.
Gets the property names for a property selector.
Readonlyvocabulary: Readonly<Record<(...), (...)>>the CallProp bits as words, in the order they are declared
The CallPropWords for a bare CallProps bitfield, as inferred functions carry one.
Readonlyquoted: {The expressions it quotes instead.
The expressions a capturing call holds on to.
ReadonlyevaluateIn: <Info>(Links every name in expr against environment and hands back what stays unresolved.
What id within captured code needs to run at all: the capturing call and every call evaluating it (eval, body(f) <- quote(...)).
The finishing pass over a complete graph: it settles what a call really evaluates, which the call itself could not know.
Every expression the value at id may hold, with the call that captured it. Several is normal.
Readonlysignature: {The formals a built-in declares.
Readonlyevery: FnSigA signature saying only that the call evaluates every argument; see ForcingEvery.
Readonlyforced: (this: void, sig: (...) | (...), count: number) => (...) | (...)Which of the first count arguments a call evaluates; see forcedArgs.
Readonlyforcing: (this: void, sig: (...) | (...), count: number) => (...) | (...)How surely a call evaluates each of the first count arguments; see argForcing.
Readonlylayout: (this: void, sig: FnSig) => SigLayoutThe positional view of a signature; see sigLayout.
Readonlyonly: (this: void, index: number, name: string) => FnSigA signature saying only that the call evaluates one argument; see forcingOnly.
ReadonlyposWith: (this: void, layout: SigLayout, count: number, prop: number) => (...)[]The positions carrying any of the given roles; see argsWith.
ReadonlypropAt: (this: void, __namedParameters: SigLayout, index: number) => numberThe roles of the argument at a position; see argProp.
Readonlyresources: (sig: FnSig, writes: boolean) => FnSigThe signature keeping only the resources the call reads or writes, see resourcesOf.
Readonlyslots: (The parameter each argument fills, honoring names; see argumentSlots.
Readonlyunsupported: {The calls that change the environment in ways flowR cannot follow.
Checks whether a data flow graph vertex represents an unsupported (environment-changing) function call (e.g. eval, load, attach, rm, ...)
Readonlyclasses: {What the project declares as a class, and how those relate.
ReadonlyargFor: <Info>(The argument a class-declaring built-in's config names.
Readonlydeclared: (graph: DataflowGraph) => Map<ClassName, DeclaredClass>Every class the graph declares, keyed by name.
Whether the vertex is a call that declares a class; its classDecl is then set.
Readonlyof: <Info>(The declaration a call states.
ReadonlysuperOf: (The transitive superclasses of a declared class.
ReadonlytoSig: (The signature-database records for a set of declared classes.
Readonlyexceptions: (The exceptions a definition may raise.
ReadonlyframeReflection: (The reflective argument bits of one definition.
Whether one definition is higher-order, i.e. whether it calls what it is handed.
Readonlyname: "FunctionSemantics"What a node within promises depends on for running at all.
How surely the holder of a promise forces it.
Readonlyprops: (What several definitions and their formals do.
Settles what a definition within a promise does, once the calls are linked.
Settles what a jump within a promise does, once the calls are linked.
Readonlystrictness: (The strictness of several definitions, sharing the work between them.
The one helper to ask what a function does: what it makes of its arguments, what it may raise, which formals it forces, and what it declares as a class.