Borrow compact insertion spans and repair omission test oracles

crates/oa-core/src/source_project.rs

@@ -1166,22 +1166,24 @@ fn inserted_value(text: &str, indent: &str, source: &str) -> String {
 // declaration field is itself omittable. For example, a selected String type
 // needs minimum_length; an Event Signal needs items. The complete tree remains
 // the comparison authority; this parallel tree is only an insertion template.
-struct InsertionSyntax {
-    values: BTreeMap<usize, String>,
+struct InsertionSyntax<'a> {
+    source: &'a str,
+    values: BTreeMap<usize, Span>,
     omitted_fields: BTreeSet<usize>,
 }
-impl InsertionSyntax {
+impl<'a> InsertionSyntax<'a> {
     fn new(
         complete: &language::EditValue,
         compact_values: &language::EditValue,
-        source: &str,
+        source: &'a str,
         compact: &language::EditValue,
     ) -> Self {
         let mut result = Self {
+            source,
             values: BTreeMap::new(),
             omitted_fields: BTreeSet::new(),
         };
-        result.collect(complete, compact_values, source);
+        result.collect(complete, compact_values);
         if let (language::EditKind::Record(all), language::EditKind::Record(kept)) =
             (&complete.kind, &compact.kind)
         {
@@ -1193,21 +1195,15 @@ impl InsertionSyntax {
         }
         result
     }
-    fn collect(
-        &mut self,
-        complete: &language::EditValue,
-        compact: &language::EditValue,
-        source: &str,
-    ) {
-        self.values.insert(
-            complete.span.start,
-            source[compact.span.start..compact.span.end].to_owned(),
-        );
+    fn collect(&mut self, complete: &language::EditValue, compact: &language::EditValue) {
+        // Borrow the existing compact text once. Copying each containing record
+        // here would duplicate a large nested payload at every depth.
+        self.values.insert(complete.span.start, compact.span);
         match (&complete.kind, &compact.kind) {
             (language::EditKind::Record(all), language::EditKind::Record(kept)) => {
                 for (key, field) in all {
                     if let Some(next) = kept.get(key) {
-                        self.collect(&field.value, &next.value, source);
+                        self.collect(&field.value, &next.value);
                     } else {
                         self.omitted_fields.insert(field.value.span.start);
                     }
@@ -1220,7 +1216,7 @@ impl InsertionSyntax {
                     "compaction preserves array membership"
                 );
                 for (field, next) in all.iter().zip(kept) {
-                    self.collect(field, next, source);
+                    self.collect(field, next);
                 }
             }
             _ => {}
@@ -1232,7 +1228,7 @@ struct SyntaxUpdate<'a> {
     source: &'a str,
     before: &'a str,
     after: &'a str,
-    insertion: Option<&'a InsertionSyntax>,
+    insertion: Option<&'a InsertionSyntax<'a>>,
     old_aliases: &'a BTreeMap<String, String>,
     new_aliases: &'a BTreeMap<String, String>,
     // Source3 migration only adds path qualification; the existing field identity
@@ -1243,8 +1239,12 @@ struct SyntaxUpdate<'a> {
 impl SyntaxUpdate<'_> {
     fn inserted(&self, value: &language::EditValue) -> &str {
         self.insertion
-            .and_then(|syntax| syntax.values.get(&value.span.start))
-            .map(String::as_str)
+            .and_then(|syntax| {
+                syntax
+                    .values
+                    .get(&value.span.start)
+                    .map(|span| &syntax.source[span.start..span.end])
+            })
             .unwrap_or(&self.after[value.span.start..value.span.end])
     }
     fn header(

crates/oa-core/tests/language.rs

@@ -3,6 +3,16 @@ use oa_core::{language, persistence, validation, *};
 fn read(source: &str) -> Project {
     language::parse(source).unwrap_or_else(|e| panic!("{e:?}\n{source}"))
 }
+fn replace_once(source: &str, before: &str, after: &str) -> String {
+    assert_eq!(
+        source.matches(before).count(),
+        1,
+        "unique mutation anchor {before:?}"
+    );
+    let changed = source.replacen(before, after, 1);
+    assert_ne!(changed, source, "test mutation must change the source");
+    changed
+}
 fn rejected(source: &str, fragment: &str) {
     let errors = language::parse(source).expect_err(source);
     assert!(
@@ -753,8 +763,8 @@ fn typed_events_vertices_and_transition_kinds_round_trip_in_both_layers() {
         source.push('}');
         let model = read(&source);
         let canonical = language::format(&model);
+        assert!(!canonical.contains("transition_kind External;"));
         for fragment in [
-            "transition_kind External;",
             "transition_kind Local;",
             "transition_kind Internal;",
             "triggers [@deadline, @assess];",
@@ -776,6 +786,7 @@ fn typed_events_vertices_and_transition_kinds_round_trip_in_both_layers() {
             .find(|r| r.alias == "recover")
             .unwrap();
         let RelationBody::StateTransition {
+            transition_kind,
             trigger,
             guard,
             effect,
@@ -784,32 +795,42 @@ fn typed_events_vertices_and_transition_kinds_round_trip_in_both_layers() {
         else {
             panic!("expected transition")
         };
+        assert_eq!(*transition_kind, TransitionKind::External);
         assert_eq!(trigger, "Operator confirms\nНе запускать код");
         assert_eq!(guard, "available && status == \"Ready\"");
         assert_eq!(effect, "Record the assessment");
+        // External is omitted in compact output. Insert an explicit invalid
+        // discriminator into Recover using its unique, nondefault trigger list.
+        let invalid_kind = replace_once(
+            &canonical,
+            "triggers [@deadline, @assess];",
+            "transition_kind Unsupported;\n        triggers [@deadline, @assess];",
+        );
+        rejected(&invalid_kind, "Unsupported");
         for invalid in [
-            canonical.replace("transition_kind External;", "transition_kind Unsupported;"),
-            canonical.replace(
+            replace_once(
+                &canonical,
                 "triggers [@deadline, @assess];",
                 "triggers [\"deadline\", @assess];",
             ),
-            canonical.replace(
+            replace_once(
+                &canonical,
                 "triggers [@deadline, @assess];",
                 "triggers [@deadline, @deadline];",
             ),
-            canonical.replace("effects [@assess];", "effects [@payload];"),
-            canonical.replace("kind After;", "kind Relative;"),
-            canonical.replace("items [@payload];", "items [@assess];"),
+            replace_once(&canonical, "effects [@assess];", "effects [@payload];"),
+            replace_once(&canonical, "kind After;", "kind Relative;"),
+            replace_once(&canonical, "items [@payload];", "items [@assess];"),
         ] {
             assert!(
                 language::parse(&invalid).is_err(),
                 "invalid typed state/event source accepted"
             );
         }
-        let legacy = canonical
-            .replace("transition_kind External;", "")
-            .replace("triggers [@deadline, @assess];", "")
-            .replace("effects [@assess];", "");
+        // Canonical source already omits External. Removing the supplied lists
+        // independently exercises their empty omission defaults and retained prose.
+        let legacy = replace_once(&canonical, "triggers [@deadline, @assess];", "");
+        let legacy = replace_once(&legacy, "effects [@assess];", "");
         let legacy = read(&legacy);
         let RelationBody::StateTransition {
             transition_kind,
@@ -829,7 +850,7 @@ fn typed_events_vertices_and_transition_kinds_round_trip_in_both_layers() {
             (retained_trigger, retained_guard, retained_effect),
             (trigger, guard, effect)
         );
-        let draft = canonical.replace("expression \"30 s\";", "expression \"\";");
+        let draft = replace_once(&canonical, "expression \"30 s\";", "expression \"\";");
         assert!(language::parse(&draft).is_ok());
         let deadline = model
             .elements
@@ -1038,7 +1059,7 @@ fn original_v2_text_and_json_preserve_identity_and_mixed_scenarios_after_extensi
         "fixture must cover actual old scenario content"
     );
     let canonical = language::format(&from_source);
-    assert!(canonical.contains("viewpoint MixedLegacy;"));
+    assert!(!canonical.contains("viewpoint MixedLegacy;"));
     for relation in from_source.relations.values() {
         if let RelationBody::StateTransition {
             transition_kind,