Skip to content

KtNameReferenceExpression

class KtNameReferenceExpression : KtExpressionImplStub<KotlinNameReferenceExpressionStub> , KtSimpleNameExpression, KtResolvableCall

Represents a simple name reference to a variable, function, or type.

Example:

val x = foo
//      ^_^

Analysis API Resolver Notes:

Resolves the declaration symbol referenced by the given KtNameReferenceExpression.

Note: Unlike other KtResolvableCall entry points that provide both resolveSuccessfulCall and resolveSuccessfulSymbol specializations, KtNameReferenceExpression.resolveSuccessfulCall may return a different KaSymbol.

For instance, this happens for constructor references. While resolveSuccessfulCall returns a KaConstructorSymbol, this method returns the corresponding KaClassLikeSymbol.

Example #1

fun foo() {}

val x = foo
//      ^^^

Calling resolveSuccessfulSymbol() on the KtNameReferenceExpression (foo) returns the KaDeclarationSymbol of foo if resolution succeeds; otherwise, it returns null (e.g., when unresolved or ambiguous).

KtNameReferenceExpression might be resolved not only to callables but also to types.

Example #2

class MyClass
object MyObject

val c = MyClass()
//      ^^^^^^^  resolves to the class `MyClass`

val o = MyObject
//      ^^^^^^^^  resolves to the object `MyObject`

Constructors

KtNameReferenceExpression

constructor(node: ASTNode)

Types

Companion

object Companion

Properties

allChildren

val PsiElement.allChildren: PsiChildRange

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

children

open override val children: @NotNull Array<out PsiElement>

containingFile

@get:NotNull
open override val containingFile: @NotNull PsiFile

containingKtFile

@get:NotNull
open override val containingKtFile: KtFile

context

open override val context: PsiElement?

elementType

open override val elementType: @NotNull IStubElementType<*, *>

endOffset

val PsiElement.endOffset: Int

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

firstChild

open override val firstChild: PsiElement?

greenStub

@get:Nullable
override val greenStub: @Nullable KotlinNameReferenceExpressionStub?

iElementType

open override val iElementType: IElementType?

isPhysical

open override val isPhysical: Boolean

isPlaceholder

true if this reference is the underscore placeholder _ (used, for example, to ignore a destructuring component or a lambda parameter).

isUnderscoreInBackticks

true if this reference is the backtick-escaped underscore identifier `_` (distinct from the plain _ placeholder).

isUserDataEmpty

isValid

open override val isValid: Boolean

isWritable

open override val isWritable: Boolean

language

@get:NotNull
open override val language: Language

lastChild

open override val lastChild: PsiElement?

manager

open override val manager: PsiManagerEx?

name

open override val name: String?

@get:NotNull
open override val navigationElement: @NotNull PsiElement

nextLeafs

val PsiElement.nextLeafs: Sequence<PsiElement>

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

nextSibling

open override val nextSibling: PsiElement?

node

@get:NotNull
open override var node: @NotNull ASTNode

originalElement

open override val originalElement: PsiElement?

ownDeclarations

@get:NotNull
open val ownDeclarations: @NotNull Collection<out @NotNull PsiSymbolDeclaration>

ownReferences

@get:NotNull
open val ownReferences: @NotNull Collection<out @NotNull PsiSymbolReference>

parent

open override val parent: PsiElement?

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.

presentation

open override val presentation: ItemPresentation?

prevLeafs

val PsiElement.prevLeafs: Sequence<PsiElement>

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

prevSibling

open override val prevSibling: PsiElement?

project

@get:NotNull
open override val project: @NotNull Project

psiOrParent

@get:NotNull
open override val psiOrParent: KtElement

pureEndOffset

The end offset of this element's source.

pureStartOffset

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

reference

open override val reference: PsiReference?

references

@get:NotNull
open override val references: Array<out PsiReference?>

resolveScope

@get:NotNull
open override val resolveScope: @NotNull GlobalSearchScope

startOffset

val PsiElement.startOffset: Int

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

startOffsetInParent

open override val startOffsetInParent: Int

startOffsetSkippingComments

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

stub

@get:Nullable
open override val stub: @Nullable KotlinNameReferenceExpressionStub?

text

open override val text: String?

textLength

open override val textLength: Int

textOffset

open override val textOffset: Int

textRange

open override val textRange: TextRange?

textRangeInParent

@get:Contract(pure = true)
@get:NotNull
open val textRangeInParent: @NotNull TextRange

textRangeWithoutComments

val PsiElement.textRangeWithoutComments: TextRange

The text range of this element excluding any leading comments.

userDataString

@get:TestOnly
open val userDataString: String?

userMap

@get:NotNull
open var userMap: @NotNull KeyFMap

useScope

@get:NotNull
open override val useScope: @NotNull SearchScope

Functions

accept

fun accept(@NotNull visitor: PsiElementVisitor)

open override 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.

acceptChildren

open fun acceptChildren(@NotNull 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.

add

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

addAfter

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

addBefore

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

addInternal

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

addRange

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

addRangeAfter

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

addRangeBefore

open fun addRangeBefore(
    @NotNull first: @NotNull PsiElement, 
    @NotNull 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.

asAssignment

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

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

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

checkAdd

open fun checkAdd(@NotNull 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()

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

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

copy

open fun copy(): PsiElement?

copyCopyableDataTo

open fun copyCopyableDataTo(clone: @NotNull UserDataHolderBase)

copyUserDataTo

open fun copyUserDataTo(other: @NotNull UserDataHolderBase)

delete

open fun delete()

Deletes this element.

When KtPsiMutationService is registered, as in the IntelliJ Kotlin plugin, the deletion may also adjust the surrounding code, e.g., delete a semicolon that follows the element. Without the service, it performs only the plain platform deletion.

deleteChildInternal

open fun deleteChildInternal(child: @NotNull ASTNode)

deleteChildRange

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

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?

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

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

getAssignmentByLHS

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

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.

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(): @NotNull Array<out PsiElement>

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.

getContainingFile

@NotNull
open fun getContainingFile(): @NotNull PsiFile

getContainingKtFile

@NotNull
open fun getContainingKtFile(): KtFile

Returns the KtFile this element belongs to.

getContext

open fun getContext(): PsiElement?

getCopyableUserData

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

getElementTextWithContext

fun PsiElement.getElementTextWithContext(): String

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

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?

getGreenStub

@Nullable
fun getGreenStub(): @Nullable KotlinNameReferenceExpressionStub?

getIcon

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

getIdentifier

open override fun getIdentifier(): PsiElement?

Returns the identifier token of this reference, or null if the name is not a plain identifier (for example, an operation sign).

getLabeledParent

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

getLanguage

@NotNull
open fun getLanguage(): Language

getLastChild

open fun getLastChild(): PsiElement?

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.

getManager

open fun getManager(): PsiManagerEx?

getModificationStamp

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

@NotNull
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

@NotNull
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

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

getParent

open fun getParent(): PsiElement?

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

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

@NotNull
open fun getProject(): @NotNull Project

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.

getQualifiedElement

Returns the enclosing qualified element for this name: a KtQualifiedExpression, a KtUserType, or this expression itself if there is no such qualifier.

getQualifiedElementOrCallableRef

Like getQualifiedElement, but also returns the enclosing KtCallableReferenceExpression when this name is its callable reference.

getQualifiedElementSelector

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

getQualifiedExpressionForReceiver

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

getQualifiedExpressionForReceiverOrThis

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

getQualifiedExpressionForSelector

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

getQualifiedExpressionForSelectorOrThis

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

getReceiverExpression

Returns the receiver this name is applied to, considering qualified expressions, binary/unary operators, and qualified user types, or null if this name has no receiver.

getReference

open fun getReference(): PsiReference

getReferencedName

open override fun getReferencedName(): String

Returns the referenced name as it appears in the source, with any surrounding backticks removed.

getReferencedNameAsName

open override fun getReferencedNameAsName(): Name

Returns the referenced name as a Name.

getReferencedNameElement

open override fun getReferencedNameElement(): PsiElement

Returns the token or element that carries the referenced name (for example, the identifier or the operation sign). Never null, even for operation references.

getReferencedNameElementType

open override fun getReferencedNameElementType(): IElementType

Returns the element type of the referenced name element.

getReferences

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

getRequiredStubOrPsiChild

fun <S : StubElement<*>?, Psi : PsiElement?> getRequiredStubOrPsiChild(elementType: @NotNull IStubElementType<S?, Psi?>): @NotNull Psi & Any

fun getRequiredStubOrPsiChild(elementType: @NotNull IElementType): @NotNull PsiElement

fun <Psi : PsiElement?> getRequiredStubOrPsiChild(elementType: @NotNull IElementType, psiClass: @NotNull Class<Psi?>): @NotNull Psi & Any

getResolveScope

@NotNull
open fun getResolveScope(): @NotNull GlobalSearchScope

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

getStrictParentOfType

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

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

getStub

@Nullable
open fun getStub(): @Nullable KotlinNameReferenceExpressionStub?

getStubOrPsiChild

open fun <Psi : PsiElement?> getStubOrPsiChild(elementType: @NotNull IStubElementType<out StubElement<*>?, Psi?>): @Nullable Psi?

fun getStubOrPsiChild(elementType: @NotNull IElementType): @Nullable PsiElement?

fun <Psi : PsiElement?> getStubOrPsiChild(elementType: @NotNull IElementType, psiClass: @NotNull Class<Psi?>): @Nullable Psi?

getStubOrPsiChildren

fun <S : StubElement<*>?, Psi : PsiElement?> getStubOrPsiChildren(elementType: @NotNull IStubElementType<S?, out Psi?>, f: @NotNull ArrayFactory<out Psi?>): @NotNull Array<out Psi?>

fun <S : StubElement<*>?, Psi : PsiElement?> getStubOrPsiChildren(elementType: @NotNull IStubElementType<S?, out Psi?>, array: @NotNull Array<out Psi?>): @NotNull Array<out Psi?>

fun <Psi : PsiElement?> getStubOrPsiChildren(elementType: @NotNull IElementType, f: @NotNull ArrayFactory<out Psi?>): @NotNull Array<out Psi?>

fun <Psi : PsiElement?> getStubOrPsiChildren(elementType: @NotNull IElementType, array: @NotNull Array<out Psi?>): @NotNull Array<out Psi?>

open fun <Psi : PsiElement?> getStubOrPsiChildren(filter: @NotNull TokenSet, f: @NotNull ArrayFactory<out Psi?>): @NotNull Array<out Psi?>

open fun <Psi : PsiElement?> getStubOrPsiChildren(filter: @NotNull TokenSet, array: @NotNull Array<out Psi?>): @NotNull Array<out Psi?>

getSuperNames

fun StubBasedPsiElementBase<out KotlinClassOrObjectStub<out KtClassOrObject>>.getSuperNames(): List<String>

Returns the unqualified names indexed as this class's superclass names. For names that might be imported through an alias, this includes both the original and aliased names; reference resolution during inheritor search disambiguates them.

getText

open fun getText(): String?

getTextLength

open fun getTextLength(): Int

getTextOffset

open fun getTextOffset(): Int

getTextRange

open fun getTextRange(): TextRange?

getTextWithLocation

fun PsiElement.getTextWithLocation(): String

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

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.

getTopmostParentQualifiedExpressionForSelector

Returns the outermost qualified expression in which this name is (transitively) the selector, or null.

getUserData

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

getUseScope

@NotNull
open fun getUseScope(): @NotNull SearchScope

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.

isCallee

Returns true if this expression can be the callee of a call with the same name.

isContextualDeclaration

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

isContractDescriptionCallPsiCheck

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

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

isDotSelector

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

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.

isImportDirectiveExpression

Returns true if this name is part of an import directive.

isInImportDirective

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

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

isNull

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

isPackageDirectiveExpression

Returns true if this name is part of a package directive.

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.

isValid

open fun isValid(): Boolean

isWritable

open fun isWritable(): Boolean

lastBlockStatementOrThis

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

open fun navigate(requestFocus: Boolean)

@RequiresReadLock
@RequiresBackgroundThread
@Nullable
open fun navigationRequest(): @Nullable 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

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.

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(
    @NotNull processor: @NotNull PsiScopeProcessor, 
    @NotNull state: @NotNull ResolveState, 
    lastParent: PsiElement?, 
    @NotNull place: @NotNull PsiElement
): Boolean

putCopyableUserData

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

putUserData

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

putUserDataIfAbsent

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

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.

rawReplace

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

Replaces this element using the raw platform implementation, bypassing the Kotlin-specific replace handling.

referenceExpression

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

replace

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

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

replaceChildInternal

open fun replaceChildInternal(child: PsiElement?, newElement: TreeElement?)

setSubstrateRef

fun setSubstrateRef(substrateRef: @NotNull SubstrateRef)

siblings

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

open fun textMatches(@NotNull text: @NotNull CharSequence): Boolean

open fun textMatches(@NotNull element: @NotNull PsiElement): Boolean

textToCharArray

open fun textToCharArray(): @NotNull CharArray

topParenthesizedParentOrMe

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

toString

open fun toString(): String

unpackFunctionLiteral

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.