KCL: Mostly reuse one string buffer in recaster (#7869)

Before this PR, most of the recast functions looked like this 

```
fn recast(&self, options, indentation_level) -> String
```

In other words, when they ran, they allocated and returned a string. This mean every function would perform at least 1 allocation.

Now they generally look like this:
```
fn recast(&self, buf: &mut String, options, indentation_level)
```

In other words, they usually accept a string from the caller and append to it, rather than allocating a new one. This reduces allocations (because generally the same single string can be shared across recasts) which saves time (because a huge portion of recast time was just allocating strings, appending their contents to some other string, then dropping it).

On my Macbook, this cuts down the recast benchmarks by 55-65%.

Author: adamchalmers

rust/kcl-lib/src/lib.rs

@@ -256,11 +256,11 @@ impl Program {
 
     pub fn recast(&self) -> String {
         // Use the default options until we integrate into the UI the ability to change them.
-        self.ast.recast(&Default::default(), 0)
+        self.ast.recast_top(&Default::default(), 0)
     }
 
     pub fn recast_with_options(&self, options: &FormatOptions) -> String {
-        self.ast.recast(options, 0)
+        self.ast.recast_top(options, 0)
     }
 
     /// Create an empty program.

rust/kcl-lib/src/lint/checks/camel_case.rs

@@ -35,7 +35,7 @@ fn lint_lower_camel_case_var(decl: &VariableDeclarator, prog: &AstNode<Program>)
 
         let mut prog = prog.clone();
         prog.rename_symbol(&new_name, ident.start);
-        let recast = prog.recast(&Default::default(), 0);
+        let recast = prog.recast_top(&Default::default(), 0);
 
         let suggestion = Suggestion {
             title: format!("rename '{name}' to '{new_name}'"),

rust/kcl-lib/src/lsp/kcl/mod.rs

@@ -860,7 +860,7 @@ impl Backend {
         // Now let's perform the rename on the ast.
         ast.rename_symbol(new_name, pos);
         // Now recast it.
-        let recast = ast.recast(&Default::default(), 0);
+        let recast = ast.recast_top(&Default::default(), 0);
 
         Ok(Some((current_code.to_string(), recast)))
     }
@@ -1480,7 +1480,7 @@ impl LanguageServer for Backend {
             return Ok(None);
         };
         // Now recast it.
-        let recast = ast.recast(
+        let recast = ast.recast_top(
             &crate::parsing::ast::types::FormatOptions {
                 tab_size: params.options.tab_size as usize,
                 insert_final_newline: params.options.insert_final_newline.unwrap_or(false),

rust/kcl-lib/src/parsing/ast/types/mod.rs

@@ -988,7 +988,13 @@ pub enum Expr {
 
 impl Expr {
     pub fn get_lsp_folding_range(&self) -> Option<FoldingRange> {
-        let recasted = self.recast(&FormatOptions::default(), 0, crate::unparser::ExprContext::Other);
+        let mut recasted = String::new();
+        self.recast(
+            &mut recasted,
+            &FormatOptions::default(),
+            0,
+            crate::unparser::ExprContext::Other,
+        );
         // If the code only has one line then we don't need to fold it.
         if recasted.lines().count() <= 1 {
             return None;
@@ -2039,7 +2045,8 @@ impl From<&VariableDeclaration> for Vec<CompletionItem> {
 
 impl Node<VariableDeclaration> {
     pub fn get_lsp_folding_range(&self) -> Option<FoldingRange> {
-        let recasted = self.recast(&FormatOptions::default(), 0);
+        let mut recasted = String::new();
+        self.recast(&mut recasted, &FormatOptions::default(), 0);
         // If the recasted value only has one line, don't fold it.
         if recasted.lines().count() <= 1 {
             return None;
@@ -3493,13 +3500,13 @@ impl FunctionExpression {
             signature.push_str("()");
         } else if self.params.len() == 1 {
             signature.push('(');
-            signature.push_str(&self.params[0].recast(&FormatOptions::default(), 0));
+            self.params[0].recast(&mut signature, &FormatOptions::default(), 0);
             signature.push(')');
         } else {
             signature.push('(');
             for a in &self.params {
                 signature.push_str("\n  ");
-                signature.push_str(&a.recast(&FormatOptions::default(), 0));
+                a.recast(&mut signature, &FormatOptions::default(), 0);
                 signature.push(',');
             }
             signature.push('\n');
@@ -3581,6 +3588,15 @@ impl FormatOptions {
         }
     }
 
+    /// Get the indentation string for the given level.
+    pub fn write_indentation(&self, buf: &mut String, times: usize) {
+        let ind = if self.use_tabs { '\t' } else { ' ' };
+        let n = if self.use_tabs { 1 } else { self.tab_size };
+        for _ in 0..(times * n) {
+            buf.push(ind);
+        }
+    }
+
     /// Get the indentation string for the given level.
     /// But offset the pipe operator (and a space) by one level.
     pub fn get_indentation_offset_pipe(&self, level: usize) -> String {
@@ -4223,7 +4239,7 @@ startSketchOn(XY)"#;
 
         assert_eq!(meta_settings.default_length_units, crate::execution::types::UnitLen::Mm);
 
-        let formatted = new_program.recast(&Default::default(), 0);
+        let formatted = new_program.recast_top(&Default::default(), 0);
 
         assert_eq!(
             formatted,
@@ -4252,7 +4268,7 @@ startSketchOn(XY)
 
         assert_eq!(meta_settings.default_length_units, crate::execution::types::UnitLen::Mm);
 
-        let formatted = new_program.recast(&Default::default(), 0);
+        let formatted = new_program.recast_top(&Default::default(), 0);
 
         assert_eq!(
             formatted,
@@ -4287,7 +4303,7 @@ startSketchOn(XY)
 
         assert_eq!(meta_settings.default_length_units, crate::execution::types::UnitLen::Cm);
 
-        let formatted = new_program.recast(&Default::default(), 0);
+        let formatted = new_program.recast_top(&Default::default(), 0);
 
         assert_eq!(
             formatted,
@@ -4341,7 +4357,7 @@ angle = atan(rise / run)"#;
         program.rename_symbol("yoyo", var_decl.as_source_range().start() + 1);
 
         // Recast the program to a string.
-        let formatted = program.recast(&Default::default(), 0);
+        let formatted = program.recast_top(&Default::default(), 0);
 
         assert_eq!(
             formatted,

rust/kcl-lib/src/simulation_tests.rs

@@ -183,7 +183,7 @@ async fn unparse_test(test: &Test) {
     let ast = crate::parsing::parse_tokens(tokens).unwrap();
 
     // Check recasting.
-    let actual = ast.recast(&Default::default(), 0);
+    let actual = ast.recast_top(&Default::default(), 0);
     let input_result = catch_unwind(AssertUnwindSafe(|| {
         assert_snapshot(test, "Result of unparsing", || {
             insta::assert_snapshot!("unparsed", actual);