ADFA-3320: add K2-backed code completions

lsp/java/src/main/java/com/itsaky/androidide/lsp/java/edits/BaseJavaEditHandler.kt

@@ -30,11 +30,11 @@ import io.github.rosemoe.sora.widget.CodeEditor
  */
 open class BaseJavaEditHandler : DefaultEditHandler() {
 
-  override fun executeCommand(editor: CodeEditor, command: Command?) {
-    if (editor is ILspEditor) {
-      editor.executeCommand(command)
-      return
-    }
-    super.executeCommand(editor, command)
-  }
+	override fun executeCommand(editor: CodeEditor, command: Command?) {
+		if (editor is ILspEditor) {
+			editor.executeCommand(command)
+			return
+		}
+		super.executeCommand(editor, command)
+	}
 }

lsp/kotlin/build.gradle.kts

@@ -38,6 +38,7 @@ dependencies {
 
 	implementation(projects.lsp.api)
 	implementation(projects.lsp.models)
+	implementation(projects.editorApi)
 	implementation(projects.eventbusEvents)
 	implementation(projects.subprojects.kotlinAnalysisApi)
 	implementation(projects.shared)

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/KotlinLanguageServer.kt

@@ -29,6 +29,7 @@ import com.itsaky.androidide.lsp.api.ILanguageServer
 import com.itsaky.androidide.lsp.api.IServerSettings
 import com.itsaky.androidide.lsp.kotlin.compiler.Compiler
 import com.itsaky.androidide.lsp.kotlin.compiler.KotlinProjectModel
+import com.itsaky.androidide.lsp.kotlin.completion.complete
 import com.itsaky.androidide.lsp.kotlin.diagnostic.collectDiagnosticsFor
 import com.itsaky.androidide.lsp.models.CompletionParams
 import com.itsaky.androidide.lsp.models.CompletionResult
@@ -160,7 +161,14 @@ class KotlinLanguageServer : ILanguageServer {
 	}
 
 	override fun complete(params: CompletionParams?): CompletionResult {
-		return CompletionResult.EMPTY
+		if (params == null) {
+			logger.warn("Cannot complete for null params")
+			return CompletionResult.EMPTY
+		}
+
+		logger.debug("complete(position={}, file={})", params.position, params.file)
+		return compiler?.compilationEnvironmentFor(params.file)?.complete(params)
+			?: CompletionResult.EMPTY
 	}
 
 	override suspend fun findReferences(params: ReferenceParams): ReferenceResult {
@@ -268,7 +276,6 @@ class KotlinLanguageServer : ILanguageServer {
 
 		compiler?.compilationEnvironmentFor(event.changedFile)?.apply {
 			val content = FileManager.getDocumentContents(event.changedFile)
-			logger.info("Notifying KtFileManager for file {} with contents {}", event.changedFile, content)
 			fileManager.onFileContentChanged(event.changedFile, content)
 		}
 

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/BaseKotlinEditHandler.kt

@@ -0,0 +1,23 @@
+package com.itsaky.androidide.lsp.kotlin.completion
+
+import com.itsaky.androidide.editor.api.ILspEditor
+import com.itsaky.androidide.lsp.edits.DefaultEditHandler
+import com.itsaky.androidide.lsp.models.Command
+import io.github.rosemoe.sora.widget.CodeEditor
+
+/**
+ * Implementation of [DefaultEditHandler] which avoids reflection in
+ * [DefaultEditHandler.executeCommand].
+ *
+ * @author Akash Yadav
+ */
+open class BaseKotlinEditHandler : DefaultEditHandler() {
+
+	override fun executeCommand(editor: CodeEditor, command: Command?) {
+		if (editor is ILspEditor) {
+			editor.executeCommand(command)
+			return
+		}
+		super.executeCommand(editor, command)
+	}
+}

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/CompletionContext.kt

@@ -0,0 +1,17 @@
+package com.itsaky.androidide.lsp.kotlin.completion
+
+/**
+ * The context for the providing code completions in a file.
+ */
+enum class CompletionContext {
+
+	/**
+	 * Scope completions (local variables, parameters, etc.)
+	 */
+	Scope,
+
+	/**
+	 * Member completions (properties, member functions, extension functions, etc.)
+	 */
+	Member,
+}

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/ContextKeywords.kt

@@ -0,0 +1,53 @@
+package com.itsaky.androidide.lsp.kotlin.completion
+
+import org.jetbrains.kotlin.lexer.KtKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens.*
+
+/**
+ *
+ */
+object ContextKeywords {
+
+	/** Hard keywords valid as *statement starters* inside a function body */
+	val STATEMENT_KEYWORDS = setOf(
+		IF_KEYWORD, ELSE_KEYWORD, WHEN_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, FOR_KEYWORD,
+		TRY_KEYWORD, RETURN_KEYWORD, THROW_KEYWORD, BREAK_KEYWORD, CONTEXT_KEYWORD,
+		VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD,// local declarations
+		OBJECT_KEYWORD,// anonymous / local object
+		CLASS_KEYWORD,// local class (rare but legal)
+	)
+
+	/** Declaration starters at top-level / class body */
+	val DECLARATION_KEYWORDS = setOf(
+		VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD, OBJECT_KEYWORD,
+		TYPE_ALIAS_KEYWORD, CONSTRUCTOR_KEYWORD, INIT_KEYWORD,
+	)
+
+	val TOP_LEVEL_ONLY = setOf(PACKAGE_KEYWORD, IMPORT_KEYWORD)
+
+	/**
+	 * Resolve valid keywords for the given declaration context.
+	 *
+	 * @param ctx The declaration context.
+	 * @return The keyword tokens for the declaration context.
+	 */
+	fun keywordsFor(ctx: DeclarationContext): Set<KtKeywordToken> = when (ctx) {
+		DeclarationContext.TOP_LEVEL,
+		DeclarationContext.SCRIPT_TOP_LEVEL -> TOP_LEVEL_ONLY + DECLARATION_KEYWORDS
+
+		DeclarationContext.CLASS_BODY -> DECLARATION_KEYWORDS +
+				setOf(INIT_KEYWORD, CONSTRUCTOR_KEYWORD)
+
+		DeclarationContext.INTERFACE_BODY -> setOf(
+			VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, CLASS_KEYWORD,
+			INTERFACE_KEYWORD, OBJECT_KEYWORD, TYPE_ALIAS_KEYWORD
+		)
+
+		DeclarationContext.OBJECT_BODY,
+		DeclarationContext.ENUM_BODY -> DECLARATION_KEYWORDS - setOf(CONSTRUCTOR_KEYWORD)
+
+		DeclarationContext.ANNOTATION_BODY -> setOf(VAL_KEYWORD)   // annotation params only
+
+		DeclarationContext.FUNCTION_BODY -> STATEMENT_KEYWORDS
+	}
+}

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/ContextResolver.kt

@@ -0,0 +1,166 @@
+package com.itsaky.androidide.lsp.kotlin.completion
+
+import org.jetbrains.kotlin.analysis.api.KaSession
+import org.jetbrains.kotlin.analysis.api.components.KaScopeContext
+import org.jetbrains.kotlin.analysis.api.scopes.KaScope
+import org.jetbrains.kotlin.com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.lexer.KtTokens.MODIFIER_KEYWORDS
+import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassBody
+import org.jetbrains.kotlin.psi.KtConstructor
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtModifierList
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.psi.KtSafeQualifiedExpression
+import org.jetbrains.kotlin.psi.KtTypeAlias
+import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
+import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
+import org.jetbrains.kotlin.psi.psiUtil.parents
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
+import org.slf4j.LoggerFactory
+
+/**
+ * Defines context at the cursor position.
+ */
+data class CursorContext(
+	val psiElement: PsiElement,
+	val ktFile: KtFile,
+	val ktElement: KtElement,
+	val scopeContext: KaScopeContext,
+	val compositeScope: KaScope,
+	val completionContext: CompletionContext,
+	val declarationContext: DeclarationContext,
+	val declarationKind: DeclarationKind,
+	val existingModifiers: Set<KtModifierKeywordToken>,
+	val isInsideModifierList: Boolean,
+)
+
+
+private val logger = LoggerFactory.getLogger("ContextResolver")
+
+/**
+ * Resolves [CursorContext] at the given offset in the given [KtFile].
+ */
+fun KaSession.resolveCursorContext(ktFile: KtFile, offset: Int): CursorContext? {
+	val psiElement = ktFile.findElementAt(offset)
+	if (psiElement == null) {
+		logger.error("Unable to find PSI element at offset {} in file {}", offset, ktFile)
+		return null
+	}
+
+	val completionContext = determineCompletionContext(psiElement)
+	val ktElement = psiElement.getParentOfType<KtElement>(strict = false)
+	if (ktElement == null) {
+		logger.error("Cannot find parent of element {}", psiElement)
+		return null
+	}
+
+	val scopeContext = ktFile.scopeContext(ktElement)
+	val compositeScope = scopeContext.compositeScope()
+
+	// The element is typically a KtModifierList, an error node,
+	// or the incomplete declaration itself.
+	val modifierList = ktElement.getParentOfType<KtModifierList>(strict = false)
+	val existingModifiers = modifierList
+		?.node?.getChildren(MODIFIER_KEYWORDS)
+		?.mapNotNull { it.elementType as? KtModifierKeywordToken }
+		?.toSet()
+		?: emptySet()
+
+	val declarationKind = resolveDeclarationKind(ktElement)
+	val declarationContext = resolveDeclarationContext(ktElement)
+
+	return CursorContext(
+		psiElement = psiElement,
+		ktFile = ktFile,
+		ktElement = ktElement,
+		scopeContext = scopeContext,
+		compositeScope = compositeScope,
+		completionContext = completionContext,
+		declarationContext = declarationContext,
+		declarationKind = declarationKind,
+		existingModifiers = existingModifiers,
+		isInsideModifierList = modifierList != null,
+	)
+}
+
+private fun determineCompletionContext(element: PsiElement): CompletionContext {
+	// Walk up to find a qualified expression where we're the selector
+	val dotExpr = element.getParentOfType<KtDotQualifiedExpression>(strict = false)
+	if (dotExpr != null && isInSelectorPosition(element, dotExpr)) {
+		return CompletionContext.Member
+	}
+
+	val safeExpr = element.getParentOfType<KtSafeQualifiedExpression>(strict = false)
+	if (safeExpr != null && isInSelectorPosition(element, safeExpr)) {
+		return CompletionContext.Member
+	}
+
+	return CompletionContext.Scope
+}
+
+private fun isInSelectorPosition(
+	element: PsiElement,
+	qualifiedExpr: KtQualifiedExpression,
+): Boolean {
+	val selector = qualifiedExpr.selectorExpression ?: return false
+	val elementOffset = element.startOffset
+	return elementOffset >= selector.startOffset
+}
+
+private fun resolveDeclarationContext(element: KtElement): DeclarationContext {
+	for (ancestor in element.parents) {
+		when (ancestor) {
+			is KtClassBody -> {
+				return when (val owner = ancestor.parent) {
+					is KtClass -> when {
+						owner.isInterface() -> DeclarationContext.INTERFACE_BODY
+						owner.isEnum() -> DeclarationContext.ENUM_BODY
+						owner.isAnnotation() -> DeclarationContext.ANNOTATION_BODY
+						else -> DeclarationContext.CLASS_BODY
+					}
+
+					is KtObjectDeclaration -> DeclarationContext.OBJECT_BODY
+					else -> DeclarationContext.CLASS_BODY
+				}
+			}
+
+			is KtBlockExpression -> return DeclarationContext.FUNCTION_BODY
+			is KtFile -> return if (ancestor.isScript())
+				DeclarationContext.SCRIPT_TOP_LEVEL
+			else
+				DeclarationContext.TOP_LEVEL
+		}
+	}
+	return DeclarationContext.TOP_LEVEL
+}
+
+private fun resolveDeclarationKind(element: KtElement): DeclarationKind {
+	// Walk up to the nearest declaration owning this modifier list / position
+	return when (val declaration = element.getNonStrictParentOfType<KtDeclaration>()) {
+		is KtClass -> when {
+			declaration.isInterface() -> DeclarationKind.INTERFACE
+			declaration.isEnum() -> DeclarationKind.ENUM_CLASS
+			declaration.isAnnotation() -> DeclarationKind.ANNOTATION_CLASS
+			else -> DeclarationKind.CLASS
+		}
+
+		is KtObjectDeclaration -> DeclarationKind.OBJECT
+		is KtNamedFunction -> DeclarationKind.FUN
+		is KtProperty -> if (declaration.isVar) DeclarationKind.PROPERTY_VAR
+		else DeclarationKind.PROPERTY_VAL
+
+		is KtTypeAlias -> DeclarationKind.TYPEALIAS
+		is KtConstructor<*> -> DeclarationKind.CONSTRUCTOR
+		null -> DeclarationKind.UNKNOWN  // pure modifier list, no keyword yet
+		else -> DeclarationKind.UNKNOWN
+	}
+}

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/completion/DeclarationContext.kt

@@ -0,0 +1,25 @@
+package com.itsaky.androidide.lsp.kotlin.completion
+
+/**
+ * Defines the possible declaration contexts of the element at cursor position.
+ */
+enum class DeclarationContext {
+	TOP_LEVEL,
+	CLASS_BODY,
+	INTERFACE_BODY,
+	OBJECT_BODY,        // includes companion object
+	ENUM_BODY,
+	FUNCTION_BODY,      // local declarations & statements
+	SCRIPT_TOP_LEVEL,
+	ANNOTATION_BODY,
+}
+
+/**
+ * Defines declaration kinds for element at cursor.
+ */
+enum class DeclarationKind {
+	CLASS, INTERFACE, OBJECT, ENUM_CLASS, ANNOTATION_CLASS,
+	FUN, PROPERTY_VAL, PROPERTY_VAR,
+	TYPEALIAS, CONSTRUCTOR,
+	UNKNOWN          // e.g. modifier typed before any keyword yet
+}