RecoverForXCompilationUnit

Convenience class for transporting field names.

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

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.

Given an identifier that has been determined to be a field, an attempt is made to get the corresponding member. This implementation follows more the way dynamic languages define method/type relations.

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.

This has found to be an expensive operation accessed often so we have memoized this step.

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

Given a type full name and member name, will persist the given types to the member.

Allows an implementation to perform an operation once type persistence is complete.

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.

If there is only 1 type hint then this is set to the typeFullName property and dynamicTypeHintFullName is cleared. If not then dynamicTypeHintFullName is set to the types.

Allows one to modify the types assigned to nodes otherwise.

Allows one to modify the types assigned to identifiers.

Allows one to modify the types assigned to locals.

Type decls where member access are required need to point to the correct type decl that holds said members. This allows implementations to use the type names to find the correct type holding members.

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

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.

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

New node tracking set.

The root of the target codebase.

For tracking members and the type operations that need to be performed. Since these are mostly out of scope locally it helps to track these separately.

// TODO: Potentially a new use for a global table or modification to the symbol table?

The delimiter used to separate methods/functions in qualified names.

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