Fix: Prevent line breaks inside generic type annotations

Fix #283

Author: NathanLovato

CHANGELOG.md

@@ -7,6 +7,7 @@ This file documents the changes made to the formatter with each release.
 ### Fixed
 
 - Make sure to keep tool at the top of the script, above class_name and extends (#285)
+- Fixed generic type parameters breaking across lines (#283)
 
 ## Release 0.22.0
 

src/formatter.rs

@@ -258,8 +258,46 @@ fn process_node(
         | GDScriptNodeKind::Dictionary
         | GDScriptNodeKind::EnumeratorList
         | GDScriptNodeKind::Parameters
-        | GDScriptNodeKind::Arguments
-        | GDScriptNodeKind::SubscriptArguments => process_container(input, node, render_elements),
+        | GDScriptNodeKind::Arguments => process_container(input, node, render_elements),
+        GDScriptNodeKind::SubscriptArguments => {
+            // Anything like a[b] is parsed as a `subscript` node, but this may
+            // be a dictionary access which can wrap across lines or a type hint
+            // like `Dictionary[String, String]` which must stay on one line;
+            // Official GDScript parser cannot parse line returns in there. So
+            // we walk up the AST to check if we are inside a `type` node.
+            // The type hint `Dictionary[String, String]` is parsed like this:
+            //
+            // ```text
+            // (type
+            // (subscript
+            //   (identifier)              ; Dictionary
+            //   arguments: (subscript_arguments
+            //     (identifier)            ; String
+            //     (identifier)))          ; String
+            // ```
+            //
+            // Which is why we walk up the AST to check if we are inside a `type` node.
+            let mut is_type_with_subscript = false;
+            let mut ancestor = node.parent();
+            while let Some(current) = ancestor {
+                let current_kind = GDScriptNodeKind::get_kind_from_ast_node(current);
+                if current_kind == GDScriptNodeKind::Type {
+                    is_type_with_subscript = true;
+                    break;
+                }
+                if current_kind != GDScriptNodeKind::Subscript
+                    && current_kind != GDScriptNodeKind::Other
+                {
+                    break;
+                }
+                ancestor = current.parent();
+            }
+            if is_type_with_subscript {
+                process_children_with_spacing(input, node, render_elements);
+            } else {
+                process_container(input, node, render_elements);
+            }
+        }
         GDScriptNodeKind::Body | GDScriptNodeKind::ClassBody | GDScriptNodeKind::MatchBody => {
             process_body(input, node, render_elements)
         }

src/node_kind.rs

@@ -109,6 +109,8 @@ pub enum GDScriptNodeKind {
     KeywordStatic,
 
     // Type annotations
+    Type,
+    Subscript,
     InferredType,
 
     // Meta
@@ -237,6 +239,8 @@ const MAP_TREE_SITTER_TO_GDSCRIPT_NODE_KIND: &[(&str, GDScriptNodeKind)] = &[
     ("parameters", GDScriptNodeKind::Parameters),
     ("arguments", GDScriptNodeKind::Arguments),
     ("subscript_arguments", GDScriptNodeKind::SubscriptArguments),
+    ("subscript", GDScriptNodeKind::Subscript),
+    ("type", GDScriptNodeKind::Type),
     ("condition", GDScriptNodeKind::Condition),
     ("conditional_expression", GDScriptNodeKind::Condition),
     ("lambda", GDScriptNodeKind::Lambda),

tests/expected/generic_type_parameters.gd

@@ -0,0 +1,14 @@
+# Generic type parameters must never break across lines, even when they would go
+# past max line length. Breaking brackets like Dictionary[ String, String] would
+# produce invalid GDScript.
+func return_nested_generic() -> Dictionary[String, Array[int]]:
+	return { "a": [1, 2, 3], "b": [4, 5, 6] }
+
+
+func typed_variable() -> void:
+	var d: Dictionary[String, int] = { }
+	print(d)
+
+
+func parameterized() -> void:
+	pass

tests/input/generic_type_parameters.gd

@@ -0,0 +1,14 @@
+# Generic type parameters must never break across lines, even when they would go
+# past max line length. Breaking brackets like Dictionary[ String, String] would
+# produce invalid GDScript.
+func return_nested_generic() -> Dictionary[String, Array[int]]:
+	return { "a": [1, 2, 3], "b": [4, 5, 6] }
+
+
+func typed_variable() -> void:
+	var d: Dictionary[String, int] = {}
+	print(d)
+
+
+func parameterized() -> void:
+	pass

tests/integration_tests.rs

@@ -3,7 +3,9 @@
 /// matches the expected output file. See files in the ./input and ./expected
 /// folders.
 use gdscript_formatter::linter::{GDScriptLinter, LinterConfig};
-use gdscript_formatter::{FormatterConfiguration, QuoteStyle, format_gdscript};
+use gdscript_formatter::{
+    FormatterConfiguration, PrinterConfiguration, QuoteStyle, format_gdscript,
+};
 use similar::{ChangeTag, TextDiff};
 use std::fs;
 use std::path::Path;
@@ -192,6 +194,30 @@ lines"""
     assert_eq!(format_gdscript(input, &config).unwrap(), expected);
 }
 
+#[test]
+fn generic_type_parameters_never_break() {
+    // Type-level generic parameters like Dictionary[String, String] must
+    // stay on one line even when max_line_length would otherwise force a
+    // break. Splitting the brackets produces invalid GDScript.
+    let input = "func test() -> Dictionary[String, String]:\n    return {}\n";
+    let config = FormatterConfiguration {
+        printer: PrinterConfiguration {
+            max_line_length: 10,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let output = format_gdscript(input, &config).unwrap();
+    // The generic type must remain on a single line.
+    let expected_line_0 = "func test() -> Dictionary[String, String]:";
+    assert!(
+        output.lines().next() == Some(expected_line_0),
+        "Expected first line to be '{}' but got '{}'",
+        expected_line_0,
+        output.lines().next().unwrap_or("")
+    );
+}
+
 #[test]
 fn editorconfig_applies_quote_style() {
     let mut config = FormatterConfiguration::default();