Search code, repositories, users, issues, pull requests...

Defined at ./src/util/objects.ts#L11

export type MergeableRecord = Record<string, unknown>

Defined at ./src/statistics/features/common-syntax-probability.ts#L29

string:       Record<string, Measurement>

Defined at ./src/statistics/features/common-syntax-probability.ts#L12

export interface CommonSyntaxTypeCounts<Measurement=bigint> {
    // just a helper to collect all as well (could be derived from sum)
    total:        Measurement,
    // counts whenever you pass more than one node that is not sensible for any other category
    multiple:     Measurement,
    // similar to multiple, but only counts empty (bodies etc.)
    empty:        Measurement,
    // in case of a = x etc.
    withArgument: Measurement,
    // arguments used without value
    noValue:      Measurement,
    // does include t and f, as well as NULL etc. (any special symbol)
    singleVar:    Record<string, Measurement>
    number:       Record<number, Measurement>
    // only explicit integers
    integer:      Record<number, Measurement>
    complex:      Record<number, Measurement>
    string:       Record<string, Measurement>
    logical:      Record<typeof RTrue | typeof RFalse, Measurement>,
    call:         Record<string, Measurement>,
    unnamedCall:  Measurement,
    // binop includes all assignments!
    binOp:        Record<string, Measurement>,
    unaryOp:      Record<string, Measurement>,
    // unknown content, records lexeme (can include break etc. for bodies), due to my oversight, this includes function definitions
    other:        Record<string, Measurement>
}

unknown
Defined at ./src/dataflow/graph/graph.ts#L386
```
unknown
```

To check whether the CFG has the expected shape, you can use the test function assertCfg which supports testing for sub-graphs as well (it provides diffing capabilities similar to assertDataflow). As the CFG may become unhandy for larger programs, there are simplifications available with simplifyControlFlowInformation (these can be passed on to the extractCFG function as well).

CFG Vertices

All vertex types are summarized in the CfgVertexType enum which currently contains the following types:

MidMarker (mid)
EndMarker (end)
Statement (stm)
Expression (expr)
Block (blk)

We use the CfgBasicBlockVertex to represent basic blocks and separate expressions (CfgExpressionVertex) and statements (CfgStatementVertex) as control flow units with and without side effects (if you want to, you can see view statements as effectful expressions). The markers (CfgMidMarkerVertex and CfgEndMarkerVertex) indicate specific segments of larger expressions/statements (e.g., an if which has a condition and its branches).

To signal these links, the expressions and statements contain information about the attached markers:

CfgWithMarker

Defined at ./src/control-flow/control-flow-graph.ts#L51

interface CfgWithMarker extends CfgBaseVertex {
    /** mid-markers linked to this statement */
    mid?: NodeId[]
    /** end-markers linked to this statement */
    end?: NodeId[]
}

View more (CfgBaseVertex)

CfgBaseVertex
A plain vertex in the ControlFlowGraph . Please use CfgSimpleVertex to refer to all potential vertex types within the graph.

Defined at ./src/control-flow/control-flow-graph.ts#L40

/**
 * A plain vertex in the {@link ControlFlowGraph}.
 * Please use {@link CfgSimpleVertex} to refer to all potential vertex types within the graph.
 */
interface CfgBaseVertex extends MergeableRecord {
    /** the type of the vertex */
    type:         CfgVertexType,
    /** the id of the vertex, for non-blocks this should directly relate to the AST node */
    id:           NodeId,
    /** child nodes attached to this one */
    children?:    NodeId[],
    /** if the vertex calls a function, this links all targets of this call */
    callTargets?: Set<NodeId>,
}

Defined at ./src/util/objects.ts#L11

export type MergeableRecord = Record<string, unknown>

Defined at ./src/statistics/features/common-syntax-probability.ts#L29

string:       Record<string, Measurement>

Defined at ./src/statistics/features/common-syntax-probability.ts#L12

export interface CommonSyntaxTypeCounts<Measurement=bigint> {
    // just a helper to collect all as well (could be derived from sum)
    total:        Measurement,
    // counts whenever you pass more than one node that is not sensible for any other category
    multiple:     Measurement,
    // similar to multiple, but only counts empty (bodies etc.)
    empty:        Measurement,
    // in case of a = x etc.
    withArgument: Measurement,
    // arguments used without value
    noValue:      Measurement,
    // does include t and f, as well as NULL etc. (any special symbol)
    singleVar:    Record<string, Measurement>
    number:       Record<number, Measurement>
    // only explicit integers
    integer:      Record<number, Measurement>
    complex:      Record<number, Measurement>
    string:       Record<string, Measurement>
    logical:      Record<typeof RTrue | typeof RFalse, Measurement>,
    call:         Record<string, Measurement>,
    unnamedCall:  Measurement,
    // binop includes all assignments!
    binOp:        Record<string, Measurement>,
    unaryOp:      Record<string, Measurement>,
    // unknown content, records lexeme (can include break etc. for bodies), due to my oversight, this includes function definitions
    other:        Record<string, Measurement>
}

unknown
Defined at ./src/dataflow/graph/graph.ts#L386
```
unknown
```

Similarly, the markers contain a link to their root:

CfgWithRoot

Defined at ./src/control-flow/control-flow-graph.ts#L66

export interface CfgWithRoot extends CfgBaseVertex {
    /** the vertex for which this is a marker */
    root: NodeId
}

View more (CfgBaseVertex)

CfgBaseVertex
A plain vertex in the ControlFlowGraph . Please use CfgSimpleVertex to refer to all potential vertex types within the graph.

Defined at ./src/control-flow/control-flow-graph.ts#L40

/**
 * A plain vertex in the {@link ControlFlowGraph}.
 * Please use {@link CfgSimpleVertex} to refer to all potential vertex types within the graph.
 */
interface CfgBaseVertex extends MergeableRecord {
    /** the type of the vertex */
    type:         CfgVertexType,
    /** the id of the vertex, for non-blocks this should directly relate to the AST node */
    id:           NodeId,
    /** child nodes attached to this one */
    children?:    NodeId[],
    /** if the vertex calls a function, this links all targets of this call */
    callTargets?: Set<NodeId>,
}

Defined at ./src/util/objects.ts#L11

export type MergeableRecord = Record<string, unknown>

Defined at ./src/statistics/features/common-syntax-probability.ts#L29

string:       Record<string, Measurement>

Defined at ./src/statistics/features/common-syntax-probability.ts#L12

export interface CommonSyntaxTypeCounts<Measurement=bigint> {
    // just a helper to collect all as well (could be derived from sum)
    total:        Measurement,
    // counts whenever you pass more than one node that is not sensible for any other category
    multiple:     Measurement,
    // similar to multiple, but only counts empty (bodies etc.)
    empty:        Measurement,
    // in case of a = x etc.
    withArgument: Measurement,
    // arguments used without value
    noValue:      Measurement,
    // does include t and f, as well as NULL etc. (any special symbol)
    singleVar:    Record<string, Measurement>
    number:       Record<number, Measurement>
    // only explicit integers
    integer:      Record<number, Measurement>
    complex:      Record<number, Measurement>
    string:       Record<string, Measurement>
    logical:      Record<typeof RTrue | typeof RFalse, Measurement>,
    call:         Record<string, Measurement>,
    unnamedCall:  Measurement,
    // binop includes all assignments!
    binOp:        Record<string, Measurement>,
    unaryOp:      Record<string, Measurement>,
    // unknown content, records lexeme (can include break etc. for bodies), due to my oversight, this includes function definitions
    other:        Record<string, Measurement>
}

unknown
Defined at ./src/dataflow/graph/graph.ts#L386
```
unknown
```

In mermaid visualizations, we use rectangles for statements, rounded rectangles for expressions, circles for exit markers and double-lined rectangles for mid markers. Blocks are visualized as boxes around the contained vertices.

Note

Every CFG vertex has a NodeId that links it to the normalized AST (although basic blocks will find no counterpart as they are a structuring element of the CFG. Additionally, it may provide information on the called functions (in case that the current element is a function call). Have a look at the CfgBaseVertex interface for more information.

CFG Edges

The ControlFlowGraph uses two types of edges to represent the control flow, separated by the CfgEdgeType enum and the two interfaces: CfgFlowDependencyEdge and CfgControlDependencyEdge.

Flow Dependencies

The most common edge is the flow dependency (FD) which simply signals that the source vertex happens after the target vertex in the control flow. So x; y would produce a flow dependency from y to x (additionally to the program-enveloping root expression list):

flowchart RL
    n2(["`RExpressionList (2)`"])
    n0(["`RSymbol (0)
#34;x#34;`"])
    n1(["`RSymbol (1)
#34;y#34;`"])
    n2-exit((2-exit))
    n0 -.->|"FD"| n2
    n1 -.->|"FD"| n0
    n2-exit -.->|"FD"| n1
    style n2 stroke:cyan,stroke-width:6.5px;    style n2-exit stroke:green,stroke-width:6.5px;

(The analysis required 1.5 ms (including the dataflow analysis, normalization, and parsing with the r-shell engine) within the generation environment. We used the following simplification: unique-cf-sets . )

Control Dependencies

Control dependencies (CD) are used to signal that the execution of the source vertex depends on the taget vertex (which, e.g., is the condition of an if statement or while loop). They contain additional information to signal when the source vertex is executed:

CfgControlDependencyEdge

Defined at ./src/control-flow/control-flow-graph.ts#L109

interface CfgControlDependencyEdge extends MergeableRecord {
    label:  CfgEdgeType.Cd
    /** the id which caused the control dependency */
    caused: NodeId,
    /** is the control dependency satisfied with a true condition or is it negated (e.g., else-branch)? */
    when:   typeof RTrue | typeof RFalse
}

View more (MergeableRecord)

Defined at ./src/util/objects.ts#L11

export type MergeableRecord = Record<string, unknown>

Defined at ./src/statistics/features/common-syntax-probability.ts#L29

string:       Record<string, Measurement>