ADFA-5047: Add Java code action: extract variable

ARCHITECTURE.md

@@ -59,7 +59,7 @@ Strategy: **layer-and-subsystem based**, not feature-by-feature. The Gradle buil
 |---|---|---|
 | Application | `app` | The IDE itself — activities, fragments, services, DI, agent, web server. Wires everything together. |
 | Build engine | `subprojects:tooling-api*`, `gradle-plugin*`, `subprojects:projects`, `subprojects:builder-model-impl` | Runs a real Gradle build of the user's project out-of-process and streams events back. |
-| Language tooling | `lsp:{api,java,kotlin,xml,indexing,…}`, `lexers`, `editor*`, `editor-treesitter` | Language servers, indexing, the Sora-based editor and highlighting. |
+| Language tooling | `lsp:{api,java,kotlin,xml,indexing,refactor-core,ui,…}`, `lexers`, `editor*`, `editor-treesitter` | Language servers, indexing, the Sora-based editor and highlighting. `lsp:refactor-core` holds the language-agnostic half of the refactorings (offset spans, block geometry, rewrite composition, name primitives) so `lsp:java` and `lsp:kotlin` share one copy; `lsp:ui` holds the Compose sheets they share. Neither depends on a language server. |
 | UI design tooling | `layouteditor`, `uidesigner`, `xml-inflater`, `vectormaster`, `compose-preview` | Visual/XML design surfaces for the *user's* app. |
 | Shell | `termux:{termux-app,termux-shared,termux-view,termux-emulator}` | Embedded Termux shell and terminal. |
 | Plugin system | `plugin-api`, `plugin-api:plugin-builder`, `plugin-manager` | In-app plugin SDK + manager — `AndroidManifest.xml` `<meta-data>` contract, permissions, extensions. See [plugin-api.md](docs/plugin-api.md) for the API surface & compatibility policy. |

idetooltips/src/main/java/com/itsaky/androidide/idetooltips/TooltipTag.kt

@@ -85,6 +85,7 @@ object TooltipTag {
 	const val EDITOR_CODE_ACTIONS_UNUSED_IMPORTS = "editor.codeactions.unusedimports"
 	const val EDITOR_CODE_ACTIONS_ORGANIZE_IMPORTS = "editor.codeactions.organizeimports"
 	const val EDITOR_CODE_ACTIONS_TRY_CATCH = "editor.codeactions.trycatch"
+	const val EDITOR_CODE_ACTIONS_EXTRACT_VARIABLE = "editor.codeactions.extractvariable"
 
 	// Kotlin code actions. Tags are per-language even where the action exists in both languages,
 	// so the tooltip can describe the Kotlin behaviour (see ADFA-4730).

lsp/java/build.gradle.kts

@@ -54,6 +54,8 @@ dependencies {
 	implementation(projects.editorApi)
 	implementation(projects.resources)
 	implementation(projects.lsp.api)
+	implementation(projects.lsp.refactorCore)
+	implementation(projects.lsp.ui)
 	implementation(projects.lsp.jvmSymbolIndex)
 	implementation(projects.subprojects.libjdwp)
 	implementation(projects.subprojects.javacServices)

lsp/java/src/main/java/com/itsaky/androidide/lsp/java/actions/ExtractVariableAction.kt

@@ -0,0 +1,173 @@
+package com.itsaky.androidide.lsp.java.actions
+
+import com.itsaky.androidide.actions.ActionData
+import com.itsaky.androidide.actions.requireContext
+import com.itsaky.androidide.actions.requireEditor
+import com.itsaky.androidide.actions.requireFile
+import com.itsaky.androidide.idetooltips.TooltipTag
+import com.itsaky.androidide.lsp.java.refactor.ExtractionPlan
+import com.itsaky.androidide.lsp.java.refactor.JAVA_KEYWORDS
+import com.itsaky.androidide.lsp.java.refactor.JAVA_NAME_MESSAGES
+import com.itsaky.androidide.lsp.java.refactor.buildExtractVariableRewrite
+import com.itsaky.androidide.lsp.java.refactor.buildExtractionPlan
+import com.itsaky.androidide.lsp.java.refactor.candidateAndScopeFor
+import com.itsaky.androidide.lsp.java.refactor.toCandidateViews
+import com.itsaky.androidide.lsp.models.CodeActionItem
+import com.itsaky.androidide.lsp.models.CodeActionKind
+import com.itsaky.androidide.lsp.models.Command
+import com.itsaky.androidide.lsp.models.DocumentChange
+import com.itsaky.androidide.lsp.refactor.toTextEdit
+import com.itsaky.androidide.lsp.ui.ExtractVariableSelection
+import com.itsaky.androidide.lsp.ui.ExtractVariableSheet
+import com.itsaky.androidide.lsp.ui.findFragmentActivity
+import com.itsaky.androidide.projects.FileManager
+import com.itsaky.androidide.resources.R
+import com.itsaky.androidide.utils.flashError
+import com.itsaky.androidide.utils.flashInfo
+import org.slf4j.LoggerFactory
+import java.nio.file.Path
+import kotlin.coroutines.cancellation.CancellationException
+
+/**
+ * Extracts the expression at the cursor, or the selected one, into a local variable.
+ *
+ * The work is split so nothing heavy touches the UI thread: [execAction] runs one attributed compile
+ * and returns a plain-data [ExtractionPlan] covering every candidate, then [postExec] shows the shared
+ * sheet and turns the user's selection into a single text edit with pure offset arithmetic.
+ */
+class ExtractVariableAction : BaseJavaCodeAction() {
+	companion object {
+ const val ID = "ide.editor.lsp.java.extractVariable"
+
+ private val log = LoggerFactory.getLogger(ExtractVariableAction::class.java)
+	}
+
+	override val titleTextRes: Int = R.string.action_extract_variable
+	override var tooltipTag: String = TooltipTag.EDITOR_CODE_ACTIONS_EXTRACT_VARIABLE
+
+	override val id: String = ID
+	override var label: String = ""
+
+	// Deciding whether anything is extractable needs an attributed compile, far too costly for
+	// prepare() on the UI thread. BaseJavaCodeAction's file-type and module gate is all that applies;
+	// the action stays visible on any Java file and reports "nothing to extract" instead, as
+	// OrganizeImportsAction does.
+	override var requiresUIThread: Boolean = false
+
+	override suspend fun execAction(data: ActionData): ExtractionPlan {
+ val file = data.requireFile().toPath()
+ val cursor = data.requireEditor().cursor
+ val selectionStart = minOf(cursor.left, cursor.right)
+ val selectionEnd = maxOf(cursor.left, cursor.right)
+ val version = documentVersionOf(file)
+
+ // Resolving the compiler and taking its lock can both throw, and neither is inside the planner's
+ // own guard. DefaultActionsRegistry catches only IllegalArgumentException and this runs on a scope
+ // with no exception handler, so anything else would crash the app rather than fail the action.
+ return runCatching {
+ data.requireCompiler().compile(file).get { task ->
+ buildExtractionPlan(task, file, selectionStart, selectionEnd, version)
+ }
+ }.getOrElse { error ->
+ if (error is CancellationException) throw error
+ log.warn("Could not analyse {} for extract variable.", file, error)
+ ExtractionPlan.empty()
+ }
+	}
+
+	override fun postExec(
+ data: ActionData,
+ result: Any,
+	) {
+ super.postExec(data, result)
+ if (result !is ExtractionPlan) return
+
+ if (result.isEmpty) {
+ flashInfo(R.string.msg_extract_variable_nothing_to_extract)
+ return
+ }
+
+ val context = data.requireContext()
+ val activity =
+ context.findFragmentActivity()
+ ?: run {
+ // A wiring problem rather than a user path: the editor is always hosted by one.
+ log.warn("No FragmentActivity for the editor context. Cannot show the extract sheet.")
+ flashError(R.string.msg_cannot_perform_fix)
+ return
+ }
+
+ val shown =
+ ExtractVariableSheet.show(
+ activity,
+ result.toCandidateViews(context),
+ JAVA_KEYWORDS,
+ JAVA_NAME_MESSAGES,
+ ) { selection -> applySelection(data, result, selection) }
+ if (!shown) {
+ log.warn("Fragment manager unavailable. Cannot show the extract sheet.")
+ }
+	}
+
+	/**
+ * Turns the user's selection into one edit and hands it to the language client.
+ *
+ * The document version is re-read here rather than trusted from the plan: the editor stays
+ * reachable while the sheet is open, and applying spans computed against older text would corrupt
+ * the file. Refusing is always safe; the user can invoke the action again.
+ */
+	private fun applySelection(
+ data: ActionData,
+ plan: ExtractionPlan,
+ selection: ExtractVariableSelection,
+	) {
+ val file = data.requireFile().toPath()
+ // A plan built while the document was closed carries no version to compare, so there is nothing
+ // to prove the text still matches: refuse rather than apply spans on trust.
+ if (plan.documentVersion == null || documentVersionOf(file) != plan.documentVersion) {
+ flashInfo(R.string.msg_extract_variable_file_changed)
+ return
+ }
+
+ val (candidate, scope) =
+ plan.candidateAndScopeFor(selection) ?: run {
+ log.warn("Selection {} does not address the plan it came from.", selection)
+ flashError(R.string.msg_cannot_perform_fix)
+ return
+ }
+
+ val rewrite =
+ buildExtractVariableRewrite(
+ fileText = plan.fileText,
+ candidateSpan = candidate.span,
+ declaredType = candidate.declaredType,
+ scope = scope,
+ name = selection.name,
+ replaceAll = selection.replaceAll,
+ ) ?: run {
+ log.warn("Could not build an extract-variable rewrite for '{}'", candidate.label)
+ flashError(R.string.msg_cannot_perform_fix)
+ return
+ }
+
+ val client =
+ data.getLanguageClient() ?: run {
+ log.warn("No language client set. Cannot extract variable.")
+ return
+ }
+
+ client.performCodeAction(
+ CodeActionItem(
+ title = label,
+ changes = listOf(DocumentChange(file = file, edits = listOf(rewrite.toTextEdit(plan.fileText)))),
+ kind = CodeActionKind.QuickFix,
+ // The rewrite is emitted fully indented. Running google-java-format here would reformat
+ // the whole file into the same undo step as the extraction.
+ command = Command("", ""),
+ ),
+ )
+	}
+
+	/** Null when the document is not open, which the confirm guard treats as unverifiable and refuses. */
+	private fun documentVersionOf(path: Path): Int? = FileManager.getActiveDocument(path)?.version
+}

lsp/java/src/main/java/com/itsaky/androidide/lsp/java/actions/JavaCodeActionsMenu.kt

@@ -93,5 +93,6 @@ object JavaCodeActionsMenu : IActionsMenuProvider {
  CATCH_BODY,
  TooltipTag.EDITOR_CODE_ACTIONS_TRY_CATCH,
  ),
+ ExtractVariableAction(),
  )
 }