Set version to chylex-15

build.gradle.kts

@@ -3,39 +3,47 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-	kotlin("jvm") version "1.8.0"
-	id("org.jetbrains.intellij") version "1.15.0"
+  kotlin("jvm") version "1.9.10"
+  id("org.jetbrains.intellij") version "1.16.1"
 }
 
 group = "org.acejump"
-version = "chylex-14"
+version = "chylex-15"
 
 repositories {
   mavenCentral()
 }
 
-kotlin {
-	jvmToolchain(17)
-}
-
 intellij {
-	version.set("2023.2")
+  version.set("2023.3")
   updateSinceUntilBuild.set(false)
-	plugins.add("IdeaVIM:chylex-20")
+  plugins.add("IdeaVIM:chylex-22")
   
   pluginsRepositories {
     custom("https://intellij.chylex.com")
   }
 }
 
+kotlin {
+  jvmToolchain(17)
+}
+
+dependencies {
+  testImplementation("org.junit.jupiter:junit-jupiter:5.9.2")
+}
+
 tasks.patchPluginXml {
-	sinceBuild.set("231")
+  sinceBuild.set("233")
 }
 
 tasks.buildSearchableOptions {
   enabled = false
 }
 
+tasks.test {
+  useJUnitPlatform()
+}
+
 tasks.withType<KotlinCompile> {
   kotlinOptions.freeCompilerArgs = listOf(
     "-Xjvm-default=all"

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,67 +17,99 @@
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MSYS* | MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +119,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,88 +130,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    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.
 
 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.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -26,6 +26,7 @@ if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
 if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -75,13 +76,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

src/main/kotlin/org/acejump/action/AceTagAction.kt

@@ -13,40 +13,35 @@ import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
 import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.playback.commands.ActionCommand
-import org.acejump.search.SearchProcessor
+import org.acejump.search.Tag
 
 /**
  * Base class for actions available after typing a tag.
  */
 sealed class AceTagAction {
-  abstract operator fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean)
+  abstract operator fun invoke(tag: Tag, shiftMode: Boolean, isFinal: Boolean)
   
   abstract class BaseJumpAction : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
+    override fun invoke(tag: Tag, shiftMode: Boolean, isFinal: Boolean) {
+      val editor = tag.editor
       val caretModel = editor.caretModel
       val oldCarets = if (shiftMode) caretModel.caretsAndSelections else emptyList()
       
-      recordCaretPosition(editor)
+      editor.project?.let { addCurrentPositionToHistory(it, editor.document) }
       
       if (isFinal) {
         ensureEditorFocused(editor)
       }
       
-      moveCaretTo(editor, getCaretOffset(editor, searchProcessor, offset))
+      moveCaretTo(editor, tag.offset)
       
       if (shiftMode) {
         caretModel.caretsAndSelections = oldCarets + caretModel.caretsAndSelections
       }
     }
-    
-    abstract fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int
   }
   
   private companion object {
-    fun recordCaretPosition(editor: Editor) = with(editor) {
-      project?.let { addCurrentPositionToHistory(it, document) }
-    }
-    
     fun moveCaretTo(editor: Editor, offset: Int) = with(editor) {
       selectionModel.removeSelection(true)
       caretModel.removeSecondaryCarets()
@@ -88,11 +83,7 @@ sealed class AceTagAction {
    * On default action, places the caret at the first character of the search query.
    * On shift action, adds the new caret to existing carets.
    */
-  object JumpToSearchStart : BaseJumpAction() {
-    override fun getCaretOffset(editor: Editor, searchProcessor: SearchProcessor, offset: Int): Int {
-      return offset
-    }
-  }
+  object JumpToSearchStart : BaseJumpAction()
   
   /**
    * On default action, performs the Go To Declaration action, available via `Navigate | Declaration or Usages`.
@@ -100,8 +91,8 @@ sealed class AceTagAction {
    * Always places the caret at the start of the word.
    */
   object GoToDeclaration : AceTagAction() {
-    override fun invoke(editor: Editor, searchProcessor: SearchProcessor, offset: Int, shiftMode: Boolean, isFinal: Boolean) {
-      JumpToSearchStart(editor, searchProcessor, offset, shiftMode = false, isFinal = isFinal)
+    override fun invoke(tag: Tag, shiftMode: Boolean, isFinal: Boolean) {
+      JumpToSearchStart.invoke(tag, shiftMode = false, isFinal = isFinal)
       ApplicationManager.getApplication().invokeLater { performAction(if (shiftMode) IdeActions.ACTION_GOTO_TYPE_DECLARATION else IdeActions.ACTION_GOTO_DECLARATION) }
     }
   }

src/main/kotlin/org/acejump/action/AceVimAction.kt

@@ -44,8 +44,8 @@ sealed class AceVimAction : DumbAwareAction() {
     session.defaultBoundary = mode.boundaries
     session.startJumpMode {
       object : JumpMode() {
-        override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-          state.act(AceTagAction.JumpToSearchStart, acceptedTag, wasUpperCase, isFinal = true)
+        override fun accept(state: SessionState, acceptedTag: Tag) {
+          AceTagAction.JumpToSearchStart.invoke(acceptedTag, shiftMode = wasUpperCase, isFinal = true)
           
           if (selectionStart != null) {
             caret.vim.vimSetSelection(selectionStart, caret.offset, moveCaretToSelectionEnd = true)
@@ -88,7 +88,6 @@ sealed class AceVimAction : DumbAwareAction() {
           
           injector.scroll.scrollCaretIntoView(editor.vim)
           mode.finishSession(editor, session)
-          return true
         }
       }
     }
@@ -176,9 +175,8 @@ sealed class AceVimAction : DumbAwareAction() {
       session.defaultBoundary = VISIBLE_ON_SCREEN
       session.startJumpMode {
         object : JumpMode() {
-          override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-            state.act(AceTagAction.GoToDeclaration, acceptedTag, shiftMode = wasUpperCase, isFinal = true)
-            return true
+          override fun accept(state: SessionState, acceptedTag: Tag) {
+            AceTagAction.GoToDeclaration.invoke(acceptedTag, shiftMode = wasUpperCase, isFinal = true)
           }
         }
       }

src/main/kotlin/org/acejump/config/AceConfig.kt

@@ -21,10 +21,8 @@ class AceConfig : PersistentStateComponent<AceSettings> {
     val layout get() = settings.layout
     val minQueryLength get() = settings.minQueryLength
     val jumpModeColor get() = settings.jumpModeColor
-    val textHighlightColor get() = settings.textHighlightColor
     val tagForegroundColor get() = settings.tagForegroundColor
-    val tagBackgroundColor get() = settings.tagBackgroundColor
-    val acceptedTagColor get() = settings.acceptedTagColor
+    val searchHighlightColor get() = settings.searchHighlightColor
   }
   
   override fun getState(): AceSettings {

src/main/kotlin/org/acejump/config/AceConfigurable.kt

@@ -16,20 +16,16 @@ class AceConfigurable : Configurable {
       panel.keyboardLayout != settings.layout ||
       panel.minQueryLengthInt != settings.minQueryLength ||
       panel.jumpModeColor != settings.jumpModeColor ||
-      panel.textHighlightColor != settings.textHighlightColor ||
       panel.tagForegroundColor != settings.tagForegroundColor ||
-      panel.tagBackgroundColor != settings.tagBackgroundColor ||
-      panel.acceptedTagColor != settings.acceptedTagColor
+      panel.searchHighlightColor != settings.searchHighlightColor
   
   override fun apply() {
     settings.allowedChars = panel.allowedChars
     settings.layout = panel.keyboardLayout
     settings.minQueryLength = panel.minQueryLengthInt ?: settings.minQueryLength
     panel.jumpModeColor?.let { settings.jumpModeColor = it }
-    panel.textHighlightColor?.let { settings.textHighlightColor = it }
     panel.tagForegroundColor?.let { settings.tagForegroundColor = it }
-    panel.tagBackgroundColor?.let { settings.tagBackgroundColor = it }
-    panel.acceptedTagColor?.let { settings.acceptedTagColor = it }
+    panel.searchHighlightColor?.let { settings.searchHighlightColor = it }
     KeyLayoutCache.reset(settings)
   }
   

src/main/kotlin/org/acejump/config/AceSettings.kt

@@ -13,15 +13,9 @@ data class AceSettings(
   @OptionTag("jumpModeRGB", converter = ColorConverter::class)
   var jumpModeColor: Color = Color(0xFFFFFF),
   
-  @OptionTag("textHighlightRGB", converter = ColorConverter::class)
-  var textHighlightColor: Color = Color(0x394B58),
-  
   @OptionTag("tagForegroundRGB", converter = ColorConverter::class)
   var tagForegroundColor: Color = Color(0xFFFFFF),
   
-  @OptionTag("tagBackgroundRGB", converter = ColorConverter::class)
-  var tagBackgroundColor: Color = Color(0x008299),
-  
-  @OptionTag("acceptedTagRGB", converter = ColorConverter::class)
-  var acceptedTagColor: Color = Color(0x394B58)
+  @OptionTag("searchHighlightRGB", converter = ColorConverter::class)
+  var searchHighlightColor: Color = Color(0x008299),
 )

src/main/kotlin/org/acejump/config/AceSettingsPanel.kt

@@ -27,10 +27,8 @@ internal class AceSettingsPanel {
   private val keyboardLayoutArea = JBTextArea().apply { isEditable = false }
   private val minQueryLengthField = JBTextField()
   private val jumpModeColorWheel = ColorPanel()
-  private val textHighlightColorWheel = ColorPanel()
   private val tagForegroundColorWheel = ColorPanel()
-  private val tagBackgroundColorWheel = ColorPanel()
-  private val acceptedTagColorWheel = ColorPanel()
+  private val searchHighlightColorWheel = ColorPanel()
   
   init {
     tagCharsField.apply { font = Font("monospaced", font.style, font.size) }
@@ -54,10 +52,8 @@ internal class AceSettingsPanel {
     
     titledRow("Colors") {
       row("Caret background:") { short(jumpModeColorWheel) }
-      row("Searched text background:") { short(textHighlightColorWheel) }
       row("Tag foreground:") { short(tagForegroundColorWheel) }
-      row("Tag background:") { short(tagBackgroundColorWheel) }
-      row("Accepted tag position background:") { short(acceptedTagColorWheel) }
+      row("Search highlight:") { short(searchHighlightColorWheel) }
     }
   }
   
@@ -67,10 +63,8 @@ internal class AceSettingsPanel {
   internal var keyChars by keyboardLayoutArea
   internal var minQueryLength by minQueryLengthField
   internal var jumpModeColor by jumpModeColorWheel
-  internal var textHighlightColor by textHighlightColorWheel
   internal var tagForegroundColor by tagForegroundColorWheel
-  internal var tagBackgroundColor by tagBackgroundColorWheel
-  internal var acceptedTagColor by acceptedTagColorWheel
+  internal var searchHighlightColor by searchHighlightColorWheel
   
   internal var minQueryLengthInt
     get() = minQueryLength.toIntOrNull()?.coerceIn(1, 10)
@@ -81,10 +75,8 @@ internal class AceSettingsPanel {
     keyboardLayout = settings.layout
     minQueryLength = settings.minQueryLength.toString()
     jumpModeColor = settings.jumpModeColor
-    textHighlightColor = settings.textHighlightColor
     tagForegroundColor = settings.tagForegroundColor
-    tagBackgroundColor = settings.tagBackgroundColor
-    acceptedTagColor = settings.acceptedTagColor
+    searchHighlightColor = settings.searchHighlightColor
   }
   
   // Removal pending support for https://youtrack.jetbrains.com/issue/KT-8575

src/main/kotlin/org/acejump/input/KeyLayout.kt

@@ -1,10 +1,5 @@
 package org.acejump.input
 
-import it.unimi.dsi.fastutil.objects.Object2IntMap
-import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
-import java.awt.geom.Point2D
-import kotlin.math.floor
-
 /**
  * Defines common keyboard layouts. Each layout has a key priority order, based on each key's distance from the home row and how
  * ergonomically difficult they are to press.
@@ -23,38 +18,7 @@ enum class KeyLayout(internal val rows: Array<String>, priority: String) {
   internal val allChars = rows.joinToString("").toCharArray().apply(CharArray::sort).joinToString("")
   internal val allPriorities = priority.mapIndexed { index, char -> char to index }.toMap()
   
-  private val keyDistances: Map<Char, Object2IntMap<Char>> by lazy {
-    val keyDistanceMap = mutableMapOf<Char, Object2IntMap<Char>>()
-    val keyLocations = mutableMapOf<Char, Point2D>()
-    
-    for ((rowIndex, rowChars) in rows.withIndex()) {
-      val keyY = rowIndex * 1.2F // Slightly increase cost of traveling between rows.
-      
-      for ((columnIndex, char) in rowChars.withIndex()) {
-        val keyX = columnIndex + (0.25F * rowIndex) // Assume a 1/4-key uniform stagger.
-        keyLocations[char] = Point2D.Float(keyX, keyY)
-      }
-    }
-    
-    for (fromChar in allChars) {
-      val distances = Object2IntOpenHashMap<Char>()
-      val fromLocation = keyLocations.getValue(fromChar)
-      
-      for (toChar in allChars) {
-        distances[toChar] = floor(2F * fromLocation.distanceSq(keyLocations.getValue(toChar))).toInt()
-      }
-      
-      keyDistanceMap[fromChar] = distances
-    }
-    
-    keyDistanceMap
-  }
-  
   internal inline fun priority(crossinline tagToChar: (String) -> Char): (String) -> Int? {
     return { allPriorities[tagToChar(it)] }
   }
-  
-  internal fun distanceBetweenKeys(char1: Char, char2: Char): Int {
-    return keyDistances.getValue(char1).getValue(char2)
-  }
 }

src/main/kotlin/org/acejump/input/KeyLayoutCache.kt

@@ -34,18 +34,17 @@ internal object KeyLayoutCache {
    */
   fun reset(settings: AceSettings) {
     tagOrder = compareBy(
-      { it[0].isDigit() || it[1].isDigit() },
-      { settings.layout.distanceBetweenKeys(it[0], it[1]) },
-      settings.layout.priority { it[0] }
+      String::length,
+      settings.layout.priority(String::last)
     )
     
+    @Suppress("ConvertLambdaToReference")
     val allPossibleChars = settings.allowedChars
       .toCharArray()
       .filter(Char::isLetterOrDigit)
       .distinct()
-      .joinToString("")
-      .ifEmpty(settings.layout::allChars)
+      .ifEmpty { settings.layout.allChars.toCharArray().toList() }
     
-    allPossibleTags = allPossibleChars.flatMap { a -> allPossibleChars.map { b -> "$a$b".intern() } }.sortedWith(tagOrder)
+    allPossibleTags = allPossibleChars.flatMap { listOf("$it", ";$it") }.sortedWith(tagOrder)
   }
 }

src/main/kotlin/org/acejump/modes/JumpMode.kt

@@ -18,8 +18,7 @@ open class JumpMode : SessionMode {
     return state.type(charTyped)
   }
   
-  override fun accept(state: SessionState, acceptedTag: Tag): Boolean {
-    state.act(AceTagAction.JumpToSearchStart, acceptedTag, wasUpperCase, isFinal = true)
-    return true
+  override fun accept(state: SessionState, acceptedTag: Tag) {
+    AceTagAction.JumpToSearchStart.invoke(acceptedTag, shiftMode = wasUpperCase, isFinal = true)
   }
 }

src/main/kotlin/org/acejump/modes/SessionMode.kt

@@ -9,5 +9,5 @@ interface SessionMode {
   val caretColor: Color
   
   fun type(state: SessionState, charTyped: Char, acceptedTag: Tag?): TypeResult
-  fun accept(state: SessionState, acceptedTag: Tag): Boolean
+  fun accept(state: SessionState, acceptedTag: Tag)
 }

src/main/kotlin/org/acejump/search/SearchProcessor.kt

@@ -3,17 +3,18 @@ package org.acejump.search
 import com.intellij.openapi.editor.Editor
 import it.unimi.dsi.fastutil.ints.IntArrayList
 import org.acejump.boundaries.Boundaries
+import org.acejump.clone
+import org.acejump.config.AceConfig
 import org.acejump.immutableText
-import org.acejump.isWordPart
 import org.acejump.matchesAt
 
 /**
- * Searches editor text for matches of a [SearchQuery], and updates previous results when the user [type]s a character.
+ * Searches editor text for matches of a [SearchQuery], and updates previous results when the user [refineQuery]s a character.
  */
-class SearchProcessor private constructor(query: SearchQuery, results: MutableMap<Editor, IntArrayList>) {
+class SearchProcessor private constructor(query: SearchQuery, private val results: MutableMap<Editor, IntArrayList>) {
   companion object {
-    fun fromChar(editors: List<Editor>, char: Char, boundaries: Boundaries): SearchProcessor {
-      return SearchProcessor(editors, SearchQuery.Literal(char.toString()), boundaries)
+    fun fromString(editors: List<Editor>, query: String, boundaries: Boundaries): SearchProcessor {
+      return SearchProcessor(editors, SearchQuery.Literal(query), boundaries)
     }
     
     fun fromRegex(editors: List<Editor>, pattern: String, boundaries: Boundaries): SearchProcessor {
@@ -53,97 +54,40 @@ class SearchProcessor private constructor(query: SearchQuery, results: MutableMa
   internal var query = query
     private set
   
-  internal var results = results
-    private set
+  val resultsCopy
+    get() = results.clone()
   
-  /**
-   * Appends a character to the search query and removes all search results that no longer match the query. If the last typed character
-   * transitioned the search query from a non-word to a word, it notifies the [Tagger] to reassign all tags. If the new query does not
-   * make sense because it would remove every result, the change is reverted and this function returns false.
-   */
-  fun type(char: Char, tagger: Tagger): Boolean {
-    val newQuery = query.rawText + char
-    val canMatchTag = tagger.canQueryMatchAnyTag(newQuery)
-    
-    // If the typed character is not compatible with any existing tag or as a continuation of any previous occurrence, reject the query
-    // change and return false to indicate that nothing else should happen.
-    
-    if (newQuery.length > 1 && !canMatchTag && !isContinuation(newQuery)) {
-      return false
-    }
-    
-    // If the typed character transitioned the search query from a non-word to a word, and the typed character does not belong to an
-    // existing tag, we basically restart the search at the beginning of every new word, and unmark existing results so that all tags get
-    // regenerated immediately afterwards. Although this causes tags to change, it is one solution for conflicts between tag characters and
-    // search query characters, and moving searches across word boundaries during search should be fairly uncommon.
-    
-    if (!canMatchTag && newQuery.length >= 2 && !newQuery[newQuery.length - 2].isWordPart && char.isWordPart) {
-      query = SearchQuery.Literal(char.toString())
-      tagger.unmark()
-      
-      for ((editor, offsets) in results) {
-        val chars = editor.immutableText
-        val iter = offsets.iterator()
-        
-        while (iter.hasNext()) {
-          val movedOffset = iter.nextInt() + newQuery.length - 1
-          
-          if (movedOffset < chars.length && chars[movedOffset].equals(char, ignoreCase = true)) {
-            iter.set(movedOffset)
-          }
-          else {
-            iter.remove()
-          }
-        }
-      }
-    }
-    else {
-      removeObsoleteResults(newQuery, tagger)
-      query = SearchQuery.Literal(newQuery)
-    }
+  val isQueryFinished
+    get() = query.rawText.length >= AceConfig.minQueryLength
   
+  fun refineQuery(char: Char): Boolean {
+    if (char == '\n') {
       return true
     }
-  
-  /**
-   * Returns true if the new query is a continuation of any remaining search query.
-   */
-  private fun isContinuation(newQuery: String): Boolean {
-    for ((editor, offsets) in results) {
-      val chars = editor.immutableText
-      if (offsets.any { chars.matchesAt(it, newQuery, ignoreCase = true) }) {
-        return true
+    else {
+      query = SearchQuery.Literal(query.rawText + char)
+      removeObsoleteResults()
+      return isQueryFinished
     }
   }
   
-    return false
-  }
-  
   /**
    * After updating the query, removes all results that no longer match the search query.
    */
-  private fun removeObsoleteResults(newQuery: String, tagger: Tagger) {
-    val lastCharOffset = newQuery.lastIndex
-    val lastChar = newQuery[lastCharOffset]
-    val ignoreCase = newQuery[0].isLowerCase()
+  private fun removeObsoleteResults() {
+    val query = query.rawText
     
-    for ((editor, offsets) in results.entries.toList()) {
-      val chars = editor.immutableText
+    for (entry in results) {
+      val editor = entry.key
+      val offsetIter = entry.value.iterator()
       
-      val remaining = IntArrayList()
-      val iter = offsets.iterator()
+      while (offsetIter.hasNext()) {
+        val offset = offsetIter.nextInt()
         
-      while (iter.hasNext()) {
-        val offset = iter.nextInt()
-        val endOffset = offset + lastCharOffset
-        val lastTypedCharMatches = endOffset < chars.length && chars[endOffset].equals(lastChar, ignoreCase)
-        
-        if (lastTypedCharMatches || tagger.isQueryCompatibleWithTagAt(newQuery, Tag(editor, offset))) {
-          remaining.add(offset)
-        }
-      }
-      
-      results[editor] = remaining
+        if (!editor.immutableText.matchesAt(offset, query, ignoreCase = true)) {
+          offsetIter.remove()
+        }
+      }
     }
   }
 }

src/main/kotlin/org/acejump/search/Solver.kt

@@ -1,231 +0,0 @@
-package org.acejump.search
-
-import com.intellij.openapi.editor.Editor
-import it.unimi.dsi.fastutil.ints.IntList
-import it.unimi.dsi.fastutil.ints.IntOpenHashSet
-import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
-import org.acejump.config.AceConfig
-import org.acejump.immutableText
-import org.acejump.input.KeyLayoutCache
-import org.acejump.isWordPart
-import org.acejump.wordEndPlus
-import java.util.IdentityHashMap
-import kotlin.math.max
-
-/*
- * Solves the Tag Assignment Problem. The tag assignment problem can be stated
- * thusly: Given a set of indices I in document d, and a set of tags T, find a
- * bijection f: T*⊂T → I*⊂I s.t. d[i..k] + t ∉ d[i'..(k + |t|)], ∀ i' ∈ I\{i},
- * ∀ k ∈ (i, |d|-|t|], where t ∈ T, i ∈ I. Maximize |I*|. This can be relaxed
- * to t=t[0] and ∀ k ∈ (i, i+K] for some fixed K, in most natural documents.
- *
- * More concretely, tags are typically two-character strings containing alpha-
- * numeric symbols. Documents are plaintext files. Indices are produced by a
- * search query of length N, i.e. the preceding N characters of every index i in
- * document d are identical. For characters proceeding d[i], all bets are off.
- * We can assume that P(d[i]|d[i-1]) has some structure for d~D. Ultimately, we
- * want a fast algorithm which maximizes the number of tagged document indices.
- *
- * Tags are used by the typist to select indices within a document. To select an
- * index, the typist starts by activating AceJump and searching for a character.
- * As soon as the first character is received, we begin to scan the document for
- * matching locations and assign as many valid tags as possible. When subsequent
- * characters are received, we refine the search results to match either:
- *
- *    1.) The plaintext query alone, or
- *    2.) The concatenation of plaintext query and partial tag
- *
- * The constraint in paragraph no. 1 tries to impose the following criteria:
- *
- *    1.) All valid key sequences will lead to a unique location in the document
- *    2.) All indices in the document will be reachable by a short key sequence
- *
- * If there is an insufficient number of two-character tags to cover every index
- * (which typically occurs when the user searches for a common character within
- * a long document), then we attempt to maximize the number of tags assigned to
- * document indices. The key is, all tags must be assigned as soon as possible,
- * i.e. as soon as the first character is received or whenever the user ceases
- * typing (at the very latest). Once assigned, a visible tag must never change
- * at any time during the selection process, so as not to confuse the user.
- */
-
-internal class Solver private constructor(
-  private val editorPriority: List<Editor>,
-  private val queryLength: Int,
-  private val newResults: Map<Editor, IntList>,
-  private val allResults: Map<Editor, IntList>,
-) {
-  companion object {
-    fun solve(
-      editorPriority: List<Editor>,
-      query: SearchQuery,
-      newResults: Map<Editor, IntList>,
-      allResults: Map<Editor, IntList>,
-      tags: List<String>,
-      caches: Map<Editor, EditorOffsetCache>,
-    ): Map<String, Tag> {
-      return Solver(editorPriority, max(1, query.rawText.length), newResults, allResults).map(tags, caches)
-    }
-  }
-  
-  private var newTags = HashMap<String, Tag>(KeyLayoutCache.allPossibleTags.size)
-  private val newTagIndices = newResults.keys.associateWith { IntOpenHashSet() }
-  
-  private var allWordFragments = HashSet<String>(allResults.values.sumBy(IntList::size)).apply {
-    for ((editor, offsets) in allResults) {
-      val chars = editor.immutableText
-      val iter = offsets.iterator()
-      while (iter.hasNext()) {
-        forEachWordFragment(chars, iter.nextInt(), this::add)
-      }
-    }
-  }
-  
-  private fun generateEligibleSites(availableTags: List<String>): Map<String, MutableList<Tag>> {
-    val eligibleSitesByTag = HashMap<String, MutableList<Tag>>(100)
-    val tagsByFirstLetter = availableTags.groupBy { it[0] }
-    
-    for ((editor, offsets) in newResults) {
-      val chars = editor.immutableText
-      val iter = offsets.iterator()
-      while (iter.hasNext()) {
-        val site = iter.nextInt()
-        
-        for ((firstLetter, tags) in tagsByFirstLetter.entries) {
-          if (canTagBeginWithChar(chars, site, firstLetter)) {
-            for (tag in tags) {
-              eligibleSitesByTag.getOrPut(tag, ::mutableListOf).add(Tag(editor, site))
-            }
-          }
-        }
-      }
-    }
-    
-    return eligibleSitesByTag
-  }
-  
-  private fun generateMatchingSites(
-    eligibleSites: Map<String, MutableList<Tag>>,
-    caches: Map<Editor, EditorOffsetCache>,
-  ): Map<String, Iterator<Tag>> {
-    val matchingSites = HashMap<MutableList<Tag>, Iterator<Tag>>()
-    val matchingSitesSorted = IdentityHashMap<String, Iterator<Tag>>() // Keys are guaranteed to be from a single collection.
-    
-    val siteOrder = siteOrder(caches)
-    
-    for ((mark, tags) in eligibleSites.entries) {
-      matchingSitesSorted[mark] = matchingSites.getOrPut(tags) {
-        @Suppress("ConvertLambdaToReference")
-        tags.toMutableList().apply { sortWith(siteOrder) }.iterator()
-      }
-    }
-    
-    return matchingSitesSorted
-  }
-  
-  fun map(availableTags: List<String>, caches: Map<Editor, EditorOffsetCache>): Map<String, Tag> {
-    val eligibleSitesByTag = generateEligibleSites(availableTags)
-    val matchingSitesSorted = generateMatchingSites(eligibleSitesByTag, caches)
-    
-    val tagOrder = KeyLayoutCache.tagOrder
-      .thenComparingInt { eligibleSitesByTag.getValue(it).size }
-      .thenBy(AceConfig.layout.priority(String::last))
-    
-    val sortedTags = eligibleSitesByTag.keys.toMutableList().apply {
-      sortWith(tagOrder)
-    }
-    
-    var totalAssigned = 0
-    val totalResults = newResults.values.sumBy(IntList::size)
-    
-    for (tag in sortedTags) {
-      if (totalAssigned == totalResults) {
-        break
-      }
-      
-      if (tryToAssignTag(tag, matchingSitesSorted.getValue(tag))) {
-        totalAssigned++
-      }
-    }
-    
-    return newTags
-  }
-  
-  private fun tryToAssignTag(mark: String, tags: Iterator<Tag>): Boolean {
-    if (newTags.containsKey(mark)) {
-      return false
-    }
-    
-    while (tags.hasNext()) {
-      val tag = tags.next()
-      val assigned = newTagIndices.getValue(tag.editor)
-      
-      if (tag.offset !in assigned) {
-        newTags[mark] = tag
-        assigned.add(tag.offset)
-        return true
-      }
-    }
-    
-    return false
-  }
-  
-  private fun siteOrder(caches: Map<Editor, EditorOffsetCache>) = Comparator<Tag> { a, b ->
-    val aEditor = a.editor
-    val bEditor = b.editor
-    
-    if (aEditor !== bEditor) {
-      val aEditorIndex = editorPriority.indexOf(aEditor)
-      val bEditorIndex = editorPriority.indexOf(bEditor)
-      // For multiple editors, prioritize them based on the provided order.
-      return@Comparator if (aEditorIndex < bEditorIndex) -1 else 1
-    }
-    
-    val aIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(aEditor, a.offset, caches.getValue(aEditor))
-    val bIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(bEditor, b.offset, caches.getValue(bEditor))
-    if (aIsVisible != bIsVisible) {
-      // Sites in immediate view should come first.
-      return@Comparator if (aIsVisible) -1 else 1
-    }
-    
-    val aIsNotWordStart = aEditor.immutableText[max(0, a.offset - 1)].isWordPart
-    val bIsNotWordStart = bEditor.immutableText[max(0, b.offset - 1)].isWordPart
-    if (aIsNotWordStart != bIsNotWordStart) {
-      // Ensure that the first letter of a word is prioritized for tagging.
-      return@Comparator if (bIsNotWordStart) -1 else 1
-    }
-    
-    when {
-      a.offset < b.offset -> -1
-      a.offset > b.offset -> 1
-      else                -> 0
-    }
-  }
-  
-  private fun canTagBeginWithChar(chars: CharSequence, site: Int, char: Char): Boolean {
-    if (char.toString() in allWordFragments) {
-      return false
-    }
-    
-    forEachWordFragment(chars, site) {
-      if (it + char in allWordFragments) {
-        return false
-      }
-    }
-    
-    return true
-  }
-  
-  private inline fun forEachWordFragment(chars: CharSequence, site: Int, callback: (String) -> Unit) {
-    val left = max(0, site + queryLength - 1)
-    val right = chars.wordEndPlus(site)
-    
-    val builder = StringBuilder(1 + right - left)
-    
-    for (i in left..right) {
-      builder.append(chars[i].toLowerCase())
-      callback(builder.toString())
-    }
-  }
-}

src/main/kotlin/org/acejump/search/Tagger.kt

@@ -1,93 +1,76 @@
 package org.acejump.search
 
 import com.google.common.collect.ArrayListMultimap
-import com.google.common.collect.HashBiMap
 import com.intellij.openapi.editor.Editor
-import it.unimi.dsi.fastutil.ints.IntArrayList
 import it.unimi.dsi.fastutil.ints.IntList
-import org.acejump.ExternalUsage
 import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
+import org.acejump.boundaries.StandardBoundaries.VISIBLE_ON_SCREEN
 import org.acejump.immutableText
-import org.acejump.input.KeyLayoutCache.allPossibleTags
+import org.acejump.input.KeyLayoutCache
 import org.acejump.isWordPart
-import org.acejump.matchesAt
 import org.acejump.view.TagMarker
-import java.util.AbstractMap.SimpleImmutableEntry
 import kotlin.collections.component1
 import kotlin.collections.component2
+import kotlin.math.max
 import kotlin.math.min
 
 /**
- * Assigns tags to search occurrences, updates them when the search query changes, and requests a jump if the search query matches a tag.
+ * Assigns tags to search occurrences.
  * The ordering of [editors] may be used to prioritize tagging editors earlier in the list in case of conflicts.
  */
-class Tagger(private val editors: List<Editor>) {
-  private var tagMap = HashBiMap.create<String, Tag>()
+class Tagger(private val editors: List<Editor>, results: Map<Editor, IntList>) {
+  private var tagMap: Map<String, Tag>
+  private var typedTag = ""
   
-  val hasTags
-    get() = tagMap.isNotEmpty()
+  internal val markers: Map<Editor, Collection<TagMarker>>
+    get() {
+      val markers = ArrayListMultimap.create<Editor, TagMarker>(editors.size, min(tagMap.values.size, 40))
       
-  @ExternalUsage
-  internal val tags
-    get() = tagMap.map { SimpleImmutableEntry(it.key, it.value) }.sortedBy { it.value.offset }
-  
-  /**
-   * Removes all markers, allowing them to be regenerated from scratch.
-   */
-  internal fun unmark() {
-    tagMap = HashBiMap.create()
+      for ((mark, tag) in tagMap) {
+        val marker = TagMarker.create(mark, tag.offset, typedTag)
+        markers.put(tag.editor, marker)
       }
       
-  /**
-   * Assigns tags to as many results as possible, keeping previously assigned tags. Returns a [TaggingResult.Accept] if the current search
-   * query matches any existing tag and we should jump to it and end the session, or [TaggingResult.Mark] to continue the session with
-   * updated tag markers.
-   *
-   * Note that the [results] collection will be mutated.
-   */
-  internal fun update(query: SearchQuery, results: Map<Editor, IntList>): TaggingResult {
-    val isRegex = query is SearchQuery.RegularExpression
-    val queryText = if (isRegex) " ${query.rawText}" else query.rawText[0] + query.rawText.drop(1).toLowerCase()
-    
-    val availableTags = allPossibleTags.filter { !queryText.endsWith(it[0]) && it !in tagMap }
-    
-    if (!isRegex) {
-      for (entry in tagMap.entries) {
-        if (entry solves queryText) {
-          return TaggingResult.Accept(entry.value)
-        }
+      return markers.asMap()
     }
   
-      if (queryText.length == 1) {
-        for ((editor, offsets) in results) {
-          removeResultsWithOverlappingTags(editor, offsets)
-        }
-      }
-    }
-    
-    if (!isRegex || tagMap.isEmpty()) {
-      tagMap = assignTagsAndMerge(results, availableTags, query, queryText)
-    }
-    
-    val resultTags = results.flatMap { (editor, offsets) -> offsets.map { Tag(editor, it) } }
-    return TaggingResult.Mark(createTagMarkers(resultTags, query.rawText.ifEmpty { null }))
-  }
-  
-  /**
-   * Assigns as many unassigned tags as possible, and merges them with the existing compatible tags.
-   */
-  private fun assignTagsAndMerge(
-    results: Map<Editor, IntList>, availableTags: List<String>, query: SearchQuery, queryText: String,
-  ): HashBiMap<String, Tag> {
+  init {
     val caches = results.keys.associateWith { EditorOffsetCache.new() }
     
+    sortResults(results, caches)
+    
+    val tagSites = results
+      .flatMap { (editor, sites) -> sites.map { site -> Tag(editor, site) } }
+      .sortedWith(siteOrder(editors, caches))
+    
+    tagMap = KeyLayoutCache.allPossibleTags.zip(tagSites).toMap()
+  }
+  
+  internal fun type(char: Char): TaggingResult {
+    val newTypedTag = typedTag + char
+    val matchingTag = tagMap[newTypedTag]
+    if (matchingTag != null) {
+      return TaggingResult.Accept(matchingTag)
+    }
+    
+    val newTagMap = tagMap.filter { it.key.startsWith(newTypedTag, ignoreCase = true) }
+    if (newTagMap.isEmpty()) {
+      return TaggingResult.Nothing
+    }
+    
+    typedTag = newTypedTag
+    tagMap = newTagMap
+    return TaggingResult.Mark(markers)
+  }
+  
+  private companion object {
+    private fun sortResults(results: Map<Editor, IntList>, caches: Map<Editor, EditorOffsetCache>) {
       for ((editor, offsets) in results) {
         val cache = caches.getValue(editor)
         
         offsets.sort { a, b ->
-        val aIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, a, cache)
-        val bIsVisible = StandardBoundaries.VISIBLE_ON_SCREEN.isOffsetInside(editor, b, cache)
+          val aIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(editor, a, cache)
+          val bIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(editor, b, cache)
           
           when {
             aIsVisible && !bIsVisible -> -1
@@ -96,134 +79,39 @@ class Tagger(private val editors: List<Editor>) {
           }
         }
       }
-    
-    val allAssignedTags = mutableMapOf<String, Tag>()
-    val oldCompatibleTags = tagMap.filter { (mark, tag) ->
-      isTagCompatibleWithQuery(mark, tag, queryText) || results[tag.editor]?.contains(tag.offset) == true
     }
     
-    val vacantResults: Map<Editor, IntList>
+    private fun siteOrder(editorPriority: List<Editor>, caches: Map<Editor, EditorOffsetCache>) = Comparator<Tag> { a, b ->
+      val aEditor = a.editor
+      val bEditor = b.editor
       
-    if (oldCompatibleTags.isEmpty()) {
-      vacantResults = results
+      if (aEditor !== bEditor) {
+        val aEditorIndex = editorPriority.indexOf(aEditor)
+        val bEditorIndex = editorPriority.indexOf(bEditor)
+        // For multiple editors, prioritize them based on the provided order.
+        return@Comparator if (aEditorIndex < bEditorIndex) -1 else 1
       }
-    else {
-      val vacant = mutableMapOf<Editor, IntList>()
       
-      for ((editor, offsets) in results) {
-        val list = IntArrayList()
-        val iter = offsets.iterator()
+      val aIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(aEditor, a.offset, caches.getValue(aEditor))
+      val bIsVisible = VISIBLE_ON_SCREEN.isOffsetInside(bEditor, b.offset, caches.getValue(bEditor))
+      if (aIsVisible != bIsVisible) {
+        // Sites in immediate view should come first.
+        return@Comparator if (aIsVisible) -1 else 1
+      }
       
-        while (iter.hasNext()) {
-          val tag = Tag(editor, iter.nextInt())
-          if (tag !in oldCompatibleTags.values) {
-            list.add(tag.offset)
+      val aIsNotWordStart = aEditor.immutableText[max(0, a.offset - 1)].isWordPart
+      val bIsNotWordStart = bEditor.immutableText[max(0, b.offset - 1)].isWordPart
+      if (aIsNotWordStart != bIsNotWordStart) {
+        // Ensure that the first letter of a word is prioritized for tagging.
+        return@Comparator if (bIsNotWordStart) -1 else 1
+      }
+      
+      when {
+        a.offset < b.offset -> -1
+        a.offset > b.offset -> 1
+        else                -> 0
       }
     }
     
-        vacant[editor] = list
-      }
-      
-      vacantResults = vacant
-    }
-    
-    allAssignedTags.putAll(oldCompatibleTags)
-    allAssignedTags.putAll(Solver.solve(editors, query, vacantResults, results, availableTags, caches))
-    
-    val assignedMarkers = allAssignedTags.keys.groupBy { it[0] }
-    
-    return allAssignedTags.mapKeysTo(HashBiMap.create(allAssignedTags.size)) { (tag, _) ->
-      if (canShortenTag(tag, assignedMarkers, queryText))
-        tag[0].toString()
-      else
-        tag
-    }
-  }
-  
-  private infix fun Map.Entry<String, Tag>.solves(query: String): Boolean {
-    return query.endsWith(key, true) && isTagCompatibleWithQuery(key, value, query)
-  }
-  
-  private fun isTagCompatibleWithQuery(marker: String, tag: Tag, query: String): Boolean {
-    return tag.editor.immutableText.matchesAt(tag.offset, getPlaintextPortion(query, marker), ignoreCase = true)
-  }
-  
-  fun isQueryCompatibleWithTagAt(query: String, tag: Tag): Boolean {
-    return tagMap.inverse()[tag].let { it != null && isTagCompatibleWithQuery(it, tag, query) }
-  }
-  
-  fun canQueryMatchAnyTag(query: String): Boolean {
-    return tagMap.any { (tag, offset) ->
-      val tagPortion = getTagPortion(query, tag)
-      tagPortion.isNotEmpty() && tag.startsWith(tagPortion, ignoreCase = true) && isTagCompatibleWithQuery(tag, offset, query)
-    }
-  }
-  
-  private fun removeResultsWithOverlappingTags(editor: Editor, offsets: IntList) {
-    val iter = offsets.iterator()
-    val chars = editor.immutableText
-    
-    while (iter.hasNext()) {
-      if (!chars.canTagWithoutOverlap(iter.nextInt())) {
-        iter.remove() // Very uncommon, so slow removal is fine.
-      }
-    }
-  }
-  
-  private fun createTagMarkers(tags: Collection<Tag>, literalQueryText: String?): MutableMap<Editor, Collection<TagMarker>> {
-    val tagMapInv = tagMap.inverse()
-    val markers = ArrayListMultimap.create<Editor, TagMarker>(editors.size, min(tags.size, 50))
-    
-    for (tag in tags) {
-      val mark = tagMapInv[tag] ?: continue
-      val editor = tag.editor
-      val marker = TagMarker.create(editor, mark, tag.offset, literalQueryText)
-      markers.put(editor, marker)
-    }
-    
-    return markers.asMap()
-  }
-  
-  private companion object {
-    private fun CharSequence.canTagWithoutOverlap(loc: Int) = when {
-      loc - 1 < 0                                                                             -> true
-      loc + 1 >= length                                                                       -> true
-      this[loc] isUnlike this[loc - 1]                                                        -> true
-      this[loc] isUnlike this[loc + 1]                                                        -> true
-      this[loc] != this[loc - 1]                                                              -> true
-      this[loc] != this[loc + 1]                                                              -> true
-      this[loc + 1] == '\r' || this[loc + 1] == '\n'                                          -> true
-      this[loc - 1] == this[loc] && this[loc] == this[loc + 1]                                -> false
-      this[loc + 1].isWhitespace() && this[(loc + 2).coerceAtMost(length - 1)].isWhitespace() -> true
-      else                                                                                    -> false
-    }
-    
-    private infix fun Char.isUnlike(other: Char): Boolean {
-      return this.isWordPart xor other.isWordPart || this.isWhitespace() xor other.isWhitespace()
-    }
-    
-    private fun getPlaintextPortion(query: String, marker: String) = when {
-      query.endsWith(marker, true)         -> query.dropLast(marker.length)
-      query.endsWith(marker.first(), true) -> query.dropLast(1)
-      else                                 -> query
-    }
-    
-    private fun getTagPortion(query: String, marker: String) = when {
-      query.endsWith(marker, true)         -> query.takeLast(marker.length)
-      query.endsWith(marker.first(), true) -> query.takeLast(1)
-      else                                 -> ""
-    }
-    
-    private fun canShortenTag(marker: String, markers: Map<Char, List<String>>, queryText: String): Boolean {
-      // Avoid matching query - will trigger a jump.
-      // TODO: lift this constraint.
-      val queryEndsWith = queryText.endsWith(marker[0]) || queryText.endsWith(marker)
-      if (queryEndsWith) {
-        return false
-      }
-      
-      val startingWithSameLetter = markers[marker[0]]
-      return startingWithSameLetter == null || startingWithSameLetter.singleOrNull() == marker
-    }
   }
 }

src/main/kotlin/org/acejump/search/TaggingResult.kt

@@ -4,6 +4,7 @@ import com.intellij.openapi.editor.Editor
 import org.acejump.view.TagMarker
 
 internal sealed class TaggingResult {
+  object Nothing : TaggingResult()
   class Accept(val tag: Tag) : TaggingResult()
-  class Mark(val markers: MutableMap<Editor, Collection<TagMarker>>) : TaggingResult()
+  class Mark(val markers: Map<Editor, Collection<TagMarker>>) : TaggingResult()
 }

src/main/kotlin/org/acejump/session/Session.kt

@@ -1,23 +1,29 @@
 package org.acejump.session
 
 import com.intellij.codeInsight.hint.HintManagerImpl
-import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.ScrollType
-import com.intellij.openapi.editor.actionSystem.TypedActionHandler
 import com.intellij.openapi.editor.colors.EditorColors
 import com.intellij.openapi.editor.colors.impl.AbstractColorsScheme
-import org.acejump.ExternalUsage
+import it.unimi.dsi.fastutil.ints.IntList
 import org.acejump.boundaries.Boundaries
 import org.acejump.boundaries.StandardBoundaries
-import org.acejump.clone
 import org.acejump.config.AceConfig
 import org.acejump.input.EditorKeyListener
 import org.acejump.input.KeyLayoutCache
 import org.acejump.modes.JumpMode
 import org.acejump.modes.SessionMode
-import org.acejump.search.*
+import org.acejump.search.Pattern
+import org.acejump.search.SearchProcessor
+import org.acejump.search.SearchQuery
+import org.acejump.search.Tag
+import org.acejump.session.TypeResult.AcceptTag
+import org.acejump.session.TypeResult.ChangeMode
+import org.acejump.session.TypeResult.ChangeState
+import org.acejump.session.TypeResult.EndSession
+import org.acejump.session.TypeResult.Nothing
 import org.acejump.view.TagCanvas
+import org.acejump.view.TagMarker
 import org.acejump.view.TextHighlighter
 
 /**
@@ -27,8 +33,7 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
   private val editorSettings = EditorSettings.setup(mainEditor)
   private lateinit var mode: SessionMode
   
-  private var state: SessionStateImpl? = null
-  private var tagger = Tagger(jumpEditors)
+  private var state: SessionState? = null
   
   private var acceptedTag: Tag? = null
     set(value) {
@@ -43,69 +48,48 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
   private val textHighlighter = TextHighlighter()
   private val tagCanvases = jumpEditors.associateWith(::TagCanvas)
   
-  @ExternalUsage
-  val tags
-    get() = tagger.tags
-  
   var defaultBoundary: Boundaries = StandardBoundaries.VISIBLE_ON_SCREEN
   
+  private val actions = object : SessionActions {
+    override fun showHighlights(results: Map<Editor, IntList>, query: SearchQuery) {
+      textHighlighter.renderOccurrences(results, query)
+    }
+    
+    override fun hideHighlights() {
+      textHighlighter.reset()
+    }
+    
+    override fun setTagMarkers(markers: Map<Editor, Collection<TagMarker>>) {
+      for ((editor, canvas) in tagCanvases) {
+        canvas.setMarkers(markers[editor].orEmpty())
+      }
+    }
+  }
+  
   init {
     KeyLayoutCache.ensureInitialized(AceConfig.settings)
+    EditorKeyListener.attach(mainEditor) { editor, charTyped, _ -> typeCharacter(editor, charTyped) }
+  }
   
-    EditorKeyListener.attach(mainEditor, object : TypedActionHandler {
-      override fun execute(editor: Editor, charTyped: Char, context: DataContext) {
+  private fun typeCharacter(editor: Editor, charTyped: Char) {
     val state = state ?: return
-        val hadTags = tagger.hasTags
     
     editorSettings.startEditing(editor)
     val result = mode.type(state, charTyped, acceptedTag)
     editorSettings.stopEditing(editor)
     
     when (result) {
-          TypeResult.Nothing          -> return;
-          is TypeResult.UpdateResults -> updateSearch(result.processor, markImmediately = hadTags)
-          is TypeResult.ChangeMode    -> setMode(result.mode)
+      Nothing        -> return
+      is ChangeState -> this.state = result.state
+      is ChangeMode  -> setMode(result.mode)
       
-          TypeResult.RestartSearch    -> restart().also {
-            this@Session.state = SessionStateImpl(jumpEditors, tagger, defaultBoundary)
-          }
-          
-          TypeResult.EndSession       -> end()
-        }
-      }
-    })
-  }
-  
-  /**
-   * Updates text highlights and tag markers according to the current search state. Dispatches jumps if the search query matches a tag.
-   */
-  private fun updateSearch(processor: SearchProcessor, markImmediately: Boolean) {
-    val query = processor.query
-    val results = processor.results
-    
-    if (!markImmediately && query.rawText.let { it.length < AceConfig.minQueryLength && it.all(Char::isLetterOrDigit) }) {
-      textHighlighter.renderOccurrences(results, query)
-      return
-    }
-    
-    when (val result = tagger.update(query, results.clone())) {
-      is TaggingResult.Accept -> {
+      is AcceptTag   -> {
         acceptedTag = result.tag
-        textHighlighter.renderFinal(result.tag, processor.query)
-        
-        if (state?.let { mode.accept(it, result.tag) } == true) {
+        mode.accept(state, result.tag)
         end()
-          return
-        }
       }
       
-      is TaggingResult.Mark   -> {
-        for ((editor, canvas) in tagCanvases) {
-          canvas.setMarkers(result.markers[editor].orEmpty())
-        }
-        
-        textHighlighter.renderOccurrences(results, query)
-      }
+      EndSession     -> end()
     }
   }
   
@@ -129,7 +113,7 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
     }
     
     setMode(mode())
-    state = SessionStateImpl(jumpEditors, tagger, defaultBoundary)
+    state = SessionState.WaitForKey(actions, jumpEditors, defaultBoundary)
   }
   
   /**
@@ -140,22 +124,18 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
       setMode(JumpMode())
     }
     
-    tagger = Tagger(jumpEditors)
-    tagCanvases.values.forEach { it.setMarkers(emptyList()) }
+    for (canvas in tagCanvases.values) {
+      canvas.setMarkers(emptyList())
+    }
     
     val processor = SearchProcessor.fromRegex(jumpEditors, pattern.regex, defaultBoundary)
-    state = SessionStateImpl(jumpEditors, tagger, defaultBoundary, processor)
+    textHighlighter.renderOccurrences(processor.resultsCopy, processor.query)
     
-    updateSearch(processor, markImmediately = true)
+    state = SessionState.SelectTag(actions, jumpEditors, processor)
   }
   
   fun tagImmediately() {
-    val state = state ?: return
-    val processor = state.currentProcessor
-    
-    if (processor != null) {
-      updateSearch(processor, markImmediately = true)
-    }
+    typeCharacter(mainEditor, '\n')
   }
   
   /**
@@ -170,7 +150,6 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
    */
   fun restart() {
     state = null
-    tagger = Tagger(jumpEditors)
     acceptedTag = null
     tagCanvases.values.forEach(TagCanvas::removeMarkers)
     textHighlighter.reset()
@@ -185,7 +164,6 @@ class Session(private val mainEditor: Editor, private val jumpEditors: List<Edit
    * Should only be used from [SessionManager] to dispose a successfully ended session.
    */
   internal fun dispose() {
-    tagger = Tagger(jumpEditors)
     tagCanvases.values.forEach(TagCanvas::unbind)
     textHighlighter.reset()
     EditorKeyListener.detach(mainEditor)

src/main/kotlin/org/acejump/session/SessionActions.kt

@@ -0,0 +1,13 @@
+package org.acejump.session
+
+import com.intellij.openapi.editor.Editor
+import it.unimi.dsi.fastutil.ints.IntList
+import org.acejump.search.SearchQuery
+import org.acejump.view.TagMarker
+
+internal interface SessionActions {
+  fun showHighlights(results: Map<Editor, IntList>, query: SearchQuery)
+  fun hideHighlights()
+  
+  fun setTagMarkers(markers: Map<Editor, Collection<TagMarker>>)
+}

src/main/kotlin/org/acejump/session/SessionState.kt

@@ -1,9 +1,72 @@
 package org.acejump.session
 
-import org.acejump.action.AceTagAction
-import org.acejump.search.Tag
+import com.intellij.openapi.editor.Editor
+import org.acejump.boundaries.Boundaries
+import org.acejump.search.SearchProcessor
+import org.acejump.search.Tagger
+import org.acejump.search.TaggingResult
 
-interface SessionState {
+sealed interface SessionState {
   fun type(char: Char): TypeResult
-  fun act(action: AceTagAction, tag: Tag, shiftMode: Boolean, isFinal: Boolean)
+  
+  class WaitForKey internal constructor(
+    private val actions: SessionActions,
+    private val jumpEditors: List<Editor>,
+    private val defaultBoundary: Boundaries,
+  ) : SessionState {
+    override fun type(char: Char): TypeResult {
+      val searchProcessor = SearchProcessor.fromString(jumpEditors, char.toString(), defaultBoundary)
+      
+      return if (searchProcessor.isQueryFinished) {
+        TypeResult.ChangeState(SelectTag(actions, jumpEditors, searchProcessor))
+      }
+      else {
+        TypeResult.ChangeState(RefineSearchQuery(actions, jumpEditors, searchProcessor))
+      }
+    }
+  }
+  
+  class RefineSearchQuery internal constructor(
+    private val actions: SessionActions,
+    private val jumpEditors: List<Editor>,
+    private val searchProcessor: SearchProcessor,
+  ) : SessionState {
+    init {
+      actions.showHighlights(searchProcessor.resultsCopy, searchProcessor.query)
+    }
+    
+    override fun type(char: Char): TypeResult {
+      return if (searchProcessor.refineQuery(char)) {
+        actions.hideHighlights()
+        TypeResult.ChangeState(SelectTag(actions, jumpEditors, searchProcessor))
+      }
+      else {
+        actions.showHighlights(searchProcessor.resultsCopy, searchProcessor.query)
+        TypeResult.Nothing
+      }
+    }
+  }
+  
+  class SelectTag internal constructor(
+    private val actions: SessionActions,
+    jumpEditors: List<Editor>,
+    searchProcessor: SearchProcessor,
+  ) : SessionState {
+    private val tagger = Tagger(jumpEditors, searchProcessor.resultsCopy)
+    
+    init {
+      actions.setTagMarkers(tagger.markers)
+    }
+    
+    override fun type(char: Char): TypeResult {
+      return when (val result = tagger.type(char)) {
+        is TaggingResult.Nothing -> TypeResult.Nothing
+        is TaggingResult.Accept  -> TypeResult.AcceptTag(result.tag)
+        is TaggingResult.Mark    -> {
+          actions.setTagMarkers(result.markers)
+          TypeResult.Nothing
+        }
+      }
+    }
+  }
 }

src/main/kotlin/org/acejump/session/SessionStateImpl.kt

@@ -1,36 +0,0 @@
-package org.acejump.session
-
-import com.intellij.openapi.editor.Editor
-import org.acejump.action.AceTagAction
-import org.acejump.boundaries.Boundaries
-import org.acejump.search.SearchProcessor
-import org.acejump.search.Tag
-import org.acejump.search.Tagger
-
-internal class SessionStateImpl(
-  private val jumpEditors: List<Editor>,
-  private val tagger: Tagger,
-  private val defaultBoundary: Boundaries,
-  processor: SearchProcessor? = null
-) : SessionState {
-  internal var currentProcessor: SearchProcessor? = processor
-  
-  override fun type(char: Char): TypeResult {
-    val processor = currentProcessor
-    
-    if (processor == null) {
-      val newProcessor = SearchProcessor.fromChar(jumpEditors, char, defaultBoundary)
-      return TypeResult.UpdateResults(newProcessor.also { currentProcessor = it })
-    }
-    
-    if (processor.type(char, tagger)) {
-      return TypeResult.UpdateResults(processor)
-    }
-    
-    return TypeResult.Nothing
-  }
-  
-  override fun act(action: AceTagAction, tag: Tag, shiftMode: Boolean, isFinal: Boolean) {
-    currentProcessor?.let { action(tag.editor, it, tag.offset, shiftMode, isFinal) }
-  }
-}

src/main/kotlin/org/acejump/session/TypeResult.kt

@@ -1,12 +1,12 @@
 package org.acejump.session
 
 import org.acejump.modes.SessionMode
-import org.acejump.search.SearchProcessor
+import org.acejump.search.Tag
 
 sealed class TypeResult {
   object Nothing : TypeResult()
-  class UpdateResults(val processor: SearchProcessor) : TypeResult()
+  class ChangeState(val state: SessionState) : TypeResult()
   class ChangeMode(val mode: SessionMode) : TypeResult()
-  object RestartSearch : TypeResult()
+  class AcceptTag(val tag: Tag) : TypeResult()
   object EndSession : TypeResult()
 }

src/main/kotlin/org/acejump/view/TagCanvas.kt

@@ -2,8 +2,7 @@ package org.acejump.view
 
 import com.intellij.openapi.application.ApplicationInfo
 import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.editor.event.CaretEvent
-import com.intellij.openapi.editor.event.CaretListener
+import com.intellij.ui.ColorUtil
 import org.acejump.boundaries.EditorOffsetCache
 import org.acejump.boundaries.StandardBoundaries
 import java.awt.Graphics
@@ -16,8 +15,9 @@ import javax.swing.SwingUtilities
 /**
  * Holds all active tag markers and renders them on top of the editor.
  */
-internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListener {
-  private var markers: Collection<TagMarker>? = null
+internal class TagCanvas(private val editor: Editor) : JComponent() {
+  private var markers: Collection<TagMarker> = emptyList()
+  private var visible = false
   
   init {
     val contentComponent = editor.contentComponent
@@ -27,43 +27,38 @@ internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListen
     if (ApplicationInfo.getInstance().build.components.first() < 173) {
       SwingUtilities.convertPoint(this, location, editor.component.rootPane).let { setLocation(-it.x, -it.y) }
     }
-    
-    editor.caretModel.addCaretListener(this)
   }
   
   fun unbind() {
-    markers = null
     editor.contentComponent.remove(this)
-    editor.caretModel.removeCaretListener(this)
-  }
-  
-  /**
-   * Ensures that all tags and the outline around the selected tag are repainted. It should not be necessary to repaint the entire tag
-   * canvas, but the cost of repainting visible tags is negligible.
-   */
-  override fun caretPositionChanged(event: CaretEvent) {
-    repaint()
+    editor.contentComponent.repaint()
   }
   
   fun setMarkers(markers: Collection<TagMarker>) {
     this.markers = markers
+    this.visible = true
     repaint()
   }
   
   fun removeMarkers() {
     this.markers = emptyList()
-  }
-  
-  override fun paint(g: Graphics) {
-    if (!markers.isNullOrEmpty()) {
-      super.paint(g)
-    }
+    this.visible = false
+    repaint()
   }
   
   override fun paintChildren(g: Graphics) {
     super.paintChildren(g)
     
-    val markers = markers ?: return
+    if (!visible) {
+      return
+    }
+    
+    g.color = ColorUtil.withAlpha(editor.colorsScheme.defaultBackground, 0.6)
+    g.fillRect(0, 0, width - 1, height - 1)
+    
+    if (markers.isEmpty()) {
+      return
+    }
     
     (g as Graphics2D).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
     
@@ -73,18 +68,8 @@ internal class TagCanvas(private val editor: Editor) : JComponent(), CaretListen
     val viewRange = StandardBoundaries.VISIBLE_ON_SCREEN.getOffsetRange(editor, cache)
     val occupied = mutableListOf<Rectangle>()
     
-    // If there is a tag at the caret location, prioritize its rendering over all other tags. This is helpful for seeing which tag is
-    // currently selected while navigating highly clustered tags, although it does end up rearranging nearby tags which can be confusing.
-    
-    // TODO instead of immediately painting, we could calculate the layout of everything first, and then remove tags that interfere with
-    //      the caret tag to avoid changing the alignment of the caret tag
-    
-    val caretOffset = editor.caretModel.offset
-    val caretMarker = markers.find { it.offsetL == caretOffset || it.offsetR == caretOffset }
-    caretMarker?.paint(g, editor, cache, font, occupied)
-    
     for (marker in markers) {
-      if (marker.isOffsetInRange(viewRange) && marker !== caretMarker) {
+      if (marker.offset in viewRange) {
         marker.paint(g, editor, cache, font, occupied)
       }
     }

src/main/kotlin/org/acejump/view/TagFont.kt

@@ -2,23 +2,18 @@ package org.acejump.view
 
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.colors.EditorFontType
-import com.intellij.ui.ColorUtil
 import org.acejump.config.AceConfig
 import java.awt.Font
-import java.awt.FontMetrics
 
 /**
  * Stores font metrics for aligning and rendering [TagMarker]s.
  */
 internal class TagFont(editor: Editor) {
-  val tagFont: Font = editor.colorsScheme.getFont(EditorFontType.BOLD)
+  val tagFont: Font = editor.colorsScheme.getFont(EditorFontType.PLAIN)
   val tagCharWidth = editor.component.getFontMetrics(tagFont).charWidth('W')
   
   val foregroundColor = AceConfig.tagForegroundColor
-  var backgroundColor = AceConfig.tagBackgroundColor
-  val isForegroundDark = ColorUtil.isDark(foregroundColor)
   
-  val editorFontMetrics: FontMetrics = editor.component.getFontMetrics(editor.colorsScheme.getFont(EditorFontType.PLAIN))
   val lineHeight = editor.lineHeight
   val baselineDistance = editor.ascent
 }

src/main/kotlin/org/acejump/view/TagMarker.kt

@@ -2,54 +2,38 @@ package org.acejump.view
 
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.SystemInfo
-import com.intellij.ui.scale.JBUIScale
 import org.acejump.boundaries.EditorOffsetCache
-import org.acejump.boundaries.StandardBoundaries
-import org.acejump.countMatchingCharacters
-import org.acejump.immutableText
 import java.awt.Color
 import java.awt.Graphics2D
 import java.awt.Point
 import java.awt.Rectangle
-import kotlin.math.max
 
 /**
  * Describes a 1 or 2 character shortcut that points to a specific character in the editor.
  */
 internal class TagMarker(
   private val tag: String,
-  val offsetL: Int,
-  val offsetR: Int,
-  private val shiftR: Int,
-  private val hasSpaceRight: Boolean
+  val offset: Int
 ) {
   private val length = tag.length
   
   companion object {
-    private const val ARC = 1
-    
     /**
      * TODO This might be due to DPI settings.
      */
     private val HIGHLIGHT_OFFSET = if (SystemInfo.isMac) -0.5 else 0.0
     
-    private val SHADOW_COLOR = Color(0F, 0F, 0F, 0.35F)
-    
     /**
      * Creates a new tag, precomputing some information about the nearby characters to reduce rendering overhead. If the last typed
-     * character ([literalQueryText]) matches the first [tag] character, only the second [tag] character is displayed.
+     * character ([typedTag]) matches the first [tag] character, only the second [tag] character is displayed.
      */
-    fun create(editor: Editor, tag: String, offset: Int, literalQueryText: String?): TagMarker {
-      val chars = editor.immutableText
-      val matching = literalQueryText?.let { chars.countMatchingCharacters(offset, it) } ?: 0
-      val hasSpaceRight = offset + 1 >= chars.length || chars[offset + 1].isWhitespace()
-      
-      val displayedTag = if (literalQueryText != null && literalQueryText.last().equals(tag.first(), ignoreCase = true))
-        tag.drop(1).toUpperCase()
+    fun create(tag: String, offset: Int, typedTag: String): TagMarker {
+      val displayedTag = if (typedTag.isNotEmpty() && typedTag.last().equals(tag.first(), ignoreCase = true))
+        tag.drop(1).uppercase()
       else
-        tag.toUpperCase()
+        tag.uppercase()
       
-      return TagMarker(displayedTag, offset, offset + max(0, matching - 1), tag.length - displayedTag.length, hasSpaceRight)
+      return TagMarker(displayedTag, offset)
     }
     
     /**
@@ -58,7 +42,7 @@ internal class TagMarker(
     private fun drawHighlight(g: Graphics2D, rect: Rectangle, color: Color) {
       g.color = color
       g.translate(0.0, HIGHLIGHT_OFFSET)
-      g.fillRoundRect(rect.x, rect.y, rect.width, rect.height + 1, ARC, ARC)
+      g.fillRect(rect.x, rect.y, rect.width, rect.height + 1)
       g.translate(0.0, -HIGHLIGHT_OFFSET)
     }
     
@@ -66,29 +50,12 @@ internal class TagMarker(
      * Renders the tag text.
      */
     private fun drawForeground(g: Graphics2D, font: TagFont, point: Point, text: String) {
-      val x = point.x + 2
-      val y = point.y + font.baselineDistance
-      
-      g.font = font.tagFont
-      
-      if (!font.isForegroundDark) {
-        g.color = SHADOW_COLOR
-        g.drawString(text, x + 1, y + 1)
-      }
-      
       g.color = font.foregroundColor
-      g.drawString(text, x, y)
+      g.font = font.tagFont
+      g.drawString(text, point.x, point.y + font.baselineDistance)
     }
   }
   
-  /**
-   * Returns true if the left-aligned offset is in the range. Use to cull tags outside visible range.
-   * Only the left offset is checked, because if the tag was right-aligned on the last index of the range, it would not be visible anyway.
-   */
-  fun isOffsetInRange(range: IntRange): Boolean {
-    return offsetL in range
-  }
-  
   /**
    * Paints the tag, taking into consideration visual space around characters in the editor, as well as all other previously painted tags.
    * Returns a rectangle indicating the area where the tag was rendered, or null if the tag could not be rendered due to overlap.
@@ -96,43 +63,16 @@ internal class TagMarker(
   fun paint(g: Graphics2D, editor: Editor, cache: EditorOffsetCache, font: TagFont, occupied: MutableList<Rectangle>): Rectangle? {
     val rect = alignTag(editor, cache, font, occupied) ?: return null
     
-    drawHighlight(g, rect, font.backgroundColor)
+    drawHighlight(g, rect, editor.colorsScheme.defaultBackground)
     drawForeground(g, font, rect.location, tag)
     
-    occupied.add(JBUIScale.scale(2).let { Rectangle(rect.x - it, rect.y, rect.width + (2 * it), rect.height) })
+    occupied.add(rect)
     return rect
   }
   
   private fun alignTag(editor: Editor, cache: EditorOffsetCache, font: TagFont, occupied: List<Rectangle>): Rectangle? {
-    val boundaries = StandardBoundaries.VISIBLE_ON_SCREEN
-    
-    if (hasSpaceRight || offsetL == 0 || editor.immutableText[offsetL - 1].let { it == '\n' || it == '\r' }) {
-      val rectR = createRightAlignedTagRect(editor, cache, font)
-      return rectR.takeIf { boundaries.isOffsetInside(editor, offsetR, cache) && occupied.none(rectR::intersects) }
-    }
-    
-    val rectL = createLeftAlignedTagRect(editor, cache, font)
-    if (occupied.none(rectL::intersects)) {
-      return rectL.takeIf { boundaries.isOffsetInside(editor, offsetL, cache) }
-    }
-    
-    val rectR = createRightAlignedTagRect(editor, cache, font)
-    if (occupied.none(rectR::intersects)) {
-      return rectR.takeIf { boundaries.isOffsetInside(editor, offsetR, cache) }
-    }
-    
-    return null
-  }
-  
-  private fun createRightAlignedTagRect(editor: Editor, cache: EditorOffsetCache, font: TagFont): Rectangle {
-    val pos = cache.offsetToXY(editor, offsetR)
-    val shift = font.editorFontMetrics.charWidth(editor.immutableText[offsetR]) + (font.tagCharWidth * shiftR)
-    return Rectangle(pos.x + shift, pos.y, (font.tagCharWidth * length) + 4, font.lineHeight)
-  }
-  
-  private fun createLeftAlignedTagRect(editor: Editor, cache: EditorOffsetCache, font: TagFont): Rectangle {
-    val pos = cache.offsetToXY(editor, offsetL)
-    val shift = -(font.tagCharWidth * length)
-    return Rectangle(pos.x + shift - 4, pos.y, (font.tagCharWidth * length) + 4, font.lineHeight)
+    val pos = cache.offsetToXY(editor, offset)
+    val rect = Rectangle(pos.x, pos.y, font.tagCharWidth * length, font.lineHeight)
+    return rect.takeIf { occupied.none(it::intersects) }
   }
 }

src/main/kotlin/org/acejump/view/TextHighlighter.kt

@@ -6,13 +6,12 @@ import com.intellij.openapi.editor.markup.CustomHighlighterRenderer
 import com.intellij.openapi.editor.markup.HighlighterLayer
 import com.intellij.openapi.editor.markup.HighlighterTargetArea
 import com.intellij.openapi.editor.markup.RangeHighlighter
-import it.unimi.dsi.fastutil.ints.IntArrayList
+import com.intellij.ui.ColorUtil
 import it.unimi.dsi.fastutil.ints.IntList
 import org.acejump.boundaries.EditorOffsetCache
 import org.acejump.config.AceConfig
 import org.acejump.immutableText
 import org.acejump.search.SearchQuery
-import org.acejump.search.Tag
 import java.awt.Color
 import java.awt.Graphics
 
@@ -32,13 +31,6 @@ internal class TextHighlighter {
     }, query::getHighlightLength)
   }
   
-  /**
-   * Removes all current highlights and re-adds a single highlight at the position of the accepted tag with a different color.
-   */
-  fun renderFinal(tag: Tag, query: SearchQuery) {
-    render(mutableMapOf(tag.editor to IntArrayList(intArrayOf(tag.offset))), AcceptedTagRenderer, query::getHighlightLength)
-  }
-  
   private inline fun render(results: Map<Editor, IntList>, renderer: CustomHighlighterRenderer, getHighlightLength: (CharSequence, Int) -> Int) {
     for ((editor, offsets) in results) {
       val highlights = previousHighlights[editor]
@@ -88,7 +80,7 @@ internal class TextHighlighter {
    */
   private object SearchedWordRenderer : CustomHighlighterRenderer {
     override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
-      drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset, AceConfig.textHighlightColor)
+      drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset, AceConfig.searchHighlightColor)
     }
   }
   
@@ -97,16 +89,7 @@ internal class TextHighlighter {
    */
   private object RegexRenderer : CustomHighlighterRenderer {
     override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
-      drawSingle(g, editor, highlighter.startOffset, AceConfig.textHighlightColor)
-    }
-  }
-  
-  /**
-   * Renders a filled highlight in the background of the accepted tag position and search query.
-   */
-  private object AcceptedTagRenderer : CustomHighlighterRenderer {
-    override fun paint(editor: Editor, highlighter: RangeHighlighter, g: Graphics) {
-      drawFilled(g, editor, highlighter.startOffset, highlighter.endOffset, AceConfig.acceptedTagColor)
+      drawSingle(g, editor, highlighter.startOffset, AceConfig.searchHighlightColor)
     }
   }
   
@@ -117,10 +100,10 @@ internal class TextHighlighter {
       val start = EditorOffsetCache.Uncached.offsetToXY(editor, startOffset)
       val end = EditorOffsetCache.Uncached.offsetToXY(editor, endOffset)
       
-      g.color = color
+      g.color = ColorUtil.withAlpha(AceConfig.searchHighlightColor, 0.2)
       g.fillRect(start.x, start.y + 1, end.x - start.x, editor.lineHeight - 1)
       
-      g.color = AceConfig.tagBackgroundColor
+      g.color = color
       g.drawRect(start.x, start.y, end.x - start.x, editor.lineHeight)
     }
     
@@ -130,10 +113,10 @@ internal class TextHighlighter {
       val font = editor.colorsScheme.getFont(EditorFontType.PLAIN)
       val lastCharWidth = editor.component.getFontMetrics(font).charWidth(char)
       
-      g.color = color
+      g.color = ColorUtil.withAlpha(AceConfig.searchHighlightColor, 0.2)
       g.fillRect(pos.x, pos.y + 1, lastCharWidth, editor.lineHeight - 1)
       
-      g.color = AceConfig.tagBackgroundColor
+      g.color = color
       g.drawRect(pos.x, pos.y, lastCharWidth, editor.lineHeight)
     }
   }

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

@@ -24,7 +24,7 @@
                          implementationClass="org.acejump.action.AceEditorAction$Reset"/>
     <editorActionHandler action="EditorBackSpace" order="first"
                          implementationClass="org.acejump.action.AceEditorAction$ClearSearch"/>
-    <editorActionHandler action="EditorEnter" order="first"
+    <editorActionHandler action="EditorEnter" order="first, before terminalEnter"
                          implementationClass="org.acejump.action.AceEditorAction$TagImmediately"/>
   </extensions>
   

src/test/kotlin/AceTest.kt

@@ -1,36 +0,0 @@
-
-import org.acejump.test.util.BaseTest
-
-/**
- * Functional test cases and end-to-end performance tests.
- *
- * TODO: Add more structure to test cases, use test resources to define files.
- */
-
-class AceTest : BaseTest() {
-  fun `test that scanner finds all occurrences of single character`() =
-    assertEquals("test test test".search("t"), setOf(0, 3, 5, 8, 10, 13))
-
-  fun `test empty results for an absent query`() =
-    assertEmpty("test test test".search("best"))
-
-  fun `test sticky results on a query with extra characters`() =
-    assertEquals("test test test".search("testz"), setOf(0, 5, 10))
-
-  fun `test a query inside text with some variations`() =
-    assertEquals("abcd dabc cdab".search("cd"), setOf(2, 10))
-
-  fun `test a query containing a space character`() =
-    assertEquals("abcd dabc cdab".search("cd "), setOf(2))
-
-  fun `test a query containing a { character`() =
-    assertEquals("abcd{dabc cdab".search("cd{"), setOf(2))
-
-  fun `test tag selection`() {
-    "<caret>testing 1234".search("g")
-
-    typeAndWaitForResults(session.tags[0].key)
-
-    myFixture.checkResult("testin<caret>g 1234")
-  }
-}