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(