diff --git a/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/KotlinCompletions.kt b/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/KotlinCompletions.kt index f6e5409216..e1a709326e 100644 --- a/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/KotlinCompletions.kt +++ b/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/KotlinCompletions.kt @@ -300,9 +300,13 @@ private fun KaSession.collectMemberCompletions(to: MutableList) } 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 } @@ -310,54 +314,21 @@ private fun KaSession.collectMemberCompletions(to: MutableList) 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, -) { - 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) diff --git a/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/MemberCompletionSymbols.kt b/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/MemberCompletionSymbols.kt new file mode 100644 index 0000000000..7361441818 --- /dev/null +++ b/lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/MemberCompletionSymbols.kt @@ -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, + 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() + 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() + 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, +) { + 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) +} diff --git a/lsp/kotlin/src/test/java/com/itsaky/androidide/lsp/kotlin/completion/MemberCompletionSymbolsTest.kt b/lsp/kotlin/src/test/java/com/itsaky/androidide/lsp/kotlin/completion/MemberCompletionSymbolsTest.kt new file mode 100644 index 0000000000..c461b51553 --- /dev/null +++ b/lsp/kotlin/src/test/java/com/itsaky/androidide/lsp/kotlin/completion/MemberCompletionSymbolsTest.kt @@ -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, + 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()", "Collections.emptyList()") + + 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() + } +}