KtLambdaExpression¶

open class KtLambdaExpression : LazyParseablePsiElement, KtExpression

Represents a lambda expression with optional parameters and a body.

Example:¶

val sum = { x: Int, y: Int -> x + y }
//        ^_________________________^

Constructors¶

KtLambdaExpression¶

constructor(text: CharSequence)

Companion properties¶

`ARRAY_FACTORY`¶

val ARRAY_FACTORY: ArrayFactory<PsiElement>

val ARRAY_FACTORY: ArrayFactory<KtExpression>

A factory for creating arrays of KtExpression, used by the PSI child-access machinery.

`EMPTY_ARRAY`¶

val EMPTY_ARRAY: Array<ASTNode>

val EMPTY_ARRAY: Array<LighterASTNode>

val EMPTY_ARRAY: Array<PsiElement>

val EMPTY_ARRAY: Array<CompositeElement>

val EMPTY_ARRAY: Array<TreeElement>

val EMPTY_ARRAY: Array<KtExpression>

A shared empty array, which can be reused to avoid unnecessary allocations.

`EMPTY_NAVIGATABLE_ARRAY`¶

val EMPTY_NAVIGATABLE_ARRAY: Array<Navigatable>

`EMPTY_NAVIGATABLE_ELEMENT_ARRAY`¶

val EMPTY_NAVIGATABLE_ELEMENT_ARRAY: Array<NavigatablePsiElement>

`EMPTY_NAVIGATION_ITEM_ARRAY`¶

val EMPTY_NAVIGATION_ITEM_ARRAY: Array<NavigationItem>

`FLAGS_LOCKED`¶

val FLAGS_LOCKED: Int = 2048

`ICON_FLAG_FAST_ONLY`¶

val ICON_FLAG_FAST_ONLY: Int = -2147483648

`ICON_FLAG_READ_STATUS`¶

val ICON_FLAG_READ_STATUS: Int = 2

`ICON_FLAG_VISIBILITY`¶

val ICON_FLAG_VISIBILITY: Int = 1

Companion functions¶

`buildRowIcon`¶

open fun buildRowIcon(baseIcon: Icon, visibilityIcon: Icon): @NotNull RowIcon

`iconWithVisibilityIfNeeded`¶

open fun iconWithVisibilityIfNeeded(
    flags: Int, 
    baseIcon: Icon, 
    visibility: Icon
): Icon

`isNativeFileType`¶

open fun isNativeFileType(fileType: FileType): Boolean

`setParsingAllowed`¶

open fun setParsingAllowed(allowed: Boolean)

`transformFlags`¶

open fun transformFlags(element: PsiElement, _flags: Int): Int

`withForcedDeferredIcons`¶

open fun withForcedDeferredIcons(runnable: @NotNull Runnable)

Properties¶

`allChildren`¶

val PsiElement.allChildren: PsiChildRange

The range of all direct children of this element, or an empty range if it has none.

`endOffset`¶

val PsiElement.endOffset: Int

The offset just past the end of this element's text range in the file.

`nextLeafs`¶

val PsiElement.nextLeafs: Sequence<PsiElement>

The following leaf elements as a lazy sequence, nearest first.

`parents`¶

val PsiElement.parents: Sequence<PsiElement>

The ancestors of this element, from its immediate parent up to and including the containing file.

`parentsWithSelf`¶

val PsiElement.parentsWithSelf: Sequence<PsiElement>

This element and its ancestors, from the element itself up to and including the containing file.

`prevLeafs`¶

val PsiElement.prevLeafs: Sequence<PsiElement>

The preceding leaf elements as a lazy sequence, nearest first.

`pureStartOffset`¶

val KtPureElement.pureStartOffset: Int

The start offset of this element's source, excluding any leading comments.

`startOffset`¶

val PsiElement.startOffset: Int

The offset of the start of this element's text range in the file.

`startOffsetSkippingComments`¶

val PsiElement.startOffsetSkippingComments: Int

The start offset of this element, skipping leading comments and the whitespace that follows them.

`textRangeWithoutComments`¶

val PsiElement.textRangeWithoutComments: TextRange

The text range of this element excluding any leading comments.

Functions¶

`accept`¶

abstract fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R

Dispatches this element to the corresponding visit* method of the given visitor and returns its result.

fun accept(@NotNull visitor: PsiElementVisitor)

open fun <R, D> accept(@NotNull visitor: KtVisitor<R, D>, data: D): R

Dispatches this element to the corresponding visit* method of the given visitor and returns its result.

`acceptChildren`¶

open fun acceptChildren(visitor: @NotNull PsiElementVisitor)

open fun <D> acceptChildren(@NotNull visitor: KtVisitor<Void, D>, data: D)

Passes each direct child of this element to the given visitor.

`acceptTree`¶

open fun acceptTree(visitor: @NotNull TreeElementVisitor)

`add`¶

open fun add(element: @NotNull PsiElement): PsiElement

`addAfter`¶

open fun addAfter(element: @NotNull PsiElement, anchor: PsiElement): PsiElement

`addBefore`¶

open fun addBefore(element: @NotNull PsiElement, anchor: PsiElement): PsiElement

`addChild`¶

open fun addChild(child: @NotNull ASTNode, anchorBefore: @Nullable ASTNode)

`addChildren`¶

open fun addChildren(
    firstChild: @NotNull ASTNode, 
    lastChild: @Nullable ASTNode, 
    anchorBefore: @Nullable ASTNode
)

`addInternal`¶

open fun addInternal(
    first: TreeElement, 
    last: ASTNode, 
    anchor: @Nullable ASTNode, 
    before: @Nullable Boolean
): TreeElement

`addLeaf`¶

open fun addLeaf(
    leafType: @NotNull IElementType, 
    leafText: @NotNull CharSequence, 
    anchorBefore: ASTNode
)

`addRange`¶

fun addRange(first: PsiElement, last: PsiElement): PsiElement

`addRangeAfter`¶

fun addRangeAfter(
    first: PsiElement, 
    last: PsiElement, 
    anchor: PsiElement
): PsiElement

`addRangeBefore`¶

fun addRangeBefore(
    first: @NotNull PsiElement, 
    last: @NotNull PsiElement, 
    anchor: PsiElement
): PsiElement

`anyDescendantOfType`¶

inline fun <reified T : PsiElement> PsiElement.anyDescendantOfType(noinline predicate: (T) -> Boolean = { true }): Boolean

Returns true if this element or any descendant of type T satisfies predicate.

inline fun <reified T : PsiElement> PsiElement.anyDescendantOfType(crossinline canGoInside: (PsiElement) -> Boolean, noinline predicate: (T) -> Boolean = { true }): Boolean

Returns true if this element or any descendant of type T satisfies predicate. canGoInside controls traversal into children but does not prevent the current element from being tested.

`applyDeleteOnReparse`¶

fun applyDeleteOnReparse(oldChild: @NotNull ASTNode)

`applyInsertOnReparse`¶

fun applyInsertOnReparse(newChild: @NotNull ASTNode, anchor: ASTNode)

`applyReplaceFileOnReparse`¶

fun applyReplaceFileOnReparse(psiFile: @NotNull PsiFile, newNode: @NotNull FileASTNode)

`applyReplaceOnReparse`¶

fun applyReplaceOnReparse(newChild: @NotNull ASTNode)

`asAssignment`¶

fun KtExpression.asAssignment(): KtBinaryExpression?

Returns this expression as a KtBinaryExpression if it is an assignment, or null otherwise.

asElement¶

@NotNull
open fun asElement(): KtElement

Returns this expression as a KtElement. Provided for uniformity with other callee/argument abstractions.

`before`¶

fun PsiElement.before(element: PsiElement): Boolean

Returns true if this element ends at or before element starts (that is, it precedes element in the file).

`blockExpressionsOrSingle`¶

fun KtElement.blockExpressionsOrSingle(): Sequence<KtElement>

Returns the statements of this element if it is a block, otherwise a single-element sequence of this element.

`canNavigate`¶

open fun canNavigate(): Boolean

`canNavigateToSource`¶

open fun canNavigateToSource(): Boolean

`checkAdd`¶

fun checkAdd(element: @NotNull PsiElement)

`checkDecompiledText`¶

fun PsiElement.checkDecompiledText()

Throws if this element belongs to a compiled file that is backed by a stub. Loading decompiled text is slow and should be avoided; stubs should be used instead. Called by the descendant-traversal helpers as a guard.

`checkDelete`¶

open fun checkDelete()

`children`¶

fun ASTNode.children(): Sequence<ASTNode>

The direct child nodes of this AST node, as a lazy sequence.

`clearCaches`¶

open fun clearCaches()

`clone`¶

open fun clone(): @NotNull CompositeElement

open fun clone(): @NotNull LazyParseablePsiElement

open fun clone(): @NotNull Any

`closestPsiElement`¶

fun ASTNode.closestPsiElement(): PsiElement?

Returns the nearest PSI element for this node, walking up to a parent node if this node has no PSI of its own.

`collectDescendantsOfType`¶

inline fun <reified T : PsiElement> PsiElement.collectDescendantsOfType(noinline predicate: (T) -> Boolean = { true }): List<T>

Collects this element and all descendants of type T satisfying predicate into a list in post-order.

inline fun <reified T : PsiElement> PsiElement.collectDescendantsOfType(crossinline canGoInside: (PsiElement) -> Boolean, noinline predicate: (T) -> Boolean = { true }): List<T>

Collects this element and all descendants of type T satisfying predicate into a list in post-order. canGoInside controls traversal into children but does not prevent the current element from being collected.

`collectDescendantsOfTypeTo`¶

inline fun <reified T : PsiElement, C : MutableCollection<T>> PsiElement.collectDescendantsOfTypeTo(
    to: C, 
    crossinline canGoInside: (PsiElement) -> Boolean, 
    noinline predicate: (T) -> Boolean = { true }
): C

Adds this element and all descendants of type T satisfying predicate to to in post-order. canGoInside controls traversal into children but does not prevent the current element from being added.

`containingClass`¶

fun KtElement.containingClass(): KtClass?

Returns the nearest enclosing KtClass, or null if there is none.

`copy`¶

open fun copy(): PsiElement

`copyCopyableDataTo`¶

open fun copyCopyableDataTo(clone: @NotNull UserDataHolderBase)

`copyElement`¶

open fun copyElement(): ASTNode

`copyTo`¶

open fun copyTo(buffer: @Nullable Array<Char>, start: Int): Int

`copyUserDataTo`¶

open fun copyUserDataTo(other: @NotNull UserDataHolderBase)

`countChildren`¶

open fun countChildren(filter: @Nullable TokenSet): Int

`delete`¶

open fun delete()

`deleteChildInternal`¶

open fun deleteChildInternal(child: @NotNull ASTNode)

`deleteChildRange`¶

open fun deleteChildRange(first: PsiElement, last: PsiElement)

`equals`¶

fun equals(obj: Any): Boolean

`findChildByRole`¶

open fun findChildByRole(role: Int): @Nullable ASTNode

`findChildByRoleAsPsiElement`¶

fun findChildByRoleAsPsiElement(role: Int): @Nullable PsiElement

`findChildByType`¶

open fun findChildByType(type: @NotNull IElementType): ASTNode

`findDescendantOfType`¶

inline fun <reified T : PsiElement> PsiElement.findDescendantOfType(noinline predicate: (T) -> Boolean = { true }): T?

Returns the first element of type T in a pre-order traversal of this element and its descendants that satisfies predicate, or null if there is none.

inline fun <reified T : PsiElement> PsiElement.findDescendantOfType(crossinline canGoInside: (PsiElement) -> Boolean, noinline predicate: (T) -> Boolean = { true }): T?

Returns the first element of type T in a pre-order traversal of this element and its descendants that satisfies predicate, or null. canGoInside controls traversal into children but does not prevent the current element from being tested.

`findElementAt`¶

open fun findElementAt(offset: Int): PsiElement

`findLeafElementAt`¶

abstract fun findLeafElementAt(p: Int): @Nullable ASTNode

open fun findLeafElementAt(offset: Int): LeafElement

`findPsiChildByType`¶

open fun findPsiChildByType(type: @NotNull IElementType): @Nullable PsiElement

`findReferenceAt`¶

open fun findReferenceAt(offset: Int): PsiReference

`forEachDescendantOfType`¶

inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfType(noinline action: (T) -> Unit)

Applies action to this element and every descendant of type T, in post-order (children before parents).

inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfType(crossinline canGoInside: (PsiElement) -> Boolean, noinline action: (T) -> Unit)

Applies action to this element and every descendant of type T, in post-order. canGoInside controls whether each visited element's children are traversed; the element itself is still passed to action when it is a T, even if canGoInside returns false for it.

`forEachDescendantOfTypeInPreorder`¶

inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfTypeInPreorder(noinline action: (T) -> Unit)

Applies action to this element and every descendant of type T, in pre-order (parents before children).

inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfTypeInPreorder(crossinline canGoInside: (PsiElement) -> Boolean, noinline action: (T) -> Unit)

Applies action to this element and every descendant of type T, in pre-order. canGoInside controls whether each visited element's children are traversed; the element itself is still passed to action when it is a T, even if canGoInside returns false for it.

`getAnnotationEntries`¶

fun KtExpression.getAnnotationEntries(): List<KtAnnotationEntry>

Returns the annotation entries applied to this expression through an enclosing annotated (or labeled) expression, or an empty list if there are none.

`getAssignmentByLHS`¶

fun KtExpression.getAssignmentByLHS(): KtBinaryExpression?

Returns the assignment in which this expression is the left-hand side, or null if it is not assigned to.

`getAssignmentLhsIfUnwrappable`¶

fun PsiElement.getAssignmentLhsIfUnwrappable(): PsiElement?

Returns the operand this operation applies to, but only when that operand is wrapped in parentheses, a label, or annotations; returns null otherwise.

`getBinaryWithTypeParent`¶

fun KtExpression.getBinaryWithTypeParent(): KtBinaryExpressionWithTypeRHS?

Returns the as/as? expression whose left-hand side is a call with this expression as its direct child, normally its callee. The call may be the selector of a qualified expression, and the call or qualified expression may be parenthesized. Returns null otherwise.

getBodyExpression¶

@Nullable
open fun getBodyExpression(): KtBlockExpression

Returns the body block of the lambda, or null if it is absent in incomplete code.

`getCachedLength`¶

open fun getCachedLength(): Int

`getChars`¶

open fun getChars(): @NotNull CharSequence

`getChildOfType`¶

inline fun <reified T : PsiElement> PsiElement.getChildOfType(): T?

Returns the first direct child of type T, or null if there is none.

`getChildren`¶

open fun getChildren(filter: @Nullable TokenSet): @NotNull Array<ASTNode>

open fun getChildren(): @NotNull Array<PsiElement>

`getChildrenAsPsiElements`¶

open fun <T : PsiElement?> getChildrenAsPsiElements(filter: @Nullable TokenSet, constructor: @NotNull ArrayFactory<out T>): @NotNull Array<T>

`getChildrenOfType`¶

inline fun <reified T : PsiElement> PsiElement.getChildrenOfType(): Array<T>

Returns the direct children of type T, or an empty array if there are none.

`getChildRole`¶

open fun getChildRole(child: @NotNull ASTNode): Int

`getContainingFile`¶

open fun getContainingFile(): PsiFile

getContainingKtFile¶

@NotNull
open fun getContainingKtFile(): KtFile

Returns the KtFile this element belongs to.

`getContainingKtFile`¶

fun LazyParseablePsiElement.getContainingKtFile(): KtFile

Returns the KtFile containing this element.

`getContext`¶

open fun getContext(): PsiElement

`getCopyableUserData`¶

abstract fun <T> getCopyableUserData(p: @NotNull Key<T>): @Nullable T

`getElementTextWithContext`¶

fun PsiElement.getElementTextWithContext(): String

Returns this element's text with surrounding source context, for use in diagnostics and log messages.

`getElementType`¶

open fun getElementType(): @NotNull IElementType

`getEndOffset`¶

open fun getEndOffset(): Int

`getExplicitReceiverOfDotQualified`¶

fun PsiElement.getExplicitReceiverOfDotQualified(): PsiElement?

Returns the source of the explicit receiver if this element is a dot-qualified expression, or null otherwise.

`getFirstChild`¶

open fun getFirstChild(): PsiElement

`getFirstChildNode`¶

abstract fun getFirstChildNode(): ASTNode

open fun getFirstChildNode(): TreeElement

getFunctionLiteral¶

@NotNull
open fun getFunctionLiteral(): KtFunctionLiteral

Returns the underlying function literal, which holds the parameters and body of the lambda. A lambda expression always wraps exactly one function literal.

`getIcon`¶

open fun getIcon(flags: Int): @Nullable Icon

`getLabeledParent`¶

fun KtExpression.getLabeledParent(labelName: String): KtLabeledExpression?

Returns the nearest enclosing labeled expression with the given labelName, or null if there is none.

`getLanguage`¶

open fun getLanguage(): @NotNull Language

`getLastChild`¶

open fun getLastChild(): PsiElement

`getLastChildNode`¶

abstract fun getLastChildNode(): ASTNode

open fun getLastChildNode(): TreeElement

`getLastParentOfTypeInRow`¶

inline fun <reified T : PsiElement> PsiElement.getLastParentOfTypeInRow(): T?

Returns the outermost element in an uninterrupted chain of ancestors of type T, or null if the parent is not a T.

`getLastParentOfTypeInRowWithSelf`¶

inline fun <reified T : PsiElement> PsiElement.getLastParentOfTypeInRowWithSelf(): T?

Like getLastParentOfTypeInRow, but the chain may start at this element itself.

getLeftCurlyBrace¶

@NotNull
open fun getLeftCurlyBrace(): ASTNode

Returns the AST node of the lambda's opening brace {.

`getManager`¶

abstract fun getManager(): PsiManager

open fun getManager(): PsiManagerEx

getModificationStamp¶

fun KtElement.getModificationStamp(): Long

Returns the modification stamp of the nearest enclosing element that tracks one (a file, a stub-based declaration, or a supertype list). The stamp changes whenever that element's subtree is modified, so it can be used to invalidate caches keyed on this element.

`getName`¶

open fun getName(): String

`getNavigationElement`¶

open fun getNavigationElement(): @NotNull PsiElement

`getNextSibling`¶

open fun getNextSibling(): PsiElement

`getNextSiblingIgnoringWhitespace`¶

fun PsiElement.getNextSiblingIgnoringWhitespace(withItself: Boolean = false): PsiElement?

Returns the next sibling that is not whitespace, or null. Considers this element if withItself.

`getNextSiblingIgnoringWhitespaceAndComments`¶

fun PsiElement.getNextSiblingIgnoringWhitespaceAndComments(withItself: Boolean = false): PsiElement?

Returns the next sibling that is neither whitespace nor a comment, or null. Considers this element if withItself.

`getNode`¶

open fun getNode(): @NotNull ASTNode

`getNonStrictParentOfType`¶

inline fun <reified T : PsiElement> PsiElement.getNonStrictParentOfType(): T?

Returns the nearest ancestor of type T including this element, or null if there is none.

fun <T : PsiElement> PsiElement.getNonStrictParentOfType(parentClass: Class<T>): T?

Returns the nearest ancestor of type T (including this element), or null if there is none.

`getOriginalElement`¶

open fun getOriginalElement(): PsiElement

`getOutermostParentContainedIn`¶

tailrec fun PsiElement.getOutermostParentContainedIn(container: PsiElement): PsiElement?

Returns the outermost element on the path from this element that is still strictly contained in container, or null.

`getOutermostParenthesizerOrThis`¶

fun KtExpression.getOutermostParenthesizerOrThis(): KtExpression

Returns the outermost expression that wraps this one only through parentheses, labels, or annotations, or this expression itself.

`getOwnDeclarations`¶

open fun getOwnDeclarations(): @NotNull Collection<out @NotNull PsiSymbolDeclaration>

`getOwnReferences`¶

open fun getOwnReferences(): @NotNull Collection<out @NotNull PsiSymbolReference>

`getParent`¶

open fun getParent(): PsiElement

abstract fun getParent(): PsiElement

Returns parent source element.

`getParentOfType`¶

inline fun <reified T : PsiElement> PsiElement.getParentOfType(strict: Boolean): T?

Returns the nearest ancestor of type T, or null. When strict is false, this element itself is also considered.

inline fun <reified T : PsiElement> PsiElement.getParentOfType(strict: Boolean, vararg stopAt: Class<out PsiElement>): T?

Returns the nearest ancestor of type T, stopping the search once an ancestor of any type in stopAt is reached, or null. When strict is false, this element itself is also considered.

`getParentOfTypeAndBranch`¶

inline fun <reified T : PsiElement> PsiElement.getParentOfTypeAndBranch(strict: Boolean = false, noinline branch: T.() -> PsiElement?): T?

Checks the nearest element of type T and returns it if this element lies within the subtree selected by branch. If that candidate's branch does not contain this element, returns null without checking higher ancestors. When strict is false, this element itself is also considered as the candidate.

`getParentOfTypeAndBranches`¶

inline fun <reified T : PsiElement> PsiElement.getParentOfTypeAndBranches(strict: Boolean = false, noinline branches: T.() -> Iterable<PsiElement?>): T?

Checks the nearest element of type T and returns it if this element lies within any subtree selected by branches. If none of that candidate's branches contain this element, returns null without checking higher ancestors. When strict is false, this element itself is also considered as the candidate.

`getParentOfTypes`¶

fun <T : PsiElement> PsiElement.getParentOfTypes(strict: Boolean = false, vararg parentClasses: Class<out T>): T?

Returns the nearest ancestor that is an instance of one of parentClasses, or null if there is none. When strict is false, this element itself is also considered.

`getParentOfTypes2`¶

inline fun <reified T : PsiElement, reified V : PsiElement> PsiElement.getParentOfTypes2(): PsiElement?

Returns the nearest strict ancestor that is a T or V, or null if there is none.

`getParentOfTypes3`¶

inline fun <reified T : PsiElement, reified V : PsiElement, reified U : PsiElement> PsiElement.getParentOfTypes3(): PsiElement?

Returns the nearest strict ancestor that is a T, V, or U, or null if there is none.

`getParentOfTypesAndPredicate`¶

fun <T : PsiElement> PsiElement.getParentOfTypesAndPredicate(
    strict: Boolean = false, 
    vararg parentClasses: Class<out T>, 
    predicate: (T) -> Boolean
): T?

Returns the nearest ancestor that is an instance of one of parentClasses and satisfies predicate, or null. When parentClasses is empty, any type matches. When strict is false, this element itself is also considered.

`getPossiblyQualifiedCallExpression`¶

fun KtExpression.getPossiblyQualifiedCallExpression(): KtCallExpression?

Returns the call expression this expression represents: the selector's call for a qualified expression, or this expression if it is itself a call. Returns null if there is no call.

`getPresentation`¶

open fun getPresentation(): ItemPresentation

`getPrevSibling`¶

open fun getPrevSibling(): PsiElement

`getPrevSiblingIgnoringWhitespace`¶

fun PsiElement.getPrevSiblingIgnoringWhitespace(withItself: Boolean = false): PsiElement?

Returns the previous sibling that is not whitespace, or null. Considers this element if withItself.

`getPrevSiblingIgnoringWhitespaceAndComments`¶

fun PsiElement.getPrevSiblingIgnoringWhitespaceAndComments(withItself: Boolean = false): PsiElement?

Returns the previous sibling that is neither whitespace nor a comment, or null. Considers this element if withItself.

`getProject`¶

open fun getProject(): @NotNull Project

`getPsi`¶

fun getPsi(): PsiElement

open fun <T : PsiElement?> getPsi(clazz: @NotNull Class<T>): T

getPsiOrParent¶

@NotNull
open fun getPsiOrParent(): KtElement

Returns this or parent source element (for synthetic element declarations). Use it only for the purposes of source attribution.

`getQualifiedElementSelector`¶

fun KtElement.getQualifiedElementSelector(): KtElement?

Returns the rightmost selector of this qualified element, or null if there is no such selector.

`getQualifiedExpressionForReceiver`¶

fun KtExpression.getQualifiedExpressionForReceiver(): KtQualifiedExpression?

Returns the qualified expression in which this expression is the receiver, or null if it is not a receiver.

`getQualifiedExpressionForReceiverOrThis`¶

fun KtExpression.getQualifiedExpressionForReceiverOrThis(): KtExpression

Returns the qualified expression in which this expression is the receiver, or this expression itself otherwise.

`getQualifiedExpressionForSelector`¶

fun KtElement.getQualifiedExpressionForSelector(): KtQualifiedExpression?

Returns the qualified expression in which this element is the selector, or null if it is not a selector.

`getQualifiedExpressionForSelectorOrThis`¶

fun KtExpression.getQualifiedExpressionForSelectorOrThis(): KtExpression

Returns the qualified expression in which this expression is the selector, or this expression itself otherwise.

`getReference`¶

open fun getReference(): PsiReference

abstract fun getReference(): PsiReference

`getReferences`¶

open fun getReferences(): @NotNull Array<PsiReference>

`getResolveScope`¶

open fun getResolveScope(): @NotNull GlobalSearchScope

getRightCurlyBrace¶

@Nullable
open fun getRightCurlyBrace(): ASTNode

Returns the AST node of the lambda's closing brace }, or null if it is absent in incomplete code.

`getStartOffset`¶

open fun getStartOffset(): Int

`getStartOffsetIn`¶

fun PsiElement.getStartOffsetIn(ancestor: PsiElement): Int

Returns the offset of this element relative to the start of ancestor (which must be an ancestor of this element).

`getStartOffsetInParent`¶

abstract fun getStartOffsetInParent(): Int

`getStrictParentOfType`¶

inline fun <reified T : PsiElement> PsiElement.getStrictParentOfType(): T?

Returns the nearest strict ancestor of type T, or null if there is none.

`getText`¶

open fun getText(): @NotNull String

`getTextLength`¶

open fun getTextLength(): Int

`getTextOffset`¶

abstract fun getTextOffset(): Int

`getTextRange`¶

abstract fun getTextRange(): TextRange

`getTextRangeInParent`¶

open fun getTextRangeInParent(): @NotNull TextRange

`getTextWithLocation`¶

fun PsiElement.getTextWithLocation(): String

Returns this element's text together with its source location, for use in diagnostics and log messages.

`getTokenType`¶

open fun getTokenType(): IElementType

`getTopmostParentOfType`¶

inline fun <reified T : PsiElement> PsiElement.getTopmostParentOfType(): T?

Returns the outermost ancestor of type T including this element, or null if there is none.

`getTreeNext`¶

abstract fun getTreeNext(): ASTNode

fun getTreeNext(): TreeElement

`getTreeParent`¶

abstract fun getTreeParent(): ASTNode

fun getTreeParent(): CompositeElement

`getTreePrev`¶

abstract fun getTreePrev(): ASTNode

fun getTreePrev(): TreeElement

`getUserData`¶

open fun <T> getUserData(key: @NotNull Key<T>): T

`getUserDataString`¶

open fun getUserDataString(): String

`getUserMap`¶

open fun getUserMap(): @NotNull KeyFMap

`getUseScope`¶

open fun getUseScope(): @NotNull SearchScope

getValueParameters¶

@NotNull
open fun getValueParameters(): List<KtParameter>

Returns the explicitly declared parameters of the lambda, or an empty list if none are declared. This method does not synthesize an implicit it parameter.

hasDeclaredReturnType¶

open fun hasDeclaredReturnType(): Boolean

Returns true if the underlying function literal has a return type reference. Valid lambda syntax cannot declare an explicit return type, so this can only be true for inconsistent PSI.

`hc`¶

open fun hc(): Int

`isAncestor`¶

fun PsiElement?.isAncestor(element: PsiElement, strict: Boolean = false): Boolean

Returns true if this element is an ancestor of element. When strict is false, an element is its own ancestor.

`isContextualDeclaration`¶

fun KtElement.isContextualDeclaration(): Boolean

Returns true if this callable, class, or object declares at least one legacy context receiver. Named context parameters are ignored.

`isContractDescriptionCallPsiCheck`¶

fun KtExpression.isContractDescriptionCallPsiCheck(): Boolean

Best-effort PSI check for whether this expression is a contract { ... } (or kotlin.contracts.contract { ... }) call.

`isCopyableDataEqual`¶

open fun isCopyableDataEqual(other: @NotNull UserDataHolderBase): Boolean

`isDotReceiver`¶

fun KtExpression.isDotReceiver(): Boolean

Returns true if this expression is the receiver of an enclosing dot-qualified expression.

`isDotSelector`¶

fun KtExpression.isDotSelector(): Boolean

Returns true if this expression is the selector of an enclosing dot-qualified expression.

`isEquivalentTo`¶

open fun isEquivalentTo(another: PsiElement): Boolean

`isExtensionDeclaration`¶

fun PsiElement.isExtensionDeclaration(): Boolean

Returns true if this element is an extension function or property (that is, it declares a receiver).

`isFirstStatement`¶

fun KtElement.isFirstStatement(): Boolean

Returns true if this element is the first statement of its enclosing block.

`isFunctionalExpression`¶

fun PsiElement.isFunctionalExpression(): Boolean

Returns true if this element is an anonymous function, such as the fun expression in val predicate = fun(x: Int): Boolean = x > 0.

`isInImportDirective`¶

fun KtExpression.isInImportDirective(): Boolean

Returns true if this expression appears inside an import directive.

`isInsideOf`¶

fun PsiElement.isInsideOf(elements: Iterable<PsiElement>): Boolean

Returns true if this element lies within, or is equal to, any of the given elements.

`isLambdaOutsideParentheses`¶

fun KtExpression.isLambdaOutsideParentheses(): Boolean

Returns true if this expression is a trailing lambda argument written outside the call parentheses.

`isNull`¶

fun KtExpression.isNull(): Boolean

Returns true if this expression is the null literal. Smart-casts the receiver to KtConstantExpression on true.

`isParsed`¶

open fun isParsed(): Boolean

`isPhysical`¶

open fun isPhysical(): Boolean

`isTopLevelKtOrJavaMember`¶

fun PsiElement.isTopLevelKtOrJavaMember(): Boolean

Returns true if this element is a top-level member of a Kotlin file or a top-level Java class.

isTrailingLambdaOnNewLine¶

fun isTrailingLambdaOnNewLine(): Boolean

Returns true if this lambda is a trailing lambda argument placed on a line of its own (separated from the call by a line break). This is a formatting property used by the IDE.

`isUserDataEmpty`¶

open fun isUserDataEmpty(): Boolean

`isValid`¶

open fun isValid(): Boolean

`isWritable`¶

open fun isWritable(): Boolean

`lastBlockStatementOrThis`¶

fun KtExpression.lastBlockStatementOrThis(): KtExpression

Returns the last statement if this expression is a block, otherwise this expression itself.

`leaves`¶

fun ASTNode.leaves(forward: Boolean = true): Sequence<ASTNode>

The leaf nodes following (or preceding, if not forward) this AST node, as a lazy sequence.

`navigate`¶

open fun navigate(requestFocus: Boolean)

`navigationRequest`¶

open fun navigationRequest(): NavigationRequest

`nextLeaf`¶

fun PsiElement.nextLeaf(skipEmptyElements: Boolean = false): PsiElement?

Returns the next leaf element in the tree, or null if there is none. Empty leaves are skipped if skipEmptyElements.

fun PsiElement.nextLeaf(filter: (PsiElement) -> Boolean): PsiElement?

Returns the nearest following leaf that satisfies filter, or null if there is none.

`nonStaticOuterClasses`¶

fun KtElement.nonStaticOuterClasses(): Sequence<KtClass>

Returns the enclosing classes that this element can access an outer instance of, from innermost to outermost.

`parameterIndex`¶

fun PsiElement.parameterIndex(): Int

Returns the index of this parameter within its own parameter list (Kotlin or Java), or -1 if it is not a parameter.

`parents`¶

fun ASTNode.parents(): Sequence<ASTNode>

The ancestor nodes of this AST node, from its parent upward, as a lazy sequence.

`prevLeaf`¶

fun PsiElement.prevLeaf(skipEmptyElements: Boolean = false): PsiElement?

Returns the previous leaf element in the tree, or null if there is none. Empty leaves are skipped if skipEmptyElements.

fun PsiElement.prevLeaf(filter: (PsiElement) -> Boolean): PsiElement?

Returns the nearest preceding leaf that satisfies filter, or null if there is none.

`processDeclarations`¶

open fun processDeclarations(
    processor: @NotNull PsiScopeProcessor, 
    state: @NotNull ResolveState, 
    lastParent: PsiElement, 
    place: @NotNull PsiElement
): Boolean

`putCopyableUserData`¶

abstract fun <T> putCopyableUserData(p: @NotNull Key<T>, p1: @Nullable T)

`putUserData`¶

open fun <T> putUserData(key: @NotNull Key<T>, value: @Nullable T)

`putUserDataIfAbsent`¶

open fun <T> putUserDataIfAbsent(key: @NotNull Key<T>, value: @NotNull T): @NotNull T

`rawAddChildren`¶

fun rawAddChildren(first: @NotNull TreeElement)

`rawAddChildrenWithoutNotifications`¶

open fun rawAddChildrenWithoutNotifications(first: @NotNull TreeElement)

rawDelete¶

open fun rawDelete()

Deletes this PSI element using the raw platform implementation, bypassing Kotlin PSI-specific delete overrides.

Regular clients should use delete instead. When KtPsiMutationService is not registered, it performs the same plain deletion, and when the service is registered, as in the IntelliJ Kotlin plugin, it may also adjust the surrounding code, e.g., delete a semicolon that follows the element.

`rawFirstChild`¶

open fun rawFirstChild(): TreeElement

`rawInsertAfterMe`¶

open fun rawInsertAfterMe(firstNew: @NotNull TreeElement)

`rawInsertBeforeMe`¶

open fun rawInsertBeforeMe(firstNew: @NotNull TreeElement)

`rawLastChild`¶

open fun rawLastChild(): TreeElement

`rawRemove`¶

open fun rawRemove()

`rawRemoveAllChildren`¶

open fun rawRemoveAllChildren()

`rawRemoveUpTo`¶

open fun rawRemoveUpTo(end: @Nullable TreeElement)

`rawRemoveUpToLast`¶

open fun rawRemoveUpToLast()

`rawReplaceWithList`¶

open fun rawReplaceWithList(firstNew: @Nullable TreeElement)

`referenceExpression`¶

fun KtExpression.referenceExpression(): KtReferenceExpression?

Returns the reference expression of this expression (the callee for a call), or null if it is not a reference.

`removeAllChildren`¶

open fun removeAllChildren()

`removeChild`¶

open fun removeChild(child: @NotNull ASTNode)

`removeRange`¶

open fun removeRange(first: @NotNull ASTNode, firstWhichStayInTree: @Nullable ASTNode)

`replace`¶

open fun <T> replace(
    key: @NotNull Key<T>, 
    oldValue: @Nullable T, 
    newValue: @Nullable T
): Boolean

open fun replace(newElement: @NotNull PsiElement): PsiElement

`replaceAllChildrenToChildrenOf`¶

open fun replaceAllChildrenToChildrenOf(anotherParent: @NotNull ASTNode)

`replaceChild`¶

open fun replaceChild(oldChild: @NotNull ASTNode, newChild: @NotNull ASTNode)

`replaceChildInternal`¶

open fun replaceChildInternal(child: @NotNull ASTNode, newElement: @NotNull TreeElement)

`setPsi`¶

open fun setPsi(psi: @NotNull PsiElement)

shouldChangeModificationCount¶

open fun shouldChangeModificationCount(place: PsiElement): Boolean

Always returns false: changes inside a lambda never affect the out-of-code-block modification count.

Kept for compatibility with potential plugins.

`siblings`¶

fun ASTNode.siblings(forward: Boolean = true): Sequence<ASTNode>

The sibling nodes of this AST node, going forward (or backward), as a lazy sequence.

fun PsiElement.siblings(forward: Boolean = true, withItself: Boolean = true): Sequence<PsiElement>

Returns the siblings of this element as a lazy sequence, going forward (or backward) and optionally including the element itself (withItself).

`startsWithComment`¶

fun PsiElement.startsWithComment(): Boolean

Returns true if this element's first child is a comment.

`subtreeChanged`¶

open fun subtreeChanged()

`textContains`¶

open fun textContains(c: Char): Boolean

`textMatches`¶

abstract fun textMatches(p: @NotNull @NonNls CharSequence): Boolean

`textToCharArray`¶

abstract fun textToCharArray(): @NotNull Array<Char>

`topParenthesizedParentOrMe`¶

fun KtExpression.topParenthesizedParentOrMe(): KtExpression

Returns the outermost enclosing expression that this expression is wrapped in only through parentheses, or this expression itself.

toString¶

open fun toString(): String

unpackFunctionLiteral¶

fun KtExpression.unpackFunctionLiteral(allowParentheses: Boolean = false): KtLambdaExpression?

If this expression is a lambda expression, or wraps one in a label or an annotation, returns that KtLambdaExpression; otherwise returns null. Parentheses are unwrapped only when allowParentheses is true.

`unwrapParenthesesLabelsAndAnnotations`¶

fun PsiElement?.unwrapParenthesesLabelsAndAnnotations(): PsiElement?

Recursively unwraps this element while it is a parenthesized, labeled, or annotated expression, returning the innermost base element. A non-wrapper element is returned unchanged.

`unwrapParenthesesLabelsAndAnnotationsDeeply`¶

fun PsiElement.unwrapParenthesesLabelsAndAnnotationsDeeply(): PsiElement

Walks up through immediately enclosing parentheses, labels, and annotations, returning the first parent outside that wrapper chain.