fix(keymap): accessible-keymaps follows parent keymaps (breadth-first)

`accessible-keymaps` used a depth-first walk that deliberately stopped at a
keymap's parent ("parent keymap, don't descend"), so prefix maps reachable only
through the parent were omitted -- e.g. a child and parent both binding C-c to
different prefix maps listed one [3] entry instead of GNU's two.

Rewrite it to mirror GNU `Faccessible_keymaps` (keymap.c): a breadth-first walk
over a growing (prefix, map) queue, scanning each map's bindings via a new
map_keymap-style walker that follows the parent chain (reporting embedded prefix
maps as bindings without descending). Enqueue a map again under a
longer/unrelated prefix but skip it when an already-queued strict-prefix path
reaches the same map -- GNU's cycle rule, which reproduces GNU's duplicate
listings and terminates on self-referential parents. Also picks up char-table
bindings the old DFS missed.

Update the guard unit test (which asserted the non-GNU no-descend behavior) to
expect the parent's prefix map. Verified against GNU: combo case now
([] [3] [3]); BFS ordering ([] [3] [24] [3 4]) matches.

Fixes keymap_parent_accessible_keymaps_combo.

Author: eval-exec

neovm-core/src/emacs_core/builtins/keymaps.rs

@@ -210,9 +210,7 @@ pub(crate) fn builtin_accessible_keymaps_impl(obarray: &Obarray, args: &[Value])
 
     // Collect all accessible keymaps
     let mut all_out = Vec::new();
-    let mut prefix = Vec::new();
-    let mut seen = Vec::new();
-    list_keymap_accessible(&keymap, &mut prefix, &mut all_out, &mut seen);
+    list_keymap_accessible(&keymap, &mut all_out);
 
     // If prefix argument is provided, filter results
     if let Some(prefix_arg) = args.get(1) {

neovm-core/src/emacs_core/keymap.rs

@@ -3281,59 +3281,90 @@ fn copy_char_table_for_keymap(ct: &Value, depth: usize) -> Value {
     copied
 }
 
-/// Collect all accessible sub-keymaps with their key prefixes.
-pub fn list_keymap_accessible(
-    keymap: &Value,
-    prefix: &mut Vec<Value>,
-    out: &mut Vec<Value>,
-    seen: &mut Vec<Value>,
-) {
-    // Detect cycles: check if we've seen this exact keymap object
-    for s in seen.iter() {
-        if keymap_value_eq(s, keymap) {
-            return;
+/// Walk KEYMAP's own bindings and those of its parent chain, mirroring GNU
+/// `map_keymap`: it reports embedded/prefix keymaps as ordinary bindings
+/// (without descending into them) and then FOLLOWS the parent keymap. Bounded
+/// against self-referential parents by walking each map object at most once.
+fn map_keymap_following_parents<F>(keymap: &Value, mut f: F)
+where
+    F: FnMut(Value, Value),
+{
+    let mut map = *keymap;
+    let mut seen_maps: Vec<Value> = Vec::new();
+    while is_list_keymap(&map) {
+        if seen_maps.iter().any(|m| keymap_value_eq(m, &map)) {
+            break;
         }
-    }
-    seen.push(*keymap);
-
-    // Add current keymap
-    out.push(Value::cons(Value::vector(prefix.clone()), *keymap));
-
-    if !keymap.is_cons() {
-        return;
-    };
-    let pair_car = keymap.cons_car();
-    let pair_cdr = keymap.cons_cdr();
-    if !KeymapMarker::Keymap.is_value(pair_car) {
-        return;
-    }
+        seen_maps.push(map);
 
-    // Scan alist entries for prefix keymaps
-    let mut cursor = pair_cdr;
-    while cursor.is_cons() {
-        if is_list_keymap(&cursor) {
+        let Some(mut cursor) = keymap_binding_spine(&map) else {
             break;
-        }
-        let entry_car = cursor.cons_car();
-        let entry_cdr = cursor.cons_cdr();
+        };
+        while cursor.is_cons() {
+            if is_list_keymap(&cursor) {
+                break; // reached the parent keymap
+            }
+            let entry_car = cursor.cons_car();
+            let entry_cdr = cursor.cons_cdr();
 
-        if entry_car.is_cons() {
-            let binding_car = entry_car.cons_car();
-            let binding_cdr = entry_car.cons_cdr();
-            if is_list_keymap(&binding_cdr) {
-                prefix.push(binding_car);
-                list_keymap_accessible(&binding_cdr, prefix, out, seen);
-                prefix.pop();
+            if super::chartable::is_char_table(&entry_car) {
+                super::chartable::for_each_non_nil_char_table_run(&entry_car, &mut f);
+            }
+            if entry_car.is_cons() {
+                f(entry_car.cons_car(), entry_car.cons_cdr());
             }
-        }
 
-        if is_list_keymap(&entry_cdr) {
-            break; // parent keymap, don't descend
+            if is_list_keymap(&entry_cdr) {
+                break; // the parent follows; handled by the outer loop
+            }
+            cursor = entry_cdr;
+        }
+        map = get_keymap_tail_parent(&map);
+    }
+}
+
+/// Collect all accessible sub-keymaps with their key prefixes, mirroring GNU
+/// `Faccessible_keymaps` (keymap.c). This is a breadth-first walk over a growing
+/// queue of `(prefix, map)` pairs: for each queued map we scan its bindings
+/// (following parents, per GNU `map_keymap`) and enqueue every prefix sub-map.
+/// A map is enqueued again under a longer/unrelated prefix, but skipped when an
+/// already-queued strict-prefix path reaches the same map (GNU's cycle rule),
+/// which both matches GNU's duplicate listings and terminates on cycles.
+pub fn list_keymap_accessible(keymap: &Value, out: &mut Vec<Value>) {
+    let mut maps: Vec<(Vec<Value>, Value)> = vec![(Vec::new(), *keymap)];
+    let mut i = 0;
+    while i < maps.len() {
+        let thisseq = maps[i].0.clone();
+        let thismap = maps[i].1;
+        i += 1;
+
+        let mut found: Vec<(Vec<Value>, Value)> = Vec::new();
+        map_keymap_following_parents(&thismap, |event, def| {
+            if is_list_keymap(&def) {
+                let mut newseq = thisseq.clone();
+                newseq.push(event);
+                found.push((newseq, def));
+            }
+        });
+
+        for (newseq, submap) in found {
+            let is_cycle = maps.iter().any(|(prefix, map)| {
+                keymap_value_eq(map, &submap)
+                    && prefix.len() < newseq.len()
+                    && prefix
+                        .iter()
+                        .zip(newseq.iter())
+                        .all(|(a, b)| a.bits() == b.bits())
+            });
+            if !is_cycle {
+                maps.push((newseq, submap));
+            }
         }
-        cursor = entry_cdr;
     }
 
-    seen.pop();
+    for (prefix, map) in &maps {
+        out.push(Value::cons(Value::vector(prefix.clone()), *map));
+    }
 }
 
 /// Check if two keymap values are the same object (by cons cell identity).

neovm-core/src/emacs_core/keymap_test.rs

@@ -590,7 +590,7 @@ fn list_keymap_for_each_binding_stops_before_direct_sparse_parent() {
 }
 
 #[test]
-fn list_keymap_accessible_does_not_descend_into_direct_sparse_parent() {
+fn list_keymap_accessible_descends_into_direct_sparse_parent() {
     crate::test_utils::init_test_tracing();
     let parent = make_sparse_list_keymap();
     let prefix_map = make_sparse_list_keymap();
@@ -599,12 +599,18 @@ fn list_keymap_accessible_does_not_descend_into_direct_sparse_parent() {
     list_keymap_define(parent, Value::fixnum('a' as i64), prefix_map);
     list_keymap_set_parent(child, parent);
 
-    let mut prefix = Vec::new();
     let mut out = Vec::new();
-    let mut seen = Vec::new();
-    list_keymap_accessible(&child, &mut prefix, &mut out, &mut seen);
-
-    assert_eq!(out.len(), 1);
+    list_keymap_accessible(&child, &mut out);
+
+    // GNU `accessible-keymaps` follows the parent (via map_keymap), so the
+    // parent's `a` prefix map is listed under [?a]. GNU prints ([] [97]).
+    assert_eq!(out.len(), 2);
+    assert_eq!(out[0].cons_car().as_vector_data().unwrap().len(), 0);
+    let second_prefix = out[1].cons_car();
+    let second_prefix = second_prefix.as_vector_data().unwrap();
+    assert_eq!(second_prefix.len(), 1);
+    assert_eq!(second_prefix[0], Value::fixnum('a' as i64));
+    assert!(keymap_value_eq(&out[1].cons_cdr(), &prefix_map));
 }
 
 #[test]