Variable DataflowConst

Type Declaration

• Readonlycreate: {
      empty: (
          this: void,
          cleanEnv?: REnvironmentInformation,
          idMap?: AstIdMap,
      ) => DataflowGraphBuilder<DataflowGraphVertexInfo>;
  }

  Dispatches to helper functions to create new dataflow graphs, e.g. from a pipeline or an empty graph.

  • Readonlyempty: (
        this: void,
        cleanEnv?: REnvironmentInformation,
        idMap?: AstIdMap,
    ) => DataflowGraphBuilder<DataflowGraphVertexInfo>

    Creates an empty dataflow graph with the given id map (or a new one if not provided).

    See

    emptyGraph

• diffGraphs: function

  • diffGraphs<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
        this: void,
        left: NamedGraph<G>,
        right: NamedGraph<G>,
        config?: Partial<GenericDiffConfiguration>,
    ): GraphDifferenceReport

    Compare two dataflow graphs and return a report on the differences. If you simply want to check whether they equal, use <result>.isEqual().

    Type Parameters

    • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

    Parameters

    • this: void
    • left: NamedGraph<G>
    • right: NamedGraph<G>
    • Optionalconfig: Partial<GenericDiffConfiguration>

    Returns GraphDifferenceReport

    See

    diffOfControlFlowGraphs - for control flow graphs

• Readonlyedge: {
      doesNotIncludeType(
          this: void,
          __namedParameters: DfEdgeLike,
          any: EdgeType,
      ): boolean;
      includesType(
          this: void,
          __namedParameters: DfEdgeLike,
          typesToInclude: EdgeType,
      ): boolean;
      name: "DfEdge";
      splitTypes(this: void, __namedParameters: DfEdgeLike): EdgeType[];
      typesToNames(this: void, __namedParameters: DfEdgeLike): Set<EdgeTypeName>;
      typeToName(this: void, type: EdgeType): string;
  }

  Maps to flowR's dataflow edge helper to work with the edges in the dataflow graph

  • doesNotIncludeType: function

    • doesNotIncludeType(
          this: void,
          __namedParameters: DfEdgeLike,
          any: EdgeType,
      ): boolean

      Check if the given-edge type does not include the given type. As types are bitmasks, you can combine multiple types with a bitwise OR (|). Counterpart of DfEdge#includesType.

      Parameters

      • this: void
      • __namedParameters: DfEdgeLike
      • any: EdgeType

      Returns boolean

  • includesType: function

    • includesType(
          this: void,
          __namedParameters: DfEdgeLike,
          typesToInclude: EdgeType,
      ): boolean

      Check if the given-edge type has any of the given types. As types are bitmasks, you can combine multiple types with a bitwise OR (|).

      Parameters

      • this: void
      • __namedParameters: DfEdgeLike
      • typesToInclude: EdgeType

      Returns boolean

      Example

      edgeIncludesType({ types: EdgeType.Reads }, EdgeType.Reads | EdgeType.DefinedBy) // true
      Copy

      Counterpart of DfEdge#doesNotIncludeType.

  • Readonlyname: "DfEdge"

  • splitTypes: function

    • splitTypes(this: void, __namedParameters: DfEdgeLike): EdgeType[]

      Takes joint edge types and splits them into their individual components.

      Parameters

      • this: void
      • __namedParameters: DfEdgeLike

      Returns EdgeType[]

      Example

      DfEdge.splitTypes({ types: EdgeType.Reads | EdgeType.DefinedBy });
      // returns [EdgeType.Reads, EdgeType.DefinedBy]
      Copy

  • typesToNames: function

    • typesToNames(this: void, __namedParameters: DfEdgeLike): Set<EdgeTypeName>

      Takes joint edge types and returns their human-readable names.

      Parameters

      • this: void
      • __namedParameters: DfEdgeLike

      Returns Set<EdgeTypeName>

  • typeToName: function

    • typeToName(this: void, type: EdgeType): string

      Only use this function to retrieve a human-readable name if you know that it is a single bitmask. Otherwise, use DfEdge#typesToNames which handles these cases.

      Parameters

      • this: void
      • type: EdgeType

      Returns string

• Readonlygraph: typeof DataflowGraph

  Maps to flowR's main graph object to store and manipulate the dataflow graph

  See

  DataflowGraph

• hasComputedArguments: function

  • hasComputedArguments(this: void, id: NodeId, graph: DataflowGraph): boolean

    Whether any argument of the call carries a value the program worked out, rather than only literals the author typed: cat("starting\n") is a log line, cat("n =", length(m)) is a finding. A call among the arguments counts as computed, even one over literals such as paste("a", "b").

    Parameters

    • this: void
    • id: NodeId
    • graph: DataflowGraph

    Returns boolean

• invertGraph: function

  • invertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
        this: void,
        graph: G,
        cleanEnv: REnvironmentInformation,
    ): G

    Inverts the given dataflow graph by reversing all edges.

    Type Parameters

    • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

    Parameters

    • this: void
    • graph: G
    • cleanEnv: REnvironmentInformation

    Returns G

• isQuoted: function

  • isQuoted(
        this: void,
        id: NodeId,
        graph: DataflowGraph,
        withOutgoing?: boolean,
    ): boolean

    Whether the node is quoted, i.e., affected by a EdgeType.NonStandardEvaluation edge that actually keeps it from being evaluated (as quote and substitute do).

    Loops mark their body as non-standard-evaluated as well, yet that body really is evaluated (and its symbols really are read), so such an edge does not quote. Use this instead of testing for the edge type directly whenever you want to know whether something is evaluated at all.

    Parameters

    • this: void
    • id: NodeId

      The id of the node to check

    • graph: DataflowGraph

      The graph the node is part of

    • withOutgoing: boolean = false

      Whether to also consider the outgoing edges of the node (i.e., whether the node itself quotes something), and not just the ingoing ones (i.e., whether it is quoted)

    Returns boolean

• Readonlyname: "Dataflow"

• Readonlyorigin: (this: void, dfg: DataflowGraph, id: NodeId) => Origin[] | undefined

  Returns the origin of a vertex in the dataflow graph

  See

  getOriginInDfg - for the underlying function

• packagesOf: function

  • packagesOf(
        this: void,
        nodes: Iterable<NodeId>,
        graph: DataflowGraph,
        includeBaseR?: boolean,
    ): Set<string>

    The packages the given nodes call into, as Dataflow.qualify resolves every call among them. This is what a selection needs, which is not what the program loads: a library() whose exports the selection never calls does not make the package needed. Base R is left out unless includeBaseR.

    Parameters

    • this: void
    • nodes: Iterable<NodeId>

      the ids to consider, e.g. the result of a slice

    • graph: DataflowGraph

      the graph the ids belong to

    • includeBaseR: boolean = false

      whether to also report base-R packages

    Returns Set<string>

• provenance: function

  • provenance(
        this: void,
        id: NodeId,
        graph: DataflowGraph,
        consider?: ReadonlySet<NodeId>,
        followEdges?: number | undefined,
    ): Set<NodeId>

    Given the id of a vertex (usually a variable use), this returns a reachable provenance set by calculating a non-interprocedural and non-context sensitive backward slice, but stopping at the given ids! You can obtain the corresponding graph using Dataflow.reduceGraph.

    Parameters

    • this: void
    • id: NodeId

      The id to use as a seed for provenance calculation

    • graph: DataflowGraph

      The graph to perform the provenance calculation on

    • Optionalconsider: ReadonlySet<NodeId>

      The ids to restrict the calculation too (e.g., the ids contained within a function definition to restrict the analysis to)

    • followEdges: number | undefined = ...

      Which edges to consider in the provenance traversal, if you set this to undefined this will automatically track all edges

    Returns Set<NodeId>

    See

    Dataflow.provenanceGraph - for a convenience wrapper to directly obtain the graph of the provenance.

• provenanceGraph: function

  • provenanceGraph(
        this: void,
        id: NodeId,
        graph: DataflowGraph,
        consider?: ReadonlySet<NodeId>,
    ): DataflowGraph

    A convenience wrapper for reducing the provenance of a graph.

    Parameters

    • this: void
    • id: NodeId

      The id to use as a seed for provenance calculation

    • graph: DataflowGraph

      The graph to perform the provenance calculation on

    • Optionalconsider: ReadonlySet<NodeId>

      The ids to restrict the calculation too (e.g., the ids contained within a function definition to restrict the analysis to)

    Returns DataflowGraph

    See

    Dataflow.provenance

• qualify: function

  • qualify(
        this: void,
        id: NodeId,
        graph: DataflowGraph,
        qualifyBaseR?: boolean,
    ): Identifier | undefined

    The qualified identifier of the call with the given id, or undefined if it does not resolve to a package export and is not itself already namespaced (with purrr loaded, a map() call yields Identifier.make('map', 'purrr'); an explicit pkg::fn() call yields pkg::fn unchanged).

    This is the compact form of Identifier.toQualified, reconstructing both the origins and the call's name from the graph.

    Parameters

    • this: void
    • id: NodeId

      The id of the call to qualify

    • graph: DataflowGraph

      The graph the call is part of

    • qualifyBaseR: boolean = true

      Whether to also qualify a bare base-R call from the package exporting it (sd yields stats::sd), which needs neither a loaded database nor graph edges. Set this to false to only qualify what the origins resolve to (or what is already namespaced).

    Returns Identifier | undefined

• reaches: function

  • reaches<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
        this: void,
        from: NodeId,
        to: NodeId,
        graph: G,
        knownReachability?: DefaultMap<NodeId, Set<NodeId>>,
    ): boolean

    Determines whether there is a path from from to to in the given graph (via any edge type, only respecting direction)

    Type Parameters

    • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

    Parameters

    • this: void
    • from: NodeId
    • to: NodeId
    • graph: G
    • knownReachability: DefaultMap<NodeId, Set<NodeId>> = ...

    Returns boolean

• reduceAndInvertGraph: function

  • reduceAndInvertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
        this: void,
        graph: G,
        select: ReadonlySet<NodeId>,
        cleanEnv: REnvironmentInformation,
    ): G

    Equivalent to reduceGraph followed by invertGraph but in a single pass over the graph, allocating only one intermediate object instead of two. Use this when you need the reduced-and-inverted graph for a forward traversal within a restriction set.

    Type Parameters

    • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

    Parameters

    • this: void
    • graph: G
    • select: ReadonlySet<NodeId>
    • cleanEnv: REnvironmentInformation

    Returns G

• reduceGraph: function

  • reduceGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
        this: void,
        graph: G,
        select: ReadonlySet<NodeId>,
        includeMissingTargets?: boolean,
    ): G

    Only returns the sub-part of the graph that is determined by the given selection. In other words, this will return a graph with only vertices that are part of the selected ids, and edges that are between such selected vertices.

    Type Parameters

    • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

    Parameters

    • this: void
    • graph: G

      the dataflow graph to slice for

    • select: ReadonlySet<NodeId>

      the ids to select in the reduced graph

    • includeMissingTargets: boolean = false

      if set to true, this will include edges which target vertices that are not selected!

    Returns G

• Readonlyresolve: {
      argument: {
          name: "argument";
          stringVector: (
              id: (...) | (...) | (...),
              info: ResolveInfo,
          ) => (...) | (...);
          symbolName: (
              id: (...) | (...) | (...),
              info: ResolveInfo,
          ) => (...) | (...);
          toName: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...);
          value: (
              id: (...) | (...) | (...),
              info: ResolveInfo,
          ) => (...) | (...) | (...) | (...) | (...) | (...);
          vectorLength: (
              id: (...) | (...) | (...),
              info: ResolveInfo,
          ) => (...) | (...);
      };
      byName: (
          id: Identifier,
          environment: REnvironmentInformation,
      ) => (...)[] | undefined;
      byNameAndType: (
          id: Identifier,
          environment: REnvironmentInformation,
          target: ReferenceType,
      ) => readonly (...)[] | undefined;
      name: "Resolve";
      toBuiltIn: (
          name: Identifier | undefined,
          environment: REnvironmentInformation,
          wantedValue: unknown,
      ) => Ternary;
      toConstants: (
          name: Identifier | undefined,
          environment: REnvironmentInformation,
      ) => ResolveResult;
      toSingleString: (
          id: NodeId | RNodeWithParent | undefined,
          info: ResolveInfo,
      ) => string | undefined;
      toValue: (
          id: NodeId | RNodeWithParent | undefined,
          environment: ResolveInfo,
      ) => ResolveResult;
  }

  Name and value resolution.

  See

  Resolve - the helper object itself, which documents which entry point to reach for

  • Readonlyargument: {
        name: "argument";
        stringVector: (
            id: (...) | (...) | (...),
            info: ResolveInfo,
        ) => (...) | (...);
        symbolName: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...);
        toName: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...);
        value: (
            id: (...) | (...) | (...),
            info: ResolveInfo,
        ) => (...) | (...) | (...) | (...) | (...) | (...);
        vectorLength: (
            id: (...) | (...) | (...),
            info: ResolveInfo,
        ) => (...) | (...);
    }

    The same, for the arguments of a call.

    • Readonlyname: "argument"

    • ReadonlystringVector: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...)

      The argument's value as a vector of strings.

    • ReadonlysymbolName: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...)

      The argument's value as the name of the symbol it holds.

    • ReadonlytoName: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...)

      The argument's name.

    • Readonlyvalue: (
          id: (...) | (...) | (...),
          info: ResolveInfo,
      ) => (...) | (...) | (...) | (...) | (...) | (...)

      The argument's value.

    • ReadonlyvectorLength: (id: (...) | (...) | (...), info: ResolveInfo) => (...) | (...)

      The length of the vector the argument holds.

  • ReadonlybyName: (id: Identifier, environment: REnvironmentInformation) => (...)[] | undefined

    Every definition the identifier may refer to, whatever its type.

  • ReadonlybyNameAndType: (
        id: Identifier,
        environment: REnvironmentInformation,
        target: ReferenceType,
    ) => readonly (...)[] | undefined

    The definitions the identifier may refer to that fit the wanted ReferenceType.

  • Readonlyname: "Resolve"

  • ReadonlytoBuiltIn: (
        name: Identifier | undefined,
        environment: REnvironmentInformation,
        wantedValue: unknown,
    ) => Ternary

    Whether the name always, never, or maybe refers to a built-in constant of the given value.

  • ReadonlytoConstants: (
        name: Identifier | undefined,
        environment: REnvironmentInformation,
    ) => ResolveResult

    The constant values the name resolves to.

  • ReadonlytoSingleString: (
        id: NodeId | RNodeWithParent | undefined,
        info: ResolveInfo,
    ) => string | undefined

    The single string the node resolves to, or undefined if it is not exactly one.

  • ReadonlytoValue: (
        id: NodeId | RNodeWithParent | undefined,
        environment: ResolveInfo,
    ) => ResolveResult

    The value(s) the node may hold, tracking aliases as the configuration allows.

• resolveGraphCriteria: function

  • resolveGraphCriteria<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
        graph: G,
        ctx: ReadOnlyFlowrAnalyzerContext,
        idMap?: AstIdMap,
    ): G

    Resolves the dataflow graph ids from slicing criterion form to ids. This returns a new graph with the resolved ids. The main use-case for this is testing - if you do not know/want to fix the specific id, you can use, e.g. 2@x as a placeholder for the first x in the second line!

    Type Parameters

    • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

    Parameters

    • graph: G
    • ctx: ReadOnlyFlowrAnalyzerContext
    • OptionalidMap: AstIdMap

    Returns G

• ReadonlysideEffects: {
      callGraphSummaries: <T>(
          this: void,
          graph: DataflowGraph,
          own: (
              id: NodeId,
              fdef: DataflowGraphVertexFunctionDefinition,
          ) => Iterable<(...)>,
      ) => Map<NodeId, Set<(...)>>;
      propagateTransitive: (
          this: void,
          graph: DataflowGraph,
          environment: REnvironmentInformation,
          ctx: FlowrAnalyzerContext,
      ) => {
          environment: REnvironmentInformation;
          escapedNames: Set<(...)>;
          grew: boolean;
      };
  }

  Interprocedural propagation of escaped side effects (attached packages, <<- definitions) to their callers.

  • ReadonlycallGraphSummaries: <T>(
        this: void,
        graph: DataflowGraph,
        own: (
            id: NodeId,
            fdef: DataflowGraphVertexFunctionDefinition,
        ) => Iterable<(...)>,
    ) => Map<NodeId, Set<(...)>>

  • ReadonlypropagateTransitive: (
        this: void,
        graph: DataflowGraph,
        environment: REnvironmentInformation,
        ctx: FlowrAnalyzerContext,
    ) => {
        environment: REnvironmentInformation;
        escapedNames: Set<(...)>;
        grew: boolean;
    }

• valueIsUsed: function

  • valueIsUsed(this: void, id: NodeId, graph: DataflowGraph): boolean

    Whether the call's result is passed on -- assigned, handed to another call, returned -- rather than left for R to auto-print. A bare anova(a, b) is an output the program reports; the summary(m) of x <- summary(m) is not.

    Only an edge that carries the value counts. A plain EdgeType.Reads does not: it also chains the calls that share a side effect, which would report plot(x) as consumed by the lines(y) drawn after it.

    Parameters

    • this: void
    • id: NodeId
    • graph: DataflowGraph

    Returns boolean

• Readonlyviews: {
      callGraph: {
          compute(this: void, graph: DataflowGraph): CallGraph;
          computeSubCallGraph(
              this: void,
              graph: CallGraph,
              entryPoints: Set<NodeId>,
          ): CallGraph;
          diffGraphs<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
              this: void,
              left: NamedGraph<G>,
              right: NamedGraph<G>,
              config?: Partial<(...)>,
          ): GraphDifferenceReport;
          dropTransitiveEdges(this: void, graph: CallGraph): CallGraph;
          entryPoints(this: void, graph: CallGraph): Set<NodeId>;
          invertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
              this: void,
              graph: G,
              cleanEnv: REnvironmentInformation,
          ): G;
          name: "CallGraph";
          reaches<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
              this: void,
              from: NodeId,
              to: NodeId,
              graph: G,
              knownReachability?: DefaultMap<NodeId, Set<(...)>>,
          ): boolean;
          resolveGraphCriteria<
              G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
          >(
              graph: G,
              ctx: ReadOnlyFlowrAnalyzerContext,
              idMap?: AstIdMap,
          ): G;
          unreachableCalls(this: void, graph: CallGraph): NodeId[];
          visualize: {
              mermaid: {
                  convert(this: ..., config: ...): ...;
                  name: ...;
                  raw(
                      this: ...,
                      graph: ...,
                      includeEnvironments?: ...,
                      mark?: ...,
                      simplified?: ...,
                      qualifyBaseR?: ...,
                  ): ...;
                  url(
                      this: ...,
                      graph: ...,
                      includeEnvironments?: ...,
                      mark?: ...,
                      simplified?: ...,
                      qualifyBaseR?: ...,
                  ): ...;
              };
              quads: { convert: ... };
          };
      };
  }

  Dispatches to helper objects that relate to (sub-) views of the dataflow graph, e.g. the call graph.

  • ReadonlycallGraph: {
        compute(this: void, graph: DataflowGraph): CallGraph;
        computeSubCallGraph(
            this: void,
            graph: CallGraph,
            entryPoints: Set<NodeId>,
        ): CallGraph;
        diffGraphs<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            left: NamedGraph<G>,
            right: NamedGraph<G>,
            config?: Partial<(...)>,
        ): GraphDifferenceReport;
        dropTransitiveEdges(this: void, graph: CallGraph): CallGraph;
        entryPoints(this: void, graph: CallGraph): Set<NodeId>;
        invertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            graph: G,
            cleanEnv: REnvironmentInformation,
        ): G;
        name: "CallGraph";
        reaches<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            from: NodeId,
            to: NodeId,
            graph: G,
            knownReachability?: DefaultMap<NodeId, Set<(...)>>,
        ): boolean;
        resolveGraphCriteria<
            G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
        >(
            graph: G,
            ctx: ReadOnlyFlowrAnalyzerContext,
            idMap?: AstIdMap,
        ): G;
        unreachableCalls(this: void, graph: CallGraph): NodeId[];
        visualize: {
            mermaid: {
                convert(this: ..., config: ...): ...;
                name: ...;
                raw(
                    this: ...,
                    graph: ...,
                    includeEnvironments?: ...,
                    mark?: ...,
                    simplified?: ...,
                    qualifyBaseR?: ...,
                ): ...;
                url(
                    this: ...,
                    graph: ...,
                    includeEnvironments?: ...,
                    mark?: ...,
                    simplified?: ...,
                    qualifyBaseR?: ...,
                ): ...;
            };
            quads: { convert: ... };
        };
    }

    Maps to flowR's helper object for the call-graph

    • compute: function

      • compute(this: void, graph: DataflowGraph): CallGraph

        Computes the call graph from the given dataflow graph.

        Parameters

        • this: void
        • graph: DataflowGraph

        Returns CallGraph

        See

        • CallGraph - for details
        • CallGraph.computeSubCallGraph - to extract sub call graphs
        • CallGraph.dropTransitiveEdges - to reduce the call graph by dropping transitive edges

    • computeSubCallGraph: function

      • computeSubCallGraph(
            this: void,
            graph: CallGraph,
            entryPoints: Set<NodeId>,
        ): CallGraph

        Extracts the sub call graph from the given call graph, starting from the given entry points.

        Parameters

        • this: void
        • graph: CallGraph
        • entryPoints: Set<NodeId>

        Returns CallGraph

    • diffGraphs: function

      • diffGraphs<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            left: NamedGraph<G>,
            right: NamedGraph<G>,
            config?: Partial<(...)>,
        ): GraphDifferenceReport

        Compare two dataflow graphs and return a report on the differences. If you simply want to check whether they equal, use <result>.isEqual().

        Type Parameters

        • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

        Parameters

        • this: void
        • left: NamedGraph<G>
        • right: NamedGraph<G>
        • Optionalconfig: Partial<(...)>

        Returns GraphDifferenceReport

        See

        diffOfControlFlowGraphs - for control flow graphs

    • dropTransitiveEdges: function

      • dropTransitiveEdges(this: void, graph: CallGraph): CallGraph

        Reduces the call graph by dropping all transitive edges.

        Parameters

        • this: void
        • graph: CallGraph

        Returns CallGraph

    • entryPoints: function

      • entryPoints(this: void, graph: CallGraph): Set<NodeId>

        The calls the program makes on its own: those outside of any function definition.

        Parameters

        • this: void
        • graph: CallGraph

        Returns Set<NodeId>

    • invertGraph: function

      • invertGraph<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            graph: G,
            cleanEnv: REnvironmentInformation,
        ): G

        Inverts the given dataflow graph by reversing all edges.

        Type Parameters

        • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

        Parameters

        • this: void
        • graph: G
        • cleanEnv: REnvironmentInformation

        Returns G

    • Readonlyname: "CallGraph"

    • reaches: function

      • reaches<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            this: void,
            from: NodeId,
            to: NodeId,
            graph: G,
            knownReachability?: DefaultMap<NodeId, Set<(...)>>,
        ): boolean

        Determines whether there is a path from from to to in the given graph (via any edge type, only respecting direction)

        Type Parameters

        • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

        Parameters

        • this: void
        • from: NodeId
        • to: NodeId
        • graph: G
        • knownReachability: DefaultMap<NodeId, Set<(...)>> = ...

        Returns boolean

    • resolveGraphCriteria: function

      • resolveGraphCriteria<G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>>(
            graph: G,
            ctx: ReadOnlyFlowrAnalyzerContext,
            idMap?: AstIdMap,
        ): G

        Resolves the dataflow graph ids from slicing criterion form to ids. This returns a new graph with the resolved ids. The main use-case for this is testing - if you do not know/want to fix the specific id, you can use, e.g. 2@x as a placeholder for the first x in the second line!

        Type Parameters

        • G extends DataflowGraph<DataflowGraphVertexInfo, DfEdge>

        Parameters

        • graph: G
        • ctx: ReadOnlyFlowrAnalyzerContext
        • OptionalidMap: AstIdMap

        Returns G

    • unreachableCalls: function

      • unreachableCalls(this: void, graph: CallGraph): NodeId[]

        The calls no execution starting at the top level reaches: those in a function nothing (transitively) calls. What mayRunAnyway may still run is left out, so a call reported here really does not run.

        Parameters

        • this: void
        • graph: CallGraph

        Returns NodeId[]

    • Readonlyvisualize: {
          mermaid: {
              convert(this: ..., config: ...): ...;
              name: ...;
              raw(
                  this: ...,
                  graph: ...,
                  includeEnvironments?: ...,
                  mark?: ...,
                  simplified?: ...,
                  qualifyBaseR?: ...,
              ): ...;
              url(
                  this: ...,
                  graph: ...,
                  includeEnvironments?: ...,
                  mark?: ...,
                  simplified?: ...,
                  qualifyBaseR?: ...,
              ): ...;
          };
          quads: { convert: ... };
      }

      Maps to the mermaid-centric visualization helper for dataflow graphs and their views

      • Readonlymermaid: {
            convert(this: ..., config: ...): ...;
            name: ...;
            raw(
                this: ...,
                graph: ...,
                includeEnvironments?: ...,
                mark?: ...,
                simplified?: ...,
                qualifyBaseR?: ...,
            ): ...;
            url(
                this: ...,
                graph: ...,
                includeEnvironments?: ...,
                mark?: ...,
                simplified?: ...,
                qualifyBaseR?: ...,
            ): ...;
        }

        Mermaid rendering helper for dataflow graphs

        • DataflowMermaid.url, DataflowMermaid.raw - to render the graph as a mermaid graph (e.g., in markdown or the mermaid live editor)
        • DataflowMermaid.convert - for the underlying transformation

        See

        DataflowMermaid

        • convert: function

          • convert(this: ..., config: ...): ...

            Converts a dataflow graph to mermaid graph code that visualizes the graph.

            Parameters

            • this: ...
            • config: ...

            Returns ...

            See

            DataflowMermaid.url - render the given graph to a url to mermaid.live

        • Readonlyname: ...

        • raw: function

          • raw(
                this: ...,
                graph: ...,
                includeEnvironments?: ...,
                mark?: ...,
                simplified?: ...,
                qualifyBaseR?: ...,
            ): ...

            This is a simplified version of DataflowMermaid.convert

            Parameters

            • this: ...
            • graph: ...
            • OptionalincludeEnvironments: ...
            • Optionalmark: ...
            • simplified: ... = false
            • qualifyBaseR: ... = true

            Returns ...

        • url: function

          • url(
                this: ...,
                graph: ...,
                includeEnvironments?: ...,
                mark?: ...,
                simplified?: ...,
                qualifyBaseR?: ...,
            ): ...

            Converts a dataflow graph to a mermaid url that visualizes the graph. This is basically a combination of DataflowMermaid.raw and Mermaid.codeToUrl.

            Parameters

            • this: ...
            • graph: ...

              the dataflow graph to render

            • OptionalincludeEnvironments: ...

              whether to include the environment content in the output

            • Optionalmark: ...

              which vertices to highlight in the visualization

            • simplified: ... = false

              whether to show a simplified use of the graph with fewer details on the vertices and edges

            • qualifyBaseR: ... = true

              show the edge-free base-R qualification (stats::acf); false when the signature database is disabled

            Returns ...

      • Readonlyquads: { convert: ... }

• visitDfg: function

  • visitDfg(
        this: void,
        graph: DataflowGraph,
        start: NodeId,
        onVertex: (vtx: DataflowGraphVertexInfo) => boolean | void,
    ): void

    A simple visitor akin to RNode.visitAst to traverse the dataflow graph starting from the start id and only respecting edge direction.

    Parameters

    • this: void
    • graph: DataflowGraph

      The dataflow graph to operate on.

    • start: NodeId

      The start id of the visitation.

    • onVertex: (vtx: DataflowGraphVertexInfo) => boolean | void

      The function to execute for each vertex, if this returns true the visitation will stop from this vertex.

    Returns void

• Readonlyvisualize: {
      mermaid: {
          convert(
              this: void,
              config: MermaidGraphConfiguration,
          ): { mermaid: MermaidGraph; string: string };
          name: "DataflowMermaid";
          raw(
              this: void,
              graph: DataflowGraph<(...), (...)> | DataflowInformation,
              includeEnvironments?: boolean,
              mark?: ReadonlySet<(...)>,
              simplified?: boolean,
              qualifyBaseR?: boolean,
          ): string;
          url(
              this: void,
              graph: DataflowGraph<(...), (...)> | DataflowInformation,
              includeEnvironments?: boolean,
              mark?: ReadonlySet<(...)>,
              simplified?: boolean,
              qualifyBaseR?: boolean,
          ): string;
      };
      quads: {
          convert: (
              graph: DataflowGraph,
              config: QuadSerializationConfiguration,
          ) => string;
      };
  }

  Maps to the mermaid-centric visualization helper for dataflow graphs and their views

  • Readonlymermaid: {
        convert(
            this: void,
            config: MermaidGraphConfiguration,
        ): { mermaid: MermaidGraph; string: string };
        name: "DataflowMermaid";
        raw(
            this: void,
            graph: DataflowGraph<(...), (...)> | DataflowInformation,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<(...)>,
            simplified?: boolean,
            qualifyBaseR?: boolean,
        ): string;
        url(
            this: void,
            graph: DataflowGraph<(...), (...)> | DataflowInformation,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<(...)>,
            simplified?: boolean,
            qualifyBaseR?: boolean,
        ): string;
    }

    Mermaid rendering helper for dataflow graphs

    • DataflowMermaid.url, DataflowMermaid.raw - to render the graph as a mermaid graph (e.g., in markdown or the mermaid live editor)
    • DataflowMermaid.convert - for the underlying transformation

    See

    DataflowMermaid

    • convert: function

      • convert(
            this: void,
            config: MermaidGraphConfiguration,
        ): { mermaid: MermaidGraph; string: string }

        Converts a dataflow graph to mermaid graph code that visualizes the graph.

        Parameters

        • this: void
        • config: MermaidGraphConfiguration

        Returns { mermaid: MermaidGraph; string: string }

        See

        DataflowMermaid.url - render the given graph to a url to mermaid.live

    • Readonlyname: "DataflowMermaid"

    • raw: function

      • raw(
            this: void,
            graph: DataflowGraph<(...), (...)> | DataflowInformation,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<(...)>,
            simplified?: boolean,
            qualifyBaseR?: boolean,
        ): string

        This is a simplified version of DataflowMermaid.convert

        Parameters

        • this: void
        • graph: DataflowGraph<(...), (...)> | DataflowInformation
        • OptionalincludeEnvironments: boolean
        • Optionalmark: ReadonlySet<(...)>
        • simplified: boolean = false
        • qualifyBaseR: boolean = true

        Returns string

    • url: function

      • url(
            this: void,
            graph: DataflowGraph<(...), (...)> | DataflowInformation,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<(...)>,
            simplified?: boolean,
            qualifyBaseR?: boolean,
        ): string

        Converts a dataflow graph to a mermaid url that visualizes the graph. This is basically a combination of DataflowMermaid.raw and Mermaid.codeToUrl.

        Parameters

        • this: void
        • graph: DataflowGraph<(...), (...)> | DataflowInformation

          the dataflow graph to render

        • OptionalincludeEnvironments: boolean

          whether to include the environment content in the output

        • Optionalmark: ReadonlySet<(...)>

          which vertices to highlight in the visualization

        • simplified: boolean = false

          whether to show a simplified use of the graph with fewer details on the vertices and edges

        • qualifyBaseR: boolean = true

          show the edge-free base-R qualification (stats::acf); false when the signature database is disabled

        Returns string

  • Readonlyquads: {
        convert: (
            graph: DataflowGraph,
            config: QuadSerializationConfiguration,
        ) => string;
    }

    • Readonlyconvert: (graph: DataflowGraph, config: QuadSerializationConfiguration) => string