Package-level declarations

Resolves CallExpression and NewExpression targets.

A ComponentPass is a pass that operates on a Component. If used with executePassSequential, one Pass object is instantiated for each Component in a TranslationResult.

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.

Represents an abstract class that enhances the graph before it is persisted. Passes can exist at three different levels:

A pass target is an interface for a Node on which a Pass can operate, it should only be implemented by TranslationResult, Component and TranslationUnitDeclaration.

Pass with some graph transformations useful when doing serialization.

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).

A TranslationResultPass is a pass that operates on a TranslationResult. If used with executePassSequential, one Pass object is instantiated for the whole TranslationResult.

A TranslationUnitPass is a pass that operates on a TranslationUnitDeclaration. If used with executePassSequential, one Pass object is instantiated for each TranslationUnitDeclaration in a Component.

Transitively connect 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, whether the specified pass has a replacement configured in config for the given language. Currently, we only allow replacement on translation unit level, as this is the only level which has a single language set.

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:

Creates a new Pass (based on cls) and executes it sequentially on the nodes of result. Depending on the type of pass, this will either execute the pass directly on the overall result, loop through each component or through each translation unit.

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

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