Package-level declarations

This is the result of SymbolResolver.resolveWithArguments. It holds all necessary intermediate results (such as candidateFunctions, viableFunctions) as well as the final result (see bestViable) of the call resolution.

A generic exception that can be thrown while building the configuration. This exception indicates that the requested configuration is not possible.

This class holds configuration options for the inference of certain constructs and auto-guessing when executing language frontends.

Annotation used to mark functions that could potentially be dangerous, in a way that could modify or alter the CPG tree structure that one does not intent to.

This annotation denotes that, this property is populates by a pass. Optionally, also specifying which Pass class is responsible.

Functions marked with this annotation are using features of the ScopeManager to resolve symbols (or scopes) during frontend parsing. This is something which we discourage. However, in non-context free languages such as C++ this is unavoidable to some degree.

The scope manager builds a multi-tree structure of nodes associated to a scope. These scopes capture the validity of certain (Variable-, Field-, Record-)declarations but are also used to identify outer scopes that should be the target of a jump (continue, break, throw).

SignatureResult will be the result of the function FunctionDeclaration.matchesSignature which calculates whether the provided CallExpression will match the signature of the current FunctionDeclaration.

The configuration for the TranslationManager holds all information that is used during the translation.

The translation context holds all necessary managers and configurations needed during the translation process.

Main entry point for all source code translation for all language front-ends.

The global (intermediate) result of the translation. A LanguageFrontend will initially populate it and a Pass can extend it.

This computed property returns the common type in a Collection of Type objects. For example, if two types A and B both derive from the interface C`` then C` would be returned.

A utility function that checks whether our Reference refers to a Type. This is used by many passes that replace certain Reference nodes with other nodes, e.g., the ResolveCallExpressionAmbiguityPass.

This function checks, if this Type can be cast into targetType. Note, this also takes the TypeOperations of the type into account, which means that pointer types of derived types will not match with a non-pointer type of its base type. But, if both are pointer types, they will match.