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(
        this: void,
        left: NamedGraph,
        right: NamedGraph,
        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().

    Parameters

    • this: void
    • left: NamedGraph
    • right: NamedGraph
    • 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

• invertGraph:function

  • invertGraph(
        this: void,
        graph: DataflowGraph,
        cleanEnv: REnvironmentInformation,
    ): DataflowGraph

    Inverts the given dataflow graph by reversing all edges.

    Parameters

    • this: void
    • graph: DataflowGraph
    • cleanEnv: REnvironmentInformation

    Returns DataflowGraph

• Readonlyname: "Dataflow"

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

  Returns the origin of a vertex in the dataflow graph

  See

  getOriginInDfg - for the underlying function

• provenance:function

  • provenance(
        this: void,
        id: NodeId,
        graph: DataflowGraph,
        consider?: ReadonlySet<NodeId>,
    ): 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)

    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

• reduceGraph:function

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

    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.

    Parameters

    • this: void
    • graph: DataflowGraph

      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 DataflowGraph

• resolveGraphCriteria:function

  • resolveGraphCriteria(
        graph: DataflowGraph,
        ctx: ReadOnlyFlowrAnalyzerContext,
        idMap?: AstIdMap,
    ): DataflowGraph

    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!

    Parameters

    • graph: DataflowGraph
    • ctx: ReadOnlyFlowrAnalyzerContext
    • OptionalidMap: AstIdMap

    Returns DataflowGraph

• Readonlyviews: {
      callGraph: {
          compute(this: void, graph: DataflowGraph): CallGraph;
          computeSubCallGraph(
              this: void,
              graph: CallGraph,
              entryPoints: Set<NodeId>,
          ): CallGraph;
          diffGraphs(
              this: void,
              left: NamedGraph,
              right: NamedGraph,
              config?: Partial<GenericDiffConfiguration>,
          ): GraphDifferenceReport;
          dropTransitiveEdges(this: void, graph: CallGraph): CallGraph;
          invertGraph(
              this: void,
              graph: DataflowGraph,
              cleanEnv: REnvironmentInformation,
          ): DataflowGraph;
          name: "CallGraph";
          reaches(
              this: void,
              from: NodeId,
              to: NodeId,
              graph: DataflowGraph,
              knownReachability?: DefaultMap<NodeId, Set<NodeId>>,
          ): boolean;
          resolveGraphCriteria(
              graph: DataflowGraph,
              ctx: ReadOnlyFlowrAnalyzerContext,
              idMap?: AstIdMap,
          ): DataflowGraph;
          visualize: {
              mermaid: {
                  convert(
                      this: void,
                      config: MermaidGraphConfiguration,
                  ): { mermaid: MermaidGraph; string: string };
                  name: "DataflowMermaid";
                  raw(
                      this: void,
                      graph:
                          | DataflowInformation
                          | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                      includeEnvironments?: boolean,
                      mark?: ReadonlySet<NodeId>,
                      simplified?: boolean,
                  ): string;
                  url(
                      this: void,
                      graph:
                          | DataflowInformation
                          | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                      includeEnvironments?: boolean,
                      mark?: ReadonlySet<NodeId>,
                      simplified?: boolean,
                  ): string;
              };
              quads: {
                  convert: (
                      graph: DataflowGraph,
                      config: QuadSerializationConfiguration,
                  ) => string;
              };
          };
      };
  }

  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(
            this: void,
            left: NamedGraph,
            right: NamedGraph,
            config?: Partial<GenericDiffConfiguration>,
        ): GraphDifferenceReport;
        dropTransitiveEdges(this: void, graph: CallGraph): CallGraph;
        invertGraph(
            this: void,
            graph: DataflowGraph,
            cleanEnv: REnvironmentInformation,
        ): DataflowGraph;
        name: "CallGraph";
        reaches(
            this: void,
            from: NodeId,
            to: NodeId,
            graph: DataflowGraph,
            knownReachability?: DefaultMap<NodeId, Set<NodeId>>,
        ): boolean;
        resolveGraphCriteria(
            graph: DataflowGraph,
            ctx: ReadOnlyFlowrAnalyzerContext,
            idMap?: AstIdMap,
        ): DataflowGraph;
        visualize: {
            mermaid: {
                convert(
                    this: void,
                    config: MermaidGraphConfiguration,
                ): { mermaid: MermaidGraph; string: string };
                name: "DataflowMermaid";
                raw(
                    this: void,
                    graph:
                        | DataflowInformation
                        | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                    includeEnvironments?: boolean,
                    mark?: ReadonlySet<NodeId>,
                    simplified?: boolean,
                ): string;
                url(
                    this: void,
                    graph:
                        | DataflowInformation
                        | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                    includeEnvironments?: boolean,
                    mark?: ReadonlySet<NodeId>,
                    simplified?: boolean,
                ): string;
            };
            quads: {
                convert: (
                    graph: DataflowGraph,
                    config: QuadSerializationConfiguration,
                ) => string;
            };
        };
    }

    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(
            this: void,
            left: NamedGraph,
            right: NamedGraph,
            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().

        Parameters

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

        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

    • invertGraph:function

      • invertGraph(
            this: void,
            graph: DataflowGraph,
            cleanEnv: REnvironmentInformation,
        ): DataflowGraph

        Inverts the given dataflow graph by reversing all edges.

        Parameters

        • this: void
        • graph: DataflowGraph
        • cleanEnv: REnvironmentInformation

        Returns DataflowGraph

    • Readonlyname: "CallGraph"

    • reaches:function

      • reaches(
            this: void,
            from: NodeId,
            to: NodeId,
            graph: DataflowGraph,
            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)

        Parameters

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

        Returns boolean

    • resolveGraphCriteria:function

      • resolveGraphCriteria(
            graph: DataflowGraph,
            ctx: ReadOnlyFlowrAnalyzerContext,
            idMap?: AstIdMap,
        ): DataflowGraph

        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!

        Parameters

        • graph: DataflowGraph
        • ctx: ReadOnlyFlowrAnalyzerContext
        • OptionalidMap: AstIdMap

        Returns DataflowGraph

    • Readonlyvisualize: {
          mermaid: {
              convert(
                  this: void,
                  config: MermaidGraphConfiguration,
              ): { mermaid: MermaidGraph; string: string };
              name: "DataflowMermaid";
              raw(
                  this: void,
                  graph:
                      | DataflowInformation
                      | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                  includeEnvironments?: boolean,
                  mark?: ReadonlySet<NodeId>,
                  simplified?: boolean,
              ): string;
              url(
                  this: void,
                  graph:
                      | DataflowInformation
                      | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                  includeEnvironments?: boolean,
                  mark?: ReadonlySet<NodeId>,
                  simplified?: 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:
                    | DataflowInformation
                    | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                includeEnvironments?: boolean,
                mark?: ReadonlySet<NodeId>,
                simplified?: boolean,
            ): string;
            url(
                this: void,
                graph:
                    | DataflowInformation
                    | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                includeEnvironments?: boolean,
                mark?: ReadonlySet<NodeId>,
                simplified?: 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 underyling 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: DataflowInformation | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                includeEnvironments?: boolean,
                mark?: ReadonlySet<NodeId>,
                simplified?: boolean,
            ): string

            This is a simplified version of DataflowMermaid.convertToMermaid

            Parameters

            • this: void
            • graph: DataflowInformation | DataflowGraph<DataflowGraphVertexInfo, DfEdge>
            • OptionalincludeEnvironments: boolean
            • Optionalmark: ReadonlySet<NodeId>
            • simplified: boolean = false

            Returns string

        • url:function

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

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

            Parameters

            • this: void
            • graph: DataflowInformation | DataflowGraph<DataflowGraphVertexInfo, DfEdge>

              the dataflow graph to render
            • OptionalincludeEnvironments: boolean

              whether to include the environment content in the output
            • Optionalmark: ReadonlySet<NodeId>

              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

            Returns string

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

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

• Readonlyvisualize: {
      mermaid: {
          convert(
              this: void,
              config: MermaidGraphConfiguration,
          ): { mermaid: MermaidGraph; string: string };
          name: "DataflowMermaid";
          raw(
              this: void,
              graph:
                  | DataflowInformation
                  | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
              includeEnvironments?: boolean,
              mark?: ReadonlySet<NodeId>,
              simplified?: boolean,
          ): string;
          url(
              this: void,
              graph:
                  | DataflowInformation
                  | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
              includeEnvironments?: boolean,
              mark?: ReadonlySet<NodeId>,
              simplified?: 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:
                | DataflowInformation
                | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<NodeId>,
            simplified?: boolean,
        ): string;
        url(
            this: void,
            graph:
                | DataflowInformation
                | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<NodeId>,
            simplified?: 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 underyling 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: DataflowInformation | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
            includeEnvironments?: boolean,
            mark?: ReadonlySet<NodeId>,
            simplified?: boolean,
        ): string

        This is a simplified version of DataflowMermaid.convertToMermaid

        Parameters

        • this: void
        • graph: DataflowInformation | DataflowGraph<DataflowGraphVertexInfo, DfEdge>
        • OptionalincludeEnvironments: boolean
        • Optionalmark: ReadonlySet<NodeId>
        • simplified: boolean = false

        Returns string

    • url:function

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

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

        Parameters

        • this: void
        • graph: DataflowInformation | DataflowGraph<DataflowGraphVertexInfo, DfEdge>

          the dataflow graph to render
        • OptionalincludeEnvironments: boolean

          whether to include the environment content in the output
        • Optionalmark: ReadonlySet<NodeId>

          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

        Returns string

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

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