RecoverForXCompilationUnit

A heuristic method to determine if a call is a constructor or not.

Refers to the declared import information. This is for legacy import notation.

Given a LHS call, will retrieve its symbol to the given types.

Similar to associateTypes but used in the case where there is some kind of field load.

Associates the types with the identifier. This may sometimes be an identifier that should be considered a field which this method uses isField to determine.

Associates the types with the identifier. This may sometimes be an identifier that should be considered a field which this method uses isField to determine.

Extracts a string representation of the name of the field within this field access.

Returns the appropriate field parent scope.

Will attempt to retrieve index access types otherwise will return dummy value.

Not all frontends populate typeFullName for literals so we allow this to be overridden.

Tries to identify the underlying symbol from the call operation as it is used on the LHS of an assignment. The second element is a list of any associated global keys if applicable.

Given a call operation, will attempt to retrieve types from it.

Generates an identifier for collection/index-access operations in the symbol table.

A heuristic method to determine if an identifier may be a field or not. The result means that it would be stored in the global symbol table. By default this checks if the identifier name matches a member name.

Will attempt to find the return values of a method if in the CPG, otherwise will give a dummy value.

The initial import setting is over-approximated, so this step checks the CPG for any matches and prunes against these findings. If there are no findings, it will leave the table as is. The latter is significant for external types or methods.

Provides an entrypoint to add known symbols and their possible types.

Will build a call full path using the call base node. This method assumes the base node is in the symbol table.

Using an entry from the symbol table, will queue the CPG modification to persist the recovered type information.

Using assignment and import information (in the global symbol table), will propagate these types in the symbol table.

For each call that contains the returnValue directive, attempt to replace the return value by the dynamic

Visits a call operation being assigned to the result of some operation.

Visits a call assigned to the return value of a call. This is often when there are operators involved.

Visits a call assigned to an identifier. This is often when there are operators involved.

Handles a call operation assigned to a method/function pointer.

Visits an identifier being assigned to the result of some operation.

Visits an identifier being assigned to a call. This call could be an operation, function invocation, or constructor invocation.

Visits an identifier being assigned to a call's return value.

Visits an identifier being assigned to a constructor and attempts to speculate the constructor path.

Will handle an identifier being assigned to a field value.

Visits an identifier being assigned to the value held by another identifier. This is a weak copy.

Visits an identifier being assigned to the result of an index access operation.

Will handle literal value assignments. Override if special handling is required.

Will handle an identifier holding a function pointer.

Visits an identifier being assigned to an operator call.

Will handle an identifier holding a type pointer.

Visits an import and stores references in the symbol table as both an identifier and call.

Using import information and internally defined procedures, will generate a mapping between how functions and types are aliased and called and themselves.

Process each statement but only assign the type of the last statement to the identifier

Stores type information for local structures that live within this compilation unit, e.g. local variables.