Set plugin version to chylex-27

Fixes multiple cursors with vim-surround commands `cs, ds, S` (but not `ys`).

gradle.properties

@@ -13,7 +13,7 @@ ideaVersion=2023.3.3
 ideaType=IC
 downloadIdeaSources=true
 instrumentPluginCode=true
-version=chylex-1
+version=chylex-27
 javaVersion=17
 remoteRobotVersion=0.11.22
 antlrVersion=4.10.1

src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdTree.kt

@@ -502,6 +502,13 @@ internal class NerdTree : VimExtension {
         }
       },
     )
+    
+    for (c in ('a'..'z') + ('A'..'Z')) {
+      val ks = KeyStroke.getKeyStroke(c)
+      if (ks !in actionsRoot) {
+        registerCommand(c.toString(), NerdAction.Code { _, _, _ -> })
+      }
+    }
   }
 
   companion object {

src/main/java/com/maddyhome/idea/vim/extension/paragraphmotion/ParagraphMotion.kt

@@ -11,8 +11,8 @@ package com.maddyhome.idea.vim.extension.paragraphmotion
 import com.intellij.openapi.editor.Caret
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
+import com.maddyhome.idea.vim.api.getLineEndForOffset
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.api.normalizeOffset
 import com.maddyhome.idea.vim.command.MappingMode
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.extension.ExtensionHandler
@@ -45,8 +45,7 @@ internal class ParagraphMotion : VimExtension {
     }
 
     fun moveCaretToNextParagraph(editor: VimEditor, caret: Caret, count: Int): Int? {
-      return injector.searchHelper.findNextParagraph(editor, caret.vim, count, true)
+      return injector.searchHelper.findNextParagraph(editor, caret.vim, count, true)?.let(editor::getLineEndForOffset)
-        ?.let { editor.normalizeOffset(it, true) }
     }
   }
 }

src/main/java/com/maddyhome/idea/vim/extension/surround/RepeatedCharSequence.kt

@@ -0,0 +1,30 @@
+package com.maddyhome.idea.vim.extension.surround
+
+import com.intellij.util.text.CharSequenceSubSequence
+
+internal data class RepeatedCharSequence(val text: CharSequence, val count: Int) : CharSequence {
+  override val length = text.length * count
+
+  override fun get(index: Int): Char {
+    if (index < 0 || index >= length) throw IndexOutOfBoundsException()
+    return text[index % text.length]
+  }
+
+  override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
+    return CharSequenceSubSequence(this, startIndex, endIndex)
+  }
+
+  override fun toString(): String {
+    return text.repeat(count)
+  }
+  
+  companion object {
+    fun of(text: CharSequence, count: Int): CharSequence {
+      return when (count) {
+        0 -> ""
+        1 -> text
+        else -> RepeatedCharSequence(text, count)
+      }
+    }
+  }
+}

src/main/java/com/maddyhome/idea/vim/extension/surround/VimSurroundExtension.kt

@@ -13,6 +13,7 @@ import com.intellij.openapi.editor.Editor
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimCaret
+import com.maddyhome.idea.vim.api.VimChangeGroup
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.endsWithNewLine
 import com.maddyhome.idea.vim.api.getLeadingCharacterOffset
@@ -31,7 +32,10 @@ import com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMa
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.setOperatorFunction
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.setRegisterForCaret
+import com.maddyhome.idea.vim.helper.runWithEveryCaretAndRestore
 import com.maddyhome.idea.vim.key.OperatorFunction
+import com.maddyhome.idea.vim.newapi.IjVimCaret
+import com.maddyhome.idea.vim.newapi.IjVimEditor
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.options.helpers.ClipboardOptionHelper
@@ -80,7 +84,7 @@ internal class VimSurroundExtension : VimExtension {
     override val isRepeatable = true
 
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      setOperatorFunction(Operator())
+      setOperatorFunction(Operator(supportsMultipleCursors = false, count = 1)) // TODO
       executeNormalWithoutMapping(injector.parser.parseKeys("g@"), editor.ij)
     }
   }
@@ -101,7 +105,7 @@ internal class VimSurroundExtension : VimExtension {
         val lastNonWhiteSpaceOffset = getLastNonWhitespaceCharacterOffset(editor.text(), lineStartOffset, lineEndOffset)
         if (lastNonWhiteSpaceOffset != null) {
           val range = TextRange(lineStartOffset, lastNonWhiteSpaceOffset + 1)
-          performSurround(pair, range, it)
+          performSurround(pair, range, it, count = operatorArguments.count1)
         }
 //        it.moveToOffset(lineStartOffset)
       }
@@ -121,15 +125,13 @@ internal class VimSurroundExtension : VimExtension {
 
   private class VSurroundHandler : ExtensionHandler {
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      val selectionStart = editor.ij.caretModel.primaryCaret.selectionStart
       // NB: Operator ignores SelectionType anyway
-      if (!Operator().apply(editor, context, editor.mode.selectionType)) {
+      if (!Operator(supportsMultipleCursors = true, count = operatorArguments.count1).apply(editor, context, editor.mode.selectionType)) {
         return
       }
       runWriteAction {
         // Leave visual mode
         executeNormalWithoutMapping(injector.parser.parseKeys("<Esc>"), editor.ij)
-        editor.ij.caretModel.moveToOffset(selectionStart)
       }
     }
   }
@@ -150,6 +152,10 @@ internal class VimSurroundExtension : VimExtension {
 
     companion object {
       fun change(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: Pair<String, String>?) {
+        editor.ij.runWithEveryCaretAndRestore { changeAtCaret(editor, context, charFrom, newSurround) }
+      }
+      
+      fun changeAtCaret(editor: VimEditor, context: ExecutionContext, charFrom: Char, newSurround: Pair<String, String>?) {
         // Save old register values for carets
         val surroundings = editor.sortedCarets()
           .map {
@@ -257,21 +263,42 @@ internal class VimSurroundExtension : VimExtension {
     }
   }
 
-  private class Operator : OperatorFunction {
+  private class Operator(private val supportsMultipleCursors: Boolean, private val count: Int) : OperatorFunction {
-    override fun apply(editor: VimEditor, context: ExecutionContext, selectionType: SelectionType?): Boolean {
+    override fun apply(vimEditor: VimEditor, context: ExecutionContext, selectionType: SelectionType?): Boolean {
-      val ijEditor = editor.ij
+      val editor = vimEditor.ij
-      val c = getChar(ijEditor)
+      val c = getChar(editor)
       if (c.code == 0) return true
 
-      val pair = getOrInputPair(c, ijEditor) ?: return false
+      val pair = getOrInputPair(c, editor) ?: return false
-      // XXX: Will it work with line-wise or block-wise selections?
+
-      val range = getSurroundRange(editor.currentCaret()) ?: return false
+      runWriteAction {
-      performSurround(pair, range, editor.currentCaret(), selectionType == SelectionType.LINE_WISE)
+        val change = VimPlugin.getChange()
+        if (supportsMultipleCursors) {
+          editor.runWithEveryCaretAndRestore {
+            applyOnce(editor, change, pair, count)
+          }
+        }
+        else {
+          applyOnce(editor, change, pair, count)
           // Jump back to start
-      executeNormalWithoutMapping(injector.parser.parseKeys("`["), ijEditor)
+          executeNormalWithoutMapping(injector.parser.parseKeys("`["), editor)
+        }
+      }
       return true
     }
     
+    private fun applyOnce(editor: Editor, change: VimChangeGroup, pair: Pair<String, String>, count: Int) {
+      // XXX: Will it work with line-wise or block-wise selections?
+      val primaryCaret = editor.caretModel.primaryCaret
+      val range = getSurroundRange(primaryCaret.vim)
+      if (range != null) {
+        val start = RepeatedCharSequence.of(pair.first, count)
+        val end = RepeatedCharSequence.of(pair.second, count)
+        change.insertText(IjVimEditor(editor), IjVimCaret(primaryCaret), range.startOffset, start)
+        change.insertText(IjVimEditor(editor), IjVimCaret(primaryCaret), range.endOffset + start.length, end)
+      }
+    }
+
     private fun getSurroundRange(caret: VimCaret): TextRange? {
       val editor = caret.editor
       val ijEditor = editor.ij
@@ -354,15 +381,15 @@ private fun getChar(editor: Editor): Char {
   return res
 }
 
-private fun performSurround(pair: Pair<String, String>, range: TextRange, caret: VimCaret, tagsOnNewLines: Boolean = false) {
+private fun performSurround(pair: Pair<String, String>, range: TextRange, caret: VimCaret, count: Int, tagsOnNewLines: Boolean = false) {
   runWriteAction {
     val editor = caret.editor
     val change = VimPlugin.getChange()
-    val leftSurround = pair.first + if (tagsOnNewLines) "\n" else ""
+    val leftSurround = RepeatedCharSequence.of(pair.first + if (tagsOnNewLines) "\n" else "", count)
 
     val isEOF = range.endOffset == editor.text().length
     val hasNewLine = editor.endsWithNewLine()
-    val rightSurround = if (tagsOnNewLines) {
+    val rightSurround = (if (tagsOnNewLines) {
       if (isEOF && !hasNewLine) {
         "\n" + pair.second
       } else {
@@ -370,7 +397,7 @@ private fun performSurround(pair: Pair<String, String>, range: TextRange, caret:
       }
     } else {
       pair.second
-    }
+    }).let { RepeatedCharSequence.of(it, count) }
 
     change.insertText(editor, caret, range.startOffset, leftSurround)
     change.insertText(editor, caret, range.endOffset + leftSurround.length, rightSurround)

src/main/java/com/maddyhome/idea/vim/group/ChangeGroup.kt

@@ -78,7 +78,6 @@ import java.math.BigInteger
 import java.util.*
 import java.util.function.Consumer
 import kotlin.math.max
-import kotlin.math.min
 
 /**
  * Provides all the insert/replace related functionality
@@ -395,6 +394,7 @@ public class ChangeGroup : VimChangeGroupBase() {
     context: ExecutionContext,
     range: TextRange,
   ) {
+    val startPos = editor.offsetToBufferPosition(caret.offset.point)
     val startOffset = editor.getLineStartForOffset(range.startOffset)
     val endOffset = editor.getLineEndForOffset(range.endOffset)
     val ijEditor = (editor as IjVimEditor).editor
@@ -419,11 +419,7 @@ public class ChangeGroup : VimChangeGroupBase() {
       }
     }
     val afterAction = {
-      val firstLine = editor.offsetToBufferPosition(
+      caret.moveToOffset(injector.motion.moveCaretToLineStartSkipLeading(editor, startPos.line))
-        min(startOffset.toDouble(), endOffset.toDouble()).toInt()
-      ).line
-      val newOffset = injector.motion.moveCaretToLineStartSkipLeading(editor, firstLine)
-      caret.moveToOffset(newOffset)
       restoreCursor(editor, caret, (caret as IjVimCaret).caret.logicalPosition.line)
     }
     if (project != null) {

src/main/java/com/maddyhome/idea/vim/group/IjOptions.kt

@@ -83,7 +83,7 @@ public object IjOptions {
   public val trackactionids: ToggleOption = addOption(ToggleOption("trackactionids", GLOBAL, "tai", false))
   public val unifyjumps: ToggleOption = addOption(ToggleOption("unifyjumps", GLOBAL, "unifyjumps", true))
   public val visualdelay: UnsignedNumberOption = addOption(UnsignedNumberOption("visualdelay", GLOBAL, "visualdelay", 100))
-  public val oldundo: ToggleOption = addOption(ToggleOption("oldundo", GLOBAL, "oldundo", false, isTemporary = true))
+  public val oldundo: ToggleOption = addOption(ToggleOption("oldundo", GLOBAL, "oldundo", true, isTemporary = true))
   public val vimscriptFunctionAnnotation: ToggleOption = addOption(ToggleOption("vimscriptfunctionannotation", GLOBAL, "vimscriptfunctionannotation", true, isTemporary = true))
   public val commandOrMotionAnnotation: ToggleOption = addOption(ToggleOption("commandormotionannotation", GLOBAL, "commandormotionannotation", true, isTemporary = true))
   public val showmodewidget: ToggleOption = addOption(ToggleOption("showmodewidget", GLOBAL, "showmodewidget", false, isTemporary = true))

src/main/java/com/maddyhome/idea/vim/group/MacroAutoImport.kt

@@ -0,0 +1,68 @@
+package com.maddyhome.idea.vim.group
+
+import com.intellij.codeInsight.daemon.ReferenceImporter
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.ReadAction
+import com.intellij.openapi.command.WriteCommandAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.fileEditor.FileDocumentManager
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.progress.Task
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiRecursiveElementWalkingVisitor
+import java.util.function.BooleanSupplier
+
+internal object MacroAutoImport {
+  fun run(editor: Editor, dataContext: DataContext) {
+    val project = CommonDataKeys.PROJECT.getData(dataContext) ?: return
+    val file = PsiDocumentManager.getInstance(project).getPsiFile(editor.document) ?: return
+
+    if (!FileDocumentManager.getInstance().requestWriting(editor.document, project)) {
+      return
+    }
+
+    val importers = ReferenceImporter.EP_NAME.extensionList
+    if (importers.isEmpty()) {
+      return
+    }
+
+    ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Auto import", true) {
+      override fun run(indicator: ProgressIndicator) {
+        val fixes = ReadAction.nonBlocking<List<BooleanSupplier>> {
+          val fixes = mutableListOf<BooleanSupplier>()
+
+          file.accept(object : PsiRecursiveElementWalkingVisitor() {
+            override fun visitElement(element: PsiElement) {
+              for (reference in element.references) {
+                if (reference.resolve() != null) {
+                  continue
+                }
+                for (importer in importers) {
+                  importer.computeAutoImportAtOffset(editor, file, element.textRange.startOffset, true)
+                    ?.let(fixes::add)
+                }
+              }
+              super.visitElement(element)
+            }
+          })
+
+          return@nonBlocking fixes
+        }.executeSynchronously()
+
+        ApplicationManager.getApplication().invokeAndWait {
+          WriteCommandAction.writeCommandAction(project)
+            .withName("Auto Import")
+            .withGroupId("IdeaVimAutoImportAfterMacro")
+            .shouldRecordActionForActiveDocument(true)
+            .run<RuntimeException> {
+              fixes.forEach { it.asBoolean }
+            }
+        }
+      }
+    })
+  }
+}

src/main/java/com/maddyhome/idea/vim/group/MacroGroup.kt

@@ -19,6 +19,7 @@ import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.helper.MessageHelper.message
 import com.maddyhome.idea.vim.macro.VimMacroBase
 import com.maddyhome.idea.vim.newapi.IjVimEditor
+import com.maddyhome.idea.vim.newapi.ij
 
 /**
  * Used to handle playback of macros
@@ -88,6 +89,9 @@ internal class MacroGroup : VimMacroBase() {
         } finally {
           keyStack.removeFirst()
         }
+        if (!isInternalMacro) {
+          MacroAutoImport.run(editor.ij, context.ij)
+        }
       }
 
       if (isInternalMacro) {

src/main/java/com/maddyhome/idea/vim/group/SearchGroup.java

@@ -214,8 +214,8 @@ public class SearchGroup extends IjVimSearchGroup implements PersistentStateComp
    * @param patternOffset   The pattern offset, e.g. `/{pattern}/{offset}`
    * @param direction       The direction to search
    */
-  @TestOnly
+  @Override
-  public void setLastSearchState(@SuppressWarnings("unused") @NotNull Editor editor, @NotNull String pattern,
+  public void setLastSearchState(@SuppressWarnings("unused") @NotNull VimEditor editor, @NotNull String pattern,
                                  @NotNull String patternOffset, Direction direction) {
     if (globalIjOptions(injector).getUseNewRegex()) {
       super.setLastSearchState(pattern, patternOffset, direction);

src/main/java/com/maddyhome/idea/vim/helper/EditorHelper.java

@@ -329,7 +329,7 @@ public class EditorHelper {
 
     final int offset = y - ((screenHeight - lineHeight) / lineHeight / 2 * lineHeight);
     @NotNull final VimEditor editor1 = new IjVimEditor(editor);
-    final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) - 1;
+    final int lastVisualLine = EngineEditorHelperKt.getVisualLineCount(editor1) + editor.getSettings().getAdditionalLinesCount();
     final int offsetForLastLineAtBottom = getOffsetToScrollVisualLineToBottomOfScreen(editor, lastVisualLine);
 
     // For `zz`, we want to use virtual space and move any line, including the last one, to the middle of the screen.

src/main/java/com/maddyhome/idea/vim/helper/EditorHelper.kt

@@ -12,6 +12,7 @@ package com.maddyhome.idea.vim.helper
 
 import com.intellij.codeWithMe.ClientId
 import com.intellij.openapi.editor.Caret
+import com.intellij.openapi.editor.CaretState
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.ex.util.EditorUtil
 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
@@ -19,6 +20,8 @@ import com.intellij.util.ui.table.JBTableRowEditor
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.group.IjOptionConstants
 import com.maddyhome.idea.vim.newapi.globalIjOptions
+import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.inBlockSelection
 import java.awt.Component
 import javax.swing.JComponent
 import javax.swing.JTable
@@ -93,3 +96,41 @@ internal val Caret.vimLine: Int
  */
 internal val Editor.vimLine: Int
   get() = this.caretModel.currentCaret.vimLine
+
+internal inline fun Editor.runWithEveryCaretAndRestore(action: () -> Unit) {
+  val caretModel = this.caretModel
+  val carets = if (this.vim.inBlockSelection) null else caretModel.allCarets
+  if (carets == null || carets.size == 1) {
+    action()
+  }
+  else {
+    var initialDocumentSize = this.document.textLength
+    var documentSizeDifference = 0
+
+    val caretOffsets = carets.map { it.selectionStart to it.selectionEnd }
+    val restoredCarets = mutableListOf<CaretState>()
+
+    caretModel.removeSecondaryCarets()
+    
+    for ((selectionStart, selectionEnd) in caretOffsets) {
+      if (selectionStart == selectionEnd) {
+        caretModel.primaryCaret.moveToOffset(selectionStart + documentSizeDifference)
+      }
+      else {
+        caretModel.primaryCaret.setSelection(
+          selectionStart + documentSizeDifference,
+          selectionEnd + documentSizeDifference
+        )
+      }
+      
+      action()
+      restoredCarets.add(caretModel.caretsAndSelections.single())
+
+      val documentLength = this.document.textLength
+      documentSizeDifference += documentLength - initialDocumentSize
+      initialDocumentSize = documentLength
+    }
+
+    caretModel.caretsAndSelections = restoredCarets
+  } 
+}

src/main/java/com/maddyhome/idea/vim/helper/ScrollViewHelper.kt

@@ -14,7 +14,6 @@ import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.api.normalizeVisualColumn
 import com.maddyhome.idea.vim.api.options
 import com.maddyhome.idea.vim.command.CommandFlags
-import com.maddyhome.idea.vim.state.VimStateMachine
 import com.maddyhome.idea.vim.helper.EditorHelper.getApproximateScreenHeight
 import com.maddyhome.idea.vim.helper.EditorHelper.getApproximateScreenWidth
 import com.maddyhome.idea.vim.helper.EditorHelper.getNonNormalizedVisualLineAtBottomOfScreen
@@ -29,6 +28,7 @@ import com.maddyhome.idea.vim.helper.EditorHelper.scrollVisualLineToBottomOfScre
 import com.maddyhome.idea.vim.helper.EditorHelper.scrollVisualLineToMiddleOfScreen
 import com.maddyhome.idea.vim.helper.EditorHelper.scrollVisualLineToTopOfScreen
 import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.VimStateMachine
 import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.roundToInt
@@ -56,7 +56,7 @@ internal object ScrollViewHelper {
     // that this needs to be replaced as a more or less dumb line for line rewrite.
     val topLine = getVisualLineAtTopOfScreen(editor)
     val bottomLine = getVisualLineAtBottomOfScreen(editor)
-    val lastLine = vimEditor.getVisualLineCount() - 1
+    val lastLine = vimEditor.getVisualLineCount() + editor.settings.additionalLinesCount
 
     // We need the non-normalised value here, so we can handle cases such as so=999 to keep the current line centred
     val scrollOffset = injector.options(vimEditor).scrolloff

src/main/java/com/maddyhome/idea/vim/helper/SearchHelper.java

@@ -9,6 +9,7 @@
 package com.maddyhome.idea.vim.helper;
 
 import com.google.common.collect.Lists;
+import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerEx;
 import com.intellij.lang.CodeDocumentationAwareCommenter;
 import com.intellij.lang.Commenter;
 import com.intellij.lang.Language;
@@ -16,22 +17,30 @@ import com.intellij.lang.LanguageCommenters;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Caret;
 import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiComment;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.spellchecker.SpellCheckerSeveritiesProvider;
 import com.maddyhome.idea.vim.VimPlugin;
 import com.maddyhome.idea.vim.api.EngineEditorHelperKt;
 import com.maddyhome.idea.vim.api.VimEditor;
 import com.maddyhome.idea.vim.regexp.*;
 import com.maddyhome.idea.vim.regexp.match.VimMatchResult;
-import com.maddyhome.idea.vim.state.mode.Mode;
-import com.maddyhome.idea.vim.state.VimStateMachine;
 import com.maddyhome.idea.vim.common.CharacterPosition;
 import com.maddyhome.idea.vim.common.Direction;
 import com.maddyhome.idea.vim.common.TextRange;
 import com.maddyhome.idea.vim.newapi.IjVimCaret;
 import com.maddyhome.idea.vim.newapi.IjVimEditor;
+import com.maddyhome.idea.vim.regexp.CharPointer;
+import com.maddyhome.idea.vim.regexp.RegExp;
+import com.maddyhome.idea.vim.state.VimStateMachine;
+import com.maddyhome.idea.vim.state.mode.Mode;
+import it.unimi.dsi.fastutil.ints.IntComparator;
+import it.unimi.dsi.fastutil.ints.IntIterator;
+import it.unimi.dsi.fastutil.ints.IntRBTreeSet;
+import it.unimi.dsi.fastutil.ints.IntSortedSet;
 import kotlin.Pair;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
@@ -1573,6 +1582,42 @@ public class SearchHelper {
     return PsiHelper.findMethodEnd(editor, caret.getOffset(), count);
   }
 
+  public static int findMisspelledWords(@NotNull Editor editor,
+                                       int startOffset,
+                                       int endOffset,
+                                       int skipCount,
+                                       IntComparator offsetOrdering) {
+    Project project = editor.getProject();
+    if (project == null) {
+      return -1;
+    }
+
+    IntSortedSet offsets = new IntRBTreeSet(offsetOrdering);
+    DaemonCodeAnalyzerEx.processHighlights(editor.getDocument(), project, SpellCheckerSeveritiesProvider.TYPO,
+                                           startOffset, endOffset, highlight -> {
+        if (highlight.getSeverity() == SpellCheckerSeveritiesProvider.TYPO) {
+          int offset = highlight.getStartOffset();
+          if (offset >= startOffset && offset <= endOffset) {
+            offsets.add(offset);
+          }
+        }
+        return true;
+      });
+    
+    if (offsets.isEmpty()) {
+      return -1;
+    }
+    
+    if (skipCount >= offsets.size()) {
+      return offsets.lastInt();
+    }
+    else {
+      IntIterator offsetIterator = offsets.iterator();
+      offsetIterator.skip(skipCount);
+      return offsetIterator.nextInt();
+    }
+  }
+
   private static @NotNull String parseMatchPairsOption(final VimEditor vimEditor) {
     List<String> pairs = options(injector, vimEditor).getMatchpairs();
     StringBuilder res = new StringBuilder();

src/main/java/com/maddyhome/idea/vim/helper/UndoRedoHelper.kt

@@ -14,6 +14,7 @@ import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.command.undo.UndoManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider
+import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
@@ -21,6 +22,8 @@ import com.maddyhome.idea.vim.common.ChangesListener
 import com.maddyhome.idea.vim.listener.SelectionVimListenerSuppressor
 import com.maddyhome.idea.vim.newapi.globalIjOptions
 import com.maddyhome.idea.vim.newapi.ij
+import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.state.mode.inVisualMode
 import com.maddyhome.idea.vim.undo.UndoRedoBase
 
 /**
@@ -39,6 +42,7 @@ internal class UndoRedoHelper : UndoRedoBase() {
 
       if (injector.globalIjOptions().oldundo) {
         SelectionVimListenerSuppressor.lock().use { undoManager.undo(fileEditor) }
+        restoreVisualMode(editor)
       } else {
         // TODO refactor me after VIM-308 when restoring selection and caret movement will be ignored by undo
         editor.runWithChangeTracking {
@@ -74,6 +78,7 @@ internal class UndoRedoHelper : UndoRedoBase() {
     if (undoManager.isRedoAvailable(fileEditor)) {
       if (injector.globalIjOptions().oldundo) {
         SelectionVimListenerSuppressor.lock().use { undoManager.redo(fileEditor) }
+        restoreVisualMode(editor)
       } else {
         undoManager.redo(fileEditor)
         CommandProcessor.getInstance().runUndoTransparentAction {
@@ -131,4 +136,21 @@ internal class UndoRedoHelper : UndoRedoBase() {
     val hasChanges: Boolean
       get() = changeListener.hasChanged || initialPath != editor.getPath()
   }
+
+  private fun restoreVisualMode(editor: VimEditor) {
+    if (!editor.inVisualMode && editor.getSelectionModel().hasSelection()) {
+      val detectedMode = VimPlugin.getVisualMotion().autodetectVisualSubmode(editor)
+      
+      // Visual block selection is restored into multiple carets, so multi-carets that form a block are always
+      // identified as visual block mode, leading to false positives.
+      // Since I use visual block mode much less often than multi-carets, this is a judgment call to never restore
+      // visual block mode.
+      val wantedMode = if (detectedMode == SelectionType.BLOCK_WISE)
+        SelectionType.CHARACTER_WISE
+      else
+        detectedMode
+      
+      VimPlugin.getVisualMotion().enterVisualMode(editor, wantedMode)
+    }
+  }
 }

src/main/java/com/maddyhome/idea/vim/listener/IdeaSpecifics.kt

@@ -27,6 +27,7 @@ import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.actionSystem.ex.AnActionListener
 import com.intellij.openapi.actionSystem.impl.ProxyShortcutSet
 import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.impl.ScrollingModelImpl
 import com.intellij.openapi.project.DumbAwareToggleAction
 import com.intellij.openapi.util.TextRange
 import com.maddyhome.idea.vim.KeyHandler
@@ -56,6 +57,7 @@ internal object IdeaSpecifics {
     private val surrounderAction =
       "com.intellij.codeInsight.generation.surroundWith.SurroundWithHandler\$InvokeSurrounderAction"
     private var editor: Editor? = null
+    private var caretOffset = -1
     private var completionPrevDocumentLength: Int? = null
     private var completionPrevDocumentOffset: Int? = null
     override fun beforeActionPerformed(action: AnAction, event: AnActionEvent) {
@@ -64,6 +66,7 @@ internal object IdeaSpecifics {
       val hostEditor = event.dataContext.getData(CommonDataKeys.HOST_EDITOR)
       if (hostEditor != null) {
         editor = hostEditor
+        caretOffset = hostEditor.caretModel.offset
       }
 
       val isVimAction = (action as? AnActionWrapper)?.delegate is VimShortcutKeyAction
@@ -95,7 +98,8 @@ internal object IdeaSpecifics {
       if (VimPlugin.isNotEnabled()) return
 
       val editor = editor
-      if (editor != null && action is ChooseItemAction && editor.vimStateMachine?.isRecording == true) {
+      if (editor != null) {
+        if (action is ChooseItemAction && editor.vimStateMachine?.isRecording == true) {
           val prevDocumentLength = completionPrevDocumentLength
           val prevDocumentOffset = completionPrevDocumentOffset
 
@@ -122,16 +126,28 @@ internal object IdeaSpecifics {
             )
           }
         ) {
-        editor?.let {
+          val commandState = editor.vim.vimStateMachine
-          val commandState = it.vim.vimStateMachine
           commandState.mode = Mode.NORMAL()
-          VimPlugin.getChange().insertBeforeCursor(it.vim, event.dataContext.vim)
+          VimPlugin.getChange().insertBeforeCursor(editor.vim, event.dataContext.vim)
-          KeyHandler.getInstance().reset(it.vim)
+          KeyHandler.getInstance().reset(editor.vim)
-        }
         }
         //endregion
 
+        if (caretOffset != -1 && caretOffset != editor.caretModel.offset) {
+          val scrollModel = editor.scrollingModel as ScrollingModelImpl
+          if (scrollModel.isScrollingNow) {
+            val v = scrollModel.verticalScrollOffset
+            val h = scrollModel.horizontalScrollOffset
+            scrollModel.finishAnimation()
+            scrollModel.scroll(h, v)
+            scrollModel.finishAnimation()
+          }
+          injector.scroll.scrollCaretIntoView(editor.vim)
+        }
+      }
+
       this.editor = null
+      this.caretOffset = -1
     }
   }
 

src/main/java/com/maddyhome/idea/vim/newapi/IjVimSearchGroup.kt

@@ -32,7 +32,7 @@ import com.maddyhome.idea.vim.vimscript.parser.VimscriptParser.parseExpression
 import org.jetbrains.annotations.TestOnly
 import javax.swing.KeyStroke
 
-public open class IjVimSearchGroup : VimSearchGroupBase() {
+public abstract class IjVimSearchGroup : VimSearchGroupBase() {
 
   init {
     // TODO: Investigate migrating these listeners to use the effective value change listener

src/main/java/com/maddyhome/idea/vim/newapi/IjVimSearchHelper.kt

@@ -29,6 +29,8 @@ import com.maddyhome.idea.vim.helper.checkInString
 import com.maddyhome.idea.vim.helper.fileSize
 import com.maddyhome.idea.vim.state.VimStateMachine.Companion.getInstance
 import com.maddyhome.idea.vim.state.mode.Mode.VISUAL
+import it.unimi.dsi.fastutil.ints.IntComparator
+import it.unimi.dsi.fastutil.ints.IntComparators
 import java.util.*
 import java.util.function.Function
 import java.util.regex.Pattern
@@ -689,4 +691,26 @@ internal class IjVimSearchHelper : VimSearchHelperBase() {
     // End offset exclusive
     return TextRange(bstart, bend + 1)
   }
+
+  override fun findMisspelledWord(editor: VimEditor, caret: ImmutableVimCaret, count: Int): Int {
+    val startOffset: Int
+    val endOffset: Int
+    val skipCount: Int
+    val offsetOrdering: IntComparator
+    
+    if (count < 0) {
+      startOffset = 0
+      endOffset = caret.offset.point - 1
+      skipCount = -count - 1
+      offsetOrdering = IntComparators.OPPOSITE_COMPARATOR
+    }
+    else {
+      startOffset = caret.offset.point + 1
+      endOffset = editor.ij.document.textLength
+      skipCount = count - 1
+      offsetOrdering = IntComparators.NATURAL_COMPARATOR
+    }
+
+    return SearchHelper.findMisspelledWords(editor.ij, startOffset, endOffset, skipCount, offsetOrdering)
+  }
 }

src/main/java/com/maddyhome/idea/vim/package-info.java

@@ -333,7 +333,7 @@
  * |[m|                   {@link com.maddyhome.idea.vim.action.motion.text.MotionMethodPreviousStartAction}
  * |[p|                   {@link com.maddyhome.idea.vim.action.copy.PutVisualTextAfterCursorNoIndentAction}
  * |[p|                   {@link com.maddyhome.idea.vim.action.copy.PutTextAfterCursorNoIndentAction}
- * |[s|                   TO BE IMPLEMENTED
+ * |[s|                   {@link com.maddyhome.idea.vim.action.motion.text.MotionMisspelledWordPreviousAction}
  * |[z|                   TO BE IMPLEMENTED
  * |[{|                   {@link com.maddyhome.idea.vim.action.motion.text.MotionUnmatchedBraceOpenAction}
  * |]_CTRL-D|             TO BE IMPLEMENTED
@@ -358,7 +358,7 @@
  * |]m|                   {@link com.maddyhome.idea.vim.action.motion.text.MotionMethodNextStartAction}
  * |]p|                   {@link com.maddyhome.idea.vim.action.copy.PutVisualTextAfterCursorNoIndentAction}
  * |]p|                   {@link com.maddyhome.idea.vim.action.copy.PutTextAfterCursorNoIndentAction}
- * |]s|                   TO BE IMPLEMENTED
+ * |]s|                   {@link com.maddyhome.idea.vim.action.motion.text.MotionMisspelledWordNextAction}
  * |]z|                   TO BE IMPLEMENTED
  * |]}|                   {@link com.maddyhome.idea.vim.action.motion.text.MotionUnmatchedBraceCloseAction}
  *

src/main/resources/META-INF/plugin.xml

@@ -150,5 +150,6 @@
     </group>
 
     <action id="VimFindActionIdAction" class="com.maddyhome.idea.vim.listener.FindActionIdAction"/>
+    <action id="VimJumpToSource" class="com.intellij.diff.actions.impl.OpenInEditorAction" />
   </actions>
 </idea-plugin>

src/test/java/org/jetbrains/plugins/ideavim/action/motion/gn/GnNextTextObjectTest.kt

@@ -12,8 +12,9 @@ package org.jetbrains.plugins.ideavim.action.motion.gn
 
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.common.Direction
+import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.Mode
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
@@ -85,7 +86,7 @@ class GnNextTextObjectTest : VimTestCase() {
 
   private fun doTestWithSearch(keys: List<KeyStroke>, before: String, after: String) {
     configureByText(before)
-    VimPlugin.getSearch().setLastSearchState(fixture.editor, "test", "", Direction.FORWARDS)
+    VimPlugin.getSearch().setLastSearchState(fixture.editor.vim, "test", "", Direction.FORWARDS)
     typeText(keys)
     assertState(after)
     assertState(Mode.NORMAL())

src/test/java/org/jetbrains/plugins/ideavim/action/motion/gn/GnPreviousTextObjectTest.kt

@@ -12,8 +12,9 @@ package org.jetbrains.plugins.ideavim.action.motion.gn
 
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.common.Direction
+import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.Mode
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
@@ -63,7 +64,7 @@ class GnPreviousTextObjectTest : VimTestCase() {
 
   private fun doTestWithSearch(keys: List<KeyStroke>, before: String, after: String) {
     configureByText(before)
-    VimPlugin.getSearch().setLastSearchState(fixture.editor, "test", "", Direction.FORWARDS)
+    VimPlugin.getSearch().setLastSearchState(fixture.editor.vim, "test", "", Direction.FORWARDS)
     typeText(keys)
     assertState(after)
     assertState(Mode.NORMAL())

src/test/java/org/jetbrains/plugins/ideavim/action/motion/gn/VisualSelectNextSearchTest.kt

@@ -11,9 +11,10 @@ import com.intellij.idea.TestFor
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.action.motion.search.SearchWholeWordForwardAction
 import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.common.Direction
+import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.SelectionType
-import com.maddyhome.idea.vim.common.Direction
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
@@ -57,7 +58,7 @@ class VisualSelectNextSearchTest : VimTestCase() {
   @Test
   fun testWithoutSpaces() {
     configureByText("test<caret>test")
-    VimPlugin.getSearch().setLastSearchState(fixture.editor, "test", "", Direction.FORWARDS)
+    VimPlugin.getSearch().setLastSearchState(fixture.editor.vim, "test", "", Direction.FORWARDS)
     typeText(injector.parser.parseKeys("gn"))
     assertOffset(7)
     assertSelection("test")

src/test/java/org/jetbrains/plugins/ideavim/action/motion/gn/VisualSelectPreviousSearchTest.kt

@@ -11,9 +11,10 @@ import com.intellij.idea.TestFor
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.action.motion.search.SearchWholeWordForwardAction
 import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.common.Direction
+import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.SelectionType
-import com.maddyhome.idea.vim.common.Direction
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
@@ -54,7 +55,7 @@ class VisualSelectPreviousSearchTest : VimTestCase() {
   @Test
   fun testWithoutSpaces() {
     configureByText("tes<caret>ttest")
-    VimPlugin.getSearch().setLastSearchState(fixture.editor, "test", "", Direction.FORWARDS)
+    VimPlugin.getSearch().setLastSearchState(fixture.editor.vim, "test", "", Direction.FORWARDS)
     typeText(injector.parser.parseKeys("gN"))
     assertOffset(0)
     assertSelection("test")

src/test/java/org/jetbrains/plugins/ideavim/action/motion/search/SearchAgainPreviousActionTest.kt

@@ -10,6 +10,7 @@ package org.jetbrains.plugins.ideavim.action.motion.search
 
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.common.Direction
+import com.maddyhome.idea.vim.newapi.vim
 import org.jetbrains.plugins.ideavim.SkipNeovimReason
 import org.jetbrains.plugins.ideavim.TestWithoutNeovim
 import org.jetbrains.plugins.ideavim.VimTestCase
@@ -167,7 +168,7 @@ class SearchAgainPreviousActionTest : VimTestCase() {
 
   private fun doTestWithSearch(keys: String, before: String, after: String) {
     doTest(keys, before, after) {
-      VimPlugin.getSearch().setLastSearchState(it, "all", "", Direction.FORWARDS)
+      VimPlugin.getSearch().setLastSearchState(it.vim, "all", "", Direction.FORWARDS)
     }
   }
 }

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/action/change/change/FilterVisualLinesAction.kt

@@ -30,6 +30,7 @@ public class FilterVisualLinesAction : VimActionHandler.SingleExecution() {
   override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_MOT_LINEWISE)
 
   override fun execute(editor: VimEditor, context: ExecutionContext, cmd: Command, operatorArguments: OperatorArguments): Boolean {
+    injector.markService.setVisualSelectionMarks(editor)
     injector.processGroup.startFilterCommand(editor, context, cmd)
     editor.exitVisualMode()
     return true

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/action/motion/leftright/TillCharacterMotion.kt

@@ -82,6 +82,13 @@ public sealed class TillCharacterMotion(
       )
     }
     injector.motion.setLastFTCmd(tillCharacterMotionType, argument.character)
+    
+    val offset = if (!finishBeforeCharacter) ""
+    else if (direction == Direction.FORWARDS) "s-1"
+    else "s+1"
+    
+    injector.searchGroup.setLastSearchState(editor, argument.character.let { if (it == '.') "\\." else it.toString() }, offset, direction)
+    
     return res.toMotionOrError()
   }
 }

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/action/motion/text/MotionMisspelledWord.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2003-2023 The IdeaVim authors
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE.txt file or at
+ * https://opensource.org/licenses/MIT.
+ */
+package com.maddyhome.idea.vim.action.motion.text
+
+import com.intellij.vim.annotations.CommandOrMotion
+import com.intellij.vim.annotations.Mode
+import com.maddyhome.idea.vim.api.ExecutionContext
+import com.maddyhome.idea.vim.api.ImmutableVimCaret
+import com.maddyhome.idea.vim.api.VimEditor
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.command.Argument
+import com.maddyhome.idea.vim.command.CommandFlags
+import com.maddyhome.idea.vim.command.MotionType
+import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.handler.Motion
+import com.maddyhome.idea.vim.handler.MotionActionHandler
+import com.maddyhome.idea.vim.handler.toMotionOrError
+import com.maddyhome.idea.vim.helper.enumSetOf
+import java.util.*
+
+@CommandOrMotion(keys = ["]s"], modes = [Mode.NORMAL, Mode.VISUAL, Mode.OP_PENDING])
+public class MotionMisspelledWordNextAction : MotionActionHandler.ForEachCaret() {
+  override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_JUMP)
+
+  override fun getOffset(
+    editor: VimEditor,
+    caret: ImmutableVimCaret,
+    context: ExecutionContext,
+    argument: Argument?,
+    operatorArguments: OperatorArguments,
+  ): Motion {
+    return injector.searchHelper.findMisspelledWord(editor, caret, operatorArguments.count1).toMotionOrError()
+  }
+
+  override val motionType: MotionType = MotionType.EXCLUSIVE
+}
+
+@CommandOrMotion(keys = ["[s"], modes = [Mode.NORMAL, Mode.VISUAL, Mode.OP_PENDING])
+public class MotionMisspelledWordPreviousAction : MotionActionHandler.ForEachCaret() {
+  override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_JUMP)
+
+  override fun getOffset(
+    editor: VimEditor,
+    caret: ImmutableVimCaret,
+    context: ExecutionContext,
+    argument: Argument?,
+    operatorArguments: OperatorArguments,
+  ): Motion {
+    return injector.searchHelper.findMisspelledWord(editor, caret, -operatorArguments.count1).toMotionOrError()
+  }
+
+  override val motionType: MotionType = MotionType.EXCLUSIVE
+}

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/api/VimChangeGroup.kt

@@ -145,7 +145,7 @@ public interface VimChangeGroup {
     operatorArguments: OperatorArguments,
   )
 
-  public fun insertText(editor: VimEditor, caret: VimCaret, offset: Int, str: String): VimCaret
+  public fun insertText(editor: VimEditor, caret: VimCaret, offset: Int, str: CharSequence): VimCaret
 
   public fun insertText(editor: VimEditor, caret: VimCaret, str: String): VimCaret
 

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/api/VimChangeGroupBase.kt

@@ -203,7 +203,7 @@ public abstract class VimChangeGroupBase : VimChangeGroup {
    * @param caret  The caret to start insertion in
    * @param str    The text to insert
    */
-  override fun insertText(editor: VimEditor, caret: VimCaret, offset: Int, str: String): VimCaret {
+  override fun insertText(editor: VimEditor, caret: VimCaret, offset: Int, str: CharSequence): VimCaret {
     (editor as MutableVimEditor).insertText(Offset(offset), str)
     val newCaret = caret.moveToInlayAwareOffset(offset + str.length)
 

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/api/VimSearchGroup.kt

@@ -25,7 +25,7 @@ public interface VimSearchGroup {
    * Last used pattern to perform a substitution.
    */
   public var lastSubstitutePattern: String?
-
+  public fun setLastSearchState(editor: VimEditor, pattern: String, patternOffset: String, direction: Direction?)
   public fun searchBackward(editor: VimEditor, offset: Int, count: Int): TextRange?
 
   /**

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/api/VimSearchHelper.kt

@@ -239,4 +239,10 @@ public interface VimSearchHelper {
     count: Int,
     isOuter: Boolean,
   ): TextRange?
+
+  public fun findMisspelledWord(
+    editor: VimEditor,
+    caret: ImmutableVimCaret,
+    count: Int,
+  ): Int
 }