Fix line length calculation for complex expressions

Close #342

Author: NathanLovato

CHANGELOG.md

@@ -8,6 +8,7 @@ This file documents the changes made to the formatter with each release.
 
 - Fixed format and reorder commands having a different result with blank lines around regions containing functions (#337). The formatter will now apply blank line rules across region markers.
 - Fix long parenthesized expression chained with a method call in an assignment, not wrapping past the max line length (#338).
+- Fixed line length calculation for long expression chains with subscript accesses and other cases like attribute access with parenthesized expressions (#342)
 
 ## Release 0.25.0 (2026-09-06)
 

src/formatter.rs

@@ -350,12 +350,19 @@ fn process_node(
             finish_group(render_elements, group_index);
         }
         GDScriptNodeKind::SetGet => process_setget(input, node, render_elements),
-        GDScriptNodeKind::ParenthesizedExpression => {
-            process_parenthesized_expression(input, node, render_elements)
+        GDScriptNodeKind::ParenthesizedExpression
+        | GDScriptNodeKind::Attribute
+        | GDScriptNodeKind::Subscript
+        | GDScriptNodeKind::Call => {
+            // Wrapping the entire expression in a group helps with calculating
+            // the length of code segments and knowing where to break lines for
+            // vertical spacing in the renderer.
+            let group_index = begin_group(render_elements);
+            process_expression_content(input, node, render_elements);
+            finish_group(render_elements, group_index);
         }
         GDScriptNodeKind::BinaryOperator => process_binary_operator(input, node, render_elements),
         GDScriptNodeKind::Condition => process_conditional_expression(input, node, render_elements),
-        GDScriptNodeKind::Attribute => process_attribute(input, node, render_elements),
         _ => process_children_with_spacing(input, node, render_elements),
     }
 }
@@ -1890,16 +1897,37 @@ fn process_container(
     }
 }
 
-/// Formats ParenthesizedExpression nodes with a Group. The group lets a long
-/// expression use its parentheses as a safe break boundary instead of breaking
-/// an enclosing line at an operator inside the expression. Inner constructs
-/// that already handle their own indentation (lambdas, arrays, dicts) keep
-/// their specialized formatting.
-fn process_parenthesized_expression(
+/// Processes part of an expression and appends render elements, without
+/// creating a new group. This recursively processes child nodes as an
+/// expression can contain sub-expressions, operators, lambda functions, etc.
+///
+/// The IR for everything visited is added to `render_elements`.
+fn process_expression_content(
     input: &ParseInput,
     node: tree_sitter::Node,
     render_elements: &mut Vec<RenderElement>,
 ) {
+    match GDScriptNodeKind::get_kind_from_ast_node(node) {
+        GDScriptNodeKind::Attribute => {
+            process_attribute(input, node, render_elements);
+            return;
+        }
+        GDScriptNodeKind::Subscript | GDScriptNodeKind::Call => {
+            process_children_with_spacing(input, node, render_elements);
+            return;
+        }
+        GDScriptNodeKind::ParenthesizedExpression => {}
+        // As we dive down the AST, we can stumble upon anything. For example,
+        // an attribute call can be a method call that within the arguments has
+        // a lambda function wrapped in parentheses or anything else. When we
+        // stumble upon something like that, we need to process those nodes
+        // recursively.
+        _ => {
+            process_node(input, node, render_elements);
+            return;
+        }
+    }
+
     let child_count = node.child_count();
     if child_count < 3 {
         process_children_with_spacing(input, node, render_elements);
@@ -1944,8 +1972,6 @@ fn process_parenthesized_expression(
         return;
     }
 
-    let group_index = begin_group(render_elements);
-
     if let Some(open) = node.child(0) {
         process_node(input, open, render_elements);
     }
@@ -1979,8 +2005,6 @@ fn process_parenthesized_expression(
     if let Some(close) = node.child((child_count - 1) as u32) {
         process_node(input, close, render_elements);
     }
-
-    finish_group(render_elements, group_index);
 }
 
 /// Finds and returns the unnamed operator token between a binary expression's
@@ -2459,14 +2483,24 @@ fn process_attribute(
     render_elements: &mut Vec<RenderElement>,
 ) {
     let child_count = node.child_count();
-    // Only handle dot-access chains (child_count >= 5: at least 2 method calls).
-    // Single method calls like a.foo() go through process_children_with_spacing.
-    let is_dot_chain = if let Some(c) = node.child(1) {
-        GDScriptNodeKind::get_kind_from_ast_node(c) == GDScriptNodeKind::TokenDot
-    } else {
-        false
-    };
-    if child_count < 5 || !is_dot_chain {
+    // An attribute node is an expression followed by dots using the dot
+    // accessor and accessing members or calling methods.
+    //
+    // If the chain has multiple dots, we need to specifically handle
+    // continuation lines. So we count the dots in the attribute chain and
+    // format accordingly.
+    let mut dot_count = 0;
+    let mut child_index = 0;
+    while child_index < child_count {
+        if let Some(child) = node.child(child_index as u32)
+            && GDScriptNodeKind::get_kind_from_ast_node(child) == GDScriptNodeKind::TokenDot
+        {
+            dot_count += 1;
+        }
+        child_index += 1;
+    }
+    let has_multiple_dot_accesses = dot_count >= 2;
+    if !has_multiple_dot_accesses {
         process_children_with_spacing(input, node, render_elements);
         return;
     }
@@ -2530,8 +2564,6 @@ fn process_attribute(
         child_index += 1;
     }
 
-    let group_index = begin_group(render_elements);
-
     if let Some(expr) = node.child(0) {
         process_node(input, expr, render_elements);
     }
@@ -2652,7 +2684,6 @@ fn process_attribute(
 
         attribute_index += 2;
     }
-    finish_group(render_elements, group_index);
 }
 
 /// Builds a method call inside a dot-access chain. Its argument container is
@@ -3046,7 +3077,18 @@ fn process_children_with_spacing(
                 index += 1;
                 continue;
             }
-            process_node(input, child, render_elements);
+            if index == 0
+                && matches!(
+                    parent_kind,
+                    GDScriptNodeKind::Attribute
+                        | GDScriptNodeKind::Subscript
+                        | GDScriptNodeKind::Call
+                )
+            {
+                process_expression_content(input, child, render_elements);
+            } else {
+                process_node(input, child, render_elements);
+            }
             previous = Some(child);
         }
         index += 1;

tests/expected/expression_chains.gd

@@ -0,0 +1,83 @@
+# This file tests long and complex expressions, especially parenthesized
+# expressions, subscripts, and nested expressions. This directly tests a line
+# length calculation for these expressions as there are just over 100 characters
+# (counting tab indents as = 4 spaces)
+func test_expressions():
+	stored_direction_with_a_long_name = (
+		transform.basis * Vector3(input_dir.x, 0, input_dir.y)
+	).normalized()
+	stored_direction_with_a_long_name += (
+		transform.basis * Vector3(input_dir.x, 0, input_dir.y)
+	)[index]
+	return (
+		first_direction_with_a_long_name + second_direction_with_a_long_name
+	)[index].normalized()
+
+	consume(
+		(first_direction_with_a_long_name + second_direction_with_a_long_name)[index].normalized(),
+		other_value,
+	)
+	var directions = [
+		(first_direction_with_a_long_name + second_direction_with_a_long_name)[index].normalized(),
+		other_value,
+	]
+	var direction_by_name = {
+		"forward": (
+			first_direction_with_a_long_name + second_direction_with_a_long_name
+		)[index].normalized()
+	}
+	if (
+		first_direction_with_a_long_name + second_direction_with_a_long_name
+	)[selected_index].is_normalized():
+		pass
+
+	var result = (
+		value
+	).transform(
+		first_argument_with_a_long_name,
+		second_argument_with_a_long_name,
+		third_argument_with_a_long_name,
+	)
+	var indexed = (
+		value
+	)[
+		first_index_with_a_long_name + second_index_with_a_long_name
+		+ third_index_with_an_extremely_long_name
+	]
+	var values = ([
+		first_element_with_a_long_name,
+		second_element_with_a_long_name,
+		third_element_with_a_long_name,
+	]).duplicate()
+	var properties = ({
+		"first": first_value_with_a_long_name,
+		"second": second_value_with_a_long_name,
+	}).duplicate()
+	var doubled = (
+		(first_direction_with_a_long_name + second_direction_with_a_long_name)
+	)[index].normalized()
+	var repeated_index = (
+		first_direction_with_a_long_name + second_direction_with_a_long_name
+	)[first_index][second_index]
+	var selected = values[
+		(
+			first_index_with_a_long_name + second_index_with_a_long_name
+			+ third_index_with_a_long_name
+		)
+	]
+	var size = create_values(first_argument_with_a_long_name, second_argument_with_a_long_name)[
+		index
+	].size()
+	var mapped = (values).map(
+		func(value):
+			return value * 2,
+	)
+
+	var transformed = (first_direction + second_direction) \
+			.first_transformation() \
+			.second_transformation() \
+			.third_transformation()
+	var explicit = (first_direction + second_direction) \
+			.first_transformation() \
+			.second_transformation() \
+			.third_transformation()

tests/expected/issue_338_parenthesized_expression.gd

@@ -3,3 +3,12 @@ func _physics_process(delta: float) -> void:
 	var direction_with_a_long_name: Vector3 = (
 		transform.basis * Vector3(input_dir.x, 0, input_dir.y)
 	).normalized()
+	var basis_property_with_an_even_longer_name = (
+		transform.basis * Vector3(input_dir.x, 0, input_dir.y)
+	).x
+	var indexed_value_with_a_long_name = (
+		transform.basis * Vector3(input_dir.x, 0, input_dir.y)
+	)[index]
+	var indexed_direction_with_a_long_name = (
+		transform.basis * Vector3(input_dir.x, 0, input_dir.y)
+	)[index].normalized()

tests/input/expression_chains.gd

@@ -0,0 +1,30 @@
+# This file tests long and complex expressions, especially parenthesized
+# expressions, subscripts, and nested expressions. This directly tests a line
+# length calculation for these expressions as there are just over 100 characters
+# (counting tab indents as = 4 spaces)
+func test_expressions():
+	stored_direction_with_a_long_name = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
+	stored_direction_with_a_long_name += (transform.basis * Vector3(input_dir.x, 0, input_dir.y))[index]
+	return (first_direction_with_a_long_name + second_direction_with_a_long_name)[index].normalized()
+
+	consume((first_direction_with_a_long_name + second_direction_with_a_long_name)[index].normalized(), other_value)
+	var directions = [(first_direction_with_a_long_name + second_direction_with_a_long_name)[index].normalized(), other_value]
+	var direction_by_name = {"forward": (first_direction_with_a_long_name + second_direction_with_a_long_name)[index].normalized()}
+	if (first_direction_with_a_long_name + second_direction_with_a_long_name)[selected_index].is_normalized():
+		pass
+
+	var result = (value).transform(first_argument_with_a_long_name, second_argument_with_a_long_name, third_argument_with_a_long_name)
+	var indexed = (value)[first_index_with_a_long_name + second_index_with_a_long_name + third_index_with_an_extremely_long_name]
+	var values = ([first_element_with_a_long_name, second_element_with_a_long_name, third_element_with_a_long_name]).duplicate()
+	var properties = ({"first": first_value_with_a_long_name, "second": second_value_with_a_long_name}).duplicate()
+	var doubled = ((first_direction_with_a_long_name + second_direction_with_a_long_name))[index].normalized()
+	var repeated_index = (first_direction_with_a_long_name + second_direction_with_a_long_name)[first_index][second_index]
+	var selected = values[(first_index_with_a_long_name + second_index_with_a_long_name + third_index_with_a_long_name)]
+	var size = create_values(first_argument_with_a_long_name, second_argument_with_a_long_name)[index].size()
+	var mapped = (values).map(func(value): return value * 2)
+
+	var transformed = (first_direction + second_direction).first_transformation().second_transformation().third_transformation()
+	var explicit = (first_direction + second_direction) \
+		.first_transformation() \
+		.second_transformation() \
+		.third_transformation()

tests/input/issue_338_parenthesized_expression.gd

@@ -1,3 +1,6 @@
 # A long parenthesized expression with a method call would not wrap as expected.
 func _physics_process(delta: float) -> void:
 	var direction_with_a_long_name: Vector3 = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
+	var basis_property_with_an_even_longer_name = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).x
+	var indexed_value_with_a_long_name = (transform.basis * Vector3(input_dir.x, 0, input_dir.y))[index]
+	var indexed_direction_with_a_long_name = (transform.basis * Vector3(input_dir.x, 0, input_dir.y))[index].normalized()

tests/renderer_tests.rs

@@ -109,6 +109,35 @@ fn break_group_when_too_long() {
     assert_eq!(out, "aaaa\nbbbb\ncccc\ndddd\n");
 }
 
+#[test]
+fn complete_line_width_includes_prefix_and_suffix() {
+    let render_elements = vec![
+        RenderElement::TextStatic("prefix = "),
+        group(2, 9),
+        RenderElement::TextStatic("("),
+        RenderElement::SoftLine,
+        indent(1, 5, 6),
+        RenderElement::TextStatic("expression"),
+        RenderElement::SoftLine,
+        RenderElement::TextStatic(")"),
+        RenderElement::TextStatic(".suffix()"),
+    ];
+    let fits_config = PrinterConfiguration {
+        max_line_length: 30,
+        ..get_default_printer_configuration()
+    };
+    let mut out = String::new();
+    render(&render_elements, "", &fits_config, &mut out);
+    assert_eq!(out, "prefix = (expression).suffix()\n");
+
+    let wraps_config = PrinterConfiguration {
+        max_line_length: 29,
+        ..get_default_printer_configuration()
+    };
+    render(&render_elements, "", &wraps_config, &mut out);
+    assert_eq!(out, "prefix = (\n    expression\n).suffix()\n");
+}
+
 #[test]
 fn balanced_group_distributes_segments_evenly() {
     let render_elements = vec![