Fix sticky text property insertion boundaries

Author: eval-exec

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

@@ -2931,22 +2931,12 @@ pub(crate) fn apply_inherited_text_properties(
         return;
     }
 
-    let (props, existing_keys) = buffers
+    let props = buffers
         .get(current_id)
         .map(|buf| {
-            let merged = super::misc_eval::inherited_text_properties_for_inserted_range_in_state(
+            super::misc_eval::inherited_text_properties_for_inserted_range_in_state(
                 obarray, dynamic, buf, old_pt, text_len,
-            );
-            // Properties already present on the just-inserted region (from the
-            // source string's own propertize plist).  Source properties win
-            // over inherited ones, matching GNU graft_intervals_into_buffer.
-            let existing: std::collections::HashSet<Value> = buf
-                .text
-                .text_props_get_properties_ordered(old_pt)
-                .into_iter()
-                .map(|(name, _)| name)
-                .collect();
-            (merged, existing)
+            )
         })
         .unwrap_or_default();
     if props.is_empty() {
@@ -2956,9 +2946,6 @@ pub(crate) fn apply_inherited_text_properties(
     // put_property prepends new properties to interval order, so apply the
     // merged GNU plist in reverse to preserve the final plist shape.
     for (name, value) in props.iter().rev() {
-        if existing_keys.contains(name) {
-            continue;
-        }
         let _ =
             buffers.put_buffer_text_property(current_id, old_pt, old_pt + text_len, *name, *value);
     }
@@ -3062,20 +3049,19 @@ fn insert_pieces_in_state(
         if let Some(str_table) = piece.text_props {
             let _ = buffers.append_buffer_text_properties(current_id, &str_table, insert_pos);
         }
-        // Match GNU adjust_intervals_for_insertion (intervals.c:802): every
-        // insert applies sticky-aware inheritance from the surrounding
-        // intervals, regardless of whether `insert-and-inherit` was used.
-        // Source-string properties already applied above take precedence
-        // because apply_inherited_text_properties skips keys already present.
-        let _ = inherit;
-        apply_inherited_text_properties(
-            obarray,
-            dynamic,
-            buffers,
-            current_id,
-            insert_pos,
-            piece.text.sbytes(),
-        );
+        if inherit {
+            // GNU clears surrounding inherited properties for plain `insert`
+            // after interval adjustment; only the inheriting insert variants
+            // keep sticky properties from adjoining text.
+            apply_inherited_text_properties(
+                obarray,
+                dynamic,
+                buffers,
+                current_id,
+                insert_pos,
+                piece.text.sbytes(),
+            );
+        }
     }
     Ok(Value::NIL)
 }

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

@@ -716,15 +716,20 @@ pub(crate) fn inherited_text_properties_for_inserted_range_in_state(
     insert_start: usize,
     insert_len: usize,
 ) -> Vec<(Value, Value)> {
-    let left_props = if insert_start > buf.point_min_byte() {
-        buf.text
-            .text_props_get_properties_ordered(insert_start.saturating_sub(1))
+    let insert_start_char = buf.text.emacs_byte_to_char(insert_start);
+    let left_props = if insert_start_char > buf.point_min_char() {
+        let left_byte = buf
+            .text
+            .char_to_emacs_byte(insert_start_char.saturating_sub(1));
+        buf.text.text_props_get_properties_ordered(left_byte)
     } else {
         Vec::new()
     };
     let right_pos = insert_start.saturating_add(insert_len);
-    let right_props = if right_pos < buf.point_max_byte() {
-        buf.text.text_props_get_properties_ordered(right_pos)
+    let right_char = buf.text.emacs_byte_to_char(right_pos);
+    let right_props = if right_char < buf.point_max_char() {
+        let right_byte = buf.text.char_to_emacs_byte(right_char);
+        buf.text.text_props_get_properties_ordered(right_byte)
     } else {
         Vec::new()
     };

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

@@ -2244,6 +2244,30 @@ fn plain_insert_does_not_inherit_spanning_text_properties() {
     );
 }
 
+#[test]
+fn insert_inherits_left_multibyte_text_property_at_char_boundary() {
+    crate::test_utils::init_test_tracing();
+    let mut eval = super::super::eval::Context::new();
+    {
+        let buf = eval.buffers.current_buffer_mut().expect("current buffer");
+        buf.insert("é");
+        buf.text
+            .text_props_put_property(0, 2, Value::symbol("face"), Value::symbol("bold"));
+    }
+
+    assert_eq!(
+        builtin_insert_and_inherit(&mut eval, vec![Value::string("X")]).unwrap(),
+        Value::NIL
+    );
+
+    let buf = eval.buffers.current_buffer().expect("current buffer");
+    assert_eq!(buf.buffer_string(), "éX");
+    assert_eq!(
+        buf.text.text_props_get_property(2, Value::symbol("face")),
+        Some(Value::symbol("bold"))
+    );
+}
+
 #[test]
 fn insert_char_nil_count_defaults_to_one_and_can_inherit_text_properties() {
     crate::test_utils::init_test_tracing();