Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -300,64 +300,35 @@ private fun KaSession.collectMemberCompletions(to: MutableList<CompletionItem>)
}

val receiver = qualifiedExpr.receiverExpression
val receiverType = receiver.expressionType
abortIfCancelled()
val symbols =
memberCompletionSymbols(receiver, isSafeCall = qualifiedExpr is KtSafeQualifiedExpression) { name ->
matchesFilter(name)
}

if (receiverType == null) {
if (symbols == null) {
logger.error("Unable to find receiver expression type")
return
}

logger.info(
"Complete members of {}: {} [{}] matching '{}'",
receiver,
receiverType,
symbols.extensionReceiverType,
receiver.text,
ctx.partial,
)

collectMembersFromType(receiverType, to)

if (qualifiedExpr is KtSafeQualifiedExpression) {
val nonNullType = receiverType.withNullability(isMarkedNullable = false)
collectMembersFromType(nonNullType, to)
}

collectExtensionFunctions(receiverType, to)
}

@OptIn(KaExperimentalApi::class)
context(ctx: AnalysisContext)
private fun KaSession.collectMembersFromType(
receiverType: KaType,
to: MutableList<CompletionItem>,
) {
abortIfCancelled()

val typeScope = receiverType.scope
if (typeScope != null) {
val callables =
typeScope
.getCallableSignatures { name -> matchesFilter(name) }
.map { it.symbol }

val classifiers =
typeScope.getClassifierSymbols { name -> matchesFilter(name) }

to += toCompletionItems(callables)
to += toCompletionItems(classifiers)
return
}

// fallback approach when typeScope is not available
val classType = receiverType as? KaClassType ?: return
val classSymbol = classType.symbol as? KaClassSymbol ?: return
val memberScope = classSymbol.memberScope

val callables = memberScope.callables { name -> matchesFilter(name) }
val classifiers = memberScope.classifiers { name -> matchesFilter(name) }
to +=
symbols.members.mapNotNull { symbol ->
when (symbol) {
is KaCallableSymbol -> callableSymbolToCompletionItem(symbol)
is KaClassifierSymbol -> classifierSymbolToCompletionItem(symbol)
else -> null
}
}

to += toCompletionItems(callables)
to += toCompletionItems(classifiers)
symbols.extensionReceiverType?.let { collectExtensionFunctions(it, to) }
}

context(ctx: AnalysisContext)
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,101 @@
package com.itsaky.androidide.lsp.kotlin.completion

import org.jetbrains.kotlin.analysis.api.KaExperimentalApi
import org.jetbrains.kotlin.analysis.api.KaSession
import org.jetbrains.kotlin.analysis.api.symbols.KaClassKind
import org.jetbrains.kotlin.analysis.api.symbols.KaClassSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaNamedClassSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
import org.jetbrains.kotlin.analysis.api.types.KaClassType
import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.idea.references.mainReference
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtExpression
import org.jetbrains.kotlin.psi.KtNameReferenceExpression
import org.jetbrains.kotlin.psi.KtQualifiedExpression

/**
* The symbols member completion offers after `receiver.`, before they become completion items.
*
* @property members Callables and classifiers, in the order they are offered.
* @property extensionReceiverType The type whose applicable extensions are offered as well, or
* `null` when no extension can be called on the receiver.
*/
internal class MemberCompletionSymbols(
val members: List<KaSymbol>,
val extensionReceiverType: KaType?,
)

/**
* The members of [receiver] whose names pass [nameFilter], or `null` when the receiver has no type.
*
* With [isSafeCall] (`receiver?.`) the members of the receiver's non-null type are offered as well.
*/
internal fun KaSession.memberCompletionSymbols(
receiver: KtExpression,
isSafeCall: Boolean,
nameFilter: (Name) -> Boolean,
): MemberCompletionSymbols? {
qualifierClass(receiver)?.let { return classQualifierSymbols(it, nameFilter) }

val receiverType = receiver.expressionType ?: return null
val members = mutableListOf<KaSymbol>()
addTypeMembers(receiverType, nameFilter, members)
if (isSafeCall) {
addTypeMembers(receiverType.withNullability(isMarkedNullable = false), nameFilter, members)
}
return MemberCompletionSymbols(members, receiverType)
}

/**
* The class [receiver] names when it is used as a qualifier (`Collections.`, `Color.`) rather than as
* a value. Such a reference has no value type - the Analysis API reports `kotlin.Unit` for it - so its
* members come from the class's static scope instead. An object is a value and is excluded.
*/
private fun KaSession.qualifierClass(receiver: KtExpression): KaClassSymbol? {
val reference =
(if (receiver is KtQualifiedExpression) receiver.selectorExpression else receiver) as? KtNameReferenceExpression
?: return null
val classSymbol = reference.mainReference.resolveToSymbol() as? KaClassSymbol ?: return null
return classSymbol.takeUnless {
it.classKind == KaClassKind.OBJECT || it.classKind == KaClassKind.COMPANION_OBJECT
}
}

/** Static members and nested classifiers of [classSymbol], plus its companion's members if it has one. */
private fun KaSession.classQualifierSymbols(
classSymbol: KaClassSymbol,
nameFilter: (Name) -> Boolean,
): MemberCompletionSymbols {
val staticScope = classSymbol.staticMemberScope
val members = mutableListOf<KaSymbol>()
members += staticScope.callables(nameFilter)
members += staticScope.classifiers(nameFilter)

val companion =
(classSymbol as? KaNamedClassSymbol)?.companionObject
?: return MemberCompletionSymbols(members, extensionReceiverType = null)
val companionType = buildClassType(companion)
addTypeMembers(companionType, nameFilter, members)
return MemberCompletionSymbols(members, extensionReceiverType = companionType)
}

@OptIn(KaExperimentalApi::class)
private fun KaSession.addTypeMembers(
type: KaType,
nameFilter: (Name) -> Boolean,
members: MutableList<KaSymbol>,
) {
val typeScope = type.scope
if (typeScope != null) {
members += typeScope.getCallableSignatures(nameFilter).map { it.symbol }
members += typeScope.getClassifierSymbols(nameFilter)
return
}

// fallback approach when typeScope is not available
val classSymbol = (type as? KaClassType)?.symbol as? KaClassSymbol ?: return
val memberScope = classSymbol.memberScope
members += memberScope.callables(nameFilter)
members += memberScope.classifiers(nameFilter)
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,96 @@
package com.itsaky.androidide.lsp.kotlin.completion

import com.google.common.truth.Truth.assertThat
import com.itsaky.androidide.lsp.kotlin.fixtures.KtLspTest
import org.jetbrains.kotlin.analysis.api.symbols.markers.KaNamedSymbol
import org.jetbrains.kotlin.com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.KtQualifiedExpression
import org.junit.Test

/** Requirements for what member completion offers after `receiver.`, by kind of receiver. */
class MemberCompletionSymbolsTest : KtLspTest() {
private val declarations =
"""
package test

enum class Color { RED, GREEN }

class WithCompanion {
companion object {
fun make(): WithCompanion = WithCompanion()
}
}

object Registry {
fun lookup(): Int = 0
}
""".trimIndent()

private class MemberNames(
val members: List<String>,
val hasExtensionReceiver: Boolean,
)

/** The member names offered after the receiver of the qualified expression whose text is [qualified]. */
private fun membersAfter(
qualified: String,
body: String,
): MemberNames {
createSourceFile("test/Declarations.kt", declarations)
val file: KtFile =
createSourceFile("test/Use.kt", "package test\n\nimport java.util.Collections\n\nfun use() {\n $body\n}\n")
val receiver =
PsiTreeUtil
.findChildrenOfType(file, KtQualifiedExpression::class.java)
.single { it.text == qualified }
.receiverExpression
return analyzeMaybeDanglingForTest(file) {
val symbols = memberCompletionSymbols(receiver, isSafeCall = false) { true }!!
MemberNames(
members = symbols.members.mapNotNull { (it as? KaNamedSymbol)?.name?.asString() },
hasExtensionReceiver = symbols.extensionReceiverType != null,
)
}
}

@Test
fun `members after a Java class name are its static members, not Unit's`() {
val names = membersAfter("Collections.emptyList<String>()", "Collections.emptyList<String>()")

assertThat(names.members).contains("emptyList")
assertThat(names.members).doesNotContain("hashCode")
assertThat(names.hasExtensionReceiver).isFalse()
}

@Test
fun `members after an enum class name include its entries`() {
val names = membersAfter("Color.RED", "Color.RED")

assertThat(names.members).containsAtLeast("RED", "GREEN")
}

@Test
fun `members after a class name with a companion include the companion's members`() {
val names = membersAfter("WithCompanion.make()", "WithCompanion.make()")

assertThat(names.members).contains("make")
assertThat(names.hasExtensionReceiver).isTrue()
}

@Test
fun `members after a value are its type's members`() {
val names = membersAfter("\"abc\".length", "\"abc\".length")

assertThat(names.members).contains("length")
assertThat(names.hasExtensionReceiver).isTrue()
}

@Test
fun `members after an object name are the object's members`() {
val names = membersAfter("Registry.lookup()", "Registry.lookup()")

assertThat(names.members).contains("lookup")
assertThat(names.hasExtensionReceiver).isTrue()
}
}
Loading