Handle suffixes of cancelled keymaps in insert mode

helix-term/src/ui/editor.rs

@@ -930,6 +930,9 @@ impl EditorView {
     }
 
     fn insert_mode(&mut self, cx: &mut commands::Context, event: KeyEvent) {
+        let mut stack = vec![event];
+
+        while let Some(event) = stack.pop() {
             if let Some(keyresult) = self.handle_keymap_event(Mode::Insert, cx, event) {
                 match keyresult {
                     KeymapResult::NotFound => {
@@ -940,23 +943,29 @@ impl EditorView {
                         }
                     }
                     KeymapResult::Cancelled(pending) => {
-                    for ev in pending {
+                        let mut pending = pending.into_iter();
-                        match ev.char() {
+                        if let Some(first) = pending.next() {
+                            // Note that since this is the first pending key, we know
+                            // it can't map to a command by itself.
+                            match first.char() {
+                                // The first key is both the start of a menu and a regular
+                                // insert key. The user may have intended to type it as an
+                                // insert, and then execute the remaining suffix of keys.
                                 Some(ch) => commands::insert::insert_char(cx, ch),
-                            None => {
+                                // If the first key is not a character to insert, then we
-                                if let KeymapResult::Matched(command) =
+                                // assume the user intended to enter a command menu, so we
-                                    self.keymaps.get(Mode::Insert, ev)
+                                // should just discard pending keys if they don't match.
-                                {
+                                None => continue,
-                                    command.execute(cx);
-                                }
-                            }
                             }
                         }
+
+                        stack.extend(pending.rev());
                     }
                     _ => unreachable!(),
                 }
             }
         }
+    }
 
     fn command_mode(&mut self, mode: Mode, cxt: &mut commands::Context, event: KeyEvent) {
         match (event, cxt.editor.count) {

helix-term/tests/integration.rs

@@ -18,6 +18,7 @@ mod test {
     mod auto_indent;
     mod auto_pairs;
     mod commands;
+    mod insert_keymap_suffix;
     mod languages;
     mod movement;
     mod prompt;

helix-term/tests/test/helpers.rs

@@ -352,8 +352,6 @@ impl AppBuilder {
         self
     }
 
-    // Remove this attribute once `with_config` is used in a test:
-    #[allow(dead_code)]
     pub fn with_config(mut self, mut config: Config) -> Self {
         let keys = replace(&mut config.keys, helix_term::keymap::default());
         merge_keys(&mut config.keys, keys);

helix-term/tests/test/insert_keymap_suffix.rs

@@ -0,0 +1,36 @@
+use super::*;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn insert_keymap_suffix() -> anyhow::Result<()> {
+    test_with_config(
+        AppBuilder::new().with_config(config()),
+        ("#[|]#", "iselffd", "self#[|\n]#"),
+    )
+    .await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn insert_keymap_suffix_non_char() -> anyhow::Result<()> {
+    test_with_config(
+        AppBuilder::new().with_config(config()),
+        ("#[|]#", "i<F1>ua", "a#[|\n]#"),
+    )
+    .await?;
+
+    Ok(())
+}
+
+fn config() -> Config {
+    let config = r#"
+        [keys.insert]
+        f.d = "normal_mode"
+        F1.j = "insert_newline"
+    "#;
+    Config::load(
+        Ok(config.to_owned()),
+        Err(helix_term::config::ConfigLoadError::default()),
+    )
+    .unwrap()
+}