Skip to content

KaCompoundArrayAccessCall

@SubclassOptInRequired(markerClass = [KaImplementationDetail::class])
interface KaCompoundArrayAccessCall : KaMultiCall, KaCall, KaCompoundAccessCall

A compound access using the array access convention, involving calls to both the get() and set() functions. For example, a[1] += "foo" is such an array compound access.

Example

fun test(m: MutableMap<String, String>) {
  m["a"] += "b"
  // indexArguments: ["a"]
  // getPartiallyAppliedSymbol: {
  //   symbol: MutableMap.get()
  //   dispatchReceiver: `m`
  //   extensionReceiver: null
  // }
  // setPartiallyAppliedSymbol: {
  //   symbol: MutableMap.set()
  //   dispatchReceiver: `m`
  //   extensionReceiver: null
  // }
  // accessType: OpAssign {
  //   kind: PLUS
  //   operand: "b"
  //   operationSymbol: String?.plus()
  // }
}

Such a call always involves both calls to the get and set functions. With the example above, a call to String?.plus is sandwiched between a get and a set call to compute the new value passed to set.

<op>Assign function calls

Simple access using the array access convention is not captured by this class. If the collection has an <op>Assign operator, the call is represented as a simple KaFunctionCall.

For example, assuming ThrowingMap throws in case of an absent key instead of returning null:

fun test(m: ThrowingMap<String, MutableList<String>>) {
  m["a"] += "b"
}

The above call is represented as a simple KaFunctionCall to MutableList.plusAssign, with the dispatch receiver referencing the expression m["a"], which is again a simple KaFunctionCall to ThrowingMap.get.

Properties

calls

abstract val calls: List<KaSimpleCall<*, *>>

The non-empty list of KaSimpleCalls that were discovered during resolution of KtResolvableCall

calls

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.

The flattened list of KaSimpleCalls.

compoundOperation

The corresponding compound operation.

constructor

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

function

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

getterCall

A call of the get function that's invoked when reading values corresponding to the given indexArguments.

indexArguments

The arguments representing the indices in the index access operator call.

Example

m1["a"] += "b"   // A single index argument `"a"`.
m2[1, 5] += 12   // Two index arguments, `1` and `5`.

operationCall

Represents a call of the operator

setterCall

A call of the set function that's invoked when writing values corresponding to the given indexArguments and the computed value from the operation

simple

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

symbols

The flattened list of KaSymbols for the resolved calls.

A list of KaSymbol.

See also

token

abstract val token: KaLifetimeToken

The KaLifetimeToken which determines the lifetime of the lifetime owner.

variable

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

Functions

assertIsValidAndAccessible

isValid

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

withValidityAssertion

inline fun <R> KaLifetimeOwner.withValidityAssertion(action: () -> R): R

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