[command-completion] IDEA-376844 Command completion. More previews

GitOrigin-RevId: a35f3298e148551ed5f5f400969007bd3035f2fc

Author: Mikhail Pyltsin

java/java-impl/src/com/intellij/codeInsight/completion/commands/impl/JavaFormatCodeCompletionCommand.kt

@@ -16,7 +16,7 @@ internal class JavaFormatCodeCompletionCommandProvider : AbstractFormatCodeCompl
     val element = getCommandContext(context.offset, context.psiFile) ?: return null
     val targetElement = findTargetToRefactorInner(element)
     val highlightInfoLookup = HighlightInfoLookup(targetElement.textRange, EditorColors.SEARCH_RESULT_ATTRIBUTES, 0)
-    val command = object : JavaFormatCodeCompletionCommand(){
+    val command = object : JavaFormatCodeCompletionCommand(context){
       override val highlightInfo: HighlightInfoLookup
         get() {
           return highlightInfoLookup
@@ -34,7 +34,7 @@ private fun findTargetToRefactorInner(element: PsiElement): PsiElement {
   return parentElement
 }
 
-internal abstract class JavaFormatCodeCompletionCommand : AbstractFormatCodeCompletionCommand() {
+internal abstract class JavaFormatCodeCompletionCommand(context: CommandCompletionProviderContext) : AbstractFormatCodeCompletionCommand(context) {
   override fun findTargetToRefactor(element: PsiElement): PsiElement {
     return findTargetToRefactorInner(element)
   }

java/java-tests/testSrc/com/intellij/java/codeInsight/completion/commands/JavaCommandsCompletionTest.kt

@@ -6,6 +6,7 @@ import com.intellij.codeInsight.completion.command.CommandCompletionDocumentatio
 import com.intellij.codeInsight.completion.command.CommandCompletionLookupElement
 import com.intellij.codeInsight.hint.HintManager
 import com.intellij.codeInsight.hint.HintManagerImpl
+import com.intellij.codeInsight.intention.preview.IntentionPreviewInfo
 import com.intellij.codeInsight.template.impl.TemplateManagerImpl
 import com.intellij.codeInspection.deadCode.UnusedDeclarationInspection
 import com.intellij.ide.highlighter.JavaFileType
@@ -72,6 +73,39 @@ class JavaCommandsCompletionTest : LightFixtureCompletionTestCase() {
     """.trimIndent())
   }
 
+  fun testFormatPreview() {
+    Registry.get("ide.completion.command.force.enabled").setValue(true, getTestRootDisposable())
+    myFixture.configureByText(JavaFileType.INSTANCE, """
+      class A { 
+        void foo() {
+          int y = 10;
+          int x =                           y.<caret>;
+        } 
+      }
+      """.trimIndent())
+    val elements = myFixture.completeBasic()
+    val item = elements.first { element -> element.lookupString.contains("format", ignoreCase = true) }
+      .`as`(CommandCompletionLookupElement::class.java)
+    if (item == null) {
+      fail()
+      return
+    }
+    val preview = item.command.getPreview()
+    if (preview !is IntentionPreviewInfo.CustomDiff) {
+      fail()
+      return
+    }
+    val expected = """
+      class A { 
+        void foo() {
+          int y = 10;
+            int x = y;
+        } 
+      }
+    """.trimIndent()
+    assertEquals(preview.modifiedText(), expected)
+  }
+
   fun testFormatWholeMethod() {
     Registry.get("ide.completion.command.force.enabled").setValue(true, getTestRootDisposable())
     myFixture.configureByText(JavaFileType.INSTANCE, """
@@ -407,13 +441,26 @@ class JavaCommandsCompletionTest : LightFixtureCompletionTestCase() {
           }
       }.<caret>""".trimIndent())
     val elements = myFixture.completeBasic()
-    selectItem(elements.first { element -> element.lookupString.contains("Comment with line comment", ignoreCase = true) })
-    myFixture.checkResult("""
+    val item = elements.first { element -> element.lookupString.contains("Comment with line comment", ignoreCase = true) }
+    selectItem(item)
+    val expectedText = """
       //class A {
       //    public String getY() {
       //        return "y";
       //    }
-      //}""".trimIndent())
+      //}""".trimIndent()
+    myFixture.checkResult(expectedText)
+    val lookupElement = item.`as`(CommandCompletionLookupElement::class.java)
+    if (lookupElement == null) {
+      fail()
+      return
+    }
+    val preview = lookupElement.command.getPreview()
+    if (preview !is IntentionPreviewInfo.CustomDiff) {
+      fail()
+      return
+    }
+    assertEquals(preview.modifiedText(), expectedText)
   }
 
   fun testCommentElementByBlock() {

platform/lang-api/resources/messages/CodeInsightBundle.properties

@@ -576,7 +576,7 @@ command.completion.filter.hint=press ''{0}'' to show commands
 command.completion.project.tool.text=Project tool
 command.completion.recent.files.text=Recent files
 command.completion.generate.text=Generate ''{0}''
-command.completion.psi.element.comment.line.text=Comment/uncomment with line comment
+command.completion.psi.element.comment.line.text=Comment with line comment
 command.completion.psi.element.comment.block.text=Comment with block comment
 command.completion.psi.element.uncomment.block.text=Uncomment
 command.completion.copy.reference.description=Copy reference for ''{0}''

platform/lang-impl/api-dump-experimental.txt

@@ -184,7 +184,7 @@ c:com.intellij.codeInsight.actions.VcsFacade
 - p:isApplicable(I,com.intellij.psi.PsiFile,com.intellij.openapi.editor.Editor):Z
 *a:com.intellij.codeInsight.completion.command.commands.AbstractFormatCodeCompletionCommand
 - com.intellij.codeInsight.completion.command.CompletionCommand
-- <init>():V
+- <init>(com.intellij.codeInsight.completion.command.CommandCompletionProviderContext):V
 - f:execute(I,com.intellij.psi.PsiFile,com.intellij.openapi.editor.Editor):V
 - a:findTargetToRefactor(com.intellij.psi.PsiElement):com.intellij.psi.PsiElement
 - getAdditionalInfo():java.lang.String

platform/lang-impl/src/com/intellij/codeInsight/completion/command/CommandCompletionProvider.kt

@@ -341,6 +341,19 @@ internal class CommandCompletionUnsupportedOperationException
 
 internal class MyEditor(psiFileCopy: PsiFile, private val settings: EditorSettings) : ImaginaryEditor(psiFileCopy.project,
                                                                                                       psiFileCopy.viewProvider.document!!) {
+
+  override fun getFoldingModel(): FoldingModel {
+    return object : FoldingModel{
+      override fun addFoldRegion(startOffset: Int, endOffset: Int, placeholderText: String): FoldRegion? = null
+      override fun removeFoldRegion(region: FoldRegion) = Unit
+      override fun getAllFoldRegions(): Array<out FoldRegion?> = emptyArray()
+      override fun isOffsetCollapsed(offset: Int): Boolean = false
+      override fun getCollapsedRegionAtOffset(offset: Int): FoldRegion? = null
+      override fun getFoldRegion(startOffset: Int, endOffset: Int): FoldRegion? = null
+      override fun runBatchFoldingOperation(operation: Runnable, allowMovingCaret: Boolean, keepRelativeCaretPosition: Boolean) {}
+    }
+  }
+
   override fun notImplemented(): RuntimeException = throw CommandCompletionUnsupportedOperationException()
 
   override fun isViewer(): Boolean = false

platform/lang-impl/src/com/intellij/codeInsight/completion/command/commands/AbstractFormatCodeCompletionCommand.kt

@@ -13,6 +13,7 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.keymap.KeymapUtil
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
+import com.intellij.psi.codeStyle.CodeStyleManager
 import org.jetbrains.annotations.Nls
 import java.util.Locale.getDefault
 
@@ -33,7 +34,7 @@ abstract class AbstractFormatCodeCompletionCommandProvider :
   abstract fun createCommand(context: CommandCompletionProviderContext): CompletionCommand?
 }
 
-abstract class AbstractFormatCodeCompletionCommand : CompletionCommand() {
+abstract class AbstractFormatCodeCompletionCommand(private val context: CommandCompletionProviderContext) : CompletionCommand() {
   final override val synonyms: List<String>
     get() = listOf("Format")
 
@@ -54,7 +55,16 @@ abstract class AbstractFormatCodeCompletionCommand : CompletionCommand() {
       .replaceFirstChar { if (it.isLowerCase()) it.titlecase(getDefault()) else it.toString() }
 
   override fun getPreview(): IntentionPreviewInfo {
-    return IntentionPreviewInfo.Html(ActionsBundle.message("action.ReformatCode.description"))
+    return tryToCalculateCommandCompletionPreview(
+      previewGenerator = { _, psiFile, offset ->
+        val element = getCommandContext(offset, psiFile) ?: return@tryToCalculateCommandCompletionPreview null
+        val target = findTargetToRefactor(element)
+        CodeStyleManager.getInstance(psiFile.getProject()).reformat(target)
+        IntentionPreviewInfo.CustomDiff(context.psiFile.fileType, null, context.psiFile.text, psiFile.text, true)
+      },
+      context = context,
+      highlight = { _, _, _ -> true },
+      fallback = { IntentionPreviewInfo.Html(ActionsBundle.message("action.ReformatCode.description")) })
   }
 
   final override fun execute(offset: Int, psiFile: PsiFile, editor: Editor?) {

platform/lang-impl/src/com/intellij/codeInsight/completion/command/commands/PreviewUtils.kt

@@ -0,0 +1,67 @@
+// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.intellij.codeInsight.completion.command.commands
+
+import com.intellij.codeInsight.actions.MultiCaretCodeInsightActionHandler
+import com.intellij.codeInsight.completion.command.CommandCompletionProviderContext
+import com.intellij.codeInsight.completion.command.MyEditor
+import com.intellij.codeInsight.intention.preview.IntentionPreviewInfo
+import com.intellij.codeInsight.intention.preview.IntentionPreviewUtils
+import com.intellij.model.SideEffectGuard
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.SelectionModel
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiFile
+import com.intellij.psi.impl.source.PostprocessReformattingAspect
+import org.jetbrains.annotations.ApiStatus
+
+
+@ApiStatus.Internal
+fun tryToCalculateCommandCompletionPreview(
+  previewGenerator: (Editor, PsiFile, Int) -> IntentionPreviewInfo?,
+  context: CommandCompletionProviderContext,
+  highlight: (Int, PsiFile, SelectionModel) -> Boolean,
+  fallback: () -> IntentionPreviewInfo,
+): IntentionPreviewInfo {
+  try {
+    val copiedFile = (context.psiFile.copy() as? PsiFile) ?: return fallback()
+    val customEditor = createCustomEditor(copiedFile, context.editor, context.offset)
+
+    var preview: IntentionPreviewInfo? = null
+    IntentionPreviewUtils.previewSession(customEditor) {
+      PostprocessReformattingAspect.getInstance(context.project).postponeFormattingInside {
+        preview = SideEffectGuard.computeWithoutSideEffects {
+          if (!highlight(context.offset, copiedFile, customEditor.selectionModel)) return@computeWithoutSideEffects null
+          previewGenerator(customEditor, copiedFile, context.offset) ?: fallback()
+        }
+      }
+    }
+    return preview ?: fallback()
+  }
+  catch (e: Exception) {
+    return fallback()
+  }
+}
+
+internal fun tryToCalculateCommandCompletionPreview(
+  commentHandler: MultiCaretCodeInsightActionHandler,
+  context: CommandCompletionProviderContext,
+  highlight: (Int, PsiFile, SelectionModel) -> Boolean,
+  fallback: () -> IntentionPreviewInfo,
+): IntentionPreviewInfo {
+  return tryToCalculateCommandCompletionPreview({ editor, psiFile, offset ->
+                                 commentHandler.invoke(context.project, editor, editor.caretModel.currentCaret, psiFile)
+                                 commentHandler.postInvoke()
+                                 PsiDocumentManager.getInstance(context.project).commitDocument(psiFile.fileDocument)
+                                 IntentionPreviewInfo.CustomDiff(context.psiFile.fileType, null, context.psiFile.text, psiFile.text, true)
+                               }, context, highlight, fallback)
+}
+
+internal fun createCustomEditor(
+  psiFile: PsiFile,
+  editor: Editor,
+  offset: Int,
+): MyEditor {
+  val intentionEditor = MyEditor(psiFile, editor.settings)
+  intentionEditor.caretModel.moveToOffset(offset)
+  return intentionEditor
+}

platform/lang-impl/src/com/intellij/codeInsight/completion/command/commands/PsiElementCommentCompletionCommand.kt

@@ -5,8 +5,12 @@ import com.intellij.codeInsight.CodeInsightBundle
 import com.intellij.codeInsight.completion.command.CommandCompletionProviderContext
 import com.intellij.codeInsight.completion.command.HighlightInfoLookup
 import com.intellij.codeInsight.completion.command.getCommandContext
+import com.intellij.codeInsight.generation.CommentByBlockCommentHandler
+import com.intellij.codeInsight.generation.CommentByLineCommentHandler
+import com.intellij.codeInsight.intention.preview.IntentionPreviewInfo
 import com.intellij.idea.ActionsBundle
 import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.SelectionModel
 import com.intellij.openapi.editor.colors.EditorColors
 import com.intellij.psi.PsiComment
 import com.intellij.psi.PsiElement
@@ -41,13 +45,29 @@ internal class PsiElementCommentByBlockCompletionCommandProvider : ActionCommand
       override fun execute(offset: Int, psiFile: PsiFile, editor: Editor?) {
         if (editor == null) return
         val selectionModel = editor.selectionModel
-        val highLevelContext = getHighLevelContext(offset, psiFile) ?: return
+        if (!highlight(offset, psiFile, selectionModel)) return
+        super.execute(offset, psiFile, editor)
+        selectionModel.removeSelection()
+      }
+
+      private fun highlight(
+        offset: Int,
+        psiFile: PsiFile,
+        selectionModel: SelectionModel,
+      ): Boolean {
+        val highLevelContext = getHighLevelContext(offset, psiFile) ?: return false
         val textRange = highLevelContext.textRange
         val startOffset = textRange.startOffset
         val endOffset = textRange.endOffset
         selectionModel.setSelection(startOffset, endOffset)
-        super.execute(offset, psiFile, editor)
-        selectionModel.removeSelection()
+        return true
+      }
+
+      override fun getPreview(): IntentionPreviewInfo {
+        val commentByBlockCommentHandler = CommentByBlockCommentHandler()
+        return tryToCalculateCommandCompletionPreview(commentByBlockCommentHandler, context,
+                                                      highlight = ({ offset, psiFile, selectionModel -> highlight(offset, psiFile, selectionModel) }),
+                                                      fallback = { super.getPreview() })
       }
     }
   }
@@ -88,7 +108,17 @@ internal class PsiElementCommentByLineCompletionCommandProvider : ActionCommandP
       override fun execute(offset: Int, psiFile: PsiFile, editor: Editor?) {
         if (editor == null) return
         val selectionModel = editor.selectionModel
-        val highLevelContext = getHighLevelContext(offset, psiFile) ?: return
+        if (!highlight(offset, psiFile, selectionModel)) return
+        super.execute(offset, psiFile, editor)
+        selectionModel.removeSelection()
+      }
+
+      private fun highlight(
+        offset: Int,
+        psiFile: PsiFile,
+        selectionModel: SelectionModel,
+      ): Boolean {
+        val highLevelContext = getHighLevelContext(offset, psiFile) ?: return false
         val textRange = highLevelContext.textRange
         var startOffset = textRange.startOffset
         val endOffset = textRange.endOffset
@@ -98,8 +128,14 @@ internal class PsiElementCommentByLineCompletionCommandProvider : ActionCommandP
           current = PsiTreeUtil.skipWhitespacesBackward(current)
         }
         selectionModel.setSelection(startOffset, endOffset)
-        super.execute(offset, psiFile, editor)
-        selectionModel.removeSelection()
+        return true
+      }
+
+      override fun getPreview(): IntentionPreviewInfo {
+        val handler = CommentByLineCommentHandler()
+        return tryToCalculateCommandCompletionPreview(handler, context,
+                                                      highlight = ({ offset, psiFile, selectionModel -> highlight(offset, psiFile, selectionModel) }),
+                                                      fallback = { super.getPreview() })
       }
     }
   }

plugins/kotlin/completion/impl-k2/src/org/jetbrains/kotlin/idea/completion/impl/k2/contributors/commands/KotlinFormatCodeCompletionCommand.kt

@@ -19,7 +19,7 @@ internal class KotlinFormatCodeCompletionCommandProvider : AbstractFormatCodeCom
         val element = getCommandContext(context.offset, context.psiFile) ?: return null
         val targetElement = findTargetToRefactorInner(element)
         val highlightInfoLookup = HighlightInfoLookup(targetElement.textRange, EditorColors.SEARCH_RESULT_ATTRIBUTES, 0)
-        val command = object : KotlinFormatCodeCompletionCommand() {
+        val command = object : KotlinFormatCodeCompletionCommand(context) {
             override val highlightInfo: HighlightInfoLookup
                 get() {
                     return highlightInfoLookup
@@ -38,7 +38,7 @@ private fun findTargetToRefactorInner(element: PsiElement): PsiElement {
 }
 
 
-internal abstract class KotlinFormatCodeCompletionCommand : AbstractFormatCodeCompletionCommand() {
+internal abstract class KotlinFormatCodeCompletionCommand(context: CommandCompletionProviderContext) : AbstractFormatCodeCompletionCommand(context) {
     override fun findTargetToRefactor(element: PsiElement): PsiElement {
         return findTargetToRefactorInner(element)
     }