Merge branch 'master' into debug

1 files changed, 23 insertions, 22 deletions

diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index 63694d0b..128fe948 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -3,7 +3,7 @@ use crate::{
     compositor::{Component, Compositor, Context, EventResult},
     job::Callback,
     key,
-    keymap::{KeymapResult, Keymaps},
+    keymap::{KeymapResult, KeymapResultKind, Keymaps},
     ui::{Completion, ProgressSpinners},
 };
 
@@ -165,8 +165,7 @@ impl EditorView {
                 let scopes = theme.scopes();
                 syntax
                     .highlight_iter(text.slice(..), Some(range), None, |language| {
-                        loader
-                            .language_config_for_scope(&format!("source.{}", language))
+                        loader.language_configuration_for_injection_string(language)
                             .and_then(|language_config| {
                                 let config = language_config.highlight_config(scopes)?;
                                 let config_ref = config.as_ref();
@@ -852,7 +851,7 @@ impl EditorView {
 
     /// Handle events by looking them up in `self.keymaps`. Returns None
     /// if event was handled (a command was executed or a subkeymap was
-    /// activated). Only KeymapResult::{NotFound, Cancelled} is returned
+    /// activated). Only KeymapResultKind::{NotFound, Cancelled} is returned
     /// otherwise.
     fn handle_keymap_event(
         &mut self,
@@ -860,8 +859,6 @@ impl EditorView {
         cxt: &mut commands::Context,
         event: KeyEvent,
     ) -> Option<KeymapResult> {
-        self.autoinfo = None;
-
         if let Some(picker) = cxt.editor.debug_config_picker.clone() {
             match event {
                 KeyEvent {
@@ -912,29 +909,32 @@ impl EditorView {
             return None;
         }
 
-        match self.keymaps.get_mut(&mode).unwrap().get(event) {
-            KeymapResult::Matched(command) => command.execute(cxt),
-            KeymapResult::Pending(node) => self.autoinfo = Some(node.into()),
-            k @ KeymapResult::NotFound | k @ KeymapResult::Cancelled(_) => return Some(k),
+        let key_result = self.keymaps.get_mut(&mode).unwrap().get(event);
+        self.autoinfo = key_result.sticky.map(|node| node.infobox());
+
+        match &key_result.kind {
+            KeymapResultKind::Matched(command) => command.execute(cxt),
+            KeymapResultKind::Pending(node) => self.autoinfo = Some(node.infobox()),
+            KeymapResultKind::NotFound | KeymapResultKind::Cancelled(_) => return Some(key_result),
         }
         None
     }
 
     fn insert_mode(&mut self, cx: &mut commands::Context, event: KeyEvent) {
         if let Some(keyresult) = self.handle_keymap_event(Mode::Insert, cx, event) {
-            match keyresult {
-                KeymapResult::NotFound => {
+            match keyresult.kind {
+                KeymapResultKind::NotFound => {
                     if let Some(ch) = event.char() {
                         commands::insert::insert_char(cx, ch)
                     }
                 }
-                KeymapResult::Cancelled(pending) => {
+                KeymapResultKind::Cancelled(pending) => {
                     for ev in pending {
                         match ev.char() {
                             Some(ch) => commands::insert::insert_char(cx, ch),
                             None => {
-                                if let KeymapResult::Matched(command) =
-                                    self.keymaps.get_mut(&Mode::Insert).unwrap().get(ev)
+                                if let KeymapResultKind::Matched(command) =
+                                    self.keymaps.get_mut(&Mode::Insert).unwrap().get(ev).kind
                                 {
                                     command.execute(cx);
                                 }
@@ -972,7 +972,7 @@ impl EditorView {
                 // debug_assert!(cxt.count != 0);
 
                 // set the register
-                cxt.selected_register = cxt.editor.selected_register.take();
+                cxt.register = cxt.editor.selected_register.take();
 
                 self.handle_keymap_event(mode, cxt, event);
                 if self.keymaps.pending().is_empty() {
@@ -1196,9 +1196,9 @@ impl EditorView {
 impl Component for EditorView {
     fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {
         let mut cxt = commands::Context {
-            selected_register: helix_view::RegisterSelection::default(),
             editor: &mut cx.editor,
             count: None,
+            register: None,
             callback: None,
             on_next_key_callback: None,
             jobs: cx.jobs,
@@ -1288,11 +1288,12 @@ impl Component for EditorView {
                         // how we entered insert mode is important, and we should track that so
                         // we can repeat the side effect.
 
-                        self.last_insert.0 = match self.keymaps.get_mut(&mode).unwrap().get(key) {
-                            KeymapResult::Matched(command) => command,
-                            // FIXME: insert mode can only be entered through single KeyCodes
-                            _ => unimplemented!(),
-                        };
+                        self.last_insert.0 =
+                            match self.keymaps.get_mut(&mode).unwrap().get(key).kind {
+                                KeymapResultKind::Matched(command) => command,
+                                // FIXME: insert mode can only be entered through single KeyCodes
+                                _ => unimplemented!(),
+                            };
                         self.last_insert.1.clear();
                     }
                     (Mode::Insert, Mode::Normal) => {