KaFunctionCall¶

The list of KaCalls associated with the KaCallInfo. The list contains a single KaCall in case of a successful call, but may contain multiple candidates in case of an error call.

The flattened list of resolved calls.

• KaSimpleCallResolutionSuccess: the resolved call as a single-element list.

• KaSimpleCallResolutionError: the candidate calls.

• KaMultiCallResolutionAttempt: the assembled call if all sub-calls succeeded, or the combined calls from individual simpleAttempts otherwise.

The flattened list of KaSimpleCalls.

• If this is an instance of KaSimpleCall, the list will contain only this call

• If this is an instance of KaMultiCall, the list will contain KaMultiCall.calls

A combined mapping from the call's argument expressions to their associated parameter symbols in a stable order. This includes both value arguments and context arguments.

In case of vararg parameters, multiple arguments may be mapped to the same KaValueParameterSymbol.

See also

• valueArgumentMapping
• contextArgumentMapping

this call as a call to a constructor, or null if it is not a constructor call.

Example

annotation class Anno

class Foo

@Anno
fun usage() {
   Foo()
}

Both the Foo() call and the @Anno annotation entry are constructor calls, so constructor returns the call itself.

See also

• KaConstructorSymbol
• function

A mapping from the call's explicit context argument expressions to their associated context parameter symbols in a stable order.

Example

context(a: A, b: B)
fun foo() { ... }

fun test() {
    with(A()) {
        foo(b = B())  // explicit context argument `b = B()`
    }
}

For the foo(b = B()) call, contextArgumentMapping contains a single entry mapping the B() expression to the context parameter b: B.

See also

• valueArgumentMapping
• combinedArgumentMapping

The list of context parameters for this symbol access. The list is available if the callable is declared with context parameters.

The dispatch receiver for this symbol access. A dispatch receiver is available if the callable is declared inside a class or object.

The extension receiver for this symbol access. An extension receiver is available if the callable is declared with an extension receiver.

this call as a KaFunctionCall, or null if it is not a call to a function.

Example

class Foo {
   fun function() {}
   var int: Int = 1
}

fun Foo.usage() {
   function()
   int
}

For function(), function is the call to function. For int, which is a KaVariableAccessCall, function is null.

See also

• KaFunctionCall
• variable

The function or variable declaration.

this call as a KaSimpleCall, or null if it is a KaMultiCall.

Example

var int: Int = 1

fun usage() {
   int = 2
   int++
}

For int = 2, simple is the write access to int. For int++, which is a KaMultiCall, simple is null.

See also

• KaSimpleCall

The KaCallableSymbol of the KaCallableMemberCall's callee.

The resolved KaCallableSymbol of the KaSimpleCall.

This is a short-cut for KaCallableSignature.symbol.

The callable symbol which the KaPartiallyAppliedSymbol represents. While the information contained in a partially applied symbol is not exhaustive (e.g. applied functions are missing value arguments), the symbol of the callable which is called is definite.

The flattened list of KaSymbols for the resolved calls.

• If this is an instance of KaSimpleCall, the list will contain only the KaSimpleCall.signature's symbol

• If this is an instance of KaMultiCall, the list will contain symbols from all KaMultiCall.calls

A list of KaSymbol.

• If this is an instance of KaSimpleSymbolResolutionSuccess, the list will contain KaSimpleSymbolResolutionSuccess.symbols.

• If this is an instance of KaSimpleSymbolResolutionError, the list will contain KaSimpleSymbolResolutionError.candidateSymbols.

• If this is an instance of KaCompoundSymbolResolutionError, the list will contain the combined symbols from all attempts.

See also

• KaResolver.tryResolveSymbols

The KaLifetimeToken which determines the lifetime of the lifetime owner.

A map of inferred type arguments. If type placeholders were used, the actual inferred type will be used as a value. The keys for this map are from signature's type parameters.

In case of a resolution or inference error, the map might be empty.

A mapping from the call's argument expressions to their associated parameter symbols in a stable order. In case of vararg parameters, multiple arguments may be mapped to the same KaValueParameterSymbol.

See also

• contextArgumentMapping
• combinedArgumentMapping

this call as a KaVariableAccessCall, or null if it is not an access to a variable.

Example

class Foo {
   fun function() {}
   var int: Int = 1
}

fun Foo.usage() {
   int
   function()
}

For int, variable is the read access to int. For function(), which is a KaFunctionCall, variable is null.

See also

• KaVariableAccessCall
• function

Whether the lifetime owner is still valid, i.e. we are still in the scope of the lifetime owner's regular lifetime.

Executes action only if the KaLifetimeOwner is still valid and accessible. Otherwise, throws a validity exception based on the concrete violation.