Set plugin version to chylex-20

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

.github/workflows/mergePr.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   build:
 
-    if: false
+    if: github.event.pull_request.merged == true && github.repository == 'JetBrains/ideavim'
     runs-on: ubuntu-latest
 
     steps:

.github/workflows/runUiOctopusTests.yml

@@ -1,85 +0,0 @@
-name: Run Non Octopus UI Tests
-on:
-  workflow_dispatch:
-  schedule:
-      - cron: '0 12 * * *'
-jobs:
-  build-for-ui-test-mac-os:
-    if: github.repository == 'JetBrains/ideavim'
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: zulu
-          java-version: 17
-      - name: Setup FFmpeg
-        uses: FedericoCarboni/setup-ffmpeg@v3
-        with:
-          # Not strictly necessary, but it may prevent rate limit
-          # errors especially on GitHub-hosted macos machines.
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
-      - name: Build Plugin
-        run: gradle :buildPlugin
-      - name: Run Idea
-        run: |
-          mkdir -p build/reports
-          gradle runIdeForUiTests -Doctopus.handler=false > build/reports/idea.log &
-      - name: Wait for Idea started
-        uses: jtalk/url-health-check-action@v3
-        with:
-          url: http://127.0.0.1:8082
-          max-attempts: 20
-          retry-delay: 10s
-      - name: Tests
-        run: gradle :tests:ui-ij-tests:testUi
-      - name: Move video
-        if: always()
-        run: mv tests/ui-ij-tests/video build/reports
-      - name: Move sandbox logs
-        if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
-      - name: Save report
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: ui-test-fails-report-mac
-          path: |
-            build/reports
-            tests/ui-ij-tests/build/reports
-            sandbox-idea-log
-#  build-for-ui-test-linux:
-#    runs-on: ubuntu-latest
-#    steps:
-#      - uses: actions/checkout@v2
-#      - name: Setup Java
-#        uses: actions/setup-java@v2.1.0
-#        with:
-#          distribution: zulu
-#          java-version: 11
-#      - name: Build Plugin
-#        run: gradle :buildPlugin
-#      - name: Run Idea
-#        run: |
-#          export DISPLAY=:99.0
-#          Xvfb -ac :99 -screen 0 1920x1080x16 &
-#          mkdir -p build/reports
-#          gradle :runIdeForUiTests #> build/reports/idea.log
-#      - name: Wait for Idea started
-#        uses: jtalk/url-health-check-action@1.5
-#        with:
-#          url: http://127.0.0.1:8082
-#          max-attempts: 15
-#          retry-delay: 30s
-#      - name: Tests
-#        run: gradle :testUi
-#      - name: Save fails report
-#        if: ${{ failure() }}
-#        uses: actions/upload-artifact@v2
-#        with:
-#          name: ui-test-fails-report-linux
-#          path: |
-#            ui-test-example/build/reports

.github/workflows/runUiPyTests.yml

@@ -1,56 +0,0 @@
-name: Run UI PyCharm Tests
-on:
-  workflow_dispatch:
-  schedule:
-      - cron: '0 12 * * *'
-jobs:
-  build-for-ui-test-mac-os:
-    if: github.repository == 'JetBrains/ideavim'
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: zulu
-          java-version: 17
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-      - name: Setup FFmpeg
-        uses: FedericoCarboni/setup-ffmpeg@v3
-        with:
-          # Not strictly necessary, but it may prevent rate limit
-          # errors especially on GitHub-hosted macos machines.
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
-      - name: Build Plugin
-        run: gradle :buildPlugin
-      - name: Run Idea
-        run: |
-          mkdir -p build/reports
-          gradle :runIdeForUiTests -PideaType=PC > build/reports/idea.log &
-      - name: Wait for Idea started
-        uses: jtalk/url-health-check-action@v3
-        with:
-          url: http://127.0.0.1:8082
-          max-attempts: 20
-          retry-delay: 10s
-      - name: Tests
-        run: gradle :tests:ui-py-tests:testUi
-      - name: Move video
-        if: always()
-        run: mv tests/ui-py-tests/video build/reports
-      - name: Move sandbox logs
-        if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
-      - name: Save report
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: ui-test-fails-report-mac
-          path: |
-            build/reports
-            tests/ui-py-tests/build/reports
-            sandbox-idea-log

.github/workflows/runUiTests.yml

@@ -8,49 +8,42 @@ jobs:
     if: github.repository == 'JetBrains/ideavim'
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: Setup Java
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v2.1.0
         with:
           distribution: zulu
-          java-version: 17
+          java-version: 11
       - name: Setup FFmpeg
-        uses: FedericoCarboni/setup-ffmpeg@v3
+        uses: FedericoCarboni/setup-ffmpeg@v1
         with:
           # Not strictly necessary, but it may prevent rate limit
           # errors especially on GitHub-hosted macos machines.
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2.4.2
+          token: ${{ secrets.GITHUB_TOKEN }}
       - name: Build Plugin
         run: gradle :buildPlugin
       - name: Run Idea
         run: |
           mkdir -p build/reports
-          gradle runIdeForUiTests > build/reports/idea.log &
+          gradle :runIdeForUiTests > build/reports/idea.log &
       - name: Wait for Idea started
-        uses: jtalk/url-health-check-action@v3
+        uses: jtalk/url-health-check-action@1.5
         with:
           url: http://127.0.0.1:8082
           max-attempts: 20
           retry-delay: 10s
       - name: Tests
-        run: gradle :tests:ui-ij-tests:testUi
+        run: gradle :testUi
       - name: Move video
-        if: always()
-        run: mv tests/ui-ij-tests/video build/reports
-      - name: Move sandbox logs
-        if: always()
-        run: mv build/idea-sandbox/system/log sandbox-idea-log
-      - name: Save report
-        if: always()
-        uses: actions/upload-artifact@v4
+        if: ${{ failure() }}
+        run: mv video build/reports
+      - name: Save fails report
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v2
         with:
           name: ui-test-fails-report-mac
           path: |
             build/reports
-            tests/ui-ij-tests/build/reports
-            sandbox-idea-log
 #  build-for-ui-test-linux:
 #    runs-on: ubuntu-latest
 #    steps:

.github/workflows/updateChangelog.yml

@@ -7,12 +7,15 @@ on:
   workflow_dispatch:
   schedule:
     - cron: '0 10 * * *'
+# Workflow run on push is disabled to avoid conflicts when merging PR
+#  push:
+#    branches: [ master ]
 
 jobs:
   build:
 
     runs-on: ubuntu-latest
-    if: false
+    if: github.repository == 'JetBrains/ideavim'
 
     steps:
       - uses: actions/checkout@v3

.gitignore

@@ -23,7 +23,6 @@
 
 # Generated by gradle task "generateGrammarSource"
 src/main/java/com/maddyhome/idea/vim/vimscript/parser/generated
-vim-engine/src/main/java/com/maddyhome/idea/vim/regexp/parser/generated
 # Generated JSONs for lazy classloading
 /vim-engine/src/main/resources/ksp-generated
 /src/main/resources/ksp-generated

.idea/copyright/IdeaVim.xml

@@ -1,6 +1,6 @@
 <component name="CopyrightManager">
   <copyright>
-    <option name="notice" value="Copyright 2003-&amp;#36;today.year The IdeaVim authors&#10;&#10;Use of this source code is governed by an MIT-style&#10;license that can be found in the LICENSE.txt file or at&#10;https://opensource.org/licenses/MIT." />
+    <option name="notice" value="Copyright 2003-2023 The IdeaVim authors&#10;&#10;Use of this source code is governed by an MIT-style&#10;license that can be found in the LICENSE.txt file or at&#10;https://opensource.org/licenses/MIT." />
     <option name="myName" value="IdeaVim" />
   </copyright>
 </component>

.teamcity/_Self/Constants.kt

@@ -5,13 +5,13 @@ object Constants {
   const val EAP_CHANNEL = "eap"
   const val DEV_CHANNEL = "Dev"
 
-  const val GITHUB_TESTS = "2023.3.2"
-  const val NVIM_TESTS = "2023.3.2"
-  const val PROPERTY_TESTS = "2023.3.2"
-  const val LONG_RUNNING_TESTS = "2023.3.2"
-  const val QODANA_TESTS = "2023.3.2"
-  const val RELEASE = "2023.3.2"
+  const val GITHUB_TESTS = "2023.1.2"
+  const val NVIM_TESTS = "2023.1.2"
+  const val PROPERTY_TESTS = "2023.1.2"
+  const val LONG_RUNNING_TESTS = "2023.1.2"
+  const val QODANA_TESTS = "2023.1.2"
+  const val RELEASE = "2023.1.2"
 
-  const val RELEASE_DEV = "2023.3.2"
-  const val RELEASE_EAP = "2023.3.2"
+  const val RELEASE_DEV = "2023.1.2"
+  const val RELEASE_EAP = "2023.1.2"
 }

.teamcity/_Self/Project.kt

@@ -15,7 +15,7 @@ import jetbrains.buildServer.configs.kotlin.v2019_2.BuildType
 import jetbrains.buildServer.configs.kotlin.v2019_2.Project
 
 object Project : Project({
-  description = "Vim engine for JetBrains IDEs"
+  description = "Vim engine for IDEs based on the IntelliJ platform"
 
   subProjects(Releases, OldTests, GitHub)
 
@@ -23,8 +23,9 @@ object Project : Project({
   vcsRoot(GitHubPullRequest)
 
   // Active tests
+  buildType(TestingBuildType("2023.2", "<default>", version = "2023.2.3"))
+  buildType(TestingBuildType("2023.1", "<default>", version = "2023.1.5"))
   buildType(TestingBuildType("Latest EAP", "<default>", version = "LATEST-EAP-SNAPSHOT"))
-  buildType(TestingBuildType("2023.3", "<default>", version = "2023.3"))
   buildType(TestingBuildType("Latest EAP With Xorg", "<default>", version = "LATEST-EAP-SNAPSHOT"))
 
   buildType(PropertyBased)
@@ -39,11 +40,6 @@ object Project : Project({
 
 // Common build type for all configurations
 abstract class IdeaVimBuildType(init: BuildType.() -> Unit) : BuildType({
-  artifactRules = """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-    """.trimIndent()
-
   init()
 
   requirements {

.teamcity/_Self/buildTypes/Compatibility.kt

@@ -34,6 +34,7 @@ object Compatibility : IdeaVimBuildType({
               
               java --version
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}org.jetbrains.IdeaVim-EasyMotion' [latest-IU] -team-city
+              java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}io.github.mishkun.ideavimsneak' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}eu.theblob42.idea.whichkey' [latest-IU] -team-city
               java -jar verifier1/verifier-cli-dev-all-1.jar check-plugin '${'$'}IdeaVimExtension' [latest-IU] -team-city
               # Outdated java -jar verifier/verifier-cli-dev-all.jar check-plugin '${'$'}github.zgqq.intellij-enhance' [latest-IU] -team-city

.teamcity/_Self/buildTypes/LongRunning.kt

@@ -25,7 +25,7 @@ object LongRunning : IdeaVimBuildType({
 
   steps {
     gradle {
-      tasks = "clean :tests:long-running-tests:testLongRunning"
+      tasks = "clean testLongRunning"
       buildFile = ""
       enableStacktrace = true
     }

.teamcity/_Self/buildTypes/Nvim.kt

@@ -39,7 +39,7 @@ object Nvim : IdeaVimBuildType({
               """.trimIndent()
     }
     gradle {
-      tasks = "clean test -Dnvim"
+      tasks = "clean testWithNeovim"
       buildFile = ""
       enableStacktrace = true
     }

.teamcity/_Self/buildTypes/PropertyBased.kt

@@ -24,7 +24,7 @@ object PropertyBased : IdeaVimBuildType({
 
   steps {
     gradle {
-      tasks = "clean :tests:property-tests:testPropertyBased"
+      tasks = "clean testPropertyBased"
       buildFile = ""
       enableStacktrace = true
     }

.teamcity/_Self/buildTypes/PublishVimEngine.kt

@@ -20,8 +20,8 @@ object PublishVimEngine : IdeaVimBuildType({
   params {
     param("env.ORG_GRADLE_PROJECT_engineVersion", "%build.number%")
     param("env.ORG_GRADLE_PROJECT_uploadUrl", "https://packages.jetbrains.team/maven/p/ij/intellij-dependencies")
-    password("env.ORG_GRADLE_PROJECT_spacePassword", "credentialsJSON:5ea56f8c-efe7-4e1e-83de-0c02bcc39d0b", display = ParameterDisplay.HIDDEN)
-    param("env.ORG_GRADLE_PROJECT_spaceUsername", "a121c67e-39ac-40e6-bf82-649855ec27b6")
+    password("env.ORG_GRADLE_PROJECT_spacePassword", "credentialsJSON:790b4e43-ee83-4184-b81b-678afab60409", display = ParameterDisplay.HIDDEN)
+    param("env.ORG_GRADLE_PROJECT_spaceUsername", "Aleksei.Plate")
   }
 
   vcs {

.teamcity/_Self/buildTypes/Qodana.kt

@@ -46,8 +46,8 @@ object Qodana : IdeaVimBuildType({
         version = Qodana.JVMVersion.LATEST
       }
       reportAsTests = true
+      additionalDockerArguments = "-e QODANA_TOKEN=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJvcmdhbml6YXRpb24iOiIzUFZrQSIsInByb2plY3QiOiIzN1FlQSIsInRva2VuIjoiM0t2bXoifQ.uohp81tM7iAfvvB6k8faarfpV-OjusAaEbWQ8iNrOgs"
       additionalQodanaArguments = "--baseline qodana.sarif.json"
-      cloudToken = "credentialsJSON:6b79412e-9198-4862-9223-c5019488f903"
     }
   }
 
@@ -63,6 +63,7 @@ object Qodana : IdeaVimBuildType({
         timezone = "SERVER"
       }
       param("dayOfWeek", "Sunday")
+      enabled = false
     }
   }
 

.teamcity/_Self/buildTypes/ReleaseEap.kt

@@ -5,7 +5,6 @@ import _Self.Constants.RELEASE_EAP
 import _Self.IdeaVimBuildType
 import jetbrains.buildServer.configs.kotlin.v2019_2.CheckoutMode
 import jetbrains.buildServer.configs.kotlin.v2019_2.DslContext
-import jetbrains.buildServer.configs.kotlin.v2019_2.ParameterDisplay
 import jetbrains.buildServer.configs.kotlin.v2019_2.buildFeatures.sshAgent
 import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
 import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.script
@@ -31,11 +30,6 @@ object ReleaseEap : IdeaVimBuildType({
       "credentialsJSON:a8ab8150-e6f8-4eaf-987c-bcd65eac50b5",
       label = "Slack Token"
     )
-    password(
-      "env.YOUTRACK_TOKEN",
-      "credentialsJSON:2479995b-7b60-4fbb-b095-f0bafae7f622",
-      display = ParameterDisplay.HIDDEN
-    )
   }
 
   vcs {
@@ -67,26 +61,26 @@ object ReleaseEap : IdeaVimBuildType({
       tasks = "scripts:addReleaseTag"
     }
     gradle {
-      name = "Publish plugin"
       tasks = "publishPlugin"
     }
+    // Same as the script below. However, jgit can't find ssh keys on TeamCity
+//    gradle {
+//      name = "Push changes to the repo"
+//      tasks = "scripts:pushChanges"
+//    }
     script {
       name = "Push changes to the repo"
       scriptContent = """
-      branch=$(git branch --show-current)
+      branch=$(git branch --show-current)  
       echo current branch is ${'$'}branch
       if [ "master" != "${'$'}branch" ];
       then
         exit 1
       fi
-
+      
       git push origin %build.number%
       """.trimIndent()
     }
-    gradle {
-      name = "YouTrack post release actions"
-      tasks = "scripts:eapReleaseActions"
-    }
   }
 
   features {

.teamcity/_Self/buildTypes/ReleasePlugin.kt

@@ -45,11 +45,7 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
       "credentialsJSON:a8ab8150-e6f8-4eaf-987c-bcd65eac50b5",
       label = "Slack Token"
     )
-    password(
-      "env.ORG_GRADLE_PROJECT_youtrackToken",
-      "credentialsJSON:7bc0eb3a-b86a-4ebd-b622-d4ef12d7e1d3",
-      display = ParameterDisplay.HIDDEN
-    )
+    password("env.ORG_GRADLE_PROJECT_youtrackToken", "credentialsJSON:3cd3e867-282c-451f-b958-bc95d56a8450", display = ParameterDisplay.HIDDEN)
     param("env.ORG_GRADLE_PROJECT_releaseType", releaseType)
   }
 
@@ -69,25 +65,9 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
       name = "Pull git history"
       scriptContent = "git fetch --unshallow"
     }
-    script {
-      name = "Reset release branch"
-      scriptContent = """
-        if [ "major" = "$releaseType" ] || [ "minor" = "$releaseType" ]
-        then
-          echo Resetting the release branch because the release type is $releaseType
-          git checkout master
-          latest_eap=${'$'}(git describe --tags --match="[0-9].[0-9]*.[0-9]-eap.[0-9]*" --abbrev=0 HEAD)
-          echo Latest EAP: ${'$'}latest_eap
-          commit_of_latest_eap=${'$'}(git rev-list -n 1 ${'$'}latest_eap)
-          echo Commit of latest EAP: ${'$'}commit_of_latest_eap
-          git checkout release
-          git reset --hard ${'$'}commit_of_latest_eap
-        else
-          git checkout release
-          echo Do not reset the release branch because the release type is $releaseType
-        fi
-        echo Checked out release branch
-      """.trimIndent()
+    gradle {
+      name = "Select branch"
+      tasks = "scripts:selectBranch"
     }
     gradle {
       name = "Calculate new version"
@@ -97,50 +77,53 @@ sealed class ReleasePlugin(private val releaseType: String) : IdeaVimBuildType({
       name = "Set TeamCity build number"
       tasks = "scripts:setTeamCityBuildNumber"
     }
-//    gradle {
-//      name = "Update change log"
-//      tasks = "scripts:changelogUpdateUnreleased"
-//    }
-//    gradle {
-//      name = "Commit preparation changes"
-//      tasks = "scripts:commitChanges"
-//    }
+    gradle {
+      name = "Update change log"
+      tasks = "scripts:changelogUpdateUnreleased"
+    }
+    gradle {
+      name = "Commit preparation changes"
+      tasks = "scripts:commitChanges"
+    }
     gradle {
       name = "Add release tag"
       tasks = "scripts:addReleaseTag"
     }
-    script {
-      name = "Run tests"
-      scriptContent = "./gradlew test"
+    gradle {
+      name = "Reset release branch"
+      tasks = "scripts:resetReleaseBranch"
     }
     gradle {
       name = "Publish release"
       tasks = "publishPlugin"
     }
-//    script {
-//      name = "Checkout master branch"
-//      scriptContent = """
-//        echo Checkout master
-//        git checkout master
-//      """.trimIndent()
-//    }
 //    gradle {
-//      name = "Update change log in master"
-//      tasks = "scripts:changelogUpdateUnreleased"
-//    }
-//    gradle {
-//      name = "Commit preparation changes in master"
-//      tasks = "scripts:commitChanges"
+//      name = "Push changes to the repo"
+//      tasks = "scripts:pushChangesWithReleaseBranch"
 //    }
     script {
       name = "Push changes to the repo"
       scriptContent = """
-      git checkout release
-      echo checkout release branch
-      git branch --set-upstream-to=origin/release release
-      git push origin --force
-      # Push tag
-      git push origin %build.number%
+      branch=$(git branch --show-current)  
+      echo current branch is ${'$'}branch
+      if [ "master" != "${'$'}branch" ];
+      then
+        git checkout master
+      fi
+      
+      git push origin --tags
+      git push origin
+      
+      if [ "patch" != $releaseType  ];
+      then
+        git checkout release
+        echo checkout release branch
+        git branch --set-upstream-to=origin/release release
+        git push --tags
+        git push origin --force
+      fi
+      
+      git checkout ${'$'}branch
       """.trimIndent()
     }
     gradle {

.teamcity/_Self/subprojects/OldTests.kt

@@ -20,6 +20,4 @@ object OldTests : Project({
   buildType(TestingBuildType("IC-2021.2.2", "203-212", javaVersion = "1.8", javaPlugin = false))
   buildType(TestingBuildType("IC-2021.3.2", "213-221", javaVersion = "1.8", javaPlugin = false))
   buildType(TestingBuildType("IC-2022.2.3", branch = "222", javaPlugin = false))
-  buildType(TestingBuildType("IC-2023.1", "231-232", javaPlugin = false))
-  buildType(TestingBuildType("IC-2023.2", "231-232", javaPlugin = false))
 })

.teamcity/patches/buildTypes/IdeaVimTests_Latest_EAP.kts

@@ -1,39 +0,0 @@
-package patches.buildTypes
-
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.GradleBuildStep
-import jetbrains.buildServer.configs.kotlin.v2019_2.buildSteps.gradle
-import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
-
-/*
-This patch script was generated by TeamCity on settings change in UI.
-To apply the patch, change the buildType with id = 'IdeaVimTests_Latest_EAP'
-accordingly, and delete the patch script.
-*/
-changeBuildType(RelativeId("IdeaVimTests_Latest_EAP")) {
-    check(artifactRules == """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-    """.trimIndent()) {
-        "Unexpected option value: artifactRules = $artifactRules"
-    }
-    artifactRules = """
-        +:build/reports => build/reports
-        +:/mnt/agent/temp/buildTmp/ => /mnt/agent/temp/buildTmp/
-        +:tests/java-tests/build/reports => tests/java-tests/build/reports
-    """.trimIndent()
-
-    expectSteps {
-        gradle {
-            tasks = "clean test"
-            buildFile = ""
-            enableStacktrace = true
-        }
-    }
-    steps {
-        update<GradleBuildStep>(0) {
-            clearConditions()
-            jdkHome = "/usr/lib/jvm/java-17-amazon-corretto"
-        }
-    }
-}

.teamcity/patches/buildTypes/PublishVimEngine.kts

@@ -1,19 +0,0 @@
-package patches.buildTypes
-
-import jetbrains.buildServer.configs.kotlin.v2019_2.*
-import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
-
-/*
-This patch script was generated by TeamCity on settings change in UI.
-To apply the patch, change the buildType with id = 'PublishVimEngine'
-accordingly, and delete the patch script.
-*/
-changeBuildType(RelativeId("PublishVimEngine")) {
-    vcs {
-
-        check(branchFilter == "+:<default>") {
-            "Unexpected option value: branchFilter = $branchFilter"
-        }
-        branchFilter = "+:fleet"
-    }
-}

.teamcity/patches/buildTypes/ReleaseMinor.kts

@@ -0,0 +1,20 @@
+package patches.buildTypes
+
+import jetbrains.buildServer.configs.kotlin.v2019_2.*
+import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
+
+/*
+This patch script was generated by TeamCity on settings change in UI.
+To apply the patch, change the buildType with id = 'ReleaseMinor'
+accordingly, and delete the patch script.
+*/
+changeBuildType(RelativeId("ReleaseMinor")) {
+    params {
+        expect {
+            password("env.ORG_GRADLE_PROJECT_youtrackToken", "credentialsJSON:3cd3e867-282c-451f-b958-bc95d56a8450", display = ParameterDisplay.HIDDEN)
+        }
+        update {
+            password("env.ORG_GRADLE_PROJECT_youtrackToken", "credentialsJSON:7bc0eb3a-b86a-4ebd-b622-d4ef12d7e1d3", display = ParameterDisplay.HIDDEN)
+        }
+    }
+}

.teamcity/patches/buildTypes/ReleasePatch.kts

@@ -0,0 +1,20 @@
+package patches.buildTypes
+
+import jetbrains.buildServer.configs.kotlin.v2019_2.*
+import jetbrains.buildServer.configs.kotlin.v2019_2.ui.*
+
+/*
+This patch script was generated by TeamCity on settings change in UI.
+To apply the patch, change the buildType with id = 'ReleasePatch'
+accordingly, and delete the patch script.
+*/
+changeBuildType(RelativeId("ReleasePatch")) {
+    params {
+        expect {
+            password("env.ORG_GRADLE_PROJECT_youtrackToken", "credentialsJSON:3cd3e867-282c-451f-b958-bc95d56a8450", display = ParameterDisplay.HIDDEN)
+        }
+        update {
+            password("env.ORG_GRADLE_PROJECT_youtrackToken", "credentialsJSON:7bc0eb3a-b86a-4ebd-b622-d4ef12d7e1d3", display = ParameterDisplay.HIDDEN)
+        }
+    }
+}

.teamcity/settings.kts

@@ -30,5 +30,5 @@ node (Plugins -> teamcity-configs -> teamcity-configs:generate),
 the 'Debug' option is available in the context menu for the task.
 */
 
-version = "2023.11"
+version = "2023.05"
 project(_Self.Project)

AUTHORS.md

@@ -487,22 +487,6 @@ Contributors:
   [![icon][github]](https://github.com/pWydmuch)
    
   pWydmuch
-* [![icon][mail]](mailto:leonid989@gmail.com)
-  [![icon][github]](https://github.com/Infonautica)
-   
-  Leonid Danilov
-* [![icon][mail]](mailto:emanuel-367@hotmail.com)
-  [![icon][github]](https://github.com/emanuelgestosa)
-   
-  Emanuel Gestosa
-* [![icon][mail]](mailto:81118900+lippfi@users.noreply.github.com)
-  [![icon][github]](https://github.com/lippfi)
-   
-  lippfi, 
-* [![icon][mail]](mailto:fillipser143@gmail.com)
-  [![icon][github]](https://github.com/Parker7123)
-   
-  FilipParker
 
 Previous contributors:
 

CHANGES.md

@@ -23,22 +23,7 @@ It is important to distinguish EAP from traditional pre-release software.
 Please note that the quality of EAP versions may at times be way below even
 usual beta standards.
 
-## End of changelog file maintenance
-
-Since version 2.9.0, the changelog can be found on YouTrack
-
-To Be Released: https://youtrack.jetbrains.com/issues/VIM?q=%23%7BReady%20To%20Release%7D%20
-Latest Fixes: https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20sort%20by:%20updated%20
-
-## 2.9.0, 2024-02-20
-
-### Fixes:
-* [VIM-3055](https://youtrack.jetbrains.com/issue/VIM-3055) Fix the issue with double deleting after dot
-
-### Merged PRs:
-* [805](https://github.com/JetBrains/ideavim/pull/805) by [chylex](https://github.com/chylex): VIM-3238 Fix recording a macro that replays another macro
-
-## 2.8.0, 2024-01-30
+## To Be Released
 
 ### Fixes:
 * [VIM-3130](https://youtrack.jetbrains.com/issue/VIM-3130) Change the build version to 2023.1.2
@@ -46,28 +31,6 @@ Latest Fixes: https://youtrack.jetbrains.com/issues/VIM?q=State:%20Fixed%20sort%
 * [VIM-3165](https://youtrack.jetbrains.com/issue/VIM-3165) Do not process enter key as IdeaVim shortcut if it's not an actual keypress
 * [VIM-3159](https://youtrack.jetbrains.com/issue/VIM-3159) Shift-enter now works in normal mode again
 * [VIM-3157](https://youtrack.jetbrains.com/issue/VIM-3157) Do not invoke enter in invokeLater for python console
-* [VIM-3195](https://youtrack.jetbrains.com/issue/VIM-3195) Fix escape in injected editor
-* [VIM-3190](https://youtrack.jetbrains.com/issue/VIM-3190) Do not use octopus handler if the enter key is used with modifiers like shift or control
-* [VIM-3203](https://youtrack.jetbrains.com/issue/VIM-3203) Split action not works in normal mode
-* [VIM-3184](https://youtrack.jetbrains.com/issue/VIM-3184) Revert "VIM-3184: Temporally disable new handlers for the thin client"
-* [VIM-3186](https://youtrack.jetbrains.com/issue/VIM-3186) Do not multiply the enter action by the amount of carets
-* [VIM-3177](https://youtrack.jetbrains.com/issue/VIM-3177) Formatting of commit message works again
-* [VIM-1611](https://youtrack.jetbrains.com/issue/VIM-1611) actions related to resolving conflicts doesn't seem to work
-* [VIM-3204](https://youtrack.jetbrains.com/issue/VIM-3204) Add checker that verifies the configuratin of the keymap
-* [VIM-3084](https://youtrack.jetbrains.com/issue/VIM-3084) Double update for the status bar icon
-* [VIM-3176](https://youtrack.jetbrains.com/issue/VIM-3176) Reselecting visual selection after pasting above it select wrong lines
-* [VIM-3206](https://youtrack.jetbrains.com/issue/VIM-3206) Disable both copilot suggestion and insert mode on a single escape
-* [VIM-3090](https://youtrack.jetbrains.com/issue/VIM-3090) Cmd line mode saves the visual mode
-* [VIM-3085](https://youtrack.jetbrains.com/issue/VIM-3085) Open access to VimTypedActionHandler and VimShortcutKeyAction
-* [VIM-3260](https://youtrack.jetbrains.com/issue/VIM-3260) Processing the offsets at the file end
-* [VIM-3183](https://youtrack.jetbrains.com/issue/VIM-3183) Execute .ideavimrc on pooled thread
-
-### Merged PRs:
-* [763](https://github.com/JetBrains/ideavim/pull/763) by [Sam Ng](https://github.com/samabcde): Fix(VIM-3176) add test for restore selection after pasting in/below s…
-* [772](https://github.com/JetBrains/ideavim/pull/772) by [chylex](https://github.com/chylex): Prevent code completion popup from appearing after running a macro
-* [787](https://github.com/JetBrains/ideavim/pull/787) by [Leonid Danilov](https://github.com/Infonautica): Added "Which-Key" to Plugins
-* [778](https://github.com/JetBrains/ideavim/pull/778) by [lippfi](https://github.com/lippfi): Showmode
-* [788](https://github.com/JetBrains/ideavim/pull/788) by [Matt Ellis](https://github.com/citizenmatt): Refactor VimOptionGroupBase
 
 ## 2.7.0, 2023-11-07
 

README.md

@@ -324,7 +324,7 @@ IdeaVim tips and tricks
 - Use the power of IJ and Vim:
     - `set ideajoin` to enable join via the IDE. See the [examples](https://jb.gg/f9zji9).
     - Make sure `ideaput` is enabled for `clipboard` to enable native IJ insertion in Vim.
-    - Sync IJ bookmarks and IdeaVim global marks: `set ideamarks` (works for marks with capital letters only)
+    - Sync IJ bookmarks and Vim marks: `set ideamarks`
     - Check out more [ex commands](https://github.com/JetBrains/ideavim/wiki/%22set%22-commands).
 
 - Use your vim settings with IdeaVim. Put `source ~/.vimrc` in `~/.ideavimrc`.

ThirdPartyLicenses.md

@@ -84,8 +84,3 @@ IV)  It is not allowed to remove this license from the distribution of the Vim
      license for previous Vim releases instead of the license that they came
      with, at your option.
 ```
-
----
-
-File [sneakIcon.png](doc/images/sneakIcon.svg), which is originally an icon of the ideavim-sneak plugin,
-is merged icons of IdeaVim plugin and a random sneaker by FreePic from flaticon.com.

annotation-processors/build.gradle.kts

@@ -8,11 +8,9 @@
 
 plugins {
   kotlin("jvm")
-  kotlin("plugin.serialization") version "1.9.22"
+  kotlin("plugin.serialization") version "1.8.21"
 }
 
-val kotlinxSerializationVersion: String by project
-
 group = "com.intellij"
 version = "SNAPSHOT"
 
@@ -21,10 +19,6 @@ repositories {
 }
 
 dependencies {
-  compileOnly("com.google.devtools.ksp:symbol-processing-api:1.9.23-1.0.19")
-  implementation("org.jetbrains.kotlinx:kotlinx-serialization-json-jvm:$kotlinxSerializationVersion") {
-    // kotlin stdlib is provided by IJ, so there is no need to include it into the distribution
-    exclude("org.jetbrains.kotlin", "kotlin-stdlib")
-    exclude("org.jetbrains.kotlin", "kotlin-stdlib-common")
-  }
+  compileOnly("com.google.devtools.ksp:symbol-processing-api:1.9.20-1.0.14")
+  implementation("org.jetbrains.kotlinx:kotlinx-serialization-json-jvm:1.6.0")
 }

annotation-processors/src/main/kotlin/com/intellij/vim/annotations/CommandOrMotion.kt

@@ -44,7 +44,7 @@ enum class Mode(val abbrev: Char) {
   OP_PENDING('O'),
 
   /**
-   * Indicates this key mapping applies to Insert or Replace modes
+   * Indicates this key mapping applies to Insert mode
    */
   INSERT('I'),
 

doc/IdeaVim Plugins.md

@@ -44,21 +44,16 @@ All commands with the mappings are supported. See the [full list of supported co
 
 <details>
 <summary><h2>sneak</h2></summary>
-
-<img src="images/sneakIcon.svg" width="80" height="80" alt="icon"/>  
-
-By [Mikhail Levchenko](https://github.com/Mishkun)  
-Original repository with the plugin: https://github.com/Mishkun/ideavim-sneak  
+   
 Original plugin: [vim-sneak](https://github.com/justinmk/vim-sneak).
    
 ### Setup:
-- Add the following command to `~/.ideavimrc`: `Plug 'justinmk/vim-sneak'`
+- Install [IdeaVim-sneak](https://plugins.jetbrains.com/plugin/15348-ideavim-sneak) plugin.
+- Add the following command to `~/.ideavimrc`: `set sneak`
    
 ### Instructions
-
-* Type `s` and two chars to start sneaking in forward direction
-* Type `S` and two chars to start sneaking in backward direction
-* Type `;` or `,` to proceed with sneaking just as if you were using `f` or `t` commands
+   
+See the [docs](https://github.com/Mishkun/ideavim-sneak#usage)
 
 </details>
 
@@ -401,19 +396,3 @@ Original plugin: [quick-scope](https://github.com/unblevable/quick-scope).
 https://plugins.jetbrains.com/plugin/19417-ideavim-quickscope
 
 </details>
-
-
-<details>
-<summary><h2>Which-Key</h2></summary>
-
-Original plugin: [vim-which-key](https://github.com/liuchengxu/vim-which-key).
-
-### Setup:
-- Install [Which-Key](https://plugins.jetbrains.com/plugin/15976-which-key) plugin.
-- Add the following command to `~/.ideavimrc`: `set which-key`
-
-### Instructions
-
-https://github.com/TheBlob42/idea-which-key?tab=readme-ov-file#installation
-
-</details>

doc/ideajoin-examples.md

@@ -3,11 +3,6 @@ Put `set ideajoin` to your `~/.ideavimrc` to enable this functionality.
 
 Now, you can press `J` (`shift+j`) on a line or a selected block of text to join the lines together.
 
-:warning: This feature is language-specific. This means that the IDE should implement this feature for a particular
-language in order for the IDE to work as described below. If any of the examples provided below don't match your case, 
-please file an issue in the project related to your IDE: https://youtrack.jetbrains.com/.  
-Here is a list of known requests: https://youtrack.jetbrains.com/issues?q=links:VIM-3214.
-
 * Automatic join concatenated lines:
 
 ```

doc/images/sneakIcon.svg

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<svg viewBox="386.498 234 32 32" xmlns="http://www.w3.org/2000/svg">
-  <defs>
-    <linearGradient id="ideavim_plugin-a" x1="-6.748%" x2="47.286%" y1="33.61%" y2="85.907%">
-      <stop offset="0" stop-color="#3BEA62"/>
-      <stop offset="1" stop-color="#087CFA"/>
-    </linearGradient>
-  </defs>
-  <g transform="matrix(1.238978, 0.90017, -0.90017, 1.238978, 131.776901, -422.953003)" style="">
-    <path d="M 399.962 247.648 C 399.207 246.894 399.147 246.318 399.692 245.453 C 400.237 244.588 401.955 245.886 401.955 245.886 L 401.955 250.737" style="fill: rgb(248, 245, 231);"/>
-    <path d="M 413.846 253.602 C 413.846 255.077 411.827 256.134 409.392 256.134 L 396.381 256.134 C 395.211 256.134 394.232 256.003 393.433 255.817 C 391.496 255.367 390.613 254.596 390.613 254.596 L 391.478 252.513 L 393.607 252.617 Z M 413.846 253.602" fill="#cce6f6" style=""/>
-    <path d="M 413.846 253.602 C 413.846 253.602 411.475 254.468 408.27 254.468 C 405.94 254.468 398.116 253.433 394.023 252.869 C 392.488 252.658 391.478 252.512 391.478 252.512 C 390.864 251.662 392.078 248.741 392.758 247.263 C 393.118 246.484 393.85 245.929 394.703 245.83 C 394.782 245.82 394.861 245.815 394.939 245.815 C 395.369 245.815 395.645 246.532 396.059 247.225 C 396.446 247.877 396.955 248.507 397.823 248.507 C 399.617 248.507 401.955 245.886 401.955 245.886 C 406.544 249.03 410.097 250.43 410.097 250.43 C 410.097 250.43 413.061 250.446 413.782 251.167 C 414.503 251.888 414.422 253.218 413.846 253.602 Z M 413.846 253.602" style="fill: rgb(8, 124, 250);"/>
-    <path d="M 394.023 252.869 L 393.433 255.817 C 391.496 255.367 390.613 254.596 390.613 254.596 L 391.478 252.513 L 393.607 252.617 Z M 394.023 252.869" fill="#9dcae0" style=""/>
-    <path d="M 396.059 247.225 C 395.073 245.986 393.193 250.255 394.023 252.869 C 392.488 252.658 391.478 252.513 391.478 252.513 C 390.864 251.662 392.078 248.741 392.758 247.263 C 393.118 246.484 393.85 245.929 394.703 245.83 C 394.782 245.82 394.861 245.815 394.939 245.815 C 395.369 245.815 395.645 246.532 396.059 247.225 Z M 396.059 247.225" style="fill: rgb(14, 112, 142);"/>
-    <path d="M 403.527 246.924 L 399.174 251.768 C 397.7 250.892 395.578 250.174 394.016 249.717 C 392.843 249.372 391.985 249.174 391.959 249.168 C 392.108 248.769 392.268 248.379 392.421 248.022 L 394.341 248.65 L 394.884 248.827 C 395.509 249.031 396.192 248.95 396.753 248.608 L 397.153 248.363 C 397.35 248.454 397.572 248.507 397.823 248.507 C 399.617 248.507 401.955 245.886 401.955 245.886 C 402.494 246.256 403.02 246.601 403.527 246.924 Z M 403.527 246.924" style="fill: rgb(59, 234, 98);"/>
-    <path d="M 413.847 253.602 C 413.847 253.602 411.475 254.468 408.27 254.468 C 407.586 254.468 406.426 254.378 405.025 254.238 L 405.025 254.237 C 405.025 253.495 406.924 251.743 408.366 251.616 C 408.623 252.865 410.097 252.512 411.219 252.128 C 412.341 251.743 413.783 251.167 413.783 251.167 C 414.503 251.888 414.422 253.218 413.847 253.602 Z M 413.847 253.602" style="fill: rgb(8, 124, 250);"/>
-    <path d="M 394.341 248.65 C 394.214 248.978 394.103 249.339 394.016 249.717 C 392.843 249.372 391.985 249.174 391.959 249.168 C 392.108 248.769 392.268 248.379 392.421 248.022 Z M 394.341 248.65" style="fill: rgb(37, 187, 163);"/>
-    <path d="M 408.366 251.616 C 406.924 251.743 405.025 253.495 405.025 254.237 L 405.025 254.238 C 403.784 254.113 402.355 253.948 400.899 253.77 C 400.899 253.051 400.191 252.372 399.174 251.768 L 399.174 251.768 L 403.528 246.924 C 407.331 249.34 410.097 250.43 410.097 250.43 C 410.77 251.102 409.809 251.487 408.366 251.616 Z M 408.366 251.616" style="fill: rgb(248, 245, 231);"/>
-    <polygon fill="url(#ideavim_plugin-a)" fill-rule="evenodd" points="406.356 248.463 403.261 252.616 402.183 248.212 400.984 249.899 401.999 254.236 403.927 254.176 407.639 249.062" style="" transform="matrix(0.994522, 0.104529, -0.104529, 0.994522, 28.475005, -40.88594)"/>
-    <g fill="#fb6572" transform="matrix(0.046265, 0, 0, 0.046265, 390.612823, 245.155533)" style="">
-      <path d="m288.839844 72.65625c-2.007813 0-4.011719-.761719-5.542969-2.292969-3.058594-3.0625-3.058594-8.023437 0-11.082031l20.089844-20.089844c3.0625-3.058594 8.023437-3.058594 11.082031 0 3.058594 3.0625 3.0625 8.023438 0 11.082032l-20.089844 20.089843c-1.527344 1.53125-3.535156 2.292969-5.539062 2.292969zm0 0" style="fill: rgb(56, 228, 105);"/>
-      <path d="m314.589844 87.082031c-2.007813 0-4.011719-.765625-5.542969-2.296875-3.0625-3.058594-3.0625-8.019531 0-11.082031l20.089844-20.085937c3.0625-3.058594 8.023437-3.058594 11.082031 0 3.058594 3.0625 3.058594 8.023437 0 11.082031l-20.089844 20.085937c-1.527344 1.53125-3.535156 2.296875-5.539062 2.296875zm0 0" style="fill: rgb(59, 233, 100);"/>
-      <path d="m340.339844 101.507812c-2.007813 0-4.011719-.765624-5.542969-2.296874-3.058594-3.058594-3.058594-8.023438 0-11.082032l20.089844-20.085937c3.0625-3.0625 8.023437-3.0625 11.082031 0 3.058594 3.058593 3.0625 8.023437 0 11.082031l-20.089844 20.085938c-1.527344 1.53125-3.535156 2.296874-5.539062 2.296874zm0 0" style="fill: rgb(59, 233, 100);"/>
-      <path d="m366.089844 115.929688c-2.003906 0-4.011719-.761719-5.539063-2.292969-3.0625-3.0625-3.0625-8.023438 0-11.082031l20.085938-20.089844c3.0625-3.058594 8.023437-3.058594 11.082031 0 3.0625 3.0625 3.0625 8.023437 0 11.082031l-20.085938 20.089844c-1.53125 1.53125-3.535156 2.292969-5.542968 2.292969zm0 0" style="fill: rgb(59, 233, 100);"/>
-    </g>
-    <path d="M 401.925 247.748 C 401.761 247.748 401.611 247.629 401.573 247.469 C 401.536 247.312 401.611 247.144 401.753 247.067 C 402 246.933 402.318 247.147 402.286 247.426 C 402.265 247.606 402.107 247.748 401.925 247.748 Z M 401.925 247.748" fill="#1e2628" style=""/>
-  </g>
-</svg>

gradle.properties

@@ -8,29 +8,21 @@
 
 # suppress inspection "UnusedProperty" for whole file
 
-#ideaVersion=LATEST-EAP-SNAPSHOT
-ideaVersion=2023.3.3
-# Values for type: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#intellij-extension-type
-ideaType=IC
+ideaVersion=2023.2
 downloadIdeaSources=true
 instrumentPluginCode=true
-version=chylex-30
+version=chylex-20
 javaVersion=17
-remoteRobotVersion=0.11.22
+remoteRobotVersion=0.11.17
 antlrVersion=4.10.1
 
 kotlin.incremental.useClasspathSnapshot=false
 
 # Please don't forget to update kotlin version in buildscript section
-# Also update kotlinxSerializationVersion version
-kotlinVersion=1.9.22
+kotlinVersion=1.8.21
 publishToken=token
 publishChannels=eap
 
-# Kotlinx serialization also uses some version of kotlin stdlib under the hood. However,
-#   we exclude this version from the dependency and use our own version of kotlin that is specified above
-kotlinxSerializationVersion=1.6.2
-
 slackUrl=
 youtrackToken=
 
@@ -42,4 +34,3 @@ kotlin.stdlib.default.dependency=false
 
 # Disable incremental annotation processing
 ksp.incremental=false
-

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
 networkTimeout=10000
-validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -130,13 +130,10 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
-    fi
 fi
 
 # Increase the maximum file descriptors if we can.

qodana.yaml

@@ -21,9 +21,6 @@ exclude:
       - src/test/java/org/jetbrains/plugins/ideavim/propertybased/samples/SimpleText.kt
       - src/main/java/com/maddyhome/idea/vim/vimscript/parser/generated
       - src/main/java/com/maddyhome/idea/vim/package-info.java
-      - vim-engine/src/main/java/com/maddyhome/idea/vim/regexp/parser/generated
-      - src/main/java/com/maddyhome/idea/vim/group/SearchGroup.java
-      - tests/ui-fixtures
 dependencyIgnores:
   - name: "acejump"
   - name: "icu4j"

scripts/build.gradle.kts

@@ -20,17 +20,17 @@ repositories {
 }
 
 dependencies {
-  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:1.9.23")
+  compileOnly("org.jetbrains.kotlin:kotlin-stdlib:1.9.20")
 
-  implementation("io.ktor:ktor-client-core:2.3.9")
-  implementation("io.ktor:ktor-client-cio:2.3.9")
-  implementation("io.ktor:ktor-client-content-negotiation:2.3.9")
-  implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.9")
-  implementation("io.ktor:ktor-client-auth:2.3.9")
+  implementation("io.ktor:ktor-client-core:2.3.6")
+  implementation("io.ktor:ktor-client-cio:2.3.5")
+  implementation("io.ktor:ktor-client-content-negotiation:2.3.6")
+  implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.6")
+  implementation("io.ktor:ktor-client-auth:2.3.6")
   implementation("org.eclipse.jgit:org.eclipse.jgit:6.6.0.202305301015-r")
 
   // This is needed for jgit to connect to ssh
-  implementation("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:6.9.0.202403050737-r")
+  implementation("org.eclipse.jgit:org.eclipse.jgit.ssh.apache:6.7.0.202309050840-r")
   implementation("com.vdurmont:semver4j:3.1.0")
 }
 
@@ -93,16 +93,28 @@ tasks.register("addReleaseTag", JavaExec::class) {
   args = listOf(project.version.toString(), rootProject.rootDir.toString(), releaseType ?: "")
 }
 
-tasks.register("selectBranch", JavaExec::class) {
+tasks.register("resetReleaseBranch", JavaExec::class) {
   group = "release"
-  mainClass.set("scripts.release.SelectBranchKt")
+  mainClass.set("scripts.release.ResetReleaseBranchKt")
   classpath = sourceSets["main"].runtimeClasspath
   args = listOf(project.version.toString(), rootProject.rootDir.toString(), releaseType ?: "")
 }
 
-tasks.register("eapReleaseActions", JavaExec::class) {
+tasks.register("pushChanges", JavaExec::class) {
+  mainClass.set("scripts.PushChangesKt")
+  classpath = sourceSets["main"].runtimeClasspath
+  args = listOf(rootProject.rootDir.toString())
+}
+
+tasks.register("pushChangesWithReleaseBranch", JavaExec::class) {
+  mainClass.set("scripts.PushChangesWithReleaseBranchKt")
+  classpath = sourceSets["main"].runtimeClasspath
+  args = listOf(rootProject.rootDir.toString(), releaseType ?: "")
+}
+
+tasks.register("selectBranch", JavaExec::class) {
   group = "release"
-  mainClass.set("scripts.releaseEap.EapReleaseActionsKt")
+  mainClass.set("scripts.release.SelectBranchKt")
   classpath = sourceSets["main"].runtimeClasspath
   args = listOf(project.version.toString(), rootProject.rootDir.toString(), releaseType ?: "")
 }

scripts/src/main/kotlin/scripts/checkNewPluginDependencies.kt

@@ -22,7 +22,7 @@ import kotlinx.serialization.json.jsonPrimitive
  */
 
 @Suppress("SpellCheckingInspection")
-val knownPlugins = setOf(
+val knownPlugins = listOf(
   "IdeaVimExtension",
   "github.zgqq.intellij-enhance",
   "org.jetbrains.IdeaVim-EasyMotion",
@@ -31,13 +31,7 @@ val knownPlugins = setOf(
   "com.github.copilot",
   "com.github.dankinsoid.multicursor",
   "com.joshestein.ideavim-quickscope",
-
   "ca.alexgirard.HarpoonIJ",
-  "me.kyren223.harpoonforjb", // https://plugins.jetbrains.com/plugin/23771-harpoonforjb
-  "com.github.erotourtes.harpoon", // https://plugins.jetbrains.com/plugin/21796-harpooner
-  "me.kyren223.trident", // https://plugins.jetbrains.com/plugin/23818-trident
-
-  "com.protoseo.input-source-auto-converter",
 
 //   "cc.implicated.intellij.plugins.bunny", // I don't want to include this plugin in the list of IdeaVim plugins as I don't understand what this is for
 )
@@ -47,7 +41,7 @@ suspend fun main() {
     parameter("dependency", "IdeaVIM")
     parameter("includeOptional", true)
   }
-  val output = response.body<List<String>>().toSet()
+  val output = response.body<List<String>>()
   println(output)
   if (knownPlugins != output) {
     val newPlugins = (output - knownPlugins).map { it to (getPluginLinkByXmlId(it) ?: "Can't find plugin link") }

scripts/src/main/kotlin/scripts/ktor.kt

@@ -32,7 +32,7 @@ fun httpClient(): HttpClient {
     install(Auth) {
       bearer {
         loadTokens {
-          val accessToken = System.getenv("YOUTRACK_TOKEN") ?: error("Missing YOUTRACK_TOKEN")
+          val accessToken = System.getenv("YOUTRACK_TOKEN")!!
           BearerTokens(accessToken, "")
         }
       }

scripts/src/main/kotlin/scripts/pushChanges.kt

@@ -0,0 +1,37 @@
+/*
+ * 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 scripts
+
+import scripts.release.checkoutBranch
+import scripts.release.withGit
+import scripts.release.withRepo
+
+fun main(args: Array<String>) {
+  val rootDir = args[0]
+  println("root dir: $rootDir")
+
+  val currentBranch = withRepo(rootDir) { it.branch }
+  println("Current branch is $currentBranch")
+
+
+  withGit(rootDir) { git ->
+    if (currentBranch != "master") {
+      git.checkoutBranch("master")
+      println("Check out master branch")
+    }
+
+    git.push()
+      .setPushTags()
+      .call()
+    println("Master pushed with tags")
+
+    git.checkoutBranch(currentBranch)
+    println("Checked out $currentBranch branch")
+  }
+}

scripts/src/main/kotlin/scripts/pushChangesWithReleaseBranch.kt

@@ -0,0 +1,54 @@
+/*
+ * 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 scripts
+
+import scripts.release.checkoutBranch
+import scripts.release.withGit
+import scripts.release.withRepo
+
+fun main(args: Array<String>) {
+  val rootDir = args[0]
+  val releaseType = args[1]
+  println("root dir: $rootDir")
+  println("releaseType: $releaseType")
+
+  val currentBranch = withRepo(rootDir) { it.branch }
+  println("Current branch is $currentBranch")
+
+
+  withGit(rootDir) { git ->
+    if (currentBranch != "master") {
+      git.checkoutBranch("master")
+      println("Check out master branch")
+    }
+
+    git.push()
+      .setPushTags()
+      .call()
+    println("Master pushed with tags")
+
+    if (releaseType != "patch") {
+      git.checkoutBranch("release")
+      println("Checked out release")
+
+      git
+        .push()
+        .setForce(true)
+        .setPushTags()
+        .call()
+      println("Pushed release branch with tags")
+    }
+    else {
+      println("Do not push release branch because type of release is $releaseType")
+    }
+
+    git.checkoutBranch(currentBranch)
+    println("Checked out $currentBranch branch")
+  }
+}

scripts/src/main/kotlin/scripts/release/calculateNewDevVersion.kt

@@ -8,29 +8,21 @@
 
 package scripts.release
 
-import org.eclipse.jgit.lib.ObjectId
-import org.eclipse.jgit.revwalk.RevCommit
-import org.eclipse.jgit.revwalk.RevWalk
-import org.eclipse.jgit.revwalk.filter.RevFilter
-
-
 fun main(args: Array<String>) {
   println("HI!")
   val projectDir = args[0]
   println("Working directory: $projectDir")
-  val (lastVersion, objectId) = getVersion(projectDir, ReleaseType.STABLE_NO_PATCH)
+  val (lastVersion, objectId) = getVersion(projectDir, onlyStable = true)
   println("Last version: $lastVersion, hash: ${objectId.name}")
 
   val branch = withRepo(projectDir) { it.branch }
   check(branch == "master") {
     "We should be on master branch"
   }
-  val mergeBaseCommit = getMergeBaseWithMaster(projectDir, objectId)
-  println("Base commit $mergeBaseCommit")
   withGit(projectDir) { git ->
     val log = git.log().setMaxCount(500).call().toList()
     println("First commit hash in log: " + log.first().name + " log size: ${log.size}")
-    val logDiff = log.takeWhile { it.id.name != mergeBaseCommit }
+    val logDiff = log.takeWhile { it.id.name != objectId.name }
     val numCommits = logDiff.size
     println("Log diff size is $numCommits")
     check(numCommits < 450) {
@@ -43,18 +35,3 @@ fun main(args: Array<String>) {
     println("##teamcity[setParameter name='env.ORG_GRADLE_PROJECT_version' value='$nextVersion']")
   }
 }
-
-private fun getMergeBaseWithMaster(projectDir: String, tag: ObjectId): String {
-  withRepo(projectDir) { repo ->
-    val master = repo.resolve("master")
-    RevWalk(repo).use { walk ->
-      val tagRevCommit = walk.parseCommit(tag)
-      val masterRevCommit = walk.parseCommit(master)
-      walk.setRevFilter(RevFilter.MERGE_BASE)
-      walk.markStart(tagRevCommit)
-      walk.markStart(masterRevCommit)
-      val mergeBase: RevCommit = walk.next()
-      return mergeBase.name
-    }
-  }
-}

scripts/src/main/kotlin/scripts/release/calculateNewEapVersion.kt

@@ -12,7 +12,7 @@ fun main(args: Array<String>) {
   println("HI!")
   val projectDir = args[0]
   println("Working directory: $projectDir")
-  val (lastVersion, _) = getVersion(projectDir, ReleaseType.ANY)
+  val (lastVersion, _) = getVersion(projectDir, onlyStable = false)
 
   val nextVersion = if (lastVersion.suffixTokens.isEmpty()) {
     lastVersion.nextMinor().withSuffix("eap.1").value

scripts/src/main/kotlin/scripts/release/calculateNewVersion.kt

@@ -14,7 +14,7 @@ fun main(args: Array<String>) {
   val releaseType = args[1]
   println("Working directory: $projectDir")
   println("Release type: $releaseType")
-  val (lastVersion, _) = getVersion(projectDir, ReleaseType.ONLY_STABLE)
+  val (lastVersion, _) = getVersion(projectDir, onlyStable = true)
 
   val nextVersion = when (releaseType) {
     "major" -> lastVersion.nextMajor()

scripts/src/main/kotlin/scripts/release/changelogUpdateUnreleased.kt

@@ -8,45 +8,28 @@
 
 package scripts.release
 
-import com.vdurmont.semver4j.Semver
 import java.time.LocalDate
 import java.time.format.DateTimeFormatter
 import kotlin.io.path.Path
 import kotlin.io.path.readText
 import kotlin.io.path.writeText
 
-private const val toBeReleased = "## To Be Released"
-
 fun main(args: Array<String>) {
   println("Start updating unreleased section")
   val (newVersion, rootDir, releaseType) = readArgs(args)
 
   checkReleaseType(releaseType)
 
+  if (releaseType == "patch") {
+    println("Skip updating the changelog because release type is 'patch'")
+    return
+  }
+
   val currentDate = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE)
   val newItem = "## $newVersion, $currentDate"
 
   val changelogPath = Path("$rootDir/CHANGES.md")
   val changelog = changelogPath.readText()
-  val newChangelog = if (releaseType == "patch") {
-    val decreasedVersion = Semver(newVersion).withIncPatch(-1)
-    val firstEntry = changelog.indexOf("## $decreasedVersion")
-    if (firstEntry != -1) {
-      val newLog = StringBuilder(changelog)
-      newLog.insert(firstEntry, newItem + "\n")
-      newLog.toString()
-    } else {
-      changelog
-    }
-  } else {
-    if (toBeReleased in changelog) {
-      changelog.replace(toBeReleased, newItem)
-    } else {
-      val firstEntry = changelog.indexOf("##")
-      val newLog = StringBuilder(changelog)
-      newLog.insert(firstEntry, newItem + "\n")
-      newLog.toString()
-    }
-  }
+  val newChangelog = changelog.replace("## To Be Released", newItem)
   changelogPath.writeText(newChangelog)
 }

scripts/src/main/kotlin/scripts/release/commitChanges.kt

@@ -13,20 +13,21 @@ fun main(args: Array<String>) {
 
   checkReleaseType(releaseType)
 
-  withGit(rootDir) { git ->
-    if (git.diff().call().isNotEmpty()) {
-      git
-        .commit()
-        .setAll(true)
-        .setAuthor("IdeaVim Bot", "maintainers@ideavim.dev")
-        .setMessage("Preparation to $newVersion release")
-        .setSign(false)
-        .call()
+  if (releaseType == "patch") {
+    println("Skip committing changes because release type is 'patch'")
+    return
+  }
 
-      val lastGitMessage = git.log().call().first().shortMessage
-      println("Changes committed. Last gitlog message: $lastGitMessage")
-    } else {
-      println("No Changes")
-    }
+  withGit(rootDir) { git ->
+    git
+      .commit()
+      .setAll(true)
+      .setAuthor("IdeaVim Bot", "maintainers@ideavim.dev")
+      .setMessage("Preparation to $newVersion release")
+      .setSign(false)
+      .call()
+
+    val lastGitMessage = git.log().call().first().shortMessage
+    println("Changes committed. Last gitlog message: $lastGitMessage")
   }
 }

scripts/src/main/kotlin/scripts/release/resetReleaseBranch.kt

@@ -0,0 +1,38 @@
+/*
+ * 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 scripts.release
+
+fun main(args: Array<String>) {
+  val (_, rootDir, releaseType) = readArgs(args)
+
+  checkReleaseType(releaseType)
+
+  checkBranch(rootDir, releaseType)
+
+  if (releaseType == "patch") {
+    println("Skip release branch reset because release type is 'patch'")
+    return
+  }
+
+  withGit(rootDir) { git ->
+    val currentCommit = git.log().setMaxCount(1).call().first()
+    println("Current commit id: ${currentCommit.id.name}")
+
+    git.checkoutBranch("release")
+    println("Checked out release branch")
+
+    git.reset()
+      .setRef(currentCommit.id.name)
+      .call()
+    println("release branch reset")
+
+    git.checkoutBranch("master")
+    println("Checked out master branch")
+  }
+}

scripts/src/main/kotlin/scripts/release/selectBranch.kt

@@ -15,7 +15,8 @@ fun main(args: Array<String>) {
 
   withGit(rootDir) { git ->
     val branchName = when (releaseType) {
-      "major", "minor", "patch" -> "release"
+      "major", "minor" -> "master"
+      "patch" -> "release"
       else -> error("Unsupported release type: $releaseType")
     }
 

scripts/src/main/kotlin/scripts/release/util.kt

@@ -58,13 +58,7 @@ internal fun checkBranch(rootDir: String, releaseType: String) {
   }
 }
 
-enum class ReleaseType {
-  ANY,
-  ONLY_STABLE,
-  STABLE_NO_PATCH, // Version that ends on 0. Like 2.5.0
-}
-
-internal fun getVersion(projectDir: String, releaseType: ReleaseType): Pair<Semver, ObjectId> {
+internal fun getVersion(projectDir: String, onlyStable: Boolean): Pair<Semver, ObjectId> {
   val repository = RepositoryBuilder().setGitDir(File("$projectDir/.git")).build()
   val git = Git(repository)
   println(git.log().call().first())
@@ -81,10 +75,10 @@ internal fun getVersion(projectDir: String, releaseType: ReleaseType): Pair<Semv
   }
     .sortedBy { it.first }
 
-  val version = when (releaseType) {
-    ReleaseType.ANY -> versions.last()
-    ReleaseType.ONLY_STABLE -> versions.last { it.first.isStable }
-    ReleaseType.STABLE_NO_PATCH -> versions.last { it.first.isStable && it.first.patch == 0 }
+  val version = if (onlyStable) {
+    versions.last { it.first.isStable }
+  } else {
+    versions.last()
   }
 
   return version

scripts/src/main/kotlin/scripts/releaseEap/eapReleaseActions.kt

@@ -1,36 +0,0 @@
-/*
- * Copyright 2003-2024 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 scripts.releaseEap
-
-import kotlinx.coroutines.runBlocking
-import scripts.addComment
-import scripts.getYoutrackTicketsByQuery
-import scripts.release.readArgs
-import scripts.releasedInEapTagId
-import scripts.setTag
-
-fun main(args: Array<String>) {
-  runBlocking {
-    val (newVersion, _, _) = readArgs(args)
-
-    // Search for Ready to release, but without "IdeaVim Released In EAP" tag
-    val ticketsToUpdate =
-      getYoutrackTicketsByQuery("%23%7BReady%20To%20Release%7D%20tag:%20-%7BIdeaVim%20Released%20In%20EAP%7D%20")
-    println("Have to update the following tickets: $ticketsToUpdate")
-
-    ticketsToUpdate.forEach { ticketId ->
-      setTag(ticketId, releasedInEapTagId)
-      addComment(
-        ticketId, """
-        The fix is available in the IdeaVim $newVersion. See https://jb.gg/ideavim-eap for the instructions on how to get EAP builds as updates within the IDE. You can also wait till the next stable release with this fix, you’ll get it automatically.
-      """.trimIndent()
-      )
-    }
-  }
-}

scripts/src/main/kotlin/scripts/youtrack.kt

@@ -11,8 +11,6 @@ package scripts
 import io.ktor.client.call.*
 import io.ktor.client.request.*
 import io.ktor.http.*
-import kotlinx.coroutines.runBlocking
-import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.json.addJsonObject
 import kotlinx.serialization.json.buildJsonObject
@@ -23,10 +21,6 @@ import kotlinx.serialization.json.put
 import kotlinx.serialization.json.putJsonArray
 import kotlinx.serialization.json.putJsonObject
 
-
-// YouTrack tag "IdeaVim Released In EAP"
-const val releasedInEapTagId = "68-385032"
-
 suspend fun setYoutrackStatus(tickets: Collection<String>, status: String) {
   val client = httpClient()
 
@@ -65,59 +59,3 @@ suspend fun setYoutrackStatus(tickets: Collection<String>, status: String) {
     }
   }
 }
-
-fun getYoutrackTicketsByQuery(query: String): Set<String> {
-  val client = httpClient()
-
-  return runBlocking {
-    val response = client.get("https://youtrack.jetbrains.com/api/issues/?fields=idReadable&query=project:VIM+$query")
-    response.body<JsonArray>().mapTo(HashSet()) { it.jsonObject.getValue("idReadable").jsonPrimitive.content }
-  }
-}
-
-/**
- * 68-385032
- * [issueHumanId] is like VIM-123
- * [tagId] is like "145-23"
- */
-suspend fun setTag(issueHumanId: String, tagId: String) {
-  val client = httpClient()
-
-  println("Try to add tag $tagId to $issueHumanId")
-  val response =
-    // I've updated default url in client, so this may be broken now
-    client.post("https://youtrack.jetbrains.com/api/issues/$issueHumanId/tags?fields=customFields(id,name,value(id,name))") {
-      contentType(ContentType.Application.Json)
-      accept(ContentType.Application.Json)
-      val request = buildJsonObject {
-        put("id", tagId)
-      }
-      setBody(request)
-    }
-  println(response)
-  println(response.body<String>())
-  if (!response.status.isSuccess()) {
-    error("Request failed. $issueHumanId, ${response.body<String>()}")
-  }
-}
-
-suspend fun addComment(issueHumanId: String, text: String) {
-  val client = httpClient()
-
-  println("Try to add comment to $issueHumanId")
-  val response =
-    // I've updated default url in client, so this may be broken now
-    client.post("https://youtrack.jetbrains.com/api/issues/$issueHumanId/comments?fields=customFields(id,name,value(id,name))") {
-      contentType(ContentType.Application.Json)
-      accept(ContentType.Application.Json)
-      val request = buildJsonObject {
-        put("text", text)
-      }
-      setBody(request)
-    }
-  println(response)
-  println(response.body<String>())
-  if (!response.status.isSuccess()) {
-    error("Request failed. $issueHumanId, ${response.body<String>()}")
-  }
-}

settings.gradle

@@ -12,9 +12,4 @@ rootProject.name = 'IdeaVIM'
 include 'vim-engine'
 include 'scripts'
 include 'annotation-processors'
-include 'tests:java-tests'
-include 'tests:property-tests'
-include 'tests:long-running-tests'
-include 'tests:ui-ij-tests'
-include 'tests:ui-py-tests'
-include 'tests:ui-fixtures'
+

src/main/java/com/maddyhome/idea/vim/EventFacade.java

@@ -11,6 +11,7 @@ package com.maddyhome.idea.vim;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.actionSystem.AnAction;
 import com.intellij.openapi.actionSystem.ShortcutSet;
+import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.editor.actionSystem.TypedAction;
@@ -79,6 +80,14 @@ public class EventFacade {
     action.unregisterCustomShortcutSet(component);
   }
 
+  public void addDocumentListener(@NotNull Document document, @NotNull DocumentListener listener) {
+    document.addDocumentListener(listener);
+  }
+
+  public void removeDocumentListener(@NotNull Document document, @NotNull DocumentListener listener) {
+    document.removeDocumentListener(listener);
+  }
+
   public void addEditorFactoryListener(@NotNull EditorFactoryListener listener, @NotNull Disposable parentDisposable) {
     EditorFactory.getInstance().addEditorFactoryListener(listener, parentDisposable);
   }
@@ -89,12 +98,20 @@ public class EventFacade {
     editor.getCaretModel().addCaretListener(listener, disposable);
   }
 
+  public void removeCaretListener(@NotNull Editor editor, @NotNull CaretListener listener) {
+    editor.getCaretModel().removeCaretListener(listener);
+  }
+
   public void addEditorMouseListener(@NotNull Editor editor,
                                      @NotNull EditorMouseListener listener,
                                      @NotNull Disposable disposable) {
     editor.addEditorMouseListener(listener, disposable);
   }
 
+  public void removeEditorMouseListener(@NotNull Editor editor, @NotNull EditorMouseListener listener) {
+    editor.removeEditorMouseListener(listener);
+  }
+
   public void addComponentMouseListener(@NotNull Component component,
                                         @NotNull MouseListener mouseListener,
                                         @NotNull Disposable disposable) {
@@ -102,18 +119,30 @@ public class EventFacade {
     Disposer.register(disposable, () -> component.removeMouseListener(mouseListener));
   }
 
+  public void removeComponentMouseListener(@NotNull Component component, @NotNull MouseListener mouseListener) {
+    component.removeMouseListener(mouseListener);
+  }
+
   public void addEditorMouseMotionListener(@NotNull Editor editor,
                                            @NotNull EditorMouseMotionListener listener,
                                            @NotNull Disposable disposable) {
     editor.addEditorMouseMotionListener(listener, disposable);
   }
 
+  public void removeEditorMouseMotionListener(@NotNull Editor editor, @NotNull EditorMouseMotionListener listener) {
+    editor.removeEditorMouseMotionListener(listener);
+  }
+
   public void addEditorSelectionListener(@NotNull Editor editor,
                                          @NotNull SelectionListener listener,
                                          @NotNull Disposable disposable) {
     editor.getSelectionModel().addSelectionListener(listener, disposable);
   }
 
+  public void removeEditorSelectionListener(@NotNull Editor editor, @NotNull SelectionListener listener) {
+    editor.getSelectionModel().removeSelectionListener(listener);
+  }
+
   private @NotNull TypedAction getTypedAction() {
     return TypedAction.getInstance();
   }

src/main/java/com/maddyhome/idea/vim/PluginStartup.kt

@@ -11,20 +11,25 @@ package com.maddyhome.idea.vim
 import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.ProjectManagerListener
-import com.intellij.openapi.startup.ProjectActivity
+import com.intellij.openapi.startup.StartupActivity
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.helper.EditorHelper
-import com.maddyhome.idea.vim.newapi.IjVimEditor
+import com.maddyhome.idea.vim.helper.localEditors
 import com.maddyhome.idea.vim.newapi.globalIjOptions
 
 /**
  * @author Alex Plate
  */
-internal class PluginStartup : ProjectActivity/*, LightEditCompatible*/ {
+// This service should be migrated to ProjectActivity. But we should cariful because simple replacement
+// leads to deadlock in tests. I'm not sure about the exact reasons, but "invokeAndWait" inside "initialize" function
+// causes this deadlock. Good new: it's easy reproducible in tests.
+// Previous migration: fc7efd5484a13b40ba9bf86a1d5429e215d973f3
+// Revert: 24dd84b31cffb99eb6114524859a46d02717d33f
+internal class PluginStartup : StartupActivity.DumbAware/*, LightEditCompatible*/ {
 
   private var firstInitializationOccurred = false
 
-  override suspend fun execute(project: Project) {
+  override fun runActivity(project: Project) {
     if (firstInitializationOccurred) return
     firstInitializationOccurred = true
 
@@ -36,10 +41,8 @@ internal class PluginStartup : ProjectActivity/*, LightEditCompatible*/ {
 // This is a temporal workaround for VIM-2487
 internal class PyNotebooksCloseWorkaround : ProjectManagerListener {
   override fun projectClosingBeforeSave(project: Project) {
-    // TODO: Confirm context in CWM scenario
     if (injector.globalIjOptions().closenotebooks) {
-      injector.editorGroup.getEditors().forEach { vimEditor ->
-        val editor = (vimEditor as IjVimEditor).editor
+      localEditors().forEach { editor ->
         val virtualFile = EditorHelper.getVirtualFile(editor)
         if (virtualFile?.extension == "ipynb") {
           val fileEditorManager = FileEditorManagerEx.getInstanceEx(project)

src/main/java/com/maddyhome/idea/vim/RegisterActions.kt

@@ -7,27 +7,56 @@
  */
 package com.maddyhome.idea.vim
 
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.extensions.ExtensionPointName
 import com.maddyhome.idea.vim.action.EngineCommandProvider
 import com.maddyhome.idea.vim.action.IntellijCommandProvider
+import com.maddyhome.idea.vim.api.injector
+import com.maddyhome.idea.vim.handler.ActionBeanClass
 import com.maddyhome.idea.vim.handler.EditorActionHandlerBase
 import com.maddyhome.idea.vim.key.MappingOwner
+import com.maddyhome.idea.vim.newapi.IjVimActionsInitiator
+import com.maddyhome.idea.vim.newapi.globalIjOptions
 import java.awt.event.KeyEvent
 import javax.swing.KeyStroke
 
 public object RegisterActions {
+  @Deprecated("Please use @CommandOrMotion annotation instead")
+  internal val VIM_ACTIONS_EP: ExtensionPointName<ActionBeanClass> = ExtensionPointName.create("IdeaVIM.vimAction")
+
   /**
    * Register all the key/action mappings for the plugin.
    */
   @JvmStatic
   public fun registerActions() {
     registerVimCommandActions()
-    registerShortcutsWithoutActions()
+    if (!injector.globalIjOptions().commandOrMotionAnnotation) {
+      registerEmptyShortcuts()
+      registerEpListener()
+    }
+  }
+
+  @Deprecated("Moving to annotations approach instead of xml")
+  private fun registerEpListener() {
+    // IdeaVim doesn't support contribution to VIM_ACTIONS_EP extension point, so technically we can skip this update,
+    //   but let's support dynamic plugins in a more classic way and reload actions on every EP change.
+    VIM_ACTIONS_EP.addChangeListener({
+      unregisterActions()
+      registerActions()
+    }, VimPlugin.getInstance())
   }
 
   public fun findAction(id: String): EditorActionHandlerBase? {
-    val commandBean = EngineCommandProvider.getCommands().firstOrNull { it.actionId == id }
-      ?: IntellijCommandProvider.getCommands().firstOrNull { it.actionId == id } ?: return null
-    return commandBean.instance
+    if (injector.globalIjOptions().commandOrMotionAnnotation) {
+      val commandBean = EngineCommandProvider.getCommands().firstOrNull { it.actionId == id }
+        ?: IntellijCommandProvider.getCommands().firstOrNull { it.actionId == id } ?: return null
+      return commandBean.instance
+    } else {
+      return VIM_ACTIONS_EP.getExtensionList(ApplicationManager.getApplication()).stream()
+        .filter { vimActionBean: ActionBeanClass -> vimActionBean.actionId == id }
+        .findFirst().map { obj: ActionBeanClass -> obj.instance }
+        .orElse(null)
+    }
   }
 
   public fun findActionOrDie(id: String): EditorActionHandlerBase {
@@ -42,15 +71,30 @@ public object RegisterActions {
 
   private fun registerVimCommandActions() {
     val parser = VimPlugin.getKey()
-    EngineCommandProvider.getCommands().forEach { parser.registerCommandAction(it) }
-    IntellijCommandProvider.getCommands().forEach { parser.registerCommandAction(it) }
+    if (injector.globalIjOptions().commandOrMotionAnnotation) {
+      EngineCommandProvider.getCommands().forEach { parser.registerCommandAction(it) }
+      IntellijCommandProvider.getCommands().forEach { parser.registerCommandAction(it) }
+    } else {
+      VIM_ACTIONS_EP.getExtensionList(ApplicationManager.getApplication()).stream().map { bean: ActionBeanClass? ->
+        IjVimActionsInitiator(
+          bean!!
+        )
+      }
+        .forEach { actionHolder: IjVimActionsInitiator? ->
+          parser.registerCommandAction(
+            actionHolder!!
+          )
+        }
+    }
   }
 
-  private fun registerShortcutsWithoutActions() {
+  // todo do we really need this?
+  private fun registerEmptyShortcuts() {
     val parser = VimPlugin.getKey()
 
     // The {char1} <BS> {char2} shortcut is handled directly by KeyHandler#handleKey, so doesn't have an action. But we
     // still need to register the shortcut, to make sure the editor doesn't swallow it.
-    parser.registerShortcutWithoutAction(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0), MappingOwner.IdeaVim.System)
+    parser
+      .registerShortcutWithoutAction(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0), MappingOwner.IdeaVim.System)
   }
 }

src/main/java/com/maddyhome/idea/vim/VimPlugin.java

@@ -39,9 +39,11 @@ import com.maddyhome.idea.vim.listener.VimListenerManager;
 import com.maddyhome.idea.vim.newapi.IjVimInjector;
 import com.maddyhome.idea.vim.ui.StatusBarIconFactory;
 import com.maddyhome.idea.vim.ui.ex.ExEntryPanel;
+import com.maddyhome.idea.vim.vimscript.services.OptionService;
 import com.maddyhome.idea.vim.vimscript.services.VariableService;
 import com.maddyhome.idea.vim.yank.YankGroupBase;
 import org.jdom.Element;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -115,6 +117,12 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     return ApplicationManager.getApplication().getService(CommandGroup.class);
   }
 
+  @Deprecated // "Please use `injector.markService` instead"
+  @ApiStatus.ScheduledForRemoval(inVersion = "2.3")
+  public static @NotNull MarkGroup getMark() {
+    return ApplicationManager.getApplication().getService(MarkGroup.class);
+  }
+
   public static @NotNull RegisterGroup getRegister() {
     return ((RegisterGroup)VimInjectorKt.getInjector().getRegisterGroup());
   }
@@ -187,6 +195,13 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     return VimInjectorKt.getInjector().getOptionGroup();
   }
 
+  /** Deprecated: Use getOptionGroup */
+  @Deprecated
+  // Used by which-key 0.8.0, IdeaVimExtension 1.6.5 + 1.6.8
+  public static @NotNull OptionService getOptionService() {
+    return VimInjectorKt.getInjector().getOptionService();
+  }
+
   private static @NotNull NotificationService getNotifications() {
     return getNotifications(null);
   }
@@ -204,30 +219,20 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     return getInstance().enabled;
   }
 
-  public static boolean isNotEnabled() {
-    return !isEnabled();
-  }
-
   public static void setEnabled(final boolean enabled) {
     if (isEnabled() == enabled) return;
 
-    getInstance().enabled = enabled;
-
-    if (enabled) {
-      VimInjectorKt.getInjector().getListenersNotifier().notifyPluginTurnedOn();
-    } else {
-      VimInjectorKt.getInjector().getListenersNotifier().notifyPluginTurnedOff();
-    }
-
     if (!enabled) {
       getInstance().turnOffPlugin(true);
     }
 
+    getInstance().enabled = enabled;
+
     if (enabled) {
       getInstance().turnOnPlugin();
     }
 
-    StatusBarIconFactory.Util.INSTANCE.updateIcon();
+    StatusBarIconFactory.Companion.updateIcon();
   }
 
   public static String getMessage() {
@@ -259,8 +264,7 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
     if (enabled) {
       Application application = ApplicationManager.getApplication();
       if (application.isUnitTestMode()) {
-        turnOnPlugin();
-        //application.invokeAndWait(this::turnOnPlugin);
+        application.invokeAndWait(this::turnOnPlugin);
       }
       else {
         application.invokeLater(this::turnOnPlugin);
@@ -353,7 +357,6 @@ public class VimPlugin implements PersistentStateComponent<Element>, Disposable
 
     if (onOffDisposable != null) {
       Disposer.dispose(onOffDisposable);
-      onOffDisposable = null;
     }
   }
 

src/main/java/com/maddyhome/idea/vim/VimProjectService.kt

@@ -14,7 +14,7 @@ import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.maddyhome.idea.vim.group.EditorHolderService
 
-@Service(Service.Level.PROJECT)
+@Service
 internal class VimProjectService(val project: Project) : Disposable {
   override fun dispose() {
     // Not sure if this is a best solution

src/main/java/com/maddyhome/idea/vim/VimTypedActionHandler.kt

@@ -28,11 +28,8 @@ import javax.swing.KeyStroke
  * Accepts all regular keystrokes and passes them on to the Vim key handler.
  *
  * IDE shortcut keys used by Vim commands are handled by [com.maddyhome.idea.vim.action.VimShortcutKeyAction].
- *
- * This class is used in Which-Key plugin, so don't make it internal. Generally, we should provide a proper
- *   way to get ideavim keys for this plugin. See VIM-3085
  */
-public class VimTypedActionHandler(origHandler: TypedActionHandler) : TypedActionHandlerEx {
+internal class VimTypedActionHandler(origHandler: TypedActionHandler) : TypedActionHandlerEx {
   private val handler = KeyHandler.getInstance()
   private val traceTime = injector.globalOptions().ideatracetime
 
@@ -77,7 +74,7 @@ public class VimTypedActionHandler(origHandler: TypedActionHandler) : TypedActio
       val modifiers = if (charTyped == ' ' && VimKeyListener.isSpaceShift) KeyEvent.SHIFT_DOWN_MASK else 0
       val keyStroke = KeyStroke.getKeyStroke(charTyped, modifiers)
       val startTime = if (traceTime) System.currentTimeMillis() else null
-      handler.handleKey(editor.vim, keyStroke, injector.executionContextManager.onEditor(editor.vim, context.vim), handler.keyHandlerState)
+      handler.handleKey(editor.vim, keyStroke, injector.executionContextManager.onEditor(editor.vim, context.vim))
       if (startTime != null) {
         val duration = System.currentTimeMillis() - startTime
         LOG.info("VimTypedAction '$charTyped': $duration ms")
@@ -89,7 +86,7 @@ public class VimTypedActionHandler(origHandler: TypedActionHandler) : TypedActio
     }
   }
 
-  internal companion object {
+  companion object {
     private val LOG = logger<VimTypedActionHandler>()
   }
 }

src/main/java/com/maddyhome/idea/vim/action/VimActionConfigurationCustomizer.kt

@@ -0,0 +1,74 @@
+/*
+ * 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
+
+import com.intellij.codeInsight.hint.HintManagerImpl
+import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.ActionUpdateThread
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.actionSystem.PerformWithDocumentsCommitted
+import com.intellij.openapi.actionSystem.PopupAction
+import com.intellij.openapi.actionSystem.impl.ActionConfigurationCustomizer
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.EditorMouseHoverPopupManager
+import com.intellij.openapi.editor.event.EditorMouseEvent
+import com.intellij.openapi.editor.event.EditorMouseEventArea
+import com.intellij.openapi.project.DumbAware
+import java.awt.event.MouseEvent
+
+// [VERSION UPDATE] 233+ Remove class
+// The ShowHoverInfo action is built into the platform (using a nicer EditorMouseHoverPopupManager API)
+public class VimActionConfigurationCustomizer : ActionConfigurationCustomizer {
+  public override fun customize(actionManager: ActionManager) {
+    // If the ShowHoverInfo action doesn't exist in the platform, add our own implementation
+    if (actionManager.getAction("ShowHoverInfo") == null) {
+      actionManager.registerAction("ShowHoverInfo", VimShowHoverInfoAction())
+    }
+  }
+
+  private class VimShowHoverInfoAction : AnAction(), HintManagerImpl.ActionToIgnore, PopupAction, DumbAware,
+    PerformWithDocumentsCommitted {
+    override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.BGT
+
+    override fun update(e: AnActionEvent) {
+      val dataContext = e.dataContext
+      val editor = CommonDataKeys.EDITOR.getData(dataContext)
+      if (editor == null) {
+        e.presentation.isEnabledAndVisible = false
+      }
+    }
+
+    override fun actionPerformed(e: AnActionEvent) {
+      val editor = CommonDataKeys.EDITOR.getData(e.dataContext) ?: return
+
+      val editorMouseEvent = createFakeEditorMouseEvent(editor)
+      EditorMouseHoverPopupManager.getInstance().showInfoTooltip(editorMouseEvent)
+    }
+
+    private fun createFakeEditorMouseEvent(editor: Editor): EditorMouseEvent {
+      val xy = editor.offsetToXY(editor.caretModel.offset)
+      val mouseEvent =
+        MouseEvent(editor.component, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, xy.x, xy.y, 0, false)
+      val editorMouseEvent = EditorMouseEvent(
+        editor,
+        mouseEvent,
+        EditorMouseEventArea.EDITING_AREA,
+        editor.caretModel.offset,
+        editor.caretModel.logicalPosition,
+        editor.caretModel.visualPosition,
+        true,
+        null,
+        null,
+        null
+      )
+      return editorMouseEvent
+    }
+  }
+}

src/main/java/com/maddyhome/idea/vim/action/VimShortcutKeyAction.kt

@@ -14,10 +14,14 @@ import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.AnActionWrapper
+import com.intellij.openapi.actionSystem.IdeActions
+import com.intellij.openapi.actionSystem.KeyboardShortcut
 import com.intellij.openapi.actionSystem.PlatformDataKeys
 import com.intellij.openapi.application.invokeLater
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.actionSystem.EditorActionManager
+import com.intellij.openapi.keymap.KeymapManager
 import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.DumbAware
 import com.intellij.openapi.util.Key
@@ -28,7 +32,6 @@ import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.group.IjOptionConstants
 import com.maddyhome.idea.vim.group.IjOptions
-import com.maddyhome.idea.vim.handler.enableOctopus
 import com.maddyhome.idea.vim.handler.isOctopusEnabled
 import com.maddyhome.idea.vim.helper.EditorHelper
 import com.maddyhome.idea.vim.helper.HandlerInjector
@@ -44,6 +47,7 @@ import com.maddyhome.idea.vim.listener.AceJumpService
 import com.maddyhome.idea.vim.listener.AppCodeTemplates.appCodeTemplateCaptured
 import com.maddyhome.idea.vim.newapi.globalIjOptions
 import com.maddyhome.idea.vim.newapi.vim
+import com.maddyhome.idea.vim.state.mode.mode
 import com.maddyhome.idea.vim.vimscript.model.datatypes.VimString
 import java.awt.event.InputEvent
 import java.awt.event.KeyEvent
@@ -54,17 +58,9 @@ import javax.swing.KeyStroke
  *
  *
  * These keys are not passed to [com.maddyhome.idea.vim.VimTypedActionHandler] and should be handled by actions.
- *
- * This class is used in Which-Key plugin, so don't make it internal. Generally, we should provide a proper
- *   way to get ideavim keys for this plugin. See VIM-3085
  */
-public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
-  private val traceTime: Boolean
-    get() {
-      // Make sure the injector is initialized
-      VimPlugin.getInstance()
-      return injector.globalOptions().ideatracetime
-    }
+internal class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible*/ {
+  private val traceTime = injector.globalOptions().ideatracetime
 
   override fun actionPerformed(e: AnActionEvent) {
     LOG.trace("Executing shortcut key action")
@@ -78,12 +74,10 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
       // Should we use HelperKt.getTopLevelEditor(editor) here, as we did in former EditorKeyHandler?
       try {
         val start = if (traceTime) System.currentTimeMillis() else null
-        val keyHandler = KeyHandler.getInstance()
-        keyHandler.handleKey(
+        KeyHandler.getInstance().handleKey(
           editor.vim,
           keyStroke,
           injector.executionContextManager.onEditor(editor.vim, e.dataContext.vim),
-          keyHandler.keyHandlerState,
         )
         if (start != null) {
           val duration = System.currentTimeMillis() - start
@@ -100,7 +94,7 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
 
   // There is a chance that we can use BGT, but we call for isCell inside the update.
   // Not sure if can can use BGT with this call. Let's use EDT for now.
-  override fun getActionUpdateThread(): ActionUpdateThread = ActionUpdateThread.EDT
+  override fun getActionUpdateThread() = ActionUpdateThread.EDT
 
   override fun update(e: AnActionEvent) {
     val start = if (traceTime) System.currentTimeMillis() else null
@@ -115,16 +109,14 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
   }
 
   private fun isEnabled(e: AnActionEvent, keyStroke: KeyStroke?): ActionEnableStatus {
-    if (VimPlugin.isNotEnabled()) return ActionEnableStatus.no("IdeaVim is disabled", LogLevel.DEBUG)
+    if (!VimPlugin.isEnabled()) return ActionEnableStatus.no("IdeaVim is disabled", LogLevel.DEBUG)
     val editor = getEditor(e)
     if (editor != null && keyStroke != null) {
-      if (enableOctopus) {
-        if (isOctopusEnabled(keyStroke, editor)) {
-          return ActionEnableStatus.no(
-            "Processing VimShortcutKeyAction for the key that is used in the octopus handler",
-            LogLevel.ERROR
-          )
-        }
+      if (isOctopusEnabled(keyStroke, editor)) {
+        return ActionEnableStatus.no(
+          "Processing VimShortcutKeyAction for the key that is used in the octopus handler",
+          LogLevel.ERROR
+        )
       }
       if (editor.isIdeaVimDisabledHere) {
         return ActionEnableStatus.no("IdeaVim is disabled in this place", LogLevel.INFO)
@@ -171,6 +163,14 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
         return ActionEnableStatus.no("App code template is active", LogLevel.INFO)
       }
 
+      val nextTemplateVariableShortcuts = KeymapManager.getInstance().activeKeymap.getShortcuts(IdeActions.ACTION_EDITOR_NEXT_TEMPLATE_VARIABLE)
+      if (nextTemplateVariableShortcuts.any { it is KeyboardShortcut && it.firstKeyStroke == keyStroke }) {
+        val handler = EditorActionManager.getInstance().getActionHandler(IdeActions.ACTION_EDITOR_NEXT_TEMPLATE_VARIABLE)
+        if (handler.isEnabled(editor, null, e.dataContext)) {
+          return ActionEnableStatus.no("Next template variable or finish in-place refactoring", LogLevel.INFO)
+        }
+      }
+      
       if (editor.inInsertMode) {
         if (keyCode == KeyEvent.VK_TAB) {
           // TODO: This stops VimEditorTab seeing <Tab> in insert mode and correctly scrolling the view
@@ -236,9 +236,9 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
   /**
    * getDefaultKeyStroke is needed for NEO layout keyboard VIM-987
    * but we should cache the value because on the second call (isEnabled -> actionPerformed)
-   * the event is already consumed and getDefaultKeyStroke returns null
+   * the event is already consumed
    */
-  private var keyStrokeCache: Pair<Long?, KeyStroke?> = null to null
+  private var keyStrokeCache: Pair<KeyEvent?, KeyStroke?> = null to null
 
   private fun getKeyStroke(e: AnActionEvent): KeyStroke? {
     val inputEvent = e.inputEvent
@@ -246,9 +246,9 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
       val defaultKeyStroke = KeyStrokeAdapter.getDefaultKeyStroke(inputEvent)
       val strokeCache = keyStrokeCache
       if (defaultKeyStroke != null) {
-        keyStrokeCache = inputEvent.`when` to defaultKeyStroke
+        keyStrokeCache = inputEvent to defaultKeyStroke
         return defaultKeyStroke
-      } else if (strokeCache.first == inputEvent.`when`) {
+      } else if (strokeCache.first === inputEvent) {
         keyStrokeCache = null to null
         return strokeCache.second
       }
@@ -281,7 +281,7 @@ public class VimShortcutKeyAction : AnAction(), DumbAware/*, LightEditCompatible
       .toSet()
   }
 
-  internal companion object {
+  companion object {
     @JvmField
     val VIM_ONLY_EDITOR_KEYS: Set<KeyStroke> =
       ImmutableSet.builder<KeyStroke>().addAll(getKeyStrokes(KeyEvent.VK_ENTER, 0))

src/main/java/com/maddyhome/idea/vim/action/change/OperatorAction.kt

@@ -14,84 +14,39 @@ 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.VimEditor
-import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.api.setChangeMarks
 import com.maddyhome.idea.vim.command.Argument
 import com.maddyhome.idea.vim.command.Command
+import com.maddyhome.idea.vim.command.CommandFlags
 import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.common.argumentCaptured
-import com.maddyhome.idea.vim.ex.ExException
 import com.maddyhome.idea.vim.group.MotionGroup
 import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import com.maddyhome.idea.vim.handler.VisualOperatorActionHandler
 import com.maddyhome.idea.vim.helper.MessageHelper
+import com.maddyhome.idea.vim.helper.enumSetOf
 import com.maddyhome.idea.vim.helper.vimStateMachine
 import com.maddyhome.idea.vim.newapi.ij
-import com.maddyhome.idea.vim.state.mode.SelectionType
-import com.maddyhome.idea.vim.vimscript.model.CommandLineVimLContext
-import com.maddyhome.idea.vim.vimscript.model.datatypes.VimFuncref
-import com.maddyhome.idea.vim.vimscript.model.expressions.FunctionCallExpression
-import com.maddyhome.idea.vim.vimscript.model.expressions.SimpleExpression
+import java.util.*
 
 // todo make it multicaret
 private fun doOperatorAction(editor: VimEditor, context: ExecutionContext, textRange: TextRange, selectionType: SelectionType): Boolean {
-  val func = injector.globalOptions().operatorfunc
-  if (func.isEmpty()) {
+  val operatorFunction = injector.keyGroup.operatorFunction
+  if (operatorFunction == null) {
     VimPlugin.showMessage(MessageHelper.message("E774"))
     return false
   }
 
-  val scriptContext = CommandLineVimLContext
-
-  // The option value is either a function name, which should have a handler, or it might be a lambda expression, or a
-  // `function` or `funcref` call expression, all of which will return a funcref (with a handler)
-  var handler = injector.functionService.getFunctionHandlerOrNull(null, func, scriptContext)
-  if (handler == null) {
-    val expression = injector.vimscriptParser.parseExpression(func)
-    if (expression != null) {
-      try {
-        val value = expression.evaluate(editor, context, scriptContext)
-        if (value is VimFuncref) {
-          handler = value.handler
-        }
-      } catch (ex: ExException) {
-        // Get the argument for function('...') or funcref('...') for the error message
-        val functionName = if (expression is FunctionCallExpression && expression.arguments.size > 0) {
-          expression.arguments[0].evaluate(editor, context, scriptContext).toString()
-        }
-        else {
-          func
-        }
-
-        VimPlugin.showMessage("E117: Unknown function: $functionName")
-        return false
-      }
-    }
-  }
-
-  if (handler == null) {
-    VimPlugin.showMessage("E117: Unknown function: $func")
-    return false
-  }
-
-  val arg = when (selectionType) {
-    SelectionType.LINE_WISE -> "line"
-    SelectionType.CHARACTER_WISE -> "char"
-    SelectionType.BLOCK_WISE -> "block"
-  }
-
   val saveRepeatHandler = VimRepeater.repeatHandler
   injector.markService.setChangeMarks(editor.primaryCaret(), textRange)
   KeyHandler.getInstance().reset(editor)
-
-  val arguments = listOf(SimpleExpression(arg))
-  handler.executeFunction(arguments, editor, context, scriptContext)
-
+  val result = operatorFunction.apply(editor, context, selectionType)
   VimRepeater.repeatHandler = saveRepeatHandler
-  return true
+  return result
 }
 
 @CommandOrMotion(keys = ["g@"], modes = [Mode.NORMAL])
@@ -149,6 +104,8 @@ internal class OperatorAction : VimActionHandler.SingleExecution() {
 internal class VisualOperatorAction : VisualOperatorActionHandler.ForEachCaret() {
   override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
 
+  override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
+
   override fun executeAction(
     editor: VimEditor,
     caret: VimCaret,

src/main/java/com/maddyhome/idea/vim/action/change/RepeatChangeAction.kt

@@ -7,9 +7,9 @@
  */
 package com.maddyhome.idea.vim.action.change
 
-import com.intellij.openapi.command.CommandProcessor
 import com.intellij.vim.annotations.CommandOrMotion
 import com.intellij.vim.annotations.Mode
+import com.intellij.openapi.command.CommandProcessor
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor

src/main/java/com/maddyhome/idea/vim/action/change/delete/DeleteJoinVisualLinesAction.kt

@@ -14,10 +14,13 @@ import com.maddyhome.idea.vim.api.VimCaret
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.command.Command
+import com.maddyhome.idea.vim.command.CommandFlags
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.handler.VisualOperatorActionHandler
+import com.maddyhome.idea.vim.helper.enumSetOf
 import com.maddyhome.idea.vim.newapi.ijOptions
+import java.util.*
 
 /**
  * @author vlan
@@ -26,6 +29,8 @@ import com.maddyhome.idea.vim.newapi.ijOptions
 public class DeleteJoinVisualLinesAction : VisualOperatorActionHandler.SingleExecution() {
   override val type: Command.Type = Command.Type.DELETE
 
+  override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
+
   override fun executeForAllCarets(
     editor: VimEditor,
     context: ExecutionContext,

src/main/java/com/maddyhome/idea/vim/action/change/delete/DeleteJoinVisualLinesSpacesAction.kt

@@ -14,10 +14,13 @@ import com.maddyhome.idea.vim.api.VimCaret
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.command.Command
+import com.maddyhome.idea.vim.command.CommandFlags
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.handler.VisualOperatorActionHandler
+import com.maddyhome.idea.vim.helper.enumSetOf
 import com.maddyhome.idea.vim.newapi.ijOptions
+import java.util.*
 
 /**
  * @author vlan
@@ -26,6 +29,8 @@ import com.maddyhome.idea.vim.newapi.ijOptions
 public class DeleteJoinVisualLinesSpacesAction : VisualOperatorActionHandler.SingleExecution() {
   override val type: Command.Type = Command.Type.DELETE
 
+  override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
+
   override fun executeForAllCarets(
     editor: VimEditor,
     context: ExecutionContext,

src/main/java/com/maddyhome/idea/vim/action/editor/VimEditorActions.kt

@@ -8,9 +8,10 @@
 
 package com.maddyhome.idea.vim.action.editor
 
-import com.intellij.openapi.actionSystem.IdeActions
 import com.intellij.vim.annotations.CommandOrMotion
 import com.intellij.vim.annotations.Mode
+import com.intellij.openapi.actionSystem.IdeActions
+import com.maddyhome.idea.vim.action.ComplicatedKeysAction
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
@@ -20,32 +21,54 @@ import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.handler.IdeActionHandler
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import com.maddyhome.idea.vim.helper.enumSetOf
+import java.awt.event.KeyEvent
 import java.util.*
+import javax.swing.KeyStroke
 
 @CommandOrMotion(keys = ["<C-H>", "<BS>"], modes = [Mode.INSERT])
-internal class VimEditorBackSpace : IdeActionHandler(IdeActions.ACTION_EDITOR_BACKSPACE) {
+internal class VimEditorBackSpace : IdeActionHandler(IdeActions.ACTION_EDITOR_BACKSPACE), ComplicatedKeysAction {
+  override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_H, KeyEvent.CTRL_DOWN_MASK)),
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0)),
+  )
   override val type: Command.Type = Command.Type.DELETE
 }
 
 @CommandOrMotion(keys = ["<Del>"], modes = [Mode.INSERT])
-internal class VimEditorDelete : IdeActionHandler(IdeActions.ACTION_EDITOR_DELETE) {
+internal class VimEditorDelete : IdeActionHandler(IdeActions.ACTION_EDITOR_DELETE), ComplicatedKeysAction {
+  override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0)),
+  )
   override val type: Command.Type = Command.Type.DELETE
+  override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_STROKE)
 }
 
 @CommandOrMotion(keys = ["<Down>", "<kDown>"], modes = [Mode.INSERT])
-internal class VimEditorDown : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CARET_DOWN) {
+internal class VimEditorDown : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CARET_DOWN), ComplicatedKeysAction {
+  override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)),
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_KP_DOWN, 0)),
+  )
   override val type: Command.Type = Command.Type.MOTION
   override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_CLEAR_STROKES)
 }
 
 @CommandOrMotion(keys = ["<Tab>", "<C-I>"], modes = [Mode.INSERT])
-internal class VimEditorTab : IdeActionHandler(IdeActions.ACTION_EDITOR_TAB) {
+internal class VimEditorTab : IdeActionHandler(IdeActions.ACTION_EDITOR_TAB), ComplicatedKeysAction {
+  override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_I, KeyEvent.CTRL_DOWN_MASK)),
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0)),
+  )
   override val type: Command.Type = Command.Type.INSERT
   override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_STROKE)
 }
 
 @CommandOrMotion(keys = ["<Up>", "<kUp>"], modes = [Mode.INSERT])
-internal class VimEditorUp : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CARET_UP) {
+internal class VimEditorUp : IdeActionHandler(IdeActions.ACTION_EDITOR_MOVE_CARET_UP), ComplicatedKeysAction {
+  override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)),
+    listOf(KeyStroke.getKeyStroke(KeyEvent.VK_KP_UP, 0)),
+  )
   override val type: Command.Type = Command.Type.MOTION
   override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_CLEAR_STROKES)
 }

src/main/java/com/maddyhome/idea/vim/action/ex/ProcessExEntryAction.kt

@@ -10,6 +10,7 @@ package com.maddyhome.idea.vim.action.ex
 import com.intellij.vim.annotations.CommandOrMotion
 import com.intellij.vim.annotations.Mode
 import com.maddyhome.idea.vim.VimPlugin
+import com.maddyhome.idea.vim.action.ComplicatedKeysAction
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.command.Command
@@ -17,6 +18,7 @@ import com.maddyhome.idea.vim.command.CommandFlags
 import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.handler.VimActionHandler
 import java.util.*
+import javax.swing.KeyStroke
 
 /**
  * Called by KeyHandler to process the contents of the ex entry panel
@@ -24,7 +26,10 @@ import java.util.*
  * The mapping for this action means that the ex command is executed as a write action
  */
 @CommandOrMotion(keys = ["<CR>", "<C-M>", "<C-J>"], modes = [Mode.CMD_LINE])
-public class ProcessExEntryAction : VimActionHandler.SingleExecution() {
+public class ProcessExEntryAction : VimActionHandler.SingleExecution(), ComplicatedKeysAction {
+  override val keyStrokesSet: Set<List<KeyStroke>> =
+    parseKeysSet("<CR>", "<C-M>", 0x0a.toChar().toString(), 0x0d.toChar().toString())
+
   override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
 
   override val flags: EnumSet<CommandFlags> = EnumSet.of(CommandFlags.FLAG_COMPLETE_EX)

src/main/java/com/maddyhome/idea/vim/command/CommandState.kt

@@ -21,19 +21,19 @@ import com.maddyhome.idea.vim.state.mode.SelectionType
 public class CommandState(private val machine: VimStateMachine) {
 
   public val isOperatorPending: Boolean
-    get() = machine.isOperatorPending(machine.mode)
+    get() = machine.isOperatorPending
 
-  public val mode: Mode
+  public val mode: CommandState.Mode
     get() {
       val myMode = machine.mode
       return when (myMode) {
-        is com.maddyhome.idea.vim.state.mode.Mode.CMD_LINE -> Mode.CMD_LINE
-        com.maddyhome.idea.vim.state.mode.Mode.INSERT -> Mode.INSERT
-        is com.maddyhome.idea.vim.state.mode.Mode.NORMAL -> Mode.COMMAND
-        is com.maddyhome.idea.vim.state.mode.Mode.OP_PENDING -> Mode.OP_PENDING
-        com.maddyhome.idea.vim.state.mode.Mode.REPLACE -> Mode.REPLACE
-        is com.maddyhome.idea.vim.state.mode.Mode.SELECT -> Mode.SELECT
-        is com.maddyhome.idea.vim.state.mode.Mode.VISUAL -> Mode.VISUAL
+        com.maddyhome.idea.vim.state.mode.Mode.CMD_LINE -> CommandState.Mode.CMD_LINE
+        com.maddyhome.idea.vim.state.mode.Mode.INSERT -> CommandState.Mode.INSERT
+        is com.maddyhome.idea.vim.state.mode.Mode.NORMAL -> CommandState.Mode.COMMAND
+        is com.maddyhome.idea.vim.state.mode.Mode.OP_PENDING -> CommandState.Mode.OP_PENDING
+        com.maddyhome.idea.vim.state.mode.Mode.REPLACE -> CommandState.Mode.REPLACE
+        is com.maddyhome.idea.vim.state.mode.Mode.SELECT -> CommandState.Mode.SELECT
+        is com.maddyhome.idea.vim.state.mode.Mode.VISUAL -> CommandState.Mode.VISUAL
       }
     }
 

src/main/java/com/maddyhome/idea/vim/extension/VimExtensionFacade.kt

@@ -9,39 +9,25 @@ package com.maddyhome.idea.vim.extension
 
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.service
-import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
 import com.maddyhome.idea.vim.KeyHandler
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.action.change.Extension
-import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.ImmutableVimCaret
 import com.maddyhome.idea.vim.api.VimCaret
-import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.command.MappingMode
+import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.common.CommandAlias
 import com.maddyhome.idea.vim.common.CommandAliasHandler
-import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.helper.CommandLineHelper
 import com.maddyhome.idea.vim.helper.TestInputModel
-import com.maddyhome.idea.vim.helper.noneOfEnum
 import com.maddyhome.idea.vim.helper.vimStateMachine
 import com.maddyhome.idea.vim.key.MappingOwner
 import com.maddyhome.idea.vim.key.OperatorFunction
 import com.maddyhome.idea.vim.newapi.vim
-import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.ui.ModalEntry
-import com.maddyhome.idea.vim.vimscript.model.Executable
-import com.maddyhome.idea.vim.vimscript.model.ExecutionResult
-import com.maddyhome.idea.vim.vimscript.model.VimLContext
-import com.maddyhome.idea.vim.vimscript.model.datatypes.VimDataType
-import com.maddyhome.idea.vim.vimscript.model.expressions.Expression
-import com.maddyhome.idea.vim.vimscript.model.expressions.Scope
-import com.maddyhome.idea.vim.vimscript.model.statements.FunctionDeclaration
-import com.maddyhome.idea.vim.vimscript.model.statements.FunctionFlag
 import java.awt.event.KeyEvent
-import java.util.*
 import javax.swing.KeyStroke
 
 /**
@@ -52,9 +38,6 @@ import javax.swing.KeyStroke
  * @author vlan
  */
 public object VimExtensionFacade {
-
-  private val LOG = logger<VimExtensionFacade>()
-
   /** The 'map' command for mapping keys to handlers defined in extensions. */
   @JvmStatic
   public fun putExtensionHandlerMapping(
@@ -133,6 +116,12 @@ public object VimExtensionFacade {
       .setAlias(name, CommandAlias.Call(minimumNumberOfArguments, maximumNumberOfArguments, name, handler))
   }
 
+  /** Sets the value of 'operatorfunc' to be used as the operator function in 'g@'. */
+  @JvmStatic
+  public fun setOperatorFunction(function: OperatorFunction) {
+    VimPlugin.getKey().operatorFunction = function
+  }
+
   /**
    * Runs normal mode commands similar to ':normal! {commands}'.
    * Mappings doesn't work with this function
@@ -143,8 +132,7 @@ public object VimExtensionFacade {
   @JvmStatic
   public fun executeNormalWithoutMapping(keys: List<KeyStroke>, editor: Editor) {
     val context = injector.executionContextManager.onEditor(editor.vim)
-    val keyHandler = KeyHandler.getInstance()
-    keys.forEach { keyHandler.handleKey(editor.vim, it, context, false, false, keyHandler.keyHandlerState) }
+    keys.forEach { KeyHandler.getInstance().handleKey(editor.vim, it, context, false, false) }
   }
 
   /** Returns a single key stroke from the user input similar to 'getchar()'. */
@@ -152,26 +140,22 @@ public object VimExtensionFacade {
   public fun inputKeyStroke(editor: Editor): KeyStroke {
     if (editor.vim.vimStateMachine.isDotRepeatInProgress) {
       val input = Extension.consumeKeystroke()
-      LOG.trace("inputKeyStroke: dot repeat in progress. Input: $input")
       return input ?: error("Not enough keystrokes saved: ${Extension.lastExtensionHandler}")
     }
 
     val key: KeyStroke? = if (ApplicationManager.getApplication().isUnitTestMode) {
-      LOG.trace("Unit test mode is active")
       val mappingStack = KeyHandler.getInstance().keyStack
       mappingStack.feedSomeStroke() ?: TestInputModel.getInstance(editor).nextKeyStroke()?.also {
-        if (injector.registerGroup.isRecording) {
+        if (editor.vim.vimStateMachine.isRecording) {
           KeyHandler.getInstance().modalEntryKeys += it
         }
       }
     } else {
-      LOG.trace("Getting char from the modal entry...")
       var ref: KeyStroke? = null
       ModalEntry.activate(editor.vim) { stroke: KeyStroke? ->
         ref = stroke
         false
       }
-      LOG.trace("Got char $ref")
       ref
     }
     val result = key ?: KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE.toChar())
@@ -215,65 +199,4 @@ public object VimExtensionFacade {
   public fun setRegister(register: Char, keys: List<KeyStroke?>?, type: SelectionType) {
     VimPlugin.getRegister().setKeys(register, keys?.filterNotNull() ?: emptyList(), type)
   }
-
-  @JvmStatic
-  public fun exportScriptFunction(
-    scope: Scope?,
-    name: String,
-    args: List<String>,
-    defaultArgs: List<Pair<String, Expression>>,
-    hasOptionalArguments: Boolean,
-    flags: EnumSet<FunctionFlag>,
-    function: ScriptFunction
-  ) {
-    var functionDeclaration: FunctionDeclaration? = null
-    val body = listOf(object : Executable {
-      // This context is set to the function declaration during initialisation and then set to the function execution
-      // context during execution
-      override lateinit var vimContext: VimLContext
-      override var rangeInScript: TextRange = TextRange(0, 0)
-
-      override fun execute(editor: VimEditor, context: ExecutionContext): ExecutionResult {
-        return function.execute(editor, context, functionDeclaration!!.functionVariables)
-      }
-    })
-    functionDeclaration = FunctionDeclaration(
-      scope,
-      name,
-      args,
-      defaultArgs,
-      body,
-      replaceExisting = true,
-      flags,
-      hasOptionalArguments
-    )
-    functionDeclaration.rangeInScript = TextRange(0, 0)
-    body.forEach { it.vimContext = functionDeclaration }
-    injector.functionService.storeFunction(functionDeclaration)
-  }
 }
-
-public fun VimExtensionFacade.exportOperatorFunction(name: String, function: OperatorFunction) {
-  exportScriptFunction(null, name, listOf("type"), emptyList(), false, noneOfEnum()) {
-    editor, context, args ->
-
-    val type = args["type"]?.asString()
-    val selectionType = when (type) {
-      "line" -> SelectionType.LINE_WISE
-      "block" -> SelectionType.BLOCK_WISE
-      "char" -> SelectionType.CHARACTER_WISE
-      else -> return@exportScriptFunction ExecutionResult.Error
-    }
-
-    if (function.apply(editor, context, selectionType)) {
-      ExecutionResult.Success
-    }
-    else {
-      ExecutionResult.Error
-    }
-  }
-}
-
-public fun interface ScriptFunction {
-  public fun execute(editor: VimEditor, context: ExecutionContext, args: Map<String, VimDataType>): ExecutionResult
-}

src/main/java/com/maddyhome/idea/vim/extension/VimExtensionRegistrar.kt

@@ -53,11 +53,6 @@ internal object VimExtensionRegistrar : VimExtensionRegistrator {
   @Synchronized
   private fun registerExtension(extensionBean: ExtensionBeanClass) {
     val name = extensionBean.name ?: extensionBean.instance.name
-    if (name == "sneak" && extensionBean.name == null) {
-      // Filter out the old ideavim-sneak extension that used to be a separate plugin
-      // https://github.com/Mishkun/ideavim-sneak
-      return
-    }
     if (name in registeredExtensions) return
 
     registeredExtensions.add(name)
@@ -67,7 +62,7 @@ internal object VimExtensionRegistrar : VimExtensionRegistrator {
     VimPlugin.getOptionGroup().addGlobalOptionChangeListener(option) {
       if (injector.optionGroup.getOptionValue(option, OptionAccessScope.GLOBAL(null)).asBoolean()) {
         initExtension(extensionBean, name)
-        PluginState.Util.enabledExtensions.add(name)
+        PluginState.enabledExtensions.add(name)
       } else {
         extensionBean.instance.dispose()
       }

src/main/java/com/maddyhome/idea/vim/extension/argtextobj/VimArgTextObjExtension.java

@@ -251,7 +251,7 @@ public class VimArgTextObjExtension implements VimExtension {
 
       final ArgumentTextObjectHandler textObjectHandler = new ArgumentTextObjectHandler(isInner);
       //noinspection DuplicatedCode
-      if (!vimStateMachine.isOperatorPending(editor.getMode())) {
+      if (!vimStateMachine.isOperatorPending()) {
         editor.nativeCarets().forEach((VimCaret caret) -> {
           final TextRange range = textObjectHandler.getRange(editor, caret, context, count, 0);
           if (range != null) {

src/main/java/com/maddyhome/idea/vim/extension/commentary/CommentaryExtension.kt

@@ -22,26 +22,26 @@ 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.getLineEndOffset
-import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.command.Argument
 import com.maddyhome.idea.vim.command.Command
 import com.maddyhome.idea.vim.command.CommandFlags
 import com.maddyhome.idea.vim.command.MappingMode
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.state.mode.SelectionType
 import com.maddyhome.idea.vim.command.TextObjectVisualType
 import com.maddyhome.idea.vim.common.CommandAliasHandler
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.ex.ranges.Ranges
 import com.maddyhome.idea.vim.extension.ExtensionHandler
 import com.maddyhome.idea.vim.extension.VimExtension
-import com.maddyhome.idea.vim.extension.VimExtensionFacade
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.addCommand
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.executeNormalWithoutMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing
-import com.maddyhome.idea.vim.extension.exportOperatorFunction
+import com.maddyhome.idea.vim.extension.VimExtensionFacade.setOperatorFunction
 import com.maddyhome.idea.vim.handler.TextObjectActionHandler
 import com.maddyhome.idea.vim.helper.PsiHelper
 import com.maddyhome.idea.vim.helper.vimStateMachine
@@ -49,19 +49,17 @@ import com.maddyhome.idea.vim.key.OperatorFunction
 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.state.mode.Mode
-import com.maddyhome.idea.vim.state.mode.SelectionType
 import java.util.*
 
 internal class CommentaryExtension : VimExtension {
 
-  object Util {
+  companion object {
     fun doCommentary(
       editor: VimEditor,
       context: ExecutionContext,
       range: TextRange,
       selectionType: SelectionType,
-      resetCaret: Boolean = true,
+      resetCaret: Boolean,
     ): Boolean {
       val mode = editor.vimStateMachine.mode
       if (mode !is Mode.VISUAL) {
@@ -69,7 +67,8 @@ internal class CommentaryExtension : VimExtension {
       }
 
       return runWriteAction {
-        // Treat block- and character-wise selections as block comments. Fall back if the first action isn't available
+        // Treat block- and character-wise selections as block comments. Be ready to fall back to if the first action
+        // isn't available
         val actions = if (selectionType === SelectionType.LINE_WISE) {
           listOf(IdeActions.ACTION_COMMENT_LINE, IdeActions.ACTION_COMMENT_BLOCK)
         } else {
@@ -114,17 +113,12 @@ internal class CommentaryExtension : VimExtension {
       // first non-whitespace character, then the caret is in the right place. If it's inserted at the first column,
       // then the caret is now in a bit of a weird place. We can't detect this scenario, so we just have to accept
       // the difference
-      // TODO: If we don't move the caret to the start offset, we should maintain the current logical position
       if (resetCaret) {
         editor.primaryCaret().moveToOffset(range.startOffset)
       }
     }
   }
 
-  companion object {
-    private const val OPERATOR_FUNC = "CommentaryOperatorFunc"
-  }
-
   override fun getName() = "commentary"
 
   override fun init() {
@@ -151,16 +145,6 @@ internal class CommentaryExtension : VimExtension {
     putKeyMapping(MappingMode.N, injector.parser.parseKeys("<Plug>(CommentLine)"), owner, plugCommentaryLineKeys, true)
 
     addCommand("Commentary", CommentaryCommandAliasHandler())
-
-    VimExtensionFacade.exportOperatorFunction(OPERATOR_FUNC, CommentaryOperatorFunction())
- }
-
-  private class CommentaryOperatorFunction : OperatorFunction {
-    // todo make it multicaret
-    override fun apply(editor: VimEditor, context: ExecutionContext, selectionType: SelectionType?): Boolean {
-      val range = injector.markService.getChangeMarks(editor.primaryCaret()) ?: return false
-      return Util.doCommentary(editor, context, range, selectionType ?: SelectionType.CHARACTER_WISE, true)
-    }
   }
 
   /**
@@ -169,13 +153,24 @@ internal class CommentaryExtension : VimExtension {
    * E.g. handles the `gc` in `gc_`, by setting the operator function, then invoking `g@` to receive the `_` motion to
    * invoke the operator. This object is both the mapping handler and the operator function.
    */
-  private class CommentaryOperatorHandler : ExtensionHandler {
+  private class CommentaryOperatorHandler : OperatorFunction, ExtensionHandler {
     override val isRepeatable = true
 
+    // In this operator we process selection by ourselves. This is necessary for rider, VIM-1758
+    override fun postProcessSelection(): Boolean {
+      return false
+    }
+
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      injector.globalOptions().operatorfunc = OPERATOR_FUNC
+      setOperatorFunction(this)
       executeNormalWithoutMapping(injector.parser.parseKeys("g@"), editor.ij)
     }
+
+    // todo make it multicaret
+    override fun apply(editor: VimEditor, context: ExecutionContext, selectionType: SelectionType?): Boolean {
+      val range = injector.markService.getChangeMarks(editor.primaryCaret()) ?: return false
+      return doCommentary(editor, context, range, selectionType ?: SelectionType.CHARACTER_WISE, true)
+    }
   }
 
   private class CommentaryMappingHandler : ExtensionHandler {
@@ -249,7 +244,7 @@ internal class CommentaryExtension : VimExtension {
    */
   private class CommentaryCommandAliasHandler : CommandAliasHandler {
     override fun execute(command: String, ranges: Ranges, editor: VimEditor, context: ExecutionContext) {
-      Util.doCommentary(editor, context, ranges.getTextRange(editor, -1), SelectionType.LINE_WISE, false)
+      doCommentary(editor, context, ranges.getTextRange(editor, -1), SelectionType.LINE_WISE, false)
     }
   }
 }

src/main/java/com/maddyhome/idea/vim/extension/exchange/VimExchangeExtension.kt

@@ -19,22 +19,24 @@ import com.intellij.openapi.util.Key
 import com.maddyhome.idea.vim.api.ExecutionContext
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.getOffset
-import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.api.setChangeMarks
 import com.maddyhome.idea.vim.command.MappingMode
 import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.state.mode.SelectionType.CHARACTER_WISE
+import com.maddyhome.idea.vim.state.mode.selectionType
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.extension.ExtensionHandler
 import com.maddyhome.idea.vim.extension.VimExtension
-import com.maddyhome.idea.vim.extension.VimExtensionFacade
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.executeNormalWithoutMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.getRegister
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing
+import com.maddyhome.idea.vim.extension.VimExtensionFacade.setOperatorFunction
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.setRegister
-import com.maddyhome.idea.vim.extension.exportOperatorFunction
 import com.maddyhome.idea.vim.helper.fileSize
+import com.maddyhome.idea.vim.state.mode.mode
 import com.maddyhome.idea.vim.helper.moveToInlayAwareLogicalPosition
 import com.maddyhome.idea.vim.helper.moveToInlayAwareOffset
 import com.maddyhome.idea.vim.key.OperatorFunction
@@ -43,8 +45,6 @@ import com.maddyhome.idea.vim.mark.VimMarkConstants
 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.state.mode.SelectionType
-import com.maddyhome.idea.vim.state.mode.selectionType
 import org.jetbrains.annotations.NonNls
 
 /**
@@ -72,13 +72,30 @@ internal class VimExchangeExtension : VimExtension {
     putKeyMappingIfMissing(MappingMode.X, injector.parser.parseKeys("X"), owner, injector.parser.parseKeys(EXCHANGE_CMD), true)
     putKeyMappingIfMissing(MappingMode.N, injector.parser.parseKeys("cxc"), owner, injector.parser.parseKeys(EXCHANGE_CLEAR_CMD), true)
     putKeyMappingIfMissing(MappingMode.N, injector.parser.parseKeys("cxx"), owner, injector.parser.parseKeys(EXCHANGE_LINE_CMD), true)
-
-    VimExtensionFacade.exportOperatorFunction(OPERATOR_FUNC, Operator())
   }
 
-  object Util {
+  companion object {
+    @NonNls
+    const val EXCHANGE_CMD = "<Plug>(Exchange)"
+
+    @NonNls
+    const val EXCHANGE_CLEAR_CMD = "<Plug>(ExchangeClear)"
+
+    @NonNls
+    const val EXCHANGE_LINE_CMD = "<Plug>(ExchangeLine)"
+
     val EXCHANGE_KEY = Key<Exchange>("exchange")
 
+    // End mark has always greater of eq offset than start mark
+    class Exchange(val type: SelectionType, val start: Mark, val end: Mark, val text: String) {
+      private var myHighlighter: RangeHighlighter? = null
+      fun setHighlighter(highlighter: RangeHighlighter) {
+        myHighlighter = highlighter
+      }
+
+      fun getHighlighter(): RangeHighlighter? = myHighlighter
+    }
+
     fun clearExchange(editor: Editor) {
       editor.getUserData(EXCHANGE_KEY)?.getHighlighter()?.let {
         editor.markupModel.removeHighlighter(it)
@@ -87,25 +104,18 @@ internal class VimExchangeExtension : VimExtension {
     }
   }
 
-  companion object {
-    @NonNls private const val EXCHANGE_CMD = "<Plug>(Exchange)"
-    @NonNls private const val EXCHANGE_CLEAR_CMD = "<Plug>(ExchangeClear)"
-    @NonNls private const val EXCHANGE_LINE_CMD = "<Plug>(ExchangeLine)"
-    @NonNls private const val OPERATOR_FUNC = "ExchangeOperatorFunc"
-  }
-
   private class ExchangeHandler(private val isLine: Boolean) : ExtensionHandler {
     override val isRepeatable = true
 
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      injector.globalOptions().operatorfunc = OPERATOR_FUNC
+      setOperatorFunction(Operator(false))
       executeNormalWithoutMapping(injector.parser.parseKeys(if (isLine) "g@_" else "g@"), editor.ij)
     }
   }
 
   private class ExchangeClearHandler : ExtensionHandler {
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      Util.clearExchange(editor.ij)
+      clearExchange(editor.ij)
     }
   }
 
@@ -115,12 +125,12 @@ internal class VimExchangeExtension : VimExtension {
         val mode = editor.mode
         // Leave visual mode to create selection marks
         executeNormalWithoutMapping(injector.parser.parseKeys("<Esc>"), editor.ij)
-        Operator(true).apply(editor, context, mode.selectionType ?: SelectionType.CHARACTER_WISE)
+        Operator(true).apply(editor, context, mode.selectionType ?: CHARACTER_WISE)
       }
     }
   }
 
-  private class Operator(private val isVisual: Boolean = false) : OperatorFunction {
+  private class Operator(private val isVisual: Boolean) : OperatorFunction {
     fun Editor.getMarkOffset(mark: Mark) = IjVimEditor(this).getOffset(mark.line, mark.col)
     fun SelectionType.getString() = when (this) {
       SelectionType.CHARACTER_WISE -> "v"
@@ -138,7 +148,7 @@ internal class VimExchangeExtension : VimExtension {
           else -> HighlighterTargetArea.EXACT_RANGE
         }
         val isVisualLine = ex.type == SelectionType.LINE_WISE
-        val endAdj = if (!(isVisualLine) && (hlArea == HighlighterTargetArea.EXACT_RANGE || isVisual)) 1 else 0
+        val endAdj = if (!(isVisualLine) && (hlArea == HighlighterTargetArea.EXACT_RANGE || (isVisual))) 1 else 0
         return ijEditor.markupModel.addRangeHighlighter(
           ijEditor.getMarkOffset(ex.start),
           (ijEditor.getMarkOffset(ex.end) + endAdj).coerceAtMost(ijEditor.fileSize),
@@ -148,12 +158,12 @@ internal class VimExchangeExtension : VimExtension {
         )
       }
 
-      val currentExchange = getExchange(ijEditor, isVisual, selectionType ?: SelectionType.CHARACTER_WISE)
-      val exchange1 = ijEditor.getUserData(Util.EXCHANGE_KEY)
+      val currentExchange = getExchange(ijEditor, isVisual, selectionType ?: CHARACTER_WISE)
+      val exchange1 = ijEditor.getUserData(EXCHANGE_KEY)
       if (exchange1 == null) {
         val highlighter = highlightExchange(currentExchange)
         currentExchange.setHighlighter(highlighter)
-        ijEditor.putUserData(Util.EXCHANGE_KEY, currentExchange)
+        ijEditor.putUserData(EXCHANGE_KEY, currentExchange)
         return true
       } else {
         val cmp = compareExchanges(exchange1, currentExchange)
@@ -179,7 +189,7 @@ internal class VimExchangeExtension : VimExtension {
           }
         }
         exchange(ijEditor, ex1, ex2, reverse, expand)
-        Util.clearExchange(ijEditor)
+        clearExchange(ijEditor)
         return true
       }
     }
@@ -344,14 +354,4 @@ internal class VimExchangeExtension : VimExtension {
       }
     }
   }
-
-  // End mark has always greater of eq offset than start mark
-  class Exchange(val type: SelectionType, val start: Mark, val end: Mark, val text: String) {
-    private var myHighlighter: RangeHighlighter? = null
-    fun setHighlighter(highlighter: RangeHighlighter) {
-      myHighlighter = highlighter
-    }
-
-    fun getHighlighter(): RangeHighlighter? = myHighlighter
-  }
 }

src/main/java/com/maddyhome/idea/vim/extension/matchit/Matchit.kt

@@ -99,7 +99,7 @@ internal class Matchit : VimExtension {
 
       // Normally we want to jump to the start of the matching pair. But when moving forward in operator
       // pending mode, we want to include the entire match. isInOpPending makes that distinction.
-      val isInOpPending = commandState.isOperatorPending(editor.mode)
+      val isInOpPending = commandState.isOperatorPending
 
       if (isInOpPending) {
         val matchitAction = MatchitAction()
@@ -217,8 +217,6 @@ private object FileTypePatterns {
 
     return if (fileTypeName in htmlLikeFileTypes) {
       this.htmlPatterns
-    } else if (fileTypeName == "JAVA" || fileExtension == "java") {
-      this.javaPatterns
     } else if (fileTypeName == "Ruby" || fileExtension == "rb") {
       this.rubyPatterns
     } else if (fileTypeName == "RHTML" || fileExtension == "erb") {
@@ -244,7 +242,6 @@ private object FileTypePatterns {
   )
 
   private val htmlPatterns = createHtmlPatterns()
-  private val javaPatterns = createJavaPatterns()
   private val rubyPatterns = createRubyPatterns()
   private val rubyAndHtmlPatterns = rubyPatterns + htmlPatterns
   private val phpPatterns = createPhpPatterns()
@@ -273,14 +270,6 @@ private object FileTypePatterns {
         LanguagePatterns(linkedMapOf(openingTagPattern to htmlSearchPair), linkedMapOf(closingTagPattern to htmlSearchPair))
       )
   }
-  
-  private fun createJavaPatterns(): LanguagePatterns {
-    return (
-        LanguagePatterns("\\b(?<!else\\s+)if\\b", "\\belse\\s+if\\b", "\\belse(?!\\s+if)\\b") +
-          LanguagePatterns("\\bdo\\b", "\\bwhile\\b") +
-          LanguagePatterns("\\btry\\b", "\\bcatch\\b", "\\bfinally\\b")
-      )
-  }
 
   private fun createRubyPatterns(): LanguagePatterns {
     // Original patterns: https://github.com/vim/vim/blob/master/runtime/ftplugin/ruby.vim

src/main/java/com/maddyhome/idea/vim/extension/multiplecursors/VimMultipleCursorsExtension.kt

@@ -246,7 +246,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
 
       // Note that ignoreCase is not overridden by the `\C` in the pattern
       val pattern = makePattern(text, whole)
-      val matches = injector.searchHelper.findAll(IjVimEditor(editor), pattern, 0, -1, false)
+      val matches = SearchHelper.findAll(editor, pattern, 0, -1, false)
       for (match in matches) {
         if (match.contains(primaryCaret.offset)) {
           primaryCaret.vim.moveToOffset(match.startOffset)
@@ -322,7 +322,7 @@ internal class VimMultipleCursorsExtension : VimExtension {
       searchOptions.add(SearchOptions.WRAP)
     }
 
-    return injector.searchHelper.findPattern(IjVimEditor(editor), makePattern(text, whole), startOffset, 1, searchOptions)?.startOffset ?: -1
+    return SearchHelper.findPattern(editor, makePattern(text, whole), startOffset, 1, searchOptions)?.startOffset ?: -1
   }
 
   private fun makePattern(text: String, whole: Boolean): String {

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

@@ -130,15 +130,15 @@ internal class NerdTree : VimExtension {
     addCommand("NERDTreeFind", IjCommandHandler("SelectInProjectView"))
     addCommand("NERDTreeRefreshRoot", IjCommandHandler("Synchronize"))
 
-    synchronized(Util.monitor) {
-      Util.commandsRegistered = true
+    synchronized(monitor) {
+      commandsRegistered = true
       ProjectManager.getInstance().openProjects.forEach { project -> installDispatcher(project) }
     }
   }
 
   class IjCommandHandler(private val actionId: String) : CommandAliasHandler {
     override fun execute(command: String, ranges: Ranges, editor: VimEditor, context: ExecutionContext) {
-      Util.callAction(editor, actionId, context)
+      callAction(editor, actionId, context)
     }
   }
 
@@ -149,7 +149,7 @@ internal class NerdTree : VimExtension {
       if (toolWindow.isVisible) {
         toolWindow.hide()
       } else {
-        Util.callAction(editor, "ActivateProjectToolWindow", context)
+        callAction(editor, "ActivateProjectToolWindow", context)
       }
     }
   }
@@ -187,8 +187,8 @@ internal class NerdTree : VimExtension {
   // TODO I'm not sure is this activity runs at all? Should we use [RunOnceUtil] instead?
   class NerdStartupActivity : ProjectActivity {
     override suspend fun execute(project: Project) {
-      synchronized(Util.monitor) {
-        if (!Util.commandsRegistered) return
+      synchronized(monitor) {
+        if (!commandsRegistered) return
         installDispatcher(project)
       }
     }
@@ -214,7 +214,7 @@ internal class NerdTree : VimExtension {
 
           val action = nextNode.actionHolder
           when (action) {
-            is NerdAction.ToIj -> Util.callAction(null, action.name, e.dataContext.vim)
+            is NerdAction.ToIj -> callAction(null, action.name, e.dataContext.vim)
             is NerdAction.Code -> e.project?.let { action.action(it, e.dataContext, e) }
           }
         }
@@ -356,7 +356,7 @@ internal class NerdTree : VimExtension {
         currentWindow?.split(SwingConstants.VERTICAL, true, file, true)
 
         // FIXME: 22.01.2021 This solution bouncing a bit
-        Util.callAction(null, "ActivateProjectToolWindow", context.vim)
+        callAction(null, "ActivateProjectToolWindow", context.vim)
       },
     )
     registerCommand(
@@ -368,7 +368,7 @@ internal class NerdTree : VimExtension {
         val currentWindow = splitters.currentWindow
         currentWindow?.split(SwingConstants.HORIZONTAL, true, file, true)
 
-        Util.callAction(null, "ActivateProjectToolWindow", context.vim)
+        callAction(null, "ActivateProjectToolWindow", context.vim)
       },
     )
     registerCommand(
@@ -502,18 +502,16 @@ 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 { _, _, _ -> })
-      }
-    }
   }
 
-  object Util {
+  companion object {
+    const val pluginName = "NERDTree"
+
     internal val monitor = Any()
     internal var commandsRegistered = false
+
+    private val LOG = logger<NerdTree>()
+
     fun callAction(editor: VimEditor?, name: String, context: ExecutionContext) {
       val action = ActionManager.getInstance().getAction(name) ?: run {
         VimPlugin.showMessage(MessageHelper.message("action.not.found.0", name))
@@ -528,51 +526,45 @@ internal class NerdTree : VimExtension {
         }
       }
     }
-  }
 
-  companion object {
-    const val pluginName = "NERDTree"
-    private val LOG = logger<NerdTree>()
+    private fun addCommand(alias: String, handler: CommandAliasHandler) {
+      VimPlugin.getCommand().setAlias(alias, CommandAlias.Call(0, -1, alias, handler))
+    }
+
+    private fun registerCommand(variable: String, default: String, action: NerdAction) {
+      val variableValue = VimPlugin.getVariableService().getGlobalVariableValue(variable)
+      val mappings = if (variableValue is VimString) {
+        variableValue.value
+      } else {
+        default
+      }
+      actionsRoot.addLeafs(mappings, action)
+    }
+
+    private fun registerCommand(default: String, action: NerdAction) {
+      actionsRoot.addLeafs(default, action)
+    }
+
+    private val actionsRoot: RootNode<NerdAction> = RootNode()
+    private var currentNode: CommandPartNode<NerdAction> = actionsRoot
+
+    private fun collectShortcuts(node: Node<NerdAction>): Set<KeyStroke> {
+      return if (node is CommandPartNode<NerdAction>) {
+        val res = node.keys.toMutableSet()
+        res += node.values.map { collectShortcuts(it) }.flatten()
+        res
+      } else {
+        emptySet()
+      }
+    }
+
+    private fun installDispatcher(project: Project) {
+      val dispatcher = NerdDispatcher.getInstance(project)
+      val shortcuts = collectShortcuts(actionsRoot).map { RequiredShortcut(it, MappingOwner.Plugin.get(pluginName)) }
+      dispatcher.registerCustomShortcutSet(
+        KeyGroup.toShortcutSet(shortcuts),
+        (ProjectView.getInstance(project) as ProjectViewImpl).component,
+      )
+    }
   }
 }
-
-private fun addCommand(alias: String, handler: CommandAliasHandler) {
-  VimPlugin.getCommand().setAlias(alias, CommandAlias.Call(0, -1, alias, handler))
-}
-
-private fun registerCommand(variable: String, default: String, action: NerdAction) {
-  val variableValue = VimPlugin.getVariableService().getGlobalVariableValue(variable)
-  val mappings = if (variableValue is VimString) {
-    variableValue.value
-  } else {
-    default
-  }
-  actionsRoot.addLeafs(mappings, action)
-}
-
-private fun registerCommand(default: String, action: NerdAction) {
-  actionsRoot.addLeafs(default, action)
-}
-
-
-private val actionsRoot: RootNode<NerdAction> = RootNode()
-private var currentNode: CommandPartNode<NerdAction> = actionsRoot
-private fun collectShortcuts(node: Node<NerdAction>): Set<KeyStroke> {
-  return if (node is CommandPartNode<NerdAction>) {
-    val res = node.keys.toMutableSet()
-    res += node.values.map { collectShortcuts(it) }.flatten()
-    res
-  } else {
-    emptySet()
-  }
-}
-
-private fun installDispatcher(project: Project) {
-  val dispatcher = NerdTree.NerdDispatcher.getInstance(project)
-  val shortcuts =
-    collectShortcuts(actionsRoot).map { RequiredShortcut(it, MappingOwner.Plugin.get(NerdTree.pluginName)) }
-  dispatcher.registerCustomShortcutSet(
-    KeyGroup.toShortcutSet(shortcuts),
-    (ProjectView.getInstance(project) as ProjectViewImpl).component,
-  )
-}

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

@@ -9,7 +9,6 @@
 package com.maddyhome.idea.vim.extension.paragraphmotion
 
 import com.intellij.openapi.editor.Caret
-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,10 +20,8 @@ import com.maddyhome.idea.vim.extension.VimExtension
 import com.maddyhome.idea.vim.extension.VimExtensionFacade
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing
 import com.maddyhome.idea.vim.helper.vimForEachCaret
-import com.maddyhome.idea.vim.key.MappingOwner
 import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
-import javax.swing.KeyStroke
 
 internal class ParagraphMotion : VimExtension {
   override fun getName(): String = "vim-paragraph-motion"
@@ -33,8 +30,8 @@ internal class ParagraphMotion : VimExtension {
     VimExtensionFacade.putExtensionHandlerMapping(MappingMode.NXO, injector.parser.parseKeys("<Plug>(ParagraphNextMotion)"), owner, ParagraphMotionHandler(1), false)
     VimExtensionFacade.putExtensionHandlerMapping(MappingMode.NXO, injector.parser.parseKeys("<Plug>(ParagraphPrevMotion)"), owner, ParagraphMotionHandler(-1), false)
 
-    putKeyMappingIfMissingFromAndToKeys(MappingMode.NXO, injector.parser.parseKeys("}"), owner, injector.parser.parseKeys("<Plug>(ParagraphNextMotion)"), true)
-    putKeyMappingIfMissingFromAndToKeys(MappingMode.NXO, injector.parser.parseKeys("{"), owner, injector.parser.parseKeys("<Plug>(ParagraphPrevMotion)"), true)
+    putKeyMappingIfMissing(MappingMode.NXO, injector.parser.parseKeys("}"), owner, injector.parser.parseKeys("<Plug>(ParagraphNextMotion)"), true)
+    putKeyMappingIfMissing(MappingMode.NXO, injector.parser.parseKeys("{"), owner, injector.parser.parseKeys("<Plug>(ParagraphPrevMotion)"), true)
   }
 
   private class ParagraphMotionHandler(private val count: Int) : ExtensionHandler {
@@ -52,17 +49,4 @@ internal class ParagraphMotion : VimExtension {
         ?.let { editor.normalizeOffset(it, true) }
     }
   }
-
-  // For VIM-3306
-  @Suppress("SameParameterValue")
-  private fun putKeyMappingIfMissingFromAndToKeys(
-    modes: Set<MappingMode>,
-    fromKeys: List<KeyStroke>,
-    pluginOwner: MappingOwner,
-    toKeys: List<KeyStroke>,
-    recursive: Boolean,
-  ) {
-    val filteredModes = modes.filterNotTo(HashSet()) { VimPlugin.getKey().hasmapfrom(it, fromKeys) }
-    putKeyMappingIfMissing(filteredModes, fromKeys, pluginOwner, toKeys, recursive)
-  }
 }

src/main/java/com/maddyhome/idea/vim/extension/replacewithregister/ReplaceWithRegister.kt

@@ -14,19 +14,24 @@ 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.getLineEndOffset
-import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.command.MappingMode
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.state.mode.SelectionType.CHARACTER_WISE
+import com.maddyhome.idea.vim.state.mode.isLine
+import com.maddyhome.idea.vim.state.mode.selectionType
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.extension.ExtensionHandler
 import com.maddyhome.idea.vim.extension.VimExtension
 import com.maddyhome.idea.vim.extension.VimExtensionFacade
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.executeNormalWithoutMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMappingIfMissing
-import com.maddyhome.idea.vim.extension.exportOperatorFunction
+import com.maddyhome.idea.vim.extension.VimExtensionFacade.setOperatorFunction
 import com.maddyhome.idea.vim.group.visual.VimSelection
 import com.maddyhome.idea.vim.helper.exitVisualMode
+import com.maddyhome.idea.vim.state.mode.mode
 import com.maddyhome.idea.vim.helper.vimStateMachine
 import com.maddyhome.idea.vim.key.OperatorFunction
 import com.maddyhome.idea.vim.newapi.IjVimEditor
@@ -34,10 +39,6 @@ import com.maddyhome.idea.vim.newapi.ij
 import com.maddyhome.idea.vim.newapi.vim
 import com.maddyhome.idea.vim.options.helpers.ClipboardOptionHelper
 import com.maddyhome.idea.vim.put.PutData
-import com.maddyhome.idea.vim.state.mode.Mode
-import com.maddyhome.idea.vim.state.mode.SelectionType
-import com.maddyhome.idea.vim.state.mode.isLine
-import com.maddyhome.idea.vim.state.mode.selectionType
 import org.jetbrains.annotations.NonNls
 
 internal class ReplaceWithRegister : VimExtension {
@@ -52,13 +53,11 @@ internal class ReplaceWithRegister : VimExtension {
     putKeyMappingIfMissing(MappingMode.N, injector.parser.parseKeys("gr"), owner, injector.parser.parseKeys(RWR_OPERATOR), true)
     putKeyMappingIfMissing(MappingMode.N, injector.parser.parseKeys("grr"), owner, injector.parser.parseKeys(RWR_LINE), true)
     putKeyMappingIfMissing(MappingMode.X, injector.parser.parseKeys("gr"), owner, injector.parser.parseKeys(RWR_VISUAL), true)
-
-    VimExtensionFacade.exportOperatorFunction(OPERATOR_FUNC, Operator())
   }
 
   private class RwrVisual : ExtensionHandler {
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      val typeInEditor = editor.mode.selectionType ?: SelectionType.CHARACTER_WISE
+      val typeInEditor = editor.mode.selectionType ?: CHARACTER_WISE
       editor.sortedCarets().forEach { caret ->
         val selectionStart = caret.selectionStart
         val selectionEnd = caret.selectionEnd
@@ -74,7 +73,7 @@ internal class ReplaceWithRegister : VimExtension {
     override val isRepeatable: Boolean = true
 
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      injector.globalOptions().operatorfunc = OPERATOR_FUNC
+      setOperatorFunction(Operator())
       executeNormalWithoutMapping(injector.parser.parseKeys("g@"), editor.ij)
     }
   }
@@ -113,11 +112,11 @@ internal class ReplaceWithRegister : VimExtension {
           editor.primaryCaret() to VimSelection.create(
             range.startOffset,
             range.endOffset - 1,
-            selectionType ?: SelectionType.CHARACTER_WISE,
+            selectionType ?: CHARACTER_WISE,
             editor,
           ),
         ),
-        selectionType ?: SelectionType.CHARACTER_WISE,
+        selectionType ?: CHARACTER_WISE,
       )
       // todo multicaret
       doReplace(ijEditor, editor.primaryCaret(), visualSelection)
@@ -133,49 +132,52 @@ internal class ReplaceWithRegister : VimExtension {
   }
 
   companion object {
-    @NonNls private const val RWR_OPERATOR = "<Plug>ReplaceWithRegisterOperator"
-    @NonNls private const val RWR_LINE = "<Plug>ReplaceWithRegisterLine"
-    @NonNls private const val RWR_VISUAL = "<Plug>ReplaceWithRegisterVisual"
-    @NonNls private const val OPERATOR_FUNC = "ReplaceWithRegisterOperatorFunc"
+    @NonNls
+    private const val RWR_OPERATOR = "<Plug>ReplaceWithRegisterOperator"
+
+    @NonNls
+    private const val RWR_LINE = "<Plug>ReplaceWithRegisterLine"
+
+    @NonNls
+    private const val RWR_VISUAL = "<Plug>ReplaceWithRegisterVisual"
+
+    private fun doReplace(editor: Editor, caret: ImmutableVimCaret, visualSelection: PutData.VisualSelection) {
+      val registerGroup = injector.registerGroup
+      val lastRegisterChar = if (editor.caretModel.caretCount == 1) registerGroup.currentRegister else registerGroup.getCurrentRegisterForMulticaret()
+      val savedRegister = caret.registerStorage.getRegister(lastRegisterChar) ?: return
+
+      var usedType = savedRegister.type
+      var usedText = savedRegister.text
+      if (usedType.isLine && usedText?.endsWith('\n') == true) {
+        // Code from original plugin implementation. Correct text for linewise selected text
+        usedText = usedText.dropLast(1)
+        usedType = SelectionType.CHARACTER_WISE
+      }
+
+      val textData = PutData.TextData(usedText, usedType, savedRegister.transferableData, savedRegister.name)
+
+      val putData = PutData(
+        textData,
+        visualSelection,
+        1,
+        insertTextBeforeCaret = true,
+        rawIndent = true,
+        caretAfterInsertedText = false,
+        putToLine = -1,
+      )
+      ClipboardOptionHelper.IdeaputDisabler().use {
+        VimPlugin.getPut().putText(
+          IjVimEditor(editor),
+          injector.executionContextManager.onEditor(editor.vim),
+          putData,
+          operatorArguments = OperatorArguments(
+            editor.vimStateMachine?.isOperatorPending ?: false,
+            0,
+            editor.vim.mode,
+          ),
+          saveToRegister = false
+        )
+      }
+    }
   }
 }
-
-private fun doReplace(editor: Editor, caret: ImmutableVimCaret, visualSelection: PutData.VisualSelection) {
-  val registerGroup = injector.registerGroup
-  val lastRegisterChar = if (editor.caretModel.caretCount == 1) registerGroup.currentRegister else registerGroup.getCurrentRegisterForMulticaret()
-  val savedRegister = caret.registerStorage.getRegister(lastRegisterChar) ?: return
-
-  var usedType = savedRegister.type
-  var usedText = savedRegister.text
-  if (usedType.isLine && usedText?.endsWith('\n') == true) {
-    // Code from original plugin implementation. Correct text for linewise selected text
-    usedText = usedText.dropLast(1)
-    usedType = SelectionType.CHARACTER_WISE
-  }
-
-  val textData = PutData.TextData(usedText, usedType, savedRegister.transferableData, savedRegister.name)
-
-  val putData = PutData(
-    textData,
-    visualSelection,
-    1,
-    insertTextBeforeCaret = true,
-    rawIndent = true,
-    caretAfterInsertedText = false,
-    putToLine = -1,
-  )
-  val vimEditor = editor.vim
-  ClipboardOptionHelper.IdeaputDisabler().use {
-    VimPlugin.getPut().putText(
-      vimEditor,
-      injector.executionContextManager.onEditor(editor.vim),
-      putData,
-      operatorArguments = OperatorArguments(
-        editor.vimStateMachine?.isOperatorPending(vimEditor.mode) ?: false,
-        0,
-        editor.vim.mode,
-      ),
-      saveToRegister = false
-    )
-  }
-}

src/main/java/com/maddyhome/idea/vim/extension/sneak/IdeaVimSneakExtension.kt

@@ -1,327 +0,0 @@
-/*
- * Copyright 2003-2024 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.extension.sneak
-
-import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.ScrollType
-import com.intellij.openapi.editor.colors.EditorColors
-import com.intellij.openapi.editor.markup.EffectType
-import com.intellij.openapi.editor.markup.HighlighterLayer
-import com.intellij.openapi.editor.markup.HighlighterTargetArea
-import com.intellij.openapi.editor.markup.RangeHighlighter
-import com.intellij.openapi.editor.markup.TextAttributes
-import com.intellij.openapi.util.Disposer
-import com.maddyhome.idea.vim.VimPlugin
-import com.maddyhome.idea.vim.VimProjectService
-import com.maddyhome.idea.vim.api.ExecutionContext
-import com.maddyhome.idea.vim.api.VimEditor
-import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.api.options
-import com.maddyhome.idea.vim.command.MappingMode
-import com.maddyhome.idea.vim.command.OperatorArguments
-import com.maddyhome.idea.vim.common.TextRange
-import com.maddyhome.idea.vim.extension.ExtensionHandler
-import com.maddyhome.idea.vim.extension.VimExtension
-import com.maddyhome.idea.vim.extension.VimExtensionFacade
-import com.maddyhome.idea.vim.extension.VimExtensionFacade.putKeyMapping
-import com.maddyhome.idea.vim.extension.VimExtensionHandler
-import com.maddyhome.idea.vim.helper.StrictMode
-import com.maddyhome.idea.vim.newapi.ij
-import java.awt.Font
-import java.awt.event.KeyEvent
-import java.util.*
-import javax.swing.Timer
-
-
-private const val DEFAULT_HIGHLIGHT_DURATION_SNEAK = 300
-
-// By [Mikhail Levchenko](https://github.com/Mishkun)
-// Original repository with the plugin: https://github.com/Mishkun/ideavim-sneak
-internal class IdeaVimSneakExtension : VimExtension {
-  override fun getName(): String = "sneak"
-
-  override fun init() {
-    val highlightHandler = HighlightHandler()
-    mapToFunctionAndProvideKeys("s", SneakHandler(highlightHandler, Direction.FORWARD), MappingMode.NXO)
-
-    // vim-sneak uses `Z` for visual mode because `S` conflict with vim-sneak plugin VIM-3330
-    mapToFunctionAndProvideKeys("S", SneakHandler(highlightHandler, Direction.BACKWARD), MappingMode.NO)
-    mapToFunctionAndProvideKeys("Z", SneakHandler(highlightHandler, Direction.BACKWARD), MappingMode.X)
-
-    // workaround to support ; and , commands
-    mapToFunctionAndProvideKeys("f", SneakMemoryHandler("f"), MappingMode.NXO)
-    mapToFunctionAndProvideKeys("F", SneakMemoryHandler("F"), MappingMode.NXO)
-    mapToFunctionAndProvideKeys("t", SneakMemoryHandler("t"), MappingMode.NXO)
-    mapToFunctionAndProvideKeys("T", SneakMemoryHandler("T"), MappingMode.NXO)
-
-    mapToFunctionAndProvideKeys(";", SneakRepeatHandler(highlightHandler, RepeatDirection.IDENTICAL), MappingMode.NXO)
-    mapToFunctionAndProvideKeys(",", SneakRepeatHandler(highlightHandler, RepeatDirection.REVERSE), MappingMode.NXO)
-  }
-
-  private class SneakHandler(
-    private val highlightHandler: HighlightHandler,
-    private val direction: Direction,
-  ) : ExtensionHandler {
-    override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      val charone = getChar(editor) ?: return
-      val chartwo = getChar(editor) ?: return
-      val range = Util.jumpTo(editor, charone, chartwo, direction)
-      range?.let { highlightHandler.highlightSneakRange(editor.ij, range) }
-      Util.lastSymbols = "${charone}${chartwo}"
-      Util.lastSDirection = direction
-    }
-
-    private fun getChar(editor: VimEditor): Char? {
-      val key = VimExtensionFacade.inputKeyStroke(editor.ij)
-      return when {
-        key.keyChar == KeyEvent.CHAR_UNDEFINED || key.keyCode == KeyEvent.VK_ESCAPE -> null
-        else -> key.keyChar
-      }
-    }
-  }
-
-  /**
-   * This class acts as proxy for normal find commands because we need to update [Util.lastSDirection]
-   */
-  private class SneakMemoryHandler(private val char: String) : VimExtensionHandler {
-    override fun execute(editor: Editor, context: DataContext) {
-      Util.lastSDirection = null
-      VimExtensionFacade.executeNormalWithoutMapping(injector.parser.parseKeys(char), editor)
-    }
-  }
-
-  private class SneakRepeatHandler(
-    private val highlightHandler: HighlightHandler,
-    private val direction: RepeatDirection,
-  ) : ExtensionHandler {
-    override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      val lastSDirection = Util.lastSDirection
-      if (lastSDirection != null) {
-        val (charone, chartwo) = Util.lastSymbols.toList()
-        val jumpRange = Util.jumpTo(editor, charone, chartwo, direction.map(lastSDirection))
-        jumpRange?.let { highlightHandler.highlightSneakRange(editor.ij, jumpRange) }
-      } else {
-        VimExtensionFacade.executeNormalWithoutMapping(injector.parser.parseKeys(direction.symb), editor.ij)
-      }
-    }
-  }
-
-  private object Util {
-    var lastSDirection: Direction? = null
-    var lastSymbols: String = ""
-    fun jumpTo(editor: VimEditor, charone: Char, chartwo: Char, sneakDirection: Direction): TextRange? {
-      val caret = editor.primaryCaret()
-      val position = caret.offset.point
-      val chars = editor.text()
-      val foundPosition = sneakDirection.findBiChar(editor, chars, position, charone, chartwo)
-      if (foundPosition != null) {
-        editor.primaryCaret().moveToOffset(foundPosition)
-      }
-      editor.ij.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE)
-      return foundPosition?.let { TextRange(foundPosition, foundPosition + 2) }
-    }
-  }
-
-  private enum class Direction(val offset: Int) {
-    FORWARD(1) {
-      override fun findBiChar(
-        editor: VimEditor,
-        charSequence: CharSequence,
-        position: Int,
-        charone: Char,
-        chartwo: Char
-      ): Int? {
-        for (i in (position + offset) until charSequence.length - 1) {
-          if (matches(editor, charSequence, i, charone, chartwo)) {
-            return i
-          }
-        }
-        return null
-      }
-    },
-    BACKWARD(-1) {
-      override fun findBiChar(
-        editor: VimEditor,
-        charSequence: CharSequence,
-        position: Int,
-        charone: Char,
-        chartwo: Char
-      ): Int? {
-        for (i in (position + offset) downTo 0) {
-          if (matches(editor, charSequence, i, charone, chartwo)) {
-            return i
-          }
-        }
-        return null
-      }
-
-    };
-
-    abstract fun findBiChar(
-      editor: VimEditor,
-      charSequence: CharSequence,
-      position: Int,
-      charone: Char,
-      chartwo: Char,
-    ): Int?
-
-    fun matches(
-      editor: VimEditor,
-      charSequence: CharSequence,
-      charPosition: Int,
-      charOne: Char,
-      charTwo: Char,
-    ): Boolean {
-      var match = charSequence[charPosition].equals(charOne, ignoreCase = injector.options(editor).ignorecase) &&
-        charSequence[charPosition + 1].equals(charTwo, ignoreCase = injector.options(editor).ignorecase)
-
-      if (injector.options(editor).ignorecase && injector.options(editor).smartcase) {
-        if (charOne.isUpperCase() || charTwo.isUpperCase()) {
-          match = charSequence[charPosition].equals(charOne, ignoreCase = false) &&
-            charSequence[charPosition + 1].equals(charTwo, ignoreCase = false)
-        }
-      }
-      return match
-    }
-  }
-
-  private enum class RepeatDirection(val symb: String) {
-    IDENTICAL(";") {
-      override fun map(direction: Direction): Direction = direction
-    },
-    REVERSE(",") {
-      override fun map(direction: Direction): Direction = when (direction) {
-        Direction.FORWARD -> Direction.BACKWARD
-        Direction.BACKWARD -> Direction.FORWARD
-      }
-    };
-
-    abstract fun map(direction: Direction): Direction
-  }
-
-  private class HighlightHandler {
-    private var editor: Editor? = null
-    private val sneakHighlighters: MutableSet<RangeHighlighter> = mutableSetOf()
-
-    fun highlightSneakRange(editor: Editor, range: TextRange) {
-      clearAllSneakHighlighters()
-
-      this.editor = editor
-      val project = editor.project
-      if (project != null) {
-        Disposer.register(VimProjectService.getInstance(project)) {
-          this.editor = null
-          sneakHighlighters.clear()
-        }
-      }
-
-      if (range.isMultiple) {
-        for (i in 0 until range.size()) {
-          highlightSingleRange(editor, range.startOffsets[i]..range.endOffsets[i])
-        }
-      } else {
-        highlightSingleRange(editor, range.startOffset..range.endOffset)
-      }
-    }
-
-    fun clearAllSneakHighlighters() {
-      sneakHighlighters.forEach { highlighter ->
-        editor?.markupModel?.removeHighlighter(highlighter) ?: StrictMode.fail("Highlighters without an editor")
-      }
-
-      sneakHighlighters.clear()
-    }
-
-    private fun highlightSingleRange(editor: Editor, range: ClosedRange<Int>) {
-      val highlighter = editor.markupModel.addRangeHighlighter(
-        range.start,
-        range.endInclusive,
-        HighlighterLayer.SELECTION,
-        getHighlightTextAttributes(),
-        HighlighterTargetArea.EXACT_RANGE
-      )
-
-      sneakHighlighters.add(highlighter)
-
-      setClearHighlightRangeTimer(highlighter)
-    }
-
-    private fun setClearHighlightRangeTimer(highlighter: RangeHighlighter) {
-      val timer = Timer(DEFAULT_HIGHLIGHT_DURATION_SNEAK) {
-        if (editor?.isDisposed != true) {
-          editor?.markupModel?.removeHighlighter(highlighter)
-        }
-      }
-      timer.isRepeats = false
-      timer.start()
-    }
-
-    private fun getHighlightTextAttributes() = TextAttributes(
-      null,
-      EditorColors.TEXT_SEARCH_RESULT_ATTRIBUTES.defaultAttributes.backgroundColor,
-      editor?.colorsScheme?.getColor(EditorColors.CARET_COLOR),
-      EffectType.SEARCH_MATCH,
-      Font.PLAIN
-    )
-  }
-}
-
-/**
- * Map some <Plug>(keys) command to given handler
- *  and create mapping to <Plug>(prefix)[keys]
- */
-private fun VimExtension.mapToFunctionAndProvideKeys(
-  keys: String, handler: ExtensionHandler, mappingModes: EnumSet<MappingMode>
-) {
-  VimExtensionFacade.putExtensionHandlerMapping(
-    mappingModes,
-    injector.parser.parseKeys(command(keys)),
-    owner,
-    handler,
-    false
-  )
-  VimExtensionFacade.putExtensionHandlerMapping(
-    mappingModes,
-    injector.parser.parseKeys(commandFromOriginalPlugin(keys)),
-    owner,
-    handler,
-    false
-  )
-
-  // This is a combination to meet the following requirements:
-  //  - Now we should support mappings from sneak `Sneak_s` and mappings from the previous version of the plugin `(sneak-s)`
-  //  - The shortcut should not be registered if any of these mappings is overridden in .ideavimrc
-  //  - The shortcut should not be registered if some other shortcut for this key exists
-  val fromKeys = injector.parser.parseKeys(keys)
-  val filteredModes = mappingModes.filterNotTo(HashSet()) {
-    VimPlugin.getKey().hasmapto(it, injector.parser.parseKeys(command(keys)))
-  }
-  val filteredModes2 = mappingModes.filterNotTo(HashSet()) {
-    VimPlugin.getKey().hasmapto(it, injector.parser.parseKeys(commandFromOriginalPlugin(keys)))
-  }
-  val filteredFromModes = mappingModes.filterNotTo(HashSet()) {
-    injector.keyGroup.hasmapfrom(it, fromKeys)
-  }
-
-  val doubleFiltered = mappingModes
-    .filter { it in filteredModes2 && it in filteredModes && it in filteredFromModes }
-    .toSet()
-  putKeyMapping(doubleFiltered, fromKeys, owner, injector.parser.parseKeys(command(keys)), true)
-  putKeyMapping(
-    doubleFiltered,
-    fromKeys,
-    owner,
-    injector.parser.parseKeys(commandFromOriginalPlugin(keys)),
-    true
-  )
-}
-
-private fun command(keys: String) = "<Plug>(sneak-$keys)"
-private fun commandFromOriginalPlugin(keys: String) = "<Plug>Sneak_$keys"

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

@@ -8,7 +8,6 @@
 package com.maddyhome.idea.vim.extension.surround
 
 import com.intellij.openapi.application.runWriteAction
-import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.editor.Editor
 import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.ExecutionContext
@@ -17,7 +16,6 @@ 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
-import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
 import com.maddyhome.idea.vim.api.setChangeMarks
 import com.maddyhome.idea.vim.command.MappingMode
@@ -25,15 +23,14 @@ import com.maddyhome.idea.vim.command.OperatorArguments
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.extension.ExtensionHandler
 import com.maddyhome.idea.vim.extension.VimExtension
-import com.maddyhome.idea.vim.extension.VimExtensionFacade
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.executeNormalWithoutMapping
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.getRegisterForCaret
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.inputKeyStroke
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.inputString
 import com.maddyhome.idea.vim.extension.VimExtensionFacade.putExtensionHandlerMapping
 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.extension.exportOperatorFunction
 import com.maddyhome.idea.vim.helper.runWithEveryCaretAndRestore
 import com.maddyhome.idea.vim.key.OperatorFunction
 import com.maddyhome.idea.vim.newapi.IjVimCaret
@@ -80,15 +77,13 @@ internal class VimSurroundExtension : VimExtension {
       putKeyMappingIfMissing(MappingMode.N, injector.parser.parseKeys("ds"), owner, injector.parser.parseKeys("<Plug>DSurround"), true)
       putKeyMappingIfMissing(MappingMode.XO, injector.parser.parseKeys("S"), owner, injector.parser.parseKeys("<Plug>VSurround"), true)
     }
-
-    VimExtensionFacade.exportOperatorFunction(OPERATOR_FUNC, Operator(supportsMultipleCursors = false, count = 1)) // TODO
   }
 
   private class YSurroundHandler : ExtensionHandler {
     override val isRepeatable = true
 
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
-      injector.globalOptions().operatorfunc = OPERATOR_FUNC
+      setOperatorFunction(Operator(supportsMultipleCursors = false, count = 1)) // TODO
       executeNormalWithoutMapping(injector.parser.parseKeys("g@"), editor.ij)
     }
   }
@@ -260,7 +255,6 @@ internal class VimSurroundExtension : VimExtension {
     override fun execute(editor: VimEditor, context: ExecutionContext, operatorArguments: OperatorArguments) {
       // Deleting surround is just changing the surrounding to "nothing"
       val charFrom = getChar(editor.ij)
-      LOG.debug("DSurroundHandler: charFrom = $charFrom")
       if (charFrom.code == 0) return
 
       runWriteAction { CSurroundHandler.change(editor, context, charFrom, null) }
@@ -313,103 +307,96 @@ internal class VimSurroundExtension : VimExtension {
       }
     }
   }
-}
 
-private val LOG = logger<VimSurroundExtension>()
-
-private const val REGISTER = '"'
-
-private const val OPERATOR_FUNC = "SurroundOperatorFunc"
+  companion object {
+    private const val REGISTER = '"'
 
     private val tagNameAndAttributesCapturePattern = "(\\S+)([^>]*)>".toPattern()
 
-private val SURROUND_PAIRS = mapOf(
-  'b' to ("(" to ")"),
-  '(' to ("( " to " )"),
-  ')' to ("(" to ")"),
-  'B' to ("{" to "}"),
-  '{' to ("{ " to " }"),
-  '}' to ("{" to "}"),
-  'r' to ("[" to "]"),
-  '[' to ("[ " to " ]"),
-  ']' to ("[" to "]"),
-  'a' to ("<" to ">"),
-  '>' to ("<" to ">"),
-  's' to (" " to ""),
-)
-
-private fun getSurroundPair(c: Char): Pair<String, String>? = if (c in SURROUND_PAIRS) {
-  SURROUND_PAIRS[c]
-} else if (!c.isLetter()) {
-  val s = c.toString()
-  s to s
-} else {
-  null
-}
-
-private fun inputTagPair(editor: Editor): Pair<String, String>? {
-  val tagInput = inputString(editor, "<", '>')
-  val matcher = tagNameAndAttributesCapturePattern.matcher(tagInput)
-  return if (matcher.find()) {
-    val tagName = matcher.group(1)
-    val tagAttributes = matcher.group(2)
-    "<$tagName$tagAttributes>" to "</$tagName>"
-  } else {
-    null
-  }
-}
-
-private fun inputFunctionName(
-  editor: Editor,
-  withInternalSpaces: Boolean,
-): Pair<String, String>? {
-  val functionNameInput = inputString(editor, "function: ", null)
-  if (functionNameInput.isEmpty()) return null
-  return if (withInternalSpaces) "$functionNameInput( " to " )" else "$functionNameInput(" to ")"
-}
-
-private fun getOrInputPair(c: Char, editor: Editor): Pair<String, String>? = when (c) {
-  '<', 't' -> inputTagPair(editor)
-  'f' -> inputFunctionName(editor, false)
-  'F' -> inputFunctionName(editor, true)
-  else -> getSurroundPair(c)
-}
-
-private fun getChar(editor: Editor): Char {
-  val key = inputKeyStroke(editor)
-  val keyChar = key.keyChar
-  val res = if (keyChar == KeyEvent.CHAR_UNDEFINED || keyChar.code == KeyEvent.VK_ESCAPE) {
-    0.toChar()
-  } else {
-    keyChar
-  }
-  LOG.trace("getChar: $res")
-  return res
-}
-
-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 = RepeatedCharSequence.of(pair.first + if (tagsOnNewLines) "\n" else "", count)
-
-    val isEOF = range.endOffset == editor.text().length
-    val hasNewLine = editor.endsWithNewLine()
-    val rightSurround = (if (tagsOnNewLines) {
-      if (isEOF && !hasNewLine) {
-        "\n" + pair.second
-      } else {
-        pair.second + "\n"
-      }
-    } else {
-      pair.second
-    }).let { RepeatedCharSequence.of(it, count) }
-
-    change.insertText(editor, caret, range.startOffset, leftSurround)
-    change.insertText(editor, caret, range.endOffset + leftSurround.length, rightSurround)
-    injector.markService.setChangeMarks(
-      caret,
-      TextRange(range.startOffset, range.endOffset + leftSurround.length + rightSurround.length)
+    private val SURROUND_PAIRS = mapOf(
+      'b' to ("(" to ")"),
+      '(' to ("( " to " )"),
+      ')' to ("(" to ")"),
+      'B' to ("{" to "}"),
+      '{' to ("{ " to " }"),
+      '}' to ("{" to "}"),
+      'r' to ("[" to "]"),
+      '[' to ("[ " to " ]"),
+      ']' to ("[" to "]"),
+      'a' to ("<" to ">"),
+      '>' to ("<" to ">"),
+      's' to (" " to ""),
     )
+
+    private fun getSurroundPair(c: Char): Pair<String, String>? = if (c in SURROUND_PAIRS) {
+      SURROUND_PAIRS[c]
+    } else if (!c.isLetter()) {
+      val s = c.toString()
+      s to s
+    } else {
+      null
+    }
+
+    private fun inputTagPair(editor: Editor): Pair<String, String>? {
+      val tagInput = inputString(editor, "<", '>')
+      val matcher = tagNameAndAttributesCapturePattern.matcher(tagInput)
+      return if (matcher.find()) {
+        val tagName = matcher.group(1)
+        val tagAttributes = matcher.group(2)
+        "<$tagName$tagAttributes>" to "</$tagName>"
+      } else {
+        null
+      }
+    }
+
+    private fun inputFunctionName(
+      editor: Editor,
+      withInternalSpaces: Boolean,
+    ): Pair<String, String>? {
+      val functionNameInput = inputString(editor, "function: ", null)
+      if (functionNameInput.isEmpty()) return null
+      return if (withInternalSpaces) "$functionNameInput( " to " )" else "$functionNameInput(" to ")"
+    }
+
+    private fun getOrInputPair(c: Char, editor: Editor): Pair<String, String>? = when (c) {
+      '<', 't' -> inputTagPair(editor)
+      'f' -> inputFunctionName(editor, false)
+      'F' -> inputFunctionName(editor, true)
+      else -> getSurroundPair(c)
+    }
+
+    private fun getChar(editor: Editor): Char {
+      val key = inputKeyStroke(editor)
+      val keyChar = key.keyChar
+      return if (keyChar == KeyEvent.CHAR_UNDEFINED || keyChar.code == KeyEvent.VK_ESCAPE) {
+        0.toChar()
+      } else {
+        keyChar
+      }
+    }
+
+    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 = RepeatedCharSequence.of(pair.first + if (tagsOnNewLines) "\n" else "", count)
+
+        val isEOF = range.endOffset == editor.text().length
+        val hasNewLine = editor.endsWithNewLine()
+        val rightSurround = (if (tagsOnNewLines) {
+          if (isEOF && !hasNewLine) {
+            "\n" + pair.second
+          } else {
+            pair.second + "\n"
+          }
+        } else {
+          pair.second
+        }).let { RepeatedCharSequence.of(it, count) }
+
+        change.insertText(editor, caret, range.startOffset, leftSurround)
+        change.insertText(editor, caret, range.endOffset + leftSurround.length, rightSurround)
+        injector.markService.setChangeMarks(caret, TextRange(range.startOffset, range.endOffset + leftSurround.length + rightSurround.length))
+      }
+    }
   }
 }

src/main/java/com/maddyhome/idea/vim/extension/textobjentire/VimTextObjEntireExtension.java

@@ -138,7 +138,7 @@ public class VimTextObjEntireExtension implements VimExtension {
 
       final EntireTextObjectHandler textObjectHandler = new EntireTextObjectHandler(ignoreLeadingAndTrailing);
       //noinspection DuplicatedCode
-      if (!vimStateMachine.isOperatorPending(editor.getMode())) {
+      if (!vimStateMachine.isOperatorPending()) {
         ((IjVimEditor) editor).getEditor().getCaretModel().runForEachCaret((Caret caret) -> {
           final TextRange range = textObjectHandler.getRange(editor, new IjVimCaret(caret), context, count, 0);
           if (range != null) {

src/main/java/com/maddyhome/idea/vim/extension/textobjindent/VimIndentObject.java

@@ -267,7 +267,7 @@ public class VimIndentObject implements VimExtension {
 
       final IndentObjectHandler textObjectHandler = new IndentObjectHandler(includeAbove, includeBelow);
 
-      if (!vimStateMachine.isOperatorPending(editor.getMode())) {
+      if (!vimStateMachine.isOperatorPending()) {
         ((IjVimEditor)editor).getEditor().getCaretModel().runForEachCaret((Caret caret) -> {
           final TextRange range = textObjectHandler.getRange(vimEditor, new IjVimCaret(caret), context, count, 0);
           if (range != null) {

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

@@ -20,6 +20,9 @@ import com.intellij.openapi.editor.actions.EnterAction
 import com.intellij.openapi.editor.event.EditorMouseEvent
 import com.intellij.openapi.editor.event.EditorMouseListener
 import com.intellij.openapi.editor.impl.TextRangeInterval
+import com.intellij.openapi.ui.MessageType
+import com.intellij.openapi.ui.popup.Balloon
+import com.intellij.openapi.ui.popup.JBPopupFactory
 import com.intellij.openapi.util.UserDataHolder
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.codeStyle.CodeStyleManager
@@ -62,29 +65,31 @@ import com.maddyhome.idea.vim.helper.endOffsetInclusive
 import com.maddyhome.idea.vim.helper.inInsertMode
 import com.maddyhome.idea.vim.helper.moveToInlayAwareLogicalPosition
 import com.maddyhome.idea.vim.helper.moveToInlayAwareOffset
+import com.maddyhome.idea.vim.icons.VimIcons
 import com.maddyhome.idea.vim.key.KeyHandlerKeeper.Companion.getInstance
 import com.maddyhome.idea.vim.listener.VimInsertListener
 import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext
 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.regexp.VimRegex
-import com.maddyhome.idea.vim.regexp.match.VimMatchResult
 import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.state.mode.Mode.VISUAL
 import com.maddyhome.idea.vim.state.mode.SelectionType
+import com.maddyhome.idea.vim.state.mode.mode
 import com.maddyhome.idea.vim.vimscript.model.commands.SortOption
 import org.jetbrains.annotations.TestOnly
 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
  */
 public class ChangeGroup : VimChangeGroupBase() {
   private val insertListeners = ContainerUtil.createLockFreeCopyOnWriteList<VimInsertListener>()
+  private var lastShownTime = 0L
   private val listener: EditorMouseListener = object : EditorMouseListener {
     override fun mouseClicked(event: EditorMouseEvent) {
       val editor = event.editor
@@ -98,6 +103,10 @@ public class ChangeGroup : VimChangeGroupBase() {
     EventFacade.getInstance().addEditorMouseListener(editor!!, listener, disposable)
   }
 
+  public fun editorReleased(editor: Editor?) {
+    EventFacade.getInstance().removeEditorMouseListener(editor!!, listener)
+  }
+
   override fun type(vimEditor: VimEditor, context: ExecutionContext, key: Char) {
     val editor = (vimEditor as IjVimEditor).editor
     val ijContext = context.ij
@@ -395,7 +404,6 @@ 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
@@ -420,7 +428,11 @@ public class ChangeGroup : VimChangeGroupBase() {
       }
     }
     val afterAction = {
-      caret.moveToOffset(injector.motion.moveCaretToLineStartSkipLeading(editor, startPos.line))
+      val firstLine = editor.offsetToBufferPosition(
+        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) {
@@ -532,7 +544,7 @@ public class ChangeGroup : VimChangeGroupBase() {
         val soff = editor.getLineStartOffset(l)
         val eoff = editor.getLineEndOffset(l, true)
         val woff = injector.motion.moveCaretToLineStartSkipLeading(editor, l)
-        val col = editor.offsetToBufferPosition(woff).column
+        val col = editor.offsetToVisualPosition(woff).column
         val limit = max(0.0, (col + dir * indentConfig.getTotalIndent(count)).toDouble())
           .toInt()
         if (col > 0 || soff != eoff) {
@@ -574,62 +586,48 @@ public class ChangeGroup : VimChangeGroupBase() {
     }
     val startOffset = editor.getLineStartOffset(startLine)
     val endOffset = editor.getLineEndOffset(endLine)
+    return sortTextRange(editor, caret, startOffset, endOffset, lineComparator, sortOptions)
+  }
 
-    val selectedText = (editor as IjVimEditor).editor.document.getText(TextRangeInterval(startOffset, endOffset))
-    val lines = selectedText.split("\n")
-    val modifiedLines = sortOptions.pattern?.let {
-      if (sortOptions.sortOnPattern) {
-        extractPatternFromLines(editor, lines, startLine, it)
-      } else {
-        deletePatternFromLines(editor, lines, startLine, it)
-      }
-    } ?: lines
-    val sortedLines = lines.zip(modifiedLines)
-      .sortedWith { l1, l2 -> lineComparator.compare(l1.second, l2.second) }
-      .map {it.first}
-      .toMutableList()
-
-    if (sortOptions.unique) {
-      val iterator = sortedLines.iterator()
+  /**
+   * Sorts a text range with a comparator. Returns true if a replace was performed, false otherwise.
+   *
+   * @param editor         The editor to replace text in
+   * @param start          The starting position for the sort
+   * @param end            The ending position for the sort
+   * @param lineComparator The comparator to use to sort
+   * @param sortOption     The option to sort the range
+   * @return true if able to sort the text, false if not
+   */
+  private fun sortTextRange(
+    editor: VimEditor,
+    caret: VimCaret,
+    start: Int,
+    end: Int,
+    lineComparator: Comparator<String>,
+    sortOption: SortOption,
+  ): Boolean {
+    val selectedText = (editor as IjVimEditor).editor.document.getText(TextRangeInterval(start, end))
+    val lines: MutableList<String> = selectedText.split("\n").sortedWith(lineComparator).toMutableList()
+    if (sortOption.unique) {
+      val iterator = lines.iterator()
       var previous: String? = null
       while (iterator.hasNext()) {
         val current = iterator.next()
-        if (current == previous || sortOptions.ignoreCase && current.equals(previous, ignoreCase = true)) {
+        if (current == previous || sortOption.ignoreCase && current.equals(previous, ignoreCase = true)) {
           iterator.remove()
         } else {
           previous = current
         }
       }
     }
-    if (sortedLines.isEmpty()) {
+    if (lines.size < 1) {
       return false
     }
-    replaceText(editor, caret, startOffset, endOffset, StringUtil.join(sortedLines, "\n"))
+    replaceText(editor, caret, start, end, StringUtil.join(lines, "\n"))
     return true
   }
 
-  private fun extractPatternFromLines(editor: VimEditor, lines: List<String>, startLine: Int, pattern: String): List<String> {
-    val regex = VimRegex(pattern)
-    return lines.mapIndexed { i: Int, line: String ->
-      val result = regex.findInLine(editor, startLine + i, 0)
-      when (result) {
-        is VimMatchResult.Success -> result.value
-        is VimMatchResult.Failure -> line
-      }
-    }
-  }
-
-  private fun deletePatternFromLines(editor: VimEditor, lines: List<String>, startLine: Int, pattern: String): List<String> {
-    val regex = VimRegex(pattern)
-    return lines.mapIndexed { i: Int, line: String ->
-      val result = regex.findInLine(editor, startLine + i, 0)
-      when (result) {
-        is VimMatchResult.Success -> line.substring(result.value.length, line.length)
-        is VimMatchResult.Failure -> line
-      }
-    }
-  }
-
   /**
    * Perform increment and decrement for numbers in visual mode
    *
@@ -647,6 +645,25 @@ public class ChangeGroup : VimChangeGroupBase() {
     avalanche: Boolean,
   ): Boolean {
 
+    // Just an easter egg
+    if (avalanche) {
+      val currentTime = System.currentTimeMillis()
+      if (currentTime - lastShownTime > 60000) {
+        lastShownTime = currentTime
+        ApplicationManager.getApplication().invokeLater {
+          val balloon = JBPopupFactory.getInstance()
+            .createHtmlTextBalloonBuilder(
+              "Wow, nice vim skills!", VimIcons.IDEAVIM,
+              MessageType.INFO.titleForeground, MessageType.INFO.popupBackground,
+              null
+            ).createBalloon()
+          balloon.show(
+            JBPopupFactory.getInstance().guessBestPopupLocation((editor as IjVimEditor).editor),
+            Balloon.Position.below
+          )
+        }
+      }
+    }
     val nf: List<String> = injector.options(editor).nrformats
     val alpha = nf.contains("alpha")
     val hex = nf.contains("hex")

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

@@ -8,11 +8,9 @@
 
 package com.maddyhome.idea.vim.group
 
-import com.intellij.openapi.components.Service
 import com.maddyhome.idea.vim.api.VimCommandGroupBase
 
 /**
  * @author Elliot Courant
  */
-@Service
 internal class CommandGroup : VimCommandGroupBase()

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

@@ -11,9 +11,6 @@ package com.maddyhome.idea.vim.group;
 import com.intellij.execution.impl.ConsoleViewImpl;
 import com.intellij.find.EditorSearchSession;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.client.ClientAppSession;
-import com.intellij.openapi.client.ClientKind;
-import com.intellij.openapi.client.ClientSessionsManager;
 import com.intellij.openapi.components.PersistentStateComponent;
 import com.intellij.openapi.components.State;
 import com.intellij.openapi.components.Storage;
@@ -25,10 +22,7 @@ import com.intellij.openapi.project.Project;
 import com.maddyhome.idea.vim.KeyHandler;
 import com.maddyhome.idea.vim.VimPlugin;
 import com.maddyhome.idea.vim.api.*;
-import com.maddyhome.idea.vim.helper.CaretVisualAttributesHelperKt;
-import com.maddyhome.idea.vim.helper.CommandStateHelper;
-import com.maddyhome.idea.vim.helper.EditorHelper;
-import com.maddyhome.idea.vim.helper.UserDataManager;
+import com.maddyhome.idea.vim.helper.*;
 import com.maddyhome.idea.vim.newapi.IjVimDocument;
 import com.maddyhome.idea.vim.newapi.IjVimEditor;
 import com.maddyhome.idea.vim.options.EffectiveOptionValueChangeListener;
@@ -40,10 +34,10 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.Collection;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static com.maddyhome.idea.vim.api.VimInjectorKt.injector;
 import static com.maddyhome.idea.vim.api.VimInjectorKt.options;
+import static com.maddyhome.idea.vim.helper.CaretVisualAttributesHelperKt.updateCaretsVisualAttributes;
 import static com.maddyhome.idea.vim.newapi.IjVimInjectorKt.ijOptions;
 
 /**
@@ -210,8 +204,7 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
   }
 
   public void editorCreated(@NotNull Editor editor) {
-    UserDataManager.setVimInitialised(editor, true);
-
+    DocumentManager.INSTANCE.addListeners(editor.getDocument());
     VimPlugin.getKey().registerRequiredShortcutKeys(new IjVimEditor(editor));
 
     initLineNumbers(editor);
@@ -253,13 +246,14 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
           switchToInsertMode.run();
         }
       });
-    updateCaretsVisualAttributes(new IjVimEditor(editor));
+    updateCaretsVisualAttributes(editor);
   }
 
   public void editorDeinit(@NotNull Editor editor, boolean isReleased) {
     deinitLineNumbers(editor, isReleased);
     UserDataManager.unInitializeEditor(editor);
     VimPlugin.getKey().unregisterShortcutKeys(new IjVimEditor(editor));
+    DocumentManager.INSTANCE.removeListeners(editor.getDocument());
     CaretVisualAttributesHelperKt.removeCaretsVisualAttributes(editor);
   }
 
@@ -290,18 +284,6 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
     notifyIdeaJoin(((IjVimEditor) editor).getEditor().getProject(), editor);
   }
 
-  @Override
-  public void updateCaretsVisualAttributes(@NotNull VimEditor editor) {
-    Editor ijEditor = ((IjVimEditor) editor).getEditor();
-    CaretVisualAttributesHelperKt.updateCaretsVisualAttributes(ijEditor);
-  }
-
-  @Override
-  public void updateCaretsVisualPosition(@NotNull VimEditor editor) {
-    Editor ijEditor = ((IjVimEditor) editor).getEditor();
-    CaretVisualAttributesHelperKt.updateCaretsVisualAttributes(ijEditor);
-  }
-
   public static class NumberChangeListener implements EffectiveOptionValueChangeListener {
     public static NumberChangeListener INSTANCE = new NumberChangeListener();
 
@@ -342,45 +324,20 @@ public class EditorGroup implements PersistentStateComponent<Element>, VimEditor
     }
   }
 
+  @NotNull
   @Override
-  public @NotNull Collection<VimEditor> getEditorsRaw() {
-    return getLocalEditors()
+  public Collection<VimEditor> localEditors() {
+    return HelperKt.localEditors().stream()
       .map(IjVimEditor::new)
       .collect(Collectors.toList());
   }
 
   @NotNull
   @Override
-  public Collection<VimEditor> getEditors() {
-    return getLocalEditors()
-      .filter(UserDataManager::getVimInitialised)
-      .map(IjVimEditor::new)
-      .collect(Collectors.toList());
-  }
-
-  @NotNull
-  @Override
-  public Collection<VimEditor> getEditors(@NotNull VimDocument buffer) {
+  public Collection<VimEditor> localEditors(@NotNull VimDocument buffer) {
     final Document document = ((IjVimDocument)buffer).getDocument();
-    return getLocalEditors()
-      .filter(editor -> UserDataManager.getVimInitialised(editor) && editor.getDocument().equals(document))
+    return HelperKt.localEditors(document).stream()
       .map(IjVimEditor::new)
       .collect(Collectors.toList());
   }
-
-  private Stream<Editor> getLocalEditors() {
-    // Always fetch local editors. If we're hosting a Code With Me session, any connected guests will create hidden
-    // editors to handle syntax highlighting, completion requests, etc. We need to make sure that IdeaVim only makes
-    // changes (e.g. adding search highlights) to local editors, so things don't incorrectly flow through to any Clients.
-    // In non-CWM scenarios, or if IdeaVim is installed on the Client, there are only ever local editors, so this will
-    // also work there. In Gateway remote development scenarios, IdeaVim should not be installed on the host, only the
-    // Client, so all should work there too.
-    // Note that most IdeaVim operations are in response to interactive keystrokes, which would mean that
-    // ClientEditorManager.getCurrentInstance would return local editors. However, some operations are in response to
-    // events such as document change (to update search highlights) and these can come from CWM guests, and we'd get the
-    // remote editors.
-    // This invocation will always get local editors, regardless of current context.
-    final ClientAppSession localSession = ClientSessionsManager.getAppSessions(ClientKind.LOCAL).get(0);
-    return localSession.getService(ClientEditorManager.class).editors();
-  }
 }

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

@@ -30,6 +30,8 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.ProjectScope;
 import com.maddyhome.idea.vim.VimPlugin;
 import com.maddyhome.idea.vim.api.*;
+import com.maddyhome.idea.vim.state.mode.Mode;
+import com.maddyhome.idea.vim.state.VimStateMachine;
 import com.maddyhome.idea.vim.common.TextRange;
 import com.maddyhome.idea.vim.helper.EditorHelper;
 import com.maddyhome.idea.vim.helper.EditorHelperRt;
@@ -38,8 +40,6 @@ import com.maddyhome.idea.vim.helper.SearchHelper;
 import com.maddyhome.idea.vim.newapi.ExecuteExtensionKt;
 import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext;
 import com.maddyhome.idea.vim.newapi.IjVimEditor;
-import com.maddyhome.idea.vim.state.VimStateMachine;
-import com.maddyhome.idea.vim.state.mode.Mode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -438,11 +438,14 @@ public class FileGroup extends VimFileBase {
   private static final @NotNull Logger logger = Logger.getInstance(FileGroup.class.getName());
 
   /**
-   * Respond to editor tab selection and remember the last used tab
+   * This method listens for editor tab changes so any insert/replace modes that need to be reset can be.
    */
   public static void fileEditorManagerSelectionChangedCallback(@NotNull FileEditorManagerEvent event) {
+    // The user has changed the editor they are working with - exit insert/replace mode, and complete any
+    // appropriate repeat
     if (event.getOldFile() != null) {
       LastTabService.getInstance(event.getManager().getProject()).setLastTab(event.getOldFile());
     }
   }
 }
+

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

@@ -20,6 +20,7 @@ import com.maddyhome.idea.vim.options.OptionAccessScope
  */
 @Suppress("SpellCheckingInspection")
 public open class GlobalIjOptions(scope: OptionAccessScope) : OptionsPropertiesBase(scope) {
+  public var closenotebooks: Boolean by optionProperty(IjOptions.closenotebooks)
   public var ide: String by optionProperty(IjOptions.ide)
   public var ideamarks: Boolean by optionProperty(IjOptions.ideamarks)
   public var ideastatusicon: String by optionProperty(IjOptions.ideastatusicon)
@@ -30,13 +31,11 @@ public open class GlobalIjOptions(scope: OptionAccessScope) : OptionsPropertiesB
   public var visualdelay: Int by optionProperty(IjOptions.visualdelay)
 
   // Temporary options to control work-in-progress behaviour
-  public var closenotebooks: Boolean by optionProperty(IjOptions.closenotebooks)
-  public var commandOrMotionAnnotation: Boolean by optionProperty(IjOptions.commandOrMotionAnnotation)
-  public var exCommandAnnotation: Boolean by optionProperty(IjOptions.exCommandAnnotation)
   public var oldundo: Boolean by optionProperty(IjOptions.oldundo)
   public var unifyjumps: Boolean by optionProperty(IjOptions.unifyjumps)
-  public var useNewRegex: Boolean by optionProperty(IjOptions.useNewRegex)
+  public var exCommandAnnotation: Boolean by optionProperty(IjOptions.exCommandAnnotation)
   public var vimscriptFunctionAnnotation: Boolean by optionProperty(IjOptions.vimscriptFunctionAnnotation)
+  public var commandOrMotionAnnotation: Boolean by optionProperty(IjOptions.commandOrMotionAnnotation)
 }
 
 /**

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

@@ -33,6 +33,8 @@ public object IjOptions {
     Options.overrideDefaultValue(Options.clipboard, VimString("ideaput,autoselect,exclude:cons\\|linux"))
   }
 
+  public val closenotebooks: ToggleOption = addOption(ToggleOption("closenotebooks", GLOBAL, "closenotebooks", true))
+  public val exCommandAnnotation: ToggleOption = addOption(ToggleOption("excommandannotation", GLOBAL, "excommandannotation", true))
   public val ide: StringOption = addOption(
     StringOption("ide", GLOBAL, "ide", ApplicationNamesInfo.getInstance().fullProductNameWithEdition)
   )
@@ -79,16 +81,11 @@ public object IjOptions {
       "<Tab>,<Down>,<Up>,<Enter>,<Left>,<Right>,<C-Down>,<C-Up>,<PageUp>,<PageDown>,<C-J>,<C-Q>")
   )
   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))
-
-  // Temporary feature flags during development, not really intended for external use
-  public val closenotebooks: ToggleOption = addOption(ToggleOption("closenotebooks", GLOBAL, "closenotebooks", true, isHidden = true))
-  public val commandOrMotionAnnotation: ToggleOption = addOption(ToggleOption("commandormotionannotation", GLOBAL, "commandormotionannotation", true, isHidden = true))
-  public val exCommandAnnotation: ToggleOption = addOption(ToggleOption("excommandannotation", GLOBAL, "excommandannotation", true, isHidden = true))
-  public val oldundo: ToggleOption = addOption(ToggleOption("oldundo", GLOBAL, "oldundo", true, isHidden = true))
-  public val unifyjumps: ToggleOption = addOption(ToggleOption("unifyjumps", GLOBAL, "unifyjumps", true, isHidden = true))
-  public val useNewRegex: ToggleOption = addOption(ToggleOption("usenewregex", GLOBAL, "usenewregex", true, isHidden = true))
-  public val vimscriptFunctionAnnotation: ToggleOption = addOption(ToggleOption("vimscriptfunctionannotation", GLOBAL, "vimscriptfunctionannotation", true, isHidden = 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))
 
   // This needs to be Option<out VimDataType> so that it can work with derived option types, such as NumberOption, which
   // derives from Option<VimInt>

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

@@ -15,38 +15,38 @@ import com.maddyhome.idea.vim.statistic.VimscriptState
 internal class IjStatisticsService : VimStatistics {
 
   override fun logTrackedAction(actionId: String) {
-    ActionTracker.Util.logTrackedAction(actionId)
+    ActionTracker.logTrackedAction(actionId)
   }
 
   override fun logCopiedAction(actionId: String) {
-    ActionTracker.Util.logCopiedAction(actionId)
+    ActionTracker.logCopiedAction(actionId)
   }
 
   override fun setIfLoopUsed(value: Boolean) {
-    VimscriptState.Util.isLoopUsed = value
+    VimscriptState.isLoopUsed = value
   }
 
   override fun setIfMapExprUsed(value: Boolean) {
-    VimscriptState.Util.isMapExprUsed = value
+    VimscriptState.isMapExprUsed = value
   }
 
   override fun setIfFunctionCallUsed(value: Boolean) {
-    VimscriptState.Util.isFunctionCallUsed = value
+    VimscriptState.isFunctionCallUsed = value
   }
 
   override fun setIfFunctionDeclarationUsed(value: Boolean) {
-    VimscriptState.Util.isFunctionDeclarationUsed = value
+    VimscriptState.isFunctionDeclarationUsed = value
   }
 
   override fun setIfIfUsed(value: Boolean) {
-    VimscriptState.Util.isIfUsed = value
+    VimscriptState.isIfUsed = value
   }
 
   override fun addExtensionEnabledWithPlug(extension: String) {
-    VimscriptState.Util.extensionsEnabledWithPlug.add(extension)
+    VimscriptState.extensionsEnabledWithPlug.add(extension)
   }
 
   override fun addSourcedFile(path: String) {
-    VimscriptState.Util.sourcedFiles.add(path)
+    VimscriptState.sourcedFiles.add(path)
   }
 }

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

@@ -24,16 +24,17 @@ import com.intellij.openapi.keymap.KeymapManager;
 import com.intellij.openapi.keymap.ex.KeymapManagerEx;
 import com.maddyhome.idea.vim.EventFacade;
 import com.maddyhome.idea.vim.VimPlugin;
+import com.maddyhome.idea.vim.action.ComplicatedKeysAction;
 import com.maddyhome.idea.vim.action.VimShortcutKeyAction;
 import com.maddyhome.idea.vim.action.change.LazyVimCommand;
-import com.maddyhome.idea.vim.api.NativeAction;
-import com.maddyhome.idea.vim.api.VimEditor;
-import com.maddyhome.idea.vim.api.VimInjectorKt;
-import com.maddyhome.idea.vim.api.VimKeyGroupBase;
+import com.maddyhome.idea.vim.api.*;
 import com.maddyhome.idea.vim.command.MappingMode;
 import com.maddyhome.idea.vim.ex.ExOutputModel;
+import com.maddyhome.idea.vim.handler.EditorActionHandlerBase;
+import com.maddyhome.idea.vim.helper.HelperKt;
 import com.maddyhome.idea.vim.key.*;
 import com.maddyhome.idea.vim.newapi.IjNativeAction;
+import com.maddyhome.idea.vim.newapi.IjVimActionsInitiator;
 import com.maddyhome.idea.vim.newapi.IjVimEditor;
 import kotlin.Pair;
 import kotlin.text.StringsKt;
@@ -48,7 +49,6 @@ import java.awt.event.KeyEvent;
 import java.util.List;
 import java.util.*;
 
-import static com.maddyhome.idea.vim.api.VimInjectorKt.injector;
 import static java.util.stream.Collectors.toList;
 
 /**
@@ -101,9 +101,9 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
 
   @Override
   public void updateShortcutKeysRegistration() {
-    for (VimEditor editor : injector.getEditorGroup().getEditors()) {
-      unregisterShortcutKeys(editor);
-      registerRequiredShortcutKeys(editor);
+    for (Editor editor : HelperKt.localEditors()) {
+      unregisterShortcutKeys(new IjVimEditor(editor));
+      registerRequiredShortcutKeys(new IjVimEditor(editor));
     }
   }
 
@@ -221,20 +221,63 @@ public class KeyGroup extends VimKeyGroupBase implements PersistentStateComponen
       registerRequiredShortcut(keyStrokes, MappingOwner.IdeaVim.System.INSTANCE);
 
       for (MappingMode mappingMode : command.getModes()) {
-        Node<LazyVimCommand> node = getKeyRoot(mappingMode);
+        Node<VimActionsInitiator> node = getKeyRoot(mappingMode);
         NodesKt.addLeafs(node, keyStrokes, command);
       }
     }
   }
 
+  @Deprecated
+  public void registerCommandAction(@NotNull VimActionsInitiator actionHolder) {
+    IjVimActionsInitiator holder = (IjVimActionsInitiator)actionHolder;
+
+    if (!VimPlugin.getPluginId().equals(holder.getBean().getPluginDescriptor().getPluginId())) {
+      logger.error("IdeaVim doesn't accept contributions to `vimActions` extension points. " +
+                   "Please create a plugin using `VimExtension`. " +
+                   "Plugin to blame: " +
+                   holder.getBean().getPluginDescriptor().getPluginId());
+      return;
+    }
+
+    Set<List<KeyStroke>> actionKeys = holder.getBean().getParsedKeys();
+    if (actionKeys == null) {
+      final EditorActionHandlerBase action = actionHolder.getInstance();
+      if (action instanceof ComplicatedKeysAction) {
+        actionKeys = ((ComplicatedKeysAction)action).getKeyStrokesSet();
+      }
+      else {
+        throw new RuntimeException("Cannot register action: " + action.getClass().getName());
+      }
+    }
+
+    Set<MappingMode> actionModes = holder.getBean().getParsedModes();
+    if (actionModes == null) {
+      throw new RuntimeException("Cannot register action: " + holder.getBean().getImplementation());
+    }
+
+    if (ApplicationManager.getApplication().isUnitTestMode()) {
+      initIdentityChecker();
+      for (List<KeyStroke> keys : actionKeys) {
+        checkCommand(actionModes, actionHolder.getInstance(), keys);
+      }
+    }
+
+    for (List<KeyStroke> keyStrokes : actionKeys) {
+      registerRequiredShortcut(keyStrokes, MappingOwner.IdeaVim.System.INSTANCE);
+
+      for (MappingMode mappingMode : actionModes) {
+        Node<VimActionsInitiator> node = getKeyRoot(mappingMode);
+        NodesKt.addLeafs(node, keyStrokes, actionHolder);
+      }
+    }
+  }
+
   private void registerRequiredShortcut(@NotNull List<KeyStroke> keys, MappingOwner owner) {
     for (KeyStroke key : keys) {
-      if (key.getKeyChar() == KeyEvent.CHAR_UNDEFINED) {
-        if (!injector.getApplication().isOctopusEnabled() ||
-            !(key.getKeyCode() == KeyEvent.VK_ESCAPE && key.getModifiers() == 0) &&
-            !(key.getKeyCode() == KeyEvent.VK_ENTER && key.getModifiers() == 0)) {
-          getRequiredShortcutKeys().add(new RequiredShortcut(key, owner));
-        }
+      if (key.getKeyChar() == KeyEvent.CHAR_UNDEFINED &&
+          key.getKeyCode() != KeyEvent.VK_ESCAPE &&
+          key.getKeyCode() != KeyEvent.VK_ENTER) {
+        getRequiredShortcutKeys().add(new RequiredShortcut(key, owner));
       }
     }
   }

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

@@ -1,68 +0,0 @@
-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

@@ -7,10 +7,7 @@
  */
 package com.maddyhome.idea.vim.group
 
-import com.intellij.codeInsight.completion.CompletionPhase
-import com.intellij.codeInsight.completion.impl.CompletionServiceImpl
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.progress.ProgressManager
@@ -22,12 +19,10 @@ 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
  */
-@Service
 internal class MacroGroup : VimMacroBase() {
 
   // If it's null, this is the top macro (as in most cases). If it's not null, this macro is executed from top macro
@@ -66,37 +61,22 @@ internal class MacroGroup : VimMacroBase() {
     try {
       myPotemkinProgress.text2 = if (isInternalMacro) "Executing internal macro" else ""
       val runnable = runnable@{
-        try {
-          // Handle one keystroke then queue up the next key
-          for (i in 0 until total) {
+        // Handle one keystroke then queue up the next key
+        for (i in 0 until total) {
+          myPotemkinProgress.fraction = (i + 1).toDouble() / total
+          while (keyStack.hasStroke()) {
+            val key = keyStack.feedStroke()
             try {
-              myPotemkinProgress.fraction = (i + 1).toDouble() / total
-              while (keyStack.hasStroke()) {
-                val key = keyStack.feedStroke()
-                try {
-                  myPotemkinProgress.checkCanceled()
-                } catch (e: ProcessCanceledException) {
-                  return@runnable
-                }
-                val keyHandler = getInstance()
-                ProgressManager.getInstance().executeNonCancelableSection {
-                  // Prevent autocompletion during macros.
-                  // See https://github.com/JetBrains/ideavim/pull/772 for details
-                  CompletionServiceImpl.setCompletionPhase(CompletionPhase.NoCompletion)
-                  keyHandler.handleKey(editor, key, context, keyHandler.keyHandlerState)
-                }
-                if (injector.messages.isError()) return@runnable
-              }
-            } finally {
-              keyStack.resetFirst()
+              myPotemkinProgress.checkCanceled()
+            } catch (e: ProcessCanceledException) {
+              return@runnable
             }
+            ProgressManager.getInstance().executeNonCancelableSection { getInstance().handleKey(editor, key, context) }
+            if (injector.messages.isError()) return@runnable
           }
-        } finally {
-          keyStack.removeFirst()
-        }
-        if (!isInternalMacro) {
-          MacroAutoImport.run(editor.ij, context.ij)
+          keyStack.resetFirst()
         }
+        keyStack.removeFirst()
       }
 
       if (isInternalMacro) {

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

@@ -0,0 +1,138 @@
+/*
+ * 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.group;
+
+import com.intellij.ide.bookmark.LineBookmark;
+import com.intellij.openapi.editor.Editor;
+import com.maddyhome.idea.vim.api.*;
+import com.maddyhome.idea.vim.common.TextRange;
+import com.maddyhome.idea.vim.mark.IntellijMark;
+import com.maddyhome.idea.vim.mark.Jump;
+import com.maddyhome.idea.vim.mark.Mark;
+import com.maddyhome.idea.vim.newapi.IjVimEditor;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+@Deprecated
+@ApiStatus.ScheduledForRemoval(inVersion = "2.3")
+public class MarkGroup {
+  public List<Jump> jumps = VimInjectorKt.injector.getJumpService().getJumps("");
+
+  public void saveJumpLocation(@NotNull Editor editor) {
+    VimInjectorKt.injector.getJumpService().saveJumpLocation(new IjVimEditor(editor));
+  }
+
+  public void saveJumpLocation(@NotNull VimEditor editor) {
+    VimInjectorKt.injector.getJumpService().saveJumpLocation(editor);
+  }
+
+  public void setChangeMarks(@NotNull VimEditor vimEditor, @NotNull TextRange range) {
+    VimMarkService markService = VimInjectorKt.injector.getMarkService();
+    VimMarkServiceKt.setChangeMarks(markService, vimEditor.primaryCaret(), range);
+  }
+
+  public void addJump(@NotNull VimEditor editor, boolean reset) {
+    VimJumpServiceKt.addJump(VimInjectorKt.injector.getJumpService(), editor, reset);
+  }
+
+  @Nullable
+  public Mark getMark(@NotNull VimEditor editor, char ch) {
+    return VimInjectorKt.injector.getMarkService().getMark(editor.primaryCaret(), ch);
+  }
+
+  @Nullable
+  public Jump getJump(int count) {
+    return VimInjectorKt.injector.getJumpService().getJump("", count);
+  }
+
+  @Nullable
+  public Mark createSystemMark(char ch, int line, int col, @NotNull VimEditor editor) {
+    Editor ijEditor = ((IjVimEditor)editor).getEditor();
+    @Nullable LineBookmark systemMark = SystemMarks.createOrGetSystemMark(ch, line, ijEditor);
+    if (systemMark == null) {
+      return null;
+    }
+    return new IntellijMark(systemMark, col, ijEditor.getProject());
+  }
+
+  public boolean setMark(@NotNull VimEditor editor, char ch, int offset) {
+    return VimInjectorKt.injector.getMarkService().setMark(editor.primaryCaret(), ch, offset);
+  }
+
+  public boolean setMark(@NotNull VimEditor editor, char ch) {
+    return VimInjectorKt.injector.getMarkService().setMark(editor, ch);
+  }
+
+  public void includeCurrentCommandAsNavigation(@NotNull VimEditor editor) {
+    VimInjectorKt.injector.getJumpService().includeCurrentCommandAsNavigation(editor);
+  }
+
+  @Nullable
+  public Mark getFileMark(@NotNull VimEditor editor, char ch) {
+    return VimInjectorKt.injector.getMarkService().getMark(editor.primaryCaret(), ch);
+  }
+
+  public void setVisualSelectionMarks(@NotNull VimEditor editor, @NotNull TextRange range) {
+    VimMarkService markService = VimInjectorKt.injector.getMarkService();
+    VimMarkServiceKt.setVisualSelectionMarks(markService, editor.primaryCaret(), range);
+  }
+
+  @Nullable
+  public TextRange getChangeMarks(@NotNull VimEditor editor) {
+    return VimInjectorKt.injector.getMarkService().getChangeMarks(editor.primaryCaret());
+  }
+
+  @Nullable
+  public TextRange getVisualSelectionMarks(@NotNull VimEditor editor) {
+    return VimInjectorKt.injector.getMarkService().getVisualSelectionMarks(editor.primaryCaret());
+  }
+
+  public void resetAllMarks() {
+    VimInjectorKt.injector.getMarkService().resetAllMarks();
+  }
+
+  public void removeMark(char ch, @NotNull Mark mark) {
+    VimInjectorKt.injector.getMarkService().removeMark(ch, mark);
+  }
+
+  @NotNull
+  public List<Mark> getMarks(@NotNull VimEditor editor) {
+    Set<Mark> marks = VimInjectorKt.injector.getMarkService().getAllLocalMarks(editor.primaryCaret());
+    marks.addAll(VimInjectorKt.injector.getMarkService().getGlobalMarks(editor));
+    return new ArrayList<>(marks);
+  }
+
+  public int getJumpSpot() {
+    return VimInjectorKt.injector.getJumpService().getJumpSpot("");
+  }
+
+  public void updateMarkFromDelete(@Nullable VimEditor editor,
+                                   @Nullable HashMap<Character, Mark> marks,
+                                   int delStartOff,
+                                   int delLength) {
+    VimInjectorKt.injector.getMarkService().updateMarksFromDelete(editor, delStartOff, delLength);
+  }
+
+  public void updateMarkFromInsert(@Nullable VimEditor editor,
+                                   @Nullable HashMap<Character, Mark> marks,
+                                   int insStartOff,
+                                   int insLength) {
+    VimInjectorKt.injector.getMarkService().updateMarksFromInsert(editor, insStartOff, insLength);
+  }
+
+  public void dropLastJump() {
+    VimInjectorKt.injector.getJumpService().dropLastJump("");
+  }
+}

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

@@ -8,7 +8,6 @@
 package com.maddyhome.idea.vim.group
 
 import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.components.Service
 import com.intellij.openapi.editor.Caret
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.LogicalPosition
@@ -49,7 +48,9 @@ import com.maddyhome.idea.vim.api.options
 import com.maddyhome.idea.vim.api.visualLineToBufferLine
 import com.maddyhome.idea.vim.command.Argument
 import com.maddyhome.idea.vim.command.MotionType
+import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.command.OperatorArguments
+import com.maddyhome.idea.vim.state.VimStateMachine
 import com.maddyhome.idea.vim.common.TextRange
 import com.maddyhome.idea.vim.ex.ExOutputModel
 import com.maddyhome.idea.vim.handler.Motion
@@ -73,8 +74,6 @@ 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.state.VimStateMachine
-import com.maddyhome.idea.vim.state.mode.Mode
 import com.maddyhome.idea.vim.ui.ex.ExEntryPanel
 import org.jetbrains.annotations.Range
 import java.io.File
@@ -84,7 +83,6 @@ import kotlin.math.min
 /**
  * This handles all motion related commands and marks
  */
-@Service
 internal class MotionGroup : VimMotionGroupBase() {
   override fun onAppCodeMovement(editor: VimEditor, caret: VimCaret, offset: Int, oldOffset: Int) {
     AppCodeTemplates.onMovement(editor.ij, caret.ij, oldOffset < offset)
@@ -463,13 +461,11 @@ internal class MotionGroup : VimMotionGroupBase() {
       val fileEditor = event.oldEditor
       if (fileEditor is TextEditor) {
         val editor = fileEditor.editor
-        if (!editor.isDisposed) {
-          ExOutputModel.getInstance(editor).clear()
-          editor.vim.let { vimEditor ->
-            if (VimStateMachine.getInstance(vimEditor).mode is Mode.VISUAL) {
-              vimEditor.exitVisualMode()
-              KeyHandler.getInstance().reset(vimEditor)
-            }
+        ExOutputModel.getInstance(editor).clear()
+        editor.vim.let { vimEditor ->
+          if (VimStateMachine.getInstance(vimEditor).mode is Mode.VISUAL) {
+            vimEditor.exitVisualMode()
+            KeyHandler.getInstance().reset(vimEditor)
           }
         }
       }

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

@@ -21,12 +21,8 @@ import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.KeyboardShortcut
-import com.intellij.openapi.components.Service
-import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.ide.CopyPasteManager
 import com.intellij.openapi.keymap.KeymapUtil
-import com.intellij.openapi.keymap.ex.KeymapManagerEx
-import com.intellij.openapi.keymap.impl.ui.KeymapPanel
 import com.intellij.openapi.options.ShowSettingsUtil
 import com.intellij.openapi.project.DumbAwareAction
 import com.intellij.openapi.project.Project
@@ -36,7 +32,6 @@ import com.maddyhome.idea.vim.VimPlugin
 import com.maddyhome.idea.vim.api.VimEditor
 import com.maddyhome.idea.vim.api.globalOptions
 import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.handler.KeyMapIssue
 import com.maddyhome.idea.vim.helper.MessageHelper
 import com.maddyhome.idea.vim.key.ShortcutOwner
 import com.maddyhome.idea.vim.key.ShortcutOwnerInfo
@@ -56,7 +51,6 @@ import javax.swing.KeyStroke
  * This service is can be used as application level and as project level service.
  * If project is null, this means that this is an application level service and notification will be shown for all projects
  */
-@Service(Service.Level.PROJECT, Service.Level.APP)
 internal class NotificationService(private val project: Project?) {
   // This constructor is used to create an applicationService
   @Suppress("unused")
@@ -186,77 +180,6 @@ internal class NotificationService(private val project: Project?) {
     ActionIdNotifier.notifyActionId(id, project)
   }
 
-  fun notifyKeymapIssues(issues: ArrayList<KeyMapIssue>) {
-    val keymapManager = KeymapManagerEx.getInstanceEx()
-    val keymap = keymapManager.activeKeymap
-    val message = buildString {
-      appendLine("Current IDE keymap (${keymap.name}) has issues:<br/>")
-      issues.forEach {
-        when (it) {
-          is KeyMapIssue.AddShortcut -> {
-            appendLine("- ${it.key} key is not assigned to the ${it.action} action.<br/>")
-          }
-          is KeyMapIssue.RemoveShortcut -> {
-            appendLine("- ${it.shortcut} key is incorrectly assigned to the ${it.action} action.<br/>")
-          }
-        }
-      }
-    }
-    val notification = IDEAVIM_STICKY_GROUP.createNotification(
-      IDEAVIM_NOTIFICATION_TITLE,
-      message,
-      NotificationType.ERROR,
-    )
-    notification.subtitle = "IDE keymap misconfigured"
-    notification.addAction(object : DumbAwareAction("Fix Keymap") {
-      override fun actionPerformed(e: AnActionEvent) {
-        issues.forEach {
-          when (it) {
-            is KeyMapIssue.AddShortcut -> {
-              keymap.addShortcut(it.actionId, KeyboardShortcut(it.keyStroke, null))
-            }
-
-            is KeyMapIssue.RemoveShortcut -> {
-              keymap.removeShortcut(it.actionId, it.shortcut)
-            }
-          }
-        }
-        LOG.info("Shortcuts updated $issues")
-        notification.expire()
-        requiredShortcutsAssigned()
-      }
-    })
-    notification.addAction(object : DumbAwareAction("Open Keymap Settings") {
-      override fun actionPerformed(e: AnActionEvent) {
-        ShowSettingsUtil.getInstance().showSettingsDialog(e.project, KeymapPanel::class.java)
-        notification.hideBalloon()
-      }
-    })
-    notification.addAction(object : DumbAwareAction("Ignore") {
-      override fun actionPerformed(e: AnActionEvent) {
-        LOG.info("Ignored to update shortcuts $issues")
-        notification.hideBalloon()
-      }
-    })
-    notification.notify(project)
-  }
-
-  private fun requiredShortcutsAssigned() {
-    val notification = Notification(
-      IDEAVIM_NOTIFICATION_ID,
-      IDEAVIM_NOTIFICATION_TITLE,
-      "Keymap fixed",
-      NotificationType.INFORMATION,
-    )
-    notification.addAction(object : DumbAwareAction("Open Keymap Settings") {
-      override fun actionPerformed(e: AnActionEvent) {
-        ShowSettingsUtil.getInstance().showSettingsDialog(e.project, KeymapPanel::class.java)
-        notification.hideBalloon()
-      }
-    })
-    notification.notify(project)
-  }
-
   object ActionIdNotifier {
     private var notification: Notification? = null
     private const val NO_ID = "<i>Cannot detect action id</i>"
@@ -278,7 +201,7 @@ internal class NotificationService(private val project: Project?) {
       }
 
       if (id != null) {
-        ActionTracker.Util.logTrackedAction(id)
+        ActionTracker.logTrackedAction(id)
       }
     }
 
@@ -286,7 +209,7 @@ internal class NotificationService(private val project: Project?) {
       override fun actionPerformed(e: AnActionEvent) {
         CopyPasteManager.getInstance().setContents(StringSelection(id ?: ""))
         if (id != null) {
-          ActionTracker.Util.logCopiedAction(id)
+          ActionTracker.logCopiedAction(id)
         }
         notification?.expire()
 
@@ -391,8 +314,6 @@ internal class NotificationService(private val project: Project?) {
     const val IDEAVIM_NOTIFICATION_TITLE = "IdeaVim"
     const val ideajoinExamplesUrl = "https://jb.gg/f9zji9"
 
-    private val LOG = logger<NotificationService>()
-
     private fun createIdeaVimRcManually(message: String, project: Project?) {
       val notification =
         Notification(IDEAVIM_NOTIFICATION_ID, IDEAVIM_NOTIFICATION_TITLE, message, NotificationType.WARNING)

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

@@ -40,6 +40,10 @@ internal class OptionGroup : VimOptionGroupBase(), IjVimOptionGroup {
   override fun getGlobalIjOptions() = GlobalIjOptions(OptionAccessScope.GLOBAL(null))
   override fun getEffectiveIjOptions(editor: VimEditor) = EffectiveIjOptions(OptionAccessScope.EFFECTIVE(editor))
 
+  private fun updateFallbackWindow(fallbackWindow: VimEditor, targetEditor: VimEditor) {
+    copyPerWindowGlobalValues(fallbackWindow, targetEditor)
+  }
+
   companion object {
     fun fileEditorManagerSelectionChangedCallback(event: FileEditorManagerEvent) {
       // Vim only has one window, and it's not possible to close it. This means that editing a new file will always
@@ -54,8 +58,6 @@ internal class OptionGroup : VimOptionGroupBase(), IjVimOptionGroup {
       // Unfortunately, we can't reliably know if a closing editor is the selected editor. Instead, we rely on selection
       // change events. If an editor is losing selection and there is no new selection, we can assume this means that
       // the last editor has been closed, and use the closed editor to update the fallback window
-      //
-      // XXX: event.oldEditor will must probably return a disposed editor. So, it should be treated with care
       if (event.newEditor == null) {
         (event.oldEditor as? TextEditor)?.editor?.let {
           (VimPlugin.getOptionGroup() as OptionGroup).updateFallbackWindow(injector.fallbackWindow, it.vim)
@@ -65,28 +67,28 @@ internal class OptionGroup : VimOptionGroupBase(), IjVimOptionGroup {
   }
 }
 
-public class IjOptionConstants {
-  @Suppress("SpellCheckingInspection", "MemberVisibilityCanBePrivate", "ConstPropertyName")
-  public companion object {
+internal class IjOptionConstants {
+  @Suppress("SpellCheckingInspection", "MemberVisibilityCanBePrivate")
+  companion object {
 
-    public const val idearefactormode_keep: String = "keep"
-    public const val idearefactormode_select: String = "select"
-    public const val idearefactormode_visual: String = "visual"
+    const val idearefactormode_keep = "keep"
+    const val idearefactormode_select = "select"
+    const val idearefactormode_visual = "visual"
 
-    public const val ideastatusicon_enabled: String = "enabled"
-    public const val ideastatusicon_gray: String = "gray"
-    public const val ideastatusicon_disabled: String = "disabled"
+    const val ideastatusicon_enabled = "enabled"
+    const val ideastatusicon_gray = "gray"
+    const val ideastatusicon_disabled = "disabled"
 
-    public const val ideavimsupport_dialog: String = "dialog"
-    public const val ideavimsupport_singleline: String = "singleline"
-    public const val ideavimsupport_dialoglegacy: String = "dialoglegacy"
+    const val ideavimsupport_dialog = "dialog"
+    const val ideavimsupport_singleline = "singleline"
+    const val ideavimsupport_dialoglegacy = "dialoglegacy"
 
-    public const val ideawrite_all: String = "all"
-    public const val ideawrite_file: String = "file"
+    const val ideawrite_all = "all"
+    const val ideawrite_file = "file"
 
-    public val ideaStatusIconValues: Set<String> = setOf(ideastatusicon_enabled, ideastatusicon_gray, ideastatusicon_disabled)
-    public val ideaRefactorModeValues: Set<String> = setOf(idearefactormode_keep, idearefactormode_select, idearefactormode_visual)
-    public val ideaWriteValues: Set<String> = setOf(ideawrite_all, ideawrite_file)
-    public val ideavimsupportValues: Set<String> = setOf(ideavimsupport_dialog, ideavimsupport_singleline, ideavimsupport_dialoglegacy)
+    val ideaStatusIconValues = setOf(ideastatusicon_enabled, ideastatusicon_gray, ideastatusicon_disabled)
+    val ideaRefactorModeValues = setOf(idearefactormode_keep, idearefactormode_select, idearefactormode_visual)
+    val ideaWriteValues = setOf(ideawrite_all, ideawrite_file)
+    val ideavimsupportValues = setOf(ideavimsupport_dialog, ideavimsupport_singleline, ideavimsupport_dialoglegacy)
   }
 }

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

@@ -0,0 +1,285 @@
+/*
+ * 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.group;
+
+import com.intellij.execution.ExecutionException;
+import com.intellij.execution.configurations.GeneralCommandLine;
+import com.intellij.execution.process.CapturingProcessHandler;
+import com.intellij.execution.process.ProcessAdapter;
+import com.intellij.execution.process.ProcessEvent;
+import com.intellij.execution.process.ProcessOutput;
+import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.progress.ProcessCanceledException;
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.progress.ProgressIndicatorProvider;
+import com.intellij.openapi.progress.ProgressManager;
+import com.intellij.util.execution.ParametersListUtil;
+import com.intellij.util.text.CharSequenceReader;
+import com.maddyhome.idea.vim.KeyHandler;
+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.VimInjectorKt;
+import com.maddyhome.idea.vim.api.VimProcessGroupBase;
+import com.maddyhome.idea.vim.command.Command;
+import com.maddyhome.idea.vim.state.mode.Mode;
+import com.maddyhome.idea.vim.state.VimStateMachine;
+import com.maddyhome.idea.vim.ex.ExException;
+import com.maddyhome.idea.vim.ex.InvalidCommandException;
+import com.maddyhome.idea.vim.helper.UiHelper;
+import com.maddyhome.idea.vim.newapi.IjEditorExecutionContext;
+import com.maddyhome.idea.vim.newapi.IjVimEditor;
+import com.maddyhome.idea.vim.ui.ex.ExEntryPanel;
+import com.maddyhome.idea.vim.vimscript.model.CommandLineVimLContext;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.io.*;
+import java.util.ArrayList;
+
+import static com.maddyhome.idea.vim.api.VimInjectorKt.globalOptions;
+import static com.maddyhome.idea.vim.api.VimInjectorKt.injector;
+
+
+public class ProcessGroup extends VimProcessGroupBase {
+  public String getLastCommand() {
+    return lastCommand;
+  }
+
+  @Override
+  public void startSearchCommand(@NotNull VimEditor editor, ExecutionContext context, int count, char leader) {
+    if (((IjVimEditor)editor).getEditor().isOneLineMode()) // Don't allow searching in one line editors
+    {
+      return;
+    }
+
+    String initText = "";
+    String label = String.valueOf(leader);
+
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    panel.activate(((IjVimEditor)editor).getEditor(), ((DataContext)context.getContext()), label, initText, count);
+  }
+
+  @Override
+  public @NotNull String endSearchCommand() {
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    panel.deactivate(true);
+
+    return panel.getText();
+  }
+
+  public void startExCommand(@NotNull VimEditor editor, ExecutionContext context, @NotNull Command cmd) {
+    // Don't allow ex commands in one line editors
+    if (editor.isOneLineMode()) return;
+
+    String initText = getRange(((IjVimEditor) editor).getEditor(), cmd);
+    injector.getMarkService().setVisualSelectionMarks(editor);
+    VimStateMachine.Companion.getInstance(editor).setMode(Mode.CMD_LINE.INSTANCE);
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    panel.activate(((IjVimEditor) editor).getEditor(), ((IjEditorExecutionContext) context).getContext(), ":", initText, 1);
+  }
+
+  @Override
+  public boolean processExKey(@NotNull VimEditor editor, @NotNull KeyStroke stroke) {
+    // This will only get called if somehow the key focus ended up in the editor while the ex entry window
+    // is open. So I'll put focus back in the editor and process the key.
+
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    if (panel.isActive()) {
+      UiHelper.requestFocus(panel.getEntry());
+      panel.handleKey(stroke);
+
+      return true;
+    }
+    else {
+      VimStateMachine.Companion.getInstance(editor).setMode(new Mode.NORMAL());
+      KeyHandler.getInstance().reset(editor);
+      return false;
+    }
+  }
+
+  public boolean processExEntry(final @NotNull VimEditor editor, final @NotNull ExecutionContext context) {
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    panel.deactivate(true);
+    boolean res = true;
+    try {
+      VimStateMachine.Companion.getInstance(editor).setMode(new Mode.NORMAL());
+
+      logger.debug("processing command");
+
+      final String text = panel.getText();
+
+      if (!panel.getLabel().equals(":")) {
+        // Search is handled via Argument.Type.EX_STRING. Although ProcessExEntryAction is registered as the handler for
+        // <CR> in both command and search modes, it's only invoked for command mode (see KeyHandler.handleCommandNode).
+        // We should never be invoked for anything other than an actual ex command.
+        throw new InvalidCommandException("Expected ':' command. Got '" + panel.getLabel() + "'", text);
+      }
+
+      if (logger.isDebugEnabled()) logger.debug("swing=" + SwingUtilities.isEventDispatchThread());
+
+      VimInjectorKt.getInjector().getVimscriptExecutor().execute(text, editor, context, skipHistory(editor), true, CommandLineVimLContext.INSTANCE);
+    }
+    catch (ExException e) {
+      VimPlugin.showMessage(e.getMessage());
+      VimPlugin.indicateError();
+      res = false;
+    }
+    catch (Exception bad) {
+      ProcessGroup.logger.error(bad);
+      VimPlugin.indicateError();
+      res = false;
+    }
+
+    return res;
+  }
+
+  // commands executed from map command / macro should not be added to history
+  private boolean skipHistory(VimEditor editor) {
+    return VimStateMachine.Companion.getInstance(editor).getMappingState().isExecutingMap() || injector.getMacro().isExecutingMacro();
+  }
+
+  public void cancelExEntry(final @NotNull VimEditor editor, boolean resetCaret) {
+    VimStateMachine.Companion.getInstance(editor).setMode(new Mode.NORMAL());
+    KeyHandler.getInstance().reset(editor);
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    panel.deactivate(true, resetCaret);
+  }
+
+  @Override
+  public void startFilterCommand(@NotNull VimEditor editor, ExecutionContext context, @NotNull Command cmd) {
+    String initText = getRange(((IjVimEditor) editor).getEditor(), cmd) + "!";
+    VimStateMachine.Companion.getInstance(editor).setMode(Mode.CMD_LINE.INSTANCE);
+    ExEntryPanel panel = ExEntryPanel.getInstance();
+    panel.activate(((IjVimEditor) editor).getEditor(), ((IjEditorExecutionContext) context).getContext(), ":", initText, 1);
+  }
+
+  private @NotNull String getRange(Editor editor, @NotNull Command cmd) {
+    String initText = "";
+    if (VimStateMachine.Companion.getInstance(new IjVimEditor(editor)).getMode() instanceof Mode.VISUAL) {
+      initText = "'<,'>";
+    }
+    else if (cmd.getRawCount() > 0) {
+      if (cmd.getCount() == 1) {
+        initText = ".";
+      }
+      else {
+        initText = ".,.+" + (cmd.getCount() - 1);
+      }
+    }
+
+    return initText;
+  }
+
+  public @Nullable String executeCommand(@NotNull VimEditor editor, @NotNull String command, @Nullable CharSequence input, @Nullable String currentDirectoryPath)
+    throws ExecutionException, ProcessCanceledException {
+
+    // This is a much simplified version of how Vim does this. We're using stdin/stdout directly, while Vim will
+    // redirect to temp files ('shellredir' and 'shelltemp') or use pipes. We don't support 'shellquote', because we're
+    // not handling redirection, but we do use 'shellxquote' and 'shellxescape', because these have defaults that work
+    // better with Windows. We also don't bother using ShellExecute for Windows commands beginning with `start`.
+    // Finally, we're also not bothering with the crazy space and backslash handling of the 'shell' options content.
+    return ProgressManager.getInstance().runProcessWithProgressSynchronously(() -> {
+
+      final String shell = globalOptions(injector).getShell();
+      final String shellcmdflag = globalOptions(injector).getShellcmdflag();
+      final String shellxescape = globalOptions(injector).getShellxescape();
+      final String shellxquote = globalOptions(injector).getShellxquote();
+
+      // For Win32. See :help 'shellxescape'
+      final String escapedCommand = shellxquote.equals("(")
+                                    ? doEscape(command, shellxescape, "^")
+                                    : command;
+      // Required for Win32+cmd.exe, defaults to "(". See :help 'shellxquote'
+      final String quotedCommand = shellxquote.equals("(")
+                                   ? "(" + escapedCommand + ")"
+                                   : (shellxquote.equals("\"(")
+                                      ? "\"(" + escapedCommand + ")\""
+                                      : shellxquote + escapedCommand + shellxquote);
+
+      final ArrayList<String> commands = new ArrayList<>();
+      commands.add(shell);
+      if (!shellcmdflag.isEmpty()) {
+        // Note that Vim also does a simple whitespace split for multiple parameters
+        commands.addAll(ParametersListUtil.parse(shellcmdflag));
+      }
+      commands.add(quotedCommand);
+
+      if (logger.isDebugEnabled()) {
+        logger.debug(String.format("shell=%s shellcmdflag=%s command=%s", shell, shellcmdflag, quotedCommand));
+      }
+
+      final GeneralCommandLine commandLine = new GeneralCommandLine(commands);
+      if (currentDirectoryPath != null) {
+        commandLine.setWorkDirectory(currentDirectoryPath);
+      }
+      final CapturingProcessHandler handler = new CapturingProcessHandler(commandLine);
+      if (input != null) {
+        handler.addProcessListener(new ProcessAdapter() {
+          @Override
+          public void startNotified(@NotNull ProcessEvent event) {
+            try {
+              final CharSequenceReader charSequenceReader = new CharSequenceReader(input);
+              final BufferedWriter outputStreamWriter = new BufferedWriter(new OutputStreamWriter(handler.getProcessInput()));
+              copy(charSequenceReader, outputStreamWriter);
+              outputStreamWriter.close();
+            }
+            catch (IOException e) {
+              logger.error(e);
+            }
+          }
+        });
+      }
+
+      final ProgressIndicator progressIndicator = ProgressIndicatorProvider.getInstance().getProgressIndicator();
+      final ProcessOutput output = handler.runProcessWithProgressIndicator(progressIndicator);
+
+      lastCommand = command;
+
+      if (output.isCancelled()) {
+        // TODO: Vim will use whatever text has already been written to stdout
+        // For whatever reason, we're not getting any here, so just throw an exception
+        throw new ProcessCanceledException();
+      }
+
+      final Integer exitCode = handler.getExitCode();
+      if (exitCode != null && exitCode != 0) {
+        VimPlugin.showMessage("shell returned " + exitCode);
+        VimPlugin.indicateError();
+      }
+
+      // Get stderr; stdout and strip colors, which are not handles properly.
+      return (output.getStderr() + output.getStdout()).replaceAll("\u001B\\[[;\\d]*m", "");
+    }, "IdeaVim - !" + command, true, ((IjVimEditor) editor).getEditor().getProject());
+  }
+
+  private String doEscape(String original, String charsToEscape, String escapeChar) {
+    String result = original;
+    for (char c : charsToEscape.toCharArray()) {
+      result = result.replace("" + c, escapeChar + c);
+    }
+    return result;
+  }
+
+  // TODO: Java 10 has a transferTo method we could use instead
+  private void copy(@NotNull Reader from, @NotNull Writer to) throws IOException {
+    char[] buf = new char[2048];
+    int cnt;
+    while ((cnt = from.read(buf)) != -1) {
+      to.write(buf, 0, cnt);
+    }
+  }
+
+  private String lastCommand;
+
+  private static final Logger logger = Logger.getInstance(ProcessGroup.class.getName());
+}

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

@@ -1,291 +0,0 @@
-/*
- * 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.group
-
-import com.intellij.execution.ExecutionException
-import com.intellij.execution.configurations.GeneralCommandLine
-import com.intellij.execution.process.CapturingProcessHandler
-import com.intellij.execution.process.ProcessAdapter
-import com.intellij.execution.process.ProcessEvent
-import com.intellij.openapi.diagnostic.debug
-import com.intellij.openapi.diagnostic.logger
-import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.openapi.progress.ProgressIndicatorProvider
-import com.intellij.openapi.progress.ProgressManager
-import com.intellij.util.execution.ParametersListUtil
-import com.intellij.util.text.CharSequenceReader
-import com.maddyhome.idea.vim.KeyHandler.Companion.getInstance
-import com.maddyhome.idea.vim.KeyProcessResult
-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.VimProcessGroupBase
-import com.maddyhome.idea.vim.api.globalOptions
-import com.maddyhome.idea.vim.api.injector
-import com.maddyhome.idea.vim.command.Command
-import com.maddyhome.idea.vim.ex.ExException
-import com.maddyhome.idea.vim.ex.InvalidCommandException
-import com.maddyhome.idea.vim.helper.requestFocus
-import com.maddyhome.idea.vim.helper.vimStateMachine
-import com.maddyhome.idea.vim.newapi.ij
-import com.maddyhome.idea.vim.state.VimStateMachine.Companion.getInstance
-import com.maddyhome.idea.vim.state.mode.Mode
-import com.maddyhome.idea.vim.state.mode.Mode.NORMAL
-import com.maddyhome.idea.vim.state.mode.Mode.VISUAL
-import com.maddyhome.idea.vim.state.mode.ReturnableFromCmd
-import com.maddyhome.idea.vim.ui.ex.ExEntryPanel
-import com.maddyhome.idea.vim.vimscript.model.CommandLineVimLContext
-import java.io.BufferedWriter
-import java.io.IOException
-import java.io.OutputStreamWriter
-import java.io.Reader
-import java.io.Writer
-import javax.swing.KeyStroke
-import javax.swing.SwingUtilities
-
-public class ProcessGroup : VimProcessGroupBase() {
-  override var lastCommand: String? = null
-    private set
-  override var isCommandProcessing: Boolean = false
-  override var modeBeforeCommandProcessing: Mode? = null
-
-  public override fun startSearchCommand(editor: VimEditor, context: ExecutionContext, count: Int, leader: Char) {
-    // Don't allow searching in one line editors
-    if (editor.isOneLineMode()) return
-
-    val initText = ""
-    val label = leader.toString()
-
-    val panel = ExEntryPanel.getInstance()
-    panel.activate(editor.ij, context.ij, label, initText, count)
-  }
-
-  public override fun endSearchCommand(): String {
-    val panel = ExEntryPanel.getInstance()
-    panel.deactivate(true)
-
-    return panel.text
-  }
-
-  public override fun startExCommand(editor: VimEditor, context: ExecutionContext, cmd: Command) {
-    // Don't allow ex commands in one line editors
-    if (editor.isOneLineMode()) return
-
-    val currentMode = editor.vimStateMachine.mode
-    check(currentMode is ReturnableFromCmd) {
-      "Cannot enable cmd mode from current mode $currentMode"
-    }
-
-    isCommandProcessing = true
-    modeBeforeCommandProcessing = currentMode
-    val initText = getRange(editor, cmd)
-    injector.markService.setVisualSelectionMarks(editor)
-    editor.mode = Mode.CMD_LINE(currentMode)
-    val panel = ExEntryPanel.getInstance()
-    panel.activate(editor.ij, context.ij, ":", initText, 1)
-  }
-
-  public override fun processExKey(editor: VimEditor, stroke: KeyStroke, processResultBuilder: KeyProcessResult.KeyProcessResultBuilder): Boolean {
-    // This will only get called if somehow the key focus ended up in the editor while the ex entry window
-    // is open. So I'll put focus back in the editor and process the key.
-
-    val panel = ExEntryPanel.getInstance()
-    if (panel.isActive) {
-      processResultBuilder.addExecutionStep { _, _, _ ->
-        requestFocus(panel.entry)
-        panel.handleKey(stroke)
-      }
-      return true
-    } else {
-      processResultBuilder.addExecutionStep { _, lambdaEditor, _ ->
-        lambdaEditor.mode = NORMAL()
-        getInstance().reset(lambdaEditor)
-      }
-      return false
-    }
-  }
-
-  public override fun processExEntry(editor: VimEditor, context: ExecutionContext): Boolean {
-    val panel = ExEntryPanel.getInstance()
-    panel.deactivate(true)
-    var res = true
-    try {
-      editor.mode = NORMAL()
-
-      logger.debug("processing command")
-
-      val text = panel.text
-
-      if (panel.label != ":") {
-        // Search is handled via Argument.Type.EX_STRING. Although ProcessExEntryAction is registered as the handler for
-        // <CR> in both command and search modes, it's only invoked for command mode (see KeyHandler.handleCommandNode).
-        // We should never be invoked for anything other than an actual ex command.
-        throw InvalidCommandException("Expected ':' command. Got '" + panel.label + "'", text)
-      }
-
-      logger.debug {
-        "swing=" + SwingUtilities.isEventDispatchThread()
-      }
-
-      injector.vimscriptExecutor.execute(text, editor, context, skipHistory(editor), true, CommandLineVimLContext)
-    } catch (e: ExException) {
-      VimPlugin.showMessage(e.message)
-      VimPlugin.indicateError()
-      res = false
-    } catch (bad: Exception) {
-      logger.error(bad)
-      VimPlugin.indicateError()
-      res = false
-    } finally {
-      isCommandProcessing = false
-      modeBeforeCommandProcessing = null
-    }
-
-    return res
-  }
-
-  // commands executed from map command / macro should not be added to history
-  private fun skipHistory(editor: VimEditor): Boolean {
-    return getInstance(editor).mappingState.isExecutingMap() || injector.macro.isExecutingMacro
-  }
-
-  public override fun cancelExEntry(editor: VimEditor, resetCaret: Boolean) {
-    editor.mode = NORMAL()
-    getInstance().reset(editor)
-    val panel = ExEntryPanel.getInstance()
-    panel.deactivate(true, resetCaret)
-  }
-
-  public override fun startFilterCommand(editor: VimEditor, context: ExecutionContext, cmd: Command) {
-    val initText = getRange(editor, cmd) + "!"
-    val currentMode = editor.mode
-    check(currentMode is ReturnableFromCmd) { "Cannot enable cmd mode from $currentMode" }
-    editor.mode = Mode.CMD_LINE(currentMode)
-    val panel = ExEntryPanel.getInstance()
-    panel.activate(editor.ij, context.ij, ":", initText, 1)
-  }
-
-  private fun getRange(editor: VimEditor, cmd: Command): String {
-    var initText = ""
-    if (editor.vimStateMachine.mode is VISUAL) {
-      initText = "'<,'>"
-    } else if (cmd.rawCount > 0) {
-      initText = if (cmd.count == 1) {
-        "."
-      } else {
-        ".,.+" + (cmd.count - 1)
-      }
-    }
-
-    return initText
-  }
-
-  @Throws(ExecutionException::class, ProcessCanceledException::class)
-  public override fun executeCommand(
-    editor: VimEditor,
-    command: String,
-    input: CharSequence?,
-    currentDirectoryPath: String?
-  ): String? {
-    // This is a much simplified version of how Vim does this. We're using stdin/stdout directly, while Vim will
-    // redirect to temp files ('shellredir' and 'shelltemp') or use pipes. We don't support 'shellquote', because we're
-    // not handling redirection, but we do use 'shellxquote' and 'shellxescape', because these have defaults that work
-    // better with Windows. We also don't bother using ShellExecute for Windows commands beginning with `start`.
-    // Finally, we're also not bothering with the crazy space and backslash handling of the 'shell' options content.
-
-    return ProgressManager.getInstance().runProcessWithProgressSynchronously<String, ExecutionException>(
-      {
-        val shell = injector.globalOptions().shell
-        val shellcmdflag = injector.globalOptions().shellcmdflag
-        val shellxescape = injector.globalOptions().shellxescape
-        val shellxquote = injector.globalOptions().shellxquote
-
-        // For Win32. See :help 'shellxescape'
-        val escapedCommand = if (shellxquote == "(") doEscape(command, shellxescape, "^")
-        else command
-        // Required for Win32+cmd.exe, defaults to "(". See :help 'shellxquote'
-        val quotedCommand = if (shellxquote == "(") "($escapedCommand)"
-        else (if (shellxquote == "\"(") "\"($escapedCommand)\""
-        else shellxquote + escapedCommand + shellxquote)
-
-        val commands = ArrayList<String>()
-        commands.add(shell)
-        if (shellcmdflag.isNotEmpty()) {
-          // Note that Vim also does a simple whitespace split for multiple parameters
-          commands.addAll(ParametersListUtil.parse(shellcmdflag))
-        }
-        commands.add(quotedCommand)
-
-        if (logger.isDebugEnabled) {
-          logger.debug(String.format("shell=%s shellcmdflag=%s command=%s", shell, shellcmdflag, quotedCommand))
-        }
-
-        val commandLine = GeneralCommandLine(commands)
-        if (currentDirectoryPath != null) {
-          commandLine.setWorkDirectory(currentDirectoryPath)
-        }
-        val handler = CapturingProcessHandler(commandLine)
-        if (input != null) {
-          handler.addProcessListener(object : ProcessAdapter() {
-            override fun startNotified(event: ProcessEvent) {
-              try {
-                val charSequenceReader = CharSequenceReader(input)
-                val outputStreamWriter = BufferedWriter(OutputStreamWriter(handler.processInput))
-                copy(charSequenceReader, outputStreamWriter)
-                outputStreamWriter.close()
-              } catch (e: IOException) {
-                logger.error(e)
-              }
-            }
-          })
-        }
-
-        val progressIndicator = ProgressIndicatorProvider.getInstance().progressIndicator
-        val output = handler.runProcessWithProgressIndicator(progressIndicator)
-
-        lastCommand = command
-
-        if (output.isCancelled) {
-          // TODO: Vim will use whatever text has already been written to stdout
-          // For whatever reason, we're not getting any here, so just throw an exception
-          throw ProcessCanceledException()
-        }
-
-        val exitCode = handler.exitCode
-        if (exitCode != null && exitCode != 0) {
-          VimPlugin.showMessage("shell returned $exitCode")
-          VimPlugin.indicateError()
-        }
-        (output.stderr + output.stdout).replace("\u001B\\[[;\\d]*m".toRegex(), "")
-      }, "IdeaVim - !$command", true, editor.ij.project
-    )
-  }
-
-  @Suppress("SameParameterValue")
-  private fun doEscape(original: String, charsToEscape: String, escapeChar: String): String {
-    var result = original
-    for (c in charsToEscape.toCharArray()) {
-      result = result.replace("" + c, escapeChar + c)
-    }
-    return result
-  }
-
-  // TODO: Java 10 has a transferTo method we could use instead
-  @Throws(IOException::class)
-  private fun copy(from: Reader, to: Writer) {
-    val buf = CharArray(2048)
-    var cnt: Int
-    while ((from.read(buf).also { cnt = it }) != -1) {
-      to.write(buf, 0, cnt)
-    }
-  }
-
-  public companion object {
-    private val logger = logger<ProcessGroup>()
-  }
-}