Variable CallGraph

Type Declaration

• 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

• Readonlydiff: {
      edges<Edge, Graph>(
          this: void,
          ctx: GraphDiffContext<Graph>,
          id: NodeId,
          lEdges: ReadonlyMap<NodeId, Edge> | undefined,
          rEdges: ReadonlyMap<NodeId, Edge> | undefined,
          diffEdge: (
              edge: Edge,
              otherEdge: Edge,
              ctx: GraphDiffContext<Graph>,
              id: NodeId,
              target: NodeId,
          ) => void,
      ): void;
      outgoingEdges<EdgeMap, Graph extends EdgeIndexedGraph<EdgeMap>>(
          this: void,
          ctx: GraphDiffContext<Graph>,
          diffEdges: (
              ctx: GraphDiffContext<Graph>,
              id: NodeId,
              lEdges: EdgeMap | undefined,
              rEdges: EdgeMap | undefined,
          ) => void,
          project?: (edges: EdgeMap) => (...) | (...),
      ): void;
  }

  The pieces a graph comparison is built from, for a view that brings its own edge shape.

  See

  GraphHelper.diffGraphs - which is what you want for two dataflow graphs

  • edges: function

    • edges<Edge, Graph>(
          this: void,
          ctx: GraphDiffContext<Graph>,
          id: NodeId,
          lEdges: ReadonlyMap<NodeId, Edge> | undefined,
          rEdges: ReadonlyMap<NodeId, Edge> | undefined,
          diffEdge: (
              edge: Edge,
              otherEdge: Edge,
              ctx: GraphDiffContext<Graph>,
              id: NodeId,
              target: NodeId,
          ) => void,
      ): void

      Compares the outgoing edges of a single vertex, handing each pair of edges to diffEdge.

      Type Parameters

      • Edge
      • Graph

      Parameters

      • this: void
      • ctx: GraphDiffContext<Graph>
      • id: NodeId
      • lEdges: ReadonlyMap<NodeId, Edge> | undefined
      • rEdges: ReadonlyMap<NodeId, Edge> | undefined
      • diffEdge: (
            edge: Edge,
            otherEdge: Edge,
            ctx: GraphDiffContext<Graph>,
            id: NodeId,
            target: NodeId,
        ) => void

      Returns void

  • outgoingEdges: function

    • outgoingEdges<EdgeMap, Graph extends EdgeIndexedGraph<EdgeMap>>(
          this: void,
          ctx: GraphDiffContext<Graph>,
          diffEdges: (
              ctx: GraphDiffContext<Graph>,
              id: NodeId,
              lEdges: EdgeMap | undefined,
              rEdges: EdgeMap | undefined,
          ) => void,
          project?: (edges: EdgeMap) => (...) | (...),
      ): void

      Compares all edges of both graphs vertex by vertex, handing each pair to diffEdges.

      Type Parameters

      • EdgeMap
      • Graph extends EdgeIndexedGraph<EdgeMap>

      Parameters

      • this: void
      • ctx: GraphDiffContext<Graph>
      • diffEdges: (
            ctx: GraphDiffContext<Graph>,
            id: NodeId,
            lEdges: EdgeMap | undefined,
            rEdges: EdgeMap | undefined,
        ) => void
      • Optionalproject: (edges: EdgeMap) => (...) | (...)

      Returns void

• 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

• 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<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

• 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: 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