Package-level declarations

Resolves CallExpression and NewExpression targets.

This pass determines the data flows of DeclaredReferenceExpressions which refer to a VariableDeclaration (not a field) while considering the control flow of a function. After this path, only such data flows are left which can occur when following the control flow (in terms of the EOG) of the program.

Adds the DFG edges for various types of nodes.

This pass creates a simple cache of commonly used edges, such as DFG or AST to quickly traverse them in different directions.

The edges cache.

Creates an Evaluation Order Graph (EOG) based on AST.

This Pass is responsible for resolving function pointer calls, i.e., CallExpression nodes that contain a reference/pointer to a function and are being "called". This pass is intentionally split from the CallResolver because it depends on DFG edges. This split allows the CallResolver to be run before any DFG passes, which in turn allow us to also populate DFG passes for inferred functions.

Represents an abstract class that enhances the graph before it is persisted.

A Pass collecting statistics for the graph. Currently, it collects the number of nodes and the number of problem nodes (i.e., nodes where the translation failed for some reason).

Transitively RecordDeclaration nodes with their supertypes' records.

Creates new connections between the place where a variable is declared and where it is used.

Adds the resolved default template arguments recursively to the templateParameter list of the ConstructExpression until a fixpoint is reached e.g. template

Changes the arguments of the CallExpression to use the implicit casts instead

Apply missingParameters (either explicit or defaults) to the ConstructExpression and its type

Performs all necessary steps to make a CallExpression instantiate a template: 1. Set TemplateInstantiation Edge from CallExpression to Template 2. Set Invokes Edge to all realizations of the Template 3. Set return type of the CallExpression and checks if it uses a ParameterizedType and therefore has to be instantiated 4. Set Template Parameters Edge from the CallExpression to all Instantiation Values 5. Set DFG Edges from instantiation to ParamVariableDeclaration in TemplateDeclaration

Checks if the current casts are compatible with the casts necessary to match with a new FunctionDeclaration. If a one argument would need to be cast in two different types it would be modified to a cast to UnknownType

Creates a Mapping between the Parameters of the TemplateDeclaration and the Values provided for the instantiation of the template (Only the ones that are in defined in the instantiation => no defaults or implicit). Additionally, it fills the maps and lists mentioned below:

Gets all ParameterizedTypes from the initialization signature

Creates a Mapping between the Parameters of the TemplateDeclaration and the Values provided * for the instantiation of the template.

Matches declared template arguments to their defaults (without defaults of a previously defined template argument)

Matches declared template arguments to the explicit instantiation

Check if we are handling an implicit template parameter, if so set instantiationSignature, instantiationType and orderedInitializationSignature maps accordingly

Handle calls in the form of super.call() or ClassName.super.call(), conforming to JLS13 §15.12.1.

Checks if the provided call parameter can instantiate the required template parameter

Resolves a CallExpression to the potential target FunctionDeclarations by checking for omitted arguments due to previously defined default arguments

modifies: call arguments by applying implicit casts

In C++ if there is a method that matches the name we are looking for, we have to stop searching in the parents even if the signature of the method does not match

Computes the implicit casts that are necessary to reach the