@eagleoutice/flowr - v2.17.4
    Preparing search index...

    The definition of an identifier within the DataflowGraph|graph.

    interface InGraphIdentifierDefinition {
        assumed?: true;
        cds?: readonly ControlDependency[];
        closureFrame?: true;
        definedAt: NodeId;
        envId?: NodeId;
        envState?: REnvironmentInformation;
        envWrites?: true;
        forces?: readonly AmbientStateName[];
        global?: boolean;
        holder?: BrandedIdentifier;
        iterated?: boolean;
        name: Identifier | undefined;
        nodeId: NodeId;
        returnsEnvState?: REnvironmentInformation;
        type: InGraphReferenceType;
        value?: NodeId[];
        writes?: readonly AmbientStateName[];
    }

    Hierarchy (View Summary)

    Index
    assumed?: true

    Whether the ambient state is only assumed written, by a body flowR cannot see.

    cds?: readonly ControlDependency[]

    If the reference is only effective, if, for example, an if-then-else condition is true, this references the root of the if.

    closureFrame?: true

    Whether envState tracks the frame of the closure this variable holds (environment(fn)), rather than an environment it holds.

    definedAt: NodeId

    The assignment node which ultimately defined this identifier (the arrow operator for e.g. x <- 3, or assign call in assign("x", 3))

    envId?: NodeId

    Names the environment object envState tracks, so that every variable aliasing it sees the same writes.

    If this variable holds an R environment (created by new.env() etc.), this tracks the current known state of that environment.

    envWrites?: true

    Whether envState holds only the writes a function makes into the environment a free variable names: the environment itself is the one the name is bound to where the function is called, which adds these writes to it.

    forces?: readonly AmbientStateName[]

    The ambient state reading this identifier may change, as forcing a promise (delayedAssign) whose code writes it does.

    global?: boolean

    Whether the read is evaluated in the global environment (source() within a function), so no frame below it can bind it

    For a registered finalizer, the variable holding the object it is registered for.

    iterated?: boolean

    Whether value names the sequence this identifier iterates over rather than what it holds, as a for loop's variable does: it takes one element of that sequence at a time.

    name: Identifier | undefined

    Name the reference is identified by (e.g., the name of the variable), undefined if the reference is "artificial" (e.g., anonymous)

    nodeId: NodeId

    The id of the node which represents the reference in the NormalizedAst|normalized AST and the DataflowGraph|dataflow graph.

    returnsEnvState?: REnvironmentInformation

    If this is a function that returns a tracked environment, stores the envState that the function returns (best-effort: only set when statically detectable).

    Type of the reference to be resolved

    value?: NodeId[]

    For value tracking, this contains all nodeIds of constant values that may be made available to this identifier For example, in x <- 3; y <- x, the definition of y will have the value 3 in its value set

    writes?: readonly AmbientStateName[]

    For a registered finalizer, the ambient state running it writes.