refactor: transpile_description mutates the description

graphqxl_transpiler/src/transpile_block_def.rs

@@ -53,8 +53,8 @@ pub(crate) fn transpile_block_def(
                     seen.insert(field.name.id.clone());
                     let mut field_clone = field.clone();
                     if !parent.is_empty() {
-                        field_clone.description = transpile_description(
-                            &field.description,
+                        transpile_description(
+                            &mut field_clone.description,
                             &HashMap::from([(PARENT, block_def.name.id.clone())]),
                         );
                     }

graphqxl_transpiler/src/transpile_description.rs

@@ -1,12 +1,12 @@
 use std::collections::HashMap;
 
-pub(crate) fn transpile_description(description: &str, replace: &HashMap<&str, String>) -> String {
+pub(crate) fn transpile_description(description: &mut String, replace: &HashMap<&str, String>) {
     let mut replaced = description.to_string();
     for (key, value) in replace.iter() {
         let replacement = replaced.replace(&format!("${key}"), value);
         replaced = replacement;
     }
-    replaced
+    *description = replaced;
 }
 
 #[cfg(test)]
@@ -15,26 +15,21 @@ mod tests {
 
     #[test]
     fn test_replaces_if_match() {
-        assert_eq!(
-            transpile_description(
-                "This must be replaced: $T",
-                &HashMap::from([
-                    ("T", "Replacement".to_string()),
-                    ("I", "Ignored".to_string())
-                ])
-            ),
-            "This must be replaced: Replacement"
-        )
+        let mut string = "This must be replaced: $T".to_string();
+        transpile_description(
+            &mut string,
+            &HashMap::from([
+                ("T", "Replacement".to_string()),
+                ("I", "Ignored".to_string()),
+            ]),
+        );
+        assert_eq!(string, "This must be replaced: Replacement")
     }
 
     #[test]
     fn test_replaces_nothing() {
-        assert_eq!(
-            transpile_description(
-                "This must not be replaced: $T",
-                &HashMap::from([("I", "Ignored".to_string())])
-            ),
-            "This must not be replaced: $T"
-        )
+        let mut string = "This must not be replaced: $T".to_string();
+        transpile_description(&mut string, &HashMap::from([("I", "Ignored".to_string())]));
+        assert_eq!(string, "This must not be replaced: $T")
     }
 }

graphqxl_transpiler/src/transpile_generic_block_def.rs

@@ -60,24 +60,25 @@ fn resolve_block_def(
     resolved_block_def.generic = None;
     resolved_block_def.name = generic_block_def.name.clone();
 
-    let mut replacements = HashMap::from([(GENERIC, generic_block_def.name.id.clone())]);
+    let mut description_replacements =
+        HashMap::from([(GENERIC, generic_block_def.name.id.clone())]);
     for (key, value) in generic_map.iter() {
-        let formatted_type = format!("{}", value.retrieve_basic_type());
-        replacements.insert(key.as_str(), formatted_type);
+        description_replacements.insert(key.as_str(), format!("{}", value.retrieve_basic_type()));
     }
 
     if !generic_block_def.description.is_empty() {
         resolved_block_def.description = generic_block_def.description.clone()
     } else {
-        resolved_block_def.description =
-            transpile_description(&resolved_block_def.description, &replacements);
+        transpile_description(
+            &mut resolved_block_def.description,
+            &description_replacements,
+        );
     }
 
     for entry in resolved_block_def.entries.iter_mut() {
         // if it is a field...
         if let BlockEntry::Field(block_field) = entry {
-            block_field.description =
-                transpile_description(&block_field.description, &replacements);
+            transpile_description(&mut block_field.description, &description_replacements);
             // ...and has a type...
             if let Some(value_type) = &block_field.value_type {
                 let basic_value_type = value_type.retrieve_basic_type();