Use simple heuristics to reduce expontential blowup

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [**Luau**] Increased the shape size of the expression in a type assertion so that it will correctly hang if over width ([#466](https://github.com/JohnnyMorganz/StyLua/issues/466))
 - Fixed binary expression in a table field containing a comment being collapsed leading to malformed formatted ([#471](https://github.com/JohnnyMorganz/StyLua/issues/471))
 - Fixed end parentheses of a function call with a multiline comment internally being expanded onto a new line unnecessarily ([#473](https://github.com/JohnnyMorganz/StyLua/issues/473))
+- Fixed severe performance regression with complex nested function calls ([#477](https://github.com/JohnnyMorganz/StyLua/issues/477))
 
 ## [0.13.1] - 2022-04-11
 ### Fixed

src/formatters/functions.rs

@@ -184,9 +184,17 @@ fn function_args_multiline_heuristic(
 
     // Format all the arguments on an infinite width, so that we can prepare them and check to see whether they
     // need expanding. We will ignore punctuation for now
-    let first_iter_formatted_arguments = arguments
-        .iter()
-        .map(|argument| format_expression(ctx, argument, shape.with_infinite_width()));
+    let first_iter_formatted_arguments = arguments.iter().map(|argument| {
+        if shape.using_simple_heuristics() {
+            argument.to_owned()
+        } else {
+            format_expression(
+                ctx,
+                argument,
+                shape.with_simple_heuristics().with_infinite_width(),
+            )
+        }
+    });
 
     // Apply some heuristics to determine whether we should expand the function call
     let mut singleline_shape = shape + PAREN_LEN;

src/shape.rs

@@ -102,6 +102,9 @@ pub struct Shape {
     offset: usize,
     /// The maximum number of characters we want to fit on a line. This is inferred from the configuration
     column_width: usize,
+    /// Whether we should use simple heuristic checking.
+    /// This is enabled when we are calling within a heuristic itself, to reduce the exponential blowup
+    simple_heuristics: bool,
 }
 
 impl Shape {
@@ -111,6 +114,7 @@ impl Shape {
             indent: Indent::new(ctx),
             offset: 0,
             column_width: ctx.config().column_width,
+            simple_heuristics: false,
         }
     }
 
@@ -179,6 +183,19 @@ impl Shape {
         }
     }
 
+    /// Whether simple heuristics should be used when calculating formatting shape
+    /// This is to reduce the expontential blowup of discarded test formatting
+    pub fn using_simple_heuristics(&self) -> bool {
+        self.simple_heuristics
+    }
+
+    pub fn with_simple_heuristics(&self) -> Shape {
+        Self {
+            simple_heuristics: true,
+            ..*self
+        }
+    }
+
     /// Resets the offset for the shape
     pub fn reset(&self) -> Shape {
         Self { offset: 0, ..*self }